From b7983d4c200fc1b713b8adc88fa62513b0dbc901 Mon Sep 17 00:00:00 2001 From: Akkadius Date: Sat, 6 Feb 2021 00:45:13 -0600 Subject: [PATCH] First pass --- zone/bot_command.cpp | 2 +- zone/client.cpp | 4 +- zone/client.h | 283 +++- zone/client_packet.cpp | 12 +- zone/client_process.cpp | 4 +- zone/command.cpp | 2 +- zone/entity.cpp | 6 +- zone/main.cpp | 10 +- zone/questmgr.cpp | 28 +- zone/tasks.cpp | 3343 ++++++++++++++++++++++----------------- zone/tasks.h | 292 ++-- zone/worldserver.cpp | 16 +- zone/zone.cpp | 2 +- 13 files changed, 2334 insertions(+), 1670 deletions(-) diff --git a/zone/bot_command.cpp b/zone/bot_command.cpp index 1dcebe5fc..f7dbdd972 100644 --- a/zone/bot_command.cpp +++ b/zone/bot_command.cpp @@ -76,7 +76,7 @@ extern QueryServ* QServ; extern WorldServer worldserver; -extern TaskManager *taskmanager; +extern TaskManager *p_task_manager; void CatchSignal(int sig_num); diff --git a/zone/client.cpp b/zone/client.cpp index 1f1ab10b9..22bdb333e 100644 --- a/zone/client.cpp +++ b/zone/client.cpp @@ -258,7 +258,7 @@ Client::Client(EQStreamInterface* ieqs) tgb = false; tribute_master_id = 0xFFFFFFFF; tribute_timer.Disable(); - taskstate = nullptr; + task_state = nullptr; TotalSecondsPlayed = 0; keyring.clear(); bind_sight_target = nullptr; @@ -452,7 +452,7 @@ Client::~Client() { // will need this data right away Save(2); // This fails when database destructor is called first on shutdown - safe_delete(taskstate); + safe_delete(task_state); safe_delete(KarmaUpdateTimer); safe_delete(GlobalChatLimiterTimer); safe_delete(qGlobals); diff --git a/zone/client.h b/zone/client.h index cc461bc22..41b384cdc 100644 --- a/zone/client.h +++ b/zone/client.h @@ -86,7 +86,7 @@ namespace EQ #define XTARGET_HARDCAP 20 extern Zone* zone; -extern TaskManager *taskmanager; +extern TaskManager *p_task_manager; class CLIENTPACKET { @@ -1006,7 +1006,7 @@ public: uint32 GetSpellIDByBookSlot(int book_slot); int GetNextAvailableSpellBookSlot(int starting_slot = 0); inline uint32 GetSpellByBookSlot(int book_slot) { return m_pp.spell_book[book_slot]; } - inline bool HasSpellScribed(int spellid) { return (FindSpellBookSlotBySpellID(spellid) != -1 ? true : false); } + inline bool HasSpellScribed(int spellid) { return FindSpellBookSlotBySpellID(spellid) != -1; } uint16 GetMaxSkillAfterSpecializationRules(EQ::skills::SkillType skillid, uint16 maxSkill); void SendPopupToClient(const char *Title, const char *Text, uint32 PopupID = 0, uint32 Buttons = 0, uint32 Duration = 0); void SendFullPopup(const char *Title, const char *Text, uint32 PopupID = 0, uint32 NegativeID = 0, uint32 Buttons = 0, uint32 Duration = 0, const char *ButtonName0 = 0, const char *ButtonName1 = 0, uint32 SoundControls = 0); @@ -1021,48 +1021,241 @@ public: // Task System Methods void LoadClientTaskState(); void RemoveClientTaskState(); - void SendTaskActivityComplete(int TaskID, int ActivityID, int TaskIndex, TaskType type, int TaskIncomplete=1); - void SendTaskFailed(int TaskID, int TaskIndex, TaskType type); - void SendTaskComplete(int TaskIndex); - inline ClientTaskState *GetTaskState() const { return taskstate; } - - inline void CancelTask(int TaskIndex, TaskType type) { if(taskstate) taskstate->CancelTask(this, TaskIndex, type); } - inline bool SaveTaskState() { return (taskmanager ? taskmanager->SaveClientState(this, taskstate) : false); } - inline bool IsTaskStateLoaded() { return taskstate != nullptr; } - inline bool IsTaskActive(int TaskID) { return (taskstate ? taskstate->IsTaskActive(TaskID) : false); } - inline bool IsTaskActivityActive(int TaskID, int ActivityID) { return (taskstate ? taskstate->IsTaskActivityActive(TaskID, ActivityID) : false); } - inline ActivityState GetTaskActivityState(TaskType type, int index, int ActivityID) { return (taskstate ? taskstate->GetTaskActivityState(type, index, ActivityID) : ActivityHidden); } - inline void UpdateTaskActivity(int TaskID, int ActivityID, int Count, bool ignore_quest_update = false) { if (taskstate) taskstate->UpdateTaskActivity(this, TaskID, ActivityID, Count, ignore_quest_update); } - inline void RemoveTaskByTaskID(uint32 task_id) { if (taskstate) taskstate->RemoveTaskByTaskID(this, task_id); } - inline void ResetTaskActivity(int TaskID, int ActivityID) { if(taskstate) taskstate->ResetTaskActivity(this, TaskID, ActivityID); } - inline void UpdateTasksOnKill(int NPCTypeID) { if(taskstate) taskstate->UpdateTasksOnKill(this, NPCTypeID); } - inline void UpdateTasksForItem(ActivityType Type, int ItemID, int Count=1) { if(taskstate) taskstate->UpdateTasksForItem(this, Type, ItemID, Count); } - inline void UpdateTasksOnExplore(int ExploreID) { if(taskstate) taskstate->UpdateTasksOnExplore(this, ExploreID); } - inline bool UpdateTasksOnSpeakWith(int NPCTypeID) { if(taskstate) return taskstate->UpdateTasksOnSpeakWith(this, NPCTypeID); else return false; } - inline bool UpdateTasksOnDeliver(std::list& Items, int Cash, int NPCTypeID) { if (taskstate) return taskstate->UpdateTasksOnDeliver(this, Items, Cash, NPCTypeID); else return false; } - inline void TaskSetSelector(Mob *mob, int TaskSetID) { if(taskmanager) taskmanager->TaskSetSelector(this, taskstate, mob, TaskSetID); } - inline void TaskQuestSetSelector(Mob *mob, int count, int *tasks) { if(taskmanager) taskmanager->TaskQuestSetSelector(this, taskstate, mob, count, tasks); } - inline void EnableTask(int TaskCount, int *TaskList) { if(taskstate) taskstate->EnableTask(CharacterID(), TaskCount, TaskList); } - inline void DisableTask(int TaskCount, int *TaskList) { if(taskstate) taskstate->DisableTask(CharacterID(), TaskCount, TaskList); } - inline bool IsTaskEnabled(int TaskID) { return (taskstate ? taskstate->IsTaskEnabled(TaskID) : false); } - inline void ProcessTaskProximities(float X, float Y, float Z) { if(taskstate) taskstate->ProcessTaskProximities(this, X, Y, Z); } - inline void AssignTask(int TaskID, int NPCID, bool enforce_level_requirement = false) { if (taskstate) taskstate->AcceptNewTask(this, TaskID, NPCID, enforce_level_requirement); } - inline int ActiveSpeakTask(int NPCID) { if(taskstate) return taskstate->ActiveSpeakTask(NPCID); else return 0; } - inline int ActiveSpeakActivity(int NPCID, int TaskID) { if(taskstate) return taskstate->ActiveSpeakActivity(NPCID, TaskID); else return 0; } - inline void FailTask(int TaskID) { if(taskstate) taskstate->FailTask(this, TaskID); } - inline int TaskTimeLeft(int TaskID) { return (taskstate ? taskstate->TaskTimeLeft(TaskID) : 0); } - inline int EnabledTaskCount(int TaskSetID) { return (taskstate ? taskstate->EnabledTaskCount(TaskSetID) : -1); } - inline int IsTaskCompleted(int TaskID) { return (taskstate ? taskstate->IsTaskCompleted(TaskID) : -1); } - inline void ShowClientTasks() { if(taskstate) taskstate->ShowClientTasks(this); } - inline void CancelAllTasks() { if(taskstate) taskstate->CancelAllTasks(this); } - inline int GetActiveTaskCount() { return (taskstate ? taskstate->GetActiveTaskCount() : 0); } - inline int GetActiveTaskID(int index) { return (taskstate ? taskstate->GetActiveTaskID(index) : -1); } - inline int GetTaskStartTime(TaskType type, int index) { return (taskstate ? taskstate->GetTaskStartTime(type, index) : -1); } - inline bool IsTaskActivityCompleted(TaskType type, int index, int ActivityID) { return (taskstate ? taskstate->IsTaskActivityCompleted(type, index, ActivityID) : false); } - inline int GetTaskActivityDoneCount(TaskType type, int ClientTaskIndex, int ActivityID) { return (taskstate ? taskstate->GetTaskActivityDoneCount(type, ClientTaskIndex, ActivityID) :0); } - inline int GetTaskActivityDoneCountFromTaskID(int TaskID, int ActivityID) { return (taskstate ? taskstate->GetTaskActivityDoneCountFromTaskID(TaskID, ActivityID) :0); } - inline int ActiveTasksInSet(int TaskSet) { return (taskstate ? taskstate->ActiveTasksInSet(TaskSet) :0); } - inline int CompletedTasksInSet(int TaskSet) { return (taskstate ? taskstate->CompletedTasksInSet(TaskSet) :0); } + void SendTaskActivityComplete(int task_id, int activity_id, int task_index, TaskType task_type, int task_incomplete=1); + void SendTaskFailed(int task_id, int task_index, TaskType task_type); + void SendTaskComplete(int task_index); + inline ClientTaskState *GetTaskState() const { return task_state; } + inline void CancelTask(int TaskIndex, TaskType type) + { + if (task_state) { + task_state->CancelTask( + this, + TaskIndex, + type + ); + } + } + inline bool SaveTaskState() + { + return p_task_manager != nullptr && p_task_manager->SaveClientState(this, task_state); + } + inline bool IsTaskStateLoaded() { return task_state != nullptr; } + inline bool IsTaskActive(int TaskID) { return task_state != nullptr && task_state->IsTaskActive(TaskID); } + inline bool IsTaskActivityActive(int TaskID, int ActivityID) + { + return task_state != nullptr && + task_state->IsTaskActivityActive( + TaskID, + ActivityID + ); + } + inline ActivityState GetTaskActivityState(TaskType task_type, int index, int activity_id) + { + return (task_state ? task_state->GetTaskActivityState(task_type, index, activity_id) : ActivityHidden); + } + inline void UpdateTaskActivity( + int task_id, + int activity_id, + int count, + bool ignore_quest_update = false + ) + { + if (task_state) { + task_state->UpdateTaskActivity(this, task_id, activity_id, count, ignore_quest_update); + } + } + inline void RemoveTaskByTaskID(uint32 task_id) { + if (task_state) { + task_state->RemoveTaskByTaskID(this, task_id); + } + } + inline void ResetTaskActivity(int task_id, int activity_id) + { + if (task_state) { + task_state->ResetTaskActivity( + this, + task_id, + activity_id + ); + } + } + inline void UpdateTasksOnKill(int npc_type_id) + { + if (task_state) { + task_state->UpdateTasksOnKill( + this, + npc_type_id + ); + } + } + inline void UpdateTasksForItem( + ActivityType activity_type, + int item_id, + int count = 1 + ) + { + if (task_state) { + task_state->UpdateTasksForItem(this, activity_type, item_id, count); + } + } + inline void UpdateTasksOnExplore(int explore_id) + { + if (task_state) { + task_state->UpdateTasksOnExplore( + this, + explore_id + ); + } + } + inline bool UpdateTasksOnSpeakWith(int npc_type_id) + { + if (task_state) { + return task_state->UpdateTasksOnSpeakWith( + this, + npc_type_id + ); + } + else { return false; } + } + inline bool UpdateTasksOnDeliver( + std::list &items, + int cash, + int npc_type_id + ) + { + if (task_state) { + return task_state->UpdateTasksOnDeliver( + this, + items, + cash, + npc_type_id + ); + } + else { return false; } + } + inline void TaskSetSelector(Mob *mob, int task_set_id) + { + if (p_task_manager) { + p_task_manager->TaskSetSelector( + this, + task_state, + mob, + task_set_id + ); + } + } + inline void TaskQuestSetSelector(Mob *mob, int count, int *tasks) + { + if (p_task_manager) { + p_task_manager->TaskQuestSetSelector( + this, + task_state, + mob, + count, + tasks + ); + } + } + inline void EnableTask(int task_count, int *task_list) + { + if (task_state) { + task_state->EnableTask( + CharacterID(), + task_count, + task_list + ); + } + } + inline void DisableTask(int task_count, int *task_list) + { + if (task_state) { + task_state->DisableTask( + CharacterID(), + task_count, + task_list + ); + } + } + inline bool IsTaskEnabled(int task_id) { + return task_state != nullptr && task_state->IsTaskEnabled(task_id); + } + inline void ProcessTaskProximities(float X, float Y, float Z) + { + if (task_state) { + task_state->ProcessTaskProximities( + this, + X, + Y, + Z + ); + } + } + inline void AssignTask( + int task_id, + int npc_id, + bool enforce_level_requirement = false + ) { + if (task_state) { + task_state->AcceptNewTask(this, task_id, npc_id, enforce_level_requirement); + } + } + inline int ActiveSpeakTask(int npc_type_id) + { + if (task_state) { + return task_state->ActiveSpeakTask(npc_type_id); + } + else { + return 0; + } + } + inline int ActiveSpeakActivity(int npc_type_id, int task_id) + { + if (task_state) { + return task_state->ActiveSpeakActivity( + npc_type_id, + task_id + ); + } + else { return 0; } + } + inline void FailTask(int task_id) { if (task_state) { task_state->FailTask(this, task_id); }} + inline int TaskTimeLeft(int task_id) { return (task_state ? task_state->TaskTimeLeft(task_id) : 0); } + inline int EnabledTaskCount(int task_set_id) + { + return (task_state ? task_state->EnabledTaskCount(task_set_id) : -1); + } + inline int IsTaskCompleted(int task_id) { return (task_state ? task_state->IsTaskCompleted(task_id) : -1); } + inline void ShowClientTasks() { if (task_state) { task_state->ShowClientTasks(this); }} + inline void CancelAllTasks() { if (task_state) { task_state->CancelAllTasks(this); }} + inline int GetActiveTaskCount() { return (task_state ? task_state->GetActiveTaskCount() : 0); } + inline int GetActiveTaskID(int index) { return (task_state ? task_state->GetActiveTaskID(index) : -1); } + inline int GetTaskStartTime(TaskType task_type, int index) + { + return (task_state ? task_state->GetTaskStartTime( + task_type, + index + ) : -1); + } + inline bool IsTaskActivityCompleted(TaskType task_type, int index, int activity_id) + { + return task_state != nullptr && task_state->IsTaskActivityCompleted(task_type, index, activity_id); + } + inline int GetTaskActivityDoneCount(TaskType task_type, int client_task_index, int activity_id) + { + return (task_state ? task_state->GetTaskActivityDoneCount(task_type, client_task_index, activity_id) : 0); + } + inline int GetTaskActivityDoneCountFromTaskID(int task_id, int activity_id) + { + return (task_state ? task_state->GetTaskActivityDoneCountFromTaskID(task_id, activity_id) : 0); + } + inline int ActiveTasksInSet(int task_set_id) + { + return (task_state ? task_state->ActiveTasksInSet(task_set_id) : 0); + } + inline int CompletedTasksInSet(int task_set_id) + { + return (task_state ? task_state->CompletedTasksInSet(task_set_id) : 0); + } inline const EQ::versions::ClientVersion ClientVersion() const { return m_ClientVersion; } inline const uint32 ClientVersionBit() const { return m_ClientVersionBit; } @@ -1645,7 +1838,7 @@ private: std::set zone_flags; - ClientTaskState *taskstate; + ClientTaskState *task_state; int TotalSecondsPlayed; //Anti Spam Stuff diff --git a/zone/client_packet.cpp b/zone/client_packet.cpp index 12df5cb0e..8ce8057a5 100644 --- a/zone/client_packet.cpp +++ b/zone/client_packet.cpp @@ -1821,8 +1821,8 @@ void Client::Handle_OP_AcceptNewTask(const EQApplicationPacket *app) } AcceptNewTask_Struct *ant = (AcceptNewTask_Struct*)app->pBuffer; - if (ant->task_id > 0 && RuleB(TaskSystem, EnableTaskSystem) && taskstate) - taskstate->AcceptNewTask(this, ant->task_id, ant->task_master_id); + if (ant->task_id > 0 && RuleB(TaskSystem, EnableTaskSystem) && task_state) + task_state->AcceptNewTask(this, ant->task_id, ant->task_master_id); } void Client::Handle_OP_AdventureInfoRequest(const EQApplicationPacket *app) @@ -4004,8 +4004,8 @@ void Client::Handle_OP_CancelTask(const EQApplicationPacket *app) } CancelTask_Struct *cts = (CancelTask_Struct*)app->pBuffer; - if (RuleB(TaskSystem, EnableTaskSystem) && taskstate) - taskstate->CancelTask(this, cts->SequenceNumber, static_cast(cts->type)); + if (RuleB(TaskSystem, EnableTaskSystem) && task_state) + task_state->CancelTask(this, cts->SequenceNumber, static_cast(cts->type)); } void Client::Handle_OP_CancelTrade(const EQApplicationPacket *app) @@ -13996,8 +13996,8 @@ void Client::Handle_OP_TaskHistoryRequest(const EQApplicationPacket *app) } TaskHistoryRequest_Struct *ths = (TaskHistoryRequest_Struct*)app->pBuffer; - if (RuleB(TaskSystem, EnableTaskSystem) && taskstate) - taskstate->SendTaskHistory(this, ths->TaskIndex); + if (RuleB(TaskSystem, EnableTaskSystem) && task_state) + task_state->SendTaskHistory(this, ths->TaskIndex); } void Client::Handle_OP_Taunt(const EQApplicationPacket *app) diff --git a/zone/client_process.cpp b/zone/client_process.cpp index 15dfa160f..fd8a6cb02 100644 --- a/zone/client_process.cpp +++ b/zone/client_process.cpp @@ -158,8 +158,8 @@ bool Client::Process() { CalcItemScale(); } - if (TaskPeriodic_Timer.Check() && taskstate) - taskstate->TaskPeriodicChecks(this); + if (TaskPeriodic_Timer.Check() && task_state) + task_state->TaskPeriodicChecks(this); if (dynamiczone_removal_timer.Check() && zone && zone->GetInstanceID() != 0) { diff --git a/zone/command.cpp b/zone/command.cpp index c156d4331..9fb970f9b 100755 --- a/zone/command.cpp +++ b/zone/command.cpp @@ -77,7 +77,7 @@ extern QueryServ* QServ; extern WorldServer worldserver; -extern TaskManager *taskmanager; +extern TaskManager *p_task_manager; extern FastMath g_Math; void CatchSignal(int sig_num); diff --git a/zone/entity.cpp b/zone/entity.cpp index f48b371ce..98c4dc2e5 100644 --- a/zone/entity.cpp +++ b/zone/entity.cpp @@ -3900,7 +3900,7 @@ void EntityList::ProcessProximitySay(const char *Message, Client *c, uint8 langu void EntityList::SaveAllClientsTaskState() { - if (!taskmanager) + if (!p_task_manager) return; auto it = client_list.begin(); @@ -3915,7 +3915,7 @@ void EntityList::SaveAllClientsTaskState() void EntityList::ReloadAllClientsTaskState(int TaskID) { - if (!taskmanager) + if (!p_task_manager) return; auto it = client_list.begin(); @@ -3928,7 +3928,7 @@ void EntityList::ReloadAllClientsTaskState(int TaskID) Log(Logs::General, Logs::Tasks, "[CLIENTLOAD] Reloading Task State For Client %s", client->GetName()); client->RemoveClientTaskState(); client->LoadClientTaskState(); - taskmanager->SendActiveTasksToClient(client); + p_task_manager->SendActiveTasksToClient(client); } } ++it; diff --git a/zone/main.cpp b/zone/main.cpp index 7b5fca736..a89f25f9e 100644 --- a/zone/main.cpp +++ b/zone/main.cpp @@ -115,8 +115,8 @@ char errorname[32]; extern Zone* zone; npcDecayTimes_Struct npcCorpseDecayTimes[100]; TitleManager title_manager; -QueryServ *QServ = 0; -TaskManager *taskmanager = 0; +QueryServ *QServ = 0; +TaskManager *p_task_manager = 0; NpcScaleManager *npc_scale_manager; QuestParserCollection *parse = 0; EQEmuLogSys LogSys; @@ -427,8 +427,8 @@ int main(int argc, char** argv) { if (RuleB(TaskSystem, EnableTaskSystem)) { Log(Logs::General, Logs::Tasks, "[INIT] Loading Tasks"); - taskmanager = new TaskManager; - taskmanager->LoadTasks(); + p_task_manager = new TaskManager; + p_task_manager->LoadTasks(); } parse = new QuestParserCollection(); @@ -607,7 +607,7 @@ int main(int argc, char** argv) { if (zone != 0) Zone::Shutdown(true); //Fix for Linux world server problem. - safe_delete(taskmanager); + safe_delete(p_task_manager); command_deinit(); #ifdef BOTS bot_command_deinit(); diff --git a/zone/questmgr.cpp b/zone/questmgr.cpp index f164341f8..247aa9501 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 && taskmanager) + if(RuleB(TaskSystem, EnableTaskSystem) && initiator && owner && p_task_manager) initiator->TaskQuestSetSelector(owner, taskcount, tasks); } void QuestManager::enabletask(int taskcount, int *tasks) { QuestManagerCurrentQuestVars(); - if(RuleB(TaskSystem, EnableTaskSystem) && initiator && taskmanager) + if(RuleB(TaskSystem, EnableTaskSystem) && initiator && p_task_manager) initiator->EnableTask(taskcount, tasks); } void QuestManager::disabletask(int taskcount, int *tasks) { QuestManagerCurrentQuestVars(); - if(RuleB(TaskSystem, EnableTaskSystem) && initiator && taskmanager) + if(RuleB(TaskSystem, EnableTaskSystem) && initiator && p_task_manager) initiator->DisableTask(taskcount, tasks); } bool QuestManager::istaskenabled(int taskid) { QuestManagerCurrentQuestVars(); - if(RuleB(TaskSystem, EnableTaskSystem) && initiator && taskmanager) + if(RuleB(TaskSystem, EnableTaskSystem) && initiator && p_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 && taskmanager) + if(RuleB(TaskSystem, EnableTaskSystem) && initiator && owner && p_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) && taskmanager) - return taskmanager->FirstTaskInSet(taskset); + if(RuleB(TaskSystem, EnableTaskSystem) && p_task_manager) + return p_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) && taskmanager) - return taskmanager->LastTaskInSet(taskset); + if(RuleB(TaskSystem, EnableTaskSystem) && p_task_manager) + return p_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) && taskmanager) - return taskmanager->NextTaskInSet(taskset, taskid); + if(RuleB(TaskSystem, EnableTaskSystem) && p_task_manager) + return p_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 && taskmanager) - return taskmanager->AppropriateLevel(task, initiator->GetLevel()); + if(RuleB(TaskSystem, EnableTaskSystem) && initiator && p_task_manager) + return p_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 taskmanager->GetTaskName(task_id); + return p_task_manager->GetTaskName(task_id); } return std::string(); diff --git a/zone/tasks.cpp b/zone/tasks.cpp index 3b8011829..866c5fb2f 100644 --- a/zone/tasks.cpp +++ b/zone/tasks.cpp @@ -40,18 +40,21 @@ Copyright (C) 2001-2008 EQEMu Development Team (http://eqemulator.net) #include "queryserv.h" #include "quest_parser_collection.h" +#include "../common/repositories/completed_tasks_repository.h" -extern QueryServ* QServ; +extern QueryServ *QServ; -TaskManager::TaskManager() { - for(int i=0; i= MAXTASKS)) return false; + if ((TaskID <= 0) || (TaskID >= MAXTASKS)) { return false; } // If this task already exists in memory, free all the dynamically allocated strings. - if(Tasks[TaskID]) { + if (Tasks[TaskID]) { safe_delete(Tasks[TaskID]); } return LoadTasks(TaskID); } -void TaskManager::ReloadGoalLists() { +void TaskManager::ReloadGoalLists() +{ - if(!GoalListManager.LoadLists()) - Log(Logs::Detail, Logs::Tasks,"TaskManager::LoadTasks LoadLists failed"); + if (!GoalListManager.LoadLists()) + Log(Logs::Detail, Logs::Tasks, "TaskManager::LoadTasks LoadLists failed"); } bool TaskManager::LoadTasks(int singleTask) { - // If TaskID !=0, then just load the task specified. + // If task_id !=0, then just load the task specified. Log(Logs::General, Logs::Tasks, "[GLOBALLOAD] TaskManager::LoadTasks Called"); std::string query; @@ -121,15 +126,21 @@ bool TaskManager::LoadTasks(int singleTask) if (!LoadTaskSets()) Log(Logs::Detail, Logs::Tasks, "TaskManager::LoadTasks LoadTaskSets failed"); - query = StringFormat("SELECT `id`, `type`, `duration`, `duration_code`, `title`, `description`, " - "`reward`, `rewardid`, `cashreward`, `xpreward`, `rewardmethod`, `faction_reward`," - "`minlevel`, `maxlevel`, `repeatable`, `completion_emote` FROM `tasks` WHERE `id` < %i", - MAXTASKS); - } else - query = StringFormat("SELECT `id`, `type`, `duration`, `duration_code`, `title`, `description`, " - "`reward`, `rewardid`, `cashreward`, `xpreward`, `rewardmethod`, `faction_reward`," - "`minlevel`, `maxlevel`, `repeatable`, `completion_emote` FROM `tasks` WHERE `id` = %i", - singleTask); + query = StringFormat( + "SELECT `id`, `type`, `duration`, `duration_code`, `title`, `description`, " + "`reward`, `rewardid`, `cashreward`, `xpreward`, `rewardmethod`, `faction_reward`," + "`minlevel`, `maxlevel`, `repeatable`, `completion_emote` FROM `tasks` WHERE `id` < %i", + MAXTASKS + ); + } + else { + query = StringFormat( + "SELECT `id`, `type`, `duration`, `duration_code`, `title`, `description`, " + "`reward`, `rewardid`, `cashreward`, `xpreward`, `rewardmethod`, `faction_reward`," + "`minlevel`, `maxlevel`, `repeatable`, `completion_emote` FROM `tasks` WHERE `id` = %i", + singleTask + ); + } const char *ERR_MYSQLERROR = "[TASKS]Error in TaskManager::LoadTasks: %s"; @@ -149,47 +160,53 @@ bool TaskManager::LoadTasks(int singleTask) } Tasks[taskID] = new TaskInformation; - Tasks[taskID]->type = static_cast(atoi(row[1])); - Tasks[taskID]->Duration = atoi(row[2]); - Tasks[taskID]->dur_code = static_cast(atoi(row[3])); - Tasks[taskID]->Title = row[4]; - Tasks[taskID]->Description = row[5]; - Tasks[taskID]->Reward = row[6]; - Tasks[taskID]->RewardID = atoi(row[7]); - Tasks[taskID]->CashReward = atoi(row[8]); - Tasks[taskID]->XPReward = atoi(row[9]); - Tasks[taskID]->RewardMethod = (TaskMethodType)atoi(row[10]); - Tasks[taskID]->faction_reward = atoi(row[11]); - Tasks[taskID]->MinLevel = atoi(row[12]); - Tasks[taskID]->MaxLevel = atoi(row[13]); - Tasks[taskID]->Repeatable = atoi(row[14]); - Tasks[taskID]->completion_emote = row[15]; - Tasks[taskID]->ActivityCount = 0; - Tasks[taskID]->SequenceMode = ActivitiesSequential; - Tasks[taskID]->LastStep = 0; + Tasks[taskID]->type = static_cast(atoi(row[1])); + Tasks[taskID]->duration = atoi(row[2]); + Tasks[taskID]->duration_code = static_cast(atoi(row[3])); + Tasks[taskID]->title = row[4]; + Tasks[taskID]->description = row[5]; + Tasks[taskID]->reward = row[6]; + Tasks[taskID]->reward_id = atoi(row[7]); + Tasks[taskID]->cash_reward = atoi(row[8]); + Tasks[taskID]->experience_reward = atoi(row[9]); + Tasks[taskID]->reward_method = (TaskMethodType) atoi(row[10]); + Tasks[taskID]->faction_reward = atoi(row[11]); + Tasks[taskID]->min_level = atoi(row[12]); + Tasks[taskID]->max_level = atoi(row[13]); + Tasks[taskID]->repeatable = atoi(row[14]); + Tasks[taskID]->completion_emote = row[15]; + Tasks[taskID]->activity_count = 0; + Tasks[taskID]->sequence_mode = ActivitiesSequential; + Tasks[taskID]->last_step = 0; Log(Logs::General, Logs::Tasks, - "[GLOBALLOAD] TaskID: %5i, Duration: %8i, Reward: %s MinLevel %i MaxLevel %i " - "Repeatable: %s", - taskID, Tasks[taskID]->Duration, Tasks[taskID]->Reward.c_str(), - Tasks[taskID]->MinLevel, Tasks[taskID]->MaxLevel, Tasks[taskID]->Repeatable ? "Yes" : "No"); - Log(Logs::General, Logs::Tasks, "[GLOBALLOAD] Title: %s", Tasks[taskID]->Title.c_str()); + "[GLOBALLOAD] task_id: %5i, duration: %8i, reward: %s min_level %i max_level %i " + "repeatable: %s", + taskID, Tasks[taskID]->duration, Tasks[taskID]->reward.c_str(), + Tasks[taskID]->min_level, Tasks[taskID]->max_level, Tasks[taskID]->repeatable ? "Yes" : "No"); + Log(Logs::General, Logs::Tasks, "[GLOBALLOAD] title: %s", Tasks[taskID]->title.c_str()); } - if (singleTask == 0) + if (singleTask == 0) { query = - StringFormat("SELECT `taskid`, `step`, `activityid`, `activitytype`, `target_name`, `item_list`, " - "`skill_list`, `spell_list`, `description_override`, `goalid`, `goalmethod`, " - "`goalcount`, `delivertonpc`, `zones`, `optional` FROM `task_activities` WHERE `taskid` < " - "%i AND `activityid` < %i ORDER BY taskid, activityid ASC", - MAXTASKS, MAXACTIVITIESPERTASK); - else + StringFormat( + "SELECT `taskid`, `step`, `activityid`, `activitytype`, `target_name`, `item_list`, " + "`skill_list`, `spell_list`, `description_override`, `goalid`, `goalmethod`, " + "`goalcount`, `delivertonpc`, `zones`, `optional` FROM `task_activities` WHERE `taskid` < " + "%i AND `activityid` < %i ORDER BY taskid, activityid ASC", + MAXTASKS, MAXACTIVITIESPERTASK + ); + } + else { query = - StringFormat("SELECT `taskid`, `step`, `activityid`, `activitytype`, `target_name`, `item_list`, " - "`skill_list`, `spell_list`, `description_override`, `goalid`, `goalmethod`, " - "`goalcount`, `delivertonpc`, `zones`, `optional` FROM `task_activities` WHERE `taskid` = " - "%i AND `activityid` < %i ORDER BY taskid, activityid ASC", - singleTask, MAXACTIVITIESPERTASK); + StringFormat( + "SELECT `taskid`, `step`, `activityid`, `activitytype`, `target_name`, `item_list`, " + "`skill_list`, `spell_list`, `description_override`, `goalid`, `goalmethod`, " + "`goalcount`, `delivertonpc`, `zones`, `optional` FROM `task_activities` WHERE `taskid` = " + "%i AND `activityid` < %i ORDER BY taskid, activityid ASC", + singleTask, MAXACTIVITIESPERTASK + ); + } results = content_db.QueryDatabase(query); if (!results.Success()) { LogError(ERR_MYSQLERROR, results.ErrorMessage().c_str()); @@ -198,83 +215,87 @@ bool TaskManager::LoadTasks(int singleTask) for (auto row = results.begin(); row != results.end(); ++row) { int taskID = atoi(row[0]); - int step = atoi(row[1]); + int step = atoi(row[1]); int activityID = atoi(row[2]); if ((taskID <= 0) || (taskID >= MAXTASKS) || (activityID < 0) || (activityID >= MAXACTIVITIESPERTASK)) { // This shouldn't happen, as the SELECT is bounded by MAXTASKS - LogError("[TASKS]Task or Activity ID ([{}], [{}]) out of range while loading activities from database", taskID, activityID); + LogError("[TASKS]Task or activity_information ID ([{}], [{}]) out of range while loading activities from database", + taskID, + activityID); continue; } if (Tasks[taskID] == nullptr) { - LogError("[TASKS]Activity for non-existent task ([{}], [{}]) while loading activities from database", - taskID, activityID); + LogError("[TASKS]activity_information for non-existent task ([{}], [{}]) while loading activities from database", + taskID, activityID); continue; } - Tasks[taskID]->Activity[Tasks[taskID]->ActivityCount].StepNumber = step; + Tasks[taskID]->activity_information[Tasks[taskID]->activity_count].StepNumber = step; - if (step != 0) - Tasks[taskID]->SequenceMode = ActivitiesStepped; + if (step != 0) { + Tasks[taskID]->sequence_mode = ActivitiesStepped; + } - if (step > Tasks[taskID]->LastStep) - Tasks[taskID]->LastStep = step; + if (step > Tasks[taskID]->last_step) { + Tasks[taskID]->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]->ActivityCount + 1)) to index from 1 - if (activityID != Tasks[taskID]->ActivityCount) { + // Change to (activityID != (Tasks[taskID]->activity_count + 1)) to index from 1 + if (activityID != Tasks[taskID]->activity_count) { LogError("[TASKS]Activities for Task [{}] are not sequential starting at 0. Not loading task", taskID, - activityID); + activityID); Tasks[taskID] = nullptr; continue; } - Tasks[taskID]->Activity[Tasks[taskID]->ActivityCount].Type = atoi(row[3]); + Tasks[taskID]->activity_information[Tasks[taskID]->activity_count].Type = atoi(row[3]); - Tasks[taskID]->Activity[Tasks[taskID]->ActivityCount].target_name = row[4]; - Tasks[taskID]->Activity[Tasks[taskID]->ActivityCount].item_list = row[5]; - Tasks[taskID]->Activity[Tasks[taskID]->ActivityCount].skill_list = row[6]; - Tasks[taskID]->Activity[Tasks[taskID]->ActivityCount].skill_id = atoi(row[6]); // for older clients - Tasks[taskID]->Activity[Tasks[taskID]->ActivityCount].spell_list = row[7]; - Tasks[taskID]->Activity[Tasks[taskID]->ActivityCount].spell_id = atoi(row[7]); // for older clients - Tasks[taskID]->Activity[Tasks[taskID]->ActivityCount].desc_override = row[8]; + Tasks[taskID]->activity_information[Tasks[taskID]->activity_count].target_name = row[4]; + Tasks[taskID]->activity_information[Tasks[taskID]->activity_count].item_list = row[5]; + Tasks[taskID]->activity_information[Tasks[taskID]->activity_count].skill_list = row[6]; + Tasks[taskID]->activity_information[Tasks[taskID]->activity_count].skill_id = atoi(row[6]); // for older clients + Tasks[taskID]->activity_information[Tasks[taskID]->activity_count].spell_list = row[7]; + Tasks[taskID]->activity_information[Tasks[taskID]->activity_count].spell_id = atoi(row[7]); // for older clients + Tasks[taskID]->activity_information[Tasks[taskID]->activity_count].desc_override = row[8]; - Tasks[taskID]->Activity[Tasks[taskID]->ActivityCount].GoalID = atoi(row[9]); - Tasks[taskID]->Activity[Tasks[taskID]->ActivityCount].GoalMethod = (TaskMethodType)atoi(row[10]); - Tasks[taskID]->Activity[Tasks[taskID]->ActivityCount].GoalCount = atoi(row[11]); - Tasks[taskID]->Activity[Tasks[taskID]->ActivityCount].DeliverToNPC = atoi(row[12]); - Tasks[taskID]->Activity[Tasks[taskID]->ActivityCount].zones = row[13]; - auto zones = SplitString(Tasks[taskID]->Activity[Tasks[taskID]->ActivityCount].zones, ';'); - for (auto && e : zones) - Tasks[taskID]->Activity[Tasks[taskID]->ActivityCount].ZoneIDs.push_back(std::stoi(e)); - Tasks[taskID]->Activity[Tasks[taskID]->ActivityCount].Optional = atoi(row[14]); + Tasks[taskID]->activity_information[Tasks[taskID]->activity_count].GoalID = atoi(row[9]); + Tasks[taskID]->activity_information[Tasks[taskID]->activity_count].GoalMethod = (TaskMethodType) atoi(row[10]); + Tasks[taskID]->activity_information[Tasks[taskID]->activity_count].GoalCount = atoi(row[11]); + Tasks[taskID]->activity_information[Tasks[taskID]->activity_count].DeliverToNPC = atoi(row[12]); + Tasks[taskID]->activity_information[Tasks[taskID]->activity_count].zones = row[13]; + auto zones = SplitString(Tasks[taskID]->activity_information[Tasks[taskID]->activity_count].zones, ';'); + for (auto &&e : zones) + Tasks[taskID]->activity_information[Tasks[taskID]->activity_count].ZoneIDs.push_back(std::stoi(e)); + Tasks[taskID]->activity_information[Tasks[taskID]->activity_count].Optional = atoi(row[14]); Log(Logs::General, Logs::Tasks, - "[GLOBALLOAD] Activity Slot %2i: ID %i for Task %5i. Type: %3i, GoalID: %8i, " - "GoalMethod: %i, GoalCount: %3i, Zones:%s", - Tasks[taskID]->ActivityCount, activityID, taskID, - Tasks[taskID]->Activity[Tasks[taskID]->ActivityCount].Type, - Tasks[taskID]->Activity[Tasks[taskID]->ActivityCount].GoalID, - Tasks[taskID]->Activity[Tasks[taskID]->ActivityCount].GoalMethod, - Tasks[taskID]->Activity[Tasks[taskID]->ActivityCount].GoalCount, - Tasks[taskID]->Activity[Tasks[taskID]->ActivityCount].zones.c_str()); + "[GLOBALLOAD] activity_information Slot %2i: ID %i for Task %5i. Type: %3i, GoalID: %8i, " + "GoalMethod: %i, GoalCount: %3i, Zones:%s", + Tasks[taskID]->activity_count, activityID, taskID, + Tasks[taskID]->activity_information[Tasks[taskID]->activity_count].Type, + Tasks[taskID]->activity_information[Tasks[taskID]->activity_count].GoalID, + Tasks[taskID]->activity_information[Tasks[taskID]->activity_count].GoalMethod, + Tasks[taskID]->activity_information[Tasks[taskID]->activity_count].GoalCount, + Tasks[taskID]->activity_information[Tasks[taskID]->activity_count].zones.c_str()); Log(Logs::General, Logs::Tasks, "[GLOBALLOAD] target_name: %s", - Tasks[taskID]->Activity[Tasks[taskID]->ActivityCount].target_name.c_str()); + Tasks[taskID]->activity_information[Tasks[taskID]->activity_count].target_name.c_str()); Log(Logs::General, Logs::Tasks, "[GLOBALLOAD] item_list: %s", - Tasks[taskID]->Activity[Tasks[taskID]->ActivityCount].item_list.c_str()); + Tasks[taskID]->activity_information[Tasks[taskID]->activity_count].item_list.c_str()); Log(Logs::General, Logs::Tasks, "[GLOBALLOAD] skill_list: %s", - Tasks[taskID]->Activity[Tasks[taskID]->ActivityCount].skill_list.c_str()); + Tasks[taskID]->activity_information[Tasks[taskID]->activity_count].skill_list.c_str()); Log(Logs::General, Logs::Tasks, "[GLOBALLOAD] spell_list: %s", - Tasks[taskID]->Activity[Tasks[taskID]->ActivityCount].spell_list.c_str()); + Tasks[taskID]->activity_information[Tasks[taskID]->activity_count].spell_list.c_str()); Log(Logs::General, Logs::Tasks, "[GLOBALLOAD] description_override: %s", - Tasks[taskID]->Activity[Tasks[taskID]->ActivityCount].desc_override.c_str()); + Tasks[taskID]->activity_information[Tasks[taskID]->activity_count].desc_override.c_str()); - Tasks[taskID]->ActivityCount++; + Tasks[taskID]->activity_count++; } return true; @@ -286,8 +307,9 @@ bool TaskManager::SaveClientState(Client *c, ClientTaskState *state) // doesn't seem to like tasks moving slots between zoning and you can end up with 'bogus' activities if the task // previously in that slot had more activities than the one now occupying it. Hopefully retaining the slot // number for the duration of a session will overcome this. - if (!c || !state) + if (!c || !state) { return false; + } const char *ERR_MYSQLERROR = "[TASKS]Error in TaskManager::SaveClientState %s"; @@ -295,67 +317,78 @@ bool TaskManager::SaveClientState(Client *c, ClientTaskState *state) Log(Logs::Detail, Logs::Tasks, "TaskManager::SaveClientState for character ID %d", characterID); - if (state->ActiveTaskCount > 0 || state->ActiveTask.TaskID != TASKSLOTEMPTY) { // TODO: tasks - for (int task = 0; task < MAXACTIVEQUESTS + 1; task++) { - int taskID = state->ActiveTasks[task].TaskID; - if (taskID == TASKSLOTEMPTY) + if (state->active_task_count > 0 || state->active_task.task_id != TASKSLOTEMPTY) { // TODO: tasks + for (auto & ActiveTask : state->ActiveTasks) { + int taskID = ActiveTask.task_id; + if (taskID == TASKSLOTEMPTY) { continue; + } - int slot = state->ActiveTasks[task].slot; + int slot = ActiveTask.slot; - if (state->ActiveTasks[task].Updated) { + if (ActiveTask.updated) { Log(Logs::General, Logs::Tasks, - "[CLIENTSAVE] TaskManager::SaveClientState for character ID %d, Updating TaskIndex " - "%i TaskID %i", - characterID, slot, taskID); + "[CLIENTSAVE] TaskManager::SaveClientState for character ID %d, Updating TaskIndex " + "%i task_id %i", + characterID, slot, taskID); - std::string query = StringFormat( - "REPLACE INTO character_tasks (charid, taskid, slot, type, acceptedtime) " - "VALUES (%i, %i, %i, %i, %i)", - characterID, taskID, slot, static_cast(Tasks[taskID]->type), - state->ActiveTasks[task].AcceptedTime); - auto results = database.QueryDatabase(query); + std::string query = StringFormat( + "REPLACE INTO character_tasks (charid, taskid, slot, type, acceptedtime) " + "VALUES (%i, %i, %i, %i, %i)", + characterID, taskID, slot, static_cast(Tasks[taskID]->type), + ActiveTask.accepted_time + ); + auto results = database.QueryDatabase(query); if (!results.Success()) { LogError(ERR_MYSQLERROR, results.ErrorMessage().c_str()); - } else { - state->ActiveTasks[task].Updated = false; + } + else { + ActiveTask.updated = false; } } std::string query = - "REPLACE INTO character_activities (charid, taskid, activityid, donecount, completed) " - "VALUES "; + "REPLACE INTO character_activities (charid, taskid, activityid, donecount, completed) " + "VALUES "; - int updatedActivityCount = 0; - for (int activityIndex = 0; activityIndex < Tasks[taskID]->ActivityCount; ++activityIndex) { + int updatedActivityCount = 0; + for (int activityIndex = 0; activityIndex < Tasks[taskID]->activity_count; ++activityIndex) { - if (!state->ActiveTasks[task].Activity[activityIndex].Updated) + if (!ActiveTask.activity[activityIndex].updated) { continue; + } Log(Logs::General, Logs::Tasks, - "[CLIENTSAVE] TaskManager::SaveClientSate for character ID %d, Updating Activity " - "%i, %i", - characterID, slot, activityIndex); + "[CLIENTSAVE] TaskManager::SaveClientSate for character ID %d, Updating activity_information " + "%i, %i", + characterID, slot, activityIndex); - if (updatedActivityCount == 0) + if (updatedActivityCount == 0) { query += - StringFormat("(%i, %i, %i, %i, %i)", characterID, taskID, activityIndex, - state->ActiveTasks[task].Activity[activityIndex].DoneCount, - state->ActiveTasks[task].Activity[activityIndex].State == - ActivityCompleted); - else + StringFormat( + "(%i, %i, %i, %i, %i)", characterID, taskID, activityIndex, + ActiveTask.activity[activityIndex].done_count, + ActiveTask.activity[activityIndex].activity_state == + ActivityCompleted + ); + } + else { query += - StringFormat(", (%i, %i, %i, %i, %i)", characterID, taskID, activityIndex, - state->ActiveTasks[task].Activity[activityIndex].DoneCount, - state->ActiveTasks[task].Activity[activityIndex].State == - ActivityCompleted); + StringFormat( + ", (%i, %i, %i, %i, %i)", characterID, taskID, activityIndex, + ActiveTask.activity[activityIndex].done_count, + ActiveTask.activity[activityIndex].activity_state == + ActivityCompleted + ); + } updatedActivityCount++; } - if (updatedActivityCount == 0) + if (updatedActivityCount == 0) { continue; + } Log(Logs::General, Logs::Tasks, "[CLIENTSAVE] Executing query %s", query.c_str()); auto results = database.QueryDatabase(query); @@ -365,119 +398,134 @@ bool TaskManager::SaveClientState(Client *c, ClientTaskState *state) continue; } - state->ActiveTasks[task].Updated = false; - for (int activityIndex = 0; activityIndex < Tasks[taskID]->ActivityCount; ++activityIndex) - state->ActiveTasks[task].Activity[activityIndex].Updated = false; + ActiveTask.updated = false; + for (int activityIndex = 0; + activityIndex < Tasks[taskID]->activity_count; + ++activityIndex) + ActiveTask.activity[activityIndex].updated = false; } } if (!RuleB(TaskSystem, RecordCompletedTasks) || - (state->CompletedTasks.size() <= (unsigned int)state->LastCompletedTaskLoaded)) { - state->LastCompletedTaskLoaded = state->CompletedTasks.size(); + (state->completed_tasks.size() <= (unsigned int) state->last_completed_task_loaded)) { + state->last_completed_task_loaded = state->completed_tasks.size(); return true; } const char *completedTaskQuery = "REPLACE INTO completed_tasks (charid, completedtime, taskid, activityid) " - "VALUES (%i, %i, %i, %i)"; + "VALUES (%i, %i, %i, %i)"; - for (unsigned int i = state->LastCompletedTaskLoaded; i < state->CompletedTasks.size(); i++) { + for (unsigned int i = state->last_completed_task_loaded; i < state->completed_tasks.size(); i++) { Log(Logs::General, Logs::Tasks, - "[CLIENTSAVE] TaskManager::SaveClientState Saving Completed Task at slot %i", i); - int taskID = state->CompletedTasks[i].TaskID; + "[CLIENTSAVE] TaskManager::SaveClientState Saving Completed Task at slot %i", i); + int taskID = state->completed_tasks[i].task_id; - if ((taskID <= 0) || (taskID >= MAXTASKS) || (Tasks[taskID] == nullptr)) + if ((taskID <= 0) || (taskID >= MAXTASKS) || (Tasks[taskID] == nullptr)) { continue; + } - // First we save a record with an ActivityID of -1. + // First we save a record with an activity_id of -1. // This indicates this task was completed at the given time. We infer that all // none optional activities were completed. // - std::string query = - StringFormat(completedTaskQuery, characterID, state->CompletedTasks[i].CompletedTime, taskID, -1); - auto results = database.QueryDatabase(query); + std::string query = + StringFormat( + completedTaskQuery, + characterID, + state->completed_tasks[i].completed_time, + taskID, + -1 + ); + auto results = database.QueryDatabase(query); if (!results.Success()) { LogError(ERR_MYSQLERROR, results.ErrorMessage().c_str()); continue; } // If the Rule to record non-optional task completion is not enabled, don't save it - if (!RuleB(TaskSystem, RecordCompletedOptionalActivities)) + if (!RuleB(TaskSystem, RecordCompletedOptionalActivities)) { continue; + } // Insert one record for each completed optional task. - for (int j = 0; j < Tasks[taskID]->ActivityCount; j++) { - if (!Tasks[taskID]->Activity[j].Optional || !state->CompletedTasks[i].ActivityDone[j]) + for (int j = 0; j < Tasks[taskID]->activity_count; j++) { + if (!Tasks[taskID]->activity_information[j].Optional || !state->completed_tasks[i].activity_done[j]) { continue; + } - query = StringFormat(completedTaskQuery, characterID, state->CompletedTasks[i].CompletedTime, - taskID, j); + query = StringFormat( + completedTaskQuery, characterID, state->completed_tasks[i].completed_time, + taskID, j + ); results = database.QueryDatabase(query); if (!results.Success()) LogError(ERR_MYSQLERROR, results.ErrorMessage().c_str()); } } - state->LastCompletedTaskLoaded = state->CompletedTasks.size(); + state->last_completed_task_loaded = state->completed_tasks.size(); return true; } -void Client::LoadClientTaskState() { +void Client::LoadClientTaskState() +{ + if (RuleB(TaskSystem, EnableTaskSystem) && p_task_manager) { + if (task_state) { + safe_delete(task_state); + } - if(RuleB(TaskSystem, EnableTaskSystem) && taskmanager) { - if(taskstate) - safe_delete(taskstate); - - taskstate = new ClientTaskState; - if(!taskmanager->LoadClientState(this, taskstate)) { - safe_delete(taskstate); + task_state = new ClientTaskState; + if (!p_task_manager->LoadClientState(this, task_state)) { + safe_delete(task_state); } else { - taskmanager->SendActiveTasksToClient(this); - taskmanager->SendCompletedTasksToClient(this, taskstate); + p_task_manager->SendActiveTasksToClient(this); + p_task_manager->SendCompletedTasksToClient(this, task_state); } } - } -void Client::RemoveClientTaskState() { - - if(taskstate) { - taskstate->CancelAllTasks(this); - safe_delete(taskstate); +void Client::RemoveClientTaskState() +{ + if (task_state) { + task_state->CancelAllTasks(this); + safe_delete(task_state); } } bool TaskManager::LoadClientState(Client *c, ClientTaskState *state) { - if (!c || !state) + if (!c || !state) { return false; + } - int characterID = c->CharacterID(); + int character_id = c->CharacterID(); - state->ActiveTaskCount = 0; + state->active_task_count = 0; - Log(Logs::General, Logs::Tasks, "[CLIENTLOAD] TaskManager::LoadClientState for character ID %d", characterID); + LogTasks("[LoadClientState] for character_id [{}]", character_id); + + std::string query = StringFormat( + "SELECT `taskid`, `slot`,`type`, `acceptedtime` " + "FROM `character_tasks` " + "WHERE `charid` = %i ORDER BY acceptedtime", + character_id + ); - std::string query = StringFormat("SELECT `taskid`, `slot`,`type`, `acceptedtime` " - "FROM `character_tasks` " - "WHERE `charid` = %i ORDER BY acceptedtime", - characterID); auto results = database.QueryDatabase(query); if (!results.Success()) { - LogError("[TASKS]Error in TaskManager::LoadClientState load Tasks: [{}]", - results.ErrorMessage().c_str()); return false; } for (auto row = results.begin(); row != results.end(); ++row) { - int taskID = atoi(row[0]); - int slot = atoi(row[1]); - TaskType type = static_cast(atoi(row[2])); + int task_id = atoi(row[0]); + int slot = atoi(row[1]); + auto type = static_cast(atoi(row[2])); - if ((taskID < 0) || (taskID >= MAXTASKS)) { - LogError("[TASKS]Task ID [{}] out of range while loading character tasks from database", taskID); + if ((task_id < 0) || (task_id >= MAXTASKS)) { + LogError("[TASKS]Task ID [{}] out of range while loading character tasks from database", task_id); continue; } @@ -488,317 +536,358 @@ bool TaskManager::LoadClientState(Client *c, ClientTaskState *state) continue; } - if (task_info->TaskID != TASKSLOTEMPTY) { - LogError("[TASKS] Slot [{}] for Task [{}]s is already occupied", slot, - taskID); + if (task_info->task_id != TASKSLOTEMPTY) { + LogError("[TASKS] Slot [{}] for Task [{}]s is already occupied", slot, task_id); continue; } - int acceptedtime = atoi(row[3]); + int accepted_time = atoi(row[3]); - task_info->TaskID = taskID; - task_info->CurrentStep = -1; - task_info->AcceptedTime = acceptedtime; - task_info->Updated = false; + task_info->task_id = task_id; + task_info->current_step = -1; + task_info->accepted_time = accepted_time; + task_info->updated = false; - for (int i = 0; i < MAXACTIVITIESPERTASK; i++) - task_info->Activity[i].ActivityID = -1; + for (auto & i : task_info->activity) { + i.activity_id = -1; + } - if (type == TaskType::Quest) - ++state->ActiveTaskCount; + if (type == TaskType::Quest) { + ++state->active_task_count; + } - Log(Logs::General, Logs::Tasks, - "[CLIENTLOAD] TaskManager::LoadClientState. Char: %i Task ID %i, Accepted Time: %8X", characterID, - taskID, acceptedtime); + LogTasks("[LoadClientState] character_id [{}] task_id [{}] accepted_time [{}]", character_id, task_id, accepted_time); } // Load Activities - Log(Logs::General, Logs::Tasks, "[CLIENTLOAD] LoadClientState. Loading activities for character ID %d", - characterID); + LogTasks("[LoadClientState] Loading activities for character_id [{}]", character_id); - query = StringFormat("SELECT `taskid`, `activityid`, `donecount`, `completed` " - "FROM `character_activities` " - "WHERE `charid` = %i " - "ORDER BY `taskid` ASC, `activityid` ASC", - characterID); + query = StringFormat( + "SELECT `taskid`, `activityid`, `donecount`, `completed` " + "FROM `character_activities` " + "WHERE `charid` = %i " + "ORDER BY `taskid` ASC, `activityid` ASC", + character_id + ); results = database.QueryDatabase(query); if (!results.Success()) { - LogError("[TASKS]Error in TaskManager::LoadClientState load Activities: [{}]", - results.ErrorMessage().c_str()); return false; } for (auto row = results.begin(); row != results.end(); ++row) { - int taskID = atoi(row[0]); - if ((taskID < 0) || (taskID >= MAXTASKS)) { - LogError("[TASKS]Task ID [{}] out of range while loading character activities from database", taskID); + int task_id = atoi(row[0]); + if ((task_id < 0) || (task_id >= MAXTASKS)) { + LogTasks( + "[LoadClientState] Error: task_id [{}] out of range while loading character activities from database character_id [{}]", + task_id, + character_id + ); continue; } - int activityID = atoi(row[1]); - if ((activityID < 0) || (activityID >= MAXACTIVITIESPERTASK)) { - LogError("[TASKS]Activity ID [{}] out of range while loading character activities from database", - activityID); + int activity_id = atoi(row[1]); + if ((activity_id < 0) || (activity_id >= MAXACTIVITIESPERTASK)) { + LogTasks( + "[LoadClientState] Error: activity_id [{}] out of range while loading character activities from database character_id [{}]", + activity_id, + character_id + ); + continue; } ClientTaskInformation *task_info = nullptr; - - if (state->ActiveTask.TaskID == taskID) - task_info = &state->ActiveTask; + if (state->active_task.task_id == task_id) { + task_info = &state->active_task; + } // wasn't task - if (task_info == nullptr) - for (int i = 0; i < MAXACTIVEQUESTS; i++) - if (state->ActiveQuests[i].TaskID == taskID) - task_info = &state->ActiveQuests[i]; + if (task_info == nullptr) { + for (auto & active_quest : state->active_quests) { + if (active_quest.task_id == task_id) { + task_info = &active_quest; + } + } + } if (task_info == nullptr) { - LogError("[TASKS]Activity [{}] found for task [{}] which client does not have", activityID, taskID); + LogTasks( + "[LoadClientState] Error: activity_id [{}] found for task_id [{}] which client does not have character_id [{}]", + activity_id, + task_id, + character_id + ); + continue; } - int doneCount = atoi(row[2]); - bool completed = atoi(row[3]); - task_info->Activity[activityID].ActivityID = activityID; - task_info->Activity[activityID].DoneCount = doneCount; - if (completed) - task_info->Activity[activityID].State = ActivityCompleted; - else - task_info->Activity[activityID].State = ActivityHidden; + int done_count = atoi(row[2]); + bool completed = atoi(row[3]); + task_info->activity[activity_id].activity_id = activity_id; + task_info->activity[activity_id].done_count = done_count; + if (completed) { + task_info->activity[activity_id].activity_state = ActivityCompleted; + } + else { + task_info->activity[activity_id].activity_state = ActivityHidden; + } - task_info->Activity[activityID].Updated = false; + task_info->activity[activity_id].updated = false; - Log(Logs::General, Logs::Tasks, - "[CLIENTLOAD] TaskManager::LoadClientState. Char: %i Task ID %i, ActivityID: %i, DoneCount: %i, " - "Completed: %i", - characterID, taskID, activityID, doneCount, completed); + LogTasks( + "[LoadClientState] character_id [{}] task_id [{}] activity_id [{}] done_count [{}] completed [{}]", + character_id, + task_id, + activity_id, + done_count, + completed + ); } if (RuleB(TaskSystem, RecordCompletedTasks)) { - query = StringFormat("SELECT `taskid`, `activityid`, `completedtime` " - "FROM `completed_tasks` " - "WHERE `charid` = %i ORDER BY completedtime, taskid, activityid", - characterID); + query = StringFormat( + "SELECT `taskid`, `activityid`, `completedtime` " + "FROM `completed_tasks` " + "WHERE `charid` = %i ORDER BY completedtime, taskid, activityid", + character_id + ); results = database.QueryDatabase(query); if (!results.Success()) { - LogError("[TASKS]Error in TaskManager::LoadClientState load completed tasks: [{}]", - results.ErrorMessage().c_str()); return false; } - CompletedTaskInformation cti; + CompletedTaskInformation completed_task_information{}; + for (bool & i : completed_task_information.activity_done) + i = false; - for (int i = 0; i < MAXACTIVITIESPERTASK; i++) - cti.ActivityDone[i] = false; - - int previousTaskID = -1; - int previousCompletedTime = -1; + int previous_task_id = -1; + int previous_completed_time = -1; for (auto row = results.begin(); row != results.end(); ++row) { - int taskID = atoi(row[0]); - if ((taskID <= 0) || (taskID >= MAXTASKS)) { - LogError("[TASKS]Task ID [{}] out of range while loading completed tasks from database", - taskID); + int task_id = atoi(row[0]); + if ((task_id <= 0) || (task_id >= MAXTASKS)) { + LogError("[TASKS]Task ID [{}] out of range while loading completed tasks from database", task_id); continue; } - // An ActivityID of -1 means mark all the none optional activities in the + // An activity_id of -1 means mark all the none optional activities in the // task as complete. If the Rule to record optional activities is enabled, // subsequent records for this task will flag any optional tasks that were // completed. - int activityID = atoi(row[1]); - if ((activityID < -1) || (activityID >= MAXACTIVITIESPERTASK)) { - LogError("[TASKS]Activity ID [{}] out of range while loading completed tasks from database", - activityID); + int activity_id = atoi(row[1]); + if ((activity_id < -1) || (activity_id >= MAXACTIVITIESPERTASK)) { + LogError("[TASKS]activity_information ID [{}] out of range while loading completed tasks from database", activity_id); continue; } - int completedTime = atoi(row[2]); - if ((previousTaskID != -1) && - ((taskID != previousTaskID) || (completedTime != previousCompletedTime))) { - state->CompletedTasks.push_back(cti); - for (int i = 0; i < MAXACTIVITIESPERTASK; i++) - cti.ActivityDone[i] = false; + int completed_time = atoi(row[2]); + if ((previous_task_id != -1) && + ((task_id != previous_task_id) || (completed_time != previous_completed_time))) { + state->completed_tasks.push_back(completed_task_information); + for (bool & activity_done : completed_task_information.activity_done) { + activity_done = false; + } } - cti.TaskID = previousTaskID = taskID; - cti.CompletedTime = previousCompletedTime = completedTime; + completed_task_information.task_id = previous_task_id = task_id; + completed_task_information.completed_time = previous_completed_time = completed_time; - // If ActivityID is -1, Mark all the non-optional tasks as completed. - if (activityID < 0) { - TaskInformation *task = Tasks[taskID]; - if (task == nullptr) + // If activity_id is -1, Mark all the non-optional tasks as completed. + if (activity_id < 0) { + TaskInformation *task = Tasks[task_id]; + if (task == nullptr) { continue; + } - for (int i = 0; i < task->ActivityCount; i++) - if (!task->Activity[i].Optional) - cti.ActivityDone[i] = true; - } else - cti.ActivityDone[activityID] = true; + for (int i = 0; i < task->activity_count; i++) { + if (!task->activity_information[i].Optional) { + completed_task_information.activity_done[i] = true; + } + } + } + else { + completed_task_information.activity_done[activity_id] = true; + } } - if (previousTaskID != -1) - state->CompletedTasks.push_back(cti); + if (previous_task_id != -1) { + state->completed_tasks.push_back(completed_task_information); + } - state->LastCompletedTaskLoaded = state->CompletedTasks.size(); + state->last_completed_task_loaded = state->completed_tasks.size(); } - query = StringFormat("SELECT `taskid` FROM character_enabledtasks " - "WHERE `charid` = %i AND `taskid` >0 AND `taskid` < %i " - "ORDER BY `taskid` ASC", - characterID, MAXTASKS); + query = StringFormat( + "SELECT `taskid` FROM character_enabledtasks " + "WHERE `charid` = %i AND `taskid` >0 AND `taskid` < %i " + "ORDER BY `taskid` ASC", + character_id, MAXTASKS + ); results = database.QueryDatabase(query); - if (!results.Success()) { - LogError("[TASKS]Error in TaskManager::LoadClientState load enabled tasks: [{}]", - results.ErrorMessage().c_str()); - } else { + if (results.Success()) { for (auto row = results.begin(); row != results.end(); ++row) { - int taskID = atoi(row[0]); - state->EnabledTasks.push_back(taskID); - Log(Logs::General, Logs::Tasks, "[CLIENTLOAD] Adding TaskID %i to enabled tasks", taskID); + int task_id = atoi(row[0]); + state->enabled_tasks.push_back(task_id); + LogTasksDetail("[LoadClientState] Adding task_id [{}] to enabled tasks", task_id); } } - // Check that there is an entry in the client task state for every activity in each task + // Check that there is an entry in the client task state for every activity_information in each task // 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 i = 0; i < MAXACTIVEQUESTS + 1; i++) { - int taskID = state->ActiveTasks[i].TaskID; - if (taskID == TASKSLOTEMPTY) - continue; - if (!Tasks[taskID]) { - c->Message(Chat::Red, - "Active Task Slot %i, references a task (%i), that does not exist. " - "Removing from memory. Contact a GM to resolve this.", - i, taskID); - - LogError("[TASKS]Character [{}] has task [{}] which does not exist", - characterID, taskID); - state->ActiveTasks[i].TaskID = TASKSLOTEMPTY; + int task_id = state->ActiveTasks[i].task_id; + if (task_id == TASKSLOTEMPTY) { continue; } - for (int j = 0; j < Tasks[taskID]->ActivityCount; j++) { + if (!Tasks[task_id]) { + c->Message( + Chat::Red, + "Active Task Slot %i, references a task (%i), that does not exist. " + "Removing from memory. Contact a GM to resolve this.", + i, task_id + ); - if (state->ActiveTasks[i].Activity[j].ActivityID != j) { - c->Message(Chat::Red, - "Active Task %i, %s. Activity count does not match expected value." - "Removing from memory. Contact a GM to resolve this.", - taskID, Tasks[taskID]->Title.c_str()); + LogError("[LoadClientState] Character [{}] has task [{}] which does not exist", character_id, task_id); + state->ActiveTasks[i].task_id = TASKSLOTEMPTY; + continue; + } + for (int activity_index = 0; activity_index < Tasks[task_id]->activity_count; activity_index++) { + if (state->ActiveTasks[i].activity[activity_index].activity_id != activity_index) { + c->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, Tasks[task_id]->title.c_str() + ); - LogError("[TASKS]Fatal error in character [{}] task state. Activity [{}] for Task [{}] either missing from client state or from task", - characterID, j, taskID); - state->ActiveTasks[i].TaskID = TASKSLOTEMPTY; + LogTasks( + "[LoadClientState] Fatal error in character [{}] task state. activity_information [{}] for Task [{}] either missing from client state or from task", + character_id, + activity_index, + task_id + ); + state->ActiveTasks[i].task_id = TASKSLOTEMPTY; break; } } } - if (state->ActiveTask.TaskID != TASKSLOTEMPTY) - state->UnlockActivities(characterID, state->ActiveTask); - // TODO: shared - for (int i = 0; i < MAXACTIVEQUESTS; i++) - if (state->ActiveQuests[i].TaskID != TASKSLOTEMPTY) - state->UnlockActivities(characterID, state->ActiveQuests[i]); + if (state->active_task.task_id != TASKSLOTEMPTY) { + state->UnlockActivities(character_id, state->active_task); + } + + // TODO: shared + for (auto & active_quest : state->active_quests) { + if (active_quest.task_id != TASKSLOTEMPTY) { + state->UnlockActivities(character_id, active_quest); + } + } + + LogTasks( "[LoadClientState] for Character ID [{}}] DONE!", character_id); - Log(Logs::General, Logs::Tasks, "[CLIENTLOAD] LoadClientState for Character ID %d DONE!", characterID); return true; } -void ClientTaskState::EnableTask(int characterID, int taskCount, int *tasks) { - +void ClientTaskState::EnableTask(int character_id, int task_count, int *tasks) +{ // Check if the Task is already enabled for this client - // - std::vector tasksEnabled; + std::vector tasks_enabled; + for (int i = 0; i < task_count; i++) { - for(int i=0; i tasks[i]) - break; + if ((*iterator) > tasks[i]) { + break; + } ++iterator; } - if(addTask) { - EnabledTasks.insert(iterator, tasks[i]); + if (addTask) { + enabled_tasks.insert(iterator, tasks[i]); // Make a note of the task we enabled, for later SQL generation - tasksEnabled.push_back(tasks[i]); + tasks_enabled.push_back(tasks[i]); } } - Log(Logs::General, Logs::Tasks, "[UPDATE] New enabled task list "); - for(unsigned int i=0; i tasksDisabled; - for(int i=0; i taskList[i]) - break; + if ((*iterator) > task_list[i]) { + break; + } ++iterator; } - if(removeTask) { - EnabledTasks.erase(iterator); - tasksDisabled.push_back(taskList[i]); + if (removeTask) { + enabled_tasks.erase(iterator); + tasksDisabled.push_back(task_list[i]); } } - Log(Logs::General, Logs::Tasks, "[UPDATE] New enabled task list "); - for(unsigned int i=0; i::iterator Iterator; - Iterator = EnabledTasks.begin(); + Iterator = enabled_tasks.begin(); - while(Iterator != EnabledTasks.end()) { - if((*Iterator) == TaskID) return true; - if((*Iterator) > TaskID) break; + while (Iterator != enabled_tasks.end()) { + if ((*Iterator) == TaskID) { return true; } + if ((*Iterator) > TaskID) { break; } ++Iterator; } return false; } -int ClientTaskState::EnabledTaskCount(int TaskSetID) { +int ClientTaskState::EnabledTaskCount(int TaskSetID) +{ // Return the number of tasks in TaskSet that this character is enabled for. unsigned int EnabledTaskIndex = 0; - unsigned int TaskSetIndex = 0; - int EnabledTaskCount = 0; + unsigned int TaskSetIndex = 0; + int EnabledTaskCount = 0; - if((TaskSetID<=0) || (TaskSetID>=MAXTASKSETS)) return -1; + if ((TaskSetID <= 0) || (TaskSetID >= MAXTASKSETS)) { return -1; } - while((EnabledTaskIndex < EnabledTasks.size()) && (TaskSetIndex < taskmanager->TaskSets[TaskSetID].size())) { + while ((EnabledTaskIndex < enabled_tasks.size()) && (TaskSetIndex < p_task_manager->TaskSets[TaskSetID].size())) { - if(EnabledTasks[EnabledTaskIndex] == taskmanager->TaskSets[TaskSetID][TaskSetIndex]) { + if (enabled_tasks[EnabledTaskIndex] == p_task_manager->TaskSets[TaskSetID][TaskSetIndex]) { EnabledTaskCount++; EnabledTaskIndex++; @@ -848,120 +942,145 @@ int ClientTaskState::EnabledTaskCount(int TaskSetID) { continue; } - if(EnabledTasks[EnabledTaskIndex] < taskmanager->TaskSets[TaskSetID][TaskSetIndex]) + if (enabled_tasks[EnabledTaskIndex] < p_task_manager->TaskSets[TaskSetID][TaskSetIndex]) { EnabledTaskIndex++; - else + } + else { TaskSetIndex++; + } } return EnabledTaskCount; } -int ClientTaskState::ActiveTasksInSet(int TaskSetID) { +int ClientTaskState::ActiveTasksInSet(int TaskSetID) +{ - if((TaskSetID<=0) || (TaskSetID>=MAXTASKSETS)) return -1; + if ((TaskSetID <= 0) || (TaskSetID >= MAXTASKSETS)) { return -1; } int Count = 0; - for(unsigned int i=0; iTaskSets[TaskSetID].size(); i++) - if(IsTaskActive(taskmanager->TaskSets[TaskSetID][i])) + for (unsigned int i = 0; i < p_task_manager->TaskSets[TaskSetID].size(); i++) + if (IsTaskActive(p_task_manager->TaskSets[TaskSetID][i])) { Count++; + } return Count; } -int ClientTaskState::CompletedTasksInSet(int TaskSetID) { +int ClientTaskState::CompletedTasksInSet(int TaskSetID) +{ - if((TaskSetID<=0) || (TaskSetID>=MAXTASKSETS)) return -1; + if ((TaskSetID <= 0) || (TaskSetID >= MAXTASKSETS)) { return -1; } int Count = 0; - for(unsigned int i=0; iTaskSets[TaskSetID].size(); i++) - if(IsTaskCompleted(taskmanager->TaskSets[TaskSetID][i])) + for (unsigned int i = 0; i < p_task_manager->TaskSets[TaskSetID].size(); i++) + if (IsTaskCompleted(p_task_manager->TaskSets[TaskSetID][i])) { Count++; + } return Count; } bool ClientTaskState::HasSlotForTask(TaskInformation *task) { - if (task == nullptr) + if (task == nullptr) { return false; + } switch (task->type) { - case TaskType::Task: - return ActiveTask.TaskID == TASKSLOTEMPTY; - case TaskType::Shared: - return false; // todo - case TaskType::Quest: - for (int i = 0; i < MAXACTIVEQUESTS; ++i) - if (ActiveQuests[i].TaskID == TASKSLOTEMPTY) - return true; - case TaskType::E: - return false; // removed on live + case TaskType::Task: + return active_task.task_id == TASKSLOTEMPTY; + case TaskType::Shared: + return false; // todo + case TaskType::Quest: + for (int i = 0; i < MAXACTIVEQUESTS; ++i) + if (active_quests[i].task_id == TASKSLOTEMPTY) { + return true; + } + case TaskType::E: + return false; // removed on live } return false; } -int TaskManager::FirstTaskInSet(int TaskSetID) { +int TaskManager::FirstTaskInSet(int TaskSetID) +{ - if((TaskSetID<=0) || (TaskSetID>=MAXTASKSETS)) return 0; + if ((TaskSetID <= 0) || (TaskSetID >= MAXTASKSETS)) { return 0; } - if(TaskSets[TaskSetID].empty()) return 0; + if (TaskSets[TaskSetID].empty()) { return 0; } auto Iterator = TaskSets[TaskSetID].begin(); - while(Iterator != TaskSets[TaskSetID].end()) { - if((*Iterator) > 0) + while (Iterator != TaskSets[TaskSetID].end()) { + if ((*Iterator) > 0) { return (*Iterator); + } ++Iterator; } return 0; } -int TaskManager::LastTaskInSet(int TaskSetID) { +int TaskManager::LastTaskInSet(int TaskSetID) +{ + if ((TaskSetID <= 0) || (TaskSetID >= MAXTASKSETS)) { + return 0; + } - if((TaskSetID<=0) || (TaskSetID>=MAXTASKSETS)) return 0; + if (TaskSets[TaskSetID].empty()) { + return 0; + } - if(TaskSets[TaskSetID].empty()) return 0; - - return TaskSets[TaskSetID][TaskSets[TaskSetID].size()-1]; + return TaskSets[TaskSetID][TaskSets[TaskSetID].size() - 1]; } -int TaskManager::NextTaskInSet(int TaskSetID, int TaskID) { +int TaskManager::NextTaskInSet(int TaskSetID, int TaskID) +{ + if ((TaskSetID <= 0) || (TaskSetID >= MAXTASKSETS)) { + return 0; + } - if((TaskSetID<=0) || (TaskSetID>=MAXTASKSETS)) return 0; + if (TaskSets[TaskSetID].empty()) { + return 0; + } - if(TaskSets[TaskSetID].empty()) return 0; - - for(unsigned int i=0; i TaskID) return TaskSets[TaskSetID][i]; + for (int i : TaskSets[TaskSetID]) { + if (i > TaskID) { + return i; + } } return 0; } -bool TaskManager::AppropriateLevel(int TaskID, int PlayerLevel) { +bool TaskManager::ValidateLevel(int TaskID, int PlayerLevel) +{ + if (Tasks[TaskID] == nullptr) { + return false; + } - if(Tasks[TaskID] == nullptr) return false; + if (Tasks[TaskID]->min_level && (PlayerLevel < Tasks[TaskID]->min_level)) { + return false; + } - if(Tasks[TaskID]->MinLevel && (PlayerLevel < Tasks[TaskID]->MinLevel)) return false; - - if(Tasks[TaskID]->MaxLevel && (PlayerLevel > Tasks[TaskID]->MaxLevel)) return false; + if (Tasks[TaskID]->max_level && (PlayerLevel > Tasks[TaskID]->max_level)) { + return false; + } return true; - } std::string TaskManager::GetTaskName(uint32 task_id) { if (task_id > 0 && task_id < MAXTASKS) { if (Tasks[task_id] != nullptr) { - return Tasks[task_id]->Title; + return Tasks[task_id]->title; } } @@ -980,9 +1099,8 @@ TaskType TaskManager::GetTaskType(uint32 task_id) int TaskManager::GetTaskMinLevel(int TaskID) { - if (Tasks[TaskID]->MinLevel) - { - return Tasks[TaskID]->MinLevel; + if (Tasks[TaskID]->min_level) { + return Tasks[TaskID]->min_level; } return -1; @@ -990,9 +1108,8 @@ int TaskManager::GetTaskMinLevel(int TaskID) int TaskManager::GetTaskMaxLevel(int TaskID) { - if (Tasks[TaskID]->MaxLevel) - { - return Tasks[TaskID]->MaxLevel; + if (Tasks[TaskID]->max_level) { + return Tasks[TaskID]->max_level; } return -1; @@ -1002,13 +1119,13 @@ void TaskManager::TaskSetSelector(Client *c, ClientTaskState *state, Mob *mob, i { int TaskList[MAXCHOOSERENTRIES]; int TaskListIndex = 0; - int PlayerLevel = c->GetLevel(); + int PlayerLevel = c->GetLevel(); - Log(Logs::General, Logs::Tasks, "[UPDATE] TaskSetSelector called for taskset %i. EnableTaskSize is %i", - TaskSetID, state->EnabledTasks.size()); + LogTasks("TaskSetSelector called for taskset [{}]. EnableTaskSize is [{}]", TaskSetID, state->enabled_tasks.size()); - if (TaskSetID <= 0 || TaskSetID >= MAXTASKSETS) + if (TaskSetID <= 0 || TaskSetID >= MAXTASKSETS) { return; + } if (TaskSets[TaskSetID].empty()) { mob->SayString(c, Chat::Yellow, MAX_ACTIVE_TASKS, c->GetName()); // I think this is suppose to be yellow @@ -1017,7 +1134,7 @@ void TaskManager::TaskSetSelector(Client *c, ClientTaskState *state, Mob *mob, i bool all_enabled = false; - // A TaskID of 0 in a TaskSet indicates that all Tasks in the set are enabled for all players. + // A task_id of 0 in a TaskSet indicates that all Tasks in the set are enabled for all players. if (TaskSets[TaskSetID][0] == 0) { Log(Logs::General, Logs::Tasks, "[UPDATE] TaskSets[%i][0] == 0. All Tasks in Set enabled.", TaskSetID); all_enabled = true; @@ -1025,94 +1142,114 @@ void TaskManager::TaskSetSelector(Client *c, ClientTaskState *state, Mob *mob, i auto Iterator = TaskSets[TaskSetID].begin(); - if (all_enabled) - ++Iterator; // skip first when all enabled since it's useless data + if (all_enabled) { + ++Iterator; + } // skip first when all enabled since it's useless data while (Iterator != TaskSets[TaskSetID].end() && TaskListIndex < 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 || state->IsTaskEnabled(task)) && AppropriateLevel(task, PlayerLevel) && - !state->IsTaskActive(task) && state->HasSlotForTask(Tasks[task]) && // this slot checking is a bit silly, but we allow mixing of task types ... - (IsTaskRepeatable(task) || !state->IsTaskCompleted(task))) + if ((all_enabled || state->IsTaskEnabled(task)) && ValidateLevel(task, PlayerLevel) && + !state->IsTaskActive(task) && state->HasSlotForTask(Tasks[task]) && + // this slot checking is a bit silly, but we allow mixing of task types ... + (IsTaskRepeatable(task) || !state->IsTaskCompleted(task))) { TaskList[TaskListIndex++] = task; + } ++Iterator; } if (TaskListIndex > 0) { SendTaskSelector(c, mob, TaskListIndex, TaskList); - } else { - mob->SayString(c, Chat::Yellow, MAX_ACTIVE_TASKS, c->GetName()); // check color, I think this might be only for (Shared) Tasks, w/e -- think should be yellow } - - return; + else { + // TODO: check color, I think this might be only for (Shared) Tasks, w/e -- think should be yellow + mob->SayString( + c, + Chat::Yellow, + MAX_ACTIVE_TASKS, + c->GetName() + ); + } } // unlike the non-Quest version of this function, it does not check enabled, that is assumed the responsibility of the quest to handle // we do however still want it to check the other stuff like level, active, room, etc void TaskManager::TaskQuestSetSelector(Client *c, ClientTaskState *state, Mob *mob, int count, int *tasks) { - int TaskList[MAXCHOOSERENTRIES]; - int TaskListIndex = 0; - int PlayerLevel = c->GetLevel(); + int task_list[MAXCHOOSERENTRIES]; + int task_list_index = 0; + int player_level = c->GetLevel(); - Log(Logs::General, Logs::Tasks, "[UPDATE] TaskQuestSetSelector called for array size %d", count); + LogTasks("[UPDATE] TaskQuestSetSelector called for array size [{}]", count); - if (count <= 0) + if (count <= 0) { return; + } for (int i = 0; i < count; ++i) { auto task = tasks[i]; // 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 (AppropriateLevel(task, PlayerLevel) && - !state->IsTaskActive(task) && state->HasSlotForTask(Tasks[task]) && // this slot checking is a bit silly, but we allow mixing of task types ... - (IsTaskRepeatable(task) || !state->IsTaskCompleted(task))) - TaskList[TaskListIndex++] = task; + if (ValidateLevel(task, player_level) && !state->IsTaskActive(task) && state->HasSlotForTask(Tasks[task]) && + // this slot checking is a bit silly, but we allow mixing of task types ... + (IsTaskRepeatable(task) || !state->IsTaskCompleted(task))) { + task_list[task_list_index++] = task; + } } - if (TaskListIndex > 0) { - SendTaskSelector(c, mob, TaskListIndex, TaskList); - } else { - mob->SayString(c, Chat::Yellow, MAX_ACTIVE_TASKS, c->GetName()); // check color, I think this might be only for (Shared) Tasks, w/e -- think should be yellow + if (task_list_index > 0) { + SendTaskSelector(c, mob, task_list_index, task_list); + } + else { + // TODO: check color, I think this might be only for (Shared) Tasks, w/e -- think should be yellow + mob->SayString( + c, + Chat::Yellow, + MAX_ACTIVE_TASKS, + c->GetName() + ); } - - return; } -void TaskManager::SendTaskSelector(Client *c, Mob *mob, int TaskCount, int *TaskList) { - - if (c->ClientVersion() >= EQ::versions::ClientVersion::RoF) - { +// sends task selector to client +void TaskManager::SendTaskSelector(Client *c, Mob *mob, int TaskCount, int *TaskList) +{ + if (c->ClientVersion() >= EQ::versions::ClientVersion::RoF) { SendTaskSelectorNew(c, mob, TaskCount, TaskList); return; } // Titanium OpCode: 0x5e7c - Log(Logs::General, Logs::Tasks, "[UPDATE] TaskSelector for %i Tasks", TaskCount); + LogTasks("TaskSelector for [{}] Tasks", TaskCount); int PlayerLevel = c->GetLevel(); // Check if any of the tasks exist for (int i = 0; i < TaskCount; i++) { - if (Tasks[TaskList[i]] != nullptr) + if (Tasks[TaskList[i]] != nullptr) { break; + } } int ValidTasks = 0; for (int i = 0; i < TaskCount; i++) { - if (!AppropriateLevel(TaskList[i], PlayerLevel)) + if (!ValidateLevel(TaskList[i], PlayerLevel)) { continue; - if (c->IsTaskActive(TaskList[i])) + } + if (c->IsTaskActive(TaskList[i])) { continue; - if (!IsTaskRepeatable(TaskList[i]) && c->IsTaskCompleted(TaskList[i])) + } + if (!IsTaskRepeatable(TaskList[i]) && c->IsTaskCompleted(TaskList[i])) { continue; + } ValidTasks++; } - if (ValidTasks == 0) + if (ValidTasks == 0) { return; + } SerializeBuffer buf(50 * ValidTasks); @@ -1122,38 +1259,43 @@ void TaskManager::SendTaskSelector(Client *c, Mob *mob, int TaskCount, int *Task buf.WriteUInt32(mob->GetID()); for (int i = 0; i < TaskCount; i++) { - if (!AppropriateLevel(TaskList[i], PlayerLevel)) + if (!ValidateLevel(TaskList[i], PlayerLevel)) { continue; - if (c->IsTaskActive(TaskList[i])) + } + if (c->IsTaskActive(TaskList[i])) { continue; - if (!IsTaskRepeatable(TaskList[i]) && c->IsTaskCompleted(TaskList[i])) + } + if (!IsTaskRepeatable(TaskList[i]) && c->IsTaskCompleted(TaskList[i])) { continue; + } - buf.WriteUInt32(TaskList[i]); // TaskID - if (c->ClientVersion() != EQ::versions::ClientVersion::Titanium) - buf.WriteFloat(1.0f); // affects color, difficulty? - buf.WriteUInt32(Tasks[TaskList[i]]->Duration); - buf.WriteUInt32(static_cast(Tasks[TaskList[i]]->dur_code)); + buf.WriteUInt32(TaskList[i]); // task_id - buf.WriteString(Tasks[TaskList[i]]->Title); // max 64 with null - buf.WriteString(Tasks[TaskList[i]]->Description); // max 4000 with null + // affects color, difficulty? + if (c->ClientVersion() != EQ::versions::ClientVersion::Titanium) { + buf.WriteFloat(1.0f); + } + buf.WriteUInt32(Tasks[TaskList[i]]->duration); + buf.WriteUInt32(static_cast(Tasks[TaskList[i]]->duration_code)); - if (c->ClientVersion() != EQ::versions::ClientVersion::Titanium) - buf.WriteUInt8(0); // Has reward set flag + buf.WriteString(Tasks[TaskList[i]]->title); // max 64 with null + buf.WriteString(Tasks[TaskList[i]]->description); // max 4000 with null - buf.WriteUInt32(Tasks[TaskList[i]]->ActivityCount); + // Has reward set flag + if (c->ClientVersion() != EQ::versions::ClientVersion::Titanium) { + buf.WriteUInt8(0); + } - for (int j = 0; j < Tasks[TaskList[i]]->ActivityCount; ++j) { - buf.WriteUInt32(j); // ActivityNumber - auto &activity = Tasks[TaskList[i]]->Activity[j]; + buf.WriteUInt32(Tasks[TaskList[i]]->activity_count); + + for (int j = 0; j < Tasks[TaskList[i]]->activity_count; ++j) { + buf.WriteUInt32(j); // ActivityNumber + auto &activity = Tasks[TaskList[i]]->activity_information[j]; buf.WriteUInt32(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) - - buf.WriteString(activity.item_list); // max length 64 in these clients - + 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) + buf.WriteString(activity.item_list); // max length 64 in these clients buf.WriteUInt32(activity.GoalCount); - buf.WriteInt32(activity.skill_id); buf.WriteInt32(activity.spell_id); buf.WriteInt32(activity.ZoneIDs.empty() ? 0 : activity.ZoneIDs.front()); @@ -1165,74 +1307,82 @@ void TaskManager::SendTaskSelector(Client *c, Mob *mob, int TaskCount, int *Task c->QueuePacket(outapp); safe_delete(outapp); - } void TaskManager::SendTaskSelectorNew(Client *c, Mob *mob, int TaskCount, int *TaskList) { - Log(Logs::General, Logs::Tasks, "[UPDATE] TaskSelector for %i Tasks", TaskCount); + LogTasks("SendTaskSelectorNew for [{}] Tasks", TaskCount); int PlayerLevel = c->GetLevel(); // Check if any of the tasks exist - for (int i = 0; i < TaskCount; i++) - if (Tasks[TaskList[i]] != nullptr) + for (int i = 0; i < TaskCount; i++) { + if (Tasks[TaskList[i]] != nullptr) { break; + } + } int ValidTasks = 0; for (int i = 0; i < TaskCount; i++) { - if (!AppropriateLevel(TaskList[i], PlayerLevel)) + if (!ValidateLevel(TaskList[i], PlayerLevel)) { continue; - if (c->IsTaskActive(TaskList[i])) + } + if (c->IsTaskActive(TaskList[i])) { continue; - if (!IsTaskRepeatable(TaskList[i]) && c->IsTaskCompleted(TaskList[i])) + } + if (!IsTaskRepeatable(TaskList[i]) && c->IsTaskCompleted(TaskList[i])) { continue; + } ValidTasks++; } - if (ValidTasks == 0) + if (ValidTasks == 0) { return; + } SerializeBuffer buf(50 * ValidTasks); - buf.WriteUInt32(ValidTasks); // TaskCount - buf.WriteUInt32(2); // Type, valid values: 0-3. 0 = Task, 1 = Shared Task, 2 = Quest, 3 = ??? -- should fix maybe some day, but we let more than 1 type through :P + buf.WriteUInt32(ValidTasks); // TaskCount + buf.WriteUInt32(2); // Type, valid values: 0-3. 0 = Task, 1 = Shared Task, 2 = Quest, 3 = ??? -- should fix maybe some day, but we let more than 1 type through :P // so I guess an NPC can only offer one type of quests or we can only open a selection with one type :P (so quest call can tell us I guess) // this is also sent in OP_TaskDescription - buf.WriteUInt32(mob->GetID()); // TaskGiver + buf.WriteUInt32(mob->GetID()); // TaskGiver for (int i = 0; i < TaskCount; i++) { // max 40 - if (!AppropriateLevel(TaskList[i], PlayerLevel)) + if (!ValidateLevel(TaskList[i], PlayerLevel)) { continue; - if (c->IsTaskActive(TaskList[i])) + } + if (c->IsTaskActive(TaskList[i])) { continue; - if (!IsTaskRepeatable(TaskList[i]) && c->IsTaskCompleted(TaskList[i])) + } + if (!IsTaskRepeatable(TaskList[i]) && c->IsTaskCompleted(TaskList[i])) { continue; + } - buf.WriteUInt32(TaskList[i]); // TaskID + buf.WriteUInt32(TaskList[i]); // task_id buf.WriteFloat(1.0f); // affects color, difficulty? - buf.WriteUInt32(Tasks[TaskList[i]]->Duration); - buf.WriteUInt32(static_cast(Tasks[TaskList[i]]->dur_code)); // 1 = Short, 2 = Medium, 3 = Long, anything else Unlimited + buf.WriteUInt32(Tasks[TaskList[i]]->duration); + buf.WriteUInt32(static_cast(Tasks[TaskList[i]]->duration_code)); // 1 = Short, 2 = Medium, 3 = Long, anything else Unlimited - buf.WriteString(Tasks[TaskList[i]]->Title); // max 64 with null - buf.WriteString(Tasks[TaskList[i]]->Description); // max 4000 with null + buf.WriteString(Tasks[TaskList[i]]->title); // max 64 with null + buf.WriteString(Tasks[TaskList[i]]->description); // max 4000 with null - buf.WriteUInt8(0); // Has reward set flag - buf.WriteUInt32(Tasks[TaskList[i]]->ActivityCount); // ActivityCount + buf.WriteUInt8(0); // Has reward set flag + buf.WriteUInt32(Tasks[TaskList[i]]->activity_count); // activity_count - for (int j = 0; j < Tasks[TaskList[i]]->ActivityCount; ++j) { - buf.WriteUInt32(j); // ActivityNumber - auto &activity = Tasks[TaskList[i]]->Activity[j]; - buf.WriteUInt32(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) + for (int j = 0; j < Tasks[TaskList[i]]->activity_count; ++j) { + buf.WriteUInt32(j); // ActivityNumber + auto &activity = Tasks[TaskList[i]]->activity_information[j]; + buf.WriteUInt32(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) // this string is item names buf.WriteLengthString(activity.item_list); - buf.WriteUInt32(activity.GoalCount); // GoalCount + buf.WriteUInt32(activity.GoalCount); // GoalCount // this string is skill IDs? probably one of the "use on" tasks buf.WriteLengthString(activity.skill_list); @@ -1240,11 +1390,11 @@ void TaskManager::SendTaskSelectorNew(Client *c, Mob *mob, int TaskCount, int *T // this string is spell IDs? probably one of the "use on" tasks buf.WriteLengthString(activity.spell_list); - //buf.WriteString(itoa(Tasks[TaskList[i]]->Activity[ActivityID].ZoneID)); - buf.WriteString(activity.zones); // Zone number in ascii max length 64, can be multiple with separated by ; - buf.WriteString(activity.desc_override); // max length 128 -- overrides the automatic descriptions + //buf.WriteString(itoa(Tasks[TaskList[i]]->activity_information[activity_id].ZoneID)); + buf.WriteString(activity.zones); // Zone number in ascii max length 64, can be multiple with separated by ; + buf.WriteString(activity.desc_override); // max length 128 -- overrides the automatic descriptions // this doesn't appear to be shown to the client at all and isn't the same as zones ... defaults to '0' though - buf.WriteString(activity.zones); // Zone number in ascii max length 64, probably can be separated by ; too, haven't found it used + buf.WriteString(activity.zones); // Zone number in ascii max length 64, probably can be separated by ; too, haven't found it used } } @@ -1252,47 +1402,50 @@ void TaskManager::SendTaskSelectorNew(Client *c, Mob *mob, int TaskCount, int *T c->QueuePacket(outapp); safe_delete(outapp); - } -int TaskManager::GetActivityCount(int TaskID) { +int TaskManager::GetActivityCount(int TaskID) +{ // Return the total number of activities in a particular task. - if((TaskID>0) && (TaskIDActivityCount; + if ((TaskID > 0) && (TaskID < MAXTASKS)) { + if (Tasks[TaskID]) { return Tasks[TaskID]->activity_count; } + } return 0; } -void TaskManager::ExplainTask(Client*c, int TaskID) { +void TaskManager::ExplainTask(Client *c, int TaskID) +{ // TODO: This method is not finished (hardly started). It was intended to - // explain in English, what each activity did, conditions for step unlocking, etc. + // explain in English, what each activity_information did, conditions for step unlocking, etc. // return; - if(!c) return; + if (!c) { return; } - if((TaskID<=0) || (TaskID>=MAXTASKS)) { - c->Message(Chat::White, "TaskID out-of-range."); + if ((TaskID <= 0) || (TaskID >= MAXTASKS)) { + c->Message(Chat::White, "task_id out-of-range."); return; } - if(Tasks[TaskID] == nullptr) { + if (Tasks[TaskID] == nullptr) { c->Message(Chat::White, "Task does not exist."); return; } - char Explanation[1000], *ptr; - c->Message(Chat::White, "Task %4i: Title: %s", TaskID, Tasks[TaskID]->Description.c_str()); - c->Message(Chat::White, "%3i Activities", Tasks[TaskID]->ActivityCount); - ptr = Explanation; - for(int i=0; iActivityCount; i++) { + char explanation[1000], *ptr; + c->Message(Chat::White, "Task %4i: title: %s", TaskID, Tasks[TaskID]->description.c_str()); + c->Message(Chat::White, "%3i Activities", Tasks[TaskID]->activity_count); + ptr = explanation; + for (int i = 0; i < Tasks[TaskID]->activity_count; i++) { - sprintf(ptr, "Act: %3i: ", i); ptr = ptr + strlen(ptr); - switch(Tasks[TaskID]->Activity[i].Type) { + sprintf(ptr, "Act: %3i: ", i); + ptr = ptr + strlen(ptr); + switch (Tasks[TaskID]->activity_information[i].Type) { case ActivityDeliver: sprintf(ptr, "Deliver"); break; @@ -1301,118 +1454,125 @@ void TaskManager::ExplainTask(Client*c, int TaskID) { } } -ClientTaskState::ClientTaskState() { - - ActiveTaskCount = 0; - LastCompletedTaskLoaded = 0; - CheckedTouchActivities = false; +ClientTaskState::ClientTaskState() +{ + active_task_count = 0; + last_completed_task_loaded = 0; + checked_touch_activities = false; for (int i = 0; i < MAXACTIVEQUESTS; i++) { - ActiveQuests[i].slot = i; - ActiveQuests[i].TaskID = TASKSLOTEMPTY; + active_quests[i].slot = i; + active_quests[i].task_id = TASKSLOTEMPTY; } - ActiveTask.slot = 0; - ActiveTask.TaskID = TASKSLOTEMPTY; + active_task.slot = 0; + active_task.task_id = TASKSLOTEMPTY; // TODO: shared task } -ClientTaskState::~ClientTaskState() { +ClientTaskState::~ClientTaskState() +{ } -int ClientTaskState::GetActiveTaskID(int index) { +int ClientTaskState::GetActiveTaskID(int index) +{ - // Return the TaskID from the client's specified Active Task slot. - - if((index<0) || (index>=MAXACTIVEQUESTS)) return 0; - - return ActiveQuests[index].TaskID; -} - -static void DeleteCompletedTaskFromDatabase(int charID, int taskID) { - - Log(Logs::General, Logs::Tasks, "[UPDATE] DeleteCompletedTasksFromDatabase. CharID = %i, TaskID = %i", charID, taskID); - - const std::string query = StringFormat("DELETE FROM completed_tasks WHERE charid=%i AND taskid = %i", charID, taskID); - auto results = database.QueryDatabase(query); - if(!results.Success()) { - return; + // Return the task_id from the client's specified Active Task slot. + if ((index < 0) || (index >= MAXACTIVEQUESTS)) { + return 0; } - Log(Logs::General, Logs::Tasks, "[UPDATE] Delete query %s", query.c_str()); + return active_quests[index].task_id; } -bool ClientTaskState::UnlockActivities(int CharID, ClientTaskInformation &task_info) +static void DeleteCompletedTaskFromDatabase(int character_id, int task_id) { - bool AllActivitiesComplete = true; + LogTasks("[DeleteCompletedTasksFromDatabase] character_id [{}], task_id [{}]", character_id, task_id); - TaskInformation* Task = taskmanager->Tasks[task_info.TaskID]; + CompletedTasksRepository::DeleteWhere( + database, + fmt::format("charid = {} and taskid = {}", character_id, task_id) + ); +} - if (Task == nullptr) +bool ClientTaskState::UnlockActivities(int character_id, ClientTaskInformation &task_info) +{ + bool all_activities_complete = true; + + TaskInformation *p_task_information = p_task_manager->Tasks[task_info.task_id]; + if (p_task_information == nullptr) { return true; + } // On loading the client state, all activities that are not completed, are // marked as hidden. For Sequential (non-stepped) mode, we mark the first - // activity as active if not complete. - Log(Logs::General, Logs::Tasks, "[UPDATE] CharID: %i Task: %i Sequence mode is %i", - CharID, task_info.TaskID, Task->SequenceMode); + // activity_information as active if not complete. + LogTasks( + "character_id [{}] task_id [{}] sequence_mode [{}]", + character_id, + task_info.task_id, + p_task_information->sequence_mode + ); - if (Task->SequenceMode == ActivitiesSequential) { - if (task_info.Activity[0].State != ActivityCompleted) - task_info.Activity[0].State = ActivityActive; + if (p_task_information->sequence_mode == ActivitiesSequential) { + if (task_info.activity[0].activity_state != ActivityCompleted) { + task_info.activity[0].activity_state = ActivityActive; + } // Enable the next Hidden task. - for (int i = 0; i < Task->ActivityCount; i++) { - if ((task_info.Activity[i].State == ActivityActive) && - (!Task->Activity[i].Optional)) { - AllActivitiesComplete = false; + for (int i = 0; i < p_task_information->activity_count; i++) { + if ((task_info.activity[i].activity_state == ActivityActive) && + (!p_task_information->activity_information[i].Optional)) { + all_activities_complete = false; break; } - if (task_info.Activity[i].State == ActivityHidden) { - task_info.Activity[i].State = ActivityActive; - AllActivitiesComplete = false; + if (task_info.activity[i].activity_state == ActivityHidden) { + task_info.activity[i].activity_state = ActivityActive; + all_activities_complete = false; break; } } - if (AllActivitiesComplete && RuleB(TaskSystem, RecordCompletedTasks)) { + if (all_activities_complete && RuleB(TaskSystem, RecordCompletedTasks)) { if (RuleB(TasksSystem, KeepOneRecordPerCompletedTask)) { - Log(Logs::General, Logs::Tasks, "[UPDATE] KeepOneRecord enabled"); - auto Iterator = CompletedTasks.begin(); - int ErasedElements = 0; - while (Iterator != CompletedTasks.end()) { - int TaskID = (*Iterator).TaskID; - if (TaskID == task_info.TaskID) { - Iterator = CompletedTasks.erase(Iterator); - ErasedElements++; - } else - ++Iterator; + LogTasks("KeepOneRecord enabled"); + auto iterator = completed_tasks.begin(); + int erased_elements = 0; + while (iterator != completed_tasks.end()) { + int task_id = (*iterator).task_id; + if (task_id == task_info.task_id) { + iterator = completed_tasks.erase(iterator); + erased_elements++; + } + else { + ++iterator; + } } - Log(Logs::General, Logs::Tasks, "[UPDATE] Erased Element count is %i", ErasedElements); + LogTasks("Erased Element count is [{}]", erased_elements); - if (ErasedElements) { - LastCompletedTaskLoaded -= ErasedElements; - DeleteCompletedTaskFromDatabase(CharID, task_info.TaskID); + if (erased_elements) { + last_completed_task_loaded -= erased_elements; + DeleteCompletedTaskFromDatabase(character_id, task_info.task_id); } } - CompletedTaskInformation cti; - cti.TaskID = task_info.TaskID; - cti.CompletedTime = time(nullptr); + CompletedTaskInformation completed_task_information{}; + completed_task_information.task_id = task_info.task_id; + completed_task_information.completed_time = time(nullptr); - for (int i = 0; i < Task->ActivityCount; i++) - cti.ActivityDone[i] = (task_info.Activity[i].State == ActivityCompleted); + for (int i = 0; i < p_task_information->activity_count; i++) { + completed_task_information.activity_done[i] = (task_info.activity[i].activity_state == ActivityCompleted); + } - CompletedTasks.push_back(cti); + completed_tasks.push_back(completed_task_information); } - Log(Logs::General, Logs::Tasks, "[UPDATE] Returning sequential task, AllActivitiesComplete is %i", - AllActivitiesComplete); + LogTasks("Returning sequential task, AllActivitiesComplete is [{}]", all_activities_complete); - return AllActivitiesComplete; + return all_activities_complete; } // Stepped Mode @@ -1420,242 +1580,264 @@ bool ClientTaskState::UnlockActivities(int CharID, ClientTaskInformation &task_i bool CurrentStepComplete = true; - Log(Logs::General, Logs::Tasks, "[UPDATE] Current Step is %i, Last Step is %i", task_info.CurrentStep, - Task->LastStep); - // If CurrentStep is -1, this is the first call to this method since loading the + Log(Logs::General, Logs::Tasks, "[UPDATE] Current Step is %i, Last Step is %i", task_info.current_step, + p_task_information->last_step); + // If current_step is -1, this is the first call to this method since loading the // client state. Unlock all activities with a step number of 0 - if (task_info.CurrentStep == -1) { - for (int i = 0; i < Task->ActivityCount; i++) { - if (Task->Activity[i].StepNumber == 0 && task_info.Activity[i].State == ActivityHidden) { - task_info.Activity[i].State = ActivityActive; - // task_info.Activity[i].Updated=true; + if (task_info.current_step == -1) { + for (int i = 0; i < p_task_information->activity_count; i++) { + if (p_task_information->activity_information[i].StepNumber == 0 && task_info.activity[i].activity_state == ActivityHidden) { + task_info.activity[i].activity_state = ActivityActive; + // task_info.activity_information[i].updated=true; } } - task_info.CurrentStep = 0; + task_info.current_step = 0; } - for (int Step = task_info.CurrentStep; Step <= Task->LastStep; Step++) { - for (int Activity = 0; Activity < Task->ActivityCount; Activity++) { - if (Task->Activity[Activity].StepNumber == (int)task_info.CurrentStep) { - if ((task_info.Activity[Activity].State != ActivityCompleted) && - (!Task->Activity[Activity].Optional)) { - CurrentStepComplete = false; - AllActivitiesComplete = false; + for (int Step = task_info.current_step; Step <= p_task_information->last_step; Step++) { + for (int Activity = 0; Activity < p_task_information->activity_count; Activity++) { + if (p_task_information->activity_information[Activity].StepNumber == (int) task_info.current_step) { + if ((task_info.activity[Activity].activity_state != ActivityCompleted) && + (!p_task_information->activity_information[Activity].Optional)) { + CurrentStepComplete = false; + all_activities_complete = false; break; } } } - if (!CurrentStepComplete) + if (!CurrentStepComplete) { break; - task_info.CurrentStep++; + } + task_info.current_step++; } - if (AllActivitiesComplete) { + if (all_activities_complete) { if (RuleB(TaskSystem, RecordCompletedTasks)) { // If we are only keeping one completed record per task, and the player has done // the same task again, erase the previous completed entry for this task. if (RuleB(TasksSystem, KeepOneRecordPerCompletedTask)) { - Log(Logs::General, Logs::Tasks, "[UPDATE] KeepOneRecord enabled"); - auto Iterator = CompletedTasks.begin(); - int ErasedElements = 0; + LogTasksDetail("[UnlockActivities] KeepOneRecord enabled"); + auto iterator = completed_tasks.begin(); + int erased_elements = 0; - while (Iterator != CompletedTasks.end()) { - int TaskID = (*Iterator).TaskID; - if (TaskID == task_info.TaskID) { - Iterator = CompletedTasks.erase(Iterator); - ErasedElements++; - } else - ++Iterator; + while (iterator != completed_tasks.end()) { + int task_id = (*iterator).task_id; + if (task_id == task_info.task_id) { + iterator = completed_tasks.erase(iterator); + erased_elements++; + } + else { + ++iterator; + } } - Log(Logs::General, Logs::Tasks, "[UPDATE] Erased Element count is %i", ErasedElements); + LogTasksDetail("[UnlockActivities] Erased Element count is [{}]", erased_elements); - if (ErasedElements) { - LastCompletedTaskLoaded -= ErasedElements; - DeleteCompletedTaskFromDatabase(CharID, task_info.TaskID); + if (erased_elements) { + last_completed_task_loaded -= erased_elements; + DeleteCompletedTaskFromDatabase(character_id, task_info.task_id); } } - CompletedTaskInformation cti; - cti.TaskID = task_info.TaskID; - cti.CompletedTime = time(nullptr); + CompletedTaskInformation completed_task_information{}; + completed_task_information.task_id = task_info.task_id; + completed_task_information.completed_time = time(nullptr); - for (int i = 0; i < Task->ActivityCount; i++) - cti.ActivityDone[i] = (task_info.Activity[i].State == ActivityCompleted); - - CompletedTasks.push_back(cti); + for (int i = 0; i < p_task_information->activity_count; i++) { + completed_task_information.activity_done[i] = (task_info.activity[i].activity_state == ActivityCompleted); + } + + completed_tasks.push_back(completed_task_information); } return true; } // Mark all non-completed tasks in the current step as active - // - for (int Activity = 0; Activity < Task->ActivityCount; Activity++) { - if ((Task->Activity[Activity].StepNumber == (int)task_info.CurrentStep) && - (task_info.Activity[Activity].State == ActivityHidden)) { - task_info.Activity[Activity].State = ActivityActive; - task_info.Activity[Activity].Updated = true; + for (int activity = 0; activity < p_task_information->activity_count; activity++) { + if ((p_task_information->activity_information[activity].StepNumber == (int) task_info.current_step) && + (task_info.activity[activity].activity_state == ActivityHidden)) { + task_info.activity[activity].activity_state = ActivityActive; + task_info.activity[activity].updated = true; } } return false; } -void ClientTaskState::UpdateTasksOnKill(Client *c, int NPCTypeID) { - +void ClientTaskState::UpdateTasksOnKill(Client *c, int NPCTypeID) +{ UpdateTasksByNPC(c, ActivityKill, NPCTypeID); - } -bool ClientTaskState::UpdateTasksOnSpeakWith(Client *c, int NPCTypeID) { - +bool ClientTaskState::UpdateTasksOnSpeakWith(Client *c, int NPCTypeID) +{ return UpdateTasksByNPC(c, ActivitySpeakWith, NPCTypeID); - } -bool ClientTaskState::UpdateTasksByNPC(Client *c, int ActivityType, int NPCTypeID) { +bool ClientTaskState::UpdateTasksByNPC(Client *c, int activity_type, int npc_type_id) +{ - int Ret = false; - - Log(Logs::General, Logs::Tasks, "[UPDATE] ClientTaskState::UpdateTasks for NPCTypeID: %d", NPCTypeID); + int is_updating = false; // If the client has no tasks, there is nothing further to check. - - if (!taskmanager || (ActiveTaskCount == 0 && ActiveTask.TaskID == TASKSLOTEMPTY)) // could be better ... + if (!p_task_manager || (active_task_count == 0 && 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 cur_task = &ActiveTasks[i]; - if (cur_task->TaskID == TASKSLOTEMPTY) + for (auto & ActiveTask : ActiveTasks) { + auto current_task = &ActiveTask; + if (current_task->task_id == TASKSLOTEMPTY) { continue; + } - // Check if there are any active kill activities for this task - - auto Task = taskmanager->Tasks[cur_task->TaskID]; - - if (Task == nullptr) + // Check if there are any active kill activities for this p_task_information + auto p_task_information = p_task_manager->Tasks[current_task->task_id]; + if (p_task_information == nullptr) { return false; + } - for (int j = 0; j < Task->ActivityCount; j++) { + for (int activity_id = 0; activity_id < p_task_information->activity_count; activity_id++) { // We are not interested in completed or hidden activities - if (cur_task->Activity[j].State != ActivityActive) + if (current_task->activity[activity_id].activity_state != ActivityActive) { continue; + } // We are only interested in Kill activities - if (Task->Activity[j].Type != ActivityType) - continue; - // Is there a zone restriction on the activity ? - if (!Task->Activity[j].CheckZone(zone->GetZoneID())) { - Log(Logs::General, Logs::Tasks, - "[UPDATE] Char: %s Task: %i, Activity %i, Activity type %i for NPC %i failed zone " - "check", - c->GetName(), cur_task->TaskID, j, ActivityType, NPCTypeID); + if (p_task_information->activity_information[activity_id].Type != activity_type) { continue; } - // Is the activity to kill this type of NPC ? - switch (Task->Activity[j].GoalMethod) { - - case METHODSINGLEID: - if (Task->Activity[j].GoalID != NPCTypeID) - continue; - break; - - case METHODLIST: - if (!taskmanager->GoalListManager.IsInList(Task->Activity[j].GoalID, NPCTypeID)) - continue; - break; - - default: - // If METHODQUEST, don't update the activity here + // Is there a zone restriction on the activity_information ? + if (!p_task_information->activity_information[activity_id].CheckZone(zone->GetZoneID())) { + LogTasks( + "[UPDATE] character [{}] task_id [{}] activity_id [{}] activity_type [{}] for NPC [{}] failed zone check", + c->GetName(), + current_task->task_id, + activity_id, + activity_type, + npc_type_id + ); continue; } - // We found an active task to kill this type of NPC, so increment the done count - Log(Logs::General, Logs::Tasks, "[UPDATE] Calling increment done count ByNPC"); - IncrementDoneCount(c, Task, cur_task->slot, j); - Ret = true; + // Is the activity_information to kill this type of NPC ? + switch (p_task_information->activity_information[activity_id].GoalMethod) { + case METHODSINGLEID: + if (p_task_information->activity_information[activity_id].GoalID != npc_type_id) { + continue; + } + break; + + case METHODLIST: + if (!p_task_manager->GoalListManager.IsInList(p_task_information->activity_information[activity_id].GoalID, npc_type_id)) { + continue; + } + break; + + default: + // If METHODQUEST, don't updated the activity_information here + continue; + } + // We found an active p_task_information to kill this type of NPC, so increment the done count + LogTasksDetail("Calling increment done count ByNPC"); + IncrementDoneCount(c, p_task_information, current_task->slot, activity_id); + is_updating = true; } } - return Ret; + return is_updating; } -int ClientTaskState::ActiveSpeakTask(int NPCTypeID) { +int ClientTaskState::ActiveSpeakTask(int npc_type_id) +{ - // This method is to be used from Perl quests only and returns the TaskID of the first - // active task found which has an active SpeakWith activity for this NPC. - - if (!taskmanager || (ActiveTaskCount == 0 && ActiveTask.TaskID == TASKSLOTEMPTY)) // could be better ... + // 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 ... return 0; + } // loop over the union of tasks and quests - for (int i = 0; i < MAXACTIVEQUESTS + 1; i++) { - auto cur_task = &ActiveTasks[i]; - if (cur_task->TaskID == TASKSLOTEMPTY) + for (auto & active_task : ActiveTasks) { + auto current_task = &active_task; + if (current_task->task_id == TASKSLOTEMPTY) { continue; + } - TaskInformation* Task = taskmanager->Tasks[cur_task->TaskID]; - - if (Task == nullptr) + TaskInformation *p_task_information = p_task_manager->Tasks[current_task->task_id]; + if (p_task_information == nullptr) { continue; + } - for (int j = 0; j < Task->ActivityCount; j++) { + for (int activity_id = 0; activity_id < p_task_information->activity_count; activity_id++) { // We are not interested in completed or hidden activities - if (cur_task->Activity[j].State != ActivityActive) + if (current_task->activity[activity_id].activity_state != ActivityActive) { continue; - if (Task->Activity[j].Type != ActivitySpeakWith) + } + if (p_task_information->activity_information[activity_id].Type != ActivitySpeakWith) { continue; - // Is there a zone restriction on the activity ? - if (!Task->Activity[j].CheckZone(zone->GetZoneID())) + } + // Is there a zone restriction on the activity_information ? + if (!p_task_information->activity_information[activity_id].CheckZone(zone->GetZoneID())) { continue; - // Is the activity to speak with this type of NPC ? - if (Task->Activity[j].GoalMethod == METHODQUEST && Task->Activity[j].GoalID == NPCTypeID) - return cur_task->TaskID; + } + // Is the activity_information to speak with this type of NPC ? + if (p_task_information->activity_information[activity_id].GoalMethod == METHODQUEST && p_task_information->activity_information[activity_id].GoalID == npc_type_id) { + return current_task->task_id; + } } } return 0; } -int ClientTaskState::ActiveSpeakActivity(int NPCTypeID, int TaskID) { +int ClientTaskState::ActiveSpeakActivity(int npc_type_id, int task_id) +{ - // This method is to be used from Perl quests only and returns the ActivityID of the first - // active activity found in the specified task which is to SpeakWith this NPC. - - if (!taskmanager || (ActiveTaskCount == 0 && ActiveTask.TaskID == TASKSLOTEMPTY)) // could be better ... + // 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 ... return -1; - if (TaskID <= 0 || TaskID >= MAXTASKS) + } + if (task_id <= 0 || task_id >= MAXTASKS) { return -1; + } // loop over the union of tasks and quests - for (int i = 0; i < MAXACTIVEQUESTS + 1; i++) { - auto cur_task = &ActiveTasks[i]; - if (cur_task->TaskID != TaskID) + for (auto & ActiveTask : ActiveTasks) { + auto current_task = &ActiveTask; + if (current_task->task_id != task_id) { continue; + } - TaskInformation* Task = taskmanager->Tasks[cur_task->TaskID]; - - if (Task == nullptr) + TaskInformation *p_task_information = p_task_manager->Tasks[current_task->task_id]; + if (p_task_information == nullptr) { continue; + } - for (int j = 0; j < Task->ActivityCount; j++) { + for (int activity_index = 0; activity_index < p_task_information->activity_count; activity_index++) { // We are not interested in completed or hidden activities - if (cur_task->Activity[j].State != ActivityActive) + if (current_task->activity[activity_index].activity_state != ActivityActive) { continue; - if (Task->Activity[j].Type != ActivitySpeakWith) + } + if (p_task_information->activity_information[activity_index].Type != ActivitySpeakWith) { continue; - // Is there a zone restriction on the activity ? - if (!Task->Activity[j].CheckZone(zone->GetZoneID())) + } + // Is there a zone restriction on the activity_information ? + if (!p_task_information->activity_information[activity_index].CheckZone(zone->GetZoneID())) { continue; - // Is the activity to speak with this type of NPC ? - if (Task->Activity[j].GoalMethod == METHODQUEST && Task->Activity[j].GoalID == NPCTypeID) - return j; + } + // Is the activity_information to speak with this type of NPC ? + if (p_task_information->activity_information[activity_index].GoalMethod == METHODQUEST && + p_task_information->activity_information[activity_index].GoalID == npc_type_id) { + return activity_index; + } } return 0; } return 0; } -void ClientTaskState::UpdateTasksForItem(Client *c, ActivityType Type, int ItemID, int Count) { +void ClientTaskState::UpdateTasksForItem(Client *c, ActivityType Type, int ItemID, int Count) +{ // This method updates the client's task activities of the specified type which relate // to the specified item. @@ -1666,49 +1848,54 @@ void ClientTaskState::UpdateTasksForItem(Client *c, ActivityType Type, int ItemI Log(Logs::General, Logs::Tasks, "[UPDATE] ClientTaskState::UpdateTasksForItem(%d,%d)", Type, ItemID); - if (!taskmanager || (ActiveTaskCount == 0 && ActiveTask.TaskID == TASKSLOTEMPTY)) // could be better ... + if (!p_task_manager || (active_task_count == 0 && active_task.task_id == TASKSLOTEMPTY)) { // could be better ... return; + } // loop over the union of tasks and quests for (int i = 0; i < MAXACTIVEQUESTS + 1; i++) { auto cur_task = &ActiveTasks[i]; - if (cur_task->TaskID == TASKSLOTEMPTY) + if (cur_task->task_id == TASKSLOTEMPTY) { continue; + } // Check if there are any active loot activities for this task - TaskInformation* Task = taskmanager->Tasks[cur_task->TaskID]; + TaskInformation *Task = p_task_manager->Tasks[cur_task->task_id]; - if (Task == nullptr) + if (Task == nullptr) { return; + } - for (int j = 0; j < Task->ActivityCount; j++) { + for (int j = 0; j < Task->activity_count; j++) { // We are not interested in completed or hidden activities - if (cur_task->Activity[j].State != ActivityActive) - continue; - // We are only interested in the ActivityType we were called with - if (Task->Activity[j].Type != (int)Type) - continue; - // Is there a zone restriction on the activity ? - if (!Task->Activity[j].CheckZone(zone->GetZoneID())) { - Log(Logs::General, Logs::Tasks, "[UPDATE] Char: %s Activity type %i for Item %i failed zone check", - c->GetName(), Type, ItemID); + if (cur_task->activity[j].activity_state != ActivityActive) { continue; } - // Is the activity related to this item ? + // We are only interested in the ActivityType we were called with + if (Task->activity_information[j].Type != (int) Type) { + continue; + } + // Is there a zone restriction on the activity_information ? + if (!Task->activity_information[j].CheckZone(zone->GetZoneID())) { + Log(Logs::General, Logs::Tasks, "[UPDATE] Char: %s activity_information type %i for Item %i failed zone check", + c->GetName(), Type, ItemID); + continue; + } + // Is the activity_information related to this item ? // - switch(Task->Activity[j].GoalMethod) { + switch (Task->activity_information[j].GoalMethod) { case METHODSINGLEID: - if(Task->Activity[j].GoalID != ItemID) continue; + if (Task->activity_information[j].GoalID != ItemID) { continue; } break; case METHODLIST: - if(!taskmanager->GoalListManager.IsInList(Task->Activity[j].GoalID, ItemID)) continue; + if (!p_task_manager->GoalListManager.IsInList(Task->activity_information[j].GoalID, ItemID)) { continue; } break; default: - // If METHODQUEST, don't update the activity here + // If METHODQUEST, don't updated the activity_information here continue; } // We found an active task related to this item, so increment the done count @@ -1726,57 +1913,66 @@ void ClientTaskState::UpdateTasksOnExplore(Client *c, int ExploreID) // If the client has no tasks, there is nothing further to check. Log(Logs::General, Logs::Tasks, "[UPDATE] ClientTaskState::UpdateTasksOnExplore(%i)", ExploreID); - if (!taskmanager || (ActiveTaskCount == 0 && ActiveTask.TaskID == TASKSLOTEMPTY)) // could be better ... + if (!p_task_manager || (active_task_count == 0 && active_task.task_id == TASKSLOTEMPTY)) { // could be better ... return; + } // loop over the union of tasks and quests for (int i = 0; i < MAXACTIVEQUESTS + 1; i++) { auto cur_task = &ActiveTasks[i]; - if (cur_task->TaskID == TASKSLOTEMPTY) + if (cur_task->task_id == TASKSLOTEMPTY) { continue; + } // Check if there are any active explore activities for this task - TaskInformation *Task = taskmanager->Tasks[cur_task->TaskID]; + TaskInformation *Task = p_task_manager->Tasks[cur_task->task_id]; - if (Task == nullptr) + if (Task == nullptr) { return; + } - for (int j = 0; j < Task->ActivityCount; j++) { + for (int j = 0; j < Task->activity_count; j++) { // We are not interested in completed or hidden activities - if (cur_task->Activity[j].State != ActivityActive) - continue; - // We are only interested in explore activities - if (Task->Activity[j].Type != ActivityExplore) - continue; - if (!Task->Activity[j].CheckZone(zone->GetZoneID())) { - Log(Logs::General, Logs::Tasks, - "[UPDATE] Char: %s Explore exploreid %i failed zone check", c->GetName(), - ExploreID); + if (cur_task->activity[j].activity_state != ActivityActive) { continue; } - // Is the activity to explore this area id ? - switch (Task->Activity[j].GoalMethod) { - - case METHODSINGLEID: - if (Task->Activity[j].GoalID != ExploreID) - continue; - break; - - case METHODLIST: - if (!taskmanager->GoalListManager.IsInList(Task->Activity[j].GoalID, ExploreID)) - continue; - break; - - default: - // If METHODQUEST, don't update the activity here + // We are only interested in explore activities + if (Task->activity_information[j].Type != ActivityExplore) { continue; } + if (!Task->activity_information[j].CheckZone(zone->GetZoneID())) { + Log(Logs::General, Logs::Tasks, + "[UPDATE] Char: %s Explore exploreid %i failed zone check", c->GetName(), + ExploreID); + continue; + } + // Is the activity_information to explore this area id ? + switch (Task->activity_information[j].GoalMethod) { + + case METHODSINGLEID: + if (Task->activity_information[j].GoalID != ExploreID) { + continue; + } + break; + + case METHODLIST: + if (!p_task_manager->GoalListManager.IsInList(Task->activity_information[j].GoalID, ExploreID)) { + continue; + } + break; + + default: + // If METHODQUEST, don't updated the activity_information here + continue; + } // We found an active task to explore this area, so set done count to goal count // (Only a goal count of 1 makes sense for explore activities?) Log(Logs::General, Logs::Tasks, "[UPDATE] Increment on explore"); - IncrementDoneCount(c, Task, cur_task->slot, j, - Task->Activity[j].GoalCount - cur_task->Activity[j].DoneCount); + IncrementDoneCount( + c, Task, cur_task->slot, j, + Task->activity_information[j].GoalCount - cur_task->activity[j].done_count + ); } } @@ -1789,64 +1985,74 @@ bool ClientTaskState::UpdateTasksOnDeliver(Client *c, std::listTaskID == TASKSLOTEMPTY) + if (cur_task->task_id == TASKSLOTEMPTY) { continue; + } // Check if there are any active deliver activities for this task - TaskInformation *Task = taskmanager->Tasks[cur_task->TaskID]; + TaskInformation *Task = p_task_manager->Tasks[cur_task->task_id]; - if (Task == nullptr) + if (Task == nullptr) { return false; + } - for (int j = 0; j < Task->ActivityCount; j++) { + for (int j = 0; j < Task->activity_count; j++) { // We are not interested in completed or hidden activities - if (cur_task->Activity[j].State != ActivityActive) - continue; - // We are only interested in Deliver activities - if (Task->Activity[j].Type != ActivityDeliver && Task->Activity[j].Type != ActivityGiveCash) - continue; - // Is there a zone restriction on the activity ? - if (!Task->Activity[j].CheckZone(zone->GetZoneID())) { - Log(Logs::General, Logs::Tasks, - "[UPDATE] Char: %s Deliver activity failed zone check (current zone %i, need zone " - "%s", - c->GetName(), zone->GetZoneID(), Task->Activity[j].zones.c_str()); + if (cur_task->activity[j].activity_state != ActivityActive) { continue; } - // Is the activity to deliver to this NPCTypeID ? - if (Task->Activity[j].DeliverToNPC != NPCTypeID) + // We are only interested in Deliver activities + if (Task->activity_information[j].Type != ActivityDeliver && Task->activity_information[j].Type != ActivityGiveCash) { continue; - // Is the activity related to these items ? + } + // Is there a zone restriction on the activity_information ? + if (!Task->activity_information[j].CheckZone(zone->GetZoneID())) { + Log(Logs::General, Logs::Tasks, + "[UPDATE] Char: %s Deliver activity_information failed zone check (current zone %i, need zone " + "%s", + c->GetName(), zone->GetZoneID(), Task->activity_information[j].zones.c_str()); + continue; + } + // Is the activity_information to deliver to this NPCTypeID ? + if (Task->activity_information[j].DeliverToNPC != NPCTypeID) { + continue; + } + // Is the activity_information related to these items ? // - if ((Task->Activity[j].Type == ActivityGiveCash) && Cash) { + if ((Task->activity_information[j].Type == ActivityGiveCash) && Cash) { Log(Logs::General, Logs::Tasks, "[UPDATE] Increment on GiveCash"); IncrementDoneCount(c, Task, i, j, Cash); Ret = true; - } else { + } + else { for (auto &k : Items) { - switch (Task->Activity[j].GoalMethod) { + switch (Task->activity_information[j].GoalMethod) { - case METHODSINGLEID: - if (Task->Activity[j].GoalID != k->GetID()) + case METHODSINGLEID: + if (Task->activity_information[j].GoalID != k->GetID()) { + continue; + } + break; + + case METHODLIST: + if (!p_task_manager->GoalListManager.IsInList( + Task->activity_information[j].GoalID, + k->GetID())) { + continue; + } + break; + + default: + // If METHODQUEST, don't updated the activity_information here continue; - break; - - case METHODLIST: - if (!taskmanager->GoalListManager.IsInList(Task->Activity[j].GoalID, - k->GetID())) - continue; - break; - - default: - // If METHODQUEST, don't update the activity here - continue; } // We found an active task related to this item, so increment the done count Log(Logs::General, Logs::Tasks, "[UPDATE] Increment on GiveItem"); @@ -1865,99 +2071,124 @@ void ClientTaskState::UpdateTasksOnTouch(Client *c, int ZoneID) // If the client has no tasks, there is nothing further to check. Log(Logs::General, Logs::Tasks, "[UPDATE] ClientTaskState::UpdateTasksOnTouch(%i)", ZoneID); - if (!taskmanager || (ActiveTaskCount == 0 && ActiveTask.TaskID == TASKSLOTEMPTY)) // could be better ... + if (!p_task_manager || (active_task_count == 0 && active_task.task_id == TASKSLOTEMPTY)) { // could be better ... return; + } // loop over the union of tasks and quests for (int i = 0; i < MAXACTIVEQUESTS + 1; i++) { auto cur_task = &ActiveTasks[i]; - if (cur_task->TaskID == TASKSLOTEMPTY) + if (cur_task->task_id == TASKSLOTEMPTY) { continue; + } // Check if there are any active explore activities for this task - TaskInformation *Task = taskmanager->Tasks[cur_task->TaskID]; + TaskInformation *Task = p_task_manager->Tasks[cur_task->task_id]; - if (Task == nullptr) + if (Task == nullptr) { return; + } - for (int j = 0; j < Task->ActivityCount; j++) { + for (int j = 0; j < Task->activity_count; j++) { // We are not interested in completed or hidden activities - if (cur_task->Activity[j].State != ActivityActive) + if (cur_task->activity[j].activity_state != ActivityActive) { continue; + } // We are only interested in touch activities - if (Task->Activity[j].Type != ActivityTouch) + if (Task->activity_information[j].Type != ActivityTouch) { continue; - if (Task->Activity[j].GoalMethod != METHODSINGLEID) + } + if (Task->activity_information[j].GoalMethod != METHODSINGLEID) { continue; - if (!Task->Activity[j].CheckZone(ZoneID)) { - Log(Logs::General, Logs::Tasks, "[UPDATE] Char: %s Touch activity failed zone check", - c->GetName()); + } + if (!Task->activity_information[j].CheckZone(ZoneID)) { + Log(Logs::General, Logs::Tasks, "[UPDATE] Char: %s Touch activity_information failed zone check", + c->GetName()); continue; } // We found an active task to zone into this zone, so set done count to goal count // (Only a goal count of 1 makes sense for touch activities?) Log(Logs::General, Logs::Tasks, "[UPDATE] Increment on Touch"); - IncrementDoneCount(c, Task, cur_task->slot, j, - Task->Activity[j].GoalCount - cur_task->Activity[j].DoneCount); + IncrementDoneCount( + c, Task, cur_task->slot, j, + Task->activity_information[j].GoalCount - cur_task->activity[j].done_count + ); } } return; } -void ClientTaskState::IncrementDoneCount(Client *c, TaskInformation *Task, int TaskIndex, int ActivityID, int Count, - bool ignore_quest_update) +void ClientTaskState::IncrementDoneCount( + Client *c, TaskInformation *Task, int TaskIndex, int ActivityID, int Count, + bool ignore_quest_update +) { Log(Logs::General, Logs::Tasks, "[UPDATE] IncrementDoneCount"); auto info = GetClientTaskInfo(Task->type, TaskIndex); - if (info == nullptr) + if (info == nullptr) { return; + } - info->Activity[ActivityID].DoneCount += Count; + info->activity[ActivityID].done_count += Count; - if(info->Activity[ActivityID].DoneCount > Task->Activity[ActivityID].GoalCount) - info->Activity[ActivityID].DoneCount = Task->Activity[ActivityID].GoalCount; + if (info->activity[ActivityID].done_count > Task->activity_information[ActivityID].GoalCount) { + info->activity[ActivityID].done_count = Task->activity_information[ActivityID].GoalCount; + } - if (!ignore_quest_update){ + if (!ignore_quest_update) { char buf[24]; - snprintf(buf, 23, "%d %d %d", info->Activity[ActivityID].DoneCount, info->Activity[ActivityID].ActivityID, info->TaskID); + snprintf( + buf, + 23, + "%d %d %d", + info->activity[ActivityID].done_count, + info->activity[ActivityID].activity_id, + info->task_id + ); buf[23] = '\0'; parse->EventPlayer(EVENT_TASK_UPDATE, c, buf, 0); } - info->Activity[ActivityID].Updated=true; - // Have we reached the goal count for this activity ? - if(info->Activity[ActivityID].DoneCount >= Task->Activity[ActivityID].GoalCount) { - Log(Logs::General, Logs::Tasks, "[UPDATE] Done (%i) = Goal (%i) for Activity %i", - info->Activity[ActivityID].DoneCount, - Task->Activity[ActivityID].GoalCount, - ActivityID); + info->activity[ActivityID].updated = true; + // Have we reached the goal count for this activity_information ? + if (info->activity[ActivityID].done_count >= Task->activity_information[ActivityID].GoalCount) { + Log(Logs::General, Logs::Tasks, "[UPDATE] Done (%i) = Goal (%i) for activity_information %i", + info->activity[ActivityID].done_count, + Task->activity_information[ActivityID].GoalCount, + ActivityID); - // Flag the activity as complete - info->Activity[ActivityID].State = ActivityCompleted; + // Flag the activity_information as complete + info->activity[ActivityID].activity_state = ActivityCompleted; // Unlock subsequent activities for this task bool TaskComplete = UnlockActivities(c->CharacterID(), *info); Log(Logs::General, Logs::Tasks, "[UPDATE] TaskCompleted is %i", TaskComplete); // and by the 'Task Stage Completed' message - c->SendTaskActivityComplete(info->TaskID, ActivityID, TaskIndex, Task->type); - // Send the updated task/activity list to the client - taskmanager->SendSingleActiveTaskToClient(c, *info, TaskComplete, false); + c->SendTaskActivityComplete(info->task_id, ActivityID, TaskIndex, Task->type); + // Send the updated task/activity_information list to the client + p_task_manager->SendSingleActiveTaskToClient(c, *info, TaskComplete, false); // Inform the client the task has been updated, both by a chat message - c->Message(Chat::White, "Your task '%s' has been updated.", Task->Title.c_str()); + c->Message(Chat::White, "Your task '%s' has been updated.", Task->title.c_str()); - if(Task->Activity[ActivityID].GoalMethod != METHODQUEST) { - if (!ignore_quest_update){ + if (Task->activity_information[ActivityID].GoalMethod != METHODQUEST) { + if (!ignore_quest_update) { char buf[24]; - snprintf(buf, 23, "%d %d", info->TaskID, info->Activity[ActivityID].ActivityID); + snprintf(buf, 23, "%d %d", info->task_id, info->activity[ActivityID].activity_id); buf[23] = '\0'; parse->EventPlayer(EVENT_TASK_STAGE_COMPLETE, c, buf, 0); } /* QS: PlayerLogTaskUpdates :: Update */ - if (RuleB(QueryServ, PlayerLogTaskUpdates)){ - std::string event_desc = StringFormat("Task Stage Complete :: taskid:%i activityid:%i donecount:%i in zoneid:%i instid:%i", info->TaskID, info->Activity[ActivityID].ActivityID, info->Activity[ActivityID].DoneCount, c->GetZoneID(), c->GetInstanceID()); + if (RuleB(QueryServ, PlayerLogTaskUpdates)) { + std::string event_desc = StringFormat( + "Task Stage Complete :: taskid:%i activityid:%i donecount:%i in zoneid:%i instid:%i", + info->task_id, + info->activity[ActivityID].activity_id, + info->activity[ActivityID].done_count, + c->GetZoneID(), + c->GetInstanceID()); QServ->PlayerLogEvent(Player_Log_Task_Updates, c->CharacterID(), event_desc); } } @@ -1965,144 +2196,164 @@ void ClientTaskState::IncrementDoneCount(Client *c, TaskInformation *Task, int T // If this task is now complete, the Completed tasks will have been // updated in UnlockActivities. Send the completed task list to the // client. This is the same sequence the packets are sent on live. - if(TaskComplete) { + if (TaskComplete) { char buf[24]; - snprintf(buf, 23, "%d %d %d", info->Activity[ActivityID].DoneCount, info->Activity[ActivityID].ActivityID, info->TaskID); + snprintf( + buf, + 23, + "%d %d %d", + info->activity[ActivityID].done_count, + info->activity[ActivityID].activity_id, + info->task_id + ); buf[23] = '\0'; parse->EventPlayer(EVENT_TASK_COMPLETE, c, buf, 0); /* QS: PlayerLogTaskUpdates :: Complete */ - if (RuleB(QueryServ, PlayerLogTaskUpdates)){ - std::string event_desc = StringFormat("Task Complete :: taskid:%i activityid:%i donecount:%i in zoneid:%i instid:%i", info->TaskID, info->Activity[ActivityID].ActivityID, info->Activity[ActivityID].DoneCount, c->GetZoneID(), c->GetInstanceID()); + if (RuleB(QueryServ, PlayerLogTaskUpdates)) { + std::string event_desc = StringFormat( + "Task Complete :: taskid:%i activityid:%i donecount:%i in zoneid:%i instid:%i", + info->task_id, + info->activity[ActivityID].activity_id, + info->activity[ActivityID].done_count, + c->GetZoneID(), + c->GetInstanceID()); QServ->PlayerLogEvent(Player_Log_Task_Updates, c->CharacterID(), event_desc); } - taskmanager->SendCompletedTasksToClient(c, this); - c->SendTaskActivityComplete(info->TaskID, 0, TaskIndex, Task->type, 0); - taskmanager->SaveClientState(c, this); + p_task_manager->SendCompletedTasksToClient(c, this); + c->SendTaskActivityComplete(info->task_id, 0, TaskIndex, Task->type, 0); + p_task_manager->SaveClientState(c, this); //c->SendTaskComplete(TaskIndex); c->CancelTask(TaskIndex, Task->type); - //if(Task->RewardMethod != METHODQUEST) RewardTask(c, Task); - // If Experience and/or cash rewards are set, reward them from the task even if RewardMethod is METHODQUEST + //if(Task->reward_method != METHODQUEST) RewardTask(c, Task); + // If Experience and/or cash rewards are set, reward them from the task even if reward_method is METHODQUEST RewardTask(c, Task); //RemoveTask(c, TaskIndex); } - } else { - // Send an update packet for this single activity - taskmanager->SendTaskActivityLong(c, info->TaskID, ActivityID, TaskIndex, - Task->Activity[ActivityID].Optional); - taskmanager->SaveClientState(c, this); + } + else { + // Send an updated packet for this single activity_information + p_task_manager->SendTaskActivityLong( + c, info->task_id, ActivityID, TaskIndex, + Task->activity_information[ActivityID].Optional + ); + p_task_manager->SaveClientState(c, this); } } -void ClientTaskState::RewardTask(Client *c, TaskInformation *Task) { +void ClientTaskState::RewardTask(Client *c, TaskInformation *Task) +{ - if(!Task || !c) return; + if (!Task || !c) { return; } - const EQ::ItemData* Item; - std::vector RewardList; + const EQ::ItemData *Item; + std::vector RewardList; - switch(Task->RewardMethod) { + switch (Task->reward_method) { - case METHODSINGLEID: - { - if(Task->RewardID) { - c->SummonItem(Task->RewardID); - Item = database.GetItem(Task->RewardID); - if(Item) + case METHODSINGLEID: { + if (Task->reward_id) { + c->SummonItem(Task->reward_id); + Item = database.GetItem(Task->reward_id); + if (Item) { c->Message(Chat::Yellow, "You receive %s as a reward.", Item->Name); + } } break; } - case METHODLIST: - { - RewardList = taskmanager->GoalListManager.GetListContents(Task->RewardID); - for(unsigned int i=0; iGoalListManager.GetListContents(Task->reward_id); + for (unsigned int i = 0; i < RewardList.size(); i++) { c->SummonItem(RewardList[i]); Item = database.GetItem(RewardList[i]); - if(Item) + if (Item) { c->Message(Chat::Yellow, "You receive %s as a reward.", Item->Name); + } } break; } - default: - { + default: { // Nothing special done for METHODQUEST break; } } - if (!Task->completion_emote.empty()) - c->SendColoredText(Chat::Yellow, Task->completion_emote); // unsure if they use this packet or color, should work + if (!Task->completion_emote.empty()) { + c->SendColoredText( + Chat::Yellow, + Task->completion_emote + ); + } // unsure if they use this packet or color, should work // just use normal NPC faction ID stuff if (Task->faction_reward) c->SetFactionLevel(c->CharacterID(), Task->faction_reward, c->GetBaseClass(), c->GetBaseRace(), c->GetDeity()); - if(Task->CashReward) { + if (Task->cash_reward) { int Plat, Gold, Silver, Copper; - Copper = Task->CashReward; + Copper = Task->cash_reward; c->AddMoneyToPP(Copper, true); - Plat = Copper / 1000; + Plat = Copper / 1000; Copper = Copper - (Plat * 1000); - Gold = Copper / 100; + Gold = Copper / 100; Copper = Copper - (Gold * 100); Silver = Copper / 10; Copper = Copper - (Silver * 10); std::string CashMessage; - if (Plat>0){ + if (Plat > 0) { CashMessage = "You receive "; CashMessage += itoa(Plat); CashMessage += " platinum"; } - if (Gold>0){ - if (CashMessage.length()==0){ + if (Gold > 0) { + if (CashMessage.length() == 0) { CashMessage = "You receive "; } - else{ + else { CashMessage += ","; } CashMessage += itoa(Gold); CashMessage += " gold"; } - if(Silver>0){ - if (CashMessage.length()==0){ + if (Silver > 0) { + if (CashMessage.length() == 0) { CashMessage = "You receive "; } - else{ + else { CashMessage += ","; } CashMessage += itoa(Silver); CashMessage += " silver"; } - if(Copper>0){ - if (CashMessage.length()==0){ + if (Copper > 0) { + if (CashMessage.length() == 0) { CashMessage = "You receive "; } - else{ + else { CashMessage += ","; } CashMessage += itoa(Copper); CashMessage += " copper"; } CashMessage += " pieces."; - c->Message(Chat::Yellow,CashMessage.c_str()); + c->Message(Chat::Yellow, CashMessage.c_str()); } - int32 EXPReward = Task->XPReward; - if(EXPReward > 0) { + int32 EXPReward = Task->experience_reward; + if (EXPReward > 0) { c->AddEXP(EXPReward); } - if(EXPReward < 0) { + if (EXPReward < 0) { uint32 PosReward = EXPReward * -1; - // Minimal Level Based Exp Reward Setting is 101 (1% exp at level 1) + // Minimal Level Based Exp reward Setting is 101 (1% exp at level 1) if (PosReward > 100 && PosReward < 25700) { - uint8 MaxLevel = PosReward / 100; + uint8 MaxLevel = PosReward / 100; uint8 ExpPercent = PosReward - (MaxLevel * 100); c->AddLevelBasedExp(ExpPercent, MaxLevel); } @@ -2113,15 +2364,18 @@ void ClientTaskState::RewardTask(Client *c, TaskInformation *Task) { bool ClientTaskState::IsTaskActive(int TaskID) { - if (ActiveTask.TaskID == TaskID) + if (active_task.task_id == TaskID) { return true; + } - if (ActiveTaskCount == 0 || TaskID == 0) + if (active_task_count == 0 || TaskID == 0) { return false; + } for (int i = 0; i < MAXACTIVEQUESTS; i++) { - if (ActiveQuests[i].TaskID == TaskID) + if (active_quests[i].task_id == TaskID) { return true; + } } return false; @@ -2129,9 +2383,9 @@ bool ClientTaskState::IsTaskActive(int TaskID) void ClientTaskState::FailTask(Client *c, int TaskID) { - Log(Logs::General, Logs::Tasks, "[UPDATE] FailTask %i, ActiveTaskCount is %i", TaskID, ActiveTaskCount); + Log(Logs::General, Logs::Tasks, "[UPDATE] FailTask %i, ActiveTaskCount is %i", TaskID, active_task_count); - if (ActiveTask.TaskID == TaskID) { + if (active_task.task_id == TaskID) { c->SendTaskFailed(TaskID, 0, TaskType::Task); // Remove the task from the client c->CancelTask(0, TaskType::Task); @@ -2140,12 +2394,13 @@ void ClientTaskState::FailTask(Client *c, int TaskID) // TODO: shared tasks - if (ActiveTaskCount == 0) + if (active_task_count == 0) { return; + } for (int i = 0; i < MAXACTIVEQUESTS; i++) { - if (ActiveQuests[i].TaskID == TaskID) { - c->SendTaskFailed(ActiveQuests[i].TaskID, i, TaskType::Quest); + if (active_quests[i].task_id == TaskID) { + c->SendTaskFailed(active_quests[i].task_id, i, TaskType::Quest); // Remove the task from the client c->CancelTask(i, TaskType::Quest); return; @@ -2159,101 +2414,120 @@ bool ClientTaskState::IsTaskActivityActive(int TaskID, int ActivityID) Log(Logs::General, Logs::Tasks, "[UPDATE] ClientTaskState IsTaskActivityActive(%i, %i).", TaskID, ActivityID); // Quick sanity check - if (ActivityID < 0) + if (ActivityID < 0) { return false; - if (ActiveTaskCount == 0 && ActiveTask.TaskID == TASKSLOTEMPTY) + } + if (active_task_count == 0 && active_task.task_id == TASKSLOTEMPTY) { return false; + } - int ActiveTaskIndex = -1; - auto type = TaskType::Task; + int ActiveTaskIndex = -1; + auto type = TaskType::Task; - if (ActiveTask.TaskID == TaskID) + if (active_task.task_id == TaskID) { ActiveTaskIndex = 0; + } if (ActiveTaskIndex == -1) { for (int i = 0; i < MAXACTIVEQUESTS; i++) { - if (ActiveQuests[i].TaskID == TaskID) { + if (active_quests[i].task_id == TaskID) { ActiveTaskIndex = i; - type = TaskType::Quest; + type = TaskType::Quest; break; } } } // The client does not have this task - if (ActiveTaskIndex == -1) + if (ActiveTaskIndex == -1) { return false; + } auto info = GetClientTaskInfo(type, ActiveTaskIndex); - if (info == nullptr) + if (info == nullptr) { return false; + } - TaskInformation *Task = taskmanager->Tasks[info->TaskID]; + TaskInformation *Task = p_task_manager->Tasks[info->task_id]; // The task is invalid - if (Task == nullptr) + if (Task == nullptr) { return false; + } - // The ActivityID is out of range - if (ActivityID >= Task->ActivityCount) + // The activity_id is out of range + if (ActivityID >= Task->activity_count) { return false; + } - Log(Logs::General, Logs::Tasks, "[UPDATE] ClientTaskState IsTaskActivityActive(%i, %i). State is %i ", TaskID, - ActivityID, info->Activity[ActivityID].State); + Log(Logs::General, Logs::Tasks, "[UPDATE] ClientTaskState IsTaskActivityActive(%i, %i). activity_state is %i ", TaskID, + ActivityID, info->activity[ActivityID].activity_state); - return (info->Activity[ActivityID].State == ActivityActive); + return (info->activity[ActivityID].activity_state == ActivityActive); } -void ClientTaskState::UpdateTaskActivity(Client *c, int TaskID, int ActivityID, int Count, bool ignore_quest_update /*= false*/) +void ClientTaskState::UpdateTaskActivity( + Client *c, + int TaskID, + int ActivityID, + int Count, + bool ignore_quest_update /*= false*/) { Log(Logs::General, Logs::Tasks, "[UPDATE] ClientTaskState UpdateTaskActivity(%i, %i, %i).", TaskID, ActivityID, - Count); + Count); // Quick sanity check - if (ActivityID < 0 || (ActiveTaskCount == 0 && ActiveTask.TaskID == TASKSLOTEMPTY)) + if (ActivityID < 0 || (active_task_count == 0 && active_task.task_id == TASKSLOTEMPTY)) { return; + } - int ActiveTaskIndex = -1; - auto type = TaskType::Task; + int ActiveTaskIndex = -1; + auto type = TaskType::Task; - if (ActiveTask.TaskID == TaskID) + if (active_task.task_id == TaskID) { ActiveTaskIndex = 0; + } if (ActiveTaskIndex == -1) { for (int i = 0; i < MAXACTIVEQUESTS; i++) { - if (ActiveQuests[i].TaskID == TaskID) { + if (active_quests[i].task_id == TaskID) { ActiveTaskIndex = i; - type = TaskType::Quest; + type = TaskType::Quest; break; } } } // The client does not have this task - if (ActiveTaskIndex == -1) + if (ActiveTaskIndex == -1) { return; + } auto info = GetClientTaskInfo(type, ActiveTaskIndex); - if (info == nullptr) + if (info == nullptr) { return; + } - TaskInformation *Task = taskmanager->Tasks[info->TaskID]; + TaskInformation *Task = p_task_manager->Tasks[info->task_id]; // The task is invalid - if (Task == nullptr) + if (Task == nullptr) { return; + } - // The ActivityID is out of range - if (ActivityID >= Task->ActivityCount) + // The activity_id is out of range + if (ActivityID >= Task->activity_count) { return; + } - // The Activity is not currently active - if (info->Activity[ActivityID].State == ActivityHidden) + // The activity_information is not currently active + if (info->activity[ActivityID].activity_state == ActivityHidden) { return; - + } + Log(Logs::General, Logs::Tasks, "[UPDATE] Increment done count on UpdateTaskActivity %d %d", ActivityID, Count); IncrementDoneCount(c, Task, ActiveTaskIndex, ActivityID, Count, ignore_quest_update); } @@ -2263,76 +2537,92 @@ void ClientTaskState::ResetTaskActivity(Client *c, int TaskID, int ActivityID) Log(Logs::General, Logs::Tasks, "[RESET] ClientTaskState ResetTaskActivity(%i, %i).", TaskID, ActivityID); // Quick sanity check - if (ActivityID < 0 || (ActiveTaskCount == 0 && ActiveTask.TaskID == TASKSLOTEMPTY)) + if (ActivityID < 0 || (active_task_count == 0 && active_task.task_id == TASKSLOTEMPTY)) { return; + } - int ActiveTaskIndex = -1; - auto type = TaskType::Task; + int ActiveTaskIndex = -1; + auto type = TaskType::Task; - if (ActiveTask.TaskID == TaskID) + if (active_task.task_id == TaskID) { ActiveTaskIndex = 0; + } if (ActiveTaskIndex == -1) { for (int i = 0; i < MAXACTIVEQUESTS; i++) { - if (ActiveQuests[i].TaskID == TaskID) { + if (active_quests[i].task_id == TaskID) { ActiveTaskIndex = i; - type = TaskType::Quest; + type = TaskType::Quest; break; } } } // The client does not have this task - if (ActiveTaskIndex == -1) + if (ActiveTaskIndex == -1) { return; + } auto info = GetClientTaskInfo(type, ActiveTaskIndex); - if (info == nullptr) + if (info == nullptr) { return; + } - TaskInformation *Task = taskmanager->Tasks[info->TaskID]; + TaskInformation *Task = p_task_manager->Tasks[info->task_id]; // The task is invalid - if (Task == nullptr) + if (Task == nullptr) { return; + } - // The ActivityID is out of range - if (ActivityID >= Task->ActivityCount) + // The activity_id is out of range + if (ActivityID >= Task->activity_count) { return; + } - // The Activity is not currently active - if (info->Activity[ActivityID].State == ActivityHidden) + // The activity_information is not currently active + if (info->activity[ActivityID].activity_state == ActivityHidden) { return; - + } + Log(Logs::General, Logs::Tasks, "[RESET] Increment done count on ResetTaskActivity"); - IncrementDoneCount(c, Task, ActiveTaskIndex, ActivityID, (info->Activity[ActivityID].DoneCount * -1), false); + IncrementDoneCount(c, Task, ActiveTaskIndex, ActivityID, (info->activity[ActivityID].done_count * -1), false); } void ClientTaskState::ShowClientTasks(Client *c) { c->Message(Chat::White, "Task Information:"); - if (ActiveTask.TaskID != TASKSLOTEMPTY) { - c->Message(Chat::White, "Task: %i %s", ActiveTask.TaskID, taskmanager->Tasks[ActiveTask.TaskID]->Title.c_str()); - c->Message(Chat::White, " Description: [%s]\n", taskmanager->Tasks[ActiveTask.TaskID]->Description.c_str()); - for (int j = 0; j < taskmanager->GetActivityCount(ActiveTask.TaskID); j++) { - c->Message(Chat::White, " Activity: %2d, DoneCount: %2d, Status: %d (0=Hidden, 1=Active, 2=Complete)", - ActiveTask.Activity[j].ActivityID, ActiveTask.Activity[j].DoneCount, - ActiveTask.Activity[j].State); + if (active_task.task_id != TASKSLOTEMPTY) { + c->Message(Chat::White, "Task: %i %s", active_task.task_id, p_task_manager->Tasks[active_task.task_id]->title.c_str()); + c->Message(Chat::White, " description: [%s]\n", p_task_manager->Tasks[active_task.task_id]->description.c_str()); + for (int j = 0; j < p_task_manager->GetActivityCount(active_task.task_id); j++) { + c->Message( + Chat::White, " activity_information: %2d, done_count: %2d, Status: %d (0=Hidden, 1=Active, 2=Complete)", + active_task.activity[j].activity_id, active_task.activity[j].done_count, + active_task.activity[j].activity_state + ); } } for (int i = 0; i < MAXACTIVEQUESTS; i++) { - if (ActiveQuests[i].TaskID == TASKSLOTEMPTY) + if (active_quests[i].task_id == TASKSLOTEMPTY) { continue; + } - c->Message(Chat::White, "Quest: %i %s", ActiveQuests[i].TaskID, - taskmanager->Tasks[ActiveQuests[i].TaskID]->Title.c_str()); - c->Message(Chat::White, " Description: [%s]\n", taskmanager->Tasks[ActiveQuests[i].TaskID]->Description.c_str()); - for (int j = 0; j < taskmanager->GetActivityCount(ActiveQuests[i].TaskID); j++) { - c->Message(Chat::White, " Activity: %2d, DoneCount: %2d, Status: %d (0=Hidden, 1=Active, 2=Complete)", - ActiveQuests[i].Activity[j].ActivityID, ActiveQuests[i].Activity[j].DoneCount, - ActiveQuests[i].Activity[j].State); + c->Message( + Chat::White, "Quest: %i %s", active_quests[i].task_id, + p_task_manager->Tasks[active_quests[i].task_id]->title.c_str()); + c->Message( + Chat::White, + " description: [%s]\n", + p_task_manager->Tasks[active_quests[i].task_id]->description.c_str()); + for (int j = 0; j < p_task_manager->GetActivityCount(active_quests[i].task_id); j++) { + c->Message( + Chat::White, " activity_information: %2d, done_count: %2d, Status: %d (0=Hidden, 1=Active, 2=Complete)", + active_quests[i].activity[j].activity_id, active_quests[i].activity[j].done_count, + active_quests[i].activity[j].activity_state + ); } } } @@ -2340,41 +2630,47 @@ void ClientTaskState::ShowClientTasks(Client *c) // TODO: Shared Task int ClientTaskState::TaskTimeLeft(int TaskID) { - if (ActiveTask.TaskID == TaskID) { + if (active_task.task_id == TaskID) { int Now = time(nullptr); - TaskInformation *Task = taskmanager->Tasks[TaskID]; + TaskInformation *Task = p_task_manager->Tasks[TaskID]; - if (Task == nullptr) + if (Task == nullptr) { return -1; + } - if (!Task->Duration) + if (!Task->duration) { return -1; + } - int TimeLeft = (ActiveTask.AcceptedTime + Task->Duration - Now); + int TimeLeft = (active_task.accepted_time + Task->duration - Now); return (TimeLeft > 0 ? TimeLeft : 0); } - if (ActiveTaskCount == 0) + if (active_task_count == 0) { return -1; + } for (int i = 0; i < MAXACTIVEQUESTS; i++) { - if (ActiveQuests[i].TaskID != TaskID) + if (active_quests[i].task_id != TaskID) { continue; + } int Now = time(nullptr); - TaskInformation *Task = taskmanager->Tasks[ActiveQuests[i].TaskID]; + TaskInformation *Task = p_task_manager->Tasks[active_quests[i].task_id]; - if (Task == nullptr) + if (Task == nullptr) { return -1; + } - if (!Task->Duration) + if (!Task->duration) { return -1; + } - int TimeLeft = (ActiveQuests[i].AcceptedTime + Task->Duration - Now); + int TimeLeft = (active_quests[i].accepted_time + Task->duration - Now); // If Timeleft is negative, return 0, else return the number of seconds left @@ -2384,31 +2680,37 @@ int ClientTaskState::TaskTimeLeft(int TaskID) return -1; } -int ClientTaskState::IsTaskCompleted(int TaskID) { +int ClientTaskState::IsTaskCompleted(int TaskID) +{ // Returns: -1 if RecordCompletedTasks is not true // +1 if the task has been completed // 0 if the task has not been completed - if(!(RuleB(TaskSystem, RecordCompletedTasks))) return -1; + if (!(RuleB(TaskSystem, RecordCompletedTasks))) { return -1; } - for(unsigned int i=0; i= MAXTASKS)) return false; + if ((TaskID <= 0) || (TaskID >= MAXTASKS)) { return false; } - TaskInformation* Task = taskmanager->Tasks[TaskID]; + TaskInformation *Task = p_task_manager->Tasks[TaskID]; - if(Task == nullptr) return false; + if (Task == nullptr) { return false; } - return Task->Repeatable; + return Task->repeatable; } bool ClientTaskState::TaskOutOfTime(TaskType type, int Index) @@ -2416,29 +2718,32 @@ bool ClientTaskState::TaskOutOfTime(TaskType type, int Index) // Returns true if the Task in the specified slot has a time limit that has been exceeded. auto info = GetClientTaskInfo(type, Index); - if (info == nullptr) + if (info == nullptr) { return false; + } - // make sure the TaskID is at least maybe in our array - if (info->TaskID <= 0 || info->TaskID >= MAXTASKS) + // make sure the task_id is at least maybe in our array + if (info->task_id <= 0 || info->task_id >= MAXTASKS) { return false; + } int Now = time(nullptr); - TaskInformation *Task = taskmanager->Tasks[info->TaskID]; + TaskInformation *Task = p_task_manager->Tasks[info->task_id]; - if (Task == nullptr) + if (Task == nullptr) { return false; + } - return (Task->Duration && (info->AcceptedTime + Task->Duration <= Now)); + return (Task->duration && (info->accepted_time + Task->duration <= Now)); } void ClientTaskState::TaskPeriodicChecks(Client *c) { - if (ActiveTask.TaskID != TASKSLOTEMPTY) { + if (active_task.task_id != TASKSLOTEMPTY) { if (TaskOutOfTime(TaskType::Task, 0)) { // Send Red Task Failed Message - c->SendTaskFailed(ActiveTask.TaskID, 0, TaskType::Task); + c->SendTaskFailed(active_task.task_id, 0, TaskType::Task); // Remove the task from the client c->CancelTask(0, TaskType::Task); // It is a conscious decision to only fail one task per call to this method, @@ -2450,18 +2755,20 @@ void ClientTaskState::TaskPeriodicChecks(Client *c) // TODO: shared tasks -- although that will probably be manager in world checking and telling zones to fail us - if (ActiveTaskCount == 0) + if (active_task_count == 0) { return; + } // Check for tasks that have failed because they have not been completed in the specified time // for (int i = 0; i < MAXACTIVEQUESTS; i++) { - if (ActiveQuests[i].TaskID == TASKSLOTEMPTY) + if (active_quests[i].task_id == TASKSLOTEMPTY) { continue; + } if (TaskOutOfTime(TaskType::Quest, i)) { // Send Red Task Failed Message - c->SendTaskFailed(ActiveQuests[i].TaskID, i, TaskType::Quest); + c->SendTaskFailed(active_quests[i].task_id, i, TaskType::Quest); // Remove the task from the client c->CancelTask(i, TaskType::Quest); // It is a conscious decision to only fail one task per call to this method, @@ -2473,11 +2780,11 @@ void ClientTaskState::TaskPeriodicChecks(Client *c) // Check for activities that require zoning into a specific zone. // 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 Completed' message. + // the zone before we send the 'Task activity_information Completed' message. // - if (!CheckedTouchActivities) { + if (!checked_touch_activities) { UpdateTasksOnTouch(c, zone->GetZoneID()); - CheckedTouchActivities = true; + checked_touch_activities = true; } } @@ -2493,7 +2800,7 @@ void Client::SendTaskComplete(int TaskIndex) { tcs = (TaskComplete_Struct*)outapp->pBuffer; // I have seen unknown0 as non-zero. It always seems to match the value in the first word of the - // Task Activity Complete packet sent immediately prior to it. + // Task activity_information Complete packet sent immediately prior to it. //tcs->unknown00 = 0x00000000; tcs->unknown00 = TaskIndex; // I have only seen 0x00000002 in the next field. This is a common 'unknown' value in the task packets. @@ -2511,7 +2818,8 @@ void Client::SendTaskComplete(int TaskIndex) { } #endif -void ClientTaskState::SendTaskHistory(Client *c, int TaskIndex) { +void ClientTaskState::SendTaskHistory(Client *c, int TaskIndex) +{ Log(Logs::General, Logs::Tasks, "[UPDATE] Task History Requested for Completed Task Index %i", TaskIndex); @@ -2519,22 +2827,23 @@ void ClientTaskState::SendTaskHistory(Client *c, int TaskIndex) { int AdjustedTaskIndex = TaskIndex; - if(CompletedTasks.size() > 50) - AdjustedTaskIndex += (CompletedTasks.size() - 50); + if (completed_tasks.size() > 50) { + AdjustedTaskIndex += (completed_tasks.size() - 50); + } - if((AdjustedTaskIndex < 0) || (AdjustedTaskIndex >= (int)CompletedTasks.size())) return; + if ((AdjustedTaskIndex < 0) || (AdjustedTaskIndex >= (int) completed_tasks.size())) { return; } - int TaskID = CompletedTasks[AdjustedTaskIndex].TaskID; + int TaskID = completed_tasks[AdjustedTaskIndex].task_id; - if((TaskID < 0) || (TaskID > MAXTASKS)) return; + if ((TaskID < 0) || (TaskID > MAXTASKS)) { return; } - TaskInformation* Task = taskmanager->Tasks[TaskID]; + TaskInformation *Task = p_task_manager->Tasks[TaskID]; - if(Task == nullptr) return; + if (Task == nullptr) { return; } - TaskHistoryReplyHeader_Struct* ths; - TaskHistoryReplyData1_Struct* thd1; - TaskHistoryReplyData2_Struct* thd2; + TaskHistoryReplyHeader_Struct *ths; + TaskHistoryReplyData1_Struct *thd1; + TaskHistoryReplyData2_Struct *thd2; char *Ptr; @@ -2542,20 +2851,20 @@ void ClientTaskState::SendTaskHistory(Client *c, int TaskIndex) { int PacketLength = sizeof(TaskHistoryReplyHeader_Struct); - for(int i=0; iActivityCount; i++) { - if(CompletedTasks[AdjustedTaskIndex].ActivityDone[i]) { + for (int i = 0; i < Task->activity_count; i++) { + if (completed_tasks[AdjustedTaskIndex].activity_done[i]) { CompletedActivityCount++; PacketLength = PacketLength + sizeof(TaskHistoryReplyData1_Struct) + - Task->Activity[i].target_name.size() + 1 + - Task->Activity[i].item_list.size() + 1 + - sizeof(TaskHistoryReplyData2_Struct) + - Task->Activity[i].desc_override.size() + 1; + Task->activity_information[i].target_name.size() + 1 + + Task->activity_information[i].item_list.size() + 1 + + sizeof(TaskHistoryReplyData2_Struct) + + Task->activity_information[i].desc_override.size() + 1; } } auto outapp = new EQApplicationPacket(OP_TaskHistoryReply, PacketLength); - ths = (TaskHistoryReplyHeader_Struct*)outapp->pBuffer; + ths = (TaskHistoryReplyHeader_Struct *) outapp->pBuffer; // We use the TaskIndex the client sent in the request ths->TaskID = TaskIndex; @@ -2564,21 +2873,21 @@ void ClientTaskState::SendTaskHistory(Client *c, int TaskIndex) { Ptr = (char *) ths + sizeof(TaskHistoryReplyHeader_Struct); - for(int i=0; iActivityCount; i++) { - if(CompletedTasks[AdjustedTaskIndex].ActivityDone[i]) { - thd1 = (TaskHistoryReplyData1_Struct*)Ptr; - thd1->ActivityType = Task->Activity[i].Type; - Ptr = (char *)thd1 + sizeof(TaskHistoryReplyData1_Struct); - VARSTRUCT_ENCODE_STRING(Ptr, Task->Activity[i].target_name.c_str()); - VARSTRUCT_ENCODE_STRING(Ptr, Task->Activity[i].item_list.c_str()); - thd2 = (TaskHistoryReplyData2_Struct*)Ptr; - thd2->GoalCount = Task->Activity[i].GoalCount; + for (int i = 0; i < Task->activity_count; i++) { + if (completed_tasks[AdjustedTaskIndex].activity_done[i]) { + thd1 = (TaskHistoryReplyData1_Struct *) Ptr; + thd1->ActivityType = Task->activity_information[i].Type; + Ptr = (char *) thd1 + sizeof(TaskHistoryReplyData1_Struct); + VARSTRUCT_ENCODE_STRING(Ptr, Task->activity_information[i].target_name.c_str()); + VARSTRUCT_ENCODE_STRING(Ptr, Task->activity_information[i].item_list.c_str()); + thd2 = (TaskHistoryReplyData2_Struct *) Ptr; + thd2->GoalCount = Task->activity_information[i].GoalCount; thd2->unknown04 = 0xffffffff; thd2->unknown08 = 0xffffffff; - thd2->ZoneID = Task->Activity[i].ZoneIDs.empty() ? 0 : Task->Activity[i].ZoneIDs.front(); + thd2->ZoneID = Task->activity_information[i].ZoneIDs.empty() ? 0 : Task->activity_information[i].ZoneIDs.front(); thd2->unknown16 = 0x00000000; - Ptr = (char *)thd2 + sizeof(TaskHistoryReplyData2_Struct); - VARSTRUCT_ENCODE_STRING(Ptr, Task->Activity[i].desc_override.c_str()); + Ptr = (char *) thd2 + sizeof(TaskHistoryReplyData2_Struct); + VARSTRUCT_ENCODE_STRING(Ptr, Task->activity_information[i].desc_override.c_str()); } } @@ -2587,25 +2896,24 @@ void ClientTaskState::SendTaskHistory(Client *c, int TaskIndex) { safe_delete(outapp); - } -void Client::SendTaskActivityComplete(int TaskID, int ActivityID, int TaskIndex, TaskType type, int TaskIncomplete) +void Client::SendTaskActivityComplete(int task_id, int activity_id, int task_index, TaskType task_type, int task_incomplete) { // 0x54eb - TaskActivityComplete_Struct* tac; + TaskActivityComplete_Struct *tac; auto outapp = new EQApplicationPacket(OP_TaskActivityComplete, sizeof(TaskActivityComplete_Struct)); - tac = (TaskActivityComplete_Struct*)outapp->pBuffer; + tac = (TaskActivityComplete_Struct *) outapp->pBuffer; - tac->TaskIndex = TaskIndex; - tac->TaskType = static_cast(type); - tac->TaskID = TaskID; - tac->ActivityID = ActivityID; + tac->TaskIndex = task_index; + tac->TaskType = static_cast(task_type); + tac->TaskID = task_id; + tac->ActivityID = activity_id; tac->task_completed = 0x00000001; - tac->stage_complete = TaskIncomplete; + tac->stage_complete = task_incomplete; QueuePacket(outapp); @@ -2613,24 +2921,24 @@ void Client::SendTaskActivityComplete(int TaskID, int ActivityID, int TaskIndex, } -void Client::SendTaskFailed(int TaskID, int TaskIndex, TaskType type) +void Client::SendTaskFailed(int task_id, int task_index, TaskType task_type) { // 0x54eb char buf[24]; - snprintf(buf, 23, "%d", TaskID); + snprintf(buf, 23, "%d", task_id); buf[23] = '\0'; parse->EventPlayer(EVENT_TASK_FAIL, this, buf, 0); - TaskActivityComplete_Struct* tac; + TaskActivityComplete_Struct *tac; auto outapp = new EQApplicationPacket(OP_TaskActivityComplete, sizeof(TaskActivityComplete_Struct)); - tac = (TaskActivityComplete_Struct*)outapp->pBuffer; + tac = (TaskActivityComplete_Struct *) outapp->pBuffer; - tac->TaskIndex = TaskIndex; - tac->TaskType = static_cast(type); - tac->TaskID = TaskID; - tac->ActivityID = 0; + tac->TaskIndex = task_index; + tac->TaskType = static_cast(task_type); + tac->TaskID = task_id; + tac->ActivityID = 0; tac->task_completed = 0; //Fail tac->stage_complete = 0; // 0 for task complete or failed. @@ -2640,7 +2948,8 @@ void Client::SendTaskFailed(int TaskID, int TaskIndex, TaskType type) safe_delete(outapp); } -void TaskManager::SendCompletedTasksToClient(Client *c, ClientTaskState *State) { +void TaskManager::SendCompletedTasksToClient(Client *c, ClientTaskState *State) +{ int PacketLength = 4; @@ -2650,44 +2959,45 @@ void TaskManager::SendCompletedTasksToClient(Client *c, ClientTaskState *State) // The client only display the first 50 Completed Tasks send, so send the 50 most recent int FirstTaskToSend = 0; - int LastTaskToSend = State->CompletedTasks.size(); + int LastTaskToSend = State->completed_tasks.size(); - if(State->CompletedTasks.size() > 50) - FirstTaskToSend = State->CompletedTasks.size() - 50; + if (State->completed_tasks.size() > 50) { + FirstTaskToSend = State->completed_tasks.size() - 50; + } Log(Logs::General, Logs::Tasks, "[UPDATE] Completed Task Count: %i, First Task to send is %i, Last is %i", - State->CompletedTasks.size(), FirstTaskToSend, LastTaskToSend); + State->completed_tasks.size(), FirstTaskToSend, LastTaskToSend); /* - for(iterator=State->CompletedTasks.begin(); iterator!=State->CompletedTasks.end(); iterator++) { - int TaskID = (*iterator).TaskID; - if(Tasks[TaskID] == nullptr) continue; - PacketLength = PacketLength + 8 + strlen(Tasks[TaskID]->Title) + 1; + for(iterator=activity_state->CompletedTasks.begin(); iterator!=activity_state->CompletedTasks.end(); iterator++) { + int task_id = (*iterator).task_id; + if(Tasks[task_id] == nullptr) continue; + PacketLength = PacketLength + 8 + strlen(Tasks[task_id]->title) + 1; } */ - for(int i = FirstTaskToSend; iCompletedTasks[i].TaskID; - if(Tasks[TaskID] == nullptr) continue; - PacketLength = PacketLength + 8 + Tasks[TaskID]->Title.size() + 1; + for (int i = FirstTaskToSend; i < LastTaskToSend; i++) { + int TaskID = State->completed_tasks[i].task_id; + if (Tasks[TaskID] == nullptr) { continue; } + PacketLength = PacketLength + 8 + Tasks[TaskID]->title.size() + 1; } auto outapp = new EQApplicationPacket(OP_CompletedTasks, PacketLength); - char *buf = (char*)outapp->pBuffer; + char *buf = (char *) outapp->pBuffer; - //*(uint32 *)buf = State->CompletedTasks.size(); - *(uint32 *)buf = LastTaskToSend - FirstTaskToSend; + //*(uint32 *)buf = activity_state->CompletedTasks.size(); + *(uint32 *) buf = LastTaskToSend - FirstTaskToSend; buf = buf + 4; - //for(iterator=State->CompletedTasks.begin(); iterator!=State->CompletedTasks.end(); iterator++) { - // int TaskID = (*iterator).TaskID; - for(int i = FirstTaskToSend; iCompletedTasks[i].TaskID; - if(Tasks[TaskID] == nullptr) continue; - *(uint32 *)buf = TaskID; + //for(iterator=activity_state->CompletedTasks.begin(); iterator!=activity_state->CompletedTasks.end(); iterator++) { + // int task_id = (*iterator).task_id; + for (int i = FirstTaskToSend; i < LastTaskToSend; i++) { + int TaskID = State->completed_tasks[i].task_id; + if (Tasks[TaskID] == nullptr) { continue; } + *(uint32 *) buf = TaskID; buf = buf + 4; - sprintf(buf, "%s", Tasks[TaskID]->Title.c_str()); + sprintf(buf, "%s", Tasks[TaskID]->title.c_str()); buf = buf + strlen(buf) + 1; //*(uint32 *)buf = (*iterator).CompletedTime; - *(uint32 *)buf = State->CompletedTasks[i].CompletedTime; + *(uint32 *) buf = State->completed_tasks[i].completed_time; buf = buf + 4; } @@ -2697,16 +3007,14 @@ void TaskManager::SendCompletedTasksToClient(Client *c, ClientTaskState *State) } - void TaskManager::SendTaskActivityShort(Client *c, int TaskID, int ActivityID, int ClientTaskIndex) { - // This Activity Packet is sent for activities that have not yet been unlocked and appear as ??? + // This activity_information Packet is sent for activities that have not yet been unlocked and appear as ??? // in the client. - TaskActivityShort_Struct* tass; + TaskActivityShort_Struct *tass; - if (c->ClientVersionBit() & EQ::versions::maskRoFAndLater) - { + if (c->ClientVersionBit() & EQ::versions::maskRoFAndLater) { auto outapp = new EQApplicationPacket(OP_TaskActivity, 25); outapp->WriteUInt32(ClientTaskIndex); outapp->WriteUInt32(static_cast(Tasks[TaskID]->type)); @@ -2722,15 +3030,15 @@ void TaskManager::SendTaskActivityShort(Client *c, int TaskID, int ActivityID, i auto outapp = new EQApplicationPacket(OP_TaskActivity, sizeof(TaskActivityShort_Struct)); - tass = (TaskActivityShort_Struct*)outapp->pBuffer; + tass = (TaskActivityShort_Struct *) outapp->pBuffer; tass->TaskSequenceNumber = ClientTaskIndex; - tass->unknown2 = static_cast(Tasks[TaskID]->type); - tass->TaskID = TaskID; - tass->ActivityID = ActivityID; - tass->unknown3 = 0x000000; - tass->ActivityType = 0xffffffff; - tass->unknown4 = 0x00000000; + tass->unknown2 = static_cast(Tasks[TaskID]->type); + tass->TaskID = TaskID; + tass->ActivityID = ActivityID; + tass->unknown3 = 0x000000; + tass->ActivityType = 0xffffffff; + tass->unknown4 = 0x00000000; c->QueuePacket(outapp); @@ -2738,11 +3046,17 @@ void TaskManager::SendTaskActivityShort(Client *c, int TaskID, int ActivityID, i } +void TaskManager::SendTaskActivityLong( + Client *c, + int TaskID, + int ActivityID, + int ClientTaskIndex, + bool Optional, + bool TaskComplete +) +{ -void TaskManager::SendTaskActivityLong(Client *c, int TaskID, int ActivityID, int ClientTaskIndex, bool Optional, bool TaskComplete) { - - if (c->ClientVersion() >= EQ::versions::ClientVersion::RoF) - { + if (c->ClientVersion() >= EQ::versions::ClientVersion::RoF) { SendTaskActivityNew(c, TaskID, ActivityID, ClientTaskIndex, Optional, TaskComplete); return; } @@ -2755,40 +3069,44 @@ void TaskManager::SendTaskActivityLong(Client *c, int TaskID, int ActivityID, in buf.WriteUInt32(ActivityID); buf.WriteUInt32(0); // unknown3 - // We send our 'internal' types as ActivityCastOn. text3 should be set to the activity description, so it makes - // no difference to the client. All activity updates will be done based on our interal activity types. - if((Tasks[TaskID]->Activity[ActivityID].Type > 0) && Tasks[TaskID]->Activity[ActivityID].Type < 100) - buf.WriteUInt32(Tasks[TaskID]->Activity[ActivityID].Type); - else - buf.WriteUInt32(ActivityCastOn); // w/e! + // 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 ((Tasks[TaskID]->activity_information[ActivityID].Type > 0) && Tasks[TaskID]->activity_information[ActivityID].Type < 100) { + buf.WriteUInt32(Tasks[TaskID]->activity_information[ActivityID].Type); + } + else { + buf.WriteUInt32(ActivityCastOn); + } // w/e! buf.WriteUInt32(Optional); - buf.WriteUInt32(0); // solo, group, raid + buf.WriteUInt32(0); // solo, group, raid - buf.WriteString(Tasks[TaskID]->Activity[ActivityID].target_name); // target name string - buf.WriteString(Tasks[TaskID]->Activity[ActivityID].item_list); // item name list + buf.WriteString(Tasks[TaskID]->activity_information[ActivityID].target_name); // target name string + buf.WriteString(Tasks[TaskID]->activity_information[ActivityID].item_list); // item name list - if(Tasks[TaskID]->Activity[ActivityID].Type != ActivityGiveCash) - buf.WriteUInt32(Tasks[TaskID]->Activity[ActivityID].GoalCount); + if (Tasks[TaskID]->activity_information[ActivityID].Type != ActivityGiveCash) + buf.WriteUInt32(Tasks[TaskID]->activity_information[ActivityID].GoalCount); else // For our internal type GiveCash, where the goal count has the amount of cash that must be given, // we don't want the donecount and goalcount fields cluttered up with potentially large numbers, so we just - // send a goalcount of 1, and a bit further down, a donecount of 1 if the activity is complete, 0 otherwise. - // The text3 field should decribe the exact activity goal, e.g. give 3500gp to Hasten Bootstrutter. + // send a goalcount of 1, and a bit further down, a donecount of 1 if the activity_information is complete, 0 otherwise. + // The text3 field should decribe the exact activity_information goal, e.g. give 3500gp to Hasten Bootstrutter. buf.WriteUInt32(1); - buf.WriteUInt32(Tasks[TaskID]->Activity[ActivityID].skill_id); - buf.WriteUInt32(Tasks[TaskID]->Activity[ActivityID].spell_id); - buf.WriteUInt32(Tasks[TaskID]->Activity[ActivityID].ZoneIDs.empty() ? 0 : Tasks[TaskID]->Activity[ActivityID].ZoneIDs.front()); + buf.WriteUInt32(Tasks[TaskID]->activity_information[ActivityID].skill_id); + buf.WriteUInt32(Tasks[TaskID]->activity_information[ActivityID].spell_id); + buf.WriteUInt32( + Tasks[TaskID]->activity_information[ActivityID].ZoneIDs.empty() ? 0 : Tasks[TaskID]->activity_information[ActivityID].ZoneIDs.front()); buf.WriteUInt32(0); - buf.WriteString(Tasks[TaskID]->Activity[ActivityID].desc_override); + buf.WriteString(Tasks[TaskID]->activity_information[ActivityID].desc_override); - if(Tasks[TaskID]->Activity[ActivityID].Type != ActivityGiveCash) + if (Tasks[TaskID]->activity_information[ActivityID].Type != ActivityGiveCash) buf.WriteUInt32(c->GetTaskActivityDoneCount(Tasks[TaskID]->type, ClientTaskIndex, ActivityID)); else - // For internal activity types, DoneCount is either 1 if the activity is complete, 0 otherwise. - buf.WriteUInt32((c->GetTaskActivityDoneCount(Tasks[TaskID]->type, ClientTaskIndex, ActivityID) >= Tasks[TaskID]->Activity[ActivityID].GoalCount)); + // For internal activity_information types, done_count is either 1 if the activity_information is complete, 0 otherwise. + buf.WriteUInt32((c->GetTaskActivityDoneCount(Tasks[TaskID]->type, ClientTaskIndex, ActivityID) >= + Tasks[TaskID]->activity_information[ActivityID].GoalCount)); buf.WriteUInt32(1); // unknown @@ -2800,57 +3118,67 @@ void TaskManager::SendTaskActivityLong(Client *c, int TaskID, int ActivityID, in } // Used only by RoF+ Clients -void TaskManager::SendTaskActivityNew(Client *c, int TaskID, int ActivityID, int ClientTaskIndex, bool Optional, bool TaskComplete) +void TaskManager::SendTaskActivityNew( + Client *c, + int TaskID, + int ActivityID, + int ClientTaskIndex, + bool Optional, + bool TaskComplete +) { SerializeBuffer buf(100); - buf.WriteUInt32(ClientTaskIndex); // TaskSequenceNumber - buf.WriteUInt32(static_cast(Tasks[TaskID]->type)); // task type + buf.WriteUInt32(ClientTaskIndex); // TaskSequenceNumber + buf.WriteUInt32(static_cast(Tasks[TaskID]->type)); // task type buf.WriteUInt32(TaskID); buf.WriteUInt32(ActivityID); - buf.WriteUInt32(0); // unknown3 + buf.WriteUInt32(0); // unknown3 - // We send our 'internal' types as ActivityCastOn. text3 should be set to the activity description, so it makes - // no difference to the client. All activity updates will be done based on our interal activity types. - if((Tasks[TaskID]->Activity[ActivityID].Type > 0) && Tasks[TaskID]->Activity[ActivityID].Type < 100) - buf.WriteUInt32(Tasks[TaskID]->Activity[ActivityID].Type); - else - buf.WriteUInt32(ActivityCastOn); // w/e! + // 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 ((Tasks[TaskID]->activity_information[ActivityID].Type > 0) && Tasks[TaskID]->activity_information[ActivityID].Type < 100) { + buf.WriteUInt32(Tasks[TaskID]->activity_information[ActivityID].Type); + } + else { + buf.WriteUInt32(ActivityCastOn); + } // w/e! buf.WriteUInt8(Optional); - buf.WriteUInt32(0); // solo, group, raid + buf.WriteUInt32(0); // solo, group, raid - // One of these unknown fields maybe related to the 'Use On' activity types - buf.WriteString(Tasks[TaskID]->Activity[ActivityID].target_name); // target name string + // One of these unknown fields maybe related to the 'Use On' activity_information types + buf.WriteString(Tasks[TaskID]->activity_information[ActivityID].target_name); // target name string - buf.WriteLengthString(Tasks[TaskID]->Activity[ActivityID].item_list); // item name list + buf.WriteLengthString(Tasks[TaskID]->activity_information[ActivityID].item_list); // item name list // Goal Count - if(Tasks[TaskID]->Activity[ActivityID].Type != ActivityGiveCash) - buf.WriteUInt32(Tasks[TaskID]->Activity[ActivityID].GoalCount); + if (Tasks[TaskID]->activity_information[ActivityID].Type != ActivityGiveCash) + buf.WriteUInt32(Tasks[TaskID]->activity_information[ActivityID].GoalCount); else - buf.WriteUInt32(1); // GoalCount + buf.WriteUInt32(1); // GoalCount // skill ID list ; separated - buf.WriteLengthString(Tasks[TaskID]->Activity[ActivityID].skill_list); + buf.WriteLengthString(Tasks[TaskID]->activity_information[ActivityID].skill_list); // spelll ID list ; separated -- unsure wtf we're doing here - buf.WriteLengthString(Tasks[TaskID]->Activity[ActivityID].spell_list); + buf.WriteLengthString(Tasks[TaskID]->activity_information[ActivityID].spell_list); - buf.WriteString(Tasks[TaskID]->Activity[ActivityID].zones); - buf.WriteUInt32(0); // unknown7 + buf.WriteString(Tasks[TaskID]->activity_information[ActivityID].zones); + buf.WriteUInt32(0); // unknown7 - buf.WriteString(Tasks[TaskID]->Activity[ActivityID].desc_override); // description override + buf.WriteString(Tasks[TaskID]->activity_information[ActivityID].desc_override); // description override - if(Tasks[TaskID]->Activity[ActivityID].Type != ActivityGiveCash) - buf.WriteUInt32(c->GetTaskActivityDoneCount(Tasks[TaskID]->type, ClientTaskIndex, ActivityID)); // DoneCount + if (Tasks[TaskID]->activity_information[ActivityID].Type != ActivityGiveCash) + buf.WriteUInt32(c->GetTaskActivityDoneCount(Tasks[TaskID]->type, ClientTaskIndex, ActivityID)); // done_count else - // For internal activity types, DoneCount is either 1 if the activity is complete, 0 otherwise. - buf.WriteUInt32((c->GetTaskActivityDoneCount(Tasks[TaskID]->type, ClientTaskIndex, ActivityID) >= Tasks[TaskID]->Activity[ActivityID].GoalCount)); + // For internal activity_information types, done_count is either 1 if the activity_information is complete, 0 otherwise. + buf.WriteUInt32((c->GetTaskActivityDoneCount(Tasks[TaskID]->type, ClientTaskIndex, ActivityID) >= + Tasks[TaskID]->activity_information[ActivityID].GoalCount)); - buf.WriteUInt8(1); // unknown9 + buf.WriteUInt8(1); // unknown9 - buf.WriteString(Tasks[TaskID]->Activity[ActivityID].zones); + buf.WriteString(Tasks[TaskID]->activity_information[ActivityID].zones); auto outapp = new EQApplicationPacket(OP_TaskActivity, buf); @@ -2862,35 +3190,46 @@ void TaskManager::SendTaskActivityNew(Client *c, int TaskID, int ActivityID, int void TaskManager::SendActiveTasksToClient(Client *c, bool TaskComplete) { auto state = c->GetTaskState(); - if (!state) + if (!state) { return; + } for (int TaskIndex = 0; TaskIndex < MAXACTIVEQUESTS + 1; TaskIndex++) { - int TaskID = state->ActiveTasks[TaskIndex].TaskID; - if ((TaskID == 0) || (Tasks[TaskID] == 0)) + int TaskID = state->ActiveTasks[TaskIndex].task_id; + if ((TaskID == 0) || (Tasks[TaskID] == 0)) { continue; - int StartTime = state->ActiveTasks[TaskIndex].AcceptedTime; + } + int StartTime = state->ActiveTasks[TaskIndex].accepted_time; - SendActiveTaskDescription(c, TaskID, state->ActiveTasks[TaskIndex], StartTime, Tasks[TaskID]->Duration, - false); + SendActiveTaskDescription( + c, TaskID, state->ActiveTasks[TaskIndex], StartTime, Tasks[TaskID]->duration, + false + ); Log(Logs::General, Logs::Tasks, "[UPDATE] SendActiveTasksToClient: Task %i, Activities: %i", TaskID, - GetActivityCount(TaskID)); + GetActivityCount(TaskID)); - int Sequence = 0; - int fixed_index = Tasks[TaskID]->type == TaskType::Task ? 0 : TaskIndex - 1; // hmmm fuck - for (int Activity = 0; Activity < GetActivityCount(TaskID); Activity++) { + int Sequence = 0; + int fixed_index = Tasks[TaskID]->type == TaskType::Task ? 0 : TaskIndex - 1; // hmmm fuck + for (int Activity = 0; Activity < GetActivityCount(TaskID); Activity++) { if (c->GetTaskActivityState(Tasks[TaskID]->type, fixed_index, Activity) != ActivityHidden) { Log(Logs::General, Logs::Tasks, "[UPDATE] Long: %i, %i, %i Complete=%i", TaskID, - Activity, fixed_index, TaskComplete); - if (Activity == GetActivityCount(TaskID) - 1) - SendTaskActivityLong(c, TaskID, Activity, fixed_index, - Tasks[TaskID]->Activity[Activity].Optional, TaskComplete); - else - SendTaskActivityLong(c, TaskID, Activity, fixed_index, - Tasks[TaskID]->Activity[Activity].Optional, 0); - } else { + Activity, fixed_index, TaskComplete); + if (Activity == GetActivityCount(TaskID) - 1) { + SendTaskActivityLong( + c, TaskID, Activity, fixed_index, + Tasks[TaskID]->activity_information[Activity].Optional, TaskComplete + ); + } + else { + SendTaskActivityLong( + c, TaskID, Activity, fixed_index, + Tasks[TaskID]->activity_information[Activity].Optional, 0 + ); + } + } + else { Log(Logs::General, Logs::Tasks, "[UPDATE] Short: %i, %i, %i", TaskID, Activity, - fixed_index); + fixed_index); SendTaskActivityShort(c, TaskID, Activity, fixed_index); } Sequence++; @@ -2898,59 +3237,83 @@ void TaskManager::SendActiveTasksToClient(Client *c, bool TaskComplete) } } -void TaskManager::SendSingleActiveTaskToClient(Client *c, ClientTaskInformation &task_info, bool TaskComplete, - bool BringUpTaskJournal) +void TaskManager::SendSingleActiveTaskToClient( + Client *c, ClientTaskInformation &task_info, bool TaskComplete, + bool BringUpTaskJournal +) { - int TaskID = task_info.TaskID; + int TaskID = task_info.task_id; - if (TaskID == 0 || Tasks[TaskID] == nullptr) + if (TaskID == 0 || Tasks[TaskID] == nullptr) { return; + } - int StartTime = task_info.AcceptedTime; - SendActiveTaskDescription(c, TaskID, task_info, StartTime, Tasks[TaskID]->Duration, BringUpTaskJournal); - Log(Logs::General, Logs::Tasks, "[UPDATE] SendSingleActiveTasksToClient: Task %i, Activities: %i", TaskID, GetActivityCount(TaskID)); + int StartTime = task_info.accepted_time; + SendActiveTaskDescription(c, TaskID, task_info, StartTime, Tasks[TaskID]->duration, BringUpTaskJournal); + Log(Logs::General, + Logs::Tasks, + "[UPDATE] SendSingleActiveTasksToClient: Task %i, Activities: %i", + TaskID, + GetActivityCount(TaskID)); for (int Activity = 0; Activity < GetActivityCount(TaskID); Activity++) { - if(task_info.Activity[Activity].State != ActivityHidden) { + if (task_info.activity[Activity].activity_state != ActivityHidden) { Log(Logs::General, Logs::Tasks, "[UPDATE] Long: %i, %i Complete=%i", TaskID, Activity, TaskComplete); - if (Activity == GetActivityCount(TaskID) - 1) - SendTaskActivityLong(c, TaskID, Activity, task_info.slot, - Tasks[TaskID]->Activity[Activity].Optional, TaskComplete); - else - SendTaskActivityLong(c, TaskID, Activity, task_info.slot, - Tasks[TaskID]->Activity[Activity].Optional, 0); - } else { + if (Activity == GetActivityCount(TaskID) - 1) { + SendTaskActivityLong( + c, TaskID, Activity, task_info.slot, + Tasks[TaskID]->activity_information[Activity].Optional, TaskComplete + ); + } + else { + SendTaskActivityLong( + c, TaskID, Activity, task_info.slot, + Tasks[TaskID]->activity_information[Activity].Optional, 0 + ); + } + } + else { Log(Logs::General, Logs::Tasks, "[UPDATE] Short: %i, %i", TaskID, Activity); SendTaskActivityShort(c, TaskID, Activity, task_info.slot); } } } -void TaskManager::SendActiveTaskDescription(Client *c, int TaskID, ClientTaskInformation &task_info, int StartTime, int Duration, bool BringUpTaskJournal) +void TaskManager::SendActiveTaskDescription( + Client *c, + int TaskID, + ClientTaskInformation &task_info, + int StartTime, + int Duration, + bool BringUpTaskJournal +) { - if ((TaskID < 1) || (TaskID >= MAXTASKS) || !Tasks[TaskID]) + if ((TaskID < 1) || (TaskID >= MAXTASKS) || !Tasks[TaskID]) { return; + } - int PacketLength = sizeof(TaskDescriptionHeader_Struct) + Tasks[TaskID]->Title.length() + 1 - + sizeof(TaskDescriptionData1_Struct) + Tasks[TaskID]->Description.length() + 1 - + sizeof(TaskDescriptionData2_Struct) + 1 + sizeof(TaskDescriptionTrailer_Struct); + int PacketLength = sizeof(TaskDescriptionHeader_Struct) + Tasks[TaskID]->title.length() + 1 + + sizeof(TaskDescriptionData1_Struct) + Tasks[TaskID]->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 + // 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(Tasks[TaskID]->RewardID && Tasks[TaskID]->item_link.empty()) { + if (Tasks[TaskID]->reward_id && Tasks[TaskID]->item_link.empty()) { int ItemID = 0; // If the reward is a list of items, and the first entry on the list is valid - if (Tasks[TaskID]->RewardMethod == METHODSINGLEID) { - ItemID = Tasks[TaskID]->RewardID; - } else if (Tasks[TaskID]->RewardMethod == METHODLIST) { - ItemID = GoalListManager.GetFirstEntry(Tasks[TaskID]->RewardID); - if (ItemID < 0) + if (Tasks[TaskID]->reward_method == METHODSINGLEID) { + ItemID = Tasks[TaskID]->reward_id; + } + else if (Tasks[TaskID]->reward_method == METHODLIST) { + ItemID = GoalListManager.GetFirstEntry(Tasks[TaskID]->reward_id); + if (ItemID < 0) { ItemID = 0; + } } - if(ItemID) { - const EQ::ItemData* reward_item = database.GetItem(ItemID); + if (ItemID) { + const EQ::ItemData *reward_item = database.GetItem(ItemID); EQ::SayLinkEngine linker; linker.SetLinkType(EQ::saylink::SayLinkItemData); @@ -2960,65 +3323,65 @@ void TaskManager::SendActiveTaskDescription(Client *c, int TaskID, ClientTaskInf } } - PacketLength += Tasks[TaskID]->Reward.length() + 1 + Tasks[TaskID]->item_link.length() + 1; + PacketLength += Tasks[TaskID]->reward.length() + 1 + Tasks[TaskID]->item_link.length() + 1; - char *Ptr; - TaskDescriptionHeader_Struct* tdh; - TaskDescriptionData1_Struct* tdd1; - TaskDescriptionData2_Struct* tdd2; - TaskDescriptionTrailer_Struct* tdt; + char *Ptr; + TaskDescriptionHeader_Struct *tdh; + TaskDescriptionData1_Struct *tdd1; + TaskDescriptionData2_Struct *tdd2; + TaskDescriptionTrailer_Struct *tdt; auto outapp = new EQApplicationPacket(OP_TaskDescription, PacketLength); - tdh = (TaskDescriptionHeader_Struct*)outapp->pBuffer; + tdh = (TaskDescriptionHeader_Struct *) outapp->pBuffer; tdh->SequenceNumber = task_info.slot; - tdh->TaskID = TaskID; - tdh->open_window = BringUpTaskJournal; - tdh->task_type = static_cast(Tasks[TaskID]->type); - tdh->reward_type = 0; // TODO: 4 says Radiant Crystals else Ebon Crystals when shared task + tdh->TaskID = TaskID; + tdh->open_window = BringUpTaskJournal; + tdh->task_type = static_cast(Tasks[TaskID]->type); + tdh->reward_type = 0; // TODO: 4 says Radiant Crystals else Ebon Crystals when shared task Ptr = (char *) tdh + sizeof(TaskDescriptionHeader_Struct); - sprintf(Ptr, "%s", Tasks[TaskID]->Title.c_str()); - Ptr += Tasks[TaskID]->Title.length() + 1; + sprintf(Ptr, "%s", Tasks[TaskID]->title.c_str()); + Ptr += Tasks[TaskID]->title.length() + 1; - tdd1 = (TaskDescriptionData1_Struct*)Ptr; + tdd1 = (TaskDescriptionData1_Struct *) Ptr; tdd1->Duration = Duration; - tdd1->dur_code = static_cast(Tasks[TaskID]->dur_code); + tdd1->dur_code = static_cast(Tasks[TaskID]->duration_code); tdd1->StartTime = StartTime; Ptr = (char *) tdd1 + sizeof(TaskDescriptionData1_Struct); - sprintf(Ptr, "%s", Tasks[TaskID]->Description.c_str()); - Ptr += Tasks[TaskID]->Description.length() + 1; + sprintf(Ptr, "%s", Tasks[TaskID]->description.c_str()); + Ptr += Tasks[TaskID]->description.length() + 1; - tdd2 = (TaskDescriptionData2_Struct*)Ptr; + tdd2 = (TaskDescriptionData2_Struct *) Ptr; // we have this reward stuff! // if we ever don't hardcode this, TaskDescriptionTrailer_Struct will need to be fixed since // "has_reward_selection" is after this bool! Smaller packet when this is 0 tdd2->has_rewards = 1; - tdd2->coin_reward = Tasks[TaskID]->CashReward; - tdd2->xp_reward = Tasks[TaskID]->XPReward ? 1 : 0; // just booled + tdd2->coin_reward = Tasks[TaskID]->cash_reward; + tdd2->xp_reward = Tasks[TaskID]->experience_reward ? 1 : 0; // just booled tdd2->faction_reward = Tasks[TaskID]->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", Tasks[TaskID]->Reward.c_str()); - Ptr += Tasks[TaskID]->Reward.length() + 1; + sprintf(Ptr, "%s", Tasks[TaskID]->reward.c_str()); + Ptr += Tasks[TaskID]->reward.length() + 1; // second string is parsed for item links sprintf(Ptr, "%s", Tasks[TaskID]->item_link.c_str()); Ptr += Tasks[TaskID]->item_link.length() + 1; - tdt = (TaskDescriptionTrailer_Struct*)Ptr; - tdt->Points = 0x00000000; // Points Count TODO: this does have a visible affect on the client ... + tdt = (TaskDescriptionTrailer_Struct *) Ptr; + tdt->Points = 0x00000000; // Points Count TODO: this does have a visible affect on the client ... tdt->has_reward_selection = 0; // TODO: new rewards window c->QueuePacket(outapp); @@ -3028,17 +3391,19 @@ void TaskManager::SendActiveTaskDescription(Client *c, int TaskID, ClientTaskInf bool ClientTaskState::IsTaskActivityCompleted(TaskType type, int index, int ActivityID) { switch (type) { - case TaskType::Task: - if (index != 0) + case TaskType::Task: + if (index != 0) { + return false; + } + return active_task.activity[ActivityID].activity_state == ActivityCompleted; + case TaskType::Shared: + return false; // TODO: shared tasks + case TaskType::Quest: + if (index < MAXACTIVEQUESTS) { + return active_quests[index].activity[ActivityID].activity_state == ActivityCompleted; + } + default: return false; - return ActiveTask.Activity[ActivityID].State == ActivityCompleted; - case TaskType::Shared: - return false; // TODO: shared tasks - case TaskType::Quest: - if (index < MAXACTIVEQUESTS) - return ActiveQuests[index].Activity[ActivityID].State == ActivityCompleted; - default: - return false; } } @@ -3047,59 +3412,65 @@ bool ClientTaskState::IsTaskActivityCompleted(TaskType type, int index, int Acti ActivityState ClientTaskState::GetTaskActivityState(TaskType type, int index, int ActivityID) { switch (type) { - case TaskType::Task: - if (index != 0) + case TaskType::Task: + if (index != 0) { + return ActivityHidden; + } + return active_task.activity[ActivityID].activity_state; + case TaskType::Shared: + return ActivityHidden; // TODO: shared tasks + case TaskType::Quest: + if (index < MAXACTIVEQUESTS) { + return active_quests[index].activity[ActivityID].activity_state; + } + default: return ActivityHidden; - return ActiveTask.Activity[ActivityID].State; - case TaskType::Shared: - return ActivityHidden; // TODO: shared tasks - case TaskType::Quest: - if (index < MAXACTIVEQUESTS) - return ActiveQuests[index].Activity[ActivityID].State; - default: - return ActivityHidden; } } int ClientTaskState::GetTaskActivityDoneCount(TaskType type, int index, int ActivityID) { switch (type) { - case TaskType::Task: - if (index != 0) + case TaskType::Task: + if (index != 0) { + return 0; + } + return active_task.activity[ActivityID].done_count; + case TaskType::Shared: + return 0; // TODO: shared tasks + case TaskType::Quest: + if (index < MAXACTIVEQUESTS) { + return active_quests[index].activity[ActivityID].done_count; + } + default: return 0; - return ActiveTask.Activity[ActivityID].DoneCount; - case TaskType::Shared: - return 0; // TODO: shared tasks - case TaskType::Quest: - if (index < MAXACTIVEQUESTS) - return ActiveQuests[index].Activity[ActivityID].DoneCount; - default: - return 0; } } int ClientTaskState::GetTaskActivityDoneCountFromTaskID(int TaskID, int ActivityID) { - if (ActiveTask.TaskID == TaskID) - return ActiveTask.Activity[ActivityID].DoneCount; + if (active_task.task_id == TaskID) { + return active_task.activity[ActivityID].done_count; + } // TODO: shared tasks - int ActiveTaskIndex = -1; - for(int i=0; ipBuffer; + CancelTask_Struct *cts = (CancelTask_Struct *) outapp->pBuffer; cts->SequenceNumber = SequenceNumber; - cts->type = static_cast(type); + cts->type = static_cast(type); Log(Logs::General, Logs::Tasks, "[UPDATE] CancelTask"); c->QueuePacket(outapp); safe_delete(outapp); - if(RemoveFromDB) + if (RemoveFromDB) { RemoveTask(c, SequenceNumber, type); + } } void ClientTaskState::RemoveTask(Client *c, int sequenceNumber, TaskType type) @@ -3159,67 +3532,81 @@ void ClientTaskState::RemoveTask(Client *c, int sequenceNumber, TaskType type) int task_id = -1; switch (type) { - case TaskType::Task: - if (sequenceNumber == 0) - task_id = ActiveTask.TaskID; - break; - case TaskType::Quest: - if (sequenceNumber < MAXACTIVEQUESTS) - task_id = ActiveQuests[sequenceNumber].TaskID; - break; - case TaskType::Shared: // TODO: - default: - break; + case TaskType::Task: + if (sequenceNumber == 0) { + task_id = active_task.task_id; + } + break; + case TaskType::Quest: + if (sequenceNumber < MAXACTIVEQUESTS) { + task_id = active_quests[sequenceNumber].task_id; + } + break; + case TaskType::Shared: // TODO: + default: + break; } - std::string query = StringFormat("DELETE FROM character_activities WHERE charid=%i AND taskid = %i", - characterID, task_id); - auto results = database.QueryDatabase(query); + std::string query = StringFormat( + "DELETE FROM character_activities WHERE charid=%i AND taskid = %i", + characterID, task_id + ); + auto results = database.QueryDatabase(query); if (!results.Success()) { LogError("[TASKS] Error in CientTaskState::CancelTask [{}]", - results.ErrorMessage().c_str()); + results.ErrorMessage().c_str()); return; } Log(Logs::General, Logs::Tasks, "[UPDATE] CancelTask: %s", query.c_str()); - query = StringFormat("DELETE FROM character_tasks WHERE charid=%i AND taskid = %i AND type=%i", characterID, - task_id, static_cast(type)); + query = StringFormat( + "DELETE FROM character_tasks WHERE charid=%i AND taskid = %i AND type=%i", characterID, + task_id, static_cast(type)); results = database.QueryDatabase(query); if (!results.Success()) LogError("[TASKS] Error in CientTaskState::CancelTask [{}]", - results.ErrorMessage().c_str()); + results.ErrorMessage().c_str()); Log(Logs::General, Logs::Tasks, "[UPDATE] CancelTask: %s", query.c_str()); switch (type) { - case TaskType::Task: - ActiveTask.TaskID = TASKSLOTEMPTY; - break; - case TaskType::Shared: - break; // TODO: shared tasks - case TaskType::Quest: - ActiveQuests[sequenceNumber].TaskID = TASKSLOTEMPTY; - ActiveTaskCount--; - break; - default: - break; + case TaskType::Task: + active_task.task_id = TASKSLOTEMPTY; + break; + case TaskType::Shared: + break; // TODO: shared tasks + case TaskType::Quest: + active_quests[sequenceNumber].task_id = TASKSLOTEMPTY; + active_task_count--; + break; + default: + break; } } void ClientTaskState::RemoveTaskByTaskID(Client *c, uint32 task_id) { - auto task_type = taskmanager->GetTaskType(task_id); - int character_id = c->CharacterID(); + auto task_type = p_task_manager->GetTaskType(task_id); + int character_id = c->CharacterID(); Log(Logs::General, Logs::Tasks, "[UPDATE] RemoveTaskByTaskID: %d", task_id); - std::string query = fmt::format("DELETE FROM character_activities WHERE charid = {} AND taskid = {}", character_id, task_id); - auto results = database.QueryDatabase(query); + std::string query = fmt::format( + "DELETE FROM character_activities WHERE charid = {} AND taskid = {}", + character_id, + task_id + ); + auto results = database.QueryDatabase(query); if (!results.Success()) { LogError("[TASKS] Error in CientTaskState::RemoveTaskByTaskID [{}]", results.ErrorMessage().c_str()); return; } LogTasks("[UPDATE] RemoveTaskByTaskID: {}", query.c_str()); - query = fmt::format("DELETE FROM character_tasks WHERE charid = {} AND taskid = {} AND type = {}", character_id, task_id, (int) task_type); + query = fmt::format( + "DELETE FROM character_tasks WHERE charid = {} AND taskid = {} AND type = {}", + character_id, + task_id, + (int) task_type + ); results = database.QueryDatabase(query); if (!results.Success()) { LogError("[TASKS] Error in ClientTaskState::RemoveTaskByTaskID [{}]", results.ErrorMessage().c_str()); @@ -3228,35 +3615,32 @@ void ClientTaskState::RemoveTaskByTaskID(Client *c, uint32 task_id) LogTasks("[UPDATE] RemoveTaskByTaskID: {}", query.c_str()); switch (task_type) { - case TaskType::Task: - { - if (ActiveTask.TaskID == task_id) { - auto outapp = new EQApplicationPacket(OP_CancelTask, sizeof(CancelTask_Struct)); - CancelTask_Struct* cts = (CancelTask_Struct*)outapp->pBuffer; + case TaskType::Task: { + if (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; - cts->type = static_cast(task_type); + cts->type = static_cast(task_type); LogTasks("[UPDATE] RemoveTaskByTaskID found Task [{}]", task_id); c->QueuePacket(outapp); safe_delete(outapp); - ActiveTask.TaskID = TASKSLOTEMPTY; + active_task.task_id = TASKSLOTEMPTY; } break; } - case TaskType::Shared: - { + case TaskType::Shared: { break; // TODO: shared tasks } - case TaskType::Quest: - { + case TaskType::Quest: { for (int active_quest = 0; active_quest < MAXACTIVEQUESTS; active_quest++) { - if (ActiveQuests[active_quest].TaskID == task_id) { - auto outapp = new EQApplicationPacket(OP_CancelTask, sizeof(CancelTask_Struct)); - CancelTask_Struct* cts = (CancelTask_Struct*)outapp->pBuffer; + if (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); + cts->type = static_cast(task_type); LogTasks("[UPDATE] RemoveTaskByTaskID found Quest [{}] at index [{}]", task_id, active_quest); - ActiveQuests[active_quest].TaskID = TASKSLOTEMPTY; - ActiveTaskCount--; + active_quests[active_quest].task_id = TASKSLOTEMPTY; + active_task_count--; c->QueuePacket(outapp); safe_delete(outapp); } @@ -3270,35 +3654,37 @@ void ClientTaskState::RemoveTaskByTaskID(Client *c, uint32 task_id) void ClientTaskState::AcceptNewTask(Client *c, int TaskID, int NPCID, bool enforce_level_requirement) { - if (!taskmanager || TaskID < 0 || TaskID >= MAXTASKS) { - c->Message(Chat::Red, "Task system not functioning, or TaskID %i out of range.", TaskID); + if (!p_task_manager || TaskID < 0 || TaskID >= MAXTASKS) { + c->Message(Chat::Red, "Task system not functioning, or task_id %i out of range.", TaskID); return; } - auto task = taskmanager->Tasks[TaskID]; + auto task = p_task_manager->Tasks[TaskID]; if (task == nullptr) { - c->Message(Chat::Red, "Invalid TaskID %i", TaskID); + c->Message(Chat::Red, "Invalid task_id %i", TaskID); return; } bool max_tasks = false; switch (task->type) { - case TaskType::Task: - if (ActiveTask.TaskID != TASKSLOTEMPTY) + case TaskType::Task: + if (active_task.task_id != TASKSLOTEMPTY) { + max_tasks = true; + } + break; + case TaskType::Shared: // TODO: shared tasks + // if (something) max_tasks = true; - break; - case TaskType::Shared: // TODO: shared tasks - // if (something) - max_tasks = true; - break; - case TaskType::Quest: - if (ActiveTaskCount == MAXACTIVEQUESTS) - max_tasks = true; - break; - default: - break; + break; + case TaskType::Quest: + if (active_task_count == MAXACTIVEQUESTS) { + max_tasks = true; + } + break; + default: + break; } if (max_tasks) { @@ -3309,20 +3695,21 @@ void ClientTaskState::AcceptNewTask(Client *c, int TaskID, int NPCID, bool enfor // only Quests can have more than one, so don't need to check others if (task->type == TaskType::Quest) { for (int i = 0; i < MAXACTIVEQUESTS; i++) { - if (ActiveQuests[i].TaskID == TaskID) { + if (active_quests[i].task_id == TaskID) { c->Message(Chat::Red, "You have already been assigned this task."); return; } } } - if (enforce_level_requirement && !taskmanager->AppropriateLevel(TaskID, c->GetLevel())) { + if (enforce_level_requirement && !p_task_manager->ValidateLevel(TaskID, c->GetLevel())) { c->Message(Chat::Red, "You are outside the level range of this task."); return; } - if (!taskmanager->IsTaskRepeatable(TaskID) && IsTaskCompleted(TaskID)) + if (!p_task_manager->IsTaskRepeatable(TaskID) && IsTaskCompleted(TaskID)) { return; + } // We do it this way, because when the Client cancels a task, it retains the sequence number of the remaining // tasks in it's window, until something causes the TaskDescription packets to be sent again. We could just @@ -3331,25 +3718,25 @@ void ClientTaskState::AcceptNewTask(Client *c, int TaskID, int NPCID, bool enfor // ClientTaskInformation *active_slot = nullptr; switch (task->type) { - case TaskType::Task: - active_slot = &ActiveTask; - break; - case TaskType::Shared: // TODO: shared - active_slot = nullptr; - break; - case TaskType::Quest: - for (int i = 0; i < MAXACTIVEQUESTS; i++) { - Log(Logs::General, Logs::Tasks, - "[UPDATE] ClientTaskState Looking for free slot in slot %i, found TaskID of %i", i, - ActiveQuests[i].TaskID); - if (ActiveQuests[i].TaskID == 0) { - active_slot = &ActiveQuests[i]; - break; + case TaskType::Task: + active_slot = &active_task; + break; + case TaskType::Shared: // TODO: shared + active_slot = nullptr; + break; + case TaskType::Quest: + for (int i = 0; i < MAXACTIVEQUESTS; i++) { + Log(Logs::General, Logs::Tasks, + "[UPDATE] ClientTaskState Looking for free slot in slot %i, found task_id of %i", i, + active_quests[i].task_id); + if (active_quests[i].task_id == 0) { + active_slot = &active_quests[i]; + break; + } } - } - break; - default: - break; + break; + default: + break; } // This shouldn't happen unless there is a bug in the handling of ActiveTaskCount somewhere @@ -3358,47 +3745,55 @@ void ClientTaskState::AcceptNewTask(Client *c, int TaskID, int NPCID, bool enfor return; } - active_slot->TaskID = TaskID; - active_slot->AcceptedTime = time(nullptr); - active_slot->Updated = true; - active_slot->CurrentStep = -1; + active_slot->task_id = TaskID; + active_slot->accepted_time = time(nullptr); + active_slot->updated = true; + active_slot->current_step = -1; - for (int i = 0; i < taskmanager->Tasks[TaskID]->ActivityCount; i++) { - active_slot->Activity[i].ActivityID = i; - active_slot->Activity[i].DoneCount = 0; - active_slot->Activity[i].State = ActivityHidden; - active_slot->Activity[i].Updated = true; + for (int i = 0; i < p_task_manager->Tasks[TaskID]->activity_count; i++) { + active_slot->activity[i].activity_id = i; + active_slot->activity[i].done_count = 0; + active_slot->activity[i].activity_state = ActivityHidden; + active_slot->activity[i].updated = true; } UnlockActivities(c->CharacterID(), *active_slot); - if (task->type == TaskType::Quest) - ActiveTaskCount++; + if (task->type == TaskType::Quest) { + active_task_count++; + } - taskmanager->SendSingleActiveTaskToClient(c, *active_slot, false, true); - c->Message(Chat::White, "You have been assigned the task '%s'.", taskmanager->Tasks[TaskID]->Title.c_str()); - taskmanager->SaveClientState(c, this); + p_task_manager->SendSingleActiveTaskToClient(c, *active_slot, false, true); + c->Message(Chat::White, "You have been assigned the task '%s'.", p_task_manager->Tasks[TaskID]->title.c_str()); + p_task_manager->SaveClientState(c, this); std::string buf = std::to_string(TaskID); NPC *npc = entity_list.GetID(NPCID)->CastToNPC(); - if(npc) { + if (npc) { parse->EventNPC(EVENT_TASK_ACCEPTED, npc, c, buf.c_str(), 0); } } -void ClientTaskState::ProcessTaskProximities(Client *c, float X, float Y, float Z) { +void ClientTaskState::ProcessTaskProximities(Client *c, float X, float Y, float Z) +{ float LastX = c->ProximityX(); float LastY = c->ProximityY(); float LastZ = c->ProximityZ(); - if((LastX==X) && (LastY==Y) && (LastZ==Z)) return; + if ((LastX == X) && (LastY == Y) && (LastZ == Z)) { return; } Log(Logs::General, Logs::Tasks, "[PROXIMITY] Checking proximities for Position %8.3f, %8.3f, %8.3f", X, Y, Z); - int ExploreID = taskmanager->ProximityManager.CheckProximities(X, Y, Z); + int ExploreID = p_task_manager->ProximityManager.CheckProximities(X, Y, Z); - if(ExploreID > 0) { - Log(Logs::General, Logs::Tasks, "[PROXIMITY] Position %8.3f, %8.3f, %8.3f is within proximity %i", X, Y, Z, ExploreID); + if (ExploreID > 0) { + Log(Logs::General, + Logs::Tasks, + "[PROXIMITY] Position %8.3f, %8.3f, %8.3f is within proximity %i", + X, + Y, + Z, + ExploreID); UpdateTasksOnExplore(c, ExploreID); } } @@ -3421,22 +3816,21 @@ bool TaskGoalListManager::LoadLists() NumberOfLists = 0; - std::string query = "SELECT `listid`, COUNT(`entry`) " - "FROM `goallists` GROUP by `listid` " - "ORDER BY `listid`"; - auto results = content_db.QueryDatabase(query); + std::string query = "SELECT `listid`, COUNT(`entry`) " + "FROM `goallists` GROUP by `listid` " + "ORDER BY `listid`"; + auto results = content_db.QueryDatabase(query); if (!results.Success()) { return false; } NumberOfLists = results.RowCount(); - Log(Logs::General, Logs::Tasks, "[GLOBALLOAD] Database returned a count of %i lists", NumberOfLists); + LogTasks("Loading GoalLists [{}] lists", NumberOfLists); TaskGoalLists.reserve(NumberOfLists); - int list_index = 0; - - for (auto row = results.begin(); row != results.end(); ++row) { + int list_index = 0; + for (auto row = results.begin(); row != results.end(); ++row) { int listID = atoi(row[0]); int listSize = atoi(row[1]); @@ -3448,10 +3842,9 @@ bool TaskGoalListManager::LoadLists() } auto goal_lists = GoallistsRepository::GetWhere(content_db, "TRUE ORDER BY listid, entry ASC"); - for (list_index = 0; list_index < NumberOfLists; list_index++) { - int list_id = TaskGoalLists[list_index].ListID; + int list_id = TaskGoalLists[list_index].ListID; for (auto &entry: goal_lists) { if (entry.listid == list_id) { @@ -3479,41 +3872,44 @@ bool TaskGoalListManager::LoadLists() } -int TaskGoalListManager::GetListByID(int ListID) { +int TaskGoalListManager::GetListByID(int ListID) +{ // Find the list with the specified ListID and return the index - auto it = std::find_if(TaskGoalLists.begin(), TaskGoalLists.end(), - [ListID](const TaskGoalList_Struct &t) { return t.ListID == ListID; }); + auto it = std::find_if( + TaskGoalLists.begin(), + TaskGoalLists.end(), + [ListID](const TaskGoalList_Struct &t) { return t.ListID == ListID; } + ); - if (it == TaskGoalLists.end()) + if (it == TaskGoalLists.end()) { return -1; + } return std::distance(TaskGoalLists.begin(), it); } -int TaskGoalListManager::GetFirstEntry(int ListID) { - +int TaskGoalListManager::GetFirstEntry(int ListID) +{ int ListIndex = GetListByID(ListID); - if((ListIndex < 0) || (ListIndex >= NumberOfLists)) return -1; + if ((ListIndex < 0) || (ListIndex >= NumberOfLists)) { return -1; } - if(TaskGoalLists[ListIndex].GoalItemEntries.empty()) return -1; + if (TaskGoalLists[ListIndex].GoalItemEntries.empty()) { return -1; } return TaskGoalLists[ListIndex].GoalItemEntries[0]; } -std::vector TaskGoalListManager::GetListContents(int ListID) { - +std::vector TaskGoalListManager::GetListContents(int ListID) +{ std::vector ListContents; + int ListIndex = GetListByID(ListID); - int ListIndex = GetListByID(ListID); - - if((ListIndex < 0) || (ListIndex >= NumberOfLists)) return ListContents; + if ((ListIndex < 0) || (ListIndex >= NumberOfLists)) { return ListContents; } ListContents = TaskGoalLists[ListIndex].GoalItemEntries; return ListContents; - } bool TaskGoalListManager::IsInList(int ListID, int Entry) @@ -3522,77 +3918,98 @@ bool TaskGoalListManager::IsInList(int ListID, int Entry) int ListIndex = GetListByID(ListID); - if ((ListIndex < 0) || (ListIndex >= NumberOfLists)) + if ((ListIndex < 0) || (ListIndex >= NumberOfLists)) { return false; + } - if ((Entry < TaskGoalLists[ListIndex].Min) || (Entry > TaskGoalLists[ListIndex].Max)) + if ((Entry < TaskGoalLists[ListIndex].Min) || (Entry > TaskGoalLists[ListIndex].Max)) { return false; + } - int FirstEntry = 0; - auto &task = TaskGoalLists[ListIndex]; + int FirstEntry = 0; + auto &task = TaskGoalLists[ListIndex]; auto it = std::find(task.GoalItemEntries.begin(), task.GoalItemEntries.end(), Entry); - if (it == task.GoalItemEntries.end()) + if (it == task.GoalItemEntries.end()) { return false; + } Log(Logs::General, Logs::Tasks, "[UPDATE] TaskGoalListManager::IsInList(%i, %i) returning true", ListIndex, - Entry); + Entry); return true; } -TaskProximityManager::TaskProximityManager() { +TaskProximityManager::TaskProximityManager() +{ } -TaskProximityManager::~TaskProximityManager() { +TaskProximityManager::~TaskProximityManager() +{ } -bool TaskProximityManager::LoadProximities(int zoneID) { +bool TaskProximityManager::LoadProximities(int zoneID) +{ TaskProximity proximity; Log(Logs::General, Logs::Tasks, "[GLOBALLOAD] TaskProximityManager::LoadProximities Called for zone %i", zoneID); TaskProximities.clear(); - std::string query = StringFormat("SELECT `exploreid`, `minx`, `maxx`, " - "`miny`, `maxy`, `minz`, `maxz` " - "FROM `proximities` WHERE `zoneid` = %i " - "ORDER BY `zoneid` ASC", zoneID); - auto results = content_db.QueryDatabase(query); - if (!results.Success()) { + std::string query = StringFormat( + "SELECT `exploreid`, `minx`, `maxx`, " + "`miny`, `maxy`, `minz`, `maxz` " + "FROM `proximities` WHERE `zoneid` = %i " + "ORDER BY `zoneid` ASC", zoneID + ); + auto results = content_db.QueryDatabase(query); + if (!results.Success()) { return false; - } + } - for( auto row = results.begin(); row != results.end(); ++row) { - proximity.ExploreID = atoi(row[0]); - proximity.MinX = atof(row[1]); - proximity.MaxX = atof(row[2]); - proximity.MinY = atof(row[3]); - proximity.MaxY = atof(row[4]); - proximity.MinZ = atof(row[5]); - proximity.MaxZ = atof(row[6]); + for (auto row = results.begin(); row != results.end(); ++row) { + proximity.ExploreID = atoi(row[0]); + proximity.MinX = atof(row[1]); + proximity.MaxX = atof(row[2]); + proximity.MinY = atof(row[3]); + proximity.MaxY = atof(row[4]); + proximity.MinZ = atof(row[5]); + proximity.MaxZ = atof(row[6]); - TaskProximities.push_back(proximity); - } + TaskProximities.push_back(proximity); + } return true; } -int TaskProximityManager::CheckProximities(float X, float Y, float Z) { +int TaskProximityManager::CheckProximities(float X, float Y, float Z) +{ - for(unsigned int i=0; iMinX, P->MaxX, P->MinY, P->MaxY, P->MinZ, P->MaxZ); + Log(Logs::General, + Logs::Tasks, + "[PROXIMITY] Checking %8.3f, %8.3f, %8.3f against %8.3f, %8.3f, %8.3f, %8.3f, %8.3f, %8.3f", + X, + Y, + Z, + P->MinX, + P->MaxX, + P->MinY, + P->MaxY, + P->MinZ, + P->MaxZ); - if(X < P->MinX || X > P->MaxX || Y < P->MinY || Y > P->MaxY || - Z < P->MinZ || Z > P->MaxZ) continue; + if (X < P->MinX || X > P->MaxX || Y < P->MinY || Y > P->MaxY || + Z < P->MinZ || Z > P->MaxZ) { + continue; + } return P->ExploreID; diff --git a/zone/tasks.h b/zone/tasks.h index cb4cd63c1..bea2dadc0 100644 --- a/zone/tasks.h +++ b/zone/tasks.h @@ -39,23 +39,22 @@ Copyright (C) 2001-2004 EQEMu Development Team (http://eqemulator.net) #define TASKSLOTEMPTY 0 // Command Codes for worldserver ServerOP_ReloadTasks -// -#define RELOADTASKS 0 -#define RELOADTASKGOALLISTS 1 -#define RELOADTASKPROXIMITIES 2 -#define RELOADTASKSETS 3 +#define RELOADTASKS 0 +#define RELOADTASKGOALLISTS 1 +#define RELOADTASKPROXIMITIES 2 +#define RELOADTASKSETS 3 class Client; + class Mob; -namespace EQ -{ +namespace EQ { class ItemInstance; } struct TaskGoalList_Struct { - int ListID; - int Min, Max; + int ListID; + int Min, Max; std::vector GoalItemEntries; }; @@ -77,11 +76,11 @@ public: private: std::vector TaskGoalLists; - int NumberOfLists; + int NumberOfLists; }; typedef struct { - int ExploreID; + int ExploreID; float MinX, MaxX, MinY, MaxY, MinZ, MaxZ; } TaskProximity; @@ -98,99 +97,122 @@ private: std::vector TaskProximities; }; -typedef enum { METHODSINGLEID = 0, METHODLIST = 1, METHODQUEST = 2 } TaskMethodType; +typedef enum { + METHODSINGLEID = 0, + METHODLIST = 1, + METHODQUEST = 2 +} TaskMethodType; struct ActivityInformation { - int StepNumber; - int Type; - std::string target_name; // name mob, location -- default empty - std::string item_list; // likely defaults to empty - std::string skill_list; // IDs ; separated -- default -1 - std::string spell_list; // IDs ; separated -- default 0 - std::string desc_override; // overrides auto generated description -- default empty - int skill_id; // older clients, first id from above - int spell_id; // older clients, first id from above - int GoalID; - TaskMethodType GoalMethod; - int GoalCount; - int DeliverToNPC; - std::vector ZoneIDs; - std::string zones; // IDs ; searated, ZoneID is the first in this list for older clients -- default empty string - bool Optional; + int StepNumber; + int Type; + std::string target_name; // name mob, location -- default empty + std::string item_list; // likely defaults to empty + std::string skill_list; // IDs ; separated -- default -1 + std::string spell_list; // IDs ; separated -- default 0 + std::string desc_override; // overrides auto generated description -- default empty + int skill_id; // older clients, first id from above + int spell_id; // older clients, first id from above + int GoalID; + TaskMethodType GoalMethod; + int GoalCount; + int DeliverToNPC; + std::vector ZoneIDs; + std::string zones; // IDs ; searated, ZoneID is the first in this list for older clients -- default empty string + bool Optional; - inline bool CheckZone(int zone_id) { - if (ZoneIDs.empty()) + inline bool CheckZone(int zone_id) + { + if (ZoneIDs.empty()) { return true; + } return std::find(ZoneIDs.begin(), ZoneIDs.end(), zone_id) != ZoneIDs.end(); } }; -typedef enum { ActivitiesSequential = 0, ActivitiesStepped = 1 } SequenceType; +typedef enum { + ActivitiesSequential = 0, ActivitiesStepped = 1 +} SequenceType; enum class TaskType { - Task = 0, // can have at max 1 - Shared = 1, // can have at max 1 - Quest = 2, // can have at max 19 or 29 depending on client - E = 3 // can have at max 19 or 29 depending on client, not present in live anymore + Task = 0, // can have at max 1 + Shared = 1, // can have at max 1 + Quest = 2, // can have at max 19 or 29 depending on client + E = 3 // can have at max 19 or 29 depending on client, not present in live anymore }; enum class DurationCode { - None = 0, - Short = 1, + None = 0, + Short = 1, Medium = 2, - Long = 3 + Long = 3 }; struct TaskInformation { - TaskType type; - int Duration; - DurationCode dur_code; // description for time investment for when Duration == 0 - std::string Title; // max length 64 - std::string Description; // max length 4000, 2048 on Tit - std::string Reward; - std::string item_link; // max length 128 older clients, item link gets own string - std::string completion_emote; // emote after completing task, yellow. Maybe should make more generic ... but yellow for now! - int RewardID; - int CashReward; // Expressed in copper - int XPReward; - int faction_reward; // just a npc_faction_id - TaskMethodType RewardMethod; - int ActivityCount; - SequenceType SequenceMode; - int LastStep; - short MinLevel; - short MaxLevel; - bool Repeatable; - ActivityInformation Activity[MAXACTIVITIESPERTASK]; + TaskType type; + int duration; + DurationCode duration_code; // description for time investment for when duration == 0 + std::string title; // max length 64 + std::string description; // max length 4000, 2048 on Tit + std::string reward; + std::string item_link; // max length 128 older clients, item link gets own string + std::string completion_emote; // emote after completing task, yellow. Maybe should make more generic ... but yellow for now! + int reward_id; + int cash_reward; // Expressed in copper + int experience_reward; + int faction_reward; // just a npc_faction_id + TaskMethodType reward_method; + int activity_count; + SequenceType sequence_mode; + int last_step; + short min_level; + short max_level; + bool repeatable; + ActivityInformation activity_information[MAXACTIVITIESPERTASK]; }; -typedef enum { ActivityHidden = 0, ActivityActive = 1, ActivityCompleted = 2 } ActivityState; - -typedef enum { ActivityDeliver = 1, ActivityKill = 2, ActivityLoot = 3, ActivitySpeakWith = 4, ActivityExplore = 5, - ActivityTradeSkill = 6, ActivityFish = 7, ActivityForage = 8, ActivityCastOn = 9, ActivitySkillOn = 10, - ActivityTouch = 11, ActivityCollect = 13, ActivityGiveCash = 100 } ActivityType; +typedef enum { + ActivityHidden = 0, + ActivityActive = 1, + ActivityCompleted = 2 +} ActivityState; +typedef enum { + ActivityDeliver = 1, + ActivityKill = 2, + ActivityLoot = 3, + ActivitySpeakWith = 4, + ActivityExplore = 5, + ActivityTradeSkill = 6, + ActivityFish = 7, + ActivityForage = 8, + ActivityCastOn = 9, + ActivitySkillOn = 10, + ActivityTouch = 11, + ActivityCollect = 13, + ActivityGiveCash = 100 +} ActivityType; struct ClientActivityInformation { - int ActivityID; - int DoneCount; - ActivityState State; - bool Updated; // Flag so we know if we need to update the database + int activity_id; + int done_count; + ActivityState activity_state; + bool updated; // Flag so we know if we need to updated the database }; struct ClientTaskInformation { - int slot; // intrusive, but makes things easier :P - int TaskID; - int CurrentStep; - int AcceptedTime; - bool Updated; - ClientActivityInformation Activity[MAXACTIVITIESPERTASK]; + int slot; // intrusive, but makes things easier :P + int task_id; + int current_step; + int accepted_time; + bool updated; + ClientActivityInformation activity[MAXACTIVITIESPERTASK]; }; struct CompletedTaskInformation { - int TaskID; - int CompletedTime; - bool ActivityDone[MAXACTIVITIESPERTASK]; + int task_id; + int completed_time; + bool activity_done[MAXACTIVITIESPERTASK]; }; class ClientTaskState { @@ -199,7 +221,7 @@ public: ClientTaskState(); ~ClientTaskState(); void ShowClientTasks(Client *c); - inline int GetActiveTaskCount() { return ActiveTaskCount; } + inline int GetActiveTaskCount() { return active_task_count; } int GetActiveTaskID(int index); bool IsTaskActivityCompleted(TaskType type, int index, int ActivityID); int GetTaskActivityDoneCount(TaskType type, int index, int ActivityID); @@ -218,67 +240,76 @@ public: void CancelAllTasks(Client *c); void RemoveTask(Client *c, int SequenceNumber, TaskType type); void RemoveTaskByTaskID(Client *c, uint32 task_id); - bool UpdateTasksByNPC(Client *c, int ActivityType, int NPCTypeID); + bool UpdateTasksByNPC(Client *c, int activity_type, int npc_type_id); void UpdateTasksOnKill(Client *c, int NPCTypeID); - void UpdateTasksForItem(Client *c, ActivityType Type, int ItemID, int Count=1); + void UpdateTasksForItem(Client *c, ActivityType Type, int ItemID, int Count = 1); void UpdateTasksOnExplore(Client *c, int ExploreID); bool UpdateTasksOnSpeakWith(Client *c, int NPCTypeID); - bool UpdateTasksOnDeliver(Client *c, std::list& Items, int Cash, int NPCTypeID); + bool UpdateTasksOnDeliver(Client *c, std::list &Items, int Cash, int NPCTypeID); void UpdateTasksOnTouch(Client *c, int ZoneID); void ProcessTaskProximities(Client *c, float X, float Y, float Z); bool TaskOutOfTime(TaskType type, int Index); void TaskPeriodicChecks(Client *c); void SendTaskHistory(Client *c, int TaskIndex); void RewardTask(Client *c, TaskInformation *Task); - void EnableTask(int CharID, int TaskCount, int *TaskList); - void DisableTask(int CharID, int TaskCount, int *TaskList); + void EnableTask(int character_id, int task_count, int *TaskList); + void DisableTask(int character_id, int task_count, int *task_list); bool IsTaskEnabled(int TaskID); int EnabledTaskCount(int TaskSetID); - int ActiveSpeakTask(int NPCID); - int ActiveSpeakActivity(int NPCID, int TaskID); + int ActiveSpeakTask(int npc_type_id); + int ActiveSpeakActivity(int npc_type_id, int task_id); int ActiveTasksInSet(int TaskSetID); int CompletedTasksInSet(int TaskSetID); bool HasSlotForTask(TaskInformation *task); - inline bool HasFreeTaskSlot() { return ActiveTask.TaskID == TASKSLOTEMPTY; } + inline bool HasFreeTaskSlot() { return active_task.task_id == TASKSLOTEMPTY; } friend class TaskManager; private: - bool UnlockActivities(int CharID, ClientTaskInformation &task_info); - void IncrementDoneCount(Client *c, TaskInformation *Task, int TaskIndex, int ActivityID, int Count = 1, bool ignore_quest_update = false); + bool UnlockActivities(int character_id, ClientTaskInformation &task_info); + void IncrementDoneCount( + Client *c, + TaskInformation *Task, + int TaskIndex, + int ActivityID, + int Count = 1, + bool ignore_quest_update = false + ); inline ClientTaskInformation *GetClientTaskInfo(TaskType type, int index) { ClientTaskInformation *info = nullptr; switch (type) { - case TaskType::Task: - if (index == 0) - info = &ActiveTask; - break; - case TaskType::Shared: - break; - case TaskType::Quest: - if (index < MAXACTIVEQUESTS) - info = &ActiveQuests[index]; - break; - default: - break; + case TaskType::Task: + if (index == 0) { + info = &active_task; + } + break; + case TaskType::Shared: + break; + case TaskType::Quest: + if (index < MAXACTIVEQUESTS) { + info = &active_quests[index]; + } + break; + default: + break; } return info; } - int ActiveTaskCount; + int active_task_count; union { // easier to loop over struct { - ClientTaskInformation ActiveTask; // only one - ClientTaskInformation ActiveQuests[MAXACTIVEQUESTS]; + ClientTaskInformation active_task; // only one + ClientTaskInformation active_quests[MAXACTIVEQUESTS]; }; ClientTaskInformation ActiveTasks[MAXACTIVEQUESTS + 1]; }; // Shared tasks should be limited to 1 as well - std::vector EnabledTasks; - std::vector CompletedTasks; - int LastCompletedTaskLoaded; - bool CheckedTouchActivities; + std::vector enabled_tasks; + std::vector completed_tasks; + int last_completed_task_loaded; + bool checked_touch_activities; }; @@ -289,7 +320,7 @@ public: ~TaskManager(); int GetActivityCount(int TaskID); bool LoadSingleTask(int TaskID); - bool LoadTasks(int SingleTask=0); + bool LoadTasks(int SingleTask = 0); void ReloadGoalLists(); inline void LoadProximities(int ZoneID) { ProximityManager.LoadProximities(ZoneID); } bool LoadTaskSets(); @@ -297,35 +328,58 @@ public: bool SaveClientState(Client *c, ClientTaskState *state); void SendTaskSelector(Client *c, Mob *mob, int TaskCount, int *TaskList); void SendTaskSelectorNew(Client *c, Mob *mob, int TaskCount, int *TaskList); - bool AppropriateLevel(int TaskID, int PlayerLevel); + bool ValidateLevel(int TaskID, int PlayerLevel); int GetTaskMinLevel(int TaskID); int GetTaskMaxLevel(int TaskID); std::string GetTaskName(uint32 task_id); TaskType GetTaskType(uint32 task_id); void TaskSetSelector(Client *c, ClientTaskState *state, Mob *mob, int TaskSetID); - void TaskQuestSetSelector(Client *c, ClientTaskState *state, Mob *mob, int count, int *tasks); // task list provided by QuestManager (perl/lua) - void SendActiveTasksToClient(Client *c, bool TaskComplete=false); - void SendSingleActiveTaskToClient(Client *c, ClientTaskInformation &task_info, bool TaskComplete, bool BringUpTaskJournal = false); + void TaskQuestSetSelector( + Client *c, + ClientTaskState *state, + Mob *mob, + int count, + int *tasks + ); // task list provided by QuestManager (perl/lua) + void SendActiveTasksToClient(Client *c, bool TaskComplete = false); + void SendSingleActiveTaskToClient( + Client *c, + ClientTaskInformation &task_info, + bool TaskComplete, + bool BringUpTaskJournal = false + ); void SendTaskActivityShort(Client *c, int TaskID, int ActivityID, int ClientTaskIndex); - void SendTaskActivityLong(Client *c, int TaskID, int ActivityID, int ClientTaskIndex, - bool Optional, bool TaskComplete=false); - void SendTaskActivityNew(Client *c, int TaskID, int ActivityID, int ClientTaskIndex, - bool Optional, bool TaskComplete=false); + void SendTaskActivityLong( + Client *c, int TaskID, int ActivityID, int ClientTaskIndex, + bool Optional, bool TaskComplete = false + ); + void SendTaskActivityNew( + Client *c, int TaskID, int ActivityID, int ClientTaskIndex, + bool Optional, bool TaskComplete = false + ); void SendCompletedTasksToClient(Client *c, ClientTaskState *state); void ExplainTask(Client *c, int TaskID); int FirstTaskInSet(int TaskSet); int LastTaskInSet(int TaskSet); int NextTaskInSet(int TaskSet, int TaskID); bool IsTaskRepeatable(int TaskID); + friend class ClientTaskState; private: - TaskGoalListManager GoalListManager; + TaskGoalListManager GoalListManager; TaskProximityManager ProximityManager; - TaskInformation* Tasks[MAXTASKS]; - std::vector TaskSets[MAXTASKSETS]; - void SendActiveTaskDescription(Client *c, int TaskID, ClientTaskInformation &task_info, int StartTime, int Duration, bool BringUpTaskJournal=false); + TaskInformation *Tasks[MAXTASKS]; + std::vector TaskSets[MAXTASKSETS]; + void SendActiveTaskDescription( + Client *c, + int TaskID, + ClientTaskInformation &task_info, + int StartTime, + int Duration, + bool BringUpTaskJournal = false + ); }; diff --git a/zone/worldserver.cpp b/zone/worldserver.cpp index eea45d057..a5772608f 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(taskmanager); - taskmanager = new TaskManager; - taskmanager->LoadTasks(); + safe_delete(p_task_manager); + p_task_manager = new TaskManager; + p_task_manager->LoadTasks(); if (zone) - taskmanager->LoadProximities(zone->GetZoneID()); + p_task_manager->LoadProximities(zone->GetZoneID()); entity_list.ReloadAllClientsTaskState(); } else { Log(Logs::General, Logs::Tasks, "[GLOBALLOAD] Reload only task %i", rts->Parameter); - taskmanager->LoadTasks(rts->Parameter); + p_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"); - taskmanager->LoadProximities(zone->GetZoneID()); + p_task_manager->LoadProximities(zone->GetZoneID()); } break; case RELOADTASKGOALLISTS: Log(Logs::General, Logs::Tasks, "[GLOBALLOAD] Reload task goal lists"); - taskmanager->ReloadGoalLists(); + p_task_manager->ReloadGoalLists(); break; case RELOADTASKSETS: Log(Logs::General, Logs::Tasks, "[GLOBALLOAD] Reload task sets"); - taskmanager->LoadTaskSets(); + p_task_manager->LoadTaskSets(); break; default: diff --git a/zone/zone.cpp b/zone/zone.cpp index 57f886eec..f088c6cee 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)) { - taskmanager->LoadProximities(zoneid); + p_task_manager->LoadProximities(zoneid); } short_name = strcpy(new char[strlen(in_short_name)+1], in_short_name);