1.05

Author: maximegmd

src/Image.cpp

@@ -37,6 +37,10 @@ Image::Image()
         spdlog::info("\tResolved to version: 1.04");
         version = MakeVersion(1,4);
         break;
+    case 0x20F87F01:
+        spdlog::info("\tResolved to version: 1.05");
+        version = MakeVersion(1, 5);
+        break;
     default:
         spdlog::error("\tUnknown version, please update the mod");
         break;

src/overlay/Overlay.cpp

@@ -46,7 +46,8 @@ void Overlay::DrawImgui(IDXGISwapChain3* apSwapChain)
 
     ImGui::Begin("Cyber Engine Tweaks");
 
-    if (Options::Get().GameImage.version == Image::MakeVersion(1, 4))
+    if (Options::Get().GameImage.version == Image::MakeVersion(1, 4) ||
+        Options::Get().GameImage.version == Image::MakeVersion(1, 5))
     {
         ImGui::PushItemWidth(600.f);
 

src/reverse/RTTI.h

@@ -34,6 +34,7 @@ struct CRTTIBaseType
 };
 
 struct CClassFunction;
+struct CBaseFunction;
 
 struct CClass : CRTTIBaseType
 {
@@ -50,7 +51,7 @@ struct IRTTISystem
     virtual void sub_3() = 0;
     virtual void sub_4() = 0;
     virtual void sub_5() = 0;
-    virtual void sub_6() = 0;
+    virtual CBaseFunction* GetGlobalFunction(uint64_t aNameHash) = 0;
     virtual void sub_7() = 0;
     virtual void sub_8() = 0;
     virtual void sub_9() = 0;

src/reverse/Scripting.cpp

@@ -5,19 +5,40 @@
 #include <spdlog/spdlog.h>
 
 #include "Engine.h"
+#include "Options.h"
 #include "Pattern.h"
 #include "RTTI.h"
 #include "Utils.h"
 
 using TExec = bool(void* apThis, ScriptArgs* apArgs, Result* apResult, uintptr_t apScriptable);
 auto* RealExec = (TExec*)(0x25FB960 + reinterpret_cast<uintptr_t>(GetModuleHandleA(nullptr)));
 
+struct Unk523
+{
+    int64_t unk0;
+    uint64_t unk8;
+};
+
+struct CScriptableStackFrame
+{
+    int64_t vtbl;
+    int64_t unk8;
+    int64_t unk10;
+    int64_t scriptable18;
+    int64_t scriptable20;
+    int64_t unk28;
+    int64_t args;
+    int32_t argCount;
+    int64_t unk40;
+};
+
 bool Scripting::Execute(const std::string& aCommand, std::string& aReturnMessage)
 {
     const auto argsStart = aCommand.find_first_of('(');
     const auto argsEnd = aCommand.find_first_of(')');
 
     const auto funcName = aCommand.substr(0, argsStart);
+    trim(funcName);
 
     std::string s = aCommand.substr(argsStart + 1, argsEnd - argsStart - 1);
     const std::string delimiter = ",";
@@ -37,33 +58,71 @@ bool Scripting::Execute(const std::string& aCommand, std::string& aReturnMessage
     trim(s);
     redArgs.emplace_back(s.c_str());
 
+    uintptr_t arg0Rtti = 0;
+    uintptr_t argiRtti = 0;
+    uintptr_t ctorOffset = 0;
+    uintptr_t execOffset = 0;
+
+    if (Options::Get().GameImage.version == Image::MakeVersion(1, 4))
+    {
+        arg0Rtti = 0x1442FD030 - 0x140000000;
+        argiRtti = 0x143C62438 - 0x140000000;
+        ctorOffset = 0x140270370 - 0x140000000;
+        execOffset = 0x1402254A0 - 0x140000000;
+    }
+    else if (Options::Get().GameImage.version == Image::MakeVersion(1, 5))
+    {
+        arg0Rtti = 0x1442BC710 - 0x140000000;
+        argiRtti = 0x143C22238 - 0x140000000;
+        ctorOffset = 0x14026F8A0 - 0x140000000;
+        execOffset = 0x1402249F0 - 0x140000000;
+    }
+
     auto* const type = CRTTISystem::Get()->GetType<CClass>(REDString::Hash("cpPlayerSystem"));
     auto* const engine = CGameEngine::Get();
     auto* unk10 = engine->framework->unk10;
 
+    auto func = CRTTISystem::Get()->GetGlobalFunction(REDString::Hash(funcName.c_str()));
+
     const auto scriptable = unk10->GetTypeInstance(type);
 
-    ScriptArgs args{};
-    args.args = redArgs.data();
-    args.argCount = redArgs.size() & 0xFFFFFFFF;
+    uint64_t a1 = *(uintptr_t*)(scriptable + 0x40);
 
-    Result result;
+    Unk523 args[4];
+    args[0].unk0 = *(uintptr_t*)(arg0Rtti + (uintptr_t)GetModuleHandle(nullptr));
+    args[0].unk8 = (uint64_t)&a1;
 
-    if (!RealExec(nullptr, &args, &result, scriptable))
+    for(auto i = 1u; i < redArgs.size(); ++i)
     {
-        aReturnMessage = result.output->ToString();
-        return false;
+        args[i].unk0 = (uintptr_t)(argiRtti + (uintptr_t)GetModuleHandle(nullptr));
+        args[i].unk8 = (uint64_t)&redArgs[i];
     }
 
-    return true;
+    CScriptableStackFrame stack;
+    auto script40 = *(uintptr_t*)(scriptable + 0x40);
+    auto script40100 = *(uintptr_t*)(script40 + 0x100);
+
+    using ctor_t = CScriptableStackFrame * (*)(CScriptableStackFrame* aThis, __int64 aScriptable, Unk523* aArgs,
+        int aArgsCount, __int64 a5, __int64* a6);
+    ctor_t ctor = (ctor_t)(ctorOffset + (uintptr_t)GetModuleHandle(nullptr));
+
+    Result result;
+
+    ctor(&stack, scriptable, args, 3, 0, 0);
+
+    using exec_t = bool (*)(CBaseFunction* aThis, CScriptableStackFrame* stack);
+    exec_t exec = (exec_t)(execOffset + (uintptr_t)GetModuleHandle(nullptr));
+
+    return exec(func, &stack);
 }
 
 Result::Result()
 {
-    static auto* ptr = FindSignature({ 0x4C,0x8D,0x25,0x03,0x63,0xAF,0x02,0x4C
-        ,0x89,0xBC,0x24,0x90,0x01,0x00,0x00,0x66
-        ,0x0F,0x42,0xC1,0x0F,0x29,0xBC,0x24,0x70
-        ,0x01,0x00 }) + 3;
+    static auto* ptr = FindSignature({
+        0x48, 0x89, 0xB4, 0x24, 0xD8, 0x01, 0x00, 0x00, 0xB9,
+        0x05, 0x00, 0x00, 0x00, 0x4C, 0x89, 0xA4, 0x24, 0xA0,
+        0x01, 0x00, 0x00, 0x66, 0x3B, 0xC1, 0x4C, 0x89, 0xAC,
+        0x24, 0x98, 0x01, 0x00, 0x00, 0x4C, 0x8D, 0x25 }) + 0x24;
 
     output = reinterpret_cast<REDString*>(ptr + *reinterpret_cast<int32_t*>(ptr) + 4);
 }

src/string_initalizer_patch.cpp

@@ -1,8 +1,4 @@
-#include <windows.h>
-
 #include "Image.h"
-#include <utility>
-#include <cstring>
 #include <spdlog/spdlog.h>
 #include <cstdint>