pa/eqemu-server
2
0
Fork 0
mirror of https://github.com/EQEmu/Server.git synced 2025-12-12 01:11:29 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

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

Browse Source 
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
This commit is contained in:
hg 2021-03-28 19:14:36 -04:00 committed by GitHub
parent dbb9c1d4f4
commit d9e23a0303
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
21 changed files with 350 additions and 286 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
common/eq_constants.h
View File

@ -464,4 +464,14 @@ namespace ZoneBlockedSpellTypes {
const uint8 Region = 2;
};
enum class DynamicZoneType
{
None = 0,
Expedition,
Tutorial,
Task,
Mission, // Shared Task
Quest
};
#endif /*COMMON_EQ_CONSTANTS_H*/

9
common/repositories/instance_list_repository.h
View File

@ -65,6 +65,15 @@ public:
// Custom extended repository methods here
static int UpdateDuration(Database& db, int instance_id, uint32_t new_duration)
{
auto results = db.QueryDatabase(fmt::format(
"UPDATE {} SET duration = {} WHERE {} = {};",
TableName(), new_duration, PrimaryKey(), instance_id
));
return (results.Success() ? results.RowsAffected() : 0);
}
};
#endif //EQEMU_INSTANCE_LIST_REPOSITORY_H

26
common/servertalk.h
View File

@ -151,23 +151,23 @@
#define ServerOP_ExpeditionGetOnlineMembers 0x0407
#define ServerOP_ExpeditionDzAddPlayer 0x0408
#define ServerOP_ExpeditionDzMakeLeader 0x0409
#define ServerOP_ExpeditionDzCompass 0x040a
#define ServerOP_ExpeditionDzSafeReturn 0x040b
#define ServerOP_ExpeditionDzZoneIn 0x040c
#define ServerOP_ExpeditionCharacterLockout 0x040d
#define ServerOP_ExpeditionSaveInvite 0x040e
#define ServerOP_ExpeditionRequestInvite 0x040f
#define ServerOP_ExpeditionReplayOnJoin 0x0410
#define ServerOP_ExpeditionLockState 0x0411
#define ServerOP_ExpeditionMembersRemoved 0x0412
#define ServerOP_ExpeditionDzDuration 0x0413
#define ServerOP_ExpeditionLockoutDuration 0x0414
#define ServerOP_ExpeditionSecondsRemaining 0x0415
#define ServerOP_ExpeditionExpireWarning 0x0416
#define ServerOP_ExpeditionChooseNewLeader 0x0417
#define ServerOP_DzCharacterChange 0x0450
#define ServerOP_DzRemoveAllCharacters 0x0451
#define ServerOP_DzSetSecondsRemaining 0x0452
#define ServerOP_DzDurationUpdate 0x0453
#define ServerOP_DzSetCompass 0x0454
#define ServerOP_DzSetSafeReturn 0x0455
#define ServerOP_DzSetZoneIn 0x0456
#define ServerOP_LSInfo 0x1000
#define ServerOP_LSStatus 0x1001
@ -2090,11 +2090,6 @@ struct ServerExpeditionCharacterID_Struct {
uint32_t character_id;
};
struct ServerExpeditionUpdateDuration_Struct {
uint32_t expedition_id;
uint32_t new_duration_seconds;
};
struct ServerExpeditionExpireWarning_Struct {
uint32_t expedition_id;
uint32_t minutes_remaining;
@ -2117,12 +2112,10 @@ struct ServerDzCommandMakeLeader_Struct {
};
struct ServerDzLocation_Struct {
uint32 owner_id; // system associated with the dz (expedition, shared task, etc)
uint16 dz_zone_id;
uint16 dz_instance_id;
uint32 dz_id;
uint32 sender_zone_id;
uint16 sender_instance_id;
uint32 zone_id; // compass or safereturn zone id
uint32 zone_id;
float y;
float x;
float z;
@ -2136,6 +2129,11 @@ struct ServerDzCharacter_Struct {
uint32 character_id;
};
struct ServerDzSetDuration_Struct {
uint32 dz_id;
uint32 seconds;
};
#pragma pack()
#endif

2
world/CMakeLists.txt
View File

@ -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

103
world/dynamic_zone.cpp Normal file
View File

@ -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;
}
};
}

42
world/dynamic_zone.h Normal file
View File

