Merge b902b5484e into 5a8fb5e2d3

src/client/Client.cpp

@@ -520,8 +520,9 @@ void WowClientDestroy() {
 }
 
 void WowClientInit() {
+    EventRegister(EVENT_ID_TICK, reinterpret_cast<EVENTHANDLERFUNC>(&CWorld::OnTick));
+
     // TODO
-    // EventRegister(EVENT_ID_5, (int)sub_4020E0);
     // _cfltcvt_init_0();
 
     ClientRegisterConsoleCommands();

src/event/Scheduler.cpp

@@ -286,12 +286,10 @@ int32_t SchedulerThreadProcProcess(uint32_t a1) {
             }
         }
 
-        uint32_t v9 = (currTime - context->m_schedLastIdle);
+        float elapsedSec = (currTime - context->m_schedLastIdle) * 0.001;
         context->m_schedLastIdle = currTime;
-        double elapsedSec = v9 * 0.001;
 
-        // TODO
-        // FrameTime::Update(currTime, elapsedSec);
+        SynthesizeTick(context, currTime, elapsedSec);
 
         IEvtTimerDispatch(context);
 

src/event/Synthesize.cpp

@@ -91,3 +91,17 @@ void SynthesizePoll(EvtContext* context) {
 
     IEvtQueueDispatch(context, EVENT_ID_POLL, nullptr);
 }
+
+void SynthesizeTick(EvtContext* context, uint32_t currTime, float elapsedSec) {
+    context->m_critsect.Enter();
+    bool closed = context->m_schedState == EvtContext::SCHEDSTATE_CLOSED;
+    context->m_critsect.Leave();
+
+    if (closed) {
+        return;
+    }
+
+    EVENT_DATA_TICK data = { elapsedSec, currTime };
+
+    IEvtQueueDispatch(context, EVENT_ID_TICK, &data);
+}

src/event/Synthesize.hpp

@@ -15,4 +15,6 @@ void SynthesizePaint(EvtContext* context);
 
 void SynthesizePoll(EvtContext* context);
 
+void SynthesizeTick(EvtContext* context, uint32_t currTime, float elapsedSec);
+
 #endif

src/event/Types.hpp

