diff --git a/changelog.txt b/changelog.txt index 6b9d00a80..3f69bf570 100644 --- a/changelog.txt +++ b/changelog.txt @@ -1,5 +1,8 @@ EQEMu Changelog (Started on Sept 24, 2003 15:50) ------------------------------------------------------- +== 8/6/2019 == +Akkadius: Optimizations to movement updates to eliminate ghosting possibilities in larger zones + == 7/22/2019 == Uleat: Added script 'vcxproj_dependencies.py' - a script to help determine conflicting project dependencies (alpha-stage) diff --git a/zone/client.cpp b/zone/client.cpp index 57f6ba865..3f0e33d2f 100644 --- a/zone/client.cpp +++ b/zone/client.cpp @@ -136,6 +136,7 @@ Client::Client(EQStreamInterface* ieqs) forget_timer(0), autosave_timer(RuleI(Character, AutosaveIntervalS) * 1000), client_scan_npc_aggro_timer(RuleI(Aggro, ClientAggroCheckInterval) * 1000), + client_zone_wide_full_position_update_timer(5 * 60 * 1000), tribute_timer(Tribute_duration), proximity_timer(ClientProximity_interval), TaskPeriodic_Timer(RuleI(TaskSystem, PeriodicCheckTimer) * 1000), @@ -9115,3 +9116,16 @@ bool Client::GotoPlayer(std::string player_name) return false; } + +glm::vec4 &Client::GetLastPositionBeforeBulkUpdate() +{ + return last_position_before_bulk_update; +} + +/** + * @param in_last_position_before_bulk_update + */ +void Client::SetLastPositionBeforeBulkUpdate(glm::vec4 in_last_position_before_bulk_update) +{ + Client::last_position_before_bulk_update = in_last_position_before_bulk_update; +} \ No newline at end of file diff --git a/zone/client.h b/zone/client.h index 0272fb21b..2ea27b108 100644 --- a/zone/client.h +++ b/zone/client.h @@ -1309,6 +1309,9 @@ public: uint32 trapid; //ID of trap player has triggered. This is cleared when the player leaves the trap's radius, or it despawns. + void SetLastPositionBeforeBulkUpdate(glm::vec4 in_last_position_before_bulk_update); + glm::vec4 &GetLastPositionBeforeBulkUpdate(); + protected: friend class Mob; void CalcItemBonuses(StatBonuses* newbon); @@ -1517,6 +1520,7 @@ private: Timer forget_timer; // our 2 min everybody forgets you timer Timer autosave_timer; Timer client_scan_npc_aggro_timer; + Timer client_zone_wide_full_position_update_timer; Timer tribute_timer; Timer proximity_timer; @@ -1539,6 +1543,7 @@ private: Timer position_update_timer; /* Timer used when client hasn't updated within a 10 second window */ glm::vec3 m_Proximity; + glm::vec4 last_position_before_bulk_update; void BulkSendInventoryItems(); diff --git a/zone/client_packet.cpp b/zone/client_packet.cpp index f0eb00d13..688a448eb 100644 --- a/zone/client_packet.cpp +++ b/zone/client_packet.cpp @@ -60,6 +60,7 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA #include "water_map.h" #include "worldserver.h" #include "zone.h" +#include "mob_movement_manager.h" #ifdef BOTS #include "bot.h" @@ -805,6 +806,8 @@ void Client::CompleteConnect() parse->EventPlayer(EVENT_ENTER_ZONE, this, "", 0); + SetLastPositionBeforeBulkUpdate(GetPosition()); + /* This sub event is for if a player logs in for the first time since entering world. */ if (firstlogon == 1) { parse->EventPlayer(EVENT_CONNECT, this, "", 0); @@ -4466,16 +4469,16 @@ void Client::Handle_OP_ClientUpdate(const EQApplicationPacket *app) { /* Handle client aggro scanning timers NPCs */ is_client_moving = (ppu->y_pos == m_Position.y && ppu->x_pos == m_Position.x) ? false : true; - + if (is_client_moving) { Log(Logs::Detail, Logs::Normal, "ClientUpdate: Client is moving - scan timer is: %u", client_scan_npc_aggro_timer.GetDuration()); if (client_scan_npc_aggro_timer.GetDuration() > 1000) { client_scan_npc_aggro_timer.Disable(); client_scan_npc_aggro_timer.Start(500); - } - } else { + } + else { Log(Logs::Detail, Logs::Normal, "ClientUpdate: Client is NOT moving - scan timer is: %u", client_scan_npc_aggro_timer.GetDuration()); if (client_scan_npc_aggro_timer.GetDuration() < 1000) { @@ -4483,7 +4486,46 @@ void Client::Handle_OP_ClientUpdate(const EQApplicationPacket *app) { client_scan_npc_aggro_timer.Start(3000); } } - + + /** + * On a normal basis we limit mob movement updates based on distance + * This ensures we send a periodic full zone update to a client that has started moving after 5 or so minutes + * + * For very large zones we will also force a full update based on distance + * + * We ignore a small distance around us so that we don't interrupt already pathing deltas as those npcs will appear + * to full stop when they are actually still pathing + */ + + float distance_moved = DistanceNoZ(GetLastPositionBeforeBulkUpdate(), GetPosition()); + bool moved_far_enough_before_bulk_update = distance_moved >= 1200; + bool is_ready_to_update = ( + client_zone_wide_full_position_update_timer.Check() || moved_far_enough_before_bulk_update + ); + + if (is_client_moving && is_ready_to_update) { + Log(Logs::Detail, Logs::Normal, "[%s] Client Zone Wide Position Update NPCs", GetCleanName()); + + auto &mob_movement_manager = MobMovementManager::Get(); + auto &mob_list = entity_list.GetMobList(); + + for (auto &it : mob_list) { + Mob *entity = it.second; + if (!entity->IsNPC()) { + continue; + } + + float distance_from_client_to_ignore = zone->GetMaxMovementUpdateRange() - 100; + if (CalculateDistance(entity->GetX(), entity->GetY(), entity->GetZ()) <= distance_from_client_to_ignore) { + continue; + } + + mob_movement_manager.SendCommandToClients(entity, 0.0, 0.0, 0.0, 0.0, 0, ClientRangeAny, this); + } + + SetLastPositionBeforeBulkUpdate(GetPosition()); + } + float new_heading = EQ12toFloat(ppu->heading); int32 new_animation = ppu->animation; diff --git a/zone/client_process.cpp b/zone/client_process.cpp index 5c750f03a..244f36580 100644 --- a/zone/client_process.cpp +++ b/zone/client_process.cpp @@ -592,8 +592,8 @@ bool Client::Process() { // only if client is not feigned if (zone->CanDoCombat() && ret && !GetFeigned() && client_scan_npc_aggro_timer.Check()) { int npc_scan_count = 0; - for (auto it = close_mobs.begin(); it != close_mobs.end(); ++it) { - Mob *mob = it->first; + for (auto & close_mob : close_mobs) { + Mob *mob = close_mob.first; if (!mob) continue; @@ -604,6 +604,7 @@ bool Client::Process() { if (mob->CheckWillAggro(this) && !mob->CheckAggro(this)) { mob->AddToHateList(this, 25); } + npc_scan_count++; } Log(Logs::General, Logs::Aggro, "Checking Reverse Aggro (client->npc) scanned_npcs (%i)", npc_scan_count); diff --git a/zone/mob_movement_manager.cpp b/zone/mob_movement_manager.cpp index 1fcc19187..df1a38168 100644 --- a/zone/mob_movement_manager.cpp +++ b/zone/mob_movement_manager.cpp @@ -14,40 +14,41 @@ #include extern double frame_time; -extern Zone *zone; +extern Zone *zone; -class IMovementCommand -{ +class IMovementCommand { public: IMovementCommand() = default; virtual ~IMovementCommand() = default; - virtual bool Process(MobMovementManager *mgr, Mob *m) = 0; + virtual bool Process(MobMovementManager *mob_movement_manager, Mob *mob) = 0; virtual bool Started() const = 0; }; -class RotateToCommand : public IMovementCommand -{ +class RotateToCommand : public IMovementCommand { public: - RotateToCommand(double rotate_to, double dir, MobMovementMode mode) { - m_rotate_to = rotate_to; - m_rotate_to_dir = dir; - m_rotate_to_mode = mode; - m_started = false; + RotateToCommand(double rotate_to, double dir, MobMovementMode mob_movement_mode) + { + m_rotate_to = rotate_to; + m_rotate_to_dir = dir; + m_rotate_to_mode = mob_movement_mode; + m_started = false; } - virtual ~RotateToCommand() { + virtual ~RotateToCommand() + { } - virtual bool Process(MobMovementManager *mgr, Mob *m) { - if (!m->IsAIControlled()) { + virtual bool Process(MobMovementManager *mob_movement_manager, Mob *mob) + { + if (!mob->IsAIControlled()) { return true; } - auto rotate_to_speed = m_rotate_to_mode == MovementRunning ? 200.0 : 16.0; //todo: get this from mob + auto rotate_to_speed = m_rotate_to_mode == MovementRunning ? 200.0 : 16.0; //todo: get this from mob - auto from = FixHeading(m->GetHeading()); - auto to = FixHeading(m_rotate_to); + auto from = FixHeading(mob->GetHeading()); + auto to = FixHeading(m_rotate_to); auto diff = to - from; while (diff < -256.0) { @@ -62,265 +63,282 @@ public: if (!m_started) { m_started = true; - m->SetMoving(true); - + mob->SetMoving(true); + if (dist > 15.0f && rotate_to_speed > 0.0 && rotate_to_speed <= 25.0) { //send basic rotation - mgr->SendCommandToClients(m, 0.0, 0.0, 0.0, m_rotate_to_dir * rotate_to_speed, 0, ClientRangeClose); + mob_movement_manager->SendCommandToClients( + mob, + 0.0, + 0.0, + 0.0, + m_rotate_to_dir * rotate_to_speed, + 0, + ClientRangeClose + ); } } - + auto td = rotate_to_speed * 19.0 * frame_time; - + if (td >= dist) { - m->SetHeading(to); - m->SetMoving(false); - mgr->SendCommandToClients(m, 0.0, 0.0, 0.0, 0.0, 0, ClientRangeCloseMedium); + mob->SetHeading(to); + mob->SetMoving(false); + mob_movement_manager->SendCommandToClients(mob, 0.0, 0.0, 0.0, 0.0, 0, ClientRangeCloseMedium); return true; } - + from += td * m_rotate_to_dir; - m->SetHeading(FixHeading(from)); + mob->SetHeading(FixHeading(from)); return false; } - virtual bool Started() const { + virtual bool Started() const + { return m_started; } private: - double m_rotate_to; - double m_rotate_to_dir; + double m_rotate_to; + double m_rotate_to_dir; MobMovementMode m_rotate_to_mode; - bool m_started; + bool m_started; }; -class MoveToCommand : public IMovementCommand -{ +class MoveToCommand : public IMovementCommand { public: - MoveToCommand(float x, float y, float z, MobMovementMode mode) { + MoveToCommand(float x, float y, float z, MobMovementMode mob_movement_mode) + { m_distance_moved_since_correction = 0.0; - m_move_to_x = x; - m_move_to_y = y; - m_move_to_z = z; - m_move_to_mode = mode; - m_last_sent_time = 0.0; - m_last_sent_speed = 0; - m_started = false; - m_total_h_dist = 0.0; - m_total_v_dist = 0.0; + m_move_to_x = x; + m_move_to_y = y; + m_move_to_z = z; + m_move_to_mode = mob_movement_mode; + m_last_sent_time = 0.0; + m_last_sent_speed = 0; + m_started = false; + m_total_h_dist = 0.0; + m_total_v_dist = 0.0; } - virtual ~MoveToCommand() { + virtual ~MoveToCommand() + { } - virtual bool Process(MobMovementManager *mgr, Mob *m) { - if (!m->IsAIControlled()) { + /** + * @param mob_movement_manager + * @param mob + * @return + */ + virtual bool Process(MobMovementManager *mob_movement_manager, Mob *mob) + { + if (!mob->IsAIControlled()) { return true; } //Send a movement packet when you start moving - double current_time = static_cast(Timer::GetCurrentTime()) / 1000.0; - int current_speed = 0; + double current_time = static_cast(Timer::GetCurrentTime()) / 1000.0; + int current_speed = 0; if (m_move_to_mode == MovementRunning) { - if (m->IsFeared()) { - current_speed = m->GetFearSpeed(); + if (mob->IsFeared()) { + current_speed = mob->GetFearSpeed(); } else { - current_speed = m->GetRunspeed(); + current_speed = mob->GetRunspeed(); } } else { - current_speed = m->GetWalkspeed(); + current_speed = mob->GetWalkspeed(); } if (!m_started) { m_started = true; //rotate to the point - m->SetMoving(true); - m->SetHeading(m->CalculateHeadingToTarget(m_move_to_x, m_move_to_y)); + mob->SetMoving(true); + mob->SetHeading(mob->CalculateHeadingToTarget(m_move_to_x, m_move_to_y)); m_last_sent_speed = current_speed; - m_last_sent_time = current_time; - m_total_h_dist = DistanceNoZ(m->GetPosition(), glm::vec4(m_move_to_x, m_move_to_y, 0.0f, 0.0f)); - m_total_v_dist = m_move_to_z - m->GetZ(); - mgr->SendCommandToClients(m, 0.0, 0.0, 0.0, 0.0, current_speed, ClientRangeCloseMedium); + m_last_sent_time = current_time; + m_total_h_dist = DistanceNoZ(mob->GetPosition(), glm::vec4(m_move_to_x, m_move_to_y, 0.0f, 0.0f)); + m_total_v_dist = m_move_to_z - mob->GetZ(); + mob_movement_manager->SendCommandToClients(mob, 0.0, 0.0, 0.0, 0.0, current_speed, ClientRangeCloseMedium); } //When speed changes if (current_speed != m_last_sent_speed) { if (RuleB(Map, FixZWhenPathing)) { - m->FixZ(); + mob->FixZ(); } m_distance_moved_since_correction = 0.0; m_last_sent_speed = current_speed; - m_last_sent_time = current_time; - mgr->SendCommandToClients(m, 0.0, 0.0, 0.0, 0.0, current_speed, ClientRangeCloseMedium); + m_last_sent_time = current_time; + mob_movement_manager->SendCommandToClients(mob, 0.0, 0.0, 0.0, 0.0, current_speed, ClientRangeCloseMedium); } //If x seconds have passed without sending an update. if (current_time - m_last_sent_time >= 5.0) { if (RuleB(Map, FixZWhenPathing)) { - m->FixZ(); + mob->FixZ(); } m_distance_moved_since_correction = 0.0; m_last_sent_speed = current_speed; - m_last_sent_time = current_time; - mgr->SendCommandToClients(m, 0.0, 0.0, 0.0, 0.0, current_speed, ClientRangeCloseMedium); + m_last_sent_time = current_time; + mob_movement_manager->SendCommandToClients(mob, 0.0, 0.0, 0.0, 0.0, current_speed, ClientRangeCloseMedium); } - auto &p = m->GetPosition(); + auto &p = mob->GetPosition(); glm::vec2 tar(m_move_to_x, m_move_to_y); glm::vec2 pos(p.x, p.y); - double len = glm::distance(pos, tar); + double len = glm::distance(pos, tar); if (len == 0) { return true; } - m->SetMoved(true); + mob->SetMoved(true); - glm::vec2 dir = tar - pos; - glm::vec2 ndir = glm::normalize(dir); - double distance_moved = frame_time * current_speed * 0.4f * 1.45f; + glm::vec2 dir = tar - pos; + glm::vec2 ndir = glm::normalize(dir); + double distance_moved = frame_time * current_speed * 0.4f * 1.45f; - if (distance_moved > len) { - if (m->IsNPC()) { - entity_list.ProcessMove(m->CastToNPC(), m_move_to_x, m_move_to_y, m_move_to_z); + if (distance_moved > len) { + if (mob->IsNPC()) { + entity_list.ProcessMove(mob->CastToNPC(), m_move_to_x, m_move_to_y, m_move_to_z); } - m->SetPosition(m_move_to_x, m_move_to_y, m_move_to_z); - + mob->SetPosition(m_move_to_x, m_move_to_y, m_move_to_z); + if (RuleB(Map, FixZWhenPathing)) { - m->FixZ(); + mob->FixZ(); } return true; } else { glm::vec2 npos = pos + (ndir * static_cast(distance_moved)); - + len -= distance_moved; double total_distance_traveled = m_total_h_dist - len; - double start_z = m_move_to_z - m_total_v_dist; - double z_at_pos = start_z + (m_total_v_dist * (total_distance_traveled / m_total_h_dist)); + double start_z = m_move_to_z - m_total_v_dist; + double z_at_pos = start_z + (m_total_v_dist * (total_distance_traveled / m_total_h_dist)); - if (m->IsNPC()) { - entity_list.ProcessMove(m->CastToNPC(), npos.x, npos.y, z_at_pos); + if (mob->IsNPC()) { + entity_list.ProcessMove(mob->CastToNPC(), npos.x, npos.y, z_at_pos); } - m->SetPosition(npos.x, npos.y, z_at_pos); + mob->SetPosition(npos.x, npos.y, z_at_pos); if (RuleB(Map, FixZWhenPathing)) { m_distance_moved_since_correction += distance_moved; if (m_distance_moved_since_correction > RuleR(Map, DistanceCanTravelBeforeAdjustment)) { m_distance_moved_since_correction = 0.0; - m->FixZ(); + mob->FixZ(); } } } - + return false; } - virtual bool Started() const { + virtual bool Started() const + { return m_started; } protected: - double m_distance_moved_since_correction; - double m_move_to_x; - double m_move_to_y; - double m_move_to_z; + double m_distance_moved_since_correction; + double m_move_to_x; + double m_move_to_y; + double m_move_to_z; MobMovementMode m_move_to_mode; - bool m_started; + bool m_started; double m_last_sent_time; - int m_last_sent_speed; + int m_last_sent_speed; double m_total_h_dist; double m_total_v_dist; }; -class SwimToCommand : public MoveToCommand -{ +class SwimToCommand : public MoveToCommand { public: - SwimToCommand(float x, float y, float z, MobMovementMode mode) : MoveToCommand(x, y, z, mode) { + SwimToCommand(float x, float y, float z, MobMovementMode mob_movement_mode) : MoveToCommand(x, y, z, mob_movement_mode) + { } - virtual bool Process(MobMovementManager *mgr, Mob *m) + virtual bool Process(MobMovementManager *mob_movement_manager, Mob *mob) { - if (!m->IsAIControlled()) { + if (!mob->IsAIControlled()) { return true; } - //Send a movement packet when you start moving - double current_time = static_cast(Timer::GetCurrentTime()) / 1000.0; - int current_speed = 0; + //Send a movement packet when you start moving + double current_time = static_cast(Timer::GetCurrentTime()) / 1000.0; + int current_speed = 0; if (m_move_to_mode == MovementRunning) { - if (m->IsFeared()) { - current_speed = m->GetFearSpeed(); + if (mob->IsFeared()) { + current_speed = mob->GetFearSpeed(); } else { - current_speed = m->GetRunspeed(); + current_speed = mob->GetRunspeed(); } } else { - current_speed = m->GetWalkspeed(); + current_speed = mob->GetWalkspeed(); } if (!m_started) { m_started = true; //rotate to the point - m->SetMoving(true); - m->SetHeading(m->CalculateHeadingToTarget(m_move_to_x, m_move_to_y)); + mob->SetMoving(true); + mob->SetHeading(mob->CalculateHeadingToTarget(m_move_to_x, m_move_to_y)); m_last_sent_speed = current_speed; - m_last_sent_time = current_time; - m_total_h_dist = DistanceNoZ(m->GetPosition(), glm::vec4(m_move_to_x, m_move_to_y, 0.0f, 0.0f)); - m_total_v_dist = m_move_to_z - m->GetZ(); - mgr->SendCommandToClients(m, 0.0, 0.0, 0.0, 0.0, current_speed, ClientRangeCloseMedium); + m_last_sent_time = current_time; + m_total_h_dist = DistanceNoZ(mob->GetPosition(), glm::vec4(m_move_to_x, m_move_to_y, 0.0f, 0.0f)); + m_total_v_dist = m_move_to_z - mob->GetZ(); + mob_movement_manager->SendCommandToClients(mob, 0.0, 0.0, 0.0, 0.0, current_speed, ClientRangeCloseMedium); } //When speed changes if (current_speed != m_last_sent_speed) { m_last_sent_speed = current_speed; - m_last_sent_time = current_time; - mgr->SendCommandToClients(m, 0.0, 0.0, 0.0, 0.0, current_speed, ClientRangeCloseMedium); + m_last_sent_time = current_time; + mob_movement_manager->SendCommandToClients(mob, 0.0, 0.0, 0.0, 0.0, current_speed, ClientRangeCloseMedium); } //If x seconds have passed without sending an update. if (current_time - m_last_sent_time >= 1.5) { m_last_sent_speed = current_speed; - m_last_sent_time = current_time; - mgr->SendCommandToClients(m, 0.0, 0.0, 0.0, 0.0, current_speed, ClientRangeCloseMedium); + m_last_sent_time = current_time; + mob_movement_manager->SendCommandToClients(mob, 0.0, 0.0, 0.0, 0.0, current_speed, ClientRangeCloseMedium); } - auto &p = m->GetPosition(); + auto &p = mob->GetPosition(); glm::vec2 tar(m_move_to_x, m_move_to_y); glm::vec2 pos(p.x, p.y); - double len = glm::distance(pos, tar); + double len = glm::distance(pos, tar); if (len == 0) { return true; } - m->SetMoved(true); + mob->SetMoved(true); - glm::vec2 dir = tar - pos; - glm::vec2 ndir = glm::normalize(dir); - double distance_moved = frame_time * current_speed * 0.4f * 1.45f; + glm::vec2 dir = tar - pos; + glm::vec2 ndir = glm::normalize(dir); + double distance_moved = frame_time * current_speed * 0.4f * 1.45f; if (distance_moved > len) { - if (m->IsNPC()) { - entity_list.ProcessMove(m->CastToNPC(), m_move_to_x, m_move_to_y, m_move_to_z); + if (mob->IsNPC()) { + entity_list.ProcessMove(mob->CastToNPC(), m_move_to_x, m_move_to_y, m_move_to_z); } - m->SetPosition(m_move_to_x, m_move_to_y, m_move_to_z); + mob->SetPosition(m_move_to_x, m_move_to_y, m_move_to_z); return true; } else { @@ -328,51 +346,54 @@ public: len -= distance_moved; double total_distance_traveled = m_total_h_dist - len; - double start_z = m_move_to_z - m_total_v_dist; - double z_at_pos = start_z + (m_total_v_dist * (total_distance_traveled / m_total_h_dist)); + double start_z = m_move_to_z - m_total_v_dist; + double z_at_pos = start_z + (m_total_v_dist * (total_distance_traveled / m_total_h_dist)); - if (m->IsNPC()) { - entity_list.ProcessMove(m->CastToNPC(), npos.x, npos.y, z_at_pos); + if (mob->IsNPC()) { + entity_list.ProcessMove(mob->CastToNPC(), npos.x, npos.y, z_at_pos); } - m->SetPosition(npos.x, npos.y, z_at_pos); + mob->SetPosition(npos.x, npos.y, z_at_pos); } return false; } }; -class TeleportToCommand : public IMovementCommand -{ +class TeleportToCommand : public IMovementCommand { public: - TeleportToCommand(float x, float y, float z, float heading) { - m_teleport_to_x = x; - m_teleport_to_y = y; - m_teleport_to_z = z; + TeleportToCommand(float x, float y, float z, float heading) + { + m_teleport_to_x = x; + m_teleport_to_y = y; + m_teleport_to_z = z; m_teleport_to_heading = heading; } - virtual ~TeleportToCommand() { + virtual ~TeleportToCommand() + { } - virtual bool Process(MobMovementManager *mgr, Mob *m) { - if (!m->IsAIControlled()) { + virtual bool Process(MobMovementManager *mob_movement_manager, Mob *mob) + { + if (!mob->IsAIControlled()) { return true; } - if (m->IsNPC()) { - entity_list.ProcessMove(m->CastToNPC(), m_teleport_to_x, m_teleport_to_y, m_teleport_to_z); + if (mob->IsNPC()) { + entity_list.ProcessMove(mob->CastToNPC(), m_teleport_to_x, m_teleport_to_y, m_teleport_to_z); } - m->SetPosition(m_teleport_to_x, m_teleport_to_y, m_teleport_to_z); - m->SetHeading(mgr->FixHeading(m_teleport_to_heading)); - mgr->SendCommandToClients(m, 0.0, 0.0, 0.0, 0.0, 0, ClientRangeAny); + mob->SetPosition(m_teleport_to_x, m_teleport_to_y, m_teleport_to_z); + mob->SetHeading(mob_movement_manager->FixHeading(m_teleport_to_heading)); + mob_movement_manager->SendCommandToClients(mob, 0.0, 0.0, 0.0, 0.0, 0, ClientRangeAny); return true; } - virtual bool Started() const { + virtual bool Started() const + { return false; } @@ -384,93 +405,99 @@ private: double m_teleport_to_heading; }; -class StopMovingCommand : public IMovementCommand -{ +class StopMovingCommand : public IMovementCommand { public: - StopMovingCommand() { + StopMovingCommand() + { } - virtual ~StopMovingCommand() { + virtual ~StopMovingCommand() + { } - virtual bool Process(MobMovementManager *mgr, Mob *m) { - if (!m->IsAIControlled()) { + virtual bool Process(MobMovementManager *mob_movement_manager, Mob *mob) + { + if (!mob->IsAIControlled()) { return true; } - if (m->IsMoving()) { - m->SetMoving(false); + if (mob->IsMoving()) { + mob->SetMoving(false); if (RuleB(Map, FixZWhenPathing)) { - m->FixZ(); + mob->FixZ(); } - mgr->SendCommandToClients(m, 0.0, 0.0, 0.0, 0.0, 0, ClientRangeCloseMedium); + mob_movement_manager->SendCommandToClients(mob, 0.0, 0.0, 0.0, 0.0, 0, ClientRangeCloseMedium); } return true; } - virtual bool Started() const { + virtual bool Started() const + { return false; } }; -class EvadeCombatCommand : public IMovementCommand -{ +class EvadeCombatCommand : public IMovementCommand { public: - EvadeCombatCommand() { + EvadeCombatCommand() + { } - virtual ~EvadeCombatCommand() { + virtual ~EvadeCombatCommand() + { } - virtual bool Process(MobMovementManager *mgr, Mob *m) { - if (!m->IsAIControlled()) { + virtual bool Process(MobMovementManager *mob_movement_manager, Mob *mob) + { + if (!mob->IsAIControlled()) { return true; } - if (m->IsMoving()) { - m->SetMoving(false); - mgr->SendCommandToClients(m, 0.0, 0.0, 0.0, 0.0, 0, ClientRangeCloseMedium); + if (mob->IsMoving()) { + mob->SetMoving(false); + mob_movement_manager->SendCommandToClients(mob, 0.0, 0.0, 0.0, 0.0, 0, ClientRangeCloseMedium); } - m->BuffFadeAll(); - m->WipeHateList(); - m->Heal(); + mob->BuffFadeAll(); + mob->WipeHateList(); + mob->Heal(); return true; } - virtual bool Started() const { + virtual bool Started() const + { return false; } }; -struct MovementStats -{ - MovementStats() { - LastResetTime = static_cast(Timer::GetCurrentTime()) / 1000.0; - TotalSent = 0ULL; +struct MovementStats { + MovementStats() + { + LastResetTime = static_cast(Timer::GetCurrentTime()) / 1000.0; + TotalSent = 0ULL; TotalSentMovement = 0ULL; TotalSentPosition = 0ULL; - TotalSentHeading = 0ULL; + TotalSentHeading = 0ULL; } - double LastResetTime; + double LastResetTime; uint64_t TotalSent; uint64_t TotalSentMovement; uint64_t TotalSentPosition; uint64_t TotalSentHeading; }; -struct NavigateTo -{ - NavigateTo() { - navigate_to_x = 0.0; - navigate_to_y = 0.0; - navigate_to_z = 0.0; +struct NavigateTo { + NavigateTo() + { + navigate_to_x = 0.0; + navigate_to_y = 0.0; + navigate_to_z = 0.0; navigate_to_heading = 0.0; - last_set_time = 0.0; + last_set_time = 0.0; } double navigate_to_x; @@ -480,13 +507,13 @@ struct NavigateTo double last_set_time; }; -struct MobMovementEntry -{ +struct MobMovementEntry { std::deque> Commands; - NavigateTo NavTo; + NavigateTo NavTo; }; -void AdjustRoute(std::list &nodes, Mob *who) { +void AdjustRoute(std::list &nodes, Mob *who) +{ if (!zone->HasMap() || !zone->HasWaterMap()) { return; } @@ -494,7 +521,7 @@ void AdjustRoute(std::list &nodes, Mob *who) { auto offset = who->GetZOffset(); for (auto &node : nodes) { - if(!zone->watermap->InLiquid(node.pos)) { + if (!zone->watermap->InLiquid(node.pos)) { auto best_z = zone->zonemap->FindBestZ(node.pos, nullptr); if (best_z != BEST_Z_INVALID) { node.pos.z = best_z + offset; @@ -503,11 +530,10 @@ void AdjustRoute(std::list &nodes, Mob *who) { } } -struct MobMovementManager::Implementation -{ - std::map Entries; - std::vector Clients; - MovementStats Stats; +struct MobMovementManager::Implementation { + std::map Entries; + std::vector Clients; + MovementStats Stats; }; MobMovementManager::MobMovementManager() @@ -522,12 +548,12 @@ MobMovementManager::~MobMovementManager() void MobMovementManager::Process() { for (auto &iter : _impl->Entries) { - auto &ent = iter.second; + auto &ent = iter.second; auto &commands = ent.Commands; while (true != commands.empty()) { auto &cmd = commands.front(); - auto r = cmd->Process(this, iter.first); + auto r = cmd->Process(this, iter.first); if (true != r) { break; @@ -538,35 +564,52 @@ void MobMovementManager::Process() } } -void MobMovementManager::AddMob(Mob *m) +/** + * @param mob + */ +void MobMovementManager::AddMob(Mob *mob) { - _impl->Entries.insert(std::make_pair(m, MobMovementEntry())); + _impl->Entries.insert(std::make_pair(mob, MobMovementEntry())); } -void MobMovementManager::RemoveMob(Mob *m) +/** + * @param mob + */ +void MobMovementManager::RemoveMob(Mob *mob) { - _impl->Entries.erase(m); + _impl->Entries.erase(mob); } -void MobMovementManager::AddClient(Client *c) +/** + * @param client + */ +void MobMovementManager::AddClient(Client *client) { - _impl->Clients.push_back(c); + _impl->Clients.push_back(client); } -void MobMovementManager::RemoveClient(Client *c) +/** + * @param client + */ +void MobMovementManager::RemoveClient(Client *client) { auto iter = _impl->Clients.begin(); while (iter != _impl->Clients.end()) { - if (c == *iter) { + if (client == *iter) { _impl->Clients.erase(iter); return; } - + ++iter; } } -void MobMovementManager::RotateTo(Mob *who, float to, MobMovementMode mode) +/** + * @param who + * @param to + * @param mob_movement_mode + */ +void MobMovementManager::RotateTo(Mob *who, float to, MobMovementMode mob_movement_mode) { auto iter = _impl->Entries.find(who); auto &ent = (*iter); @@ -574,20 +617,34 @@ void MobMovementManager::RotateTo(Mob *who, float to, MobMovementMode mode) if (true != ent.second.Commands.empty()) { return; } - - PushRotateTo(ent.second, who, to, mode); + + PushRotateTo(ent.second, who, to, mob_movement_mode); } +/** + * @param who + * @param x + * @param y + * @param z + * @param heading + */ void MobMovementManager::Teleport(Mob *who, float x, float y, float z, float heading) { auto iter = _impl->Entries.find(who); auto &ent = (*iter); - + ent.second.Commands.clear(); PushTeleportTo(ent.second, x, y, z, heading); } +/** + * @param who + * @param x + * @param y + * @param z + * @param mode + */ void MobMovementManager::NavigateTo(Mob *who, float x, float y, float z, MobMovementMode mode) { if (IsPositionEqualWithinCertainZ(glm::vec3(x, y, z), glm::vec3(who->GetX(), who->GetY(), who->GetZ()), 6.0f)) { @@ -601,8 +658,13 @@ void MobMovementManager::NavigateTo(Mob *who, float x, float y, float z, MobMove double current_time = static_cast(Timer::GetCurrentTime()) / 1000.0; if ((current_time - nav.last_set_time) > 0.5) { //Can potentially recalc - - auto within = IsPositionWithinSimpleCylinder(glm::vec3(x, y, z), glm::vec3(nav.navigate_to_x, nav.navigate_to_y, nav.navigate_to_z), 1.5f, 6.0f); + + auto within = IsPositionWithinSimpleCylinder( + glm::vec3(x, y, z), + glm::vec3(nav.navigate_to_x, nav.navigate_to_y, nav.navigate_to_z), + 1.5f, + 6.0f + ); auto heading_match = IsHeadingEqual(0.0, nav.navigate_to_heading); if (false == within || false == heading_match || ent.second.Commands.size() == 0) { @@ -610,23 +672,27 @@ void MobMovementManager::NavigateTo(Mob *who, float x, float y, float z, MobMove //Path is no longer valid, calculate a new path UpdatePath(who, x, y, z, mode); - nav.navigate_to_x = x; - nav.navigate_to_y = y; - nav.navigate_to_z = z; + nav.navigate_to_x = x; + nav.navigate_to_y = y; + nav.navigate_to_z = z; nav.navigate_to_heading = 0.0; - nav.last_set_time = current_time; + nav.last_set_time = current_time; } } } -void MobMovementManager::StopNavigation(Mob *who) { +/** + * @param who + */ +void MobMovementManager::StopNavigation(Mob *who) +{ auto iter = _impl->Entries.find(who); auto &ent = (*iter); auto &nav = ent.second.NavTo; - nav.navigate_to_x = 0.0; - nav.navigate_to_y = 0.0; - nav.navigate_to_z = 0.0; + nav.navigate_to_x = 0.0; + nav.navigate_to_y = 0.0; + nav.navigate_to_z = 0.0; nav.navigate_to_heading = 0.0; if (true == ent.second.Commands.empty()) { @@ -643,24 +709,48 @@ void MobMovementManager::StopNavigation(Mob *who) { PushStopMoving(ent.second); } -void MobMovementManager::SendCommandToClients(Mob *m, float dx, float dy, float dz, float dh, int anim, ClientRange range) +/** + * @param mob + * @param delta_x + * @param delta_y + * @param delta_z + * @param delta_heading + * @param anim + * @param range + * @param single_client + */ +void MobMovementManager::SendCommandToClients( + Mob *mob, + float delta_x, + float delta_y, + float delta_z, + float delta_heading, + int anim, + ClientRange range, + Client* single_client +) { if (range == ClientRangeNone) { return; } EQApplicationPacket outapp(OP_ClientUpdate, sizeof(PlayerPositionUpdateServer_Struct)); - PlayerPositionUpdateServer_Struct *spu = (PlayerPositionUpdateServer_Struct*)outapp.pBuffer; - FillCommandStruct(spu, m, dx, dy, dz, dh, anim); + auto *spu = (PlayerPositionUpdateServer_Struct *) outapp.pBuffer; + + FillCommandStruct(spu, mob, delta_x, delta_y, delta_z, delta_heading, anim); if (range == ClientRangeAny) { for (auto &c : _impl->Clients) { + if (single_client && c != single_client) { + continue; + } + _impl->Stats.TotalSent++; if (anim != 0) { _impl->Stats.TotalSentMovement++; } - else if (dh != 0) { + else if (delta_heading != 0) { _impl->Stats.TotalSentHeading++; } else { @@ -672,26 +762,30 @@ void MobMovementManager::SendCommandToClients(Mob *m, float dx, float dy, float } else { float short_range = RuleR(Pathing, ShortMovementUpdateRange); - float long_range = zone->GetMaxMovementUpdateRange(); + float long_range = zone->GetMaxMovementUpdateRange(); for (auto &c : _impl->Clients) { - float dist = c->CalculateDistance(m->GetX(), m->GetY(), m->GetZ()); + if (single_client && c != single_client) { + continue; + } + + float distance = c->CalculateDistance(mob->GetX(), mob->GetY(), mob->GetZ()); bool match = false; if (range & ClientRangeClose) { - if (dist < short_range) { + if (distance < short_range) { match = true; } } if (!match && range & ClientRangeMedium) { - if (dist >= short_range && dist < long_range) { + if (distance >= short_range && distance < long_range) { match = true; } } if (!match && range & ClientRangeLong) { - if (dist >= long_range) { + if (distance >= long_range) { match = true; } } @@ -702,7 +796,7 @@ void MobMovementManager::SendCommandToClients(Mob *m, float dx, float dy, float if (anim != 0) { _impl->Stats.TotalSentMovement++; } - else if (dh != 0) { + else if (delta_heading != 0) { _impl->Stats.TotalSentHeading++; } else { @@ -715,6 +809,10 @@ void MobMovementManager::SendCommandToClients(Mob *m, float dx, float dy, float } } +/** + * @param in + * @return + */ float MobMovementManager::FixHeading(float in) { auto h = in; @@ -729,83 +827,139 @@ float MobMovementManager::FixHeading(float in) return h; } -void MobMovementManager::DumpStats(Client *to) +/** + * @param client + */ +void MobMovementManager::DumpStats(Client *client) { auto current_time = static_cast(Timer::GetCurrentTime()) / 1000.0; - auto total_time = current_time - _impl->Stats.LastResetTime; + auto total_time = current_time - _impl->Stats.LastResetTime; - to->Message(MT_System, "Dumping Movement Stats:"); - to->Message(MT_System, "Total Sent: %u (%.2f / sec)", _impl->Stats.TotalSent, static_cast(_impl->Stats.TotalSent) / total_time); - to->Message(MT_System, "Total Heading: %u (%.2f / sec)", _impl->Stats.TotalSentHeading, static_cast(_impl->Stats.TotalSentHeading) / total_time); - to->Message(MT_System, "Total Movement: %u (%.2f / sec)", _impl->Stats.TotalSentMovement, static_cast(_impl->Stats.TotalSentMovement) / total_time); - to->Message(MT_System, "Total Position: %u (%.2f / sec)", _impl->Stats.TotalSentPosition, static_cast(_impl->Stats.TotalSentPosition) / total_time); + client->Message(MT_System, "Dumping Movement Stats:"); + client->Message( + MT_System, + "Total Sent: %u (%.2f / sec)", + _impl->Stats.TotalSent, + static_cast(_impl->Stats.TotalSent) / total_time + ); + client->Message( + MT_System, + "Total Heading: %u (%.2f / sec)", + _impl->Stats.TotalSentHeading, + static_cast(_impl->Stats.TotalSentHeading) / total_time + ); + client->Message( + MT_System, + "Total Movement: %u (%.2f / sec)", + _impl->Stats.TotalSentMovement, + static_cast(_impl->Stats.TotalSentMovement) / total_time + ); + client->Message( + MT_System, + "Total Position: %u (%.2f / sec)", + _impl->Stats.TotalSentPosition, + static_cast(_impl->Stats.TotalSentPosition) / total_time + ); } void MobMovementManager::ClearStats() { - _impl->Stats.LastResetTime = static_cast(Timer::GetCurrentTime()) / 1000.0; - _impl->Stats.TotalSent = 0; - _impl->Stats.TotalSentHeading = 0; + _impl->Stats.LastResetTime = static_cast(Timer::GetCurrentTime()) / 1000.0; + _impl->Stats.TotalSent = 0; + _impl->Stats.TotalSentHeading = 0; _impl->Stats.TotalSentMovement = 0; _impl->Stats.TotalSentPosition = 0; } -void MobMovementManager::FillCommandStruct(PlayerPositionUpdateServer_Struct *spu, Mob *m, float dx, float dy, float dz, float dh, int anim) +/** + * @param position_update + * @param mob + * @param delta_x + * @param delta_y + * @param delta_z + * @param delta_heading + * @param anim + */ +void MobMovementManager::FillCommandStruct( + PlayerPositionUpdateServer_Struct *position_update, + Mob *mob, + float delta_x, + float delta_y, + float delta_z, + float delta_heading, + int anim +) { - memset(spu, 0x00, sizeof(PlayerPositionUpdateServer_Struct)); - spu->spawn_id = m->GetID(); - spu->x_pos = FloatToEQ19(m->GetX()); - spu->y_pos = FloatToEQ19(m->GetY()); - spu->z_pos = FloatToEQ19(m->GetZ()); - spu->heading = FloatToEQ12(m->GetHeading()); - spu->delta_x = FloatToEQ13(dx); - spu->delta_y = FloatToEQ13(dy); - spu->delta_z = FloatToEQ13(dz); - spu->delta_heading = FloatToEQ10(dh); - spu->animation = (m->IsBot() ? (int)((float)anim / 1.785714f) : anim); + memset(position_update, 0x00, sizeof(PlayerPositionUpdateServer_Struct)); + position_update->spawn_id = mob->GetID(); + position_update->x_pos = FloatToEQ19(mob->GetX()); + position_update->y_pos = FloatToEQ19(mob->GetY()); + position_update->z_pos = FloatToEQ19(mob->GetZ()); + position_update->heading = FloatToEQ12(mob->GetHeading()); + position_update->delta_x = FloatToEQ13(delta_x); + position_update->delta_y = FloatToEQ13(delta_y); + position_update->delta_z = FloatToEQ13(delta_z); + position_update->delta_heading = FloatToEQ10(delta_heading); + position_update->animation = (mob->IsBot() ? (int) ((float) anim / 1.785714f) : anim); } -void MobMovementManager::UpdatePath(Mob *who, float x, float y, float z, MobMovementMode mode) +/** + * @param who + * @param x + * @param y + * @param z + * @param mob_movement_mode + */ +void MobMovementManager::UpdatePath(Mob *who, float x, float y, float z, MobMovementMode mob_movement_mode) { if (!zone->HasMap() || !zone->HasWaterMap()) { auto iter = _impl->Entries.find(who); auto &ent = (*iter); - - PushMoveTo(ent.second, x, y, z, mode); + + PushMoveTo(ent.second, x, y, z, mob_movement_mode); PushStopMoving(ent.second); return; } - + if (who->IsBoat()) { - UpdatePathBoat(who, x, y, z, mode); - } else if (who->IsUnderwaterOnly()) { - UpdatePathUnderwater(who, x, y, z, mode); + UpdatePathBoat(who, x, y, z, mob_movement_mode); + } + else if (who->IsUnderwaterOnly()) { + UpdatePathUnderwater(who, x, y, z, mob_movement_mode); } else { - UpdatePathGround(who, x, y, z, mode); + UpdatePathGround(who, x, y, z, mob_movement_mode); } } -void MobMovementManager::UpdatePathGround(Mob * who, float x, float y, float z, MobMovementMode mode) +/** + * @param who + * @param x + * @param y + * @param z + * @param mode + */ +void MobMovementManager::UpdatePathGround(Mob *who, float x, float y, float z, MobMovementMode mode) { PathfinderOptions opts; opts.smooth_path = true; - opts.step_size = RuleR(Pathing, NavmeshStepSize); - opts.offset = who->GetZOffset(); - opts.flags = PathingNotDisabled ^ PathingZoneLine; + opts.step_size = RuleR(Pathing, NavmeshStepSize); + opts.offset = who->GetZOffset(); + opts.flags = PathingNotDisabled ^ PathingZoneLine; //This is probably pointless since the nav mesh tool currently sets zonelines to disabled anyway auto partial = false; - auto stuck = false; - auto route = zone->pathing->FindPath( + auto stuck = false; + auto route = zone->pathing->FindPath( glm::vec3(who->GetX(), who->GetY(), who->GetZ()), glm::vec3(x, y, z), partial, stuck, - opts); + opts + ); auto eiter = _impl->Entries.find(who); - auto &ent = (*eiter); + auto &ent = (*eiter); if (route.size() == 0) { HandleStuckBehavior(who, x, y, z, mode); @@ -813,31 +967,26 @@ void MobMovementManager::UpdatePathGround(Mob * who, float x, float y, float z, } AdjustRoute(route, who); - - - + //avoid doing any processing if the mob is stuck to allow normal stuck code to work. - if (!stuck) - { + if (!stuck) { //there are times when the routes returned are no differen than where the mob is currently standing. What basically happens - //is a mob will get 'stuck' in such a way that it should be moving but the 'moving' place is the exact same spot it is at. - //this is a problem and creates an area of ground that if a mob gets to, will stay there forever. If socal this creates a - //"Ball of Death" (tm). This code tries to prevent this by simply warping the mob to the requested x/y. Better to have a warp than + //is a mob will get 'stuck' in such a way that it should be moving but the 'moving' place is the exact same spot it is at. + //this is a problem and creates an area of ground that if a mob gets to, will stay there forever. If socal this creates a + //"Ball of Death" (tm). This code tries to prevent this by simply warping the mob to the requested x/y. Better to have a warp than //have stuck mobs. - auto routeNode = route.begin(); + auto routeNode = route.begin(); bool noValidPath = true; while (routeNode != route.end() && noValidPath == true) { auto ¤tNode = (*routeNode); - if (routeNode == route.end()) - { + if (routeNode == route.end()) { continue; } - if (!(currentNode.pos.x == who->GetX() && currentNode.pos.y == who->GetY())) - { + if (!(currentNode.pos.x == who->GetX() && currentNode.pos.y == who->GetY())) { //if one of the nodes to move to, is not our current node, pass it. noValidPath = false; break; @@ -847,47 +996,62 @@ void MobMovementManager::UpdatePathGround(Mob * who, float x, float y, float z, } - if (noValidPath) - { + if (noValidPath) { //we are 'stuck' in a path, lets just get out of this by 'teleporting' to the next position. - PushTeleportTo(ent.second, x, y, z, - CalculateHeadingAngleBetweenPositions(who->GetX(), who->GetY(), x, y)); + PushTeleportTo( + ent.second, + x, + y, + z, + CalculateHeadingAngleBetweenPositions(who->GetX(), who->GetY(), x, y) + ); + return; } } - + auto iter = route.begin(); + glm::vec3 previous_pos(who->GetX(), who->GetY(), who->GetZ()); + bool first_node = true; - - while (iter != route.end()) { auto ¤t_node = (*iter); - + iter++; - + if (iter == route.end()) { continue; } - + previous_pos = current_node.pos; auto &next_node = (*iter); - + if (first_node) { - + if (mode == MovementWalking) { auto h = who->CalculateHeadingToTarget(next_node.pos.x, next_node.pos.y); PushRotateTo(ent.second, who, h, mode); } - + first_node = false; } - + //move to / teleport to node + 1 if (next_node.teleport && next_node.pos.x != 0.0f && next_node.pos.y != 0.0f) { - PushTeleportTo(ent.second, next_node.pos.x, next_node.pos.y, next_node.pos.z, - CalculateHeadingAngleBetweenPositions(current_node.pos.x, current_node.pos.y, next_node.pos.x, next_node.pos.y)); + PushTeleportTo( + ent.second, + next_node.pos.x, + next_node.pos.y, + next_node.pos.z, + CalculateHeadingAngleBetweenPositions( + current_node.pos.x, + current_node.pos.y, + next_node.pos.x, + next_node.pos.y + ) + ); } else { if (zone->watermap->InLiquid(previous_pos)) { @@ -907,41 +1071,50 @@ void MobMovementManager::UpdatePathGround(Mob * who, float x, float y, float z, } } -void MobMovementManager::UpdatePathUnderwater(Mob *who, float x, float y, float z, MobMovementMode mode) +/** + * @param who + * @param x + * @param y + * @param z + * @param movement_mode + */ +void MobMovementManager::UpdatePathUnderwater(Mob *who, float x, float y, float z, MobMovementMode movement_mode) { auto eiter = _impl->Entries.find(who); - auto &ent = (*eiter); - if (zone->watermap->InLiquid(who->GetPosition()) && zone->watermap->InLiquid(glm::vec3(x, y, z)) && zone->zonemap->CheckLoS(who->GetPosition(), glm::vec3(x, y, z))) { - PushSwimTo(ent.second, x, y, z, mode); + auto &ent = (*eiter); + if (zone->watermap->InLiquid(who->GetPosition()) && zone->watermap->InLiquid(glm::vec3(x, y, z)) && + zone->zonemap->CheckLoS(who->GetPosition(), glm::vec3(x, y, z))) { + PushSwimTo(ent.second, x, y, z, movement_mode); PushStopMoving(ent.second); return; } PathfinderOptions opts; opts.smooth_path = true; - opts.step_size = RuleR(Pathing, NavmeshStepSize); - opts.offset = who->GetZOffset(); - opts.flags = PathingNotDisabled ^ PathingZoneLine; + opts.step_size = RuleR(Pathing, NavmeshStepSize); + opts.offset = who->GetZOffset(); + opts.flags = PathingNotDisabled ^ PathingZoneLine; auto partial = false; - auto stuck = false; - auto route = zone->pathing->FindPath( + auto stuck = false; + auto route = zone->pathing->FindPath( glm::vec3(who->GetX(), who->GetY(), who->GetZ()), glm::vec3(x, y, z), partial, stuck, - opts); + opts + ); if (route.size() == 0) { - HandleStuckBehavior(who, x, y, z, mode); + HandleStuckBehavior(who, x, y, z, movement_mode); return; } AdjustRoute(route, who); - auto iter = route.begin(); + auto iter = route.begin(); glm::vec3 previous_pos(who->GetX(), who->GetY(), who->GetZ()); - bool first_node = true; + bool first_node = true; while (iter != route.end()) { auto ¤t_node = (*iter); @@ -961,7 +1134,7 @@ void MobMovementManager::UpdatePathUnderwater(Mob *who, float x, float y, float } if (route.size() == 0) { - HandleStuckBehavior(who, x, y, z, mode); + HandleStuckBehavior(who, x, y, z, movement_mode); return; } @@ -981,9 +1154,9 @@ void MobMovementManager::UpdatePathUnderwater(Mob *who, float x, float y, float if (first_node) { - if (mode == MovementWalking) { + if (movement_mode == MovementWalking) { auto h = who->CalculateHeadingToTarget(next_node.pos.x, next_node.pos.y); - PushRotateTo(ent.second, who, h, mode); + PushRotateTo(ent.second, who, h, movement_mode); } first_node = false; @@ -991,47 +1164,87 @@ void MobMovementManager::UpdatePathUnderwater(Mob *who, float x, float y, float //move to / teleport to node + 1 if (next_node.teleport && next_node.pos.x != 0.0f && next_node.pos.y != 0.0f) { - PushTeleportTo(ent.second, next_node.pos.x, next_node.pos.y, next_node.pos.z, - CalculateHeadingAngleBetweenPositions(current_node.pos.x, current_node.pos.y, next_node.pos.x, next_node.pos.y)); + PushTeleportTo( + ent.second, next_node.pos.x, next_node.pos.y, next_node.pos.z, + CalculateHeadingAngleBetweenPositions( + current_node.pos.x, + current_node.pos.y, + next_node.pos.x, + next_node.pos.y + )); } else { - PushSwimTo(ent.second, next_node.pos.x, next_node.pos.y, next_node.pos.z, mode); + PushSwimTo(ent.second, next_node.pos.x, next_node.pos.y, next_node.pos.z, movement_mode); } } if (stuck) { - HandleStuckBehavior(who, x, y, z, mode); + HandleStuckBehavior(who, x, y, z, movement_mode); } else { PushStopMoving(ent.second); } } +/** + * @param who + * @param x + * @param y + * @param z + * @param mode + */ void MobMovementManager::UpdatePathBoat(Mob *who, float x, float y, float z, MobMovementMode mode) { auto eiter = _impl->Entries.find(who); - auto &ent = (*eiter); + auto &ent = (*eiter); PushSwimTo(ent.second, x, y, z, mode); PushStopMoving(ent.second); } +/** + * @param ent + * @param x + * @param y + * @param z + * @param heading + */ void MobMovementManager::PushTeleportTo(MobMovementEntry &ent, float x, float y, float z, float heading) { ent.Commands.push_back(std::unique_ptr(new TeleportToCommand(x, y, z, heading))); } -void MobMovementManager::PushMoveTo(MobMovementEntry &ent, float x, float y, float z, MobMovementMode mode) +/** + * @param ent + * @param x + * @param y + * @param z + * @param mob_movement_mode + */ +void MobMovementManager::PushMoveTo(MobMovementEntry &ent, float x, float y, float z, MobMovementMode mob_movement_mode) { - ent.Commands.push_back(std::unique_ptr(new MoveToCommand(x, y, z, mode))); + ent.Commands.push_back(std::unique_ptr(new MoveToCommand(x, y, z, mob_movement_mode))); } -void MobMovementManager::PushSwimTo(MobMovementEntry &ent, float x, float y, float z, MobMovementMode mode) +/** + * @param ent + * @param x + * @param y + * @param z + * @param mob_movement_mode + */ +void MobMovementManager::PushSwimTo(MobMovementEntry &ent, float x, float y, float z, MobMovementMode mob_movement_mode) { - ent.Commands.push_back(std::unique_ptr(new SwimToCommand(x, y, z, mode))); + ent.Commands.push_back(std::unique_ptr(new SwimToCommand(x, y, z, mob_movement_mode))); } -void MobMovementManager::PushRotateTo(MobMovementEntry &ent, Mob *who, float to, MobMovementMode mode) +/** + * @param ent + * @param who + * @param to + * @param mob_movement_mode + */ +void MobMovementManager::PushRotateTo(MobMovementEntry &ent, Mob *who, float to, MobMovementMode mob_movement_mode) { auto from = FixHeading(who->GetHeading()); to = FixHeading(to); @@ -1050,46 +1263,59 @@ void MobMovementManager::PushRotateTo(MobMovementEntry &ent, Mob *who, float to, diff -= 512.0; } - ent.Commands.push_back(std::unique_ptr(new RotateToCommand(to, diff > 0 ? 1.0 : -1.0, mode))); + ent.Commands.push_back(std::unique_ptr(new RotateToCommand(to, diff > 0 ? 1.0 : -1.0, mob_movement_mode))); } -void MobMovementManager::PushStopMoving(MobMovementEntry &ent) +/** + * @param mob_movement_entry + */ +void MobMovementManager::PushStopMoving(MobMovementEntry &mob_movement_entry) { - ent.Commands.push_back(std::unique_ptr(new StopMovingCommand())); + mob_movement_entry.Commands.push_back(std::unique_ptr(new StopMovingCommand())); } -void MobMovementManager::PushEvadeCombat(MobMovementEntry &ent) +/** + * @param mob_movement_entry + */ +void MobMovementManager::PushEvadeCombat(MobMovementEntry &mob_movement_entry) { - ent.Commands.push_back(std::unique_ptr(new EvadeCombatCommand())); + mob_movement_entry.Commands.push_back(std::unique_ptr(new EvadeCombatCommand())); } -void MobMovementManager::HandleStuckBehavior(Mob *who, float x, float y, float z, MobMovementMode mode) +/** + * @param who + * @param x + * @param y + * @param z + * @param mob_movement_mode + */ +void MobMovementManager::HandleStuckBehavior(Mob *who, float x, float y, float z, MobMovementMode mob_movement_mode) { - auto sb = who->GetStuckBehavior(); + auto sb = who->GetStuckBehavior(); MobStuckBehavior behavior = RunToTarget; if (sb >= 0 && sb < MaxStuckBehavior) { - behavior = (MobStuckBehavior)sb; + behavior = (MobStuckBehavior) sb; } auto eiter = _impl->Entries.find(who); - auto &ent = (*eiter); + auto &ent = (*eiter); switch (sb) { - case RunToTarget: - PushMoveTo(ent.second, x, y, z, mode); - PushStopMoving(ent.second); - break; - case WarpToTarget: - PushTeleportTo(ent.second, x, y, z, 0.0f); - PushStopMoving(ent.second); - break; - case TakeNoAction: - PushStopMoving(ent.second); - break; - case EvadeCombat: - //PushEvadeCombat(ent.second); - PushStopMoving(ent.second); - break; + case RunToTarget: + PushMoveTo(ent.second, x, y, z, mob_movement_mode); + PushStopMoving(ent.second); + break; + case WarpToTarget: + PushTeleportTo(ent.second, x, y, z, 0.0f); + PushStopMoving(ent.second); + break; + case TakeNoAction: + PushStopMoving(ent.second); + break; + case EvadeCombat: + //PushEvadeCombat(ent.second); + PushStopMoving(ent.second); + break; } } diff --git a/zone/mob_movement_manager.h b/zone/mob_movement_manager.h index d9b2e7845..3c616cc5a 100644 --- a/zone/mob_movement_manager.h +++ b/zone/mob_movement_manager.h @@ -41,18 +41,29 @@ class MobMovementManager public: ~MobMovementManager(); void Process(); - void AddMob(Mob *m); - void RemoveMob(Mob *m); - void AddClient(Client *c); - void RemoveClient(Client *c); + void AddMob(Mob *mob); + void RemoveMob(Mob *mob); + void AddClient(Client *client); + void RemoveClient(Client *client); - void RotateTo(Mob *who, float to, MobMovementMode mode = MovementRunning); + void RotateTo(Mob *who, float to, MobMovementMode mob_movement_mode = MovementRunning); void Teleport(Mob *who, float x, float y, float z, float heading); void NavigateTo(Mob *who, float x, float y, float z, MobMovementMode mode = MovementRunning); void StopNavigation(Mob *who); - void SendCommandToClients(Mob *m, float dx, float dy, float dz, float dh, int anim, ClientRange range); + + void SendCommandToClients( + Mob *mob, + float delta_x, + float delta_y, + float delta_z, + float delta_heading, + int anim, + ClientRange range, + Client* single_client = nullptr + ); + float FixHeading(float in); - void DumpStats(Client *to); + void DumpStats(Client *client); void ClearStats(); static MobMovementManager &Get() { @@ -65,18 +76,18 @@ private: MobMovementManager(const MobMovementManager&); MobMovementManager& operator=(const MobMovementManager&); - void FillCommandStruct(PlayerPositionUpdateServer_Struct *spu, Mob *m, float dx, float dy, float dz, float dh, int anim); - void UpdatePath(Mob *who, float x, float y, float z, MobMovementMode mode); + void FillCommandStruct(PlayerPositionUpdateServer_Struct *position_update, Mob *mob, float delta_x, float delta_y, float delta_z, float delta_heading, int anim); + void UpdatePath(Mob *who, float x, float y, float z, MobMovementMode mob_movement_mode); void UpdatePathGround(Mob *who, float x, float y, float z, MobMovementMode mode); - void UpdatePathUnderwater(Mob *who, float x, float y, float z, MobMovementMode mode); + void UpdatePathUnderwater(Mob *who, float x, float y, float z, MobMovementMode movement_mode); void UpdatePathBoat(Mob *who, float x, float y, float z, MobMovementMode mode); void PushTeleportTo(MobMovementEntry &ent, float x, float y, float z, float heading); - void PushMoveTo(MobMovementEntry &ent, float x, float y, float z, MobMovementMode mode); - void PushSwimTo(MobMovementEntry &ent, float x, float y, float z, MobMovementMode mode); - void PushRotateTo(MobMovementEntry &ent, Mob *who, float to, MobMovementMode mode); - void PushStopMoving(MobMovementEntry &ent); - void PushEvadeCombat(MobMovementEntry &ent); - void HandleStuckBehavior(Mob *who, float x, float y, float z, MobMovementMode mode); + void PushMoveTo(MobMovementEntry &ent, float x, float y, float z, MobMovementMode mob_movement_mode); + void PushSwimTo(MobMovementEntry &ent, float x, float y, float z, MobMovementMode mob_movement_mode); + void PushRotateTo(MobMovementEntry &ent, Mob *who, float to, MobMovementMode mob_movement_mode); + void PushStopMoving(MobMovementEntry &mob_movement_entry); + void PushEvadeCombat(MobMovementEntry &mob_movement_entry); + void HandleStuckBehavior(Mob *who, float x, float y, float z, MobMovementMode mob_movement_mode); struct Implementation; std::unique_ptr _impl;