Revert Visibility Notifier changes (#17682)

* Revert "fix(Core/Grid): Implement missing GridUnload setting (#17569)" This reverts commit 79b39f9655. * Revert "fix(Core/Grid): Address bugs and performance issues introduced by visibility notifier implementation (#17480)" This reverts commit 60e27511c5. * Revert "fix(Core): GridCleanUpDelay Log (#17436)" This reverts commit 90b16ca065. * Revert "feat(Core/Grids): Implement visibility notifier (#15919)" This reverts commit 2779833768.
2026-01-14 09:39:11 +00:00 · 2023-11-12 00:48:49 +01:00
parent 4df0ab3427
commit bbadc32bea
64 changed files with 1074 additions and 1764 deletions
--- a/src/server/game/Entities/Unit/Unit.cpp
+++ b/src/server/game/Entities/Unit/Unit.cpp
@@ -32,6 +32,7 @@
 #include "CreatureAIImpl.h"
 #include "CreatureGroups.h"
 #include "DisableMgr.h"
+#include "DynamicVisibility.h"
 #include "Formulas.h"
 #include "GameObjectAI.h"
 #include "GameTime.h"
@@ -43,7 +44,6 @@
 #include "MoveSpline.h"
 #include "MoveSplineInit.h"
 #include "MovementGenerator.h"
-#include "MovementPacketBuilder.h"
 #include "ObjectAccessor.h"
 #include "ObjectMgr.h"
 #include "Opcodes.h"
@@ -317,6 +317,12 @@ Unit::Unit(bool isWorldObject) : WorldObject(isWorldObject),

    m_serverSideVisibility.SetValue(SERVERSIDE_VISIBILITY_GHOST, GHOST_VISIBILITY_ALIVE);

+    m_last_notify_position.Relocate(-5000.0f, -5000.0f, -5000.0f, 0.0f);
+    m_last_notify_mstime = 0;
+    m_delayed_unit_relocation_timer = 0;
+    m_delayed_unit_ai_notify_timer = 0;
+    bRequestForcedVisibilityUpdate = false;
+
    m_applyResilience = false;
    _instantCast = false;

@@ -405,6 +411,32 @@ void Unit::Update(uint32 p_time)
    if (!IsInWorld())
        return;

+    // pussywizard:
+    if (GetTypeId() != TYPEID_PLAYER || (!ToPlayer()->IsBeingTeleported() && !bRequestForcedVisibilityUpdate))
+    {
+        if (m_delayed_unit_relocation_timer)
+        {
+            if (m_delayed_unit_relocation_timer <= p_time)
+            {
+                m_delayed_unit_relocation_timer = 0;
+                //ExecuteDelayedUnitRelocationEvent();
+                FindMap()->i_objectsForDelayedVisibility.insert(this);
+            }
+            else
+                m_delayed_unit_relocation_timer -= p_time;
+        }
+        if (m_delayed_unit_ai_notify_timer)
+        {
+            if (m_delayed_unit_ai_notify_timer <= p_time)
+            {
+                m_delayed_unit_ai_notify_timer = 0;
+                ExecuteDelayedUnitAINotifyEvent();
+            }
+            else
+                m_delayed_unit_ai_notify_timer -= p_time;
+        }
+    }
+
    _UpdateSpells( p_time );

    if (CanHaveThreatList() && GetThreatMgr().isNeedUpdateToClient(p_time))
@@ -568,27 +600,14 @@ void Unit::UpdateSplineMovement(uint32 t_diff)
    SplineHandler handler(this);
    movespline->updateState(t_diff, handler);
    // Xinef: Spline was cleared by StopMoving, return
-    if (!movespline->Initialized()) {
+    if (!movespline->Initialized())
+    {
        DisableSpline();
        return;
    }

    bool arrived = movespline->Finalized();

-    if (movespline->isCyclic())
-    {
-        m_splineSyncTimer.Update(t_diff);
-        if (m_splineSyncTimer.Passed())
-        {
-            m_splineSyncTimer.Reset(5000); // Retail value, do not change
-
-            WorldPacket data(SMSG_FLIGHT_SPLINE_SYNC, 4 + GetPackGUID().size());
-            Movement::PacketBuilder::WriteSplineSync(*movespline, data);
-            data.appendPackGUID(GetGUID());
-            SendMessageToSet(&data, true);
-        }
-    }
-
    if (arrived)
    {
        DisableSpline();
@@ -597,11 +616,17 @@ void Unit::UpdateSplineMovement(uint32 t_diff)
            SetByteValue(UNIT_FIELD_BYTES_1, UNIT_BYTES_1_OFFSET_ANIM_TIER, movespline->GetAnimationType());
    }

+    // pussywizard: update always! not every 400ms, because movement generators need the actual position
+    //m_movesplineTimer.Update(t_diff);
+    //if (m_movesplineTimer.Passed() || arrived)
    UpdateSplinePosition();
 }

 void Unit::UpdateSplinePosition()
 {
+    //static uint32 const positionUpdateDelay = 400;
+
+    //m_movesplineTimer.Reset(positionUpdateDelay);
    Movement::Location loc = movespline->ComputePosition();

    if (movespline->onTransport)
@@ -614,14 +639,16 @@ void Unit::UpdateSplinePosition()

        if (TransportBase* transport = GetDirectTransport())
            transport->CalculatePassengerPosition(loc.x, loc.y, loc.z, &loc.orientation);
-        else
-            return;
    }

-    if (HasUnitState(UNIT_STATE_CANNOT_TURN))
-        loc.orientation = GetOrientation();
+    // Xinef: if we had spline running update orientation along with position
+    //if (HasUnitState(UNIT_STATE_CANNOT_TURN))
+    //    loc.orientation = GetOrientation();

-    UpdatePosition(loc.x, loc.y, loc.z, loc.orientation);
+    if (GetTypeId() == TYPEID_PLAYER)
+        UpdatePosition(loc.x, loc.y, loc.z, loc.orientation);
+    else
+        ToCreature()->SetPosition(loc.x, loc.y, loc.z, loc.orientation);
 }

 void Unit::DisableSpline()
@@ -15714,9 +15741,15 @@ void Unit::CleanupBeforeRemoveFromMap(bool finalCleanup)

 void Unit::CleanupsBeforeDelete(bool finalCleanup)
 {
-    CleanupBeforeRemoveFromMap(finalCleanup);
+    if (GetTransport())
+    {
+        GetTransport()->RemovePassenger(this);
+        SetTransport(nullptr);
+        m_movementInfo.transport.Reset();
+        m_movementInfo.RemoveMovementFlag(MOVEMENTFLAG_ONTRANSPORT);
+    }

-    WorldObject::CleanupsBeforeDelete(finalCleanup);
+    CleanupBeforeRemoveFromMap(finalCleanup);
 }

 void Unit::UpdateCharmAI()
@@ -17489,17 +17522,13 @@ void Unit::SetContestedPvP(Player* attackedPlayer, bool lookForNearContestedGuar
        player->AddUnitState(UNIT_STATE_ATTACK_PLAYER);
        player->SetPlayerFlag(PLAYER_FLAGS_CONTESTED_PVP);
        // call MoveInLineOfSight for nearby contested guards
-        Acore::AIRelocationNotifier notifier(*this);
-        Cell::VisitWorldObjects(this, notifier, GetVisibilityRange());
+        AddToNotify(NOTIFY_AI_RELOCATION);
    }
-    for (Unit* unit : m_Controlled)
+    if (!HasUnitState(UNIT_STATE_ATTACK_PLAYER))
    {
-        if (!unit->HasUnitState(UNIT_STATE_ATTACK_PLAYER))
-        {
-            unit->AddUnitState(UNIT_STATE_ATTACK_PLAYER);
-            Acore::AIRelocationNotifier notifier(*unit);
-            Cell::VisitWorldObjects(this, notifier, GetVisibilityRange());
-        }
+        AddUnitState(UNIT_STATE_ATTACK_PLAYER);
+        // call MoveInLineOfSight for nearby contested guards
+        AddToNotify(NOTIFY_AI_RELOCATION);
    }
 }

@@ -19346,7 +19375,7 @@ void Unit::SetPhaseMask(uint32 newPhaseMask, bool update)
    }
 }

