From 0c533071d41c806295b64869187468a9475d71b4 Mon Sep 17 00:00:00 2001 From: Akkadius Date: Sun, 7 Feb 2021 15:00:16 -0600 Subject: [PATCH] Yet more cleanup --- zone/bot_command.cpp | 2 +- zone/client.h | 12 +- zone/command.cpp | 2 +- zone/entity.cpp | 17 +- zone/entity.h | 2 +- zone/main.cpp | 31 +-- zone/questmgr.cpp | 28 +-- zone/task_client_state.cpp | 332 +++++++++++++-------------- zone/task_client_state.h | 25 ++- zone/task_manager.cpp | 450 ++++++++++++++++++------------------- zone/task_manager.h | 10 +- zone/tasks.cpp | 8 +- zone/worldserver.cpp | 16 +- zone/zone.cpp | 2 +- 14 files changed, 461 insertions(+), 476 deletions(-) diff --git a/zone/bot_command.cpp b/zone/bot_command.cpp index f7dbdd972..10b869d9c 100644 --- a/zone/bot_command.cpp +++ b/zone/bot_command.cpp @@ -76,7 +76,7 @@ extern QueryServ* QServ; extern WorldServer worldserver; -extern TaskManager *p_task_manager; +extern TaskManager *task_manager; void CatchSignal(int sig_num); diff --git a/zone/client.h b/zone/client.h index 931cb9fd4..160ea145b 100644 --- a/zone/client.h +++ b/zone/client.h @@ -88,7 +88,7 @@ namespace EQ #define XTARGET_HARDCAP 20 extern Zone* zone; -extern TaskManager *p_task_manager; +extern TaskManager *task_manager; class CLIENTPACKET { @@ -1039,7 +1039,7 @@ public: } inline bool SaveTaskState() { - return p_task_manager != nullptr && p_task_manager->SaveClientState(this, task_state); + return task_manager != nullptr && task_manager->SaveClientState(this, task_state); } inline bool IsTaskStateLoaded() { return task_state != nullptr; } inline bool IsTaskActive(int task_id) { return task_state != nullptr && task_state->IsTaskActive(task_id); } @@ -1137,8 +1137,8 @@ public: } inline void TaskSetSelector(Mob *mob, int task_set_id) { - if (p_task_manager) { - p_task_manager->TaskSetSelector( + if (task_manager) { + task_manager->TaskSetSelector( this, task_state, mob, @@ -1148,8 +1148,8 @@ public: } inline void TaskQuestSetSelector(Mob *mob, int count, int *tasks) { - if (p_task_manager) { - p_task_manager->TaskQuestSetSelector( + if (task_manager) { + task_manager->TaskQuestSetSelector( this, task_state, mob, diff --git a/zone/command.cpp b/zone/command.cpp index 14e849256..b88f1e102 100755 --- a/zone/command.cpp +++ b/zone/command.cpp @@ -77,7 +77,7 @@ extern QueryServ* QServ; extern WorldServer worldserver; -extern TaskManager *p_task_manager; +extern TaskManager *task_manager; extern FastMath g_Math; void CatchSignal(int sig_num); diff --git a/zone/entity.cpp b/zone/entity.cpp index 98c4dc2e5..dc630ceef 100644 --- a/zone/entity.cpp +++ b/zone/entity.cpp @@ -32,6 +32,7 @@ #include "../common/features.h" #include "../common/guilds.h" +#include "entity.h" #include "dynamiczone.h" #include "guild_mgr.h" #include "petitions.h" @@ -3900,22 +3901,24 @@ void EntityList::ProcessProximitySay(const char *Message, Client *c, uint8 langu void EntityList::SaveAllClientsTaskState() { - if (!p_task_manager) + if (!task_manager) { return; + } auto it = client_list.begin(); while (it != client_list.end()) { Client *client = it->second; - if (client->IsTaskStateLoaded()) + if (client->IsTaskStateLoaded()) { client->SaveTaskState(); + } ++it; } } -void EntityList::ReloadAllClientsTaskState(int TaskID) +void EntityList::ReloadAllClientsTaskState(int task_id) { - if (!p_task_manager) + if (!task_manager) return; auto it = client_list.begin(); @@ -3924,11 +3927,11 @@ void EntityList::ReloadAllClientsTaskState(int TaskID) if (client->IsTaskStateLoaded()) { // If we have been passed a TaskID, only reload the client state if they have // that Task active. - if ((!TaskID) || (TaskID && client->IsTaskActive(TaskID))) { + if ((!task_id) || (task_id && client->IsTaskActive(task_id))) { Log(Logs::General, Logs::Tasks, "[CLIENTLOAD] Reloading Task State For Client %s", client->GetName()); client->RemoveClientTaskState(); client->LoadClientTaskState(); - p_task_manager->SendActiveTasksToClient(client); + task_manager->SendActiveTasksToClient(client); } } ++it; @@ -4136,7 +4139,7 @@ void EntityList::AddTempPetsToHateList(Mob *owner, Mob* other, bool bFrenzy) if (n->GetSwarmInfo()) { if (n->GetSwarmInfo()->owner_id == owner->GetID()) { if ( - !n->GetSpecialAbility(IMMUNE_AGGRO) && + !n->GetSpecialAbility(IMMUNE_AGGRO) && !(n->GetSpecialAbility(IMMUNE_AGGRO_CLIENT) && other->IsClient()) && !(n->GetSpecialAbility(IMMUNE_AGGRO_NPC) && other->IsNPC()) ) { diff --git a/zone/entity.h b/zone/entity.h index 5bb5981fa..5a93adf9d 100644 --- a/zone/entity.h +++ b/zone/entity.h @@ -483,7 +483,7 @@ public: void SendGroupLeader(uint32 gid, const char *lname, const char *oldlname); void SaveAllClientsTaskState(); - void ReloadAllClientsTaskState(int TaskID=0); + void ReloadAllClientsTaskState(int task_id=0); uint16 CreateGroundObject(uint32 itemid, const glm::vec4& position, uint32 decay_time = 300000); uint16 CreateGroundObjectFromModel(const char *model, const glm::vec4& position, uint8 type = 0x00, uint32 decay_time = 0); uint16 CreateDoor(const char *model, const glm::vec4& position, uint8 type = 0, uint16 size = 100); diff --git a/zone/main.cpp b/zone/main.cpp index 6cdd56735..376b8a508 100644 --- a/zone/main.cpp +++ b/zone/main.cpp @@ -22,26 +22,18 @@ #define PLATFORM_ZONE 1 #include "../common/global_define.h" -#include "../common/features.h" -#include "../common/queue.h" #include "../common/timer.h" #include "../common/eq_packet_structs.h" #include "../common/mutex.h" -#include "../common/version.h" -#include "../common/packet_dump_file.h" #include "../common/opcodemgr.h" #include "../common/guilds.h" #include "../common/eq_stream_ident.h" #include "../common/patches/patches.h" #include "../common/rulesys.h" #include "../common/profanity_manager.h" -#include "../common/misc_functions.h" #include "../common/string_util.h" -#include "../common/platform.h" #include "../common/crash.h" -#include "../common/ipc_mutex.h" #include "../common/memory_mapped_file.h" -#include "../common/eqemu_exception.h" #include "../common/spdat.h" #include "../common/eqemu_logsys.h" @@ -57,32 +49,21 @@ #endif #include "zonedb.h" #include "zone_store.h" -#include "zone_config.h" #include "titles.h" #include "guild_mgr.h" -#include "tasks.h" +#include "task_manager.h" #include "quest_parser_collection.h" #include "embparser.h" #include "lua_parser.h" #include "questmgr.h" #include "npc_scale_manager.h" -#include "../common/event/event_loop.h" -#include "../common/event/timer.h" #include "../common/net/eqstream.h" -#include "../common/net/servertalk_server.h" #include "../common/content/world_content_service.h" -#include "../common/repositories/content_flags_repository.h" -#include -#include -#include #include -#include #include #include -#include -#include #include #ifdef _CRTDBG_MAP_ALLOC @@ -115,8 +96,8 @@ char errorname[32]; extern Zone* zone; npcDecayTimes_Struct npcCorpseDecayTimes[100]; TitleManager title_manager; -QueryServ *QServ = 0; -TaskManager *p_task_manager = 0; +QueryServ *QServ = 0; +TaskManager *task_manager = 0; NpcScaleManager *npc_scale_manager; QuestParserCollection *parse = 0; EQEmuLogSys LogSys; @@ -426,8 +407,8 @@ int main(int argc, char** argv) { #endif if (RuleB(TaskSystem, EnableTaskSystem)) { - p_task_manager = new TaskManager; - p_task_manager->LoadTasks(); + task_manager = new TaskManager; + task_manager->LoadTasks(); } parse = new QuestParserCollection(); @@ -606,7 +587,7 @@ int main(int argc, char** argv) { if (zone != 0) Zone::Shutdown(true); //Fix for Linux world server problem. - safe_delete(p_task_manager); + safe_delete(task_manager); command_deinit(); #ifdef BOTS bot_command_deinit(); diff --git a/zone/questmgr.cpp b/zone/questmgr.cpp index 247aa9501..a61a4e856 100644 --- a/zone/questmgr.cpp +++ b/zone/questmgr.cpp @@ -2223,27 +2223,27 @@ bool QuestManager::createBot(const char *name, const char *lastname, uint8 level void QuestManager::taskselector(int taskcount, int *tasks) { QuestManagerCurrentQuestVars(); - if(RuleB(TaskSystem, EnableTaskSystem) && initiator && owner && p_task_manager) + if(RuleB(TaskSystem, EnableTaskSystem) && initiator && owner && task_manager) initiator->TaskQuestSetSelector(owner, taskcount, tasks); } void QuestManager::enabletask(int taskcount, int *tasks) { QuestManagerCurrentQuestVars(); - if(RuleB(TaskSystem, EnableTaskSystem) && initiator && p_task_manager) + if(RuleB(TaskSystem, EnableTaskSystem) && initiator && task_manager) initiator->EnableTask(taskcount, tasks); } void QuestManager::disabletask(int taskcount, int *tasks) { QuestManagerCurrentQuestVars(); - if(RuleB(TaskSystem, EnableTaskSystem) && initiator && p_task_manager) + if(RuleB(TaskSystem, EnableTaskSystem) && initiator && task_manager) initiator->DisableTask(taskcount, tasks); } bool QuestManager::istaskenabled(int taskid) { QuestManagerCurrentQuestVars(); - if(RuleB(TaskSystem, EnableTaskSystem) && initiator && p_task_manager) + if(RuleB(TaskSystem, EnableTaskSystem) && initiator && task_manager) return initiator->IsTaskEnabled(taskid); return false; @@ -2252,7 +2252,7 @@ bool QuestManager::istaskenabled(int taskid) { void QuestManager::tasksetselector(int tasksetid) { QuestManagerCurrentQuestVars(); Log(Logs::General, Logs::Tasks, "[UPDATE] TaskSetSelector called for task set %i", tasksetid); - if(RuleB(TaskSystem, EnableTaskSystem) && initiator && owner && p_task_manager) + if(RuleB(TaskSystem, EnableTaskSystem) && initiator && owner && task_manager) initiator->TaskSetSelector(owner, tasksetid); } @@ -2341,8 +2341,8 @@ int QuestManager::enabledtaskcount(int taskset) { int QuestManager::firsttaskinset(int taskset) { QuestManagerCurrentQuestVars(); - if(RuleB(TaskSystem, EnableTaskSystem) && p_task_manager) - return p_task_manager->FirstTaskInSet(taskset); + if(RuleB(TaskSystem, EnableTaskSystem) && task_manager) + return task_manager->FirstTaskInSet(taskset); return -1; } @@ -2350,8 +2350,8 @@ int QuestManager::firsttaskinset(int taskset) { int QuestManager::lasttaskinset(int taskset) { QuestManagerCurrentQuestVars(); - if(RuleB(TaskSystem, EnableTaskSystem) && p_task_manager) - return p_task_manager->LastTaskInSet(taskset); + if(RuleB(TaskSystem, EnableTaskSystem) && task_manager) + return task_manager->LastTaskInSet(taskset); return -1; } @@ -2359,8 +2359,8 @@ int QuestManager::lasttaskinset(int taskset) { int QuestManager::nexttaskinset(int taskset, int taskid) { QuestManagerCurrentQuestVars(); - if(RuleB(TaskSystem, EnableTaskSystem) && p_task_manager) - return p_task_manager->NextTaskInSet(taskset, taskid); + if(RuleB(TaskSystem, EnableTaskSystem) && task_manager) + return task_manager->NextTaskInSet(taskset, taskid); return -1; } @@ -2412,8 +2412,8 @@ int QuestManager::completedtasksinset(int taskset) { bool QuestManager::istaskappropriate(int task) { QuestManagerCurrentQuestVars(); - if(RuleB(TaskSystem, EnableTaskSystem) && initiator && p_task_manager) - return p_task_manager->ValidateLevel(task, initiator->GetLevel()); + if(RuleB(TaskSystem, EnableTaskSystem) && initiator && task_manager) + return task_manager->ValidateLevel(task, initiator->GetLevel()); return false; } @@ -2422,7 +2422,7 @@ std::string QuestManager::gettaskname(uint32 task_id) { QuestManagerCurrentQuestVars(); if (RuleB(TaskSystem, EnableTaskSystem)) { - return p_task_manager->GetTaskName(task_id); + return task_manager->GetTaskName(task_id); } return std::string(); diff --git a/zone/task_client_state.cpp b/zone/task_client_state.cpp index b235700a1..0eaf8fc9b 100644 --- a/zone/task_client_state.cpp +++ b/zone/task_client_state.cpp @@ -14,17 +14,17 @@ extern QueryServ *QServ; ClientTaskState::ClientTaskState() { - active_task_count = 0; - last_completed_task_loaded = 0; - checked_touch_activities = false; + m_active_task_count = 0; + m_last_completed_task_loaded = 0; + m_checked_touch_activities = false; for (int i = 0; i < MAXACTIVEQUESTS; i++) { - active_quests[i].slot = i; - active_quests[i].task_id = TASKSLOTEMPTY; + m_active_quests[i].slot = i; + m_active_quests[i].task_id = TASKSLOTEMPTY; } - active_task.slot = 0; - active_task.task_id = TASKSLOTEMPTY; + m_active_task.slot = 0; + m_active_task.task_id = TASKSLOTEMPTY; // TODO: shared task } @@ -40,20 +40,20 @@ void ClientTaskState::SendTaskHistory(Client *client, int task_index) // We only sent the most recent 50 completed tasks, so we need to offset the Index the client sent to us. int adjusted_task_index = task_index; - if (completed_tasks.size() > 50) { - adjusted_task_index += (completed_tasks.size() - 50); + if (m_completed_tasks.size() > 50) { + adjusted_task_index += (m_completed_tasks.size() - 50); } - if ((adjusted_task_index < 0) || (adjusted_task_index >= (int) completed_tasks.size())) { + if ((adjusted_task_index < 0) || (adjusted_task_index >= (int) m_completed_tasks.size())) { return; } - int task_id = completed_tasks[adjusted_task_index].task_id; + int task_id = m_completed_tasks[adjusted_task_index].task_id; if ((task_id < 0) || (task_id > MAXTASKS)) { return; } - TaskInformation *p_task_data = p_task_manager->p_task_data[task_id]; + TaskInformation *p_task_data = task_manager->m_task_data[task_id]; if (p_task_data == nullptr) { return; @@ -69,7 +69,7 @@ void ClientTaskState::SendTaskHistory(Client *client, int task_index) int packet_length = sizeof(TaskHistoryReplyHeader_Struct); for (int i = 0; i < p_task_data->activity_count; i++) { - if (completed_tasks[adjusted_task_index].activity_done[i]) { + if (m_completed_tasks[adjusted_task_index].activity_done[i]) { completed_activity_count++; packet_length = packet_length + sizeof(TaskHistoryReplyData1_Struct) + p_task_data->activity_information[i].target_name.size() + 1 + @@ -90,7 +90,7 @@ void ClientTaskState::SendTaskHistory(Client *client, int task_index) reply = (char *) task_history_reply + sizeof(TaskHistoryReplyHeader_Struct); for (int i = 0; i < p_task_data->activity_count; i++) { - if (completed_tasks[adjusted_task_index].activity_done[i]) { + if (m_completed_tasks[adjusted_task_index].activity_done[i]) { task_history_reply_data_1 = (TaskHistoryReplyData1_Struct *) reply; task_history_reply_data_1->ActivityType = p_task_data->activity_information[i].activity_type; reply = (char *) task_history_reply_data_1 + sizeof(TaskHistoryReplyData1_Struct); @@ -118,10 +118,10 @@ void ClientTaskState::EnableTask(int character_id, int task_count, int *task_lis std::vector tasks_enabled; for (int i = 0; i < task_count; i++) { - auto iterator = enabled_tasks.begin(); + auto iterator = m_enabled_tasks.begin(); bool add_task = true; - while (iterator != enabled_tasks.end()) { + while (iterator != m_enabled_tasks.end()) { // If this task is already enabled, stop looking if ((*iterator) == task_list[i]) { add_task = false; @@ -136,14 +136,14 @@ void ClientTaskState::EnableTask(int character_id, int task_count, int *task_lis } if (add_task) { - enabled_tasks.insert(iterator, task_list[i]); + m_enabled_tasks.insert(iterator, task_list[i]); // Make a note of the task we enabled, for later SQL generation tasks_enabled.push_back(task_list[i]); } } LogTasksDetail("[EnableTask] New enabled task list"); - for (int enabled_task : enabled_tasks) { + for (int enabled_task : m_enabled_tasks) { LogTasksDetail("[EnableTask] enabled [{}] character_id [{}]", enabled_task, character_id); } @@ -173,10 +173,10 @@ void ClientTaskState::DisableTask(int character_id, int task_count, int *task_li std::vector tasks_disabled; for (int task_id = 0; task_id < task_count; task_id++) { - auto iterator = enabled_tasks.begin(); + auto iterator = m_enabled_tasks.begin(); bool removeTask = false; - while (iterator != enabled_tasks.end()) { + while (iterator != m_enabled_tasks.end()) { if ((*iterator) == task_list[task_id]) { removeTask = true; break; @@ -190,13 +190,13 @@ void ClientTaskState::DisableTask(int character_id, int task_count, int *task_li } if (removeTask) { - enabled_tasks.erase(iterator); + m_enabled_tasks.erase(iterator); tasks_disabled.push_back(task_list[task_id]); } } LogTasks("[DisableTask] New enabled task list "); - for (int enabled_task : enabled_tasks) { + for (int enabled_task : m_enabled_tasks) { LogTasks("[DisableTask] enabled_tasks [{}]", enabled_task); } @@ -233,9 +233,9 @@ bool ClientTaskState::IsTaskEnabled(int task_id) { std::vector::iterator iterator; - iterator = enabled_tasks.begin(); + iterator = m_enabled_tasks.begin(); - while (iterator != enabled_tasks.end()) { + while (iterator != m_enabled_tasks.end()) { if ((*iterator) == task_id) { return true; } if ((*iterator) > task_id) { break; } ++iterator; @@ -255,17 +255,17 @@ int ClientTaskState::EnabledTaskCount(int task_set_id) if ((task_set_id <= 0) || (task_set_id >= MAXTASKSETS)) { return -1; } - while ((enabled_task_index < enabled_tasks.size()) && - (task_set_index < p_task_manager->task_sets[task_set_id].size())) { + while ((enabled_task_index < m_enabled_tasks.size()) && + (task_set_index < task_manager->m_task_sets[task_set_id].size())) { - if (enabled_tasks[enabled_task_index] == p_task_manager->task_sets[task_set_id][task_set_index]) { + if (m_enabled_tasks[enabled_task_index] == task_manager->m_task_sets[task_set_id][task_set_index]) { enabled_task_count++; enabled_task_index++; task_set_index++; continue; } - if (enabled_tasks[enabled_task_index] < p_task_manager->task_sets[task_set_id][task_set_index]) { + if (m_enabled_tasks[enabled_task_index] < task_manager->m_task_sets[task_set_id][task_set_index]) { enabled_task_index++; } else { @@ -285,7 +285,7 @@ int ClientTaskState::ActiveTasksInSet(int task_set_id) int active_task_in_set_count = 0; - for (int task_id : p_task_manager->task_sets[task_set_id]) { + for (int task_id : task_manager->m_task_sets[task_set_id]) { if (IsTaskActive(task_id)) { active_task_in_set_count++; } @@ -302,7 +302,7 @@ int ClientTaskState::CompletedTasksInSet(int task_set_id) int completed_tasks_count = 0; - for (int i : p_task_manager->task_sets[task_set_id]) { + for (int i : task_manager->m_task_sets[task_set_id]) { if (IsTaskCompleted(i)) { completed_tasks_count++; } @@ -319,11 +319,11 @@ bool ClientTaskState::HasSlotForTask(TaskInformation *task) switch (task->type) { case TaskType::Task: - return active_task.task_id == TASKSLOTEMPTY; + return m_active_task.task_id == TASKSLOTEMPTY; case TaskType::Shared: return false; // todo case TaskType::Quest: - for (auto &active_quest : active_quests) { + for (auto &active_quest : m_active_quests) { if (active_quest.task_id == TASKSLOTEMPTY) { return true; } @@ -342,7 +342,7 @@ int ClientTaskState::GetActiveTaskID(int index) return 0; } - return active_quests[index].task_id; + return m_active_quests[index].task_id; } static void DeleteCompletedTaskFromDatabase(int character_id, int task_id) @@ -359,7 +359,7 @@ bool ClientTaskState::UnlockActivities(int character_id, ClientTaskInformation & { bool all_activities_complete = true; - TaskInformation *p_task_information = p_task_manager->p_task_data[task_info.task_id]; + TaskInformation *p_task_information = task_manager->m_task_data[task_info.task_id]; if (p_task_information == nullptr) { return true; } @@ -397,12 +397,12 @@ bool ClientTaskState::UnlockActivities(int character_id, ClientTaskInformation & if (all_activities_complete && RuleB(TaskSystem, RecordCompletedTasks)) { if (RuleB(TasksSystem, KeepOneRecordPerCompletedTask)) { LogTasks("KeepOneRecord enabled"); - auto iterator = completed_tasks.begin(); + auto iterator = m_completed_tasks.begin(); int erased_elements = 0; - while (iterator != completed_tasks.end()) { + while (iterator != m_completed_tasks.end()) { int task_id = (*iterator).task_id; if (task_id == task_info.task_id) { - iterator = completed_tasks.erase(iterator); + iterator = m_completed_tasks.erase(iterator); erased_elements++; } else { @@ -413,7 +413,7 @@ bool ClientTaskState::UnlockActivities(int character_id, ClientTaskInformation & LogTasks("Erased Element count is [{}]", erased_elements); if (erased_elements) { - last_completed_task_loaded -= erased_elements; + m_last_completed_task_loaded -= erased_elements; DeleteCompletedTaskFromDatabase(character_id, task_info.task_id); } } @@ -427,7 +427,7 @@ bool ClientTaskState::UnlockActivities(int character_id, ClientTaskInformation & ActivityCompleted); } - completed_tasks.push_back(completed_task_information); + m_completed_tasks.push_back(completed_task_information); } LogTasks("Returning sequential task, AllActivitiesComplete is [{}]", all_activities_complete); @@ -484,13 +484,13 @@ bool ClientTaskState::UnlockActivities(int character_id, ClientTaskInformation & // the same task again, erase the previous completed entry for this task. if (RuleB(TasksSystem, KeepOneRecordPerCompletedTask)) { LogTasksDetail("[UnlockActivities] KeepOneRecord enabled"); - auto iterator = completed_tasks.begin(); + auto iterator = m_completed_tasks.begin(); int erased_elements = 0; - while (iterator != completed_tasks.end()) { + while (iterator != m_completed_tasks.end()) { int task_id = (*iterator).task_id; if (task_id == task_info.task_id) { - iterator = completed_tasks.erase(iterator); + iterator = m_completed_tasks.erase(iterator); erased_elements++; } else { @@ -501,7 +501,7 @@ bool ClientTaskState::UnlockActivities(int character_id, ClientTaskInformation & LogTasksDetail("[UnlockActivities] Erased Element count is [{}]", erased_elements); if (erased_elements) { - last_completed_task_loaded -= erased_elements; + m_last_completed_task_loaded -= erased_elements; DeleteCompletedTaskFromDatabase(character_id, task_info.task_id); } } @@ -515,7 +515,7 @@ bool ClientTaskState::UnlockActivities(int character_id, ClientTaskInformation & (task_info.activity[activity_id].activity_state == ActivityCompleted); } - completed_tasks.push_back(completed_task_information); + m_completed_tasks.push_back(completed_task_information); } return true; } @@ -548,19 +548,19 @@ bool ClientTaskState::UpdateTasksByNPC(Client *client, int activity_type, int np int is_updating = false; // If the client has no tasks, there is nothing further to check. - if (!p_task_manager || (active_task_count == 0 && active_task.task_id == TASKSLOTEMPTY)) { // could be better ... + if (!task_manager || (m_active_task_count == 0 && m_active_task.task_id == TASKSLOTEMPTY)) { // could be better ... return false; } // loop over the union of tasks and quests - for (auto &active_task : active_tasks) { + for (auto &active_task : m_active_tasks) { auto current_task = &active_task; if (current_task->task_id == TASKSLOTEMPTY) { continue; } // Check if there are any active kill activities for this p_task_information - auto p_task_data = p_task_manager->p_task_data[current_task->task_id]; + auto p_task_data = task_manager->m_task_data[current_task->task_id]; if (p_task_data == nullptr) { return false; } @@ -598,7 +598,7 @@ bool ClientTaskState::UpdateTasksByNPC(Client *client, int activity_type, int np break; case METHODLIST: - if (!p_task_manager->goal_list_manager.IsInList( + if (!task_manager->m_goal_list_manager.IsInList( activity_info->goal_id, npc_type_id )) { @@ -625,18 +625,18 @@ int ClientTaskState::ActiveSpeakTask(int npc_type_id) // This method is to be used from Perl quests only and returns the task_id of the first // active task found which has an active SpeakWith activity_information for this NPC. - if (!p_task_manager || (active_task_count == 0 && active_task.task_id == TASKSLOTEMPTY)) { // could be better ... + if (!task_manager || (m_active_task_count == 0 && m_active_task.task_id == TASKSLOTEMPTY)) { // could be better ... return 0; } // loop over the union of tasks and quests - for (auto &active_task : active_tasks) { + for (auto &active_task : m_active_tasks) { auto current_task = &active_task; if (current_task->task_id == TASKSLOTEMPTY) { continue; } - TaskInformation *p_task_data = p_task_manager->p_task_data[current_task->task_id]; + TaskInformation *p_task_data = task_manager->m_task_data[current_task->task_id]; if (p_task_data == nullptr) { continue; } @@ -671,7 +671,7 @@ int ClientTaskState::ActiveSpeakActivity(int npc_type_id, int task_id) // This method is to be used from Perl quests only and returns the activity_id of the first // active activity_information found in the specified task which is to SpeakWith this NPC. - if (!p_task_manager || (active_task_count == 0 && active_task.task_id == TASKSLOTEMPTY)) { // could be better ... + if (!task_manager || (m_active_task_count == 0 && m_active_task.task_id == TASKSLOTEMPTY)) { // could be better ... return -1; } if (task_id <= 0 || task_id >= MAXTASKS) { @@ -679,13 +679,13 @@ int ClientTaskState::ActiveSpeakActivity(int npc_type_id, int task_id) } // loop over the union of tasks and quests - for (auto &active_task : active_tasks) { + for (auto &active_task : m_active_tasks) { auto current_task = &active_task; if (current_task->task_id != task_id) { continue; } - TaskInformation *p_task_data = p_task_manager->p_task_data[current_task->task_id]; + TaskInformation *p_task_data = task_manager->m_task_data[current_task->task_id]; if (p_task_data == nullptr) { continue; } @@ -732,12 +732,12 @@ void ClientTaskState::UpdateTasksForItem(Client *client, ActivityType activity_t item_id ); - if (!p_task_manager || (active_task_count == 0 && active_task.task_id == TASKSLOTEMPTY)) { // could be better ... + if (!task_manager || (m_active_task_count == 0 && m_active_task.task_id == TASKSLOTEMPTY)) { // could be better ... return; } // loop over the union of tasks and quests - for (auto &active_task : active_tasks) { + for (auto &active_task : m_active_tasks) { auto current_task = &active_task; if (current_task->task_id == TASKSLOTEMPTY) { continue; @@ -745,7 +745,7 @@ void ClientTaskState::UpdateTasksForItem(Client *client, ActivityType activity_t // Check if there are any active loot activities for this task - TaskInformation *p_task_data = p_task_manager->p_task_data[current_task->task_id]; + TaskInformation *p_task_data = task_manager->m_task_data[current_task->task_id]; if (p_task_data == nullptr) { return; } @@ -781,7 +781,7 @@ void ClientTaskState::UpdateTasksForItem(Client *client, ActivityType activity_t break; case METHODLIST: - if (!p_task_manager->goal_list_manager.IsInList( + if (!task_manager->m_goal_list_manager.IsInList( activity_info->goal_id, item_id )) { continue; } @@ -801,12 +801,12 @@ void ClientTaskState::UpdateTasksForItem(Client *client, ActivityType activity_t void ClientTaskState::UpdateTasksOnExplore(Client *client, int explore_id) { LogTasks("[UpdateTasksOnExplore] explore_id [{}]", explore_id); - if (!p_task_manager || (active_task_count == 0 && active_task.task_id == TASKSLOTEMPTY)) { // could be better ... + if (!task_manager || (m_active_task_count == 0 && m_active_task.task_id == TASKSLOTEMPTY)) { // could be better ... return; } // loop over the union of tasks and quests - for (auto &active_task : active_tasks) { + for (auto &active_task : m_active_tasks) { auto current_task = &active_task; if (current_task->task_id == TASKSLOTEMPTY) { continue; @@ -814,7 +814,7 @@ void ClientTaskState::UpdateTasksOnExplore(Client *client, int explore_id) // Check if there are any active explore activities for this task - TaskInformation *task_data = p_task_manager->p_task_data[current_task->task_id]; + TaskInformation *task_data = task_manager->m_task_data[current_task->task_id]; if (task_data == nullptr) { return; } @@ -849,7 +849,7 @@ void ClientTaskState::UpdateTasksOnExplore(Client *client, int explore_id) break; case METHODLIST: - if (!p_task_manager->goal_list_manager.IsInList( + if (!task_manager->m_goal_list_manager.IsInList( activity_info->goal_id, explore_id )) { @@ -891,19 +891,19 @@ bool ClientTaskState::UpdateTasksOnDeliver( bool is_updated = false; LogTasks("[UpdateTasksOnDeliver] [{}]", npc_type_id); - if (!p_task_manager || (active_task_count == 0 && active_task.task_id == TASKSLOTEMPTY)) { // could be better ... + if (!task_manager || (m_active_task_count == 0 && m_active_task.task_id == TASKSLOTEMPTY)) { // could be better ... return false; } // loop over the union of tasks and quests for (int i = 0; i < MAXACTIVEQUESTS + 1; i++) { - auto current_task = &active_tasks[i]; + auto current_task = &m_active_tasks[i]; if (current_task->task_id == TASKSLOTEMPTY) { continue; } // Check if there are any active deliver activities for this task - TaskInformation *p_task_data = p_task_manager->p_task_data[current_task->task_id]; + TaskInformation *p_task_data = task_manager->m_task_data[current_task->task_id]; if (p_task_data == nullptr) { return false; } @@ -952,7 +952,7 @@ bool ClientTaskState::UpdateTasksOnDeliver( break; case METHODLIST: - if (!p_task_manager->goal_list_manager.IsInList( + if (!task_manager->m_goal_list_manager.IsInList( activity_info->goal_id, item->GetID())) { continue; @@ -986,19 +986,19 @@ void ClientTaskState::UpdateTasksOnTouch(Client *client, int zone_id) // If the client has no tasks, there is nothing further to check. LogTasks("[UpdateTasksOnTouch] [{}] ", zone_id); - if (!p_task_manager || (active_task_count == 0 && active_task.task_id == TASKSLOTEMPTY)) { // could be better ... + if (!task_manager || (m_active_task_count == 0 && m_active_task.task_id == TASKSLOTEMPTY)) { // could be better ... return; } // loop over the union of tasks and quests - for (auto &active_task : active_tasks) { + for (auto &active_task : m_active_tasks) { auto current_task = &active_task; if (current_task->task_id == TASKSLOTEMPTY) { continue; } // Check if there are any active explore activities for this task - TaskInformation *p_task_data = p_task_manager->p_task_data[current_task->task_id]; + TaskInformation *p_task_data = task_manager->m_task_data[current_task->task_id]; if (p_task_data == nullptr) { return; } @@ -1094,7 +1094,7 @@ void ClientTaskState::IncrementDoneCount( // and by the 'Task Stage Completed' message client->SendTaskActivityComplete(info->task_id, activity_id, task_index, task_information->type); // Send the updated task/activity_information list to the client - p_task_manager->SendSingleActiveTaskToClient(client, *info, task_complete, false); + task_manager->SendSingleActiveTaskToClient(client, *info, task_complete, false); // Inform the client the task has been updated, both by a chat message client->Message(Chat::White, "Your task '%s' has been updated.", task_information->title.c_str()); @@ -1146,9 +1146,9 @@ void ClientTaskState::IncrementDoneCount( QServ->PlayerLogEvent(Player_Log_Task_Updates, client->CharacterID(), event_desc); } - p_task_manager->SendCompletedTasksToClient(client, this); + task_manager->SendCompletedTasksToClient(client, this); client->SendTaskActivityComplete(info->task_id, 0, task_index, task_information->type, 0); - p_task_manager->SaveClientState(client, this); + task_manager->SaveClientState(client, this); //c->SendTaskComplete(TaskIndex); client->CancelTask(task_index, task_information->type); //if(Task->reward_method != METHODQUEST) RewardTask(c, Task); @@ -1161,11 +1161,11 @@ void ClientTaskState::IncrementDoneCount( } else { // Send an updated packet for this single activity_information - p_task_manager->SendTaskActivityLong( + task_manager->SendTaskActivityLong( client, info->task_id, activity_id, task_index, task_information->activity_information[activity_id].optional ); - p_task_manager->SaveClientState(client, this); + task_manager->SaveClientState(client, this); } } @@ -1191,7 +1191,7 @@ void ClientTaskState::RewardTask(Client *client, TaskInformation *task_informati break; } case METHODLIST: { - reward_list = p_task_manager->goal_list_manager.GetListContents(task_information->reward_id); + reward_list = task_manager->m_goal_list_manager.GetListContents(task_information->reward_id); for (int item_id : reward_list) { client->SummonItem(item_id); item_data = database.GetItem(item_id); @@ -1297,15 +1297,15 @@ void ClientTaskState::RewardTask(Client *client, TaskInformation *task_informati bool ClientTaskState::IsTaskActive(int task_id) { - if (active_task.task_id == task_id) { + if (m_active_task.task_id == task_id) { return true; } - if (active_task_count == 0 || task_id == 0) { + if (m_active_task_count == 0 || task_id == 0) { return false; } - for (auto &active_quest : active_quests) { + for (auto &active_quest : m_active_quests) { if (active_quest.task_id == task_id) { return true; } @@ -1320,10 +1320,10 @@ void ClientTaskState::FailTask(Client *client, int task_id) "[FailTask] Failing task for character [{}] task_id [{}] task_count [{}]", client->GetCleanName(), task_id, - active_task_count + m_active_task_count ); - if (active_task.task_id == task_id) { + if (m_active_task.task_id == task_id) { client->SendTaskFailed(task_id, 0, TaskType::Task); // Remove the task from the client client->CancelTask(0, TaskType::Task); @@ -1332,13 +1332,13 @@ void ClientTaskState::FailTask(Client *client, int task_id) // TODO: shared tasks - if (active_task_count == 0) { + if (m_active_task_count == 0) { return; } for (int i = 0; i < MAXACTIVEQUESTS; i++) { - if (active_quests[i].task_id == task_id) { - client->SendTaskFailed(active_quests[i].task_id, i, TaskType::Quest); + if (m_active_quests[i].task_id == task_id) { + client->SendTaskFailed(m_active_quests[i].task_id, i, TaskType::Quest); // Remove the task from the client client->CancelTask(i, TaskType::Quest); return; @@ -1355,20 +1355,20 @@ bool ClientTaskState::IsTaskActivityActive(int task_id, int activity_id) if (activity_id < 0) { return false; } - if (active_task_count == 0 && active_task.task_id == TASKSLOTEMPTY) { + if (m_active_task_count == 0 && m_active_task.task_id == TASKSLOTEMPTY) { return false; } int active_task_index = -1; auto task_type = TaskType::Task; - if (active_task.task_id == task_id) { + if (m_active_task.task_id == task_id) { active_task_index = 0; } if (active_task_index == -1) { for (int i = 0; i < MAXACTIVEQUESTS; i++) { - if (active_quests[i].task_id == task_id) { + if (m_active_quests[i].task_id == task_id) { active_task_index = i; task_type = TaskType::Quest; break; @@ -1387,7 +1387,7 @@ bool ClientTaskState::IsTaskActivityActive(int task_id, int activity_id) return false; } - TaskInformation *p_task_data = p_task_manager->p_task_data[info->task_id]; + TaskInformation *p_task_data = task_manager->m_task_data[info->task_id]; // The task is invalid if (p_task_data == nullptr) { @@ -1424,20 +1424,20 @@ void ClientTaskState::UpdateTaskActivity( ); // Quick sanity check - if (activity_id < 0 || (active_task_count == 0 && active_task.task_id == TASKSLOTEMPTY)) { + if (activity_id < 0 || (m_active_task_count == 0 && m_active_task.task_id == TASKSLOTEMPTY)) { return; } int active_task_index = -1; auto type = TaskType::Task; - if (active_task.task_id == task_id) { + if (m_active_task.task_id == task_id) { active_task_index = 0; } if (active_task_index == -1) { for (int i = 0; i < MAXACTIVEQUESTS; i++) { - if (active_quests[i].task_id == task_id) { + if (m_active_quests[i].task_id == task_id) { active_task_index = i; type = TaskType::Quest; break; @@ -1455,7 +1455,7 @@ void ClientTaskState::UpdateTaskActivity( return; } - TaskInformation *p_task_data = p_task_manager->p_task_data[info->task_id]; + TaskInformation *p_task_data = task_manager->m_task_data[info->task_id]; // The task is invalid if (p_task_data == nullptr) { @@ -1492,19 +1492,19 @@ void ClientTaskState::ResetTaskActivity(Client *client, int task_id, int activit ); // Quick sanity check - if (activity_id < 0 || (active_task_count == 0 && active_task.task_id == TASKSLOTEMPTY)) { + if (activity_id < 0 || (m_active_task_count == 0 && m_active_task.task_id == TASKSLOTEMPTY)) { return; } int active_task_index = -1; auto type = TaskType::Task; - if (active_task.task_id == task_id) { + if (m_active_task.task_id == task_id) { active_task_index = 0; } if (active_task_index == -1) { for (int i = 0; i < MAXACTIVEQUESTS; i++) { - if (active_quests[i].task_id == task_id) { + if (m_active_quests[i].task_id == task_id) { active_task_index = i; type = TaskType::Quest; break; @@ -1522,7 +1522,7 @@ void ClientTaskState::ResetTaskActivity(Client *client, int task_id, int activit return; } - TaskInformation *p_task_data = p_task_manager->p_task_data[info->task_id]; + TaskInformation *p_task_data = task_manager->m_task_data[info->task_id]; if (p_task_data == nullptr) { return; } @@ -1559,30 +1559,30 @@ void ClientTaskState::ShowClientTasks(Client *client) client->Message(Chat::White, "------------------------------------------------"); client->Message(Chat::White, "# Task Information | Client [%s]", client->GetCleanName()); // client->Message(Chat::White, "------------------------------------------------"); - if (active_task.task_id != TASKSLOTEMPTY) { + if (m_active_task.task_id != TASKSLOTEMPTY) { client->Message( Chat::White, "Task: %i %s", - active_task.task_id, - p_task_manager->p_task_data[active_task.task_id]->title.c_str() + m_active_task.task_id, + task_manager->m_task_data[m_active_task.task_id]->title.c_str() ); client->Message( Chat::White, " description: [%s]\n", - p_task_manager->p_task_data[active_task.task_id]->description.c_str() + task_manager->m_task_data[m_active_task.task_id]->description.c_str() ); - for (int activity_id = 0; activity_id < p_task_manager->GetActivityCount(active_task.task_id); activity_id++) { + for (int activity_id = 0; activity_id < task_manager->GetActivityCount(m_active_task.task_id); activity_id++) { client->Message( Chat::White, " activity_information: %2d, done_count: %2d, Status: %d (0=Hidden, 1=Active, 2=Complete)", - active_task.activity[activity_id].activity_id, - active_task.activity[activity_id].done_count, - active_task.activity[activity_id].activity_state + m_active_task.activity[activity_id].activity_id, + m_active_task.activity[activity_id].done_count, + m_active_task.activity[activity_id].activity_state ); } } - for (auto &active_quest : active_quests) { + for (auto &active_quest : m_active_quests) { if (active_quest.task_id == TASKSLOTEMPTY) { continue; } @@ -1591,17 +1591,17 @@ void ClientTaskState::ShowClientTasks(Client *client) client->Message( Chat::White, "# Quest | task_id [%i] title [%s]", active_quest.task_id, - p_task_manager->p_task_data[active_quest.task_id]->title.c_str() + task_manager->m_task_data[active_quest.task_id]->title.c_str() ); client->Message(Chat::White, "------------------------------------------------"); client->Message( Chat::White, " -- Description [%s]\n", - p_task_manager->p_task_data[active_quest.task_id]->description.c_str() + task_manager->m_task_data[active_quest.task_id]->description.c_str() ); - for (int activity_id = 0; activity_id < p_task_manager->GetActivityCount(active_quest.task_id); activity_id++) { + for (int activity_id = 0; activity_id < task_manager->GetActivityCount(active_quest.task_id); activity_id++) { std::vector update_increments = {"1", "5", "50"}; std::string update_saylinks; @@ -1637,10 +1637,10 @@ void ClientTaskState::ShowClientTasks(Client *client) // TODO: Shared Task int ClientTaskState::TaskTimeLeft(int task_id) { - if (active_task.task_id == task_id) { + if (m_active_task.task_id == task_id) { int time_now = time(nullptr); - TaskInformation *p_task_data = p_task_manager->p_task_data[task_id]; + TaskInformation *p_task_data = task_manager->m_task_data[task_id]; if (p_task_data == nullptr) { return -1; } @@ -1649,23 +1649,23 @@ int ClientTaskState::TaskTimeLeft(int task_id) return -1; } - int time_left = (active_task.accepted_time + p_task_data->duration - time_now); + int time_left = (m_active_task.accepted_time + p_task_data->duration - time_now); return (time_left > 0 ? time_left : 0); } - if (active_task_count == 0) { + if (m_active_task_count == 0) { return -1; } - for (auto &active_quest : active_quests) { + for (auto &active_quest : m_active_quests) { if (active_quest.task_id != task_id) { continue; } int time_now = time(nullptr); - TaskInformation *p_task_data = p_task_manager->p_task_data[active_quest.task_id]; + TaskInformation *p_task_data = task_manager->m_task_data[active_quest.task_id]; if (p_task_data == nullptr) { return -1; } @@ -1695,7 +1695,7 @@ int ClientTaskState::IsTaskCompleted(int task_id) return -1; } - for (auto &completed_task : completed_tasks) { + for (auto &completed_task : m_completed_tasks) { LogTasks("[IsTaskCompleted] Comparing compelted task [{}] with [{}]", completed_task.task_id, task_id); if (completed_task.task_id == task_id) { return 1; @@ -1719,7 +1719,7 @@ bool ClientTaskState::TaskOutOfTime(TaskType task_type, int index) } int time_now = time(nullptr); - TaskInformation *task_data = p_task_manager->p_task_data[info->task_id]; + TaskInformation *task_data = task_manager->m_task_data[info->task_id]; if (task_data == nullptr) { return false; } @@ -1729,10 +1729,10 @@ bool ClientTaskState::TaskOutOfTime(TaskType task_type, int index) void ClientTaskState::TaskPeriodicChecks(Client *client) { - if (active_task.task_id != TASKSLOTEMPTY) { + if (m_active_task.task_id != TASKSLOTEMPTY) { if (TaskOutOfTime(TaskType::Task, 0)) { // Send Red Task Failed Message - client->SendTaskFailed(active_task.task_id, 0, TaskType::Task); + client->SendTaskFailed(m_active_task.task_id, 0, TaskType::Task); // Remove the task from the client client->CancelTask(0, TaskType::Task); // It is a conscious decision to only fail one task per call to this method, @@ -1744,20 +1744,20 @@ void ClientTaskState::TaskPeriodicChecks(Client *client) // TODO: shared tasks -- although that will probably be manager in world checking and telling zones to fail us - if (active_task_count == 0) { + if (m_active_task_count == 0) { return; } // Check for tasks that have failed because they have not been completed in the specified time // for (int task_index = 0; task_index < MAXACTIVEQUESTS; task_index++) { - if (active_quests[task_index].task_id == TASKSLOTEMPTY) { + if (m_active_quests[task_index].task_id == TASKSLOTEMPTY) { continue; } if (TaskOutOfTime(TaskType::Quest, task_index)) { // Send Red Task Failed Message - client->SendTaskFailed(active_quests[task_index].task_id, task_index, TaskType::Quest); + client->SendTaskFailed(m_active_quests[task_index].task_id, task_index, TaskType::Quest); // Remove the task from the client client->CancelTask(task_index, TaskType::Quest); // It is a conscious decision to only fail one task per call to this method, @@ -1771,9 +1771,9 @@ void ClientTaskState::TaskPeriodicChecks(Client *client) // This is done in this method because it gives an extra few seconds for the client screen to display // the zone before we send the 'Task activity_information Completed' message. // - if (!checked_touch_activities) { + if (!m_checked_touch_activities) { UpdateTasksOnTouch(client, zone->GetZoneID()); - checked_touch_activities = true; + m_checked_touch_activities = true; } } @@ -1784,12 +1784,12 @@ bool ClientTaskState::IsTaskActivityCompleted(TaskType task_type, int index, int if (index != 0) { return false; } - return active_task.activity[activity_id].activity_state == ActivityCompleted; + return m_active_task.activity[activity_id].activity_state == ActivityCompleted; case TaskType::Shared: return false; // TODO: shared tasks case TaskType::Quest: if (index < MAXACTIVEQUESTS) { - return active_quests[index].activity[activity_id].activity_state == ActivityCompleted; + return m_active_quests[index].activity[activity_id].activity_state == ActivityCompleted; } default: return false; @@ -1805,12 +1805,12 @@ ActivityState ClientTaskState::GetTaskActivityState(TaskType task_type, int inde if (index != 0) { return ActivityHidden; } - return active_task.activity[activity_id].activity_state; + return m_active_task.activity[activity_id].activity_state; case TaskType::Shared: return ActivityHidden; // TODO: shared tasks case TaskType::Quest: if (index < MAXACTIVEQUESTS) { - return active_quests[index].activity[activity_id].activity_state; + return m_active_quests[index].activity[activity_id].activity_state; } default: return ActivityHidden; @@ -1824,12 +1824,12 @@ int ClientTaskState::GetTaskActivityDoneCount(TaskType task_type, int index, int if (index != 0) { return 0; } - return active_task.activity[activity_id].done_count; + return m_active_task.activity[activity_id].done_count; case TaskType::Shared: return 0; // TODO: shared tasks case TaskType::Quest: if (index < MAXACTIVEQUESTS) { - return active_quests[index].activity[activity_id].done_count; + return m_active_quests[index].activity[activity_id].done_count; } default: return 0; @@ -1838,8 +1838,8 @@ int ClientTaskState::GetTaskActivityDoneCount(TaskType task_type, int index, int int ClientTaskState::GetTaskActivityDoneCountFromTaskID(int task_id, int activity_id) { - if (active_task.task_id == task_id) { - return active_task.activity[activity_id].done_count; + if (m_active_task.task_id == task_id) { + return m_active_task.activity[activity_id].done_count; } // TODO: shared tasks @@ -1847,7 +1847,7 @@ int ClientTaskState::GetTaskActivityDoneCountFromTaskID(int task_id, int activit int active_task_index = -1; for (int task_index = 0; task_index < MAXACTIVEQUESTS; task_index++) { - if (active_quests[task_index].task_id == task_id) { + if (m_active_quests[task_index].task_id == task_id) { active_task_index = task_index; break; } @@ -1857,8 +1857,8 @@ int ClientTaskState::GetTaskActivityDoneCountFromTaskID(int task_id, int activit return 0; } - if (active_quests[active_task_index].activity[activity_id].done_count) { - return active_quests[active_task_index].activity[activity_id].done_count; + if (m_active_quests[active_task_index].activity[activity_id].done_count) { + return m_active_quests[active_task_index].activity[activity_id].done_count; } else { return 0; @@ -1869,9 +1869,9 @@ int ClientTaskState::GetTaskStartTime(TaskType task_type, int index) { switch (task_type) { case TaskType::Task: - return active_task.accepted_time; + return m_active_task.accepted_time; case TaskType::Quest: - return active_quests[index].accepted_time; + return m_active_quests[index].accepted_time; case TaskType::Shared: // TODO default: return -1; @@ -1886,12 +1886,12 @@ void ClientTaskState::CancelAllTasks(Client *client) // resent to the client, in case an updated task fails to load CancelTask(client, 0, TaskType::Task, false); - active_task.task_id = TASKSLOTEMPTY; + m_active_task.task_id = TASKSLOTEMPTY; for (int task_index = 0; task_index < MAXACTIVEQUESTS; task_index++) - if (active_quests[task_index].task_id != TASKSLOTEMPTY) { + if (m_active_quests[task_index].task_id != TASKSLOTEMPTY) { CancelTask(client, task_index, TaskType::Quest, false); - active_quests[task_index].task_id = TASKSLOTEMPTY; + m_active_quests[task_index].task_id = TASKSLOTEMPTY; } // TODO: shared @@ -1924,12 +1924,12 @@ void ClientTaskState::RemoveTask(Client *client, int sequence_number, TaskType t switch (task_type) { case TaskType::Task: if (sequence_number == 0) { - task_id = active_task.task_id; + task_id = m_active_task.task_id; } break; case TaskType::Quest: if (sequence_number < MAXACTIVEQUESTS) { - task_id = active_quests[sequence_number].task_id; + task_id = m_active_quests[sequence_number].task_id; } break; case TaskType::Shared: // TODO: @@ -1949,13 +1949,13 @@ void ClientTaskState::RemoveTask(Client *client, int sequence_number, TaskType t switch (task_type) { case TaskType::Task: - active_task.task_id = TASKSLOTEMPTY; + m_active_task.task_id = TASKSLOTEMPTY; break; case TaskType::Shared: break; // TODO: shared tasks case TaskType::Quest: - active_quests[sequence_number].task_id = TASKSLOTEMPTY; - active_task_count--; + m_active_quests[sequence_number].task_id = TASKSLOTEMPTY; + m_active_task_count--; break; default: break; @@ -1964,7 +1964,7 @@ void ClientTaskState::RemoveTask(Client *client, int sequence_number, TaskType t void ClientTaskState::RemoveTaskByTaskID(Client *client, uint32 task_id) { - auto task_type = p_task_manager->GetTaskType(task_id); + auto task_type = task_manager->GetTaskType(task_id); int character_id = client->CharacterID(); CharacterActivitiesRepository::DeleteWhere( @@ -1979,7 +1979,7 @@ void ClientTaskState::RemoveTaskByTaskID(Client *client, uint32 task_id) switch (task_type) { case TaskType::Task: { - if (active_task.task_id == task_id) { + if (m_active_task.task_id == task_id) { auto outapp = new EQApplicationPacket(OP_CancelTask, sizeof(CancelTask_Struct)); CancelTask_Struct *cts = (CancelTask_Struct *) outapp->pBuffer; cts->SequenceNumber = 0; @@ -1987,7 +1987,7 @@ void ClientTaskState::RemoveTaskByTaskID(Client *client, uint32 task_id) LogTasks("[UPDATE] RemoveTaskByTaskID found Task [{}]", task_id); client->QueuePacket(outapp); safe_delete(outapp); - active_task.task_id = TASKSLOTEMPTY; + m_active_task.task_id = TASKSLOTEMPTY; } break; } @@ -1996,14 +1996,14 @@ void ClientTaskState::RemoveTaskByTaskID(Client *client, uint32 task_id) } case TaskType::Quest: { for (int active_quest = 0; active_quest < MAXACTIVEQUESTS; active_quest++) { - if (active_quests[active_quest].task_id == task_id) { + if (m_active_quests[active_quest].task_id == task_id) { auto outapp = new EQApplicationPacket(OP_CancelTask, sizeof(CancelTask_Struct)); CancelTask_Struct *cts = (CancelTask_Struct *) outapp->pBuffer; cts->SequenceNumber = active_quest; cts->type = static_cast(task_type); LogTasks("[UPDATE] RemoveTaskByTaskID found Quest [{}] at index [{}]", task_id, active_quest); - active_quests[active_quest].task_id = TASKSLOTEMPTY; - active_task_count--; + m_active_quests[active_quest].task_id = TASKSLOTEMPTY; + m_active_task_count--; client->QueuePacket(outapp); safe_delete(outapp); } @@ -2017,12 +2017,12 @@ void ClientTaskState::RemoveTaskByTaskID(Client *client, uint32 task_id) void ClientTaskState::AcceptNewTask(Client *client, int task_id, int npc_type_id, bool enforce_level_requirement) { - if (!p_task_manager || task_id < 0 || task_id >= MAXTASKS) { + if (!task_manager || task_id < 0 || task_id >= MAXTASKS) { client->Message(Chat::Red, "Task system not functioning, or task_id %i out of range.", task_id); return; } - auto task = p_task_manager->p_task_data[task_id]; + auto task = task_manager->m_task_data[task_id]; if (task == nullptr) { client->Message(Chat::Red, "Invalid task_id %i", task_id); @@ -2033,7 +2033,7 @@ void ClientTaskState::AcceptNewTask(Client *client, int task_id, int npc_type_id switch (task->type) { case TaskType::Task: - if (active_task.task_id != TASKSLOTEMPTY) { + if (m_active_task.task_id != TASKSLOTEMPTY) { max_tasks = true; } break; @@ -2042,7 +2042,7 @@ void ClientTaskState::AcceptNewTask(Client *client, int task_id, int npc_type_id max_tasks = true; break; case TaskType::Quest: - if (active_task_count == MAXACTIVEQUESTS) { + if (m_active_task_count == MAXACTIVEQUESTS) { max_tasks = true; } break; @@ -2061,7 +2061,7 @@ void ClientTaskState::AcceptNewTask(Client *client, int task_id, int npc_type_id // only Quests can have more than one, so don't need to check others if (task->type == TaskType::Quest) { - for (auto &active_quest : active_quests) { + for (auto &active_quest : m_active_quests) { if (active_quest.task_id == task_id) { client->Message(Chat::Red, "You have already been assigned this task."); return; @@ -2069,12 +2069,12 @@ void ClientTaskState::AcceptNewTask(Client *client, int task_id, int npc_type_id } } - if (enforce_level_requirement && !p_task_manager->ValidateLevel(task_id, client->GetLevel())) { + if (enforce_level_requirement && !task_manager->ValidateLevel(task_id, client->GetLevel())) { client->Message(Chat::Red, "You are outside the level range of this task."); return; } - if (!p_task_manager->IsTaskRepeatable(task_id) && IsTaskCompleted(task_id)) { + if (!task_manager->IsTaskRepeatable(task_id) && IsTaskCompleted(task_id)) { return; } @@ -2086,7 +2086,7 @@ void ClientTaskState::AcceptNewTask(Client *client, int task_id, int npc_type_id ClientTaskInformation *active_slot = nullptr; switch (task->type) { case TaskType::Task: - active_slot = &active_task; + active_slot = &m_active_task; break; case TaskType::Shared: // TODO: shared active_slot = nullptr; @@ -2095,9 +2095,9 @@ void ClientTaskState::AcceptNewTask(Client *client, int task_id, int npc_type_id for (int task_index = 0; task_index < MAXACTIVEQUESTS; task_index++) { Log(Logs::General, Logs::Tasks, "[UPDATE] ClientTaskState Looking for free slot in slot %i, found task_id of %i", task_index, - active_quests[task_index].task_id); - if (active_quests[task_index].task_id == 0) { - active_slot = &active_quests[task_index]; + m_active_quests[task_index].task_id); + if (m_active_quests[task_index].task_id == 0) { + active_slot = &m_active_quests[task_index]; break; } } @@ -2121,7 +2121,7 @@ void ClientTaskState::AcceptNewTask(Client *client, int task_id, int npc_type_id active_slot->updated = true; active_slot->current_step = -1; - for (int activity_id = 0; activity_id < p_task_manager->p_task_data[task_id]->activity_count; activity_id++) { + for (int activity_id = 0; activity_id < task_manager->m_task_data[task_id]->activity_count; activity_id++) { active_slot->activity[activity_id].activity_id = activity_id; active_slot->activity[activity_id].done_count = 0; active_slot->activity[activity_id].activity_state = ActivityHidden; @@ -2131,16 +2131,16 @@ void ClientTaskState::AcceptNewTask(Client *client, int task_id, int npc_type_id UnlockActivities(client->CharacterID(), *active_slot); if (task->type == TaskType::Quest) { - active_task_count++; + m_active_task_count++; } - p_task_manager->SendSingleActiveTaskToClient(client, *active_slot, false, true); + task_manager->SendSingleActiveTaskToClient(client, *active_slot, false, true); client->Message( Chat::White, "You have been assigned the task '%s'.", - p_task_manager->p_task_data[task_id]->title.c_str() + task_manager->m_task_data[task_id]->title.c_str() ); - p_task_manager->SaveClientState(client, this); + task_manager->SaveClientState(client, this); std::string buf = std::to_string(task_id); NPC *npc = entity_list.GetID(npc_type_id)->CastToNPC(); @@ -2160,7 +2160,7 @@ void ClientTaskState::ProcessTaskProximities(Client *client, float x, float y, f } LogTasksDetail("[ProcessTaskProximities] Checking proximities for Position x[{}] y[{}] z[{}]", x, y, z); - int explore_id = p_task_manager->proximity_manager.CheckProximities(x, y, z); + int explore_id = task_manager->m_proximity_manager.CheckProximities(x, y, z); if (explore_id > 0) { LogTasksDetail( "[ProcessTaskProximities] Position x[{}] y[{}] z[{}] is within proximity explore_id [{}]", diff --git a/zone/task_client_state.h b/zone/task_client_state.h index 676f5383e..6812e99c6 100644 --- a/zone/task_client_state.h +++ b/zone/task_client_state.h @@ -14,7 +14,7 @@ public: ClientTaskState(); ~ClientTaskState(); void ShowClientTasks(Client *client); - inline int GetActiveTaskCount() { return active_task_count; } + inline int GetActiveTaskCount() { return m_active_task_count; } int GetActiveTaskID(int index); bool IsTaskActivityCompleted(TaskType task_type, int index, int activity_id); int GetTaskActivityDoneCount(TaskType task_type, int index, int activity_id); @@ -55,7 +55,7 @@ public: int CompletedTasksInSet(int task_set_id); bool HasSlotForTask(TaskInformation *task); - inline bool HasFreeTaskSlot() { return active_task.task_id == TASKSLOTEMPTY; } + inline bool HasFreeTaskSlot() { return m_active_task.task_id == TASKSLOTEMPTY; } friend class TaskManager; @@ -69,20 +69,21 @@ private: int count = 1, bool ignore_quest_update = false ); + inline ClientTaskInformation *GetClientTaskInfo(TaskType task_type, int index) { ClientTaskInformation *info = nullptr; switch (task_type) { case TaskType::Task: if (index == 0) { - info = &active_task; + info = &m_active_task; } break; case TaskType::Shared: break; case TaskType::Quest: if (index < MAXACTIVEQUESTS) { - info = &active_quests[index]; + info = &m_active_quests[index]; } break; default: @@ -90,20 +91,20 @@ private: } return info; } - int active_task_count; union { // easier to loop over struct { - ClientTaskInformation active_task; // only one - ClientTaskInformation active_quests[MAXACTIVEQUESTS]; + ClientTaskInformation m_active_task; // only one + ClientTaskInformation m_active_quests[MAXACTIVEQUESTS]; }; - ClientTaskInformation active_tasks[MAXACTIVEQUESTS + 1]; + ClientTaskInformation m_active_tasks[MAXACTIVEQUESTS + 1]; }; // Shared tasks should be limited to 1 as well - std::vector enabled_tasks; - std::vector completed_tasks; - int last_completed_task_loaded; - bool checked_touch_activities; + int m_active_task_count; + std::vector m_enabled_tasks; + std::vector m_completed_tasks; + int m_last_completed_task_loaded; + bool m_checked_touch_activities; }; diff --git a/zone/task_manager.cpp b/zone/task_manager.cpp index 87d56d6d2..d55d5b980 100644 --- a/zone/task_manager.cpp +++ b/zone/task_manager.cpp @@ -12,14 +12,14 @@ TaskManager::TaskManager() { - for (auto &task : p_task_data) { + for (auto &task : m_task_data) { task = nullptr; } } TaskManager::~TaskManager() { - for (auto &task : p_task_data) { + for (auto &task : m_task_data) { if (task != nullptr) { safe_delete(task); } @@ -30,7 +30,7 @@ bool TaskManager::LoadTaskSets() { // Clear all task sets in memory. Done so we can reload them on the fly if required by just calling // this method again. - for (auto &task_set : task_sets) { + for (auto &task_set : m_task_sets) { task_set.clear(); } @@ -44,7 +44,7 @@ bool TaskManager::LoadTaskSets() ); for (auto &task_set: rows) { - task_sets[task_set.id].push_back(task_set.taskid); + m_task_sets[task_set.id].push_back(task_set.taskid); LogTasksDetail("[LoadTaskSets] Adding task_id [{}] to task_set [{}]", task_set.taskid, task_set.id); } @@ -53,7 +53,7 @@ bool TaskManager::LoadTaskSets() void TaskManager::ReloadGoalLists() { - if (!goal_list_manager.LoadLists()) { + if (!m_goal_list_manager.LoadLists()) { Log(Logs::Detail, Logs::Tasks, "TaskManager::LoadTasks LoadLists failed"); } } @@ -63,7 +63,7 @@ bool TaskManager::LoadTasks(int single_task) std::string task_query_filter = fmt::format("id = {}", single_task); std::string query; if (single_task == 0) { - if (!goal_list_manager.LoadLists()) { + if (!m_goal_list_manager.LoadLists()) { LogTasks("[TaskManager::LoadTasks] LoadLists failed"); } @@ -87,25 +87,25 @@ bool TaskManager::LoadTasks(int single_task) } // load task data - p_task_data[task_id] = new TaskInformation; - p_task_data[task_id]->type = static_cast(task.type); - p_task_data[task_id]->duration = task.duration; - p_task_data[task_id]->duration_code = static_cast(task.duration_code); - p_task_data[task_id]->title = task.title; - p_task_data[task_id]->description = task.description; - p_task_data[task_id]->reward = task.reward; - p_task_data[task_id]->reward_id = task.rewardid; - p_task_data[task_id]->cash_reward = task.cashreward; - p_task_data[task_id]->experience_reward = task.xpreward; - p_task_data[task_id]->reward_method = (TaskMethodType) task.rewardmethod; - p_task_data[task_id]->faction_reward = task.faction_reward; - p_task_data[task_id]->min_level = task.minlevel; - p_task_data[task_id]->max_level = task.maxlevel; - p_task_data[task_id]->repeatable = task.repeatable; - p_task_data[task_id]->completion_emote = task.completion_emote; - p_task_data[task_id]->activity_count = 0; - p_task_data[task_id]->sequence_mode = ActivitiesSequential; - p_task_data[task_id]->last_step = 0; + m_task_data[task_id] = new TaskInformation; + m_task_data[task_id]->type = static_cast(task.type); + m_task_data[task_id]->duration = task.duration; + m_task_data[task_id]->duration_code = static_cast(task.duration_code); + m_task_data[task_id]->title = task.title; + m_task_data[task_id]->description = task.description; + m_task_data[task_id]->reward = task.reward; + m_task_data[task_id]->reward_id = task.rewardid; + m_task_data[task_id]->cash_reward = task.cashreward; + m_task_data[task_id]->experience_reward = task.xpreward; + m_task_data[task_id]->reward_method = (TaskMethodType) task.rewardmethod; + m_task_data[task_id]->faction_reward = task.faction_reward; + m_task_data[task_id]->min_level = task.minlevel; + m_task_data[task_id]->max_level = task.maxlevel; + m_task_data[task_id]->repeatable = task.repeatable; + m_task_data[task_id]->completion_emote = task.completion_emote; + m_task_data[task_id]->activity_count = 0; + m_task_data[task_id]->sequence_mode = ActivitiesSequential; + m_task_data[task_id]->last_step = 0; LogTasksDetail( "[LoadTasks] (Task) task_id [{}] type [{}] duration [{}] duration_code [{}] title [{}] description [{}] " @@ -155,8 +155,8 @@ bool TaskManager::LoadTasks(int single_task) int activity_id = task_activity.activityid; // create pointer to activity data since declarations get unruly long - int activity_index = p_task_data[task_id]->activity_count; - ActivityInformation *p_activity_data = &p_task_data[task_id]->activity_information[activity_index]; + int activity_index = m_task_data[task_id]->activity_count; + ActivityInformation *activity_data = &m_task_data[task_id]->activity_information[activity_index]; if ((task_id <= 0) || (task_id >= MAXTASKS) || (activity_id < 0) || (activity_id >= MAXACTIVITIESPERTASK)) { @@ -169,7 +169,7 @@ bool TaskManager::LoadTasks(int single_task) continue; } - if (p_task_data[task_id] == nullptr) { + if (m_task_data[task_id] == nullptr) { LogTasks( "Error: activity_information for non-existent task ([{}], [{}]) while loading activities from database", task_id, @@ -178,76 +178,76 @@ bool TaskManager::LoadTasks(int single_task) continue; } - p_task_data[task_id]->activity_information[p_task_data[task_id]->activity_count].step_number = step; + m_task_data[task_id]->activity_information[m_task_data[task_id]->activity_count].step_number = step; if (step != 0) { - p_task_data[task_id]->sequence_mode = ActivitiesStepped; + m_task_data[task_id]->sequence_mode = ActivitiesStepped; } - if (step > p_task_data[task_id]->last_step) { - p_task_data[task_id]->last_step = step; + if (step > m_task_data[task_id]->last_step) { + m_task_data[task_id]->last_step = step; } // Task Activities MUST be numbered sequentially from 0. If not, log an error // and set the task to nullptr. Subsequent activities for this task will raise // ERR_NOTASK errors. // Change to (activityID != (Tasks[taskID]->activity_count + 1)) to index from 1 - if (activity_id != p_task_data[task_id]->activity_count) { + if (activity_id != m_task_data[task_id]->activity_count) { LogError( "[TASKS]Activities for Task [{}] are not sequential starting at 0. Not loading task", task_id, activity_id ); - p_task_data[task_id] = nullptr; + m_task_data[task_id] = nullptr; continue; } // set activity data - p_activity_data->activity_type = task_activity.activitytype; - p_activity_data->target_name = task_activity.target_name; - p_activity_data->item_list = task_activity.item_list; - p_activity_data->skill_list = task_activity.skill_list; - p_activity_data->skill_id = std::stoi(task_activity.skill_list); // for older clients - p_activity_data->spell_list = task_activity.spell_list; - p_activity_data->spell_id = std::stoi(task_activity.spell_list); // for older clients - p_activity_data->description_override = task_activity.description_override; - p_activity_data->goal_id = task_activity.goalid; - p_activity_data->goal_method = (TaskMethodType) task_activity.goalmethod; - p_activity_data->goal_count = task_activity.goalcount; - p_activity_data->deliver_to_npc = task_activity.delivertonpc; + activity_data->activity_type = task_activity.activitytype; + activity_data->target_name = task_activity.target_name; + activity_data->item_list = task_activity.item_list; + activity_data->skill_list = task_activity.skill_list; + activity_data->skill_id = std::stoi(task_activity.skill_list); // for older clients + activity_data->spell_list = task_activity.spell_list; + activity_data->spell_id = std::stoi(task_activity.spell_list); // for older clients + activity_data->description_override = task_activity.description_override; + activity_data->goal_id = task_activity.goalid; + activity_data->goal_method = (TaskMethodType) task_activity.goalmethod; + activity_data->goal_count = task_activity.goalcount; + activity_data->deliver_to_npc = task_activity.delivertonpc; // zones - p_activity_data->zones = task_activity.zones; + activity_data->zones = task_activity.zones; auto zones = SplitString( task_activity.zones, ';' ); for (auto &&e : zones) { - p_activity_data->zone_ids.push_back(std::stoi(e)); + activity_data->zone_ids.push_back(std::stoi(e)); } - p_activity_data->optional = task_activity.optional; + activity_data->optional = task_activity.optional; LogTasksDetail( "[LoadTasks] (Activity) task_id [{}] activity_id [{}] slot [{}] activity_type [{}] goal_id [{}] goal_method [{}] goal_count [{}] zones [{}]" " target_name [{}] item_list [{}] skill_list [{}] spell_list [{}] description_override [{}]", task_id, activity_id, - p_task_data[task_id]->activity_count, - p_activity_data->activity_type, - p_activity_data->goal_id, - p_activity_data->goal_method, - p_activity_data->goal_count, - p_activity_data->zones.c_str(), - p_activity_data->target_name.c_str(), - p_activity_data->item_list.c_str(), - p_activity_data->skill_list.c_str(), - p_activity_data->spell_list.c_str(), - p_activity_data->description_override.c_str() + m_task_data[task_id]->activity_count, + activity_data->activity_type, + activity_data->goal_id, + activity_data->goal_method, + activity_data->goal_count, + activity_data->zones.c_str(), + activity_data->target_name.c_str(), + activity_data->item_list.c_str(), + activity_data->skill_list.c_str(), + activity_data->spell_list.c_str(), + activity_data->description_override.c_str() ); - p_task_data[task_id]->activity_count++; + m_task_data[task_id]->activity_count++; } LogTasks("Loaded [{}] Task Activities", task_activities.size()); @@ -271,9 +271,9 @@ bool TaskManager::SaveClientState(Client *client, ClientTaskState *client_task_s LogTasks("[SaveClientState] character_id [{}]", character_id); - if (client_task_state->active_task_count > 0 || - client_task_state->active_task.task_id != TASKSLOTEMPTY) { // TODO: tasks - for (auto &active_task : client_task_state->active_tasks) { + if (client_task_state->m_active_task_count > 0 || + client_task_state->m_active_task.task_id != TASKSLOTEMPTY) { // TODO: tasks + for (auto &active_task : client_task_state->m_active_tasks) { int task_id = active_task.task_id; if (task_id == TASKSLOTEMPTY) { continue; @@ -295,7 +295,7 @@ bool TaskManager::SaveClientState(Client *client, ClientTaskState *client_task_s character_id, task_id, slot, - static_cast(p_task_data[task_id]->type), + static_cast(m_task_data[task_id]->type), active_task.accepted_time ); @@ -314,7 +314,7 @@ bool TaskManager::SaveClientState(Client *client, ClientTaskState *client_task_s int updated_activity_count = 0; - for (int activity_index = 0; activity_index < p_task_data[task_id]->activity_count; ++activity_index) { + for (int activity_index = 0; activity_index < m_task_data[task_id]->activity_count; ++activity_index) { if (!active_task.activity[activity_index].updated) { continue; } @@ -362,28 +362,28 @@ bool TaskManager::SaveClientState(Client *client, ClientTaskState *client_task_s active_task.updated = false; for (int activity_index = 0; - activity_index < p_task_data[task_id]->activity_count; + activity_index < m_task_data[task_id]->activity_count; ++activity_index) active_task.activity[activity_index].updated = false; } } if (!RuleB(TaskSystem, RecordCompletedTasks) || - (client_task_state->completed_tasks.size() <= (unsigned int) client_task_state->last_completed_task_loaded)) { - client_task_state->last_completed_task_loaded = client_task_state->completed_tasks.size(); + (client_task_state->m_completed_tasks.size() <= (unsigned int) client_task_state->m_last_completed_task_loaded)) { + client_task_state->m_last_completed_task_loaded = client_task_state->m_completed_tasks.size(); return true; } const char *completed_task_query = "REPLACE INTO completed_tasks (charid, completedtime, taskid, activityid) " "VALUES (%i, %i, %i, %i)"; - for (unsigned int task_index = client_task_state->last_completed_task_loaded; - task_index < client_task_state->completed_tasks.size(); + for (unsigned int task_index = client_task_state->m_last_completed_task_loaded; + task_index < client_task_state->m_completed_tasks.size(); task_index++) { - int task_id = client_task_state->completed_tasks[task_index].task_id; + int task_id = client_task_state->m_completed_tasks[task_index].task_id; - if ((task_id <= 0) || (task_id >= MAXTASKS) || (p_task_data[task_id] == nullptr)) { + if ((task_id <= 0) || (task_id >= MAXTASKS) || (m_task_data[task_id] == nullptr)) { continue; } @@ -394,7 +394,7 @@ bool TaskManager::SaveClientState(Client *client, ClientTaskState *client_task_s std::string query = StringFormat( completed_task_query, character_id, - client_task_state->completed_tasks[task_index].completed_time, + client_task_state->m_completed_tasks[task_index].completed_time, task_id, -1 ); @@ -411,16 +411,16 @@ bool TaskManager::SaveClientState(Client *client, ClientTaskState *client_task_s } // Insert one record for each completed optional task. - for (int activity_id = 0; activity_id < p_task_data[task_id]->activity_count; activity_id++) { - if (!p_task_data[task_id]->activity_information[activity_id].optional || - !client_task_state->completed_tasks[task_index].activity_done[activity_id]) { + for (int activity_id = 0; activity_id < m_task_data[task_id]->activity_count; activity_id++) { + if (!m_task_data[task_id]->activity_information[activity_id].optional || + !client_task_state->m_completed_tasks[task_index].activity_done[activity_id]) { continue; } query = StringFormat( completed_task_query, character_id, - client_task_state->completed_tasks[task_index].completed_time, + client_task_state->m_completed_tasks[task_index].completed_time, task_id, activity_id ); @@ -431,7 +431,7 @@ bool TaskManager::SaveClientState(Client *client, ClientTaskState *client_task_s } } - client_task_state->last_completed_task_loaded = client_task_state->completed_tasks.size(); + client_task_state->m_last_completed_task_loaded = client_task_state->m_completed_tasks.size(); return true; } @@ -441,12 +441,12 @@ int TaskManager::FirstTaskInSet(int task_set) return 0; } - if (task_sets[task_set].empty()) { + if (m_task_sets[task_set].empty()) { return 0; } - auto iterator = task_sets[task_set].begin(); - while (iterator != task_sets[task_set].end()) { + auto iterator = m_task_sets[task_set].begin(); + while (iterator != m_task_sets[task_set].end()) { if ((*iterator) > 0) { return (*iterator); } @@ -462,11 +462,11 @@ int TaskManager::LastTaskInSet(int task_set) return 0; } - if (task_sets[task_set].empty()) { + if (m_task_sets[task_set].empty()) { return 0; } - return task_sets[task_set][task_sets[task_set].size() - 1]; + return m_task_sets[task_set][m_task_sets[task_set].size() - 1]; } int TaskManager::NextTaskInSet(int task_set, int task_id) @@ -475,11 +475,11 @@ int TaskManager::NextTaskInSet(int task_set, int task_id) return 0; } - if (task_sets[task_set].empty()) { + if (m_task_sets[task_set].empty()) { return 0; } - for (int i : task_sets[task_set]) { + for (int i : m_task_sets[task_set]) { if (i > task_id) { return i; } @@ -490,15 +490,15 @@ int TaskManager::NextTaskInSet(int task_set, int task_id) bool TaskManager::ValidateLevel(int task_id, int player_level) { - if (p_task_data[task_id] == nullptr) { + if (m_task_data[task_id] == nullptr) { return false; } - if (p_task_data[task_id]->min_level && (player_level < p_task_data[task_id]->min_level)) { + if (m_task_data[task_id]->min_level && (player_level < m_task_data[task_id]->min_level)) { return false; } - if (p_task_data[task_id]->max_level && (player_level > p_task_data[task_id]->max_level)) { + if (m_task_data[task_id]->max_level && (player_level > m_task_data[task_id]->max_level)) { return false; } @@ -508,8 +508,8 @@ bool TaskManager::ValidateLevel(int task_id, int player_level) std::string TaskManager::GetTaskName(uint32 task_id) { if (task_id > 0 && task_id < MAXTASKS) { - if (p_task_data[task_id] != nullptr) { - return p_task_data[task_id]->title; + if (m_task_data[task_id] != nullptr) { + return m_task_data[task_id]->title; } } @@ -519,8 +519,8 @@ std::string TaskManager::GetTaskName(uint32 task_id) TaskType TaskManager::GetTaskType(uint32 task_id) { if (task_id > 0 && task_id < MAXTASKS) { - if (p_task_data[task_id] != nullptr) { - return p_task_data[task_id]->type; + if (m_task_data[task_id] != nullptr) { + return m_task_data[task_id]->type; } } return TaskType::Task; @@ -535,14 +535,14 @@ void TaskManager::TaskSetSelector(Client *client, ClientTaskState *client_task_s LogTasks( "TaskSetSelector called for task_set_id [{}] EnableTaskSize is [{}]", task_set_id, - client_task_state->enabled_tasks.size() + client_task_state->m_enabled_tasks.size() ); if (task_set_id <= 0 || task_set_id >= MAXTASKSETS) { return; } - if (task_sets[task_set_id].empty()) { + if (m_task_sets[task_set_id].empty()) { // I think this is suppose to be yellow mob->SayString( client, @@ -556,22 +556,22 @@ void TaskManager::TaskSetSelector(Client *client, ClientTaskState *client_task_s bool all_enabled = false; // A task_id of 0 in a TaskSet indicates that all Tasks in the set are enabled for all players. - if (task_sets[task_set_id][0] == 0) { + if (m_task_sets[task_set_id][0] == 0) { LogTasks("[TaskSetSelector] TaskSets[{}][0] == 0. All Tasks in Set enabled.", task_set_id); all_enabled = true; } - auto iterator = task_sets[task_set_id].begin(); + auto iterator = m_task_sets[task_set_id].begin(); if (all_enabled) { ++iterator; } // skip first when all enabled since it's useless data - while (iterator != task_sets[task_set_id].end() && task_list_index < MAXCHOOSERENTRIES) { + while (iterator != m_task_sets[task_set_id].end() && task_list_index < MAXCHOOSERENTRIES) { auto task = *iterator; // verify level, we're not currently on it, repeatable status, if it's a (shared) task // we aren't currently on another, and if it's enabled if not all_enabled if ((all_enabled || client_task_state->IsTaskEnabled(task)) && ValidateLevel(task, player_level) && - !client_task_state->IsTaskActive(task) && client_task_state->HasSlotForTask(p_task_data[task]) && + !client_task_state->IsTaskActive(task) && client_task_state->HasSlotForTask(m_task_data[task]) && // this slot checking is a bit silly, but we allow mixing of task types ... (IsTaskRepeatable(task) || !client_task_state->IsTaskCompleted(task))) { task_list[task_list_index++] = task; @@ -619,7 +619,7 @@ void TaskManager::TaskQuestSetSelector( // verify level, we're not currently on it, repeatable status, if it's a (shared) task // we aren't currently on another, and if it's enabled if not all_enabled if (ValidateLevel(task, player_level) && !client_task_state->IsTaskActive(task) && - client_task_state->HasSlotForTask(p_task_data[task]) && + client_task_state->HasSlotForTask(m_task_data[task]) && // this slot checking is a bit silly, but we allow mixing of task types ... (IsTaskRepeatable(task) || !client_task_state->IsTaskCompleted(task))) { task_list[task_list_index++] = task; @@ -653,7 +653,7 @@ void TaskManager::SendTaskSelector(Client *client, Mob *mob, int task_count, int // Check if any of the tasks exist for (int i = 0; i < task_count; i++) { - if (p_task_data[task_list[i]] != nullptr) { + if (m_task_data[task_list[i]] != nullptr) { break; } } @@ -701,24 +701,24 @@ void TaskManager::SendTaskSelector(Client *client, Mob *mob, int task_count, int if (client->ClientVersion() != EQ::versions::ClientVersion::Titanium) { buf.WriteFloat(1.0f); } - buf.WriteUInt32(p_task_data[task_list[task_index]]->duration); - buf.WriteUInt32(static_cast(p_task_data[task_list[task_index]]->duration_code)); + buf.WriteUInt32(m_task_data[task_list[task_index]]->duration); + buf.WriteUInt32(static_cast(m_task_data[task_list[task_index]]->duration_code)); - buf.WriteString(p_task_data[task_list[task_index]]->title); // max 64 with null - buf.WriteString(p_task_data[task_list[task_index]]->description); // max 4000 with null + buf.WriteString(m_task_data[task_list[task_index]]->title); // max 64 with null + buf.WriteString(m_task_data[task_list[task_index]]->description); // max 4000 with null // Has reward set flag if (client->ClientVersion() != EQ::versions::ClientVersion::Titanium) { buf.WriteUInt8(0); } - buf.WriteUInt32(p_task_data[task_list[task_index]]->activity_count); + buf.WriteUInt32(m_task_data[task_list[task_index]]->activity_count); for (int activity_index = 0; - activity_index < p_task_data[task_list[task_index]]->activity_count; + activity_index < m_task_data[task_list[task_index]]->activity_count; ++activity_index) { buf.WriteUInt32(activity_index); // ActivityNumber - auto &activity = p_task_data[task_list[task_index]]->activity_information[activity_index]; + auto &activity = m_task_data[task_list[task_index]]->activity_information[activity_index]; buf.WriteUInt32(activity.activity_type); buf.WriteUInt32(0); // solo, group, raid? buf.WriteString(activity.target_name); // max length 64, "target name" so like loot x foo from bar (this is bar) @@ -745,7 +745,7 @@ void TaskManager::SendTaskSelectorNew(Client *client, Mob *mob, int task_count, // Check if any of the tasks exist for (int i = 0; i < task_count; i++) { - if (p_task_data[task_list[i]] != nullptr) { + if (m_task_data[task_list[i]] != nullptr) { break; } } @@ -790,18 +790,18 @@ void TaskManager::SendTaskSelectorNew(Client *client, Mob *mob, int task_count, buf.WriteUInt32(task_list[i]); // task_id buf.WriteFloat(1.0f); // affects color, difficulty? - buf.WriteUInt32(p_task_data[task_list[i]]->duration); - buf.WriteUInt32(static_cast(p_task_data[task_list[i]]->duration_code)); // 1 = Short, 2 = Medium, 3 = Long, anything else Unlimited + buf.WriteUInt32(m_task_data[task_list[i]]->duration); + buf.WriteUInt32(static_cast(m_task_data[task_list[i]]->duration_code)); // 1 = Short, 2 = Medium, 3 = Long, anything else Unlimited - buf.WriteString(p_task_data[task_list[i]]->title); // max 64 with null - buf.WriteString(p_task_data[task_list[i]]->description); // max 4000 with null + buf.WriteString(m_task_data[task_list[i]]->title); // max 64 with null + buf.WriteString(m_task_data[task_list[i]]->description); // max 4000 with null buf.WriteUInt8(0); // Has reward set flag - buf.WriteUInt32(p_task_data[task_list[i]]->activity_count); // activity_count + buf.WriteUInt32(m_task_data[task_list[i]]->activity_count); // activity_count - for (int j = 0; j < p_task_data[task_list[i]]->activity_count; ++j) { + for (int j = 0; j < m_task_data[task_list[i]]->activity_count; ++j) { buf.WriteUInt32(j); // ActivityNumber - auto &activity = p_task_data[task_list[i]]->activity_information[j]; + auto &activity = m_task_data[task_list[i]]->activity_information[j]; buf.WriteUInt32(activity.activity_type); // ActivityType buf.WriteUInt32(0); // solo, group, raid? buf.WriteString(activity.target_name); // max length 64, "target name" so like loot x foo from bar (this is bar) @@ -834,7 +834,7 @@ void TaskManager::SendTaskSelectorNew(Client *client, Mob *mob, int task_count, int TaskManager::GetActivityCount(int task_id) { if ((task_id > 0) && (task_id < MAXTASKS)) { - if (p_task_data[task_id]) { return p_task_data[task_id]->activity_count; } + if (m_task_data[task_id]) { return m_task_data[task_id]->activity_count; } } return 0; @@ -855,20 +855,20 @@ void TaskManager::ExplainTask(Client *client, int task_id) return; } - if (p_task_data[task_id] == nullptr) { + if (m_task_data[task_id] == nullptr) { client->Message(Chat::White, "Task does not exist."); return; } char explanation[1000], *ptr; - client->Message(Chat::White, "Task %4i: title: %s", task_id, p_task_data[task_id]->description.c_str()); - client->Message(Chat::White, "%3i Activities", p_task_data[task_id]->activity_count); + client->Message(Chat::White, "Task %4i: title: %s", task_id, m_task_data[task_id]->description.c_str()); + client->Message(Chat::White, "%3i Activities", m_task_data[task_id]->activity_count); ptr = explanation; - for (int i = 0; i < p_task_data[task_id]->activity_count; i++) { + for (int i = 0; i < m_task_data[task_id]->activity_count; i++) { sprintf(ptr, "Act: %3i: ", i); ptr = ptr + strlen(ptr); - switch (p_task_data[task_id]->activity_information[i].activity_type) { + switch (m_task_data[task_id]->activity_information[i].activity_type) { case ActivityDeliver: sprintf(ptr, "Deliver"); break; @@ -883,7 +883,7 @@ bool TaskManager::IsTaskRepeatable(int task_id) return false; } - TaskInformation *task_data = p_task_manager->p_task_data[task_id]; + TaskInformation *task_data = task_manager->m_task_data[task_id]; if (task_data == nullptr) { return false; } @@ -898,15 +898,15 @@ void TaskManager::SendCompletedTasksToClient(Client *c, ClientTaskState *client_ //vector::const_iterator iterator; // The client only display the first 50 Completed Tasks send, so send the 50 most recent int first_task_to_send = 0; - int last_task_to_send = client_task_state->completed_tasks.size(); + int last_task_to_send = client_task_state->m_completed_tasks.size(); - if (client_task_state->completed_tasks.size() > 50) { - first_task_to_send = client_task_state->completed_tasks.size() - 50; + if (client_task_state->m_completed_tasks.size() > 50) { + first_task_to_send = client_task_state->m_completed_tasks.size() - 50; } LogTasks( "[SendCompletedTasksToClient] completed task count [{}] first tank to send is [{}] last is [{}]", - client_task_state->completed_tasks.size(), + client_task_state->m_completed_tasks.size(), first_task_to_send, last_task_to_send ); @@ -919,9 +919,9 @@ void TaskManager::SendCompletedTasksToClient(Client *c, ClientTaskState *client_ } */ for (int i = first_task_to_send; i < last_task_to_send; i++) { - int TaskID = client_task_state->completed_tasks[i].task_id; - if (p_task_data[TaskID] == nullptr) { continue; } - packet_length = packet_length + 8 + p_task_data[TaskID]->title.size() + 1; + int TaskID = client_task_state->m_completed_tasks[i].task_id; + if (m_task_data[TaskID] == nullptr) { continue; } + packet_length = packet_length + 8 + m_task_data[TaskID]->title.size() + 1; } auto outapp = new EQApplicationPacket(OP_CompletedTasks, packet_length); @@ -933,15 +933,15 @@ void TaskManager::SendCompletedTasksToClient(Client *c, ClientTaskState *client_ //for(iterator=activity_state->CompletedTasks.begin(); iterator!=activity_state->CompletedTasks.end(); iterator++) { // int task_id = (*iterator).task_id; for (int i = first_task_to_send; i < last_task_to_send; i++) { - int task_id = client_task_state->completed_tasks[i].task_id; - if (p_task_data[task_id] == nullptr) { continue; } + int task_id = client_task_state->m_completed_tasks[i].task_id; + if (m_task_data[task_id] == nullptr) { continue; } *(uint32 *) buf = task_id; buf = buf + 4; - sprintf(buf, "%s", p_task_data[task_id]->title.c_str()); + sprintf(buf, "%s", m_task_data[task_id]->title.c_str()); buf = buf + strlen(buf) + 1; //*(uint32 *)buf = (*iterator).CompletedTime; - *(uint32 *) buf = client_task_state->completed_tasks[i].completed_time; + *(uint32 *) buf = client_task_state->m_completed_tasks[i].completed_time; buf = buf + 4; } @@ -958,7 +958,7 @@ void TaskManager::SendTaskActivityShort(Client *client, int task_id, int activit if (client->ClientVersionBit() & EQ::versions::maskRoFAndLater) { auto outapp = new EQApplicationPacket(OP_TaskActivity, 25); outapp->WriteUInt32(client_task_index); - outapp->WriteUInt32(static_cast(p_task_data[task_id]->type)); + outapp->WriteUInt32(static_cast(m_task_data[task_id]->type)); outapp->WriteUInt32(task_id); outapp->WriteUInt32(activity_id); outapp->WriteUInt32(0); @@ -973,7 +973,7 @@ void TaskManager::SendTaskActivityShort(Client *client, int task_id, int activit task_activity_short = (TaskActivityShort_Struct *) outapp->pBuffer; task_activity_short->TaskSequenceNumber = client_task_index; - task_activity_short->unknown2 = static_cast(p_task_data[task_id]->type); + task_activity_short->unknown2 = static_cast(m_task_data[task_id]->type); task_activity_short->TaskID = task_id; task_activity_short->ActivityID = activity_id; task_activity_short->unknown3 = 0x000000; @@ -1002,16 +1002,16 @@ void TaskManager::SendTaskActivityLong( SerializeBuffer buf(100); buf.WriteUInt32(client_task_index); - buf.WriteUInt32(static_cast(p_task_data[task_id]->type)); + buf.WriteUInt32(static_cast(m_task_data[task_id]->type)); buf.WriteUInt32(task_id); buf.WriteUInt32(activity_id); buf.WriteUInt32(0); // unknown3 // We send our 'internal' types as ActivityCastOn. text3 should be set to the activity_information description, so it makes // no difference to the client. All activity_information updates will be done based on our interal activity_information types. - if ((p_task_data[task_id]->activity_information[activity_id].activity_type > 0) && - p_task_data[task_id]->activity_information[activity_id].activity_type < 100) { - buf.WriteUInt32(p_task_data[task_id]->activity_information[activity_id].activity_type); + if ((m_task_data[task_id]->activity_information[activity_id].activity_type > 0) && + m_task_data[task_id]->activity_information[activity_id].activity_type < 100) { + buf.WriteUInt32(m_task_data[task_id]->activity_information[activity_id].activity_type); } else { buf.WriteUInt32(ActivityCastOn); @@ -1020,11 +1020,11 @@ void TaskManager::SendTaskActivityLong( buf.WriteUInt32(optional); buf.WriteUInt32(0); // solo, group, raid - buf.WriteString(p_task_data[task_id]->activity_information[activity_id].target_name); // target name string - buf.WriteString(p_task_data[task_id]->activity_information[activity_id].item_list); // item name list + buf.WriteString(m_task_data[task_id]->activity_information[activity_id].target_name); // target name string + buf.WriteString(m_task_data[task_id]->activity_information[activity_id].item_list); // item name list - if (p_task_data[task_id]->activity_information[activity_id].activity_type != ActivityGiveCash) { - buf.WriteUInt32(p_task_data[task_id]->activity_information[activity_id].goal_count); + if (m_task_data[task_id]->activity_information[activity_id].activity_type != ActivityGiveCash) { + buf.WriteUInt32(m_task_data[task_id]->activity_information[activity_id].goal_count); } else { // For our internal type GiveCash, where the goal count has the amount of cash that must be given, @@ -1034,22 +1034,22 @@ void TaskManager::SendTaskActivityLong( buf.WriteUInt32(1); } - buf.WriteUInt32(p_task_data[task_id]->activity_information[activity_id].skill_id); - buf.WriteUInt32(p_task_data[task_id]->activity_information[activity_id].spell_id); + buf.WriteUInt32(m_task_data[task_id]->activity_information[activity_id].skill_id); + buf.WriteUInt32(m_task_data[task_id]->activity_information[activity_id].spell_id); buf.WriteUInt32( - p_task_data[task_id]->activity_information[activity_id].zone_ids.empty() ? 0 - : p_task_data[task_id]->activity_information[activity_id].zone_ids.front()); + m_task_data[task_id]->activity_information[activity_id].zone_ids.empty() ? 0 + : m_task_data[task_id]->activity_information[activity_id].zone_ids.front()); buf.WriteUInt32(0); - buf.WriteString(p_task_data[task_id]->activity_information[activity_id].description_override); + buf.WriteString(m_task_data[task_id]->activity_information[activity_id].description_override); - if (p_task_data[task_id]->activity_information[activity_id].activity_type != ActivityGiveCash) { - buf.WriteUInt32(client->GetTaskActivityDoneCount(p_task_data[task_id]->type, client_task_index, activity_id)); + if (m_task_data[task_id]->activity_information[activity_id].activity_type != ActivityGiveCash) { + buf.WriteUInt32(client->GetTaskActivityDoneCount(m_task_data[task_id]->type, client_task_index, activity_id)); } else { // For internal activity_information types, done_count is either 1 if the activity_information is complete, 0 otherwise. - buf.WriteUInt32((client->GetTaskActivityDoneCount(p_task_data[task_id]->type, client_task_index, activity_id) >= - p_task_data[task_id]->activity_information[activity_id].goal_count)); + buf.WriteUInt32((client->GetTaskActivityDoneCount(m_task_data[task_id]->type, client_task_index, activity_id) >= + m_task_data[task_id]->activity_information[activity_id].goal_count)); } buf.WriteUInt32(1); // unknown @@ -1074,16 +1074,16 @@ void TaskManager::SendTaskActivityNew( SerializeBuffer buf(100); buf.WriteUInt32(client_task_index); // TaskSequenceNumber - buf.WriteUInt32(static_cast(p_task_data[task_id]->type)); // task type + buf.WriteUInt32(static_cast(m_task_data[task_id]->type)); // task type buf.WriteUInt32(task_id); buf.WriteUInt32(activity_id); buf.WriteUInt32(0); // unknown3 // We send our 'internal' types as ActivityCastOn. text3 should be set to the activity_information description, so it makes // no difference to the client. All activity_information updates will be done based on our interal activity_information types. - if ((p_task_data[task_id]->activity_information[activity_id].activity_type > 0) && - p_task_data[task_id]->activity_information[activity_id].activity_type < 100) { - buf.WriteUInt32(p_task_data[task_id]->activity_information[activity_id].activity_type); + if ((m_task_data[task_id]->activity_information[activity_id].activity_type > 0) && + m_task_data[task_id]->activity_information[activity_id].activity_type < 100) { + buf.WriteUInt32(m_task_data[task_id]->activity_information[activity_id].activity_type); } else { buf.WriteUInt32(ActivityCastOn); @@ -1093,46 +1093,46 @@ void TaskManager::SendTaskActivityNew( buf.WriteUInt32(0); // solo, group, raid // One of these unknown fields maybe related to the 'Use On' activity_information types - buf.WriteString(p_task_data[task_id]->activity_information[activity_id].target_name); // target name string + buf.WriteString(m_task_data[task_id]->activity_information[activity_id].target_name); // target name string - buf.WriteLengthString(p_task_data[task_id]->activity_information[activity_id].item_list); // item name list + buf.WriteLengthString(m_task_data[task_id]->activity_information[activity_id].item_list); // item name list // Goal Count - if (p_task_data[task_id]->activity_information[activity_id].activity_type != ActivityGiveCash) { - buf.WriteUInt32(p_task_data[task_id]->activity_information[activity_id].goal_count); + if (m_task_data[task_id]->activity_information[activity_id].activity_type != ActivityGiveCash) { + buf.WriteUInt32(m_task_data[task_id]->activity_information[activity_id].goal_count); } else { buf.WriteUInt32(1); } // GoalCount // skill ID list ; separated - buf.WriteLengthString(p_task_data[task_id]->activity_information[activity_id].skill_list); + buf.WriteLengthString(m_task_data[task_id]->activity_information[activity_id].skill_list); // spelll ID list ; separated -- unsure wtf we're doing here - buf.WriteLengthString(p_task_data[task_id]->activity_information[activity_id].spell_list); + buf.WriteLengthString(m_task_data[task_id]->activity_information[activity_id].spell_list); - buf.WriteString(p_task_data[task_id]->activity_information[activity_id].zones); + buf.WriteString(m_task_data[task_id]->activity_information[activity_id].zones); buf.WriteUInt32(0); // unknown7 - buf.WriteString(p_task_data[task_id]->activity_information[activity_id].description_override); // description override + buf.WriteString(m_task_data[task_id]->activity_information[activity_id].description_override); // description override - if (p_task_data[task_id]->activity_information[activity_id].activity_type != ActivityGiveCash) { + if (m_task_data[task_id]->activity_information[activity_id].activity_type != ActivityGiveCash) { buf.WriteUInt32( client->GetTaskActivityDoneCount( - p_task_data[task_id]->type, + m_task_data[task_id]->type, client_task_index, activity_id )); // done_count } else { // For internal activity_information types, done_count is either 1 if the activity_information is complete, 0 otherwise. - buf.WriteUInt32((client->GetTaskActivityDoneCount(p_task_data[task_id]->type, client_task_index, activity_id) >= - p_task_data[task_id]->activity_information[activity_id].goal_count)); + buf.WriteUInt32((client->GetTaskActivityDoneCount(m_task_data[task_id]->type, client_task_index, activity_id) >= + m_task_data[task_id]->activity_information[activity_id].goal_count)); } buf.WriteUInt8(1); // unknown9 - buf.WriteString(p_task_data[task_id]->activity_information[activity_id].zones); + buf.WriteString(m_task_data[task_id]->activity_information[activity_id].zones); auto outapp = new EQApplicationPacket(OP_TaskActivity, buf); @@ -1149,22 +1149,22 @@ void TaskManager::SendActiveTasksToClient(Client *client, bool task_complete) } for (int task_index = 0; task_index < MAXACTIVEQUESTS + 1; task_index++) { - int task_id = state->active_tasks[task_index].task_id; - if ((task_id == 0) || (p_task_data[task_id] == 0)) { + int task_id = state->m_active_tasks[task_index].task_id; + if ((task_id == 0) || (m_task_data[task_id] == 0)) { continue; } - int start_time = state->active_tasks[task_index].accepted_time; + int start_time = state->m_active_tasks[task_index].accepted_time; SendActiveTaskDescription( - client, task_id, state->active_tasks[task_index], start_time, p_task_data[task_id]->duration, + client, task_id, state->m_active_tasks[task_index], start_time, m_task_data[task_id]->duration, false ); LogTasks("[SendActiveTasksToClient] task_id [{}] activity_count [{}]", task_id, GetActivityCount(task_id)); int sequence = 0; - int fixed_index = p_task_data[task_id]->type == TaskType::Task ? 0 : task_index - 1; // hmmm fuck + int fixed_index = m_task_data[task_id]->type == TaskType::Task ? 0 : task_index - 1; // hmmm fuck for (int activity_id = 0; activity_id < GetActivityCount(task_id); activity_id++) { - if (client->GetTaskActivityState(p_task_data[task_id]->type, fixed_index, activity_id) != ActivityHidden) { + if (client->GetTaskActivityState(m_task_data[task_id]->type, fixed_index, activity_id) != ActivityHidden) { LogTasks( "[SendActiveTasksToClient] (Long Update) task_id [{}] activity_id [{}] fixed_index [{}] task_complete [{}]", task_id, @@ -1179,7 +1179,7 @@ void TaskManager::SendActiveTasksToClient(Client *client, bool task_complete) task_id, activity_id, fixed_index, - p_task_data[task_id]->activity_information[activity_id].optional, + m_task_data[task_id]->activity_information[activity_id].optional, task_complete ); } @@ -1189,7 +1189,7 @@ void TaskManager::SendActiveTasksToClient(Client *client, bool task_complete) task_id, activity_id, fixed_index, - p_task_data[task_id]->activity_information[activity_id].optional, + m_task_data[task_id]->activity_information[activity_id].optional, 0 ); } @@ -1215,7 +1215,7 @@ void TaskManager::SendSingleActiveTaskToClient( ) { int task_id = task_info.task_id; - if (task_id == 0 || p_task_data[task_id] == nullptr) { + if (task_id == 0 || m_task_data[task_id] == nullptr) { return; } @@ -1225,7 +1225,7 @@ void TaskManager::SendSingleActiveTaskToClient( task_id, task_info, start_time, - p_task_data[task_id]->duration, + m_task_data[task_id]->duration, bring_up_task_journal ); Log(Logs::General, @@ -1243,13 +1243,13 @@ void TaskManager::SendSingleActiveTaskToClient( if (activity_id == GetActivityCount(task_id) - 1) { SendTaskActivityLong( client, task_id, activity_id, task_info.slot, - p_task_data[task_id]->activity_information[activity_id].optional, task_complete + m_task_data[task_id]->activity_information[activity_id].optional, task_complete ); } else { SendTaskActivityLong( client, task_id, activity_id, task_info.slot, - p_task_data[task_id]->activity_information[activity_id].optional, 0 + m_task_data[task_id]->activity_information[activity_id].optional, 0 ); } } @@ -1269,25 +1269,25 @@ void TaskManager::SendActiveTaskDescription( bool bring_up_task_journal ) { - if ((task_id < 1) || (task_id >= MAXTASKS) || !p_task_data[task_id]) { + if ((task_id < 1) || (task_id >= MAXTASKS) || !m_task_data[task_id]) { return; } - int packet_length = sizeof(TaskDescriptionHeader_Struct) + p_task_data[task_id]->title.length() + 1 - + sizeof(TaskDescriptionData1_Struct) + p_task_data[task_id]->description.length() + 1 + int packet_length = sizeof(TaskDescriptionHeader_Struct) + m_task_data[task_id]->title.length() + 1 + + sizeof(TaskDescriptionData1_Struct) + m_task_data[task_id]->description.length() + 1 + sizeof(TaskDescriptionData2_Struct) + 1 + sizeof(TaskDescriptionTrailer_Struct); // If there is an item make the reward text into a link to the item (only the first item if a list // is specified). I have been unable to get multiple item links to work. // - if (p_task_data[task_id]->reward_id && p_task_data[task_id]->item_link.empty()) { + if (m_task_data[task_id]->reward_id && m_task_data[task_id]->item_link.empty()) { int item_id = 0; // If the reward is a list of items, and the first entry on the list is valid - if (p_task_data[task_id]->reward_method == METHODSINGLEID) { - item_id = p_task_data[task_id]->reward_id; + if (m_task_data[task_id]->reward_method == METHODSINGLEID) { + item_id = m_task_data[task_id]->reward_id; } - else if (p_task_data[task_id]->reward_method == METHODLIST) { - item_id = goal_list_manager.GetFirstEntry(p_task_data[task_id]->reward_id); + else if (m_task_data[task_id]->reward_method == METHODLIST) { + item_id = m_goal_list_manager.GetFirstEntry(m_task_data[task_id]->reward_id); if (item_id < 0) { item_id = 0; } @@ -1300,11 +1300,11 @@ void TaskManager::SendActiveTaskDescription( linker.SetLinkType(EQ::saylink::SayLinkItemData); linker.SetItemData(reward_item); linker.SetTaskUse(); - p_task_data[task_id]->item_link = linker.GenerateLink(); + m_task_data[task_id]->item_link = linker.GenerateLink(); } } - packet_length += p_task_data[task_id]->reward.length() + 1 + p_task_data[task_id]->item_link.length() + 1; + packet_length += m_task_data[task_id]->reward.length() + 1 + m_task_data[task_id]->item_link.length() + 1; char *Ptr; TaskDescriptionHeader_Struct *task_description_header; @@ -1319,25 +1319,25 @@ void TaskManager::SendActiveTaskDescription( task_description_header->SequenceNumber = task_info.slot; task_description_header->TaskID = task_id; task_description_header->open_window = bring_up_task_journal; - task_description_header->task_type = static_cast(p_task_data[task_id]->type); + task_description_header->task_type = static_cast(m_task_data[task_id]->type); task_description_header->reward_type = 0; // TODO: 4 says Radiant Crystals else Ebon Crystals when shared task Ptr = (char *) task_description_header + sizeof(TaskDescriptionHeader_Struct); - sprintf(Ptr, "%s", p_task_data[task_id]->title.c_str()); - Ptr += p_task_data[task_id]->title.length() + 1; + sprintf(Ptr, "%s", m_task_data[task_id]->title.c_str()); + Ptr += m_task_data[task_id]->title.length() + 1; tdd1 = (TaskDescriptionData1_Struct *) Ptr; tdd1->Duration = duration; - tdd1->dur_code = static_cast(p_task_data[task_id]->duration_code); + tdd1->dur_code = static_cast(m_task_data[task_id]->duration_code); tdd1->StartTime = start_time; Ptr = (char *) tdd1 + sizeof(TaskDescriptionData1_Struct); - sprintf(Ptr, "%s", p_task_data[task_id]->description.c_str()); - Ptr += p_task_data[task_id]->description.length() + 1; + sprintf(Ptr, "%s", m_task_data[task_id]->description.c_str()); + Ptr += m_task_data[task_id]->description.length() + 1; tdd2 = (TaskDescriptionData2_Struct *) Ptr; @@ -1346,20 +1346,20 @@ void TaskManager::SendActiveTaskDescription( // "has_reward_selection" is after this bool! Smaller packet when this is 0 tdd2->has_rewards = 1; - tdd2->coin_reward = p_task_data[task_id]->cash_reward; - tdd2->xp_reward = p_task_data[task_id]->experience_reward ? 1 : 0; // just booled - tdd2->faction_reward = p_task_data[task_id]->faction_reward ? 1 : 0; // faction booled + tdd2->coin_reward = m_task_data[task_id]->cash_reward; + tdd2->xp_reward = m_task_data[task_id]->experience_reward ? 1 : 0; // just booled + tdd2->faction_reward = m_task_data[task_id]->faction_reward ? 1 : 0; // faction booled Ptr = (char *) tdd2 + sizeof(TaskDescriptionData2_Struct); // we actually have 2 strings here. One is max length 96 and not parsed for item links // We actually skipped past that string incorrectly before, so TODO: fix item link string - sprintf(Ptr, "%s", p_task_data[task_id]->reward.c_str()); - Ptr += p_task_data[task_id]->reward.length() + 1; + sprintf(Ptr, "%s", m_task_data[task_id]->reward.c_str()); + Ptr += m_task_data[task_id]->reward.length() + 1; // second string is parsed for item links - sprintf(Ptr, "%s", p_task_data[task_id]->item_link.c_str()); - Ptr += p_task_data[task_id]->item_link.length() + 1; + sprintf(Ptr, "%s", m_task_data[task_id]->item_link.c_str()); + Ptr += m_task_data[task_id]->item_link.length() + 1; tdt = (TaskDescriptionTrailer_Struct *) Ptr; tdt->Points = 0x00000000; // Points Count TODO: this does have a visible affect on the client ... @@ -1377,7 +1377,7 @@ bool TaskManager::LoadClientState(Client *client, ClientTaskState *client_task_s int character_id = client->CharacterID(); - client_task_state->active_task_count = 0; + client_task_state->m_active_task_count = 0; LogTasks("[LoadClientState] for character_id [{}]", character_id); @@ -1424,7 +1424,7 @@ bool TaskManager::LoadClientState(Client *client, ClientTaskState *client_task_s } if (type == TaskType::Quest) { - ++client_task_state->active_task_count; + ++client_task_state->m_active_task_count; } LogTasks( @@ -1466,13 +1466,13 @@ bool TaskManager::LoadClientState(Client *client, ClientTaskState *client_task_s } ClientTaskInformation *task_info = nullptr; - if (client_task_state->active_task.task_id == task_id) { - task_info = &client_task_state->active_task; + if (client_task_state->m_active_task.task_id == task_id) { + task_info = &client_task_state->m_active_task; } // wasn't task if (task_info == nullptr) { - for (auto &active_quest : client_task_state->active_quests) { + for (auto &active_quest : client_task_state->m_active_quests) { if (active_quest.task_id == task_id) { task_info = &active_quest; } @@ -1547,7 +1547,7 @@ bool TaskManager::LoadClientState(Client *client, ClientTaskState *client_task_s int completed_time = character_completed_task.completedtime; if ((previous_task_id != -1) && ((task_id != previous_task_id) || (completed_time != previous_completed_time))) { - client_task_state->completed_tasks.push_back(completed_task_information); + client_task_state->m_completed_tasks.push_back(completed_task_information); for (bool &activity_done : completed_task_information.activity_done) { activity_done = false; } @@ -1558,7 +1558,7 @@ bool TaskManager::LoadClientState(Client *client, ClientTaskState *client_task_s // If activity_id is -1, Mark all the non-optional tasks as completed. if (activity_id < 0) { - TaskInformation *task = p_task_data[task_id]; + TaskInformation *task = m_task_data[task_id]; if (task == nullptr) { continue; } @@ -1575,10 +1575,10 @@ bool TaskManager::LoadClientState(Client *client, ClientTaskState *client_task_s } if (previous_task_id != -1) { - client_task_state->completed_tasks.push_back(completed_task_information); + client_task_state->m_completed_tasks.push_back(completed_task_information); } - client_task_state->last_completed_task_loaded = client_task_state->completed_tasks.size(); + client_task_state->m_last_completed_task_loaded = client_task_state->m_completed_tasks.size(); } std::string query = StringFormat( @@ -1592,7 +1592,7 @@ bool TaskManager::LoadClientState(Client *client, ClientTaskState *client_task_s if (results.Success()) { for (auto row = results.begin(); row != results.end(); ++row) { int task_id = atoi(row[0]); - client_task_state->enabled_tasks.push_back(task_id); + client_task_state->m_enabled_tasks.push_back(task_id); LogTasksDetail("[LoadClientState] Adding task_id [{}] to enabled tasks", task_id); } } @@ -1601,11 +1601,11 @@ bool TaskManager::LoadClientState(Client *client, ClientTaskState *client_task_s // This should only break if a ServerOP adds or deletes activites for a task that players already // have active, or due to a bug. for (int task_index = 0; task_index < MAXACTIVEQUESTS + 1; task_index++) { - int task_id = client_task_state->active_tasks[task_index].task_id; + int task_id = client_task_state->m_active_tasks[task_index].task_id; if (task_id == TASKSLOTEMPTY) { continue; } - if (!p_task_data[task_id]) { + if (!m_task_data[task_id]) { client->Message( Chat::Red, "Active Task Slot %i, references a task (%i), that does not exist. " @@ -1615,16 +1615,16 @@ bool TaskManager::LoadClientState(Client *client, ClientTaskState *client_task_s ); LogError("[LoadClientState] Character [{}] has task [{}] which does not exist", character_id, task_id); - client_task_state->active_tasks[task_index].task_id = TASKSLOTEMPTY; + client_task_state->m_active_tasks[task_index].task_id = TASKSLOTEMPTY; continue; } - for (int activity_index = 0; activity_index < p_task_data[task_id]->activity_count; activity_index++) { - if (client_task_state->active_tasks[task_index].activity[activity_index].activity_id != activity_index) { + for (int activity_index = 0; activity_index < m_task_data[task_id]->activity_count; activity_index++) { + if (client_task_state->m_active_tasks[task_index].activity[activity_index].activity_id != activity_index) { client->Message( Chat::Red, "Active Task %i, %s. activity_information count does not match expected value." "Removing from memory. Contact a GM to resolve this.", - task_id, p_task_data[task_id]->title.c_str() + task_id, m_task_data[task_id]->title.c_str() ); LogTasks( @@ -1633,18 +1633,18 @@ bool TaskManager::LoadClientState(Client *client, ClientTaskState *client_task_s activity_index, task_id ); - client_task_state->active_tasks[task_index].task_id = TASKSLOTEMPTY; + client_task_state->m_active_tasks[task_index].task_id = TASKSLOTEMPTY; break; } } } - if (client_task_state->active_task.task_id != TASKSLOTEMPTY) { - client_task_state->UnlockActivities(character_id, client_task_state->active_task); + if (client_task_state->m_active_task.task_id != TASKSLOTEMPTY) { + client_task_state->UnlockActivities(character_id, client_task_state->m_active_task); } // TODO: shared - for (auto &active_quest : client_task_state->active_quests) { + for (auto &active_quest : client_task_state->m_active_quests) { if (active_quest.task_id != TASKSLOTEMPTY) { client_task_state->UnlockActivities(character_id, active_quest); } diff --git a/zone/task_manager.h b/zone/task_manager.h index 83994a058..f1fe41bd9 100644 --- a/zone/task_manager.h +++ b/zone/task_manager.h @@ -25,7 +25,7 @@ public: void ReloadGoalLists(); inline void LoadProximities(int zone_id) { - proximity_manager.LoadProximities(zone_id); + m_proximity_manager.LoadProximities(zone_id); } bool LoadTaskSets(); bool LoadClientState(Client *client, ClientTaskState *client_task_state); @@ -79,10 +79,10 @@ public: private: - TaskGoalListManager goal_list_manager; - TaskProximityManager proximity_manager; - TaskInformation *p_task_data[MAXTASKS]{}; - std::vector task_sets[MAXTASKSETS]; + TaskGoalListManager m_goal_list_manager; + TaskProximityManager m_proximity_manager; + TaskInformation *m_task_data[MAXTASKS]{}; + std::vector m_task_sets[MAXTASKSETS]; void SendActiveTaskDescription( Client *client, int task_id, diff --git a/zone/tasks.cpp b/zone/tasks.cpp index c1c4cbceb..4f240bab5 100644 --- a/zone/tasks.cpp +++ b/zone/tasks.cpp @@ -12,18 +12,18 @@ extern QueryServ *QServ; void Client::LoadClientTaskState() { - if (RuleB(TaskSystem, EnableTaskSystem) && p_task_manager) { + if (RuleB(TaskSystem, EnableTaskSystem) && task_manager) { if (task_state) { safe_delete(task_state); } task_state = new ClientTaskState; - if (!p_task_manager->LoadClientState(this, task_state)) { + if (!task_manager->LoadClientState(this, task_state)) { safe_delete(task_state); } else { - p_task_manager->SendActiveTasksToClient(this); - p_task_manager->SendCompletedTasksToClient(this, task_state); + task_manager->SendActiveTasksToClient(this); + task_manager->SendCompletedTasksToClient(this, task_state); } } } diff --git a/zone/worldserver.cpp b/zone/worldserver.cpp index 5540d89ec..76b00398e 100644 --- a/zone/worldserver.cpp +++ b/zone/worldserver.cpp @@ -3100,16 +3100,16 @@ void WorldServer::HandleReloadTasks(ServerPacket *pack) if (rts->Parameter == 0) { Log(Logs::General, Logs::Tasks, "[GLOBALLOAD] Reload ALL tasks"); - safe_delete(p_task_manager); - p_task_manager = new TaskManager; - p_task_manager->LoadTasks(); + safe_delete(task_manager); + task_manager = new TaskManager; + task_manager->LoadTasks(); if (zone) - p_task_manager->LoadProximities(zone->GetZoneID()); + task_manager->LoadProximities(zone->GetZoneID()); entity_list.ReloadAllClientsTaskState(); } else { Log(Logs::General, Logs::Tasks, "[GLOBALLOAD] Reload only task %i", rts->Parameter); - p_task_manager->LoadTasks(rts->Parameter); + task_manager->LoadTasks(rts->Parameter); entity_list.ReloadAllClientsTaskState(rts->Parameter); } @@ -3118,18 +3118,18 @@ void WorldServer::HandleReloadTasks(ServerPacket *pack) case RELOADTASKPROXIMITIES: if (zone) { Log(Logs::General, Logs::Tasks, "[GLOBALLOAD] Reload task proximities"); - p_task_manager->LoadProximities(zone->GetZoneID()); + task_manager->LoadProximities(zone->GetZoneID()); } break; case RELOADTASKGOALLISTS: Log(Logs::General, Logs::Tasks, "[GLOBALLOAD] Reload task goal lists"); - p_task_manager->ReloadGoalLists(); + task_manager->ReloadGoalLists(); break; case RELOADTASKSETS: Log(Logs::General, Logs::Tasks, "[GLOBALLOAD] Reload task sets"); - p_task_manager->LoadTaskSets(); + task_manager->LoadTaskSets(); break; default: diff --git a/zone/zone.cpp b/zone/zone.cpp index f088c6cee..2e29e8eec 100755 --- a/zone/zone.cpp +++ b/zone/zone.cpp @@ -964,7 +964,7 @@ Zone::Zone(uint32 in_zoneid, uint32 in_instanceid, const char* in_short_name) lootvar = 0; if(RuleB(TaskSystem, EnableTaskSystem)) { - p_task_manager->LoadProximities(zoneid); + task_manager->LoadProximities(zoneid); } short_name = strcpy(new char[strlen(in_short_name)+1], in_short_name);