switch to mat-dash

Author: matcool

.gitmodules

@@ -11,3 +11,6 @@
 [submodule "libraries/cocos-headers"]
 	path = libraries/cocos-headers
 	url = https://github.com/HJfod/cocos-headers.git
+[submodule "libraries/mat-dash"]
+	path = libraries/mat-dash
+	url = [email protected]:matcool/mat-dash.git

CMakeLists.txt

@@ -3,6 +3,8 @@ set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 
+include(libraries/mat-dash/include.cmake)
+
 project(replay-bot)
 
 find_file(WINDOWS_HEADER windows.h)

libraries/mat-dash

@@ -1,9 +1,10 @@
 #include "includes.h"
 #include <fstream>
+#include <matdash.hpp>
 
 #include "hooks.hpp"
 
-DWORD WINAPI thread_entry(void* module) {
+void mod_main(HMODULE module) {
 #ifdef SHOW_CONSOLE
     AllocConsole();
     std::ofstream conout("CONOUT$", std::ios::out);
@@ -12,14 +13,10 @@ DWORD WINAPI thread_entry(void* module) {
     std::cin.rdbuf(conin.rdbuf());
 #endif
 
-    DisableThreadLibraryCalls(cast<HMODULE>(module));
-
-    MH_Initialize();
+    DisableThreadLibraryCalls(module);
 
     Hooks::init();
 
-    MH_EnableHook(MH_ALL_HOOKS);
-
 #ifdef SHOW_CONSOLE
     std::getline(std::cin, std::string());
     MH_Uninitialize();
@@ -28,14 +25,6 @@ DWORD WINAPI thread_entry(void* module) {
     FreeConsole();
     FreeLibraryAndExitThread(cast<HMODULE>(module), 0);
 #endif
-
-    return 0;
 }
 
-BOOL APIENTRY DllMain(HMODULE module, DWORD reason, LPVOID reserved) {
-    if (reason == DLL_PROCESS_ATTACH) {
-        auto handle = CreateThread(0, 0, thread_entry, module, 0, 0);
-        if (handle) CloseHandle(handle);
-    }
-    return TRUE;
-}
+#include <matdash/boilerplate.hpp>

src/dllmain.cpp

@@ -3,49 +3,45 @@
 #include "overlay_layer.hpp"
 #include "recorder.hpp"
 #include <chrono>
+#include <matdash/minhook.hpp>
 
-auto add_gd_hook(uintptr_t offset, void* hook, void* orig) {
-    return MH_CreateHook(cast<void*>(gd::base + offset), hook, cast<void**>(orig));
+auto cocos(const char* symbol) {
+    static auto mod = GetModuleHandleA("libcocos2d.dll");
+    return GetProcAddress(mod, symbol);
 }
-#define ADD_GD_HOOK(o, f) add_gd_hook(o, f##_H, &f)
-
-auto add_cocos_hook(const char* symbol, void* hook, void* orig) {
-    return MH_CreateHook(GetProcAddress(GetModuleHandleA("libcocos2d.dll"), symbol), hook, cast<void**>(orig));
-}
-#define ADD_COCOS_HOOK(o, f) add_cocos_hook(o, f##_H, &f)
 
 void Hooks::init() {
-    ADD_COCOS_HOOK("?update@CCScheduler@cocos2d@@UAEXM@Z", CCScheduler_update);
-    ADD_COCOS_HOOK("?dispatchKeyboardMSG@CCKeyboardDispatcher@cocos2d@@QAE_NW4enumKeyCodes@2@_N@Z", CCKeyboardDispatcher_dispatchKeyboardMSG);
-    ADD_GD_HOOK(0x20ddd0, CheckpointObject_create);
+    add_hook<&CCScheduler_update, Thiscall>(cocos("?update@CCScheduler@cocos2d@@UAEXM@Z"));
+    add_hook<&CCKeyboardDispatcher_dispatchKeyboardMSG>(cocos("?dispatchKeyboardMSG@CCKeyboardDispatcher@cocos2d@@QAE_NW4enumKeyCodes@2@_N@Z"));
+    add_hook<&CheckpointObject_create, Optfastcall>(gd::base + 0x20ddd0);
 
-    ADD_GD_HOOK(0x2029C0, PlayLayer::update);
+    add_hook<&PlayLayer::update, Thiscall>(gd::base + 0x2029C0);
 
-    ADD_GD_HOOK(0x111500, PlayLayer::pushButton);
-    ADD_GD_HOOK(0x111660, PlayLayer::releaseButton);
-    ADD_GD_HOOK(0x20BF00, PlayLayer::resetLevel);
+    add_hook<&PlayLayer::pushButton>(gd::base + 0x111500);
+    add_hook<&PlayLayer::releaseButton>(gd::base + 0x111660);
+    add_hook<&PlayLayer::resetLevel>(gd::base + 0x20BF00);
 
-    ADD_GD_HOOK(0x20D3C0, PlayLayer::pauseGame);
+    add_hook<&PlayLayer::pauseGame>(gd::base + 0x20D3C0);
 
-    ADD_GD_HOOK(0x1FD3D0, PlayLayer::levelComplete);
-    ADD_GD_HOOK(0x20D810, PlayLayer::onQuit);
-    ADD_GD_HOOK(0x1E60E0, PlayLayer::onEditor);
+    add_hook<&PlayLayer::levelComplete>(gd::base + 0x1FD3D0);
+    add_hook<&PlayLayer::onQuit>(gd::base + 0x20D810);
+    add_hook<&PauseLayer_onEditor>(gd::base + 0x1E60E0);
 
-    ADD_GD_HOOK(0x205460, PlayLayer::updateVisiblity);
+    add_hook<&PlayLayer::updateVisiblity>(gd::base + 0x205460);
 
-    ADD_GD_HOOK(0x1E4620, PauseLayer_init);
+    add_hook<&PauseLayer_init>(gd::base + 0x1E4620);
 
-    ADD_GD_HOOK(0x1f4ff0, PlayerObject_ringJump);
-    ADD_GD_HOOK(0xef0e0, GameObject_activateObject);
-    ADD_GD_HOOK(0x10ed50, GJBaseGameLayer_bumpPlayer);
+    add_hook<&PlayerObject_ringJump>(gd::base + 0x1f4ff0);
+    add_hook<&GameObject_activateObject>(gd::base + 0xef0e0);
+    add_hook<&GJBaseGameLayer_bumpPlayer>(gd::base + 0x10ed50);
 }
 
 // yes these are global, too lazy to store them in replaysystem or smth
 // not like theyre used anywhere else atm
 bool g_disable_render = false;
 float g_left_over = 0.f;
 
-void __fastcall Hooks::CCScheduler_update_H(CCScheduler* self, int, float dt) {
+void Hooks::CCScheduler_update(CCScheduler* self, float dt) {
     auto& rs = ReplaySystem::get_instance();
     if (rs.recorder.m_recording || rs.is_playing() || rs.is_recording() && gd::GameManager::sharedState()->getPlayLayer()) {
         const auto fps = rs.get_replay().get_fps();
@@ -54,19 +50,19 @@ void __fastcall Hooks::CCScheduler_update_H(CCScheduler* self, int, float dt) {
         const float target_dt = 1.f / fps / speedhack;
 
         if (!rs.real_time_mode)
-            return CCScheduler_update(self, target_dt);
+            return orig<&CCScheduler_update, Thiscall>(self, target_dt);
 
         // todo: find ways to disable more render stuff
         g_disable_render = false;
 
         unsigned times = static_cast<int>((dt + g_left_over) / target_dt);
         if (dt == 0.f)
-            return CCScheduler_update(self, target_dt);
+            return orig<&CCScheduler_update, Thiscall>(self, target_dt);
         auto start = std::chrono::high_resolution_clock::now();
         for (unsigned i = 0; i < times; ++i) {
             // if (i == times - 1)
             //     g_disable_render = false;
-            CCScheduler_update(self, target_dt);
+            orig<&CCScheduler_update, Thiscall>(self, target_dt);
             using namespace std::literals;
             if (std::chrono::high_resolution_clock::now() - start > 33.333ms) {
                 times = i + 1;
@@ -75,39 +71,39 @@ void __fastcall Hooks::CCScheduler_update_H(CCScheduler* self, int, float dt) {
         }
         g_left_over += dt - target_dt * times;
     } else {
-        CCScheduler_update(self, dt);
+        orig<&CCScheduler_update, Thiscall>(self, dt);
     }
 }
 
-void __fastcall Hooks::CCKeyboardDispatcher_dispatchKeyboardMSG_H(CCKeyboardDispatcher* self, int, int key, bool down) {
+void Hooks::CCKeyboardDispatcher_dispatchKeyboardMSG(CCKeyboardDispatcher* self, int key, bool down) {
     auto& rs = ReplaySystem::get_instance();
     if (down) {
         auto play_layer = gd::GameManager::sharedState()->getPlayLayer();
         if (rs.is_recording() && play_layer) {
             if (key == 'C') {
                 rs.set_frame_advance(false);
-                PlayLayer::update_H(play_layer, 0, 1.f / rs.get_default_fps());
+                PlayLayer::update(play_layer, 1.f / rs.get_default_fps());
                 rs.set_frame_advance(true);
             } else if (key == 'F') {
                 rs.set_frame_advance(false);
             } else if (key == 'R') {
-                PlayLayer::resetLevel_H(play_layer, 0);
+                PlayLayer::resetLevel(play_layer);
             }
         }
     }
-    CCKeyboardDispatcher_dispatchKeyboardMSG(self, key, down);
+    orig<&CCKeyboardDispatcher_dispatchKeyboardMSG>(self, key, down);
 }
 
 float g_xpos_time = 0.f;
 
-void __fastcall Hooks::PlayLayer::update_H(gd::PlayLayer* self, int, float dt) {
+void Hooks::PlayLayer::update(gd::PlayLayer* self, float dt) {
     auto& rs = ReplaySystem::get_instance();
     if (rs.get_frame_advance()) return;
     if (rs.is_playing()) rs.handle_playing();
     if (rs.recorder.m_recording) {
         rs.recorder.handle_recording(self, dt);
     }
-    update(self, dt);
+    orig<&update, Thiscall>(self, dt);
 }
 
 
@@ -120,29 +116,28 @@ bool _player_button_handler(bool hold, bool button) {
     return false;
 }
 
-int __fastcall Hooks::PlayLayer::pushButton_H(gd::PlayLayer* self, int, int idk, bool button) {
-    if (_player_button_handler(true, button)) return 0;
-    return pushButton(self, idk, button);
+void Hooks::PlayLayer::pushButton(gd::PlayLayer* self, int idk, bool button) {
+    if (_player_button_handler(true, button)) return;
+    orig<&pushButton>(self, idk, button);
 }
 
-int __fastcall Hooks::PlayLayer::releaseButton_H(gd::PlayLayer* self, int, int idk, bool button) {
-    if (_player_button_handler(false, button)) return 0;
-    return releaseButton(self, idk, button);
+void Hooks::PlayLayer::releaseButton(gd::PlayLayer* self, int idk, bool button) {
+    if (_player_button_handler(false, button)) return;
+    orig<&releaseButton>(self, idk, button);
 }
 
-int __fastcall Hooks::PlayLayer::resetLevel_H(gd::PlayLayer* self, int) {
-    auto ret = resetLevel(self);
+void Hooks::PlayLayer::resetLevel(gd::PlayLayer* self) {
+    orig<&resetLevel>(self);
     auto& rs = ReplaySystem::get_instance();
     rs.on_reset();
     // from what i've checked rob doesnt store this anywhere, so i have to calculate it again
     if (rs.recorder.m_recording)
         rs.recorder.m_song_start_offset = self->timeForXPos2(
             self->m_player1->m_position.x, self->m_isTestMode) + self->m_levelSettings->m_songStartOffset;
-    return ret;
 }
 
 
-void __fastcall Hooks::PlayLayer::pauseGame_H(gd::PlayLayer* self, int, bool idk) {
+void Hooks::PlayLayer::pauseGame(gd::PlayLayer* self, bool idk) {
     auto addr = cast<void*>(gd::base + 0x20D43C);
     auto& rs = ReplaySystem::get_instance();
     if (rs.is_recording())
@@ -152,39 +147,39 @@ void __fastcall Hooks::PlayLayer::pauseGame_H(gd::PlayLayer* self, int, bool idk
     if (should_patch)
         patch(addr, {0x83, 0xC4, 0x04, 0x90, 0x90});
 
-    pauseGame(self, idk);
+    orig<&pauseGame>(self, idk);
 
     if (should_patch)
         patch(addr, {0xe8, 0x2f, 0x7b, 0xfe, 0xff});
 }
 
 
-CCObject* __fastcall Hooks::CheckpointObject_create_H() {
+CCObject* Hooks::CheckpointObject_create() {
     return CheckpointObjectMod::create();
 }
 
-void* __fastcall Hooks::PlayLayer::levelComplete_H(gd::PlayLayer* self, int) {
+void Hooks::PlayLayer::levelComplete(gd::PlayLayer* self) {
     ReplaySystem::get_instance().reset_state();
-    return levelComplete(self);
+    return orig<&levelComplete>(self);
 }
 
 void _on_exit_level() {
     auto& rs = ReplaySystem::get_instance();
     rs.reset_state();
 }
 
-void* __fastcall Hooks::PlayLayer::onQuit_H(gd::PlayLayer* self, int) {
+void Hooks::PlayLayer::onQuit(gd::PlayLayer* self) {
     _on_exit_level();
-    return onQuit(self);
+    orig<&onQuit>(self);
 }
 
-void* __fastcall Hooks::PlayLayer::onEditor_H(gd::PlayLayer* self, int, void* idk) {
+void Hooks::PauseLayer_onEditor(gd::PauseLayer* self, CCObject* idk) {
     _on_exit_level();
-    return onEditor(self, idk);
+    orig<&PauseLayer_onEditor>(self, idk);
 }
 
-bool __fastcall Hooks::PauseLayer_init_H(gd::PauseLayer* self, int) {
-    if (PauseLayer_init(self)) {
+bool Hooks::PauseLayer_init(gd::PauseLayer* self) {
+    if (orig<&PauseLayer_init>(self)) {
         auto win_size = CCDirector::sharedDirector()->getWinSize();
 
         auto menu = CCMenu::create();
@@ -217,28 +212,28 @@ void _handle_activated_object(bool a, bool b, gd::GameObject* object) {
     }
 }
 
-void __fastcall Hooks::PlayerObject_ringJump_H(gd::PlayerObject* self, int, gd::GameObject* ring) {
+void Hooks::PlayerObject_ringJump(gd::PlayerObject* self, gd::GameObject* ring) {
     bool a = ring->m_hasBeenActivated;
     bool b = ring->m_hasBeenActivatedP2;
-    PlayerObject_ringJump(self, ring);
+    orig<&PlayerObject_ringJump>(self, ring);
     _handle_activated_object(a, b, ring);
 }
 
-void __fastcall Hooks::GameObject_activateObject_H(gd::GameObject* self, int, gd::PlayerObject* player) {
+void Hooks::GameObject_activateObject(gd::GameObject* self, gd::PlayerObject* player) {
     bool a = self->m_hasBeenActivated;
     bool b = self->m_hasBeenActivatedP2;
-    GameObject_activateObject(self, player);
+    orig<&GameObject_activateObject>(self, player);
     _handle_activated_object(a, b, self);
 }
 
-void __fastcall Hooks::GJBaseGameLayer_bumpPlayer_H(gd::GJBaseGameLayer* self, int, gd::PlayerObject* player, gd::GameObject* object) {
+void Hooks::GJBaseGameLayer_bumpPlayer(gd::GJBaseGameLayer* self, gd::PlayerObject* player, gd::GameObject* object) {
     bool a = object->m_hasBeenActivated;
     bool b = object->m_hasBeenActivatedP2;
-    GJBaseGameLayer_bumpPlayer(self, player, object);
+    orig<&GJBaseGameLayer_bumpPlayer>(self, player, object);
     _handle_activated_object(a, b, object);
 }
 
-void __fastcall Hooks::PlayLayer::updateVisiblity_H(gd::PlayLayer* self, int) {
+void Hooks::PlayLayer::updateVisiblity(gd::PlayLayer* self) {
     if (!g_disable_render)
-        updateVisiblity(self);
+        orig<&updateVisiblity>(self);
 }

src/hooks.cpp

@@ -1,43 +1,36 @@
 #pragma once
 #include "includes.h"
 #include <vector>
-
-#define _THISCALL_HOOK(name, ret_type, self_type, ...) \
-inline ret_type(__thiscall* name)(self_type* self, __VA_ARGS__); \
-ret_type __fastcall name##_H(self_type* self, int, __VA_ARGS__);
-
-#define _FASTCALL_HOOK(name, ret_type, ...) \
-inline ret_type(__fastcall* name)(__VA_ARGS__); \
-ret_type __fastcall name##_H(__VA_ARGS__);
+#include <matdash.hpp>
 
 namespace Hooks {
     void init();
 
-    _THISCALL_HOOK(CCScheduler_update, void, CCScheduler, float dt)
-    _THISCALL_HOOK(CCKeyboardDispatcher_dispatchKeyboardMSG, void, CCKeyboardDispatcher, int key, bool down)
-    _FASTCALL_HOOK(CheckpointObject_create, CCObject*)
+    void CCScheduler_update(CCScheduler*, float dt);
+    void CCKeyboardDispatcher_dispatchKeyboardMSG(CCKeyboardDispatcher*, int key, bool down);
+    CCObject* CheckpointObject_create();
 
     namespace PlayLayer {
-        _THISCALL_HOOK(update, void, gd::PlayLayer, float dt)
+        void update(gd::PlayLayer*, float dt);
 
-        _THISCALL_HOOK(pushButton, int, gd::PlayLayer, int, bool)
-        _THISCALL_HOOK(releaseButton, int, gd::PlayLayer, int, bool)
-        _THISCALL_HOOK(resetLevel, int, gd::PlayLayer)
+        void pushButton(gd::PlayLayer*, int, bool);
+        void releaseButton(gd::PlayLayer*, int, bool);
+        void resetLevel(gd::PlayLayer*);
 
-        _THISCALL_HOOK(pauseGame, void, gd::PlayLayer, bool)
+        void pauseGame(gd::PlayLayer*, bool);
 
-        _THISCALL_HOOK(levelComplete, void*, gd::PlayLayer)
+        void levelComplete(gd::PlayLayer*);
         // these are only for stopping recording/playing
         // maybe hook the destructor instead ?
-        _THISCALL_HOOK(onQuit, void*, gd::PlayLayer)
-        _THISCALL_HOOK(onEditor, void*, gd::PlayLayer, void*)
+        void onQuit(gd::PlayLayer*);
 
-        _THISCALL_HOOK(updateVisiblity, void, gd::PlayLayer)
+        void updateVisiblity(gd::PlayLayer*);
     }
 
-    _THISCALL_HOOK(PauseLayer_init, bool, gd::PauseLayer)
+    void PauseLayer_onEditor(gd::PauseLayer*, CCObject*);
+    bool PauseLayer_init(gd::PauseLayer*);
 
-    _THISCALL_HOOK(PlayerObject_ringJump, void, gd::PlayerObject, gd::GameObject* ring)
-    _THISCALL_HOOK(GameObject_activateObject, void, gd::GameObject, gd::PlayerObject* player)
-    _THISCALL_HOOK(GJBaseGameLayer_bumpPlayer, void, gd::GJBaseGameLayer, gd::PlayerObject* player, gd::GameObject* object)
+    void PlayerObject_ringJump(gd::PlayerObject*, gd::GameObject* ring);
+    void GameObject_activateObject(gd::GameObject*, gd::PlayerObject* player);
+    void GJBaseGameLayer_bumpPlayer(gd::GJBaseGameLayer*, gd::PlayerObject* player, gd::GameObject* object);
 }