pa/eqemu-server
2
0
Fork 0
mirror of https://github.com/EQEmu/Server.git synced 2026-03-30 09:22:24 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Task update events should be task type aware now

Browse Source
This commit is contained in:
Michael Cook (mackal) 2018-07-05 00:13:19 -04:00
parent 2f4fb46007
commit 0367bc3465
4 changed files with 257 additions and 175 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
common/eq_packet_structs.h
View File

@ -3897,11 +3897,11 @@ struct TaskActivityShort_Struct {
struct TaskActivityComplete_Struct { struct TaskActivityComplete_Struct {
uint32 TaskIndex; uint32 TaskIndex;
uint32 unknown2; // 0x00000002 uint32 TaskType; // task, shared task, quest
uint32 unknown3; uint32 TaskID; // must match
uint32 ActivityID; uint32 ActivityID;
uint32 unknown4; // 0x00000001 uint32 task_completed; // Broadcasts "Task '%1' Completed" it not 0 and "Task '%1' Failed." if 0
uint32 unknown5; // 0x00000001 uint32 stage_complete; // Broadcasts "Task Stage Completed"
}; };
#if 0 #if 0

4
zone/client.h
View File

@ -1001,8 +1001,8 @@ public:
// Task System Methods // Task System Methods
void LoadClientTaskState(); void LoadClientTaskState();
void RemoveClientTaskState(); void RemoveClientTaskState();
void SendTaskActivityComplete(int TaskID, int ActivityID, int TaskIndex, int TaskIncomplete=1); void SendTaskActivityComplete(int TaskID, int ActivityID, int TaskIndex, TaskType type, int TaskIncomplete=1);
void SendTaskFailed(int TaskID, int TaskIndex); void SendTaskFailed(int TaskID, int TaskIndex, TaskType type);
void SendTaskComplete(int TaskIndex); void SendTaskComplete(int TaskIndex);
inline ClientTaskState *GetTaskState() const { return taskstate; } inline ClientTaskState *GetTaskState() const { return taskstate; }

392
zone/tasks.cpp
View File

@ -1468,43 +1468,53 @@ bool ClientTaskState::UpdateTasksByNPC(Client *c, int ActivityType, int NPCTypeI
// If the client has no tasks, there is nothing further to check. // If the client has no tasks, there is nothing further to check.
if(!taskmanager || ActiveTaskCount == 0) return false; if (!taskmanager || (ActiveTaskCount == 0 && ActiveTask.TaskID == TASKSLOTEMPTY)) // could be better ...
return false;
for(int i=0; i<MAXACTIVEQUESTS; i++) { // loop over the union of tasks and quests
if(ActiveQuests[i].TaskID == TASKSLOTEMPTY) continue; for (int i = 0; i < MAXACTIVEQUESTS + 1; i++) {
auto cur_task = &ActiveTasks[i];
if (cur_task->TaskID == TASKSLOTEMPTY)
continue;
// Check if there are any active kill activities for this task // Check if there are any active kill activities for this task
TaskInformation* Task = taskmanager->Tasks[ActiveQuests[i].TaskID]; auto Task = taskmanager->Tasks[cur_task->TaskID];
if(Task == nullptr) return false; if (Task == nullptr)
return false;
for(int j=0; j<Task->ActivityCount; j++) { for (int j = 0; j < Task->ActivityCount; j++) {
// We are not interested in completed or hidden activities // We are not interested in completed or hidden activities
if(ActiveQuests[i].Activity[j].State != ActivityActive) continue; if (cur_task->Activity[j].State != ActivityActive)
continue;
// We are only interested in Kill activities // We are only interested in Kill activities
if(Task->Activity[j].Type != ActivityType) continue; if (Task->Activity[j].Type != ActivityType)
continue;
// Is there a zone restriction on the activity ? // Is there a zone restriction on the activity ?
if((Task->Activity[j].ZoneID >0) && (Task->Activity[j].ZoneID != (int)zone->GetZoneID())) { if ((Task->Activity[j].ZoneID > 0) && (Task->Activity[j].ZoneID != (int)zone->GetZoneID())) {
Log(Logs::General, Logs::Tasks, "[UPDATE] Char: %s Task: %i, Activity %i, Activity type %i for NPC %i failed zone check", Log(Logs::General, Logs::Tasks,
c->GetName(), ActiveQuests[i].TaskID, j, ActivityType, NPCTypeID); "[UPDATE] Char: %s Task: %i, Activity %i, Activity type %i for NPC %i failed zone "
"check",
c->GetName(), cur_task->TaskID, j, ActivityType, NPCTypeID);
continue; continue;
} }
// Is the activity to kill this type of NPC ? // Is the activity to kill this type of NPC ?
switch(Task->Activity[j].GoalMethod) { switch (Task->Activity[j].GoalMethod) {
case METHODSINGLEID: case METHODSINGLEID:
if(Task->Activity[j].GoalID != NPCTypeID) continue; if (Task->Activity[j].GoalID != NPCTypeID)
break;
case METHODLIST:
if(!taskmanager->GoalListManager.IsInList(Task->Activity[j].GoalID,
NPCTypeID)) continue;
break;
default:
// If METHODQUEST, don't update the activity here
continue; continue;
break;
case METHODLIST:
if (!taskmanager->GoalListManager.IsInList(Task->Activity[j].GoalID, NPCTypeID))
continue;
break;
default:
// If METHODQUEST, don't update the activity here
continue;
} }
// We found an active task to kill this type of NPC, so increment the done count // 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"); Log(Logs::General, Logs::Tasks, "[UPDATE] Calling increment done count ByNPC");
@ -1521,26 +1531,32 @@ int ClientTaskState::ActiveSpeakTask(int NPCTypeID) {
// This method is to be used from Perl quests only and returns the TaskID of the first // 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. // active task found which has an active SpeakWith activity for this NPC.
if(!taskmanager || ActiveTaskCount == 0) return 0; if (!taskmanager || (ActiveTaskCount == 0 && ActiveTask.TaskID == TASKSLOTEMPTY)) // could be better ...
return 0;
for(int i=0; i<MAXACTIVEQUESTS; i++) { // loop over the union of tasks and quests
if(ActiveQuests[i].TaskID == TASKSLOTEMPTY) continue; for (int i = 0; i < MAXACTIVEQUESTS + 1; i++) {
auto cur_task = &ActiveTasks[i];
if (cur_task->TaskID == TASKSLOTEMPTY)
continue;
TaskInformation* Task = taskmanager->Tasks[ActiveQuests[i].TaskID]; TaskInformation* Task = taskmanager->Tasks[cur_task->TaskID];
if(Task == nullptr) continue; if (Task == nullptr)
continue;
for(int j=0; j<Task->ActivityCount; j++) { for (int j = 0; j < Task->ActivityCount; j++) {
// We are not interested in completed or hidden activities // We are not interested in completed or hidden activities
if(ActiveQuests[i].Activity[j].State != ActivityActive) continue; if (cur_task->Activity[j].State != ActivityActive)
if(Task->Activity[j].Type != ActivitySpeakWith) continue; continue;
// Is there a zone restriction on the activity ? if (Task->Activity[j].Type != ActivitySpeakWith)
if((Task->Activity[j].ZoneID >0) && (Task->Activity[j].ZoneID != (int)zone->GetZoneID())) { continue;
// Is there a zone restriction on the activity ?
if (Task->Activity[j].ZoneID > 0 && Task->Activity[j].ZoneID != (int)zone->GetZoneID())
continue; continue;
}
// Is the activity to speak with this type of NPC ? // Is the activity to speak with this type of NPC ?
if((Task->Activity[j].GoalMethod == METHODQUEST) && if (Task->Activity[j].GoalMethod == METHODQUEST && Task->Activity[j].GoalID == NPCTypeID)
(Task->Activity[j].GoalID == NPCTypeID)) return ActiveQuests[i].TaskID; return cur_task->TaskID;
} }
} }
return 0; return 0;
@ -1551,27 +1567,34 @@ int ClientTaskState::ActiveSpeakActivity(int NPCTypeID, int TaskID) {
// This method is to be used from Perl quests only and returns the ActivityID of the first // 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. // active activity found in the specified task which is to SpeakWith this NPC.
if(!taskmanager || ActiveTaskCount == 0) return -1; if (!taskmanager || (ActiveTaskCount == 0 && ActiveTask.TaskID == TASKSLOTEMPTY)) // could be better ...
if((TaskID<=0) || (TaskID>=MAXTASKS)) return -1; return -1;
if (TaskID <= 0 || TaskID >= MAXTASKS)
return -1;
for(int i=0; i<MAXACTIVEQUESTS; i++) { // loop over the union of tasks and quests
if(ActiveQuests[i].TaskID != TaskID) continue; for (int i = 0; i < MAXACTIVEQUESTS + 1; i++) {
auto cur_task = &ActiveTasks[i];
if (cur_task->TaskID != TaskID)
continue;
TaskInformation* Task = taskmanager->Tasks[ActiveQuests[i].TaskID]; TaskInformation* Task = taskmanager->Tasks[cur_task->TaskID];
if(Task == nullptr) continue; if (Task == nullptr)
continue;
for(int j=0; j<Task->ActivityCount; j++) { for (int j = 0; j < Task->ActivityCount; j++) {
// We are not interested in completed or hidden activities // We are not interested in completed or hidden activities
if(ActiveQuests[i].Activity[j].State != ActivityActive) continue; if (cur_task->Activity[j].State != ActivityActive)
if(Task->Activity[j].Type != ActivitySpeakWith) continue; continue;
// Is there a zone restriction on the activity ? if (Task->Activity[j].Type != ActivitySpeakWith)
if((Task->Activity[j].ZoneID >0) && (Task->Activity[j].ZoneID != (int)zone->GetZoneID())) { continue;
// Is there a zone restriction on the activity ?
if (Task->Activity[j].ZoneID > 0 && Task->Activity[j].ZoneID != (int)zone->GetZoneID())
continue; continue;
}
// Is the activity to speak with this type of NPC ? // Is the activity to speak with this type of NPC ?
if((Task->Activity[j].GoalMethod == METHODQUEST) && if (Task->Activity[j].GoalMethod == METHODQUEST && Task->Activity[j].GoalID == NPCTypeID)
(Task->Activity[j].GoalID == NPCTypeID)) return j; return j;
} }
return 0; return 0;
} }
@ -1588,24 +1611,31 @@ void ClientTaskState::UpdateTasksForItem(Client *c, ActivityType Type, int ItemI
Log(Logs::General, Logs::Tasks, "[UPDATE] ClientTaskState::UpdateTasksForItem(%d,%d)", Type, ItemID); Log(Logs::General, Logs::Tasks, "[UPDATE] ClientTaskState::UpdateTasksForItem(%d,%d)", Type, ItemID);
if(ActiveTaskCount == 0) return; if (!taskmanager || (ActiveTaskCount == 0 && ActiveTask.TaskID == TASKSLOTEMPTY)) // could be better ...
return;
for(int i=0; i<MAXACTIVEQUESTS; i++) { // loop over the union of tasks and quests
if(ActiveQuests[i].TaskID == TASKSLOTEMPTY) continue; for (int i = 0; i < MAXACTIVEQUESTS + 1; i++) {
auto cur_task = &ActiveTasks[i];
if (cur_task->TaskID == TASKSLOTEMPTY)
continue;
// Check if there are any active loot activities for this task // Check if there are any active loot activities for this task
TaskInformation* Task = taskmanager->Tasks[ActiveQuests[i].TaskID]; TaskInformation* Task = taskmanager->Tasks[cur_task->TaskID];
if(Task == nullptr) return; if (Task == nullptr)
return;
for(int j=0; j<Task->ActivityCount; j++) { for (int j = 0; j < Task->ActivityCount; j++) {
// We are not interested in completed or hidden activities // We are not interested in completed or hidden activities
if(ActiveQuests[i].Activity[j].State != ActivityActive) continue; if (cur_task->Activity[j].State != ActivityActive)
continue;
// We are only interested in the ActivityType we were called with // We are only interested in the ActivityType we were called with
if(Task->Activity[j].Type != (int)Type) continue; if (Task->Activity[j].Type != (int)Type)
continue;
// Is there a zone restriction on the activity ? // Is there a zone restriction on the activity ?
if((Task->Activity[j].ZoneID >0) && (Task->Activity[j].ZoneID != (int)zone->GetZoneID())) { if (Task->Activity[j].ZoneID > 0 && Task->Activity[j].ZoneID != (int)zone->GetZoneID()) {
Log(Logs::General, Logs::Tasks, "[UPDATE] Char: %s Activity type %i for Item %i failed zone check", Log(Logs::General, Logs::Tasks, "[UPDATE] Char: %s Activity type %i for Item %i failed zone check",
c->GetName(), Type, ItemID); c->GetName(), Type, ItemID);
continue; continue;
@ -1635,114 +1665,133 @@ void ClientTaskState::UpdateTasksForItem(Client *c, ActivityType Type, int ItemI
return; return;
} }
void ClientTaskState::UpdateTasksOnExplore(Client *c, int ExploreID) { void ClientTaskState::UpdateTasksOnExplore(Client *c, int ExploreID)
{
// If the client has no tasks, there is nothing further to check. // If the client has no tasks, there is nothing further to check.
Log(Logs::General, Logs::Tasks, "[UPDATE] ClientTaskState::UpdateTasksOnExplore(%i)", ExploreID); Log(Logs::General, Logs::Tasks, "[UPDATE] ClientTaskState::UpdateTasksOnExplore(%i)", ExploreID);
if(ActiveTaskCount == 0) return; if (!taskmanager || (ActiveTaskCount == 0 && ActiveTask.TaskID == TASKSLOTEMPTY)) // could be better ...
return;
for(int i=0; i<MAXACTIVEQUESTS; i++) { // loop over the union of tasks and quests
if(ActiveQuests[i].TaskID == TASKSLOTEMPTY) continue; for (int i = 0; i < MAXACTIVEQUESTS + 1; i++) {
auto cur_task = &ActiveTasks[i];
if (cur_task->TaskID == TASKSLOTEMPTY)
continue;
// Check if there are any active explore activities for this task // Check if there are any active explore activities for this task
TaskInformation* Task = taskmanager->Tasks[ActiveQuests[i].TaskID]; TaskInformation *Task = taskmanager->Tasks[cur_task->TaskID];
if(Task == nullptr) return; if (Task == nullptr)
return;
for(int j=0; j<Task->ActivityCount; j++) { for (int j = 0; j < Task->ActivityCount; j++) {
// We are not interested in completed or hidden activities // We are not interested in completed or hidden activities
if(ActiveQuests[i].Activity[j].State != ActivityActive) continue; if (cur_task->Activity[j].State != ActivityActive)
continue;
// We are only interested in explore activities // We are only interested in explore activities
if(Task->Activity[j].Type != ActivityExplore) continue; if (Task->Activity[j].Type != ActivityExplore)
if((Task->Activity[j].ZoneID >0) && (Task->Activity[j].ZoneID != (int)zone->GetZoneID())) { continue;
Log(Logs::General, Logs::Tasks, "[UPDATE] Char: %s Explore exploreid %i failed zone check", if (Task->Activity[j].ZoneID > 0 && Task->Activity[j].ZoneID != (int)zone->GetZoneID()) {
c->GetName(), ExploreID); Log(Logs::General, Logs::Tasks,
"[UPDATE] Char: %s Explore exploreid %i failed zone check", c->GetName(),
ExploreID);
continue; continue;
} }
// Is the activity to explore this area id ? // Is the activity to explore this area id ?
switch(Task->Activity[j].GoalMethod) { switch (Task->Activity[j].GoalMethod) {
case METHODSINGLEID: case METHODSINGLEID:
if(Task->Activity[j].GoalID != ExploreID) continue; if (Task->Activity[j].GoalID != ExploreID)
break;
case METHODLIST:
if(!taskmanager->GoalListManager.IsInList(Task->Activity[j].GoalID,
ExploreID)) continue;
break;
default:
// If METHODQUEST, don't update the activity here
continue; continue;
break;
case METHODLIST:
if (!taskmanager->GoalListManager.IsInList(Task->Activity[j].GoalID, ExploreID))
continue;
break;
default:
// If METHODQUEST, don't update the activity here
continue;
} }
// We found an active task to explore this area, so set done count to goal count // 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?) // (Only a goal count of 1 makes sense for explore activities?)
Log(Logs::General, Logs::Tasks, "[UPDATE] Increment on explore"); Log(Logs::General, Logs::Tasks, "[UPDATE] Increment on explore");
IncrementDoneCount(c, Task, i, j, IncrementDoneCount(c, Task, i, j,
Task->Activity[j].GoalCount - ActiveQuests[i].Activity[j].DoneCount); Task->Activity[j].GoalCount - cur_task->Activity[j].DoneCount);
} }
} }
return; return;
} }
bool ClientTaskState::UpdateTasksOnDeliver(Client *c, std::list<EQEmu::ItemInstance*>& Items, int Cash, int NPCTypeID) { bool ClientTaskState::UpdateTasksOnDeliver(Client *c, std::list<EQEmu::ItemInstance *> &Items, int Cash, int NPCTypeID)
{
bool Ret = false; bool Ret = false;
Log(Logs::General, Logs::Tasks, "[UPDATE] ClientTaskState::UpdateTasksForOnDeliver(%d)", NPCTypeID); Log(Logs::General, Logs::Tasks, "[UPDATE] ClientTaskState::UpdateTasksForOnDeliver(%d)", NPCTypeID);
if(ActiveTaskCount == 0) return false; if (!taskmanager || (ActiveTaskCount == 0 && ActiveTask.TaskID == TASKSLOTEMPTY)) // could be better ...
return false;
for(int i=0; i<MAXACTIVEQUESTS; i++) { // loop over the union of tasks and quests
if(ActiveQuests[i].TaskID == TASKSLOTEMPTY) continue; for (int i = 0; i < MAXACTIVEQUESTS + 1; i++) {
auto cur_task = &ActiveTasks[i];
if (cur_task->TaskID == TASKSLOTEMPTY)
continue;
// Check if there are any active deliver activities for this task // Check if there are any active deliver activities for this task
TaskInformation* Task = taskmanager->Tasks[ActiveQuests[i].TaskID]; TaskInformation *Task = taskmanager->Tasks[cur_task->TaskID];
if(Task == nullptr) return false; if (Task == nullptr)
return false;
for(int j=0; j<Task->ActivityCount; j++) { for (int j = 0; j < Task->ActivityCount; j++) {
// We are not interested in completed or hidden activities // We are not interested in completed or hidden activities
if(ActiveQuests[i].Activity[j].State != ActivityActive) continue; if (cur_task->Activity[j].State != ActivityActive)
continue;
// We are only interested in Deliver activities // We are only interested in Deliver activities
if((Task->Activity[j].Type != ActivityDeliver) && if (Task->Activity[j].Type != ActivityDeliver && Task->Activity[j].Type != ActivityGiveCash)
(Task->Activity[j].Type != ActivityGiveCash)) continue; continue;
// Is there a zone restriction on the activity ? // Is there a zone restriction on the activity ?
if((Task->Activity[j].ZoneID >0) && (Task->Activity[j].ZoneID != (int)zone->GetZoneID())) { if (Task->Activity[j].ZoneID > 0 && Task->Activity[j].ZoneID != (int)zone->GetZoneID()) {
Log(Logs::General, Logs::Tasks, "[UPDATE] Char: %s Deliver activity failed zone check (current zone %i, need zone %i", Log(Logs::General, Logs::Tasks,
c->GetName(), zone->GetZoneID(), Task->Activity[j].ZoneID); "[UPDATE] Char: %s Deliver activity failed zone check (current zone %i, need zone "
"%i",
c->GetName(), zone->GetZoneID(), Task->Activity[j].ZoneID);
continue; continue;
} }
// Is the activity to deliver to this NPCTypeID ? // Is the activity to deliver to this NPCTypeID ?
if(Task->Activity[j].DeliverToNPC != NPCTypeID) continue; if (Task->Activity[j].DeliverToNPC != NPCTypeID)
continue;
// Is the activity related to these items ? // Is the activity related to these items ?
// //
if((Task->Activity[j].Type == ActivityGiveCash) && Cash) { if ((Task->Activity[j].Type == ActivityGiveCash) && Cash) {
Log(Logs::General, Logs::Tasks, "[UPDATE] Increment on GiveCash"); Log(Logs::General, Logs::Tasks, "[UPDATE] Increment on GiveCash");
IncrementDoneCount(c, Task, i, j, Cash); IncrementDoneCount(c, Task, i, j, Cash);
Ret = true; Ret = true;
} } else {
else { for (auto &k : Items) {
for(auto& k : Items) { switch (Task->Activity[j].GoalMethod) {
switch(Task->Activity[j].GoalMethod) {
case METHODSINGLEID: case METHODSINGLEID:
if(Task->Activity[j].GoalID != k->GetID()) continue; if (Task->Activity[j].GoalID != k->GetID())
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; 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 // We found an active task related to this item, so increment the done count
Log(Logs::General, Logs::Tasks, "[UPDATE] Increment on GiveItem"); Log(Logs::General, Logs::Tasks, "[UPDATE] Increment on GiveItem");
@ -1756,74 +1805,89 @@ bool ClientTaskState::UpdateTasksOnDeliver(Client *c, std::list<EQEmu::ItemInsta
return Ret; return Ret;
} }
void ClientTaskState::UpdateTasksOnTouch(Client *c, int ZoneID) { void ClientTaskState::UpdateTasksOnTouch(Client *c, int ZoneID)
{
// If the client has no tasks, there is nothing further to check. // If the client has no tasks, there is nothing further to check.
Log(Logs::General, Logs::Tasks, "[UPDATE] ClientTaskState::UpdateTasksOnTouch(%i)", ZoneID); Log(Logs::General, Logs::Tasks, "[UPDATE] ClientTaskState::UpdateTasksOnTouch(%i)", ZoneID);
if(ActiveTaskCount == 0) return; if (!taskmanager || (ActiveTaskCount == 0 && ActiveTask.TaskID == TASKSLOTEMPTY)) // could be better ...
return;
for(int i=0; i<MAXACTIVEQUESTS; i++) { // loop over the union of tasks and quests
if(ActiveQuests[i].TaskID == TASKSLOTEMPTY) continue; for (int i = 0; i < MAXACTIVEQUESTS + 1; i++) {
auto cur_task = &ActiveTasks[i];
if (cur_task->TaskID == TASKSLOTEMPTY)
continue;
// Check if there are any active explore activities for this task // Check if there are any active explore activities for this task
TaskInformation* Task = taskmanager->Tasks[ActiveQuests[i].TaskID]; TaskInformation *Task = taskmanager->Tasks[cur_task->TaskID];
if(Task == nullptr) return; if (Task == nullptr)
return;
for(int j=0; j<Task->ActivityCount; j++) { for (int j = 0; j < Task->ActivityCount; j++) {
// We are not interested in completed or hidden activities // We are not interested in completed or hidden activities
if(ActiveQuests[i].Activity[j].State != ActivityActive) continue; if (cur_task->Activity[j].State != ActivityActive)
continue;
// We are only interested in touch activities // We are only interested in touch activities
if(Task->Activity[j].Type != ActivityTouch) continue; if (Task->Activity[j].Type != ActivityTouch)
if(Task->Activity[j].GoalMethod != METHODSINGLEID) continue; continue;
if(Task->Activity[j].ZoneID != ZoneID) { if (Task->Activity[j].GoalMethod != METHODSINGLEID)
continue;
if (Task->Activity[j].ZoneID != ZoneID) {
Log(Logs::General, Logs::Tasks, "[UPDATE] Char: %s Touch activity failed zone check", Log(Logs::General, Logs::Tasks, "[UPDATE] Char: %s Touch activity failed zone check",
c->GetName()); c->GetName());
continue; continue;
} }
// We found an active task to zone into this zone, so set done count to goal count // 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?) // (Only a goal count of 1 makes sense for touch activities?)
Log(Logs::General, Logs::Tasks, "[UPDATE] Increment on Touch"); Log(Logs::General, Logs::Tasks, "[UPDATE] Increment on Touch");
IncrementDoneCount(c, Task, i, j, IncrementDoneCount(c, Task, i, j,
Task->Activity[j].GoalCount - ActiveQuests[i].Activity[j].DoneCount); Task->Activity[j].GoalCount - cur_task->Activity[j].DoneCount);
} }
} }
return; 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"); Log(Logs::General, Logs::Tasks, "[UPDATE] IncrementDoneCount");
ActiveQuests[TaskIndex].Activity[ActivityID].DoneCount += Count; auto info = GetClientTaskInfo(Task->type, TaskIndex);
if(ActiveQuests[TaskIndex].Activity[ActivityID].DoneCount > Task->Activity[ActivityID].GoalCount) if (info == nullptr)
ActiveQuests[TaskIndex].Activity[ActivityID].DoneCount = Task->Activity[ActivityID].GoalCount; return;
info->Activity[ActivityID].DoneCount += Count;
if(info->Activity[ActivityID].DoneCount > Task->Activity[ActivityID].GoalCount)
info->Activity[ActivityID].DoneCount = Task->Activity[ActivityID].GoalCount;
if (!ignore_quest_update){ if (!ignore_quest_update){
char buf[24]; char buf[24];
snprintf(buf, 23, "%d %d %d", ActiveQuests[TaskIndex].Activity[ActivityID].DoneCount, ActiveQuests[TaskIndex].Activity[ActivityID].ActivityID, ActiveQuests[TaskIndex].TaskID); snprintf(buf, 23, "%d %d %d", info->Activity[ActivityID].DoneCount, info->Activity[ActivityID].ActivityID, info->TaskID);
buf[23] = '\0'; buf[23] = '\0';
parse->EventPlayer(EVENT_TASK_UPDATE, c, buf, 0); parse->EventPlayer(EVENT_TASK_UPDATE, c, buf, 0);
} }
ActiveQuests[TaskIndex].Activity[ActivityID].Updated=true; info->Activity[ActivityID].Updated=true;
// Have we reached the goal count for this activity ? // Have we reached the goal count for this activity ?
if(ActiveQuests[TaskIndex].Activity[ActivityID].DoneCount >= Task->Activity[ActivityID].GoalCount) { if(info->Activity[ActivityID].DoneCount >= Task->Activity[ActivityID].GoalCount) {
Log(Logs::General, Logs::Tasks, "[UPDATE] Done (%i) = Goal (%i) for Activity %i", Log(Logs::General, Logs::Tasks, "[UPDATE] Done (%i) = Goal (%i) for Activity %i",
ActiveQuests[TaskIndex].Activity[ActivityID].DoneCount, info->Activity[ActivityID].DoneCount,
Task->Activity[ActivityID].GoalCount, Task->Activity[ActivityID].GoalCount,
ActivityID); ActivityID);
// Flag the activity as complete // Flag the activity as complete
ActiveQuests[TaskIndex].Activity[ActivityID].State = ActivityCompleted; info->Activity[ActivityID].State = ActivityCompleted;
// Unlock subsequent activities for this task // Unlock subsequent activities for this task
bool TaskComplete = UnlockActivities(c->CharacterID(), ActiveQuests[TaskIndex]); // TODO: fix this function bool TaskComplete = UnlockActivities(c->CharacterID(), *info);
Log(Logs::General, Logs::Tasks, "[UPDATE] TaskCompleted is %i", TaskComplete); Log(Logs::General, Logs::Tasks, "[UPDATE] TaskCompleted is %i", TaskComplete);
// and by the 'Task Stage Completed' message // and by the 'Task Stage Completed' message
c->SendTaskActivityComplete(ActiveQuests[TaskIndex].TaskID, ActivityID, TaskIndex); c->SendTaskActivityComplete(info->TaskID, ActivityID, TaskIndex, Task->type);
// Send the updated task/activity list to the client // Send the updated task/activity list to the client
taskmanager->SendSingleActiveTaskToClient(c, ActiveQuests[TaskIndex], TaskComplete, false); taskmanager->SendSingleActiveTaskToClient(c, ActiveQuests[TaskIndex], TaskComplete, false);
// Inform the client the task has been updated, both by a chat message // Inform the client the task has been updated, both by a chat message
@ -1832,13 +1896,13 @@ void ClientTaskState::IncrementDoneCount(Client *c, TaskInformation* Task, int T
if(Task->Activity[ActivityID].GoalMethod != METHODQUEST) { if(Task->Activity[ActivityID].GoalMethod != METHODQUEST) {
if (!ignore_quest_update){ if (!ignore_quest_update){
char buf[24]; char buf[24];
snprintf(buf, 23, "%d %d", ActiveQuests[TaskIndex].TaskID, ActiveQuests[TaskIndex].Activity[ActivityID].ActivityID); snprintf(buf, 23, "%d %d", info->TaskID, info->Activity[ActivityID].ActivityID);
buf[23] = '\0'; buf[23] = '\0';
parse->EventPlayer(EVENT_TASK_STAGE_COMPLETE, c, buf, 0); parse->EventPlayer(EVENT_TASK_STAGE_COMPLETE, c, buf, 0);
} }
/* QS: PlayerLogTaskUpdates :: Update */ /* QS: PlayerLogTaskUpdates :: Update */
if (RuleB(QueryServ, PlayerLogTaskUpdates)){ if (RuleB(QueryServ, PlayerLogTaskUpdates)){
std::string event_desc = StringFormat("Task Stage Complete :: taskid:%i activityid:%i donecount:%i in zoneid:%i instid:%i", ActiveQuests[TaskIndex].TaskID, ActiveQuests[TaskIndex].Activity[ActivityID].ActivityID, ActiveQuests[TaskIndex].Activity[ActivityID].DoneCount, c->GetZoneID(), c->GetInstanceID()); 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());
QServ->PlayerLogEvent(Player_Log_Task_Updates, c->CharacterID(), event_desc); QServ->PlayerLogEvent(Player_Log_Task_Updates, c->CharacterID(), event_desc);
} }
} }
@ -1848,21 +1912,21 @@ void ClientTaskState::IncrementDoneCount(Client *c, TaskInformation* Task, int T
// client. This is the same sequence the packets are sent on live. // client. This is the same sequence the packets are sent on live.
if(TaskComplete) { if(TaskComplete) {
char buf[24]; char buf[24];
snprintf(buf, 23, "%d %d %d", ActiveQuests[TaskIndex].Activity[ActivityID].DoneCount, ActiveQuests[TaskIndex].Activity[ActivityID].ActivityID, ActiveQuests[TaskIndex].TaskID); snprintf(buf, 23, "%d %d %d", info->Activity[ActivityID].DoneCount, info->Activity[ActivityID].ActivityID, info->TaskID);
buf[23] = '\0'; buf[23] = '\0';
parse->EventPlayer(EVENT_TASK_COMPLETE, c, buf, 0); parse->EventPlayer(EVENT_TASK_COMPLETE, c, buf, 0);
/* QS: PlayerLogTaskUpdates :: Complete */ /* QS: PlayerLogTaskUpdates :: Complete */
if (RuleB(QueryServ, PlayerLogTaskUpdates)){ if (RuleB(QueryServ, PlayerLogTaskUpdates)){
std::string event_desc = StringFormat("Task Complete :: taskid:%i activityid:%i donecount:%i in zoneid:%i instid:%i", ActiveQuests[TaskIndex].TaskID, ActiveQuests[TaskIndex].Activity[ActivityID].ActivityID, ActiveQuests[TaskIndex].Activity[ActivityID].DoneCount, c->GetZoneID(), c->GetInstanceID()); 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());
QServ->PlayerLogEvent(Player_Log_Task_Updates, c->CharacterID(), event_desc); QServ->PlayerLogEvent(Player_Log_Task_Updates, c->CharacterID(), event_desc);
} }
taskmanager->SendCompletedTasksToClient(c, this); taskmanager->SendCompletedTasksToClient(c, this);
c->SendTaskActivityComplete(ActiveQuests[TaskIndex].TaskID, 0, TaskIndex, false); c->SendTaskActivityComplete(info->TaskID, 0, TaskIndex, Task->type, 0);
taskmanager->SaveClientState(c, this); taskmanager->SaveClientState(c, this);
//c->SendTaskComplete(TaskIndex); //c->SendTaskComplete(TaskIndex);
c->CancelTask(TaskIndex, TaskType::Quest); // TODO: fix c->CancelTask(TaskIndex, Task->type);
//if(Task->RewardMethod != METHODQUEST) RewardTask(c, Task); //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 Experience and/or cash rewards are set, reward them from the task even if RewardMethod is METHODQUEST
RewardTask(c, Task); RewardTask(c, Task);
@ -2007,7 +2071,7 @@ void ClientTaskState::FailTask(Client *c, int TaskID) {
for(int i=0; i<MAXACTIVEQUESTS; i++) { for(int i=0; i<MAXACTIVEQUESTS; i++) {
if(ActiveQuests[i].TaskID==TaskID) { if(ActiveQuests[i].TaskID==TaskID) {
c->SendTaskFailed(ActiveQuests[i].TaskID, i); c->SendTaskFailed(ActiveQuests[i].TaskID, i, TaskType::Quest); // TODO: fix
// Remove the task from the client // Remove the task from the client
c->CancelTask(i, TaskType::Quest); // TODO: fix c->CancelTask(i, TaskType::Quest); // TODO: fix
return; return;
@ -2231,7 +2295,7 @@ void ClientTaskState::TaskPeriodicChecks(Client *c) {
if(TaskOutOfTime(i)) { if(TaskOutOfTime(i)) {
// Send Red Task Failed Message // Send Red Task Failed Message
c->SendTaskFailed(ActiveQuests[i].TaskID, i); c->SendTaskFailed(ActiveQuests[i].TaskID, i, TaskType::Quest); // TODO: fix
// Remove the task from the client // Remove the task from the client
c->CancelTask(i, TaskType::Quest); // TODO: Fix c->CancelTask(i, TaskType::Quest); // TODO: Fix
// It is a conscious decision to only fail one task per call to this method, // It is a conscious decision to only fail one task per call to this method,
@ -2362,8 +2426,8 @@ void ClientTaskState::SendTaskHistory(Client *c, int TaskIndex) {
} }
void Client::SendTaskActivityComplete(int TaskID, int ActivityID, int TaskIndex, int TaskIncomplete) { void Client::SendTaskActivityComplete(int TaskID, int ActivityID, int TaskIndex, TaskType type, int TaskIncomplete)
{
// 0x54eb // 0x54eb
TaskActivityComplete_Struct* tac; TaskActivityComplete_Struct* tac;
@ -2372,15 +2436,12 @@ void Client::SendTaskActivityComplete(int TaskID, int ActivityID, int TaskIndex,
tac = (TaskActivityComplete_Struct*)outapp->pBuffer; tac = (TaskActivityComplete_Struct*)outapp->pBuffer;
//tac->unknown1 = 0x00000000;
tac->TaskIndex = TaskIndex; tac->TaskIndex = TaskIndex;
tac->unknown2 = 0x00000002; tac->TaskType = static_cast<uint32>(type);
//tac->unknown3 = 0x00000000; tac->TaskID = TaskID;
tac->unknown3 = TaskID; // Correct ?
tac->ActivityID = ActivityID; tac->ActivityID = ActivityID;
tac->unknown4 = 0x00000001; tac->task_completed = 0x00000001;
//tac->unknown5 = 0x00000001; tac->stage_complete = TaskIncomplete;
tac->unknown5 = TaskIncomplete;
QueuePacket(outapp); QueuePacket(outapp);
@ -2388,8 +2449,8 @@ void Client::SendTaskActivityComplete(int TaskID, int ActivityID, int TaskIndex,
} }
void Client::SendTaskFailed(int TaskID, int TaskIndex) { void Client::SendTaskFailed(int TaskID, int TaskIndex, TaskType type)
{
// 0x54eb // 0x54eb
char buf[24]; char buf[24];
snprintf(buf, 23, "%d", TaskID); snprintf(buf, 23, "%d", TaskID);
@ -2402,15 +2463,12 @@ void Client::SendTaskFailed(int TaskID, int TaskIndex) {
tac = (TaskActivityComplete_Struct*)outapp->pBuffer; tac = (TaskActivityComplete_Struct*)outapp->pBuffer;
//tac->unknown1 = 0x00000000;
tac->TaskIndex = TaskIndex; tac->TaskIndex = TaskIndex;
tac->unknown2 = 0x00000002; tac->TaskType = static_cast<uint32>(type);
//tac->unknown3 = 0x00000000; tac->TaskID = TaskID;
tac->unknown3 = TaskID; // Correct ?
tac->ActivityID = 0; tac->ActivityID = 0;
tac->unknown4 = 0x00000000; //Fail tac->task_completed = 0; //Fail
//tac->unknown5 = 0x00000001; tac->stage_complete = 0; // 0 for task complete or failed.
tac->unknown5 = 0; // 0 for task complete or failed.
Log(Logs::General, Logs::Tasks, "[UPDATE] TaskFailed"); Log(Logs::General, Logs::Tasks, "[UPDATE] TaskFailed");

28
zone/tasks.h
View File

@ -241,9 +241,33 @@ public:
private: private:
bool UnlockActivities(int CharID, ClientTaskInformation &task_info); 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); 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;
}
return info;
}
int ActiveTaskCount; int ActiveTaskCount;
ClientTaskInformation ActiveTask; // only one union { // easier to loop over
ClientTaskInformation ActiveQuests[MAXACTIVEQUESTS]; struct {
ClientTaskInformation ActiveTask; // only one
ClientTaskInformation ActiveQuests[MAXACTIVEQUESTS];
};
ClientTaskInformation ActiveTasks[MAXACTIVEQUESTS + 1];
};
// Shared tasks should be limited to 1 as well // Shared tasks should be limited to 1 as well
std::vector<int> EnabledTasks; std::vector<int> EnabledTasks;
std::vector<CompletedTaskInformation> CompletedTasks; std::vector<CompletedTaskInformation> CompletedTasks;