[Expeditions] Decouple dz updates from expeditions (#1303)

Use internal dz messages to process duration and location changes

Add world DynamicZone class (later this will inherit from a base)

Add FindDynamicZoneByID to get dz from zone and world system caches

world/CMakeLists.txt

@@ -7,6 +7,7 @@ SET(world_sources
 	cliententry.cpp
 	clientlist.cpp
 	console.cpp
+	dynamic_zone.cpp
 	eql_config.cpp
 	eqemu_api_world_data_service.cpp
 	expedition.cpp
@@ -41,6 +42,7 @@ SET(world_headers
 	cliententry.h
 	clientlist.h
 	console.h
+	dynamic_zone.h
 	eql_config.h
 	eqemu_api_world_data_service.h
 	expedition.h

world/dynamic_zone.cpp

@@ -0,0 +1,103 @@
+#include "dynamic_zone.h"
+#include "expedition.h"
+#include "expedition_state.h"
+#include "worlddb.h"
+#include "zonelist.h"
+#include "zoneserver.h"
+#include "../common/eqemu_logsys.h"
+#include "../common/repositories/instance_list_repository.h"
+
+extern ZSList zoneserver_list;
+
+DynamicZone::DynamicZone(
+	uint32_t id, uint32_t zone_id, uint32_t instance_id, uint32_t zone_version,
+	uint32_t start_time, uint32_t duration, DynamicZoneType type
+) :
+	m_id(id),
+	m_instance_id(instance_id),
+	m_zone_id(zone_id),
+	m_zone_version(zone_version),
+	m_start_time(std::chrono::system_clock::from_time_t(start_time)),
+	m_duration(duration),
+	m_type(type),
+	m_expire_time(m_start_time + m_duration)
+{
+}
+
+DynamicZone* DynamicZone::FindDynamicZoneByID(uint32_t dz_id)
+{
+	auto expedition = expedition_state.GetExpeditionByDynamicZoneID(dz_id);
+	if (expedition)
+	{
+		return &expedition->GetDynamicZone();
+	}
+	// todo: other system caches
+	return nullptr;
+}
+
+void DynamicZone::SetSecondsRemaining(uint32_t seconds_remaining)
+{
+	auto now = std::chrono::system_clock::now();
+	auto new_remaining = std::chrono::seconds(seconds_remaining);
+
+	auto current_remaining = m_expire_time - now;
+	if (current_remaining > new_remaining) // reduce only
+	{
+		LogDynamicZonesDetail("Updating dynamic zone [{}] instance [{}] seconds remaining to [{}]s",
+			GetID(), GetInstanceID(), seconds_remaining);
+
+		// preserve original start time and adjust duration instead
+		m_expire_time = now + new_remaining;
+		m_duration = std::chrono::duration_cast<std::chrono::seconds>(m_expire_time - m_start_time);
+
+		InstanceListRepository::UpdateDuration(database,
+			GetInstanceID(), static_cast<uint32_t>(m_duration.count()));
+
+		SendZonesDurationUpdate(); // update zone caches and actual instance's timer
+	}
+}
+
+void DynamicZone::SendZonesDurationUpdate()
+{
+	constexpr uint32_t packsize = sizeof(ServerDzSetDuration_Struct);
+	auto pack = std::make_unique<ServerPacket>(ServerOP_DzDurationUpdate, packsize);
+	auto packbuf = reinterpret_cast<ServerDzSetDuration_Struct*>(pack->pBuffer);
+	packbuf->dz_id = GetID();
+	packbuf->seconds = static_cast<uint32_t>(m_duration.count());
+	zoneserver_list.SendPacket(pack.get());
+}
+
+void DynamicZone::HandleZoneMessage(ServerPacket* pack)
+{
+	switch (pack->opcode)
+	{
+	case ServerOP_DzSetCompass:
+	case ServerOP_DzSetSafeReturn:
+	case ServerOP_DzSetZoneIn:
+	{
+		zoneserver_list.SendPacket(pack);
+		break;
+	}
+	case ServerOP_DzCharacterChange:
+	case ServerOP_DzRemoveAllCharacters:
+	{
+		auto buf = reinterpret_cast<ServerDzCharacter_Struct*>(pack->pBuffer);
+		ZoneServer* instance_zs = zoneserver_list.FindByInstanceID(buf->instance_id);
+		if (instance_zs)
+		{
+			instance_zs->SendPacket(pack);
+		}
+		break;
+	}
+	case ServerOP_DzSetSecondsRemaining:
+	{
+		auto buf = reinterpret_cast<ServerDzSetDuration_Struct*>(pack->pBuffer);
+		auto dz = DynamicZone::FindDynamicZoneByID(buf->dz_id);
+		if (dz)
+		{
+			dz->SetSecondsRemaining(buf->seconds);
+		}
+		break;
+	}
+	};
+}

world/dynamic_zone.h

@@ -0,0 +1,42 @@
+#ifndef WORLD_DYNAMIC_ZONE_H
+#define WORLD_DYNAMIC_ZONE_H
+
+#include "../common/eq_constants.h"
+#include <chrono>
+
+class ServerPacket;
+
+class DynamicZone
+{
+public:
+	DynamicZone() = default;
+	DynamicZone(uint32_t id, uint32_t zone_id, uint32_t instance_id, uint32_t zone_version,
+		uint32_t start_time, uint32_t duration, DynamicZoneType type);
+
+	static DynamicZone* FindDynamicZoneByID(uint32_t dz_id);
+	static void HandleZoneMessage(ServerPacket* pack);
+
+	uint32_t GetID() const { return m_id; }
+	uint16_t GetInstanceID() const { return static_cast<uint16_t>(m_instance_id); }
+	uint16_t GetZoneID() const { return static_cast<uint16_t>(m_zone_id); }
+	uint32_t GetZoneVersion() const { return m_zone_version; }
+	std::chrono::system_clock::duration GetRemainingDuration() const {
+		return m_expire_time - std::chrono::system_clock::now(); }
+
+	bool IsExpired() const { return m_expire_time < std::chrono::system_clock::now(); }
+	void SetSecondsRemaining(uint32_t seconds_remaining);
+
+private:
+	void SendZonesDurationUpdate();
+
+	uint32_t m_id = 0;
+	uint32_t m_instance_id = 0;
+	uint32_t m_zone_id = 0;
+	uint32_t m_zone_version = 0;
+	DynamicZoneType m_type{ DynamicZoneType::None };
+	std::chrono::seconds m_duration;
+	std::chrono::time_point<std::chrono::system_clock> m_start_time;
+	std::chrono::time_point<std::chrono::system_clock> m_expire_time;
+};
+
+#endif

world/expedition.cpp

@@ -30,28 +30,19 @@
 extern ClientList client_list;
 extern ZSList zoneserver_list;
 
-Expedition::Expedition(uint32_t expedition_id, uint32_t dz_id, uint32_t dz_instance_id,
-	uint32_t dz_zone_id, uint32_t start_time, uint32_t duration, uint32_t leader_id
+Expedition::Expedition(uint32_t expedition_id, const DynamicZone& dz, uint32_t leader_id
 ) :
 	m_expedition_id(expedition_id),
-	m_dz_id(dz_id),
-	m_dz_instance_id(dz_instance_id),
-	m_dz_zone_id(dz_zone_id),
-	m_start_time(std::chrono::system_clock::from_time_t(start_time)),
-	m_duration(duration),
+	m_dynamic_zone(dz),
 	m_leader_id(leader_id),
 	m_choose_leader_cooldown_timer{ static_cast<uint32_t>(RuleI(Expedition, ChooseLeaderCooldownTime)) }
 {
-	m_expire_time = m_start_time + m_duration;
 	m_warning_cooldown_timer.Enable();
 }
 
 void Expedition::AddMember(uint32_t character_id)
 {
-	auto it = std::find_if(m_member_ids.begin(), m_member_ids.end(),
-		[&](uint32_t member_id) { return member_id == character_id; });
-
-	if (it == m_member_ids.end())
+	if (!HasMember(character_id))
 	{
 		m_member_ids.emplace_back(character_id);
 	}
@@ -126,16 +117,6 @@ void Expedition::SendZonesExpeditionDeleted()
 	zoneserver_list.SendPacket(pack.get());
 }
 
-void Expedition::SendZonesDurationUpdate()
-{
-	uint32_t packsize = sizeof(ServerExpeditionUpdateDuration_Struct);
-	auto pack = std::make_unique<ServerPacket>(ServerOP_ExpeditionDzDuration, packsize);
-	auto packbuf = reinterpret_cast<ServerExpeditionUpdateDuration_Struct*>(pack->pBuffer);
-	packbuf->expedition_id = GetID();
-	packbuf->new_duration_seconds = static_cast<uint32_t>(m_duration.count());
-	zoneserver_list.SendPacket(pack.get());
-}
-
 void Expedition::SendZonesExpireWarning(uint32_t minutes_remaining)
 {
 	uint32_t pack_size = sizeof(ServerExpeditionExpireWarning_Struct);
@@ -156,41 +137,12 @@ void Expedition::SendZonesLeaderChanged()
 	zoneserver_list.SendPacket(pack.get());
 }
 
-void Expedition::UpdateDzSecondsRemaining(uint32_t seconds_remaining)
-{
-	auto now = std::chrono::system_clock::now();
-	auto update_time = std::chrono::seconds(seconds_remaining);
-
-	auto current_remaining = m_expire_time - now;
-	if (current_remaining > update_time) // reduce only
-	{
-		LogExpeditionsDetail(
-			"Updating expedition [{}] dz instance [{}] seconds remaining to [{}]s",
-			GetID(), GetInstanceID(), seconds_remaining
-		);
-
-		// preserve original start time and adjust duration instead
-		m_expire_time = now + update_time;
-		m_duration = std::chrono::duration_cast<std::chrono::seconds>(m_expire_time - m_start_time);
-
-		ExpeditionDatabase::UpdateDzDuration(GetInstanceID(), static_cast<uint32_t>(m_duration.count()));
-
-		// update zone level caches and update the actual dz instance's timer
-		SendZonesDurationUpdate();
-	}
-}
-
-std::chrono::system_clock::duration Expedition::GetRemainingDuration() const
-{
-	return m_expire_time - std::chrono::system_clock::now();
-}
-
 void Expedition::CheckExpireWarning()
 {
 	if (m_warning_cooldown_timer.Check(false))
 	{
 		using namespace std::chrono_literals;
-		auto remaining = GetRemainingDuration();
+		auto remaining = GetDynamicZone().GetRemainingDuration();
 		if ((remaining > 14min && remaining < 15min) ||
 		    (remaining > 4min && remaining < 5min) ||
 		    (remaining > 0min && remaining < 1min))

world/expedition.h

@@ -21,6 +21,7 @@
 #ifndef WORLD_EXPEDITION_H
 #define WORLD_EXPEDITION_H
 
+#include "dynamic_zone.h"
 #include "../common/timer.h"
 #include <chrono>
 #include <cstdint>
@@ -30,8 +31,7 @@ class Expedition
 {
 public:
 	Expedition() = default;
-	Expedition(uint32_t expedition_id, uint32_t dz_id, uint32_t dz_instance_id,
-		uint32_t dz_zone_id, uint32_t expire_time, uint32_t duration, uint32_t leader_id);
+	Expedition(uint32_t expedition_id, const DynamicZone& dz, uint32_t leader_id);
 
 	void AddMember(uint32_t character_id);
 	void RemoveMember(uint32_t character_id);
@@ -39,38 +39,28 @@ public:
 	void CheckExpireWarning();
 	void CheckLeader();
 	void ChooseNewLeader();
+	DynamicZone& GetDynamicZone() { return m_dynamic_zone; }
 	uint32_t GetID() const { return m_expedition_id; }
-	uint16_t GetInstanceID() const { return static_cast<uint16_t>(m_dz_instance_id); }
-	uint16_t GetZoneID() const { return static_cast<uint16_t>(m_dz_zone_id); }
 	bool HasMember(uint32_t character_id);
 	bool IsEmpty() const { return m_member_ids.empty(); }
-	bool IsExpired() const { return m_expire_time < std::chrono::system_clock::now(); }
 	bool IsPendingDelete() const { return m_pending_delete; }
 	bool IsValid() const { return m_expedition_id != 0; }
-	void SendZonesDurationUpdate();
 	void SendZonesExpeditionDeleted();
 	void SendZonesExpireWarning(uint32_t minutes_remaining);
 	bool SetNewLeader(uint32_t new_leader_id);
 	void SetPendingDelete(bool pending) { m_pending_delete = pending; }
-	void UpdateDzSecondsRemaining(uint32_t seconds_remaining);
-	std::chrono::system_clock::duration GetRemainingDuration() const;
 
 private:
 	void SendZonesLeaderChanged();
 
 	uint32_t m_expedition_id  = 0;
-	uint32_t m_dz_id          = 0;
-	uint32_t m_dz_instance_id = 0;
-	uint32_t m_dz_zone_id     = 0;
 	uint32_t m_leader_id      = 0;
 	bool m_pending_delete = false;
 	bool m_choose_leader_needed = false;
 	Timer m_choose_leader_cooldown_timer;
 	Timer m_warning_cooldown_timer;
+	DynamicZone m_dynamic_zone;
 	std::vector<uint32_t> m_member_ids;
-	std::chrono::seconds m_duration;
-	std::chrono::time_point<std::chrono::system_clock> m_start_time;
-	std::chrono::time_point<std::chrono::system_clock> m_expire_time;
 };
 
 #endif

world/expedition_database.cpp

@@ -81,6 +81,7 @@ std::vector<Expedition> ExpeditionDatabase::LoadExpeditions(uint32_t select_expe
 			expeditions.dynamic_zone_id,
 			instance_list.id,
 			instance_list.zone,
+			instance_list.version,
 			instance_list.start_time,
 			instance_list.duration,
 			expeditions.leader_id,
@@ -112,20 +113,26 @@ std::vector<Expedition> ExpeditionDatabase::LoadExpeditions(uint32_t select_expe
 
 			if (last_expedition_id != expedition_id)
 			{
-				expeditions.emplace_back(
-					static_cast<uint32_t>(strtoul(row[0], nullptr, 10)), // expedition_id
+				DynamicZone dynamic_zone{
 					static_cast<uint32_t>(strtoul(row[1], nullptr, 10)), // dz_id
-					static_cast<uint32_t>(strtoul(row[2], nullptr, 10)), // dz_instance_id
 					static_cast<uint32_t>(strtoul(row[3], nullptr, 10)), // dz_zone_id
-					static_cast<uint32_t>(strtoul(row[4], nullptr, 10)), // start_time
-					static_cast<uint32_t>(strtoul(row[5], nullptr, 10)), // duration
-					static_cast<uint32_t>(strtoul(row[6], nullptr, 10))  // leader_id
+					static_cast<uint32_t>(strtoul(row[2], nullptr, 10)), // dz_instance_id
+					static_cast<uint32_t>(strtoul(row[4], nullptr, 10)), // dz_zone_version
+					static_cast<uint32_t>(strtoul(row[5], nullptr, 10)), // start_time
+					static_cast<uint32_t>(strtoul(row[6], nullptr, 10)), // duration
+					DynamicZoneType::Expedition
+				};
+
+				expeditions.emplace_back(
+					expedition_id,
+					dynamic_zone,
+					static_cast<uint32_t>(strtoul(row[7], nullptr, 10)) // leader_id
 				);
 			}
 
 			last_expedition_id = expedition_id;
 
-			uint32_t member_id = static_cast<uint32_t>(strtoul(row[7], nullptr, 10));
+			uint32_t member_id = static_cast<uint32_t>(strtoul(row[8], nullptr, 10));
 			expeditions.back().AddMember(member_id);
 		}
 	}
@@ -167,16 +174,6 @@ void ExpeditionDatabase::DeleteExpeditions(const std::vector<uint32_t>& expediti
 	}
 }
 
-void ExpeditionDatabase::UpdateDzDuration(uint16_t instance_id, uint32_t new_duration)
-{
-	std::string query = fmt::format(
-		"UPDATE instance_list SET duration = {} WHERE id = {};",
-		new_duration, instance_id
-	);
-
-	database.QueryDatabase(query);
-}
-
 void ExpeditionDatabase::UpdateLeaderID(uint32_t expedition_id, uint32_t leader_id)
 {
 	LogExpeditionsDetail("Updating leader [{}] for expedition [{}]", leader_id, expedition_id);

world/expedition_database.h

@@ -34,7 +34,6 @@ namespace ExpeditionDatabase
 	void MoveMembersToSafeReturn(const std::vector<uint32_t>& expedition_ids);
 	void PurgeExpiredExpeditions();
 	void PurgeExpiredCharacterLockouts();
-	void UpdateDzDuration(uint16_t instance_id, uint32_t new_duration);
 	void UpdateLeaderID(uint32_t expedition_id, uint32_t leader_id);
 };
 

world/expedition_message.cpp

@@ -104,12 +104,6 @@ void ExpeditionMessage::HandleZoneMessage(ServerPacket* pack)
 		ExpeditionMessage::RequestInvite(pack);
 		break;
 	}
-	case ServerOP_ExpeditionSecondsRemaining:
-	{
-		auto buf = reinterpret_cast<ServerExpeditionUpdateDuration_Struct*>(pack->pBuffer);
-		expedition_state.SetSecondsRemaining(buf->expedition_id, buf->new_duration_seconds);
-		break;
-	}
 	}
 }
 

world/expedition_state.cpp

@@ -38,6 +38,14 @@ Expedition* ExpeditionState::GetExpedition(uint32_t expedition_id)
 	return (it != m_expeditions.end()) ? &(*it) : nullptr;
 }
 
+Expedition* ExpeditionState::GetExpeditionByDynamicZoneID(uint32_t dz_id)
+{
+	auto it = std::find_if(m_expeditions.begin(), m_expeditions.end(),
+		[&](Expedition& expedition) { return expedition.GetDynamicZone().GetID() == dz_id; });
+
+	return (it != m_expeditions.end()) ? &(*it) : nullptr;
+}
+
 void ExpeditionState::LoadActiveExpeditions()
 {
 	BenchTimer benchmark;
@@ -98,15 +106,6 @@ void ExpeditionState::RemoveAllMembers(uint32_t expedition_id)
 	}
 }
 
-void ExpeditionState::SetSecondsRemaining(uint32_t expedition_id, uint32_t seconds_remaining)
-{
-	auto expedition = GetExpedition(expedition_id);
-	if (expedition)
-	{
-		expedition->UpdateDzSecondsRemaining(seconds_remaining);
-	}
-}
-
 void ExpeditionState::Process()
 {
 	if (!m_process_throttle_timer.Check())
@@ -120,13 +119,13 @@ void ExpeditionState::Process()
 	{
 		bool is_deleted = false;
 
-		if (it->IsEmpty() || it->IsExpired())
+		if (it->IsEmpty() || it->GetDynamicZone().IsExpired())
 		{
 			// don't delete expedition until its dz instance is empty. this prevents
 			// an exploit where all members leave expedition and complete an event
 			// before being kicked from removal timer. the lockout could never be
 			// applied because the zone expedition cache was already invalidated.
-			auto dz_zoneserver = zoneserver_list.FindByInstanceID(it->GetInstanceID());
+			auto dz_zoneserver = zoneserver_list.FindByInstanceID(it->GetDynamicZone().GetInstanceID());
 			if (!dz_zoneserver || dz_zoneserver->NumPlayers() == 0)
 			{
 				LogExpeditions("Expedition [{}] expired or empty, notifying zones and deleting", it->GetID());
@@ -137,7 +136,7 @@ void ExpeditionState::Process()
 
 			if (it->IsEmpty() && !it->IsPendingDelete() && RuleB(Expedition, EmptyDzShutdownEnabled))
 			{
-				it->UpdateDzSecondsRemaining(RuleI(Expedition, EmptyDzShutdownDelaySeconds));
+				it->GetDynamicZone().SetSecondsRemaining(RuleI(Expedition, EmptyDzShutdownDelaySeconds));
 			}
 
 			it->SetPendingDelete(true);

world/expedition_state.h

@@ -35,12 +35,12 @@ class ExpeditionState
 public:
 	void AddExpedition(uint32_t expedition_id);
 	Expedition* GetExpedition(uint32_t expedition_id);
+	Expedition* GetExpeditionByDynamicZoneID(uint32_t dz_id);
 	void LoadActiveExpeditions();
 	void MemberChange(uint32_t expedition_id, uint32_t character_id, bool remove);
 	void Process();
 	void RemoveAllMembers(uint32_t expedition_id);
 	void RemoveExpedition(uint32_t expedition_id);
-	void SetSecondsRemaining(uint32_t expedition_id, uint32_t seconds_remaining);
 
 private:
 	std::vector<Expedition> m_expeditions;

world/zoneserver.cpp

@@ -36,6 +36,7 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 #include "ucs.h"
 #include "queryserv.h"
 #include "world_store.h"
+#include "dynamic_zone.h"
 #include "expedition_message.h"
 
 extern ClientList client_list;
@@ -1367,9 +1368,6 @@ void ZoneServer::HandleMessage(uint16 opcode, const EQ::Net::Packet &p) {
 	case ServerOP_ExpeditionLockState:
 	case ServerOP_ExpeditionMemberStatus:
 	case ServerOP_ExpeditionReplayOnJoin:
-	case ServerOP_ExpeditionDzCompass:
-	case ServerOP_ExpeditionDzSafeReturn:
-	case ServerOP_ExpeditionDzZoneIn:
 	case ServerOP_ExpeditionExpireWarning:
 	{
 		zoneserver_list.SendPacket(pack);
@@ -1386,20 +1384,18 @@ void ZoneServer::HandleMessage(uint16 opcode, const EQ::Net::Packet &p) {
 	case ServerOP_ExpeditionCharacterLockout:
 	case ServerOP_ExpeditionSaveInvite:
 	case ServerOP_ExpeditionRequestInvite:
-	case ServerOP_ExpeditionSecondsRemaining:
 	{
 		ExpeditionMessage::HandleZoneMessage(pack);
 		break;
 	}
 	case ServerOP_DzCharacterChange:
 	case ServerOP_DzRemoveAllCharacters:
+	case ServerOP_DzSetSecondsRemaining:
+	case ServerOP_DzSetCompass:
+	case ServerOP_DzSetSafeReturn:
+	case ServerOP_DzSetZoneIn:
 	{
-		auto buf = reinterpret_cast<ServerDzCharacter_Struct*>(pack->pBuffer);
-		ZoneServer* instance_zs = zoneserver_list.FindByInstanceID(buf->instance_id);
-		if (instance_zs)
-		{
-			instance_zs->SendPacket(pack);
-		}
+		DynamicZone::HandleZoneMessage(pack);
 		break;
 	}
 	default: