Merge 4a102c6ace into 5a69128f63

src/object/client/CGObject_C.cpp

@@ -1,4 +1,5 @@
 #include "object/client/CGObject_C.hpp"
+#include "model/Model2.hpp"
 #include "object/client/ObjMgr.hpp"
 #include "world/World.hpp"
 
@@ -6,6 +7,7 @@ CGObject_C::CGObject_C(uint32_t time, CClientObjCreate& objCreate) {
     // TODO
 
     this->m_model = nullptr;
+    this->m_worldObject = 0;
 
     // TODO
 
@@ -28,7 +30,52 @@ CGObject_C::~CGObject_C() {
 }
 
 void CGObject_C::AddWorldObject() {
-    // TODO
+    if (!this->m_model) {
+        const char* fileName;
+        if (this->GetModelFileName(fileName)) {
+            auto model = CWorld::GetM2Scene()->CreateModel(fileName, 0);
+            this->SetModel(model);
+            model->Release();
+        }
+    }
+
+    if (!this->m_model) {
+        return;
+    }
+
+    if (ClntObjMgrGetPlayerType() != PLAYER_NORMAL) {
+        return;
+    }
+
+    if (this->m_worldObject) {
+        // TODO SysMsgPrintf(1, 2, "OBJECTALREADYACTIVE|0x%016I64X", this->GetGUID());
+
+        return;
+    }
+
+    uint32_t objFlags = 0x0;
+
+    if (this->IsA(TYPE_GAMEOBJECT)) {
+        objFlags |= 0x8 | 0x2 | 0x1;
+    } else if (this->IsA(TYPE_DYNAMICOBJECT)) {
+        objFlags |= 0x8 | 0x2;
+    } else if (this->IsA(TYPE_CORPSE)) {
+        // TODO
+    } else if (this->IsA(TYPE_UNIT)) {
+        // TODO
+
+        objFlags |= 0x10;
+
+        if (this->IsA(TYPE_PLAYER)) {
+            objFlags |= 0x20;
+        }
+    }
+
+    this->m_worldObject = CWorld::AddObject(this->GetObjectModel(), nullptr, nullptr, this->GetGUID(), 0, objFlags);
+
+    if (!this->m_inReenable && this->m_postInited) {
+        this->UpdateWorldObject(false);
+    }
 }
 
 int32_t CGObject_C::CanBeTargetted() {
@@ -48,6 +95,14 @@ void CGObject_C::Disable() {
     this->m_disableTimeMs = CWorld::GetCurTimeMs();
 }
 
+int32_t CGObject_C::GetModelFileName(const char*& name) const {
+    return false;
+}
+
+CM2Model* CGObject_C::GetObjectModel() {
+    return this->m_model;
+}
+
 int32_t CGObject_C::IsInReenable() {
     return this->m_inReenable;
 }
@@ -90,6 +145,25 @@ void CGObject_C::SetDisablePending(int32_t pending) {
     }
 }
 
+void CGObject_C::SetModel(CM2Model* model) {
+    // No change
+    if (this->m_model == model) {
+        return;
+    }
+
+    if (model) {
+        model->AddRef();
+    }
+
+    this->m_model = model;
+
+    this->SetModelFinish(model);
+}
+
+void CGObject_C::SetModelFinish(CM2Model* model) {
+    // TODO
+}
+
 void CGObject_C::SetObjectLocked(int32_t locked) {
     if (locked) {
         if (this->m_lockCount != 0xFFFF) {
@@ -147,3 +221,7 @@ void CGObject_C::SetTypeID(OBJECT_TYPE_ID typeID) {
             break;
     }
 }
+
+void CGObject_C::UpdateWorldObject(int32_t a2) {
+    // TODO
+}

src/object/client/CGObject_C.hpp

@@ -5,6 +5,7 @@
 #include "object/client/CClientObjCreate.hpp"
 #include "object/client/CGObject.hpp"
 #include "util/GUID.hpp"
+#include "world/Types.hpp"
 #include <storm/Hash.hpp>
 #include <storm/List.hpp>
 
@@ -18,6 +19,7 @@ class CGObject_C : public CGObject, public TSHashObject<CGObject_C, CHashKeyGUID
         // TODO
         CM2Model* m_model;
         // TODO
+        HWORLDOBJECT m_worldObject;
         uint32_t m_lockCount        : 16;
         uint32_t m_disabled         : 1;
         uint32_t m_inReenable       : 1;
@@ -32,9 +34,14 @@ class CGObject_C : public CGObject, public TSHashObject<CGObject_C, CHashKeyGUID
         void Reenable();
         void PostReenable();
         virtual void HandleOutOfRange(OUT_OF_RANGE_TYPE type) {};
+        virtual void UpdateWorldObject(int32_t a2);
+        // TODO
+        virtual int32_t GetModelFileName(const char*& name) const;
         // TODO
         virtual int32_t CanHighlight();
         virtual int32_t CanBeTargetted();
+        // TODO
+        virtual CM2Model* GetObjectModel();
 
         // Public member functions
         CGObject_C() = default;
@@ -45,6 +52,8 @@ class CGObject_C : public CGObject, public TSHashObject<CGObject_C, CHashKeyGUID
         void PostInit(uint32_t time, const CClientObjCreate& init, bool a4);
         void SetBlock(uint32_t block, uint32_t value);
         void SetDisablePending(int32_t pending);
+        void SetModel(CM2Model* model);
+        void SetModelFinish(CM2Model* model);
         void SetObjectLocked(int32_t locked);
         void SetStorage(uint32_t* storage, uint32_t* saved);
         void SetTypeID(OBJECT_TYPE_ID typeID);

src/object/client/CGUnit_C.cpp

@@ -115,6 +115,26 @@ int32_t CGUnit_C::CanBeTargetted() {
     return this->CanHighlight();
 }
 
+CreatureModelDataRec* CGUnit_C::GetModelData() const {
+    // TODO
+    return nullptr;
+}
+
+int32_t CGUnit_C::GetModelFileName(const char*& name) const {
+    auto modelDataRec = this->GetModelData();
+
+    // Model data not found
+    if (!modelDataRec) {
+        name = "Spells\\ErrorCube.mdx";
+
+        return true;
+    }
+
+    name = modelDataRec->m_modelName;
+
+    return modelDataRec->m_modelName ? true : false;
+}
+
 void CGUnit_C::PostInit(uint32_t time, const CClientObjCreate& init, bool a4) {
     // TODO
 

src/object/client/CGUnit_C.hpp

@@ -9,6 +9,7 @@
 
 class ChrClassesRec;
 class ChrRacesRec;
+class CreatureModelDataRec;
 
 class CGUnit_C : public CGObject_C, public CGUnit {
     public:
@@ -22,12 +23,15 @@ class CGUnit_C : public CGObject_C, public CGUnit {
         // Virtual public member functions
         virtual ~CGUnit_C();
         // TODO
+        virtual int32_t GetModelFileName(const char*& name) const;
+        // TODO
         virtual int32_t CanHighlight();
         virtual int32_t CanBeTargetted();
         // TODO
 
         // Public member functions
         CGUnit_C(uint32_t time, CClientObjCreate& objCreate);
+        CreatureModelDataRec* GetModelData() const;
         void PostInit(uint32_t time, const CClientObjCreate& init, bool a4);
         void PostMovementUpdate(const CClientMoveUpdate& move, int32_t activeMover);
         void SetStorage(uint32_t* storage, uint32_t* saved);

src/ui/CLayoutFrame.cpp

@@ -862,6 +862,13 @@ void CLayoutFrame::SetProtectFlag(uint32_t flag) {
     this->m_flags &= ~0x800;
 }
 
+void CLayoutFrame::SetSize(float width, float height) {
+    this->m_flags &= ~0x8;
+    this->m_width = width;
+    this->m_height = height;
+    this->Resize(0);
+}
+
 void CLayoutFrame::SetWidth(float width) {
     this->m_flags &= ~0x8;
     this->m_width = width;

src/ui/CLayoutFrame.hpp

@@ -49,6 +49,7 @@ class CLayoutFrame {
         virtual bool SetLayoutScale(float scale, bool force);
         virtual void SetWidth(float width);
         virtual void SetHeight(float height);
+        virtual void SetSize(float width, float height);
         virtual float GetWidth();
         virtual float GetHeight();
         virtual void GetSize(float& width, float& height, int32_t a4);

src/ui/CScriptRegionScript.cpp

@@ -219,7 +219,28 @@ int32_t CScriptRegion_SetHeight(lua_State* L) {
 }
 
 int32_t CScriptRegion_SetSize(lua_State* L) {
-    WHOA_UNIMPLEMENTED(0);
+    auto type = CScriptRegion::GetObjectType();
+    auto region = static_cast<CScriptRegion*>(FrameScript_GetObjectThis(L, type));
+
+    if (!region->ProtectedFunctionsAllowed()) {
+        // TODO disallowed logic
+        return 0;
+    }
+
+    if (!lua_isnumber(L, 2) || !lua_isnumber(L, 3)) {
+        luaL_error(L, "Usage: %s:SetSize(width, height)", region->GetDisplayName());
+        return 0;
+    }
+
+    auto ndcWidth = static_cast<float>(lua_tonumber(L, 2)) / (CoordinateGetAspectCompensation() * 1024.0f);
+    auto ddcWidth = NDCToDDCWidth(ndcWidth);
+
+    auto ndcHeight = static_cast<float>(lua_tonumber(L, 3)) / (CoordinateGetAspectCompensation() * 1024.0f);
+    auto ddcHeight = NDCToDDCWidth(ndcHeight);
+
+    region->SetSize(ddcWidth, ddcHeight);
+
+    return 0;
 }
 
 int32_t CScriptRegion_GetSize(lua_State* L) {

src/ui/FrameScript_Object.cpp

@@ -193,6 +193,25 @@ int32_t FrameScript_Object::SetScript(lua_State* L) {
     return 0;
 }
 
+void FrameScript_Object::UnregisterScriptEvent(const char* name) {
+    auto event = FrameScript::s_scriptEventsHash.Ptr(name);
+
+    if (!event) {
+        return;
+    }
+
+    if (event->pendingSignalCount) {
+        for (auto node = event->registerListeners.Head(); node; node = event->registerListeners.Next(node)) {
+            if (node->listener == this) {
+                event->registerListeners.DeleteNode(node);
+                break;
+            }
+        }
+    }
+
+    FrameScript_UnregisterScriptEvent(this, event);
+}
+
 void FrameScript_Object::UnregisterScriptObject(const char* name) {
     auto L = FrameScript_GetContext();
 

src/ui/FrameScript_Object.hpp

@@ -48,6 +48,7 @@ class FrameScript_Object {
         void RegisterScriptObject(const char* name);
         void RunScript(ScriptIx const& script, int32_t argCount, const char* a4);
         int32_t SetScript(lua_State* L);
+        void UnregisterScriptEvent(const char* name);
         void UnregisterScriptObject(const char* name);
 };
 

src/ui/game/BattlenetUI.cpp

@@ -0,0 +1,319 @@
+#include "ui/game/BattlenetUI.hpp"
+#include "client/ClientServices.hpp"
+#include "net/Login.hpp"
+#include "ui/FrameScript.hpp"
+#include "util/Lua.hpp"
+#include "util/Unimplemented.hpp"
+
+namespace BattlenetUI {
+
+int32_t Script_BNGetInfo(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNGetNumFriends(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNGetFriendInfo(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNGetFriendInfoByID(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNGetNumFriendToons(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNGetFriendToonInfo(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNGetToonInfo(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNRemoveFriend(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNSetFriendNote(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNSetSelectedFriend(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNGetSelectedFriend(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNGetNumFriendInvites(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNGetFriendInviteInfo(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNSendFriendInvite(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNSendFriendInviteByID(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNAcceptFriendInvite(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNDeclineFriendInvite(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNReportFriendInvite(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNSetAFK(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNSetDND(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNSetCustomMessage(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNGetCustomMessageTable(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNSetFocus(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNSendWhisper(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNCreateConversation(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNInviteToConversation(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNLeaveConversation(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNSendConversationMessage(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNGetNumConversationMembers(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNGetConversationMemberInfo(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNGetConversationInfo(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNListConversation(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNGetNumBlocked(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNGetBlockedInfo(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNIsBlocked(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNSetBlocked(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNSetSelectedBlock(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNGetSelectedBlock(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNGetNumBlockedToons(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNGetBlockedToonInfo(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNIsToonBlocked(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNSetToonBlocked(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNSetSelectedToonBlock(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNGetSelectedToonBlock(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNReportPlayer(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNConnected(lua_State* L) {
+    // TODO real implementation
+    lua_pushboolean(L, false);
+
+    return 1;
+}
+
+int32_t Script_BNFeaturesEnabledAndConnected(lua_State* L) {
+    // TODO real implementation
+    lua_pushboolean(L, false);
+
+    return 1;
+}
+
+int32_t Script_IsBNLogin(lua_State* L) {
+    if (ClientServices::LoginConnection() && ClientServices::LoginConnection()->GetLoginServerType() == 1) {
+        lua_pushboolean(L, true);
+    } else {
+        lua_pushboolean(L, false);
+    }
+
+    return 1;
+}
+
+int32_t Script_BNFeaturesEnabled(lua_State* L) {
+    // TODO real implementation
+    lua_pushboolean(L, false);
+
+    return 1;
+}
+
+int32_t Script_BNRequestFOFInfo(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNGetNumFOF(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNGetFOFInfo(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNSetMatureLanguageFilter(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNGetMatureLanguageFilter(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNIsSelf(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNIsFriend(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_BNGetMaxPlayersInConversation(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+static FrameScript_Method s_ScriptFunctions[] = {
+    { "BNGetInfo",                      &Script_BNGetInfo },
+    { "BNGetNumFriends",                &Script_BNGetNumFriends },
+    { "BNGetFriendInfo",                &Script_BNGetFriendInfo },
+    { "BNGetFriendInfoByID",            &Script_BNGetFriendInfoByID },
+    { "BNGetNumFriendToons",            &Script_BNGetNumFriendToons },
+    { "BNGetFriendToonInfo",            &Script_BNGetFriendToonInfo },
+    { "BNGetToonInfo",                  &Script_BNGetToonInfo },
+    { "BNRemoveFriend",                 &Script_BNRemoveFriend },
+    { "BNSetFriendNote",                &Script_BNSetFriendNote },
+    { "BNSetSelectedFriend",            &Script_BNSetSelectedFriend },
+    { "BNGetSelectedFriend",            &Script_BNGetSelectedFriend },
+    { "BNGetNumFriendInvites",          &Script_BNGetNumFriendInvites },
+    { "BNGetFriendInviteInfo",          &Script_BNGetFriendInviteInfo },
+    { "BNSendFriendInvite",             &Script_BNSendFriendInvite },
+    { "BNSendFriendInviteByID",         &Script_BNSendFriendInviteByID },
+    { "BNAcceptFriendInvite",           &Script_BNAcceptFriendInvite },
+    { "BNDeclineFriendInvite",          &Script_BNDeclineFriendInvite },
+    { "BNReportFriendInvite",           &Script_BNReportFriendInvite },
+    { "BNSetAFK",                       &Script_BNSetAFK },
+    { "BNSetDND",                       &Script_BNSetDND },
+    { "BNSetCustomMessage",             &Script_BNSetCustomMessage },
+    { "BNGetCustomMessageTable",        &Script_BNGetCustomMessageTable },
+    { "BNSetFocus",                     &Script_BNSetFocus },
+    { "BNSendWhisper",                  &Script_BNSendWhisper },
+    { "BNCreateConversation",           &Script_BNCreateConversation },
+    { "BNInviteToConversation",         &Script_BNInviteToConversation },
+    { "BNLeaveConversation",            &Script_BNLeaveConversation },
+    { "BNSendConversationMessage",      &Script_BNSendConversationMessage },
+    { "BNGetNumConversationMembers",    &Script_BNGetNumConversationMembers },
+    { "BNGetConversationMemberInfo",    &Script_BNGetConversationMemberInfo },
+    { "BNGetConversationInfo",          &Script_BNGetConversationInfo },
+    { "BNListConversation",             &Script_BNListConversation },
+    { "BNGetNumBlocked",                &Script_BNGetNumBlocked },
+    { "BNGetBlockedInfo",               &Script_BNGetBlockedInfo },
+    { "BNIsBlocked",                    &Script_BNIsBlocked },
+    { "BNSetBlocked",                   &Script_BNSetBlocked },
+    { "BNSetSelectedBlock",             &Script_BNSetSelectedBlock },
+    { "BNGetSelectedBlock",             &Script_BNGetSelectedBlock },
+    { "BNGetNumBlockedToons",           &Script_BNGetNumBlockedToons },
+    { "BNGetBlockedToonInfo",           &Script_BNGetBlockedToonInfo },
+    { "BNIsToonBlocked",                &Script_BNIsToonBlocked },
+    { "BNSetToonBlocked",               &Script_BNSetToonBlocked },
+    { "BNSetSelectedToonBlock",         &Script_BNSetSelectedToonBlock },
+    { "BNGetSelectedToonBlock",         &Script_BNGetSelectedToonBlock },
+    { "BNReportPlayer",                 &Script_BNReportPlayer },
+    { "BNConnected",                    &Script_BNConnected },
+    { "BNFeaturesEnabledAndConnected",  &Script_BNFeaturesEnabledAndConnected },
+    { "IsBNLogin",                      &Script_IsBNLogin },
+    { "BNFeaturesEnabled",              &Script_BNFeaturesEnabled },
+    { "BNRequestFOFInfo",               &Script_BNRequestFOFInfo },
+    { "BNGetNumFOF",                    &Script_BNGetNumFOF },
+    { "BNGetFOFInfo",                   &Script_BNGetFOFInfo },
+    { "BNSetMatureLanguageFilter",      &Script_BNSetMatureLanguageFilter },
+    { "BNGetMatureLanguageFilter",      &Script_BNGetMatureLanguageFilter },
+    { "BNIsSelf",                       &Script_BNIsSelf },
+    { "BNIsFriend",                     &Script_BNIsFriend },
+    { "BNGetMaxPlayersInConversation",  &Script_BNGetMaxPlayersInConversation },
+};
+
+}
+
+void BattlenetUI_RegisterScriptFunctions() {
+    for (auto& func : BattlenetUI::s_ScriptFunctions) {
+        FrameScript_RegisterFunction(func.name, func.method);
+    }
+}

src/ui/game/BattlenetUI.hpp

@@ -0,0 +1,6 @@
+#ifndef UI_GAME_BATTLENET_UI_HPP
+#define UI_GAME_BATTLENET_UI_HPP
+
+void BattlenetUI_RegisterScriptFunctions();
+
+#endif

src/ui/game/CGGameUI.cpp

@@ -1,11 +1,13 @@
 #include "ui/game/CGGameUI.hpp"
 #include "client/Client.hpp"
+#include "console/CVar.hpp"
 #include "object/Client.hpp"
 #include "ui/CScriptObject.hpp"
 #include "ui/FrameXML.hpp"
 #include "ui/Key.hpp"
 #include "ui/game/ActionBarScript.hpp"
 #include "ui/game/BattlefieldInfoScript.hpp"
+#include "ui/game/BattlenetUI.hpp"
 #include "ui/game/CGCharacterModelBase.hpp"
 #include "ui/game/CGCooldown.hpp"
 #include "ui/game/CGDressUpModelFrame.hpp"
@@ -17,6 +19,8 @@
 #include "ui/game/CharacterInfoScript.hpp"
 #include "ui/game/GMTicketInfoScript.hpp"
 #include "ui/game/GameScript.hpp"
+#include "ui/game/PartyInfoScript.hpp"
+#include "ui/game/RaidInfoScript.hpp"
 #include "ui/game/ScriptEvents.hpp"
 #include "ui/game/TradeInfoScript.hpp"
 #include "ui/game/Types.hpp"
@@ -54,6 +58,7 @@ void LoadScriptFunctions() {
     // TODO
 
     ActionBarRegisterScriptFunctions();
+    PartyInfoRegisterScriptFunctions();
 
     // TODO
 
@@ -69,9 +74,12 @@ void LoadScriptFunctions() {
 
     // TODO
 
-    GMTicketInfoRegisterScriptFunctions();
+    RaidInfoRegisterScriptFunctions();
 
     // TODO
+
+    GMTicketInfoRegisterScriptFunctions();
+    BattlenetUI_RegisterScriptFunctions();
 }
 
 void CGGameUI::EnterWorld() {
@@ -121,6 +129,7 @@ void CGGameUI::Initialize() {
 
     LoadScriptFunctions();
     ScriptEventsRegisterEvents();
+    CGGameUI::RegisterGameCVars();
 
     // TODO
 
@@ -232,3 +241,47 @@ void CGGameUI::RegisterFrameFactories() {
     FrameXML_RegisterFactory("TabardModel", &CGTabardModelFrame::Create, false);
     FrameXML_RegisterFactory("QuestPOIFrame", &CGQuestPOIFrame::Create, false);
 }
+
+void CGGameUI::RegisterGameCVars() {
+    // TODO
+
+    CVar::Register("enableCombatText", "Whether to show floating combat text", 0x10, "1", nullptr, GAME);
+    CVar::Register("combatTextFloatMode", "The combat text float mode", 0x10, "1", nullptr, GAME);
+    CVar::Register("fctCombatState", nullptr, 0x10, "0", nullptr, GAME);
+    CVar::Register("fctDodgeParryMiss", nullptr, 0x10, "0", nullptr, GAME);
+    CVar::Register("fctDamageReduction", nullptr, 0x10, "0", nullptr, GAME);
+    CVar::Register("fctRepChanges", nullptr, 0x10, "0", nullptr, GAME);
+    CVar::Register("fctReactives", nullptr, 0x10, "0", nullptr, GAME);
+    CVar::Register("fctFriendlyHealers", nullptr, 0x10, "0", nullptr, GAME);
+    CVar::Register("fctComboPoints", nullptr, 0x10, "0", nullptr, GAME);
+    CVar::Register("fctLowManaHealth", nullptr, 0x10, "1", nullptr, GAME);
+    CVar::Register("fctEnergyGains", nullptr, 0x10, "0", nullptr, GAME);
+    CVar::Register("fctPeriodicEnergyGains", nullptr, 0x10, "0", nullptr, GAME);
+    CVar::Register("fctHonorGains", nullptr, 0x10, "0", nullptr, GAME);
+    CVar::Register("fctAuras", nullptr, 0x10, "0", nullptr, GAME);
+    CVar::Register("fctAllSpellMechanics", nullptr, 0x10, "0", nullptr, GAME);
+    CVar::Register("fctSpellMechanics", nullptr, 0x10, "0", nullptr, GAME);
+    CVar::Register("fctSpellMechanicsOther", nullptr, 0x10, "0", nullptr, GAME);
+
+    CVar::Register("xpBarText", "Whether the XP bar shows the numeric experience value", 0x10, "0", nullptr, GAME);
+
+    CVar::Register("playerStatusText", "Whether the player portrait shows numeric health/mana values", 0x10, "0", nullptr, GAME);
+    CVar::Register("petStatusText", "Whether the pet portrait shows numeric health/mana values", 0x10, "0", nullptr, GAME);
+    CVar::Register("partyStatusText", "Whether the party portraits shows numeric health/mana values", 0x10, "0", nullptr, GAME);
+    CVar::Register("targetStatusText", "Whether the target portrait shows numeric health/mana values", 0x10, "0", nullptr, GAME);
+    CVar::Register("statusTextPercentage", "Whether numeric health/mana values are shown as raw values or percentages", 0x10, "0", nullptr, GAME);
+
+    CVar::Register("showPartyBackground", "Show a background behind party members", 0x10, "0", nullptr, GAME);
+    CVar::Register("partyBackgroundOpacity", "The opacity of the party background", 0x10, "0.5", nullptr, GAME);
+    CVar::Register("hidePartyInRaid", "Whether to hide the party UI while in a raid", 0x10, "0", nullptr, GAME);
+    CVar::Register("showPartyPets", "Whether to show pets in the party UI", 0x20, "1", nullptr, GAME);
+    CVar::Register("showRaidRange", "Show range indicator in raid UI", 0x20, "0", nullptr, GAME);
+
+    CVar::Register("showArenaEnemyFrames", "Show arena enemy frames while in an Arena", 0x20, "1", nullptr, GAME);
+    CVar::Register("showArenaEnemyCastbar", "Show the spell enemies are casting on the Arena Enemy frames", 0x20, "1", nullptr, GAME);
+    CVar::Register("showArenaEnemyPets", "Show the enemy team's pets on the ArenaEnemy frames", 0x20, "1", nullptr, GAME);
+
+    CVar::Register("fullSizeFocusFrame", "Increases the size of the focus frame to that of the target frame", 0x20, "0", nullptr, GAME);
+
+    // TODO
+}

src/ui/game/CGGameUI.hpp

@@ -23,6 +23,7 @@ class CGGameUI {
         static int32_t IsRaidMember(const WOWGUID& guid);
         static int32_t IsRaidMemberOrPet(const WOWGUID& guid);
         static void RegisterFrameFactories();
+        static void RegisterGameCVars();
 
     private:
         static WOWGUID s_currentObjectTrack;

src/ui/game/CGPartyInfo.cpp

@@ -0,0 +1,15 @@
+#include "ui/game/CGPartyInfo.hpp"
+
+WOWGUID CGPartyInfo::m_members[4];
+
+uint32_t CGPartyInfo::NumMembers() {
+    uint32_t count = 0;
+
+    for (auto& member : CGPartyInfo::m_members) {
+        if (member != 0) {
+            count++;
+        }
+    }
+
+    return count;
+}

src/ui/game/CGPartyInfo.hpp

@@ -0,0 +1,16 @@
+#ifndef UI_GAME_C_G_PARTY_INFO_HPP
+#define UI_GAME_C_G_PARTY_INFO_HPP
+
+#include "util/GUID.hpp"
+
+class CGPartyInfo {
+    public:
+        // Public static functions
+        static uint32_t NumMembers();
+
+    private:
+        // Private static variables
+        static WOWGUID m_members[];
+};
+
+#endif

src/ui/game/CGRaidInfo.cpp

@@ -0,0 +1,7 @@
+#include "ui/game/CGRaidInfo.hpp"
+
+uint32_t CGRaidInfo::s_numMembers;
+
+uint32_t CGRaidInfo::NumMembers() {
+    return CGRaidInfo::s_numMembers;
+}

src/ui/game/CGRaidInfo.hpp

@@ -0,0 +1,16 @@
+#ifndef UI_GAME_C_G_RAID_INFO_HPP
+#define UI_GAME_C_G_RAID_INFO_HPP
+
+#include <cstdint>
+
+class CGRaidInfo {
+    public:
+        // Public static functions
+        static uint32_t NumMembers();
+
+    private:
+        // Private static variables
+        static uint32_t s_numMembers;
+};
+
+#endif

src/ui/game/GameScript.cpp

@@ -206,7 +206,22 @@ int32_t Script_GetCVarBool(lua_State* L) {
 }
 
 int32_t Script_GetCVarDefault(lua_State* L) {
-    WHOA_UNIMPLEMENTED(0);
+    if (!lua_isstring(L, 1)) {
+        luaL_error(L, "Usage: GetCVarDefault(\"cvar\")");
+        return 0;
+    }
+
+    auto varName = lua_tostring(L, 1);
+    auto var = CVar::LookupRegistered(varName);
+
+    if (!var || (var->m_flags & 0x40)) {
+        luaL_error(L, "Couldn't find CVar named '%s'", varName);
+        return 0;
+    }
+
+    lua_pushstring(L, var->GetDefaultValue());
+
+    return 1;
 }
 
 int32_t Script_GetCVarMin(lua_State* L) {

src/ui/game/PartyInfoScript.cpp

@@ -0,0 +1,130 @@
+#include "ui/game/PartyInfoScript.hpp"
+#include "ui/FrameScript.hpp"
+#include "ui/game/CGPartyInfo.hpp"
+#include "util/Lua.hpp"
+#include "util/Unimplemented.hpp"
+
+namespace {
+
+int32_t Script_GetNumPartyMembers(lua_State* L) {
+    lua_pushnumber(L, CGPartyInfo::NumMembers());
+
+    return 1;
+}
+
+int32_t Script_GetRealNumPartyMembers(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_GetPartyMember(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_GetPartyLeaderIndex(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_IsPartyLeader(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_IsRealPartyLeader(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_LeaveParty(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_GetLootMethod(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_SetLootMethod(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_GetLootThreshold(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_SetLootThreshold(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_SetPartyAssignment(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_ClearPartyAssignment(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_GetPartyAssignment(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_SilenceMember(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_UnSilenceMember(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_SetOptOutOfLoot(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_GetOptOutOfLoot(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_CanChangePlayerDifficulty(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_ChangePlayerDifficulty(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_IsPartyLFG(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_HasLFGRestrictions(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+}
+
+static FrameScript_Method s_ScriptFunctions[] = {
+    { "GetNumPartyMembers",         &Script_GetNumPartyMembers },
+    { "GetRealNumPartyMembers",     &Script_GetRealNumPartyMembers },
+    { "GetPartyMember",             &Script_GetPartyMember },
+    { "GetPartyLeaderIndex",        &Script_GetPartyLeaderIndex },
+    { "IsPartyLeader",              &Script_IsPartyLeader },
+    { "IsRealPartyLeader",          &Script_IsRealPartyLeader },
+    { "LeaveParty",                 &Script_LeaveParty },
+    { "GetLootMethod",              &Script_GetLootMethod },
+    { "SetLootMethod",              &Script_SetLootMethod },
+    { "GetLootThreshold",           &Script_GetLootThreshold },
+    { "SetLootThreshold",           &Script_SetLootThreshold },
+    { "SetPartyAssignment",         &Script_SetPartyAssignment },
+    { "ClearPartyAssignment",       &Script_ClearPartyAssignment },
+    { "GetPartyAssignment",         &Script_GetPartyAssignment },
+    { "SilenceMember",              &Script_SilenceMember },
+    { "UnSilenceMember",            &Script_UnSilenceMember },
+    { "SetOptOutOfLoot",            &Script_SetOptOutOfLoot },
+    { "GetOptOutOfLoot",            &Script_GetOptOutOfLoot },
+    { "CanChangePlayerDifficulty",  &Script_CanChangePlayerDifficulty },
+    { "ChangePlayerDifficulty",     &Script_ChangePlayerDifficulty },
+    { "IsPartyLFG",                 &Script_IsPartyLFG },
+    { "HasLFGRestrictions",         &Script_HasLFGRestrictions },
+};
+
+void PartyInfoRegisterScriptFunctions() {
+    for (auto& func : s_ScriptFunctions) {
+        FrameScript_RegisterFunction(func.name, func.method);
+    }
+}

src/ui/game/PartyInfoScript.hpp

@@ -0,0 +1,6 @@
+#ifndef UI_GAME_PARTY_INFO_SCRIPT_HPP
+#define UI_GAME_PARTY_INFO_SCRIPT_HPP
+
+void PartyInfoRegisterScriptFunctions();
+
+#endif

src/ui/game/RaidInfoScript.cpp

@@ -0,0 +1,120 @@
+#include "ui/game/RaidInfoScript.hpp"
+#include "ui/FrameScript.hpp"
+#include "ui/game/CGRaidInfo.hpp"
+#include "util/Lua.hpp"
+#include "util/Unimplemented.hpp"
+
+namespace {
+
+int32_t Script_GetNumRaidMembers(lua_State* L) {
+    lua_pushnumber(L, CGRaidInfo::NumMembers());
+
+    return 1;
+}
+
+int32_t Script_GetRealNumRaidMembers(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_GetRaidRosterInfo(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_SetRaidRosterSelection(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_GetRaidRosterSelection(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_IsRaidLeader(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_IsRealRaidLeader(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_IsRaidOfficer(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_SetRaidSubgroup(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_SwapRaidSubgroup(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_ConvertToRaid(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_PromoteToLeader(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_PromoteToAssistant(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_DemoteAssistant(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_SetRaidTarget(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_GetRaidTargetIndex(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_DoReadyCheck(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_ConfirmReadyCheck(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_GetReadyCheckTimeLeft(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+int32_t Script_GetReadyCheckStatus(lua_State* L) {
+    WHOA_UNIMPLEMENTED(0);
+}
+
+}
+
+static FrameScript_Method s_ScriptFunctions[] = {
+    { "GetNumRaidMembers",          &Script_GetNumRaidMembers },
+    { "GetRealNumRaidMembers",      &Script_GetRealNumRaidMembers },
+    { "GetRaidRosterInfo",          &Script_GetRaidRosterInfo },
+    { "SetRaidRosterSelection",     &Script_SetRaidRosterSelection },
+    { "GetRaidRosterSelection",     &Script_GetRaidRosterSelection },
+    { "IsRaidLeader",               &Script_IsRaidLeader },
+    { "IsRealRaidLeader",           &Script_IsRealRaidLeader },
+    { "IsRaidOfficer",              &Script_IsRaidOfficer },
+    { "SetRaidSubgroup",            &Script_SetRaidSubgroup },
+    { "SwapRaidSubgroup",           &Script_SwapRaidSubgroup },
+    { "ConvertToRaid",              &Script_ConvertToRaid },
+    { "PromoteToLeader",            &Script_PromoteToLeader },
+    { "PromoteToAssistant",         &Script_PromoteToAssistant },
+    { "DemoteAssistant",            &Script_DemoteAssistant },
+    { "SetRaidTarget",              &Script_SetRaidTarget },
+    { "GetRaidTargetIndex",         &Script_GetRaidTargetIndex },
+    { "DoReadyCheck",               &Script_DoReadyCheck },
+    { "ConfirmReadyCheck",          &Script_ConfirmReadyCheck },
+    { "GetReadyCheckTimeLeft",      &Script_GetReadyCheckTimeLeft },
+    { "GetReadyCheckStatus",        &Script_GetReadyCheckStatus },
+};
+
+void RaidInfoRegisterScriptFunctions() {
+    for (auto& func : s_ScriptFunctions) {
+        FrameScript_RegisterFunction(func.name, func.method);
+    }
+}

src/ui/game/RaidInfoScript.hpp

@@ -0,0 +1,6 @@
+#ifndef UI_GAME_RAID_INFO_SCRIPT_HPP
+#define UI_GAME_RAID_INFO_SCRIPT_HPP
+
+void RaidInfoRegisterScriptFunctions();
+
+#endif

src/ui/simple/CSimpleFrameScript.cpp

@@ -3,6 +3,8 @@
 #include "ui/CBackdropGenerator.hpp"
 #include "ui/FrameScript.hpp"
 #include "ui/FrameXML.hpp"
+#include "ui/simple/CSimpleFont.hpp"
+#include "ui/simple/CSimpleFontString.hpp"
 #include "ui/simple/CSimpleFrame.hpp"
 #include "ui/simple/CSimpleTexture.hpp"
 #include "util/Lua.hpp"
@@ -85,7 +87,73 @@ int32_t CSimpleFrame_CreateTexture(lua_State* L) {
 }
 
 int32_t CSimpleFrame_CreateFontString(lua_State* L) {
-    WHOA_UNIMPLEMENTED(0);
+    auto type = CSimpleFrame::GetObjectType();
+    auto frame = static_cast<CSimpleFrame*>(FrameScript_GetObjectThis(L, type));
+
+    const char* name = nullptr;
+    if (lua_isstring(L, 2)) {
+        name = lua_tostring(L, 2);
+    }
+
+    int32_t drawlayer = DRAWLAYER_ARTWORK;
+    if (lua_isstring(L, 3)) {
+        auto drawlayerStr = lua_tostring(L, 3);
+        StringToDrawLayer(drawlayerStr, drawlayer);
+    }
+
+    CSimpleFont* inheritFont = nullptr;
+    XMLNode* inheritNode = nullptr;
+
+    if (lua_type(L, 4) == LUA_TSTRING) {
+        auto inheritName = lua_tostring(L, 4);
+
+        inheritFont = CSimpleFont::GetFont(inheritName, 0);
+
+        if (!inheritFont) {
+            const char* tainted;
+            bool locked;
+            inheritNode = FrameXML_AcquireHashNode(inheritName, tainted, locked);
+
+            if (!inheritNode) {
+                luaL_error(L, "%s:CreateFontString(): Couldn't find inherited node \"%s\"", frame->GetDisplayName(), inheritName);
+                return 0;
+            }
+
+            if (locked) {
+                luaL_error(L, "%s:CreateFontString(): Recursively inherited node \"%s\"", frame->GetDisplayName(), inheritName);
+                return 0;
+            }
+        }
+    }
+
+    // TODO CDataAllocator::GetData
+    auto string = STORM_NEW(CSimpleFontString)(frame, drawlayer, true);
+
+    if (name && *name) {
+        string->SetName(name);
+    }
+
+    if (inheritFont) {
+        string->SetFontObject(inheritFont);
+    } else if (inheritNode) {
+        CStatus status;
+
+        string->LoadXML(inheritNode, &status);
+        string->PostLoadXML(inheritNode, &status);
+
+        auto inheritName = lua_tostring(L, 4);
+        FrameXML_ReleaseHashNode(inheritName);
+    }
+
+    // TODO anim related logic?
+
+    if (!string->lua_registered) {
+        string->RegisterScriptObject(nullptr);
+    }
+
+    lua_rawgeti(L, LUA_REGISTRYINDEX, string->lua_objectRef);
+
+    return 1;
 }
 
 int32_t CSimpleFrame_GetBoundsRect(lua_State* L) {
@@ -221,7 +289,19 @@ int32_t CSimpleFrame_RegisterEvent(lua_State* L) {
 }
 
 int32_t CSimpleFrame_UnregisterEvent(lua_State* L) {
-    WHOA_UNIMPLEMENTED(0);
+    auto type = CSimpleFrame::GetObjectType();
+    auto frame = static_cast<CSimpleFrame*>(FrameScript_GetObjectThis(L, type));
+
+    if (!lua_isstring(L, 2)) {
+        luaL_error(L, "Usage: %s:UnregisterEvent(\"event\")", frame->GetDisplayName());
+        return 0;
+    }
+
+    auto eventName = lua_tostring(L, 2);
+
+    frame->UnregisterScriptEvent(eventName);
+
+    return 0;
 }
 
 int32_t CSimpleFrame_RegisterAllEvents(lua_State* L) {

src/world/CWorld.cpp

@@ -12,6 +12,7 @@ uint32_t CWorld::s_enables;
 uint32_t CWorld::s_enables2;
 uint32_t CWorld::s_gameTimeFixed;
 float CWorld::s_gameTimeSec;
+CM2Scene* CWorld::s_m2Scene;
 uint32_t CWorld::s_tickTimeFixed;
 uint32_t CWorld::s_tickTimeMs;
 float CWorld::s_tickTimeSec;
@@ -66,6 +67,10 @@ float CWorld::GetGameTimeSec() {
     return CWorld::s_gameTimeSec;
 }
 
+CM2Scene* CWorld::GetM2Scene() {
+    return CWorld::s_m2Scene;
+}
+
 uint32_t CWorld::GetTickTimeFixed() {
     return CWorld::s_tickTimeFixed;
 }
@@ -97,8 +102,6 @@ void CWorld::Initialize() {
     CWorld::s_gameTimeFixed = 0;
     CWorld::s_gameTimeSec = 0.0f;
 
-    // TODO
-
     if (GxCaps().m_shaderTargets[GxSh_Pixel] > GxShPS_none) {
         CWorld::s_enables |= Enables::Enable_PixelShader;
     }
@@ -109,6 +112,10 @@ void CWorld::Initialize() {
 
     // TODO
 
+    CWorld::s_m2Scene = M2CreateScene();
+
+    // TODO
+
     uint32_t m2Flags = M2GetCacheFlags();
     CShaderEffect::InitShaderSystem(
         (m2Flags & 0x8) != 0,

src/world/CWorld.hpp

@@ -7,6 +7,7 @@
 #include <cstdint>
 
 class CM2Model;
+class CM2Scene;
 class Weather;
 
 class CWorld {
@@ -58,6 +59,7 @@ class CWorld {
         static float GetCurTimeSec();
         static uint32_t GetGameTimeFixed();
         static float GetGameTimeSec();
+        static CM2Scene* GetM2Scene();
         static uint32_t GetTickTimeFixed();
         static uint32_t GetTickTimeMs();
         static float GetTickTimeSec();
@@ -72,6 +74,7 @@ class CWorld {
         static float s_curTimeSec;
         static uint32_t s_gameTimeFixed;
         static float s_gameTimeSec;
+        static CM2Scene* s_m2Scene;
         static uint32_t s_tickTimeFixed;
         static uint32_t s_tickTimeMs;
         static float s_tickTimeSec;