[Quest API] Add apis to end shared tasks (#2521)

This required some minor shared task refactoring

- Shared task expiration handling was moved to world. Previously this
  was handled by zone and had clients self remove when a shared task
  expired. This resulted in wrong messages when a task ended.

- FailTask is now implemented for shared tasks which previously only
  made the client quit the shared task. It now fails the task for all
  members by ending the shared task.

The `Client::EndSharedTask` api will end the client's current shared
task (removing all members). This is similiar to the `FailTask` api
except it doesn't require a `task_id` and the red task fail banner is
optional (live doesn't use it for shared tasks).

The global `end_dz_task` api was added for when a client context isn't
available. This will end a shared task if the current zone is a dynamic
zone for a shared task mission. Currently only shared tasks use dynamic
zones but this api can be expanded if support is added for tasks/quests.

The global `get_dz_task_id` was added to conveniently get the task id
for the current dynamic zone if it's used for a mission. Note this is
a database hit since that information is not available at zone level.

world/shared_task_manager.cpp

@@ -242,6 +242,27 @@ void SharedTaskManager::RemoveEveryoneFromSharedTask(SharedTask *t, uint32 reque
 	PrintSharedTaskState();
 }
 
+void SharedTaskManager::Terminate(SharedTask& s, bool send_fail, bool erase)
+{
+	LogTasksDetail("[Terminate] shared task [{}]", s.GetDbSharedTask().id);
+	for (const auto& member : s.GetMembers())
+	{
+		if (send_fail)
+		{
+			SendSharedTaskFailed(member.character_id, s.GetTaskData().id);
+		}
+		SendRemovePlayerFromSharedTaskPacket(member.character_id, s.GetTaskData().id, true);
+		client_list.SendCharacterMessageID(member.character_id, Chat::Yellow, TaskStr::HAS_ENDED, {s.GetTaskData().title});
+	}
+
+	RemoveAllMembersFromDynamicZones(&s);
+
+	if (erase)
+	{
+		DeleteSharedTask(s.GetDbSharedTask().id);
+	}
+}
+
 void SharedTaskManager::DeleteSharedTask(int64 shared_task_id)
 {
 	LogTasksDetail(
@@ -689,6 +710,20 @@ void SharedTaskManager::SendRemovePlayerFromSharedTaskPacket(
 	}
 }
 
+void SharedTaskManager::SendSharedTaskFailed(uint32_t character_id, uint32_t task_id)
+{
+	ServerPacket pack(ServerOP_SharedTaskFailed, sizeof(ServerSharedTaskCharacterTask_Struct));
+	auto buf = reinterpret_cast<ServerSharedTaskCharacterTask_Struct*>(pack.pBuffer);
+	buf->character_id = character_id;
+	buf->task_id = task_id;
+
+	ClientListEntry* cle = client_list.FindCLEByCharacterID(character_id);
+	if (cle && cle->Server())
+	{
+		cle->Server()->SendPacket(&pack);
+	}
+}
+
 void SharedTaskManager::SendSharedTaskMemberList(uint32 character_id, const std::vector<SharedTaskMember> &members)
 {
 	EQ::Net::DynamicPacket dyn_pack;
@@ -1042,6 +1077,18 @@ SharedTask *SharedTaskManager::FindSharedTaskById(int64 shared_task_id)
 	return nullptr;
 }
 
+SharedTask* SharedTaskManager::FindSharedTaskByDzId(uint32_t dz_id)
+{
+	for (auto& s: m_shared_tasks) {
+		auto it = std::find(s.dynamic_zone_ids.begin(), s.dynamic_zone_ids.end(), dz_id);
+		if (it != s.dynamic_zone_ids.end()) {
+			return &s;
+		}
+	}
+
+	return nullptr;
+}
+
 void SharedTaskManager::QueueActiveInvitation(int64 shared_task_id, int64 character_id)
 {
 	LogTasksDetail(
@@ -1757,16 +1804,9 @@ void SharedTaskManager::Process()
 	std::vector<int64_t> delete_tasks;
 	for (auto& shared_task : m_shared_tasks)
 	{
-		if (shared_task.GetMembers().empty() || shared_task.terminate_timer.Check())
+		if (shared_task.GetMembers().empty() || shared_task.terminate_timer.Check() || shared_task.IsExpired())
 		{
-			LogTasksDetail("[Process] Terminating shared task [{}]", shared_task.GetDbSharedTask().id);
-			for (const auto& member : shared_task.GetMembers())
-			{
-				SendRemovePlayerFromSharedTaskPacket(member.character_id, shared_task.GetTaskData().id, true);
-				client_list.SendCharacterMessageID(member.character_id, Chat::Yellow, TaskStr::HAS_ENDED, {shared_task.GetTaskData().title});
-			}
-
-			RemoveAllMembersFromDynamicZones(&shared_task);
+			Terminate(shared_task, false, false);
 
 			// avoid erasing from m_shared_tasks while iterating it
 			delete_tasks.push_back(shared_task.GetDbSharedTask().id);

world/shared_task_manager.h

@@ -50,6 +50,7 @@ public:
 
 	SharedTask *FindSharedTaskByTaskIdAndCharacterId(uint32 task_id, uint32 character_id);
 	SharedTask *FindSharedTaskById(int64 shared_task_id);
+	SharedTask* FindSharedTaskByDzId(uint32_t dz_id);
 
 	void DeleteSharedTask(int64 shared_task_id);
 	void SaveSharedTaskActivityState(int64 shared_task_id, std::vector<SharedTaskActivityStateEntry> activity_state);
@@ -58,6 +59,7 @@ public:
 	void LockTask(SharedTask* s, bool lock);
 	void SendAcceptNewSharedTaskPacket(uint32 character_id, uint32 task_id, uint32_t npc_context_id, int accept_time);
 	void SendRemovePlayerFromSharedTaskPacket(uint32 character_id, uint32 task_id, bool remove_from_db);
+	void SendSharedTaskFailed(uint32_t character_id, uint32_t task_id);
 	void SendSharedTaskMemberList(uint32 character_id, const std::vector<SharedTaskMember> &members);
 	void SendSharedTaskMemberList(uint32 character_id, const EQ::Net::DynamicPacket &serialized_members);
 	void SendSharedTaskMemberChange(
@@ -72,6 +74,9 @@ public:
 	void RemoveMember(SharedTask* s, const SharedTaskMember& member, bool remove_from_db);
 	void RemoveEveryoneFromSharedTask(SharedTask *s, uint32 requested_character_id);
 
+	// caller is responsible for removing from db/cache if erase is false
+	void Terminate(SharedTask& s, bool send_fail, bool erase);
+
 	void MakeLeaderByPlayerName(SharedTask *s, const std::string &character_name);
 	void AddPlayerByCharacterIdAndName(SharedTask *s, int64 character_id, const std::string &character_name);
 	void InvitePlayerByPlayerName(SharedTask *s, const std::string &player_name);

world/shared_task_world_messaging.cpp

@@ -338,6 +338,24 @@ void SharedTaskWorldMessaging::HandleZoneMessage(ServerPacket *pack)
 			}
 			break;
 		}
+		case ServerOP_SharedTaskEndByDz: {
+			auto buf = reinterpret_cast<ServerSharedTaskEnd_Struct*>(pack->pBuffer);
+			auto shared_task = shared_task_manager.FindSharedTaskByDzId(buf->dz_id);
+			if (shared_task)
+			{
+				shared_task_manager.Terminate(*shared_task, buf->send_fail, true);
+			}
+			break;
+		}
+		case ServerOP_SharedTaskEnd: {
+			auto buf = reinterpret_cast<ServerSharedTaskEnd_Struct*>(pack->pBuffer);
+			auto shared_task = shared_task_manager.FindSharedTaskByTaskIdAndCharacterId(buf->task_id, buf->character_id);
+			if (shared_task)
+			{
+				shared_task_manager.Terminate(*shared_task, buf->send_fail, true);
+			}
+			break;
+		}
 		default:
 			break;
 	}

world/zoneserver.cpp

@@ -1411,6 +1411,8 @@ void ZoneServer::HandleMessage(uint16 opcode, const EQ::Net::Packet &p) {
 		case ServerOP_SharedTaskPurgeAllCommand:
 		case ServerOP_SharedTaskPlayerList:
 		case ServerOP_SharedTaskLock:
+		case ServerOP_SharedTaskEndByDz:
+		case ServerOP_SharedTaskEnd:
 		case ServerOP_SharedTaskKickPlayers: {
 			SharedTaskWorldMessaging::HandleZoneMessage(pack);
 			break;