Merge pull request 'Add GameObjectTypeWrapper Get_Display_Name() function' (#2) from text-id into main

Reviewed-on: http://gitea.drewcav.com/drew/FoCAPI/pulls/2

FoCAPI.vcxproj

@@ -166,6 +166,8 @@
     <ClCompile Include="functions\functions.cpp" />
     <ClCompile Include="functions\file_io.cpp" />
     <ClCompile Include="functions\players.cpp" />
+    <ClCompile Include="functions\screen_text.cpp" />
+    <ClCompile Include="functions\game_object_type.cpp" />
   </ItemGroup>
   <ItemGroup>
     <None Include="powrprof.def" />

FoCAPI.vcxproj.filters

@@ -50,12 +50,18 @@
     <ClCompile Include="functions\players.cpp">
       <Filter>Source Files\Functions</Filter>
     </ClCompile>
+    <ClCompile Include="functions\screen_text.cpp">
+      <Filter>Source Files\Functions</Filter>
+    </ClCompile>
     <ClCompile Include="functions\file_io.cpp">
       <Filter>Source Files\Functions</Filter>
     </ClCompile>
     <ClCompile Include="functions\functions.cpp">
       <Filter>Source Files\Functions</Filter>
     </ClCompile>
+    <ClCompile Include="functions\game_object_type.cpp">
+      <Filter>Source Files\Functions</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <None Include="powrprof.def">

README.md

@@ -5,9 +5,22 @@ A powrprof.dll hook which adds custom Lua functions to Forces of Corruption.
 ## Usage
 
 Drop powrprof.dll and MinHooks.x64.dll into the `/corruption/` folder of your Empire at War installation.
-Currently only works with the debug kit `StarWarsI.exe`; `StarWarsG.exe` support is coming soon.
+Works with both the debug kit `StarWarsI.exe` and client version `StarWarsG.exe` of the Steam version.
+Not supported on disc / GoG versions (sorry).
 
 ## Functions
 
-- Global `WriteToFile(str a, str b)` - Appends a line of text `b` to the file name `a` in the game directory.
+- Global `WriteToFile(file, text)` - Appends a line of text specified file in the game directory.
+  - Parameter `file` string - The file name to append.
+  - Parameter `text` string - The text line to append.
 - Global `Get_All_Players()` - Returns a 1-based Lua table of all active players, iterable with `ipairs()`. Each entry is the same PlayerWrapper type returned by `Find_Player()`.
+- Global `Add_Tutorial_Text(key, text, duration, r, g, b, a)` - Adds a line to the tutorial text pane.
+  - Parameter `key`: string - The key used to identify this line, later can be used to update or remove the text.
+  - Parameter `text`: string - The text to display.
+  - Parameter `duration` number? - The duration to display the text. Default: -1 (infinite)
+  - Parameter `r` number? - The red color component. Default: 1
+  - Parameter `g` number? - The green color component. Default: 1
+  - Parameter `b` number? - The blue color component. Default: 1
+  - Parameter `a` number? - The alpha component. Default: 1
+- Global `Remove_Tutorial_Text(key)` - Removes the line associated with the key.
+  - Parameter `key` string - The key used to identify the line when it was added.

functions/functions.cpp

@@ -10,4 +10,5 @@
 void Register_All(lua_State* L) {
     Register_FileIO(L);
     Register_Players(L);
+    Register_ScreenText(L);
 }

functions/functions.h

@@ -10,3 +10,8 @@ void Register_All(lua_State* L);
 // Each checks its own required function pointer guards before registering.
 void Register_FileIO(lua_State* L);
 void Register_Players(lua_State* L);
+void Register_ScreenText(lua_State* L);
+
+// Called from the GameObjectTypeWrapper ctor hook (not from Register_All).
+// Registers custom member functions on each wrapper instance.
+void Register_GOTMembers(void* wrapper);

functions/game_object_type.cpp

@@ -0,0 +1,92 @@
+#include "functions.h"
+#include "../lua_hook.h"
+#include <windows.h>
+#include <string>
+#include <cstring>
+
+// Offset of SmartPtr<GameObjectTypeClass> within GameObjectTypeWrapper.
+// SmartPtr stores the raw pointer as its first member.
+static constexpr int OFFSET_OBJECT = 0x70;
+
+// MSVC std::wstring layout (x64, MSVC 14.0+).
+// Used to read the wstring* returned by GameTextClass::Get.
+struct MSVCWString {
+    union {
+        wchar_t buf[8];    // SSO buffer (up to 7 wchars + null)
+        wchar_t* ptr;      // heap pointer when capacity > 7
+    };
+    size_t size;
+    size_t capacity;       // <= 7 means SSO, > 7 means heap
+
+    const wchar_t* c_str() const { return (capacity <= 7) ? buf : ptr; }
+};
+
+// Custom member function registered on GameObjectTypeWrapper.
+// Signature matches LuaTable* __thiscall (LuaScriptClass*, LuaTable*).
+// On x64 this is the standard calling convention: this_wrapper in RCX, script in RDX, params in R8.
+static void* Lua_Get_Display_Name(void* this_wrapper, void* /*script*/, void* /*params*/)
+{
+    // 1. Get GameObjectTypeClass* from SmartPtr at offset 0x70
+    void* got_class = *(void**)((char*)this_wrapper + OFFSET_OBJECT);
+    if (!got_class)
+        return nullptr;
+
+    // 2. Get the text ID string (e.g. "TEXT_UNIT_X_WING") via Get_Text_Name_ID.
+    //    The game's function constructs a std::string into our buffer via copy-ctor.
+    //    Assumes shared CRT (both DLL and game link to vcruntime140.dll dynamically).
+    std::string text_id;
+    pfn_get_text_name_id(got_class, &text_id);
+
+    // 3. Resolve the localized display name via TheGameText.Get(text_id, false).
+    //    Returns a pointer to an internal wstring (the translated text).
+    MSVCWString* display_wstr = (MSVCWString*)pfn_game_text_get(g_the_game_text, &text_id, false);
+    if (!display_wstr)
+        return nullptr;
+
+    // 4. Convert the wide display name to a narrow (UTF-8) string for Lua.
+    const wchar_t* wdata = display_wstr->c_str();
+    int wlen = (int)display_wstr->size;
+
+    int narrow_len = WideCharToMultiByte(CP_UTF8, 0, wdata, wlen, nullptr, 0, nullptr, nullptr);
+    if (narrow_len <= 0)
+        return nullptr;
+
+    std::string narrow(narrow_len, '\0');
+    WideCharToMultiByte(CP_UTF8, 0, wdata, wlen, &narrow[0], narrow_len, nullptr, nullptr);
+
+    // 5. Create a LuaString (LuaValue<string>, 0x78 bytes) and return it.
+    void* lua_value = ::operator new(0x78);
+    if (!lua_value)
+        return nullptr;
+    memset(lua_value, 0, 0x78);
+    pfn_lua_value_ctor(lua_value, &narrow);
+
+    return pfn_return_variable(this_wrapper, lua_value);
+}
+
+void Register_GOTMembers(void* wrapper)
+{
+    if (!pfn_lmfw_ctor || !pfn_register_member)
+        return;
+    if (!pfn_get_text_name_id || !pfn_game_text_get || !g_the_game_text)
+        return;
+    if (!pfn_lua_value_ctor || !pfn_return_variable)
+        return;
+
+    // Allocate a LuaMemberFunctionWrapper<GameObjectTypeWrapper> (0x88 bytes).
+    void* lmfw = ::operator new(0x88);
+    if (!lmfw) return;
+    memset(lmfw, 0, 0x88);
+
+    // Build the 16-byte pointer-to-member-function structure.
+    // MSVC x64 multiple-inheritance PMF: [8-byte func addr][8-byte this-adjustment].
+    // this-adjustment is 0 (our function expects the full GameObjectTypeWrapper*).
+    alignas(8) uint8_t pmf[16] = {};
+    *(uintptr_t*)pmf = (uintptr_t)&Lua_Get_Display_Name;
+
+    // Construct the LuaMemberFunctionWrapper via the game's ctor.
+    pfn_lmfw_ctor(lmfw, wrapper, pmf, false);
+
+    // Register as a member callable via wrapper.Get_Display_Name()
+    pfn_register_member(wrapper, "Get_Display_Name", lmfw);
+}

functions/screen_text.cpp

@@ -0,0 +1,66 @@
+#include "functions.h"
+#include "../lua_hook.h"
+#include <windows.h>
+#include <string>
+
+// Add_Tutorial_Text(key, text [, duration [, r, g, b, a]])
+// duration defaults to -1 (perpetual). r/g/b/a default to 1.0 (white, opaque).
+// The color pointer must be non-null: the game copies 16 bytes from it unconditionally
+// before its own null check, so we always pass a valid buffer.
+static int L_Add_Tutorial_Text(lua_State* L)
+{
+    const char* key  = pfn_tostring(L, 1);
+    const char* text = pfn_tostring(L, 2);
+    if (!key || !text)
+        return 0;
+
+    float duration = -1.0f;
+    float color[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
+
+    if (pfn_tonumber)
+    {
+        double arg3 = pfn_tonumber(L, 3);
+        if (arg3 != 0.0) duration = (float)arg3;
+
+        double r = pfn_tonumber(L, 4);
+        double g = pfn_tonumber(L, 5);
+        double b = pfn_tonumber(L, 6);
+        double a = pfn_tonumber(L, 7);
+        if (r != 0.0 || g != 0.0 || b != 0.0 || a != 0.0)
+        {
+            color[0] = (float)r;
+            color[1] = (float)g;
+            color[2] = (float)b;
+            color[3] = (float)a;
+        }
+    }
+
+    int wlen = MultiByteToWideChar(CP_ACP, 0, text, -1, nullptr, 0);
+    std::wstring wtext(wlen - 1, L'\0');
+    MultiByteToWideChar(CP_ACP, 0, text, -1, &wtext[0], wlen);
+
+    pfn_add_tutorial_text(g_command_bar, &wtext, (char*)key, duration, 0, false, color);
+
+    return 0;
+}
+
+// Remove_Tutorial_Text(key)
+static int L_Remove_Tutorial_Text(lua_State* L)
+{
+    const char* key = pfn_tostring(L, 1);
+    if (!key)
+        return 0;
+
+    pfn_remove_tutorial_text(g_command_bar, (char*)key);
+
+    return 0;
+}
+
+void Register_ScreenText(lua_State* L)
+{
+    if (!pfn_add_tutorial_text || !pfn_remove_tutorial_text || !g_command_bar)
+        return;
+
+    register_global(L, "Add_Tutorial_Text",    L_Add_Tutorial_Text);
+    register_global(L, "Remove_Tutorial_Text", L_Remove_Tutorial_Text);
+}

lua_hook.cpp

@@ -17,7 +17,18 @@ void*                  g_player_list             = nullptr;
 fn_PlayerWrapperCreate pfn_player_wrapper_create = nullptr;
 fn_GetScriptFromState  pfn_get_script_from_state = nullptr;
 fn_MapVarToLua         pfn_map_var_to_lua        = nullptr;
+fn_AddTutorialText     pfn_add_tutorial_text     = nullptr;
+fn_RemoveTutorialText  pfn_remove_tutorial_text  = nullptr;
+void*                  g_command_bar             = nullptr;
 fn_DebugPrint          pfn_debug_print           = nullptr;
+fn_RegisterMember      pfn_register_member       = nullptr;
+fn_LuaValueCtor        pfn_lua_value_ctor        = nullptr;
+fn_ReturnVariable      pfn_return_variable       = nullptr;
+fn_GotWrapperCtor      real_got_wrapper_ctor     = nullptr;
+fn_LmfwCtor            pfn_lmfw_ctor             = nullptr;
+fn_GetTextNameId       pfn_get_text_name_id      = nullptr;
+fn_GameTextGet         pfn_game_text_get         = nullptr;
+void*                  g_the_game_text           = nullptr;
 
 void register_global(lua_State* L, const char* name, lua_CFunction fn) {
 	pfn_pushstring(L, name);
@@ -25,6 +36,13 @@ void register_global(lua_State* L, const char* name, lua_CFunction fn) {
 	pfn_settable(L, LUA_GLOBALSINDEX);
 }
 
+// Fired every time the game constructs a GameObjectTypeWrapper
+static void* Hook_GOTWrapperCtor(void* this_wrapper) {
+	void* result = real_got_wrapper_ctor(this_wrapper);
+	Register_GOTMembers(this_wrapper);
+	return result;
+}
+
 // Fired every time the game creates a new Lua state
 static lua_State* Hook_lua_open() {
 	lua_State* L = real_lua_open();
@@ -72,9 +90,31 @@ bool LuaHook_Init() {
 		pfn_map_var_to_lua        = (fn_MapVarToLua)(base + rvas->map_var_to_lua);
 	}
 
+	if (rvas->command_bar && rvas->add_tutorial_text && rvas->remove_tutorial_text) {
+		g_command_bar            = (void*)(base + rvas->command_bar);
+		pfn_add_tutorial_text    = (fn_AddTutorialText)(base + rvas->add_tutorial_text);
+		pfn_remove_tutorial_text = (fn_RemoveTutorialText)(base + rvas->remove_tutorial_text);
+	}
+
 	if (rvas->debug_print)
 		pfn_debug_print = (fn_DebugPrint)(base + rvas->debug_print);
 
+	if (rvas->register_member)
+		pfn_register_member = (fn_RegisterMember)(base + rvas->register_member);
+	if (rvas->lua_value_ctor)
+		pfn_lua_value_ctor = (fn_LuaValueCtor)(base + rvas->lua_value_ctor);
+	if (rvas->return_variable)
+		pfn_return_variable = (fn_ReturnVariable)(base + rvas->return_variable);
+
+	if (rvas->the_game_text)
+		g_the_game_text = (void*)(base + rvas->the_game_text);
+	if (rvas->get_string)
+		pfn_game_text_get = (fn_GameTextGet)(base + rvas->get_string);
+	if (rvas->got_get_text_name_id)
+		pfn_get_text_name_id = (fn_GetTextNameId)(base + rvas->got_get_text_name_id);
+	if (rvas->got_lmfw_ctor)
+		pfn_lmfw_ctor = (fn_LmfwCtor)(base + rvas->got_lmfw_ctor);
+
 	if (rvas->lua_newtable && rvas->lua_rawseti) {
 		pfn_newtable = (fn_lua_newtable)(base + rvas->lua_newtable);
 		pfn_rawseti  = (fn_lua_rawseti)(base + rvas->lua_rawseti);
@@ -94,6 +134,18 @@ bool LuaHook_Init() {
 		return false;
 	}
 
+	// Hook GameObjectTypeWrapper constructor to register custom member functions
+	if (rvas->got_wrapper_ctor && rvas->got_lmfw_ctor &&
+		pfn_register_member && pfn_lmfw_ctor &&
+		pfn_get_text_name_id && pfn_game_text_get && g_the_game_text &&
+		pfn_lua_value_ctor && pfn_return_variable)
+	{
+		void* got_ctor_target = (void*)(base + rvas->got_wrapper_ctor);
+		if (MH_CreateHook(got_ctor_target, &Hook_GOTWrapperCtor, (void**)&real_got_wrapper_ctor) == MH_OK) {
+			MH_EnableHook(got_ctor_target);
+		}
+	}
+
 	return true;
 }
 

lua_hook.h

@@ -17,7 +17,18 @@ typedef void*        (*fn_GetPlayerByIndex)(void*, int);          // PlayerListC
 typedef void*        (*fn_PlayerWrapperCreate)(void*, void*);     // PlayerWrapper::Create(PlayerClass*, LuaScriptClass*)
 typedef void*        (*fn_GetScriptFromState)(lua_State*);        // LuaScriptClass::Get_Script_From_State
 typedef void         (*fn_MapVarToLua)(lua_State*, void*);        // LuaScriptClass::Map_Var_To_Lua (static)
+typedef void         (*fn_AddTutorialText)(void*, void*, const char*, float, unsigned int, bool, void*); // CommandBarClass::Add_Tutorial_Text (inner)
+typedef void         (*fn_RemoveTutorialText)(void*, const char*);                                      // CommandBarClass::Remove_Tutorial_Text
 typedef void         (*fn_DebugPrint)(const char*);               // Debug_Print
+// Scripting internals (LuaUserVar) -- usable by any wrapper module
+typedef void         (*fn_RegisterMember)(void* uservar, const char* name, void* fn_ptr); // LuaUserVar::Register_Member
+typedef void         (*fn_LuaValueCtor)(void* lua_value, void* basic_string_ptr);         // LuaValue<>::LuaValue<>(basic_string<>*)
+typedef void*        (*fn_ReturnVariable)(void* uservar, void* lua_var);                  // LuaUserVar::Return_Variable(LuaVar*) -> LuaTable*
+// Game Object Type Wrapper internals
+typedef void*        (*fn_GotWrapperCtor)(void* this_wrapper);                            // GameObjectTypeWrapper::GameObjectTypeWrapper()
+typedef void*        (*fn_LmfwCtor)(void* lmfw, void* wrapper, void* pmf, bool use_maps); // LuaMemberFunctionWrapper<GameObjectTypeWrapper>::ctor
+typedef void*        (*fn_GetTextNameId)(void* got_class, void* out_string);              // GameObjectTypeClass::Get_Text_Name_ID() -- returns via hidden out-param
+typedef void*        (*fn_GameTextGet)(void* game_text, void* text_id_str, bool insert);  // GameTextClass::Get(basic_string*, bool) -- returns wstring*
 
 // Resolved function pointers (defined in lua_hook.cpp)
 extern fn_lua_open            real_lua_open;
@@ -33,7 +44,18 @@ extern void*                  g_player_list;
 extern fn_PlayerWrapperCreate pfn_player_wrapper_create;
 extern fn_GetScriptFromState  pfn_get_script_from_state;
 extern fn_MapVarToLua         pfn_map_var_to_lua;
+extern fn_AddTutorialText     pfn_add_tutorial_text;
+extern fn_RemoveTutorialText  pfn_remove_tutorial_text;
+extern void*                  g_command_bar;
 extern fn_DebugPrint          pfn_debug_print;
+extern fn_RegisterMember      pfn_register_member;
+extern fn_LuaValueCtor        pfn_lua_value_ctor;
+extern fn_ReturnVariable      pfn_return_variable;
+extern fn_GotWrapperCtor      real_got_wrapper_ctor;
+extern fn_LmfwCtor            pfn_lmfw_ctor;
+extern fn_GetTextNameId       pfn_get_text_name_id;
+extern fn_GameTextGet         pfn_game_text_get;
+extern void*                  g_the_game_text;
 
 constexpr int LUA_GLOBALSINDEX = -10001;
 

minhook/include/MinHook.h

@@ -1,185 +0,0 @@
-/*
- *  MinHook - The Minimalistic API Hooking Library for x64/x86
- *  Copyright (C) 2009-2017 Tsuda Kageyu.
- *  All rights reserved.
- *
- *  Redistribution and use in source and binary forms, with or without
- *  modification, are permitted provided that the following conditions
- *  are met:
- *
- *   1. Redistributions of source code must retain the above copyright
- *      notice, this list of conditions and the following disclaimer.
- *   2. Redistributions in binary form must reproduce the above copyright
- *      notice, this list of conditions and the following disclaimer in the
- *      documentation and/or other materials provided with the distribution.
- *
- *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- *  TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- *  PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER
- *  OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- *  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- *  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- *  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#pragma once
-
-#if !(defined _M_IX86) && !(defined _M_X64) && !(defined __i386__) && !(defined __x86_64__)
-    #error MinHook supports only x86 and x64 systems.
-#endif
-
-#include <windows.h>
-
-// MinHook Error Codes.
-typedef enum MH_STATUS
-{
-    // Unknown error. Should not be returned.
-    MH_UNKNOWN = -1,
-
-    // Successful.
-    MH_OK = 0,
-
-    // MinHook is already initialized.
-    MH_ERROR_ALREADY_INITIALIZED,
-
-    // MinHook is not initialized yet, or already uninitialized.
-    MH_ERROR_NOT_INITIALIZED,
-
-    // The hook for the specified target function is already created.
-    MH_ERROR_ALREADY_CREATED,
-
-    // The hook for the specified target function is not created yet.
-    MH_ERROR_NOT_CREATED,
-
-    // The hook for the specified target function is already enabled.
-    MH_ERROR_ENABLED,
-
-    // The hook for the specified target function is not enabled yet, or already
-    // disabled.
-    MH_ERROR_DISABLED,
-
-    // The specified pointer is invalid. It points the address of non-allocated
-    // and/or non-executable region.
-    MH_ERROR_NOT_EXECUTABLE,
-
-    // The specified target function cannot be hooked.
-    MH_ERROR_UNSUPPORTED_FUNCTION,
-
-    // Failed to allocate memory.
-    MH_ERROR_MEMORY_ALLOC,
-
-    // Failed to change the memory protection.
-    MH_ERROR_MEMORY_PROTECT,
-
-    // The specified module is not loaded.
-    MH_ERROR_MODULE_NOT_FOUND,
-
-    // The specified function is not found.
-    MH_ERROR_FUNCTION_NOT_FOUND
-}
-MH_STATUS;
-
-// Can be passed as a parameter to MH_EnableHook, MH_DisableHook,
-// MH_QueueEnableHook or MH_QueueDisableHook.
-#define MH_ALL_HOOKS NULL
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-    // Initialize the MinHook library. You must call this function EXACTLY ONCE
-    // at the beginning of your program.
-    MH_STATUS WINAPI MH_Initialize(VOID);
-
-    // Uninitialize the MinHook library. You must call this function EXACTLY
-    // ONCE at the end of your program.
-    MH_STATUS WINAPI MH_Uninitialize(VOID);
-
-    // Creates a hook for the specified target function, in disabled state.
-    // Parameters:
-    //   pTarget     [in]  A pointer to the target function, which will be
-    //                     overridden by the detour function.
-    //   pDetour     [in]  A pointer to the detour function, which will override
-    //                     the target function.
-    //   ppOriginal  [out] A pointer to the trampoline function, which will be
-    //                     used to call the original target function.
-    //                     This parameter can be NULL.
-    MH_STATUS WINAPI MH_CreateHook(LPVOID pTarget, LPVOID pDetour, LPVOID *ppOriginal);
-
-    // Creates a hook for the specified API function, in disabled state.
-    // Parameters:
-    //   pszModule   [in]  A pointer to the loaded module name which contains the
-    //                     target function.
-    //   pszProcName [in]  A pointer to the target function name, which will be
-    //                     overridden by the detour function.
-    //   pDetour     [in]  A pointer to the detour function, which will override
-    //                     the target function.
-    //   ppOriginal  [out] A pointer to the trampoline function, which will be
-    //                     used to call the original target function.
-    //                     This parameter can be NULL.
-    MH_STATUS WINAPI MH_CreateHookApi(
-        LPCWSTR pszModule, LPCSTR pszProcName, LPVOID pDetour, LPVOID *ppOriginal);
-
-    // Creates a hook for the specified API function, in disabled state.
-    // Parameters:
-    //   pszModule   [in]  A pointer to the loaded module name which contains the
-    //                     target function.
-    //   pszProcName [in]  A pointer to the target function name, which will be
-    //                     overridden by the detour function.
-    //   pDetour     [in]  A pointer to the detour function, which will override
-    //                     the target function.
-    //   ppOriginal  [out] A pointer to the trampoline function, which will be
-    //                     used to call the original target function.
-    //                     This parameter can be NULL.
-    //   ppTarget    [out] A pointer to the target function, which will be used
-    //                     with other functions.
-    //                     This parameter can be NULL.
-    MH_STATUS WINAPI MH_CreateHookApiEx(
-        LPCWSTR pszModule, LPCSTR pszProcName, LPVOID pDetour, LPVOID *ppOriginal, LPVOID *ppTarget);
-
-    // Removes an already created hook.
-    // Parameters:
-    //   pTarget [in] A pointer to the target function.
-    MH_STATUS WINAPI MH_RemoveHook(LPVOID pTarget);
-
-    // Enables an already created hook.
-    // Parameters:
-    //   pTarget [in] A pointer to the target function.
-    //                If this parameter is MH_ALL_HOOKS, all created hooks are
-    //                enabled in one go.
-    MH_STATUS WINAPI MH_EnableHook(LPVOID pTarget);
-
-    // Disables an already created hook.
-    // Parameters:
-    //   pTarget [in] A pointer to the target function.
-    //                If this parameter is MH_ALL_HOOKS, all created hooks are
-    //                disabled in one go.
-    MH_STATUS WINAPI MH_DisableHook(LPVOID pTarget);
-
-    // Queues to enable an already created hook.
-    // Parameters:
-    //   pTarget [in] A pointer to the target function.
-    //                If this parameter is MH_ALL_HOOKS, all created hooks are
-    //                queued to be enabled.
-    MH_STATUS WINAPI MH_QueueEnableHook(LPVOID pTarget);
-
-    // Queues to disable an already created hook.
-    // Parameters:
-    //   pTarget [in] A pointer to the target function.
-    //                If this parameter is MH_ALL_HOOKS, all created hooks are
-    //                queued to be disabled.
-    MH_STATUS WINAPI MH_QueueDisableHook(LPVOID pTarget);
-
-    // Applies all queued changes in one go.
-    MH_STATUS WINAPI MH_ApplyQueued(VOID);
-
-    // Translates the MH_STATUS to its name as a string.
-    const char * WINAPI MH_StatusToString(MH_STATUS status);
-
-#ifdef __cplusplus
-}
-#endif

rvas.h

@@ -12,14 +12,31 @@ struct LuaRVAs {
     uintptr_t lua_newtable;
     uintptr_t lua_rawseti;
 
+    // --- Scripts ---
+    uintptr_t get_script_from_state;   // LuaScriptClass::Get_Script_From_State (static)
+    uintptr_t map_var_to_lua;          // LuaScriptClass::Map_Var_To_Lua (member)
+    uintptr_t register_member;         // LuaUserVar::Register_Member(char*, LuaVar*)
+    uintptr_t lua_value_ctor;          // LuaValue<>::LuaValue<>(basic_string<>*)
+    uintptr_t return_variable;         // LuaUserVar::Return_Variable(LuaVar*)
+
+    // --- TheGameText ---
+	uintptr_t the_game_text;		  // TheGameText global object (data, not a function)
+	uintptr_t get_string;			  // GameTextClass::Get(char*, bool)
+
     // --- Players ---
     uintptr_t get_player_by_index;     // PlayerListClass::Get_Player_By_Index
     uintptr_t player_list;             // PlayerList global object (data, not a function)
     uintptr_t player_wrapper_create;   // PlayerWrapper::Create (static)
 
-    // --- Scripts ---
+    // --- Screen Text ---
-    uintptr_t get_script_from_state;   // LuaScriptClass::Get_Script_From_State (static)
+    uintptr_t command_bar;             // TheCommandBar global object (data, not a function)
-    uintptr_t map_var_to_lua;          // LuaScriptClass::Map_Var_To_Lua (member)
+    uintptr_t add_tutorial_text;       // CommandBarClass::Add_Tutorial_Text (inner overload: wstring*, char*, float, uint, bool, RGBAClass*)
+    uintptr_t remove_tutorial_text;    // CommandBarClass::Remove_Tutorial_Text(char*)
+
+    // --- Game Object Type Wrapper ---
+    uintptr_t got_wrapper_ctor;        // GameObjectTypeWrapper::GameObjectTypeWrapper()
+    uintptr_t got_get_text_name_id;    // GameObjectTypeClass::Get_Text_Name_ID()
+    uintptr_t got_lmfw_ctor;           // LuaMemberFunctionWrapper<GameObjectTypeWrapper>::LuaMemberFunctionWrapper<>()
 
     // --- Debug ---
     uintptr_t debug_print;             // Debug_Print(char*)
@@ -37,14 +54,31 @@ constexpr LuaRVAs RVAs_StarWarsI = {
     0x12AC460, // lua_newtable
     0x12ACD70, // lua_rawseti
 
+    // --- Scripts ---
+    0x0537BB0, // LuaScriptClass::Get_Script_From_State
+    0x0536FE0, // LuaScriptClass::Map_Var_To_Lua
+    0x0046f51, // LuaUserVar::Register_Member
+    0x004df5e, // LuaValue<>::LuaValue<>
+    0x0058887, // LuaUserVar::Return_Variable
+
+    // --- TheGameText ---
+    0x18578b0, // TheGameText global object
+    0x002b4cc, // GameTextClass::Get
+
     // --- Players ---
     0x000b0e1, // PlayerListClass::Get_Player_By_Index
     0x1913158, // PlayerList global object
     0x0F12010, // PlayerWrapper::Create
 
-    // --- Scripts ---
+    // --- Screen Text ---
-    0x0537BB0, // LuaScriptClass::Get_Script_From_State
+    0x1916b80, // TheCommandBar global object
-    0x0536FE0, // LuaScriptClass::Map_Var_To_Lua
+    0x003c83a, // CommandBarClass::Add_Tutorial_Text inner
+    0x006e1eb, // CommandBarClass::Remove_Tutorial_Text
+
+    // --- Game Object Type Wrapper ---
+    0x004f6c9, // GameObjectTypeWrapper::GameObjectTypeWrapper()
+	0x007b747, // GameObjectTypeClass::Get_Text_Name_ID()
+    0x0f08450, // LuaMemberFunctionWrapper<GameObjectTypeWrapper>::ctor
 
     // --- Debug ---
     0x0476AE0, // Debug_Print
@@ -59,18 +93,35 @@ constexpr LuaRVAs RVAs_StarWarsG = {
     0x07b9a60, // lua_settable
     0x07b9cc0, // lua_tostring
     0x07b9bc0, // lua_tonumber
-    0x07b9140, // lua_newtable (TODO)
+    0x07b9140, // lua_newtable
-    0x07b9820, // lua_rawseti (TODO)
+    0x07b9820, // lua_rawseti
-
-    // --- Players ---
-    0x0294bc0, // PlayerListClass::Get_Player_By_Index (TODO)
-    0x0a16fd0, // PlayerList global object (TODO)
-    0x06019f0, // PlayerWrapper::Create (TODO)
 
     // --- Scripts ---
-    0x0245790, // LuaScriptClass::Get_Script_From_State (TODO)
+    0x0245790, // LuaScriptClass::Get_Script_From_State
-    0x0247700, // LuaScriptClass::Map_Var_To_Lua (TODO)
+    0x0247700, // LuaScriptClass::Map_Var_To_Lua
+    0,         // LuaUserVar::Register_Member  -- not mapped
+    0,         // LuaString::LuaString         -- not mapped
+    0,         // LuaUserVar::Return_Variable  -- not mapped
+
+    // --- TheGameText ---
+    0, // TheGameText global object
+    0, // GameTextClass::Get
+
+    // --- Players ---
+    0x0294bc0, // PlayerListClass::Get_Player_By_Index
+    0x0a16fd0, // PlayerList global object
+    0x06019f0, // PlayerWrapper::Create
+
+    // --- Screen Text ---
+    0x0b27f60, // TheCommandBar global object
+    0x02dfd10, // CommandBarClass::Add_Tutorial_Text inner
+    0x02ff290, // CommandBarClass::Remove_Tutorial_Text
+
+    // --- Game Object Type Wrapper ---
+    0,         // GameObjectTypeWrapper::GameObjectTypeWrapper() -- not mapped
+    0,         // GameObjectTypeClass::Get_Text_Name_ID()        -- not mapped
+    0,         // LuaMemberFunctionWrapper<GameObjectTypeWrapper>::ctor -- not mapped
 
     // --- Debug ---
-    0,         // Debug_Print (TODO)
+    0,         // Debug_Print (not mapped)
 };