@ -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

56
world/expedition.cpp
View File

@ -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))

18
world/expedition.h
View File

@ -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

31
world/expedition_database.cpp
View File

@ -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);

1
world/expedition_database.h
View File

@ -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);
};

6
world/expedition_message.cpp
View File

@ -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;
}
}
}

23
world/expedition_state.cpp
View File

@ -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);

2
world/expedition_state.h
View File

@ -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;

16
world/zoneserver.cpp
View File

@ -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:

108
zone/dynamic_zone.cpp
View File

@ -20,6 +20,7 @@
#include "dynamic_zone.h"
#include "client.h"
#include "expedition.h"
#include "worldserver.h"
#include "zonedb.h"
#include "../common/eqemu_logsys.h"
@ -37,20 +38,27 @@ DynamicZone::DynamicZone(
}
DynamicZone::DynamicZone(
std::string zone_shortname, uint32_t version, uint32_t duration, DynamicZoneType type
std::string zone_name, uint32_t version, uint32_t duration, DynamicZoneType type
) :
m_version(version),
m_duration(duration),
m_type(type)
DynamicZone(ZoneID(zone_name), version, duration, type)
{
m_zone_id = ZoneID(zone_shortname.c_str());
if (!m_zone_id)
{
LogDynamicZones("Failed to get zone id for zone [{}]", zone_shortname);
LogDynamicZones("Failed to get zone id for zone [{}]", zone_name);
}
}
DynamicZone* DynamicZone::FindDynamicZoneByID(uint32_t dz_id)
{
auto expedition = Expedition::FindCachedExpeditionByDynamicZoneID(dz_id);
if (expedition)
{
return &expedition->GetDynamicZone();
}
// todo: other system caches
return nullptr;
}
std::unordered_map<uint32_t, DynamicZone> DynamicZone::LoadMultipleDzFromDatabase(
const std::vector<uint32_t>& dynamic_zone_ids)
{
@ -443,12 +451,23 @@ void DynamicZone::SetCompass(const DynamicZoneLocation& location, bool update_db
{
m_compass = location;
if (m_on_compass_change)
{
m_on_compass_change();
}
if (update_db)
{
SaveCompassToDatabase();
SendWorldSetLocation(ServerOP_DzSetCompass, location);
}
}
void DynamicZone::SetCompass(uint32_t zone_id, float x, float y, float z, bool update_db)
{
SetCompass({ zone_id, x, y, z, 0.0f }, update_db);
}
void DynamicZone::SetSafeReturn(const DynamicZoneLocation& location, bool update_db)
{
m_safereturn = location;
@ -456,9 +475,15 @@ void DynamicZone::SetSafeReturn(const DynamicZoneLocation& location, bool update
if (update_db)
{
SaveSafeReturnToDatabase();
SendWorldSetLocation(ServerOP_DzSetSafeReturn, location);
}
}
void DynamicZone::SetSafeReturn(uint32_t zone_id, float x, float y, float z, float heading, bool update_db)
{
SetSafeReturn({ zone_id, x, y, z, heading }, update_db);
}
void DynamicZone::SetZoneInLocation(const DynamicZoneLocation& location, bool update_db)
{
m_zonein = location;
@ -467,9 +492,15 @@ void DynamicZone::SetZoneInLocation(const DynamicZoneLocation& location, bool up
if (update_db)
{
SaveZoneInLocationToDatabase();
SendWorldSetLocation(ServerOP_DzSetZoneIn, location);
}
}
void DynamicZone::SetZoneInLocation(float x, float y, float z, float heading, bool update_db)
{
SetZoneInLocation({ 0, x, y, z, heading }, update_db);
}
bool DynamicZone::IsCurrentZoneDzInstance() const
{
return (zone && zone->GetInstanceID() != 0 && zone->GetInstanceID() == GetInstanceID());
@ -496,6 +527,17 @@ uint32_t DynamicZone::GetSecondsRemaining() const
return 0;
}
void DynamicZone::SetSecondsRemaining(uint32_t seconds_remaining)
{
// async
constexpr uint32_t pack_size = sizeof(ServerDzSetDuration_Struct);
auto pack = std::make_unique<ServerPacket>(ServerOP_DzSetSecondsRemaining, pack_size);
auto buf = reinterpret_cast<ServerDzSetDuration_Struct*>(pack->pBuffer);
buf->dz_id = GetID();
buf->seconds = seconds_remaining;
worldserver.SendPacket(pack.get());
}
void DynamicZone::SetUpdatedDuration(uint32_t new_duration)
{
// preserves original start time, just modifies duration and expire time
@ -511,6 +553,22 @@ void DynamicZone::SetUpdatedDuration(uint32_t new_duration)
}
}
void DynamicZone::SendWorldSetLocation(uint16_t server_opcode, const DynamicZoneLocation& location)
{
uint32_t pack_size = sizeof(ServerDzLocation_Struct);
auto pack = std::make_unique<ServerPacket>(server_opcode, pack_size);
auto buf = reinterpret_cast<ServerDzLocation_Struct*>(pack->pBuffer);
buf->dz_id = GetID();
buf->sender_zone_id = zone ? zone->GetZoneID() : 0;
buf->sender_instance_id = zone ? zone->GetInstanceID() : 0;
buf->zone_id = location.zone_id;
buf->x = location.x;
buf->y = location.y;
buf->z = location.z;
buf->heading = location.heading;
worldserver.SendPacket(pack.get());
}
void DynamicZone::HandleWorldMessage(ServerPacket* pack)
{
switch (pack->opcode)
@ -540,5 +598,41 @@ void DynamicZone::HandleWorldMessage(ServerPacket* pack)
}
break;
}
case ServerOP_DzDurationUpdate:
{
auto buf = reinterpret_cast<ServerDzSetDuration_Struct*>(pack->pBuffer);
auto dz = DynamicZone::FindDynamicZoneByID(buf->dz_id);
if (dz)
{
dz->SetUpdatedDuration(buf->seconds);
}
break;
}
case ServerOP_DzSetCompass:
case ServerOP_DzSetSafeReturn:
case ServerOP_DzSetZoneIn:
{
auto buf = reinterpret_cast<ServerDzLocation_Struct*>(pack->pBuffer);
if (zone && !zone->IsZone(buf->sender_zone_id, buf->sender_instance_id))
{
auto dz = DynamicZone::FindDynamicZoneByID(buf->dz_id);
if (dz)
{
if (pack->opcode == ServerOP_DzSetCompass)
{
dz->SetCompass(buf->zone_id, buf->x, buf->y, buf->z, false);
}
else if (pack->opcode == ServerOP_DzSetSafeReturn)
{
dz->SetSafeReturn(buf->zone_id, buf->x, buf->y, buf->z, buf->heading, false);
}
else if (pack->opcode == ServerOP_DzSetZoneIn)
{
dz->SetZoneInLocation(buf->x, buf->y, buf->z, buf->heading, false);
}
}
}
break;
}
}
}