-void Unit::UpdateObjectVisibility(bool forced)
+void Unit::UpdateObjectVisibility(bool forced, bool /*fromUpdate*/)
 {
    if (!forced)
        AddToNotify(NOTIFY_VISIBILITY_CHANGED);
@@ -19354,7 +19383,8 @@ void Unit::UpdateObjectVisibility(bool forced)
    {
        WorldObject::UpdateObjectVisibility(true);
        Acore::AIRelocationNotifier notifier(*this);
-        Cell::VisitAllObjects(this, notifier, GetVisibilityRange());
+        float radius = 60.0f;
+        Cell::VisitAllObjects(this, notifier, radius);
    }
 }

@@ -20252,14 +20282,10 @@ bool Unit::UpdatePosition(float x, float y, float z, float orientation, bool tel
    if (!Acore::IsValidMapCoord(x, y, z, orientation))
        return false;

-    // Check if angular distance changed
-    bool const turn = G3D::fuzzyGt(M_PI - fabs(fabs(GetOrientation() - orientation) - M_PI), 0.0f);
-
-    // G3D::fuzzyEq won't help here, in some cases magnitudes differ by a little more than G3D::eps, but should be considered equal
-    bool const relocated = (teleport ||
-        std::fabs(GetPositionX() - x) > 0.001f ||
-        std::fabs(GetPositionY() - y) > 0.001f ||
-        std::fabs(GetPositionZ() - z) > 0.001f);
+    float old_orientation = GetOrientation();
+    float current_z = GetPositionZ();
+    bool turn = (old_orientation != orientation);
+    bool relocated = (teleport || GetPositionX() != x || GetPositionY() != y || current_z != z);

    if (!GetVehicle())
    {
@@ -20285,8 +20311,6 @@ bool Unit::UpdatePosition(float x, float y, float z, float orientation, bool tel
            UpdateObjectVisibility(false);
    }

-    UpdatePositionData();
-
    return (relocated || turn);
 }

@@ -20717,6 +20741,124 @@ bool ConflagrateAuraStateDelayEvent::Execute(uint64 /*e_time*/, uint32  /*p_time
    return true;
 }

+void Unit::ExecuteDelayedUnitRelocationEvent()
+{
+    this->RemoveFromNotify(NOTIFY_VISIBILITY_CHANGED);
+    if (!this->IsInWorld() || this->IsDuringRemoveFromWorld())
+        return;
+
+    if (this->HasSharedVision())
+        for (SharedVisionList::const_iterator itr = this->GetSharedVisionList().begin(); itr != this->GetSharedVisionList().end(); ++itr)
+            if (Player* player = (*itr))
+            {
+                if (player->IsOnVehicle(this) || !player->IsInWorld() || player->IsDuringRemoveFromWorld()) // players on vehicles have their own event executed (due to passenger relocation)
+                    continue;
+                WorldObject* viewPoint = player;
+                if (player->m_seer && player->m_seer->IsInWorld())
+                    viewPoint = player->m_seer;
+                if (!viewPoint->IsPositionValid() || !player->IsPositionValid())
+                    continue;
+
+                if (Unit* active = viewPoint->ToUnit())
+                {
+                    //if (active->IsVehicle()) // always check original unit here, last notify position is not relocated
+                    //  active = player;
+
+                    float dx = active->m_last_notify_position.GetPositionX() - active->GetPositionX();
+                    float dy = active->m_last_notify_position.GetPositionY() - active->GetPositionY();
+                    float dz = active->m_last_notify_position.GetPositionZ() - active->GetPositionZ();
+                    float distsq = dx * dx + dy * dy + dz * dz;
+                    float mindistsq = DynamicVisibilityMgr::GetReqMoveDistSq(active->FindMap()->GetEntry()->map_type);
+                    if (distsq < mindistsq)
+                        continue;
+
+                    // this will be relocated below sharedvision!
+                    //active->m_last_notify_position.Relocate(active->GetPositionX(), active->GetPositionY(), active->GetPositionZ());
+                }
+
+                Acore::PlayerRelocationNotifier relocateNoLarge(*player, false); // visit only objects which are not large; default distance
+                Cell::VisitAllObjects(viewPoint, relocateNoLarge, player->GetSightRange() + VISIBILITY_INC_FOR_GOBJECTS);
+                relocateNoLarge.SendToSelf();
+                Acore::PlayerRelocationNotifier relocateLarge(*player, true);    // visit only large objects; maximum distance
+                Cell::VisitAllObjects(viewPoint, relocateLarge, MAX_VISIBILITY_DISTANCE);
+                relocateLarge.SendToSelf();
+            }
+
+    if (Player* player = this->ToPlayer())
+    {
+        WorldObject* viewPoint = player;
+        if (player->m_seer && player->m_seer->IsInWorld())
+            viewPoint = player->m_seer;
+
+        if (viewPoint->GetMapId() != player->GetMapId() || !viewPoint->IsPositionValid() || !player->IsPositionValid())
+            return;
+
+        if (Unit* active = viewPoint->ToUnit())
+        {
+            if (active->IsVehicle())
+                active = player;
+
+            if (!player->GetFarSightDistance())
+            {
+                float dx     = active->m_last_notify_position.GetPositionX() - active->GetPositionX();
+                float dy     = active->m_last_notify_position.GetPositionY() - active->GetPositionY();
+                float dz     = active->m_last_notify_position.GetPositionZ() - active->GetPositionZ();
+                float distsq = dx * dx + dy * dy + dz * dz;
+
+                float mindistsq = DynamicVisibilityMgr::GetReqMoveDistSq(active->FindMap()->GetEntry()->map_type);
+                if (distsq < mindistsq)
+                    return;
+
+                active->m_last_notify_position.Relocate(active->GetPositionX(), active->GetPositionY(), active->GetPositionZ());
+            }
+        }
+
+        Acore::PlayerRelocationNotifier relocateNoLarge(*player, false); // visit only objects which are not large; default distance
+        Cell::VisitAllObjects(viewPoint, relocateNoLarge, player->GetSightRange() + VISIBILITY_INC_FOR_GOBJECTS);
+        relocateNoLarge.SendToSelf();
+
+        if (!player->GetFarSightDistance())
+        {
+            Acore::PlayerRelocationNotifier relocateLarge(*player, true); // visit only large objects; maximum distance
+            Cell::VisitAllObjects(viewPoint, relocateLarge, MAX_VISIBILITY_DISTANCE);
+            relocateLarge.SendToSelf();
+        }
+
+        this->AddToNotify(NOTIFY_AI_RELOCATION);
+    }
+    else if (Creature* unit = this->ToCreature())
+    {
+        if (!unit->IsPositionValid())
+            return;
+
+        float dx = unit->m_last_notify_position.GetPositionX() - unit->GetPositionX();
+        float dy = unit->m_last_notify_position.GetPositionY() - unit->GetPositionY();
+        float dz = unit->m_last_notify_position.GetPositionZ() - unit->GetPositionZ();
+        float distsq = dx * dx + dy * dy + dz * dz;
+        float mindistsq = DynamicVisibilityMgr::GetReqMoveDistSq(unit->FindMap()->GetEntry()->map_type);
+        if (distsq < mindistsq)
+            return;
+
+        unit->m_last_notify_position.Relocate(unit->GetPositionX(), unit->GetPositionY(), unit->GetPositionZ());
+
+        Acore::CreatureRelocationNotifier relocate(*unit);
+        Cell::VisitAllObjects(unit, relocate, unit->GetVisibilityRange() + VISIBILITY_COMPENSATION);
+
+        this->AddToNotify(NOTIFY_AI_RELOCATION);
+    }
+}
+
+void Unit::ExecuteDelayedUnitAINotifyEvent()
+{
+    this->RemoveFromNotify(NOTIFY_AI_RELOCATION);
+    if (!this->IsInWorld() || this->IsDuringRemoveFromWorld())
+        return;
+
+    Acore::AIRelocationNotifier notifier(*this);
+    float radius = 60.0f;
+    Cell::VisitAllObjects(this, notifier, radius);
+}
+
 void Unit::SetInFront(WorldObject const* target)
 {
    if (!HasUnitState(UNIT_STATE_CANNOT_TURN))