@@ -12,7 +12,7 @@ enum EVENTID {
     EVENT_ID_FOCUS              = 2,
     EVENT_ID_CLOSE              = 3,
     EVENT_ID_DESTROY            = 4,
-    EVENT_ID_5                  = 5,
+    EVENT_ID_TICK               = 5,
     EVENT_ID_IDLE               = 6,
     EVENT_ID_POLL               = 7,
     EVENT_ID_INITIALIZE         = 8,
@@ -259,4 +259,9 @@ struct EVENT_DATA_SIZE {
     int32_t h;
 };
 
+struct EVENT_DATA_TICK {
+    float tickTimeSec;
+    uint32_t curTimeMs;
+};
+
 #endif

src/glue/CGlueMgr.cpp

@@ -56,6 +56,7 @@ unsigned char InterfaceKey[256] = {
 };
 
 int32_t CGlueMgr::m_acceptedEULA = 1; // TODO
+int32_t CGlueMgr::m_acceptedScanning = 1; // TODO
 int32_t CGlueMgr::m_acceptedTerminationWithoutNotice;
 int32_t CGlueMgr::m_acceptedTOS = 1; // TODO
 int32_t CGlueMgr::m_accountMsgAvailable;

src/glue/CGlueMgr.hpp

@@ -33,6 +33,7 @@ class CGlueMgr {
 
         // Static variables
         static int32_t m_acceptedEULA;
+        static int32_t m_acceptedScanning;
         static int32_t m_acceptedTerminationWithoutNotice;
         static int32_t m_acceptedTOS;
         static int32_t m_accountMsgAvailable;

src/glue/GlueScript.cpp

@@ -210,7 +210,14 @@ int32_t Script_ShowScanningNotice(lua_State* L) {
 }
 
 int32_t Script_ScanningAccepted(lua_State* L) {
-    WHOA_UNIMPLEMENTED(0);
+    if (CGlueMgr::m_acceptedScanning) {
+        lua_pushnumber(L, 1.0);
+    }
+    else {
+        lua_pushnil(L);
+    }
+
+    return 1;
 }
 
 int32_t Script_AcceptScanning(lua_State* L) {

src/object/Types.hpp

@@ -72,6 +72,12 @@ enum OBJECT_TYPE_ID {
     // TODO
 };
 
+enum OUT_OF_RANGE_TYPE {
+    OUT_OF_RANGE_0      = 0,
+    OUT_OF_RANGE_1      = 1,
+    OUT_OF_RANGE_2      = 2,
+};
+
 enum SHEATHE_TYPE {
     SHEATHE_0           = 0,
     SHEATHE_1           = 1,

src/object/client/CGContainer_C.cpp

@@ -4,6 +4,10 @@ CGContainer_C::CGContainer_C(uint32_t time, CClientObjCreate& objCreate) : CGIte
     // TODO
 }
 
+CGContainer_C::~CGContainer_C() {
+    // TODO
+}
+
 void CGContainer_C::SetStorage(uint32_t* storage, uint32_t* saved) {
     this->CGItem_C::SetStorage(storage, saved);
 

src/object/client/CGContainer_C.hpp

@@ -7,6 +7,9 @@
 
 class CGContainer_C : public CGItem_C, public CGContainer {
     public:
+        // Virtual public member functions
+        virtual ~CGContainer_C();
+
         // Public member functions
         CGContainer_C(uint32_t time, CClientObjCreate& objCreate);
         void SetStorage(uint32_t* storage, uint32_t* saved);

src/object/client/CGCorpse_C.cpp

@@ -4,6 +4,10 @@ CGCorpse_C::CGCorpse_C(uint32_t time, CClientObjCreate& objCreate) : CGObject_C(
     // TODO
 }
 
+CGCorpse_C::~CGCorpse_C() {
+    // TODO
+}
+
 void CGCorpse_C::SetStorage(uint32_t* storage, uint32_t* saved) {
     this->CGObject_C::SetStorage(storage, saved);
 

src/object/client/CGCorpse_C.hpp

@@ -7,6 +7,9 @@
 
 class CGCorpse_C : public CGObject_C, public CGCorpse {
     public:
+        // Virtual public member functions
+        virtual ~CGCorpse_C();
+
         // Public member functions
         CGCorpse_C(uint32_t time, CClientObjCreate& objCreate);
         void SetStorage(uint32_t* storage, uint32_t* saved);

src/object/client/CGDynamicObject_C.cpp

@@ -4,6 +4,10 @@ CGDynamicObject_C::CGDynamicObject_C(uint32_t time, CClientObjCreate& objCreate)
     // TODO
 }
 
+CGDynamicObject_C::~CGDynamicObject_C() {
+    // TODO
+}
+
 void CGDynamicObject_C::SetStorage(uint32_t* storage, uint32_t* saved) {
     this->CGObject_C::SetStorage(storage, saved);
 

src/object/client/CGDynamicObject_C.hpp

@@ -7,6 +7,9 @@
 
 class CGDynamicObject_C : public CGObject_C, public CGDynamicObject {
     public:
+        // Virtual public member functions
+        virtual ~CGDynamicObject_C();
+
         // Public member functions
         CGDynamicObject_C(uint32_t time, CClientObjCreate& objCreate);
         void SetStorage(uint32_t* storage, uint32_t* saved);

src/object/client/CGGameObject_C.cpp

@@ -4,6 +4,10 @@ CGGameObject_C::CGGameObject_C(uint32_t time, CClientObjCreate& objCreate) : CGO
     // TODO
 }
 
+CGGameObject_C::~CGGameObject_C() {
+    // TODO
+}
+
 void CGGameObject_C::SetStorage(uint32_t* storage, uint32_t* saved) {
     this->CGObject_C::SetStorage(storage, saved);
 

src/object/client/CGGameObject_C.hpp

@@ -7,6 +7,9 @@
 
 class CGGameObject_C : public CGObject_C, public CGGameObject {
     public:
+        // Virtual public member functions
+        virtual ~CGGameObject_C();
+
         // Public member functions
         CGGameObject_C(uint32_t time, CClientObjCreate& objCreate);
         void SetStorage(uint32_t* storage, uint32_t* saved);

src/object/client/CGItem_C.cpp

@@ -4,6 +4,10 @@ CGItem_C::CGItem_C(uint32_t time, CClientObjCreate& objCreate) : CGObject_C(time
     // TODO
 }
 
+CGItem_C::~CGItem_C() {
+    // TODO
+}
+
 void CGItem_C::SetStorage(uint32_t* storage, uint32_t* saved) {
     this->CGObject_C::SetStorage(storage, saved);
 

src/object/client/CGItem_C.hpp

@@ -7,6 +7,9 @@
 
 class CGItem_C : public CGObject_C, public CGItem {
     public:
+        // Virtual public member functions
+        virtual ~CGItem_C();
+
         // Public member functions
         CGItem_C(uint32_t time, CClientObjCreate& objCreate);
         void SetStorage(uint32_t* storage, uint32_t* saved);

src/object/client/CGObject_C.cpp

@@ -1,19 +1,53 @@
 #include "object/client/CGObject_C.hpp"
 #include "object/client/ObjMgr.hpp"
+#include "world/World.hpp"
 
 CGObject_C::CGObject_C(uint32_t time, CClientObjCreate& objCreate) {
     // TODO
 
+    this->m_lockCount = 0;
+    this->m_disabled = false;
+    this->m_inReenable = false;
+    this->m_postInited = false;
+    this->m_flag19 = false;
+    this->m_disablePending = false;
+
+    // TODO
+
     ClntObjMgrLinkInNewObject(this);
 
     // TODO
 }
 
+CGObject_C::~CGObject_C() {
+    // TODO
+}
+
 void CGObject_C::AddWorldObject() {
     // TODO
 }
 
+void CGObject_C::Disable() {
+    // TODO
+
+    this->m_disabled = true;
+    // TODO other flag manipulation
+
+    this->m_disableTimeMs = CWorld::GetCurTimeMs();
+}
+
+int32_t CGObject_C::IsInReenable() {
+    return this->m_inReenable;
+}
+
+int32_t CGObject_C::IsObjectLocked() {
+    return this->m_lockCount != 0;
+}
+
 void CGObject_C::Reenable() {
+    this->m_disabled = false;
+    this->m_inReenable = true;
+
     // TODO
 }
 
@@ -23,7 +57,23 @@ void CGObject_C::SetBlock(uint32_t block, uint32_t value) {
 }
 
 void CGObject_C::SetDisablePending(int32_t pending) {
-    // TODO
+    if (pending) {
+        this->m_disablePending = true;
+    } else {
+        this->m_disablePending = false;
+    }
+}
+
+void CGObject_C::SetObjectLocked(int32_t locked) {
+    if (locked) {
+        if (this->m_lockCount != 0xFFFF) {
+            this->m_lockCount++;
+        }
+    } else {
+        if (this->m_lockCount != 0) {
+            this->m_lockCount--;
+        }
+    }
 }
 
 void CGObject_C::SetStorage(uint32_t* storage, uint32_t* saved) {

src/object/client/CGObject_C.hpp

@@ -12,14 +12,33 @@ class CGObject_C : public CGObject, public TSHashObject<CGObject_C, CHashKeyGUID
     public:
         // Public member variables
         TSLink<CGObject_C> m_link;
+        uint32_t m_disableTimeMs;
+        // TODO
+        uint32_t m_lockCount        : 16;
+        uint32_t m_disabled         : 1;
+        uint32_t m_inReenable       : 1;
+        uint32_t m_postInited       : 1;
+        uint32_t m_flag19           : 1;
+        uint32_t m_disablePending   : 1;
+        // TODO
+
+        // Virtual public member functions
+        virtual ~CGObject_C();
+        virtual void Disable();
+        // TODO
+        virtual void HandleOutOfRange(OUT_OF_RANGE_TYPE type) {};
+        // TODO
 
         // Public member functions
         CGObject_C() = default;
         CGObject_C(uint32_t time, CClientObjCreate& objCreate);
         void AddWorldObject();
+        int32_t IsInReenable();
+        int32_t IsObjectLocked();
         void Reenable();
         void SetBlock(uint32_t block, uint32_t value);
         void SetDisablePending(int32_t pending);
+        void SetObjectLocked(int32_t locked);
         void SetStorage(uint32_t* storage, uint32_t* saved);
         void SetTypeID(OBJECT_TYPE_ID typeID);
 };

src/object/client/CGPlayer_C.cpp

@@ -7,6 +7,10 @@ CGPlayer_C::CGPlayer_C(uint32_t time, CClientObjCreate& objCreate) : CGUnit_C(ti
     // TODO
 }
 
+CGPlayer_C::~CGPlayer_C() {
+    // TODO
+}
+
 void CGPlayer_C::SetStorage(uint32_t* storage, uint32_t* saved) {
     this->CGUnit_C::SetStorage(storage, saved);
 

src/object/client/CGPlayer_C.hpp

@@ -10,6 +10,9 @@ class CreatureModelDataRec;
 
 class CGPlayer_C : public CGUnit_C, public CGPlayer {
     public:
+        // Virtual public member functions
+        virtual ~CGPlayer_C();
+
         // Public member functions
         CGPlayer_C(uint32_t time, CClientObjCreate& objCreate);
         void SetStorage(uint32_t* storage, uint32_t* saved);

src/object/client/CGUnit_C.cpp

@@ -93,6 +93,10 @@ CGUnit_C::CGUnit_C(uint32_t time, CClientObjCreate& objCreate) : CGObject_C(time
     // TODO
 }
 
+CGUnit_C::~CGUnit_C() {
+    // TODO
+}
+
 void CGUnit_C::SetStorage(uint32_t* storage, uint32_t* saved) {
     this->CGObject_C::SetStorage(storage, saved);
 

src/object/client/CGUnit_C.hpp

@@ -15,6 +15,9 @@ class CGUnit_C : public CGObject_C, public CGUnit {
         static const char* GetDisplayClassNameFromRecord(const ChrClassesRec* classRec, UNIT_SEX sex, UNIT_SEX* displaySex);
         static const char* GetDisplayRaceNameFromRecord(const ChrRacesRec* raceRec, UNIT_SEX sex, UNIT_SEX* displaySex);
 
+        // Virtual public member functions
+        virtual ~CGUnit_C();
+
         // Public member functions
         CGUnit_C(uint32_t time, CClientObjCreate& objCreate);
         void SetStorage(uint32_t* storage, uint32_t* saved);

src/object/client/ClntObjMgr.hpp

@@ -13,7 +13,7 @@ class ClntObjMgr {
         // Member variables
         TSHashTable<CGObject_C, CHashKeyGUID> m_objects;
         TSHashTable<CGObject_C, CHashKeyGUID> m_lazyCleanupObjects;
-        // TODO
+        STORM_EXPLICIT_LIST(CGObject_C, m_link) m_lazyCleanupFifo[NUM_CLIENT_OBJECT_TYPES - 1];
         STORM_EXPLICIT_LIST(CGObject_C, m_link) m_visibleObjects;
         STORM_EXPLICIT_LIST(CGObject_C, m_link) m_reenabledObjects;
         // TODO

src/object/client/MessageHandlers.cpp

@@ -34,22 +34,65 @@ int32_t SkipPartialObjectUpdate(CDataStore* msg) {
 }
 
 void UpdateOutOfRangeObjects(CDataStore* msg) {
-    WHOA_UNIMPLEMENTED();
+    uint32_t count;
+    msg->Get(count);
+
+    // TODO CVehiclePassenger_C::StartAddingPendingRescueTransitions();
+
+    auto startPos = msg->Tell();
+
+    // Pass 1
+
+    for (int32_t i = 0; i < count; i++) {
+        SmartGUID guid;
+        *msg >> guid;
+
+        if (guid == ClntObjMgrGetActivePlayer()) {
+            continue;
+        }
+
+        auto object = FindActiveObject(guid);
+
+        if (object) {
+            HandleObjectOutOfRangePass1(object, OUT_OF_RANGE_0);
+        }
+    }
+
+    msg->Seek(startPos);
+
+    // Pass 2
+
+    for (int32_t i = 0; i < count; i++) {
+        SmartGUID guid;
+        *msg >> guid;
+
+        if (guid == ClntObjMgrGetActivePlayer()) {
+            continue;
+        }
+
+        auto object = FindActiveObject(guid);
+
+        if (object && !object->IsObjectLocked()) {
+            HandleObjectOutOfRangePass2(object);
+        }
+    }
+
+    // TODO CVehiclePassenger_C::ExecutePendingRescueTransitions();
 }
 
 int32_t UpdateObject(CDataStore* msg) {
     SmartGUID guid;
     *msg >> guid;
 
-    int32_t reenabled;
-    auto object = GetUpdateObject(guid, &reenabled);
+    int32_t reenable;
+    auto object = GetUpdateObject(guid, &reenable);
 
     if (object) {
         if (!FillInPartialObjectData(object, object->m_obj->m_guid, msg, false, false)) {
             return 0;
         }
 
-        if (reenabled) {
+        if (reenable) {
             object->Reenable();
         }
 
@@ -167,8 +210,8 @@ int32_t CreateObject(CDataStore* msg, uint32_t time) {
     msg->Get(_typeID);
     auto typeID = static_cast<OBJECT_TYPE_ID>(_typeID);
 
-    int32_t reenabled;
-    auto existingObject = GetUpdateObject(guid, &reenabled);
+    int32_t reenable;
+    auto existingObject = GetUpdateObject(guid, &reenable);
 
     if (existingObject) {
         CClientObjCreate::Skip(msg);
@@ -177,7 +220,7 @@ int32_t CreateObject(CDataStore* msg, uint32_t time) {
             return 0;
         }
 
-        if (reenabled) {
+        if (reenable) {
             existingObject->Reenable();
         }
 
@@ -193,7 +236,7 @@ int32_t CreateObject(CDataStore* msg, uint32_t time) {
         ClntObjMgrSetActivePlayer(guid);
     }
 
-    auto newObject = static_cast<CGObject_C*>(ClntObjMgrAllocObject(typeID, guid));
+    auto newObject = ClntObjMgrAllocObject(typeID, guid);
 
     SetupObjectStorage(typeID, newObject, guid);
 
@@ -219,10 +262,10 @@ void UpdateInRangeObjects(CDataStore* msg) {
         *msg >> guid;
 
         if (guid != ClntObjMgrGetActivePlayer()) {
-            int32_t reenabled;
-            auto object = GetUpdateObject(guid, &reenabled);
+            int32_t reenable;
+            auto object = GetUpdateObject(guid, &reenable);
 
-            if (object && reenabled) {
+            if (object && reenable) {
                 object->Reenable();
             }
         }
@@ -341,6 +384,8 @@ int32_t ObjectUpdateHandler(void* param, NETMESSAGE msgId, uint32_t time, CDataS
     uint32_t updateCount;
     msg->Get(updateCount);
 
+    // If first update type is out of range, handle it before continuing with normal processing
+
     auto startPos = msg->Tell();
 
     uint8_t firstUpdateType;
@@ -355,6 +400,8 @@ int32_t ObjectUpdateHandler(void* param, NETMESSAGE msgId, uint32_t time, CDataS
         msg->Seek(startPos);
     }
 
+    // Process all updates in two passes (creates, updates and disables objects as appropriate)
+
     int32_t result = 0;
 
     if (ObjectUpdateFirstPass(msg, time, updateIdx, updateCount)) {
@@ -362,11 +409,31 @@ int32_t ObjectUpdateHandler(void* param, NETMESSAGE msgId, uint32_t time, CDataS
         result = ObjectUpdateSecondPass(msg, time, updateCount);
     }
 
-    // TODO
+    // Garbage collect objects disabled more than 2 minutes ago (catch all)
+
+    for (int32_t typeID = ID_OBJECT; typeID < NUM_CLIENT_OBJECT_TYPES; typeID++) {
+        GarbageCollect(static_cast<OBJECT_TYPE_ID>(typeID), 120000);
+    }
 
     return result;
 }
 
 int32_t OnObjectDestroy(void* param, NETMESSAGE msgId, uint32_t time, CDataStore* msg) {
-    WHOA_UNIMPLEMENTED(0);
+    WOWGUID guid;
+    msg->Get(guid);
+
+    uint8_t dead;
+    msg->Get(dead);
+
+    auto object = FindActiveObject(guid);
+
+    if (object) {
+        // TODO handle unit death
+
+        if (HandleObjectOutOfRangePass1(object, OUT_OF_RANGE_1)) {
+            HandleObjectOutOfRangePass2(object);
+        }
+    }
+
+    return 1;
 }

src/object/client/ObjMgr.cpp

@@ -67,15 +67,15 @@ void MirrorInitialize() {
     // TODO
 }
 
-void* ClntObjMgrAllocObject(OBJECT_TYPE_ID typeID, WOWGUID guid) {
+CGObject_C* ClntObjMgrAllocObject(OBJECT_TYPE_ID typeID, WOWGUID guid) {
     auto playerGUID = ClntObjMgrGetActivePlayer();
 
     // Heap allocate player object for current player
     if (guid == playerGUID) {
-        return STORM_ALLOC(sizeof(CGPlayer_C) + CGPlayer::GetDataSize() + CGPlayer::GetDataSizeSaved());
+        return static_cast<CGObject_C*>(STORM_ALLOC(sizeof(CGPlayer_C) + CGPlayer::GetDataSize() + CGPlayer::GetDataSizeSaved()));
     }
 
-    // TODO GarbageCollect(typeID, 10000);
+    GarbageCollect(typeID, 10000);
 
     uint32_t memHandle;
     void* mem;
@@ -85,9 +85,40 @@ void* ClntObjMgrAllocObject(OBJECT_TYPE_ID typeID, WOWGUID guid) {
     }
 
     // TODO pointer should be fetched via ObjectPtr
-    static_cast<CGObject_C*>(mem)->m_memHandle = memHandle;
+    auto object = static_cast<CGObject_C*>(mem);
+    object->m_memHandle = memHandle;
 
-    return mem;
+    return object;
+}
+
+void ClntObjMgrFreeObject(CGObject_C* object) {
+    auto playerGUID = ClntObjMgrGetActivePlayer();
+    auto isActivePlayer = object->m_obj->m_guid == playerGUID;
+
+    switch (object->m_obj->m_type) {
+        case TYPE_OBJECT:
+        case HIER_TYPE_ITEM:
+        case HIER_TYPE_CONTAINER:
+        case HIER_TYPE_UNIT:
+        case HIER_TYPE_PLAYER:
+        case HIER_TYPE_GAMEOBJECT:
+        case HIER_TYPE_DYNAMICOBJECT:
+        case HIER_TYPE_CORPSE: {
+            object->~CGObject_C();
+
+            break;
+        }
+
+        default: {
+            break;
+        }
+    }
+
+    if (isActivePlayer) {
+        STORM_FREE(object);
+    } else {
+        ObjectFree(s_objHeapId[object->m_typeID], object->m_memHandle);
+    }
 }
 
 WOWGUID ClntObjMgrGetActivePlayer() {

src/object/client/ObjMgr.hpp

@@ -6,10 +6,12 @@
 #include "object/Types.hpp"
 #include <cstdint>
 
-void* ClntObjMgrAllocObject(OBJECT_TYPE_ID typeID, WOWGUID guid);
+CGObject_C* ClntObjMgrAllocObject(OBJECT_TYPE_ID typeID, WOWGUID guid);
 
 WOWGUID ClntObjMgrGetActivePlayer();
 
+void ClntObjMgrFreeObject(CGObject_C* object);
+
 ClntObjMgr* ClntObjMgrGetCurrent();
 
 uint32_t ClntObjMgrGetMapID();

src/object/client/Util.cpp

@@ -9,13 +9,37 @@
 #include "object/client/CGPlayer_C.hpp"
 #include "object/client/CGUnit_C.hpp"
 #include "object/client/ObjMgr.hpp"
+#include <common/Time.hpp>
 
 CGObject_C* FindActiveObject(WOWGUID guid) {
     return ClntObjMgrGetCurrent()->m_objects.Ptr(guid, CHashKeyGUID(guid));
 }
 
-CGObject_C* GetUpdateObject(WOWGUID guid, int32_t* reenabled) {
-    *reenabled = false;
+/**
+ * Given an object type and collection age, free the object at the head of that type's FIFO queue
+ * if it was disabled longer ago than the collection age. Only frees at most one object per call.
+ */
+void GarbageCollect(OBJECT_TYPE_ID typeID, uint32_t collectAgeMs) {
+    auto object = ClntObjMgrGetCurrent()->m_lazyCleanupFifo[typeID - 1].Head();
+
+    if (!object) {
+        return;
+    }
+
+    uint32_t disableAgeMs = OsGetAsyncTimeMsPrecise() - object->m_disableTimeMs;
+
+    if (disableAgeMs < collectAgeMs) {
+        return;
+    }
+
+    ClntObjMgrGetCurrent()->m_lazyCleanupObjects.Unlink(object);
+    object->m_link.Unlink();
+
+    ClntObjMgrFreeObject(object);
+}
+
+CGObject_C* GetUpdateObject(WOWGUID guid, int32_t* reenable) {
+    *reenable = false;
 
     // Active object
 
@@ -44,7 +68,7 @@ CGObject_C* GetUpdateObject(WOWGUID guid, int32_t* reenabled) {
             !ClntObjMgrGetCurrent()->m_visibleObjects.IsLinked(disabledObject)
             && !ClntObjMgrGetCurrent()->m_reenabledObjects.IsLinked(disabledObject)
         ) {
-            *reenabled = true;
+            *reenable = true;
             ClntObjMgrGetCurrent()->m_reenabledObjects.LinkToTail(disabledObject);
         }
 
@@ -56,6 +80,36 @@ CGObject_C* GetUpdateObject(WOWGUID guid, int32_t* reenabled) {
     return nullptr;
 }
 
+int32_t HandleObjectOutOfRangePass1(CGObject_C* object, OUT_OF_RANGE_TYPE type) {
+    // TODO arena unit out of range handling
+
+    object->HandleOutOfRange(type);
+
+    if (object->IsObjectLocked()) {
+        object->SetDisablePending(true);
+
+        return false;
+    }
+
+    object->SetDisablePending(false);
+    object->Disable();
+
+    return true;
+}
+
+void HandleObjectOutOfRangePass2(CGObject_C* object) {
+    // TODO ClearObjectMirrorHandlers(object);
+
+    ClntObjMgrGetCurrent()->m_objects.Unlink(object);
+
+    if (ClntObjMgrGetCurrent()->m_visibleObjects.IsLinked(object)) {
+        ClntObjMgrGetCurrent()->m_visibleObjects.UnlinkNode(object);
+    }
+
+    ClntObjMgrGetCurrent()->m_lazyCleanupObjects.Insert(object, object->m_hashval, CHashKeyGUID(object->m_key));
+    ClntObjMgrGetCurrent()->m_lazyCleanupFifo[object->m_typeID - 1].LinkToTail(object);
+}
+
 void InitObject(CGObject_C* object, uint32_t time, CClientObjCreate& objCreate) {
     switch (object->m_typeID) {
         case ID_ITEM: {

src/object/client/Util.hpp

@@ -1,6 +1,7 @@
 #ifndef OBJECT_CLIENT_UTIL_HPP
 #define OBJECT_CLIENT_UTIL_HPP
 
+#include "object/Types.hpp"
 #include "util/GUID.hpp"
 #include <cstdint>
 
@@ -9,7 +10,13 @@ class CGObject_C;
 
 CGObject_C* FindActiveObject(WOWGUID guid);
 
-CGObject_C* GetUpdateObject(WOWGUID guid, int32_t* reenabled);
+void GarbageCollect(OBJECT_TYPE_ID typeID, uint32_t collectAgeMs);
+
+CGObject_C* GetUpdateObject(WOWGUID guid, int32_t* reenable);
+
+int32_t HandleObjectOutOfRangePass1(CGObject_C* object, OUT_OF_RANGE_TYPE type);
+
+void HandleObjectOutOfRangePass2(CGObject_C* object);
 
 void InitObject(CGObject_C* object, uint32_t time, CClientObjCreate& objCreate);
 

src/world/CWorld.cpp

@@ -6,10 +6,49 @@
 #include "world/Weather.hpp"
 #include <storm/Memory.hpp>
 
+uint32_t CWorld::s_curTimeMs;
+float CWorld::s_curTimeSec;
 uint32_t CWorld::s_enables;
 uint32_t CWorld::s_enables2;
+uint32_t CWorld::s_gameTimeFixed;
+float CWorld::s_gameTimeSec;
+uint32_t CWorld::s_tickTimeFixed;
+uint32_t CWorld::s_tickTimeMs;
+float CWorld::s_tickTimeSec;
 Weather* CWorld::s_weather;
 
+uint32_t CWorld::GetCurTimeMs() {
+    return CWorld::s_curTimeMs;
+}
+
+float CWorld::GetCurTimeSec() {
+    return CWorld::s_curTimeSec;
+}
+
+uint32_t CWorld::GetFixedPrecisionTime(float timeSec) {
+    return static_cast<uint32_t>(timeSec * 1024.0f);
+}
+
+uint32_t CWorld::GetGameTimeFixed() {
+    return CWorld::s_gameTimeFixed;
+}
+
+float CWorld::GetGameTimeSec() {
+    return CWorld::s_gameTimeSec;
+}
+
+uint32_t CWorld::GetTickTimeFixed() {
+    return CWorld::s_tickTimeFixed;
+}
+
+uint32_t CWorld::GetTickTimeMs() {
+    return CWorld::s_tickTimeMs;
+}
+
+float CWorld::GetTickTimeSec() {
+    return CWorld::s_tickTimeSec;
+}
+
 void CWorld::Initialize() {
     CWorld::s_enables |=
           Enables::Enable_1
@@ -26,6 +65,9 @@ void CWorld::Initialize() {
         | Enables::Enable_Particulates
         | Enables::Enable_LowDetail;
 
+    CWorld::s_gameTimeFixed = 0;
+    CWorld::s_gameTimeSec = 0.0f;
+
     // TODO
 
     if (GxCaps().m_shaderTargets[GxSh_Pixel] > GxShPS_none) {
@@ -58,3 +100,23 @@ void CWorld::LoadMap(const char* mapName, const C3Vector& position, int32_t zone
 
     // TODO
 }
+
+int32_t CWorld::OnTick(const EVENT_DATA_TICK* data, void* param) {
+    CWorld::SetUpdateTime(data->tickTimeSec, data->curTimeMs);
+
+    return 1;
+}
+
+void CWorld::SetUpdateTime(float tickTimeSec, uint32_t curTimeMs) {
+    auto tickTimeFixed = CWorld::GetFixedPrecisionTime(tickTimeSec);
+
+    CWorld::s_curTimeMs = curTimeMs;
+    CWorld::s_curTimeSec = static_cast<float>(curTimeMs) * 0.001f;
+
+    CWorld::s_gameTimeFixed += tickTimeFixed;
+    CWorld::s_gameTimeSec += tickTimeSec;
+
+    CWorld::s_tickTimeFixed = tickTimeFixed;
+    CWorld::s_tickTimeMs = static_cast<uint32_t>(tickTimeSec * 1000.0f);
+    CWorld::s_tickTimeSec = tickTimeSec;
+}

src/world/CWorld.hpp

@@ -1,6 +1,7 @@
 #ifndef WORLD_C_WORLD_HPP
 #define WORLD_C_WORLD_HPP
 
+#include "event/Event.hpp"
 #include <tempest/Vector.hpp>
 #include <cstdint>
 
@@ -44,14 +45,36 @@ class CWorld {
             Enable_HwPcf = 0x2
         };
 
-        // Static variables
+        // Public static variables
         static uint32_t s_enables;
         static uint32_t s_enables2;
         static Weather* s_weather;
 
-        // Static functions
-        static void Initialize(void);
+        // Public static functions
+        static uint32_t GetCurTimeMs();
+        static float GetCurTimeSec();
+        static uint32_t GetGameTimeFixed();
+        static float GetGameTimeSec();
+        static uint32_t GetTickTimeFixed();
+        static uint32_t GetTickTimeMs();
+        static float GetTickTimeSec();
+        static void Initialize();
         static void LoadMap(const char* mapName, const C3Vector& position, int32_t zoneID);
+        static int32_t OnTick(const EVENT_DATA_TICK* data, void* param);
+        static void SetUpdateTime(float tickTimeSec, uint32_t curTimeMs);
+
+    private:
+        // Private static variables
+        static uint32_t s_curTimeMs;
+        static float s_curTimeSec;
+        static uint32_t s_gameTimeFixed;
+        static float s_gameTimeSec;
+        static uint32_t s_tickTimeFixed;
+        static uint32_t s_tickTimeMs;
+        static float s_tickTimeSec;
+
+        // Private static functions
+        static uint32_t GetFixedPrecisionTime(float timeSec);
 };
 
 #endif