20
zone/dynamic_zone.h
View File

@ -21,8 +21,10 @@
#ifndef DYNAMIC_ZONE_H
#define DYNAMIC_ZONE_H
#include "../common/eq_constants.h"
#include <chrono>
#include <cstdint>
#include <functional>
#include <string>
#include <unordered_map>
#include <vector>
@ -30,16 +32,6 @@
class MySQLRequestRow;
class ServerPacket;
enum class DynamicZoneType : uint8_t
{
None = 0,
Expedition,
Tutorial,
Task,
Mission, // Shared Task
Quest
};
struct DynamicZoneLocation
{
uint32_t zone_id = 0;
@ -62,6 +54,7 @@ public:
DynamicZone(uint32_t dz_id) : m_id(dz_id) {}
DynamicZone(DynamicZoneType type) : m_type(type) {}
static DynamicZone* FindDynamicZoneByID(uint32_t dz_id);
static std::unordered_map<uint32_t, DynamicZone> LoadMultipleDzFromDatabase(
const std::vector<uint32_t>& dynamic_zone_ids);
static void HandleWorldMessage(ServerPacket* pack);
@ -88,15 +81,20 @@ public:
bool IsInstanceID(uint32_t instance_id) const;
bool IsValid() const { return m_instance_id != 0; }
bool IsSameDz(uint32_t zone_id, uint32_t instance_id) const;
void RegisterOnCompassChange(const std::function<void()>& on_change) { m_on_compass_change = on_change; }
void RemoveAllCharacters(bool enable_removal_timers = true);
void RemoveCharacter(uint32_t character_id);
void SaveInstanceMembersToDatabase(const std::vector<uint32_t>& character_ids);
void SendInstanceCharacterChange(uint32_t character_id, bool removed);
void SetCompass(const DynamicZoneLocation& location, bool update_db = false);
void SetCompass(uint32_t zone_id, float x, float y, float z, bool update_db = false);
void SetLeaderName(const std::string& leader_name) { m_leader_name = leader_name; }
void SetName(const std::string& name) { m_name = name; }
void SetSafeReturn(const DynamicZoneLocation& location, bool update_db = false);
void SetSafeReturn(uint32_t zone_id, float x, float y, float z, float heading, bool update_db = false);
void SetSecondsRemaining(uint32_t seconds_remaining);
void SetZoneInLocation(const DynamicZoneLocation& location, bool update_db = false);
void SetZoneInLocation(float x, float y, float z, float heading, bool update_db = false);
void SetUpdatedDuration(uint32_t seconds);
private:
@ -105,6 +103,7 @@ private:
void SaveCompassToDatabase();
void SaveSafeReturnToDatabase();
void SaveZoneInLocationToDatabase();
void SendWorldSetLocation(uint16_t server_opcode, const DynamicZoneLocation& location);
uint32_t SaveToDatabase();
uint32_t m_id = 0;
@ -122,6 +121,7 @@ private:
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;
std::function<void()> m_on_compass_change;
};
#endif

116
zone/expedition.cpp
View File

@ -69,6 +69,7 @@ void Expedition::SetDynamicZone(DynamicZone&& dz)
dz.SetLeaderName(GetLeaderName());
m_dynamiczone = std::move(dz);
m_dynamiczone.RegisterOnCompassChange([this]() { SendCompassUpdateToZoneMembers(); });
}
Expedition* Expedition::TryCreate(
@ -1631,24 +1632,6 @@ void Expedition::SendWorldMemberStatus(uint32_t character_id, ExpeditionMemberSt
worldserver.SendPacket(pack.get());
}
void Expedition::SendWorldDzLocationUpdate(uint16_t server_opcode, const DynamicZoneLocation& location)
{
uint32_t pack_size = sizeof(ServerDzLocation_Struct);
auto pack = std::make_unique<ServerPacket>(server_opcode, pack_size);
auto buf = reinterpret_cast<ServerDzLocation_Struct*>(pack->pBuffer);
buf->owner_id = GetID();
buf->dz_zone_id = m_dynamiczone.GetZoneID();
buf->dz_instance_id = m_dynamiczone.GetInstanceID();
buf->sender_zone_id = zone ? zone->GetZoneID() : 0;
buf->sender_instance_id = zone ? zone->GetInstanceID() : 0;
buf->zone_id = location.zone_id;
buf->x = location.x;
buf->y = location.y;
buf->z = location.z;
buf->heading = location.heading;
worldserver.SendPacket(pack.get());
}
void Expedition::SendWorldMemberSwapped(
const std::string& remove_char_name, uint32_t remove_char_id, const std::string& add_char_name, uint32_t add_char_id)
{
@ -1716,16 +1699,6 @@ void Expedition::SendWorldCharacterLockout(
worldserver.SendPacket(pack.get());
}
void Expedition::SendWorldSetSecondsRemaining(uint32_t seconds_remaining)
{
uint32_t pack_size = sizeof(ServerExpeditionUpdateDuration_Struct);
auto pack = std::make_unique<ServerPacket>(ServerOP_ExpeditionSecondsRemaining, pack_size);
auto buf = reinterpret_cast<ServerExpeditionUpdateDuration_Struct*>(pack->pBuffer);
buf->expedition_id = GetID();
buf->new_duration_seconds = seconds_remaining;
worldserver.SendPacket(pack.get());
}
void Expedition::AddLockoutByCharacterID(
uint32_t character_id, const std::string& expedition_name, const std::string& event_name,
uint32_t seconds, const std::string& uuid)
@ -2007,32 +1980,6 @@ void Expedition::HandleWorldMessage(ServerPacket* pack)
}
break;
}
case ServerOP_ExpeditionDzCompass:
case ServerOP_ExpeditionDzSafeReturn:
case ServerOP_ExpeditionDzZoneIn:
{
auto buf = reinterpret_cast<ServerDzLocation_Struct*>(pack->pBuffer);
if (zone && !zone->IsZone(buf->sender_zone_id, buf->sender_instance_id))
{
auto expedition = Expedition::FindCachedExpeditionByID(buf->owner_id);
if (expedition)
{
if (pack->opcode == ServerOP_ExpeditionDzCompass)
{
expedition->SetDzCompass(buf->zone_id, buf->x, buf->y, buf->z, false);
}
else if (pack->opcode == ServerOP_ExpeditionDzSafeReturn)
{
expedition->SetDzSafeReturn(buf->zone_id, buf->x, buf->y, buf->z, buf->heading, false);
}
else if (pack->opcode == ServerOP_ExpeditionDzZoneIn)
{
expedition->SetDzZoneInLocation(buf->x, buf->y, buf->z, buf->heading, false);
}
}
}
break;
}
case ServerOP_ExpeditionCharacterLockout:
{
auto buf = reinterpret_cast<ServerExpeditionCharacterLockout_Struct*>(pack->pBuffer);
@ -2056,16 +2003,6 @@ void Expedition::HandleWorldMessage(ServerPacket* pack)
}
break;
}
case ServerOP_ExpeditionDzDuration:
{
auto buf = reinterpret_cast<ServerExpeditionUpdateDuration_Struct*>(pack->pBuffer);
auto expedition = Expedition::FindCachedExpeditionByID(buf->expedition_id);
if (expedition)
{
expedition->UpdateDzDuration(buf->new_duration_seconds);
}
break;
}
case ServerOP_ExpeditionExpireWarning:
{
auto buf = reinterpret_cast<ServerExpeditionExpireWarning_Struct*>(pack->pBuffer);
@ -2079,11 +2016,8 @@ void Expedition::HandleWorldMessage(ServerPacket* pack)
}
}
void Expedition::SetDzCompass(uint32_t zone_id, float x, float y, float z, bool update_db)
void Expedition::SendCompassUpdateToZoneMembers()
{
DynamicZoneLocation location{ zone_id, x, y, z, 0.0f };
m_dynamiczone.SetCompass(location, update_db);
for (const auto& member : m_members)
{
Client* member_client = entity_list.GetClientByCharID(member.char_id);
@ -2092,52 +2026,6 @@ void Expedition::SetDzCompass(uint32_t zone_id, float x, float y, float z, bool
member_client->SendDzCompassUpdate();
}
}
if (update_db)
{
SendWorldDzLocationUpdate(ServerOP_ExpeditionDzCompass, location);
}
}
void Expedition::SetDzCompass(const std::string& zone_name, float x, float y, float z, bool update_db)
{
auto zone_id = ZoneID(zone_name.c_str());
SetDzCompass(zone_id, x, y, z, update_db);
}
void Expedition::SetDzSafeReturn(uint32_t zone_id, float x, float y, float z, float heading, bool update_db)
{
DynamicZoneLocation location{ zone_id, x, y, z, heading };
m_dynamiczone.SetSafeReturn(location, update_db);
if (update_db)
{
SendWorldDzLocationUpdate(ServerOP_ExpeditionDzSafeReturn, location);
}
}
void Expedition::SetDzSafeReturn(const std::string& zone_name, float x, float y, float z, float heading, bool update_db)
{
auto zone_id = ZoneID(zone_name.c_str());
SetDzSafeReturn(zone_id, x, y, z, heading, update_db);
}
void Expedition::SetDzSecondsRemaining(uint32_t seconds_remaining)
{
SendWorldSetSecondsRemaining(seconds_remaining); // async
}
void Expedition::SetDzZoneInLocation(float x, float y, float z, float heading, bool update_db)
{
DynamicZoneLocation location{ 0, x, y, z, heading };
m_dynamiczone.SetZoneInLocation(location, update_db);
if (update_db)
{
SendWorldDzLocationUpdate(ServerOP_ExpeditionDzZoneIn, location);
}
}
bool Expedition::CanClientLootCorpse(Client* client, uint32_t npc_type_id, uint32_t spawn_id)

11
zone/expedition.h
View File

@ -161,13 +161,6 @@ public:
void DzQuit(Client* requester);
void DzKickPlayers(Client* requester);
void SetDzCompass(uint32_t zone_id, float x, float y, float z, bool update_db = false);
void SetDzCompass(const std::string& zone_name, float x, float y, float z, bool update_db = false);
void SetDzSafeReturn(uint32_t zone_id, float x, float y, float z, float heading, bool update_db = false);
void SetDzSafeReturn(const std::string& zone_name, float x, float y, float z, float heading, bool update_db = false);
void SetDzSecondsRemaining(uint32_t seconds_remaining);
void SetDzZoneInLocation(float x, float y, float z, float heading, bool update_db = false);
static const int32_t REPLAY_TIMER_ID;
static const int32_t EVENT_TIMER_ID;
@ -197,7 +190,7 @@ private:
void SendMembersExpireWarning(uint32_t minutes);
void SendNewMemberAddedToZoneMembers(const std::string& added_name);
void SendUpdatesToZoneMembers(bool clear = false, bool message_on_clear = true);
void SendWorldDzLocationUpdate(uint16_t server_opcode, const DynamicZoneLocation& location);
void SendCompassUpdateToZoneMembers();
void SendWorldExpeditionUpdate(uint16_t server_opcode);
void SendWorldAddPlayerInvite(const std::string& inviter_name, const std::string& swap_remove_name,
const std::string& add_name, bool pending = false);
@ -209,12 +202,10 @@ private:
void SendWorldMemberStatus(uint32_t character_id, ExpeditionMemberStatus status);
void SendWorldMemberSwapped(const std::string& remove_char_name, uint32_t remove_char_id,
const std::string& add_char_name, uint32_t add_char_id);
void SendWorldSetSecondsRemaining(uint32_t seconds_remaining);
void SendWorldSettingChanged(uint16_t server_opcode, bool setting_value);
void SetDynamicZone(DynamicZone&& dz);
void TryAddClient(Client* add_client, const std::string& inviter_name,
const std::string& swap_remove_name, Client* leader_client = nullptr);
void UpdateDzDuration(uint32_t new_duration) { m_dynamiczone.SetUpdatedDuration(new_duration); }
void UpdateMemberStatus(uint32_t update_character_id, ExpeditionMemberStatus status);
ExpeditionMember GetMemberData(uint32_t character_id);

14
zone/lua_expedition.cpp
View File

@ -168,7 +168,7 @@ bool Lua_Expedition::IsLocked() {
void Lua_Expedition::RemoveCompass() {
Lua_Safe_Call_Void();
self->SetDzCompass(0, 0, 0, 0, true);
self->GetDynamicZone().SetCompass(0, 0, 0, 0, true);
}
void Lua_Expedition::RemoveLockout(std::string event_name) {
@ -178,12 +178,12 @@ void Lua_Expedition::RemoveLockout(std::string event_name) {
void Lua_Expedition::SetCompass(uint32_t zone_id, float x, float y, float z) {
Lua_Safe_Call_Void();
self->SetDzCompass(zone_id, x, y, z, true);
self->GetDynamicZone().SetCompass(zone_id, x, y, z, true);
}
void Lua_Expedition::SetCompass(std::string zone_name, float x, float y, float z) {
Lua_Safe_Call_Void();
self->SetDzCompass(zone_name, x, y, z, true);
self->GetDynamicZone().SetCompass(ZoneID(zone_name), x, y, z, true);
}
void Lua_Expedition::SetLocked(bool lock_expedition) {
@ -218,23 +218,23 @@ void Lua_Expedition::SetReplayLockoutOnMemberJoin(bool enable) {
void Lua_Expedition::SetSafeReturn(uint32_t zone_id, float x, float y, float z, float heading) {
Lua_Safe_Call_Void();
self->SetDzSafeReturn(zone_id, x, y, z, heading, true);
self->GetDynamicZone().SetSafeReturn(zone_id, x, y, z, heading, true);
}
void Lua_Expedition::SetSafeReturn(std::string zone_name, float x, float y, float z, float heading) {
Lua_Safe_Call_Void();
self->SetDzSafeReturn(zone_name, x, y, z, heading, true);
self->GetDynamicZone().SetSafeReturn(ZoneID(zone_name), x, y, z, heading, true);
}
void Lua_Expedition::SetSecondsRemaining(uint32_t seconds_remaining)
{
Lua_Safe_Call_Void();
self->SetDzSecondsRemaining(seconds_remaining);
self->GetDynamicZone().SetSecondsRemaining(seconds_remaining);
}
void Lua_Expedition::SetZoneInLocation(float x, float y, float z, float heading) {
Lua_Safe_Call_Void();
self->SetDzZoneInLocation(x, y, z, heading, true);
self->GetDynamicZone().SetZoneInLocation(x, y, z, heading, true);
}
void Lua_Expedition::UpdateLockoutDuration(std::string event_name, uint32_t duration) {

14
zone/perl_expedition.cpp
View File

@ -407,7 +407,7 @@ XS(XS_Expedition_RemoveCompass) {
Expedition* THIS = nullptr;
VALIDATE_THIS_IS_EXPEDITION;
THIS->SetDzCompass(0, 0, 0, 0, true);
THIS->GetDynamicZone().SetCompass(0, 0, 0, 0, true);
XSRETURN_EMPTY;
}
@ -446,12 +446,12 @@ XS(XS_Expedition_SetCompass) {
if (SvTYPE(ST(1)) == SVt_PV)
{
std::string zone_name(SvPV_nolen(ST(1)));
THIS->SetDzCompass(zone_name, x, y, z, true);
THIS->GetDynamicZone().SetCompass(ZoneID(zone_name), x, y, z, true);
}
else if (SvTYPE(ST(1)) == SVt_IV)
{
uint32_t zone_id = static_cast<uint32_t>(SvUV(ST(1)));
THIS->SetDzCompass(zone_id, x, y, z, true);
THIS->GetDynamicZone().SetCompass(zone_id, x, y, z, true);
}
else
{
@ -556,12 +556,12 @@ XS(XS_Expedition_SetSafeReturn) {
if (SvTYPE(ST(1)) == SVt_PV)
{
std::string zone_name(SvPV_nolen(ST(1)));
THIS->SetDzSafeReturn(zone_name, x, y, z, heading, true);
THIS->GetDynamicZone().SetSafeReturn(ZoneID(zone_name), x, y, z, heading, true);
}
else if (SvTYPE(ST(1)) == SVt_IV)
{
uint32_t zone_id = static_cast<uint32_t>(SvUV(ST(1)));
THIS->SetDzSafeReturn(zone_id, x, y, z, heading, true);
THIS->GetDynamicZone().SetSafeReturn(zone_id, x, y, z, heading, true);
}
else
{
@ -582,7 +582,7 @@ XS(XS_Expedition_SetSecondsRemaining) {
VALIDATE_THIS_IS_EXPEDITION;
uint32_t seconds_remaining = static_cast<uint32_t>(SvUV(ST(1)));
THIS->SetDzSecondsRemaining(seconds_remaining);
THIS->GetDynamicZone().SetSecondsRemaining(seconds_remaining);
XSRETURN_EMPTY;
}
@ -602,7 +602,7 @@ XS(XS_Expedition_SetZoneInLocation) {
float z = static_cast<float>(SvNV(ST(3)));
float heading = static_cast<float>(SvNV(ST(4)));
THIS->SetDzZoneInLocation(x, y, z, heading, true);
THIS->GetDynamicZone().SetZoneInLocation(x, y, z, heading, true);
XSRETURN_EMPTY;
}

8
zone/worldserver.cpp
View File

@ -2900,10 +2900,6 @@ void WorldServer::HandleMessage(uint16 opcode, const EQ::Net::Packet &p)
case ServerOP_ExpeditionGetOnlineMembers:
case ServerOP_ExpeditionDzAddPlayer:
case ServerOP_ExpeditionDzMakeLeader:
case ServerOP_ExpeditionDzCompass:
case ServerOP_ExpeditionDzSafeReturn:
case ServerOP_ExpeditionDzZoneIn:
case ServerOP_ExpeditionDzDuration:
case ServerOP_ExpeditionCharacterLockout:
case ServerOP_ExpeditionExpireWarning:
{
@ -2912,6 +2908,10 @@ void WorldServer::HandleMessage(uint16 opcode, const EQ::Net::Packet &p)
}
case ServerOP_DzCharacterChange:
case ServerOP_DzRemoveAllCharacters:
case ServerOP_DzDurationUpdate:
case ServerOP_DzSetCompass:
case ServerOP_DzSetSafeReturn:
case ServerOP_DzSetZoneIn:
{
DynamicZone::HandleWorldMessage(pack);
break;