Merge pull request DK22Pac#262 from ICantReadYourMind/master

gennariarmando · web-flow · commit bf87d44dc815 · 2025-09-23T17:45:46.000+02:00
Update patch, injector, SpriteLoader, and GTA3 CPad
diff --git a/injector/injector.hpp b/injector/injector.hpp
@@ -28,6 +28,7 @@
 #include <windows.h>
 #include <cstdint>
 #include <cstdio>
+#include <type_traits>
 #include "gvm/gvm.hpp"
 #include "..\shared\DynAddress.h"
 /*
@@ -61,7 +62,24 @@
 
 namespace injector
 {
+/*
+*   valid_pointer_type
+*       Concept to check if T is either a pointer or an integer that fits in a pointer
+*/
+    template <class T>
+    concept valid_pointer_type = std::is_scalar_v<T> && sizeof(T) <= sizeof(uintptr_t) && !std::is_floating_point_v<T>;
 
+/*
+*   to_void_pointer
+*       Function to convert a valid_pointer_type to a void*
+*/
+    template <valid_pointer_type T>
+    inline void* to_void_pointer(T x)
+    {
+		void* p = nullptr;
+		std::memcpy(&p, std::addressof(x), sizeof(T));
+        return p;
+	}
 
 /*
  *  auto_pointer 
@@ -79,8 +97,9 @@ union auto_pointer
     public:
         auto_pointer() : p(0)                          {}
         auto_pointer(const auto_pointer& x) : p(x.p)  {}
-        explicit auto_pointer(void* x)    : p(x)       {}
-        explicit auto_pointer(uint32_t x) : a(x)       {}
+
+        template<valid_pointer_type T>
+        explicit auto_pointer(T x) : p(to_void_pointer(x))       {}
 
         bool is_null() const { return this->p != nullptr; }
 
@@ -117,13 +136,10 @@ union basic_memory_pointer
     public:
         basic_memory_pointer()                      : p(nullptr)    {}
         basic_memory_pointer(std::nullptr_t)        : p(nullptr)    {}
-        basic_memory_pointer(uintptr_t x)           : a(x)          {}
+        template<valid_pointer_type T>
+        basic_memory_pointer(T x)                   : p(to_void_pointer(x))          {}
         basic_memory_pointer(const auto_pointer& x) : p(x.p)        {}
         basic_memory_pointer(const basic_memory_pointer& rhs) : p(rhs.p)  {}
-
-        template<class T>
-        basic_memory_pointer(T* x) : p((void*)x) {}
-
         
 
         
@@ -136,8 +152,9 @@ union basic_memory_pointer
         // Gets the raw pointer, without translation (casted to T*)
         template<class T> T* get_raw() const    { return auto_pointer(p); }
         
-        // This type can get assigned from void* and uintptr_t
-        basic_memory_pointer& operator=(void* x)		{ return p = x, *this; }
+        // This type can get assigned from any pointer and uintptr_t
+        template<valid_pointer_type T>
+        basic_memory_pointer& operator=(T x) { return p = to_void_pointer(x), *this; }
         basic_memory_pointer& operator=(uintptr_t x)	{ return a = x, *this; }
         
         /* Arithmetic */
@@ -222,13 +239,10 @@ union memory_pointer_tr
             : p(rhs.p)
         {}  // Constructs from my own type, copy constructor
         
-        memory_pointer_tr(uintptr_t x)
-            : p(memory_pointer(x).get())
-        {}  // Constructs from a integer, translating the address
-      
-        memory_pointer_tr(void* x)
-            : p(memory_pointer(x).get())
-        {}  // Constructs from a void pointer, translating the address
+        template<valid_pointer_type T>
+        memory_pointer_tr(T x)
+            : p(memory_pointer(to_void_pointer(x)).get())
+        {}  // Constructs from any pointer or integer, translating the address
         
         // Just to be method-compatible with basic_memory_pointer ...
         auto_pointer         get()      { return auto_pointer(p);     }
diff --git a/plugin_III/game_III/CPad.h b/plugin_III/game_III/CPad.h
@@ -18,22 +18,18 @@ class CPad {
     CControllerState PCTempKeyState;
     CControllerState PCTempJoyState;
     CControllerState PCTempMouseState;
-    short wordD2;
+    short Phase;
     short Mode;
     short ShakeDur;
-    char ShakeFreq;
-    char byteD9;
-    char byteDA;
-    char byteDB;
-    char byteDC;
-    char byteDD;
-    char byteDE;
-    char DisablePlayerControls;
-    char byteE0;
-    char gapE1[15];
-    int dwordF0;
-    int dwordF4;
-    int dwordF8;
+    unsigned char ShakeFreq;
+    bool bHornHistory[5];
+    unsigned char iCurrHornHistory;
+    unsigned char DisablePlayerControls;
+    char bApplyBrakes;
+    char CheatString[12];
+    int LastTimeTouched;
+    int AverageWeapon;
+    int AverageEntries;
         
     //variables
     static short &ReconState;
diff --git a/shared/Patch.cpp b/shared/Patch.cpp
@@ -41,11 +41,11 @@ void plugin::patch::Nop(uintptr_t address, size_t size, bool vp) {
     injector::MakeNOP(GetGlobalAddress(address), size, vp);
 }
 
-void plugin::patch::RedirectCall(uintptr_t address, void *func, bool vp) {
+void plugin::patch::RedirectCall(uintptr_t address, injector::memory_pointer_raw func, bool vp) {
     injector::MakeCALL(GetGlobalAddress(address), func, vp);
 }
 
-void plugin::patch::RedirectJump(uintptr_t address, void *func, bool vp) {
+void plugin::patch::RedirectJump(uintptr_t address, injector::memory_pointer_raw func, bool vp) {
     injector::MakeJMP(GetGlobalAddress(address), func, vp);
 }
 
@@ -77,7 +77,7 @@ void plugin::patch::SetFloat(uintptr_t address, float value, bool vp) {
     injector::WriteMemory(GetGlobalAddress(address), value, vp);
 }
 
-void plugin::patch::SetPointer(uintptr_t address, void *value, bool vp) {
+void plugin::patch::SetPointer(uintptr_t address, injector::memory_pointer_raw value, bool vp) {
     injector::WriteMemory(GetGlobalAddress(address), value, vp);
 }
 
@@ -130,7 +130,7 @@ void plugin::patch::GetRaw(uintptr_t address,void* ret, size_t size, bool vp) {
     injector::ReadMemoryRaw(GetGlobalAddress(address), ret, size, vp);
 }
 
-void plugin::patch::RedirectShortJump(uintptr_t address, void* dest, bool vp) {
+void plugin::patch::RedirectShortJump(uintptr_t address, injector::memory_pointer_raw dest, bool vp) {
 
     uintptr_t GlobalAddress = GetGlobalAddress(address);
     injector::WriteMemory<uint8_t>(GlobalAddress, 0xEB, vp);
diff --git a/shared/Patch.h b/shared/Patch.h
@@ -23,16 +23,16 @@ class patch {
 public:
     static void NopRestore(uintptr_t address, bool vp = true);
     static void Nop(uintptr_t address, size_t size, bool vp = true);
-    static void RedirectCall(uintptr_t address, void *func, bool vp = true);
-    static void RedirectJump(uintptr_t address, void *func, bool vp = true);
+    static void RedirectCall(uintptr_t address, injector::memory_pointer_raw func, bool vp = true);
+    static void RedirectJump(uintptr_t address, injector::memory_pointer_raw func, bool vp = true);
     static void SetChar(uintptr_t address, char value, bool vp = true);
     static void SetUChar(uintptr_t address, unsigned char value, bool vp = true);
     static void SetShort(uintptr_t address, short value, bool vp = true);
     static void SetUShort(uintptr_t address, unsigned short value, bool vp = true);
     static void SetInt(uintptr_t address, uintptr_t value, bool vp = true);
     static void SetUInt(uintptr_t address, uintptr_t value, bool vp = true);
     static void SetFloat(uintptr_t address, float value, bool vp = true);
-    static void SetPointer(uintptr_t address, void *value, bool vp = true);
+    static void SetPointer(uintptr_t address, injector::memory_pointer_raw value, bool vp = true);
     static char GetChar(uintptr_t address, bool vp = true);
     static unsigned char GetUChar(uintptr_t address, bool vp = true);
     static short GetShort(uintptr_t address, bool vp = true);
@@ -43,23 +43,23 @@ class patch {
     static void *GetPointer(uintptr_t address, bool vp = true);
     static void SetRaw(uintptr_t address, void* value, size_t size, bool vp = true);
     static void GetRaw(uintptr_t address, void* ret, size_t size, bool vp = true);
-    static void RedirectShortJump(uintptr_t address, void* dest = nullptr, bool vp = true);
+    static void RedirectShortJump(uintptr_t address, injector::memory_pointer_raw dest = nullptr, bool vp = true);
     static void PutRetn(uintptr_t address, unsigned short BytesToPop = 0, bool vp = true);
     static void PutRetn0(uintptr_t address, unsigned short BytesToPop = 0, bool vp = true);
     static void PutRetn1(uintptr_t address, unsigned short BytesToPop = 0, bool vp = true);
 
     template <typename T>
-    static void Set(uintptr_t address, T value, bool vp = true) {
+    static inline void Set(uintptr_t address, T value, bool vp = true) {
         injector::WriteMemory(GetGlobalAddress(address), value, vp);
     }
 
     template <typename T>
-    static T Get(uintptr_t address, bool vp = true) {
+    static inline T Get(uintptr_t address, bool vp = true) {
         return injector::ReadMemory<T>(GetGlobalAddress(address), vp);
     }
 
     template <typename T>
-    static T TranslateCallOffset(uintptr_t address) {
+    static inline T TranslateCallOffset(uintptr_t address) {
         if (GetUChar(address) == 0xE8) {
             auto offset = GetInt(address + 1);
             offset += (GetGlobalAddress(address) + 5);
@@ -69,7 +69,7 @@ class patch {
     }
 
     template <typename T>
-    static T TranslateJumpOffset(uintptr_t address) {
+    static inline T TranslateJumpOffset(uintptr_t address) {
         if (GetUChar(address) == 0xE9) {
             auto offset = GetInt(address + 1);
             offset += (GetGlobalAddress(address) + 5);
@@ -81,52 +81,52 @@ class patch {
     static void ReplaceFunction(uintptr_t address, void *func, bool vp = true);
     static void ReplaceFunctionCall(uintptr_t address, void *func, bool vp = true);
 
-    static void SetPointer(std::vector<uintptr_t> const& addresses, void* value, bool vp = true) {
+    static inline void SetPointer(std::vector<uintptr_t> const& addresses, injector::memory_pointer_raw value, bool vp = true) {
         for (auto& address : addresses) {
             SetPointer(address, value, vp);
         }
     }
 
     template <typename T>
-    static void Set(std::vector<uintptr_t> const& addresses, T value, bool vp = true) {
+    static inline void Set(std::vector<uintptr_t> const& addresses, T value, bool vp = true) {
         for (auto& address : addresses) {
             Set(address, value, vp);
         }
     }
 
-    static void SetInt(std::vector<uintptr_t> const& addresses, uintptr_t value, bool vp = true) {
+    static inline void SetInt(std::vector<uintptr_t> const& addresses, uintptr_t value, bool vp = true) {
         for (auto& address : addresses) {
             SetInt(address, value, vp);
         }
     }
 
-    static void SetFloat(std::vector<uintptr_t> const& addresses, float value, bool vp = true) {
+    static inline void SetFloat(std::vector<uintptr_t> const& addresses, float value, bool vp = true) {
         for (auto& address : addresses) {
             SetFloat(address, value, vp);
         }
     }
 
-    static void RedirectJump(std::vector<uintptr_t> const& addresses, void* func, bool vp = true) {
+    static inline void RedirectJump(std::vector<uintptr_t> const& addresses, injector::memory_pointer_raw func, bool vp = true) {
         for (auto& address : addresses) {
             RedirectJump(address, func, vp);
         }
     }
 
-    static void RedirectCall(std::vector<uintptr_t> const& addresses, void* func, bool vp = true) {
+    static inline void RedirectCall(std::vector<uintptr_t> const& addresses, injector::memory_pointer_raw func, bool vp = true) {
         for (auto& address : addresses) {
             RedirectCall(address, func, vp);
         }
     }
 
-    static void Nop(std::vector<uintptr_t> const& addresses, size_t size, bool vp = true) {
+    static inline void Nop(std::vector<uintptr_t> const& addresses, size_t size, bool vp = true) {
         for (auto& address : addresses) {
             Nop(address, size, vp);
         }
     }
 
     using RegPack = injector::reg_pack;
 
-    static void StaticHook(uintptr_t start, uintptr_t end, void (*func)(RegPack&)) {
+    static inline void StaticHook(uintptr_t start, uintptr_t end, void (*func)(RegPack&)) {
         struct staticHook {
             void (*func)(RegPack&);
 
@@ -143,8 +143,12 @@ class patch {
         injector::MakeInline(start, end, *ptr);
     }
 
+    static inline void StaticHook(uintptr_t address, void (*func)(RegPack&)) {
+        StaticHook(address, address + 5, func);
+	}
+
     template <typename T>
-    static void StaticHook(uintptr_t start, uintptr_t end) {
+    static inline void StaticHook(uintptr_t start, uintptr_t end) {
         injector::MakeInline<T>(start, end);
     }
 };
diff --git a/shared/SpriteLoader.cpp b/shared/SpriteLoader.cpp
@@ -204,7 +204,7 @@ namespace plugin {
     }
 
     CSprite2d SpriteLoader::GetSprite(std::string const& name) {
-        CSprite2d sprite;
+        CSprite2d sprite = {};
         auto s = spritesMap.find(name);
         if (s != spritesMap.end())
             sprite.m_pTexture = s->second;
@@ -213,7 +213,7 @@ namespace plugin {
     }
 
     CSprite2d SpriteLoader::GetSprite(uint32_t id) {
-        CSprite2d sprite;
+        CSprite2d sprite = {};
 
         auto s = spritesMapIndex.find(id);
         if (s != spritesMapIndex.end())
@@ -233,7 +233,7 @@ namespace plugin {
         mipMap = on;
     }
 
-    void SpriteLoader::SetExtension(std::string ext) {
+    void SpriteLoader::SetExtension(std::string const& ext) {
         extension = ext;
     }
 
diff --git a/shared/SpriteLoader.h b/shared/SpriteLoader.h
@@ -64,7 +64,7 @@ namespace plugin {
         CSprite2d GetSprite(uint32_t id);
         texClass* GetTex(std::string const& name);
         void SetMipMapOn(bool on);
-        void SetExtension(std::string ext);
+        void SetExtension(std::string const& ext);
         uint32_t GetMemoryUsed();
     };
 }

Original file line number	Diff line number	Diff line change
`@@ -41,11 +41,11 @@ void plugin::patch::Nop(uintptr_t address, size_t size, bool vp) {`
`41`	`41`	`injector::MakeNOP(GetGlobalAddress(address), size, vp);`
`42`	`42`	`}`
`43`	`43`
`44`		`-void plugin::patch::RedirectCall(uintptr_t address, void *func, bool vp) {`
	`44`	`+void plugin::patch::RedirectCall(uintptr_t address, injector::memory_pointer_raw func, bool vp) {`
`45`	`45`	`injector::MakeCALL(GetGlobalAddress(address), func, vp);`
`46`	`46`	`}`
`47`	`47`
`48`		`-void plugin::patch::RedirectJump(uintptr_t address, void *func, bool vp) {`
	`48`	`+void plugin::patch::RedirectJump(uintptr_t address, injector::memory_pointer_raw func, bool vp) {`
`49`	`49`	`injector::MakeJMP(GetGlobalAddress(address), func, vp);`
`50`	`50`	`}`
`51`	`51`
`@@ -77,7 +77,7 @@ void plugin::patch::SetFloat(uintptr_t address, float value, bool vp) {`
`77`	`77`	`injector::WriteMemory(GetGlobalAddress(address), value, vp);`
`78`	`78`	`}`
`79`	`79`
`80`		`-void plugin::patch::SetPointer(uintptr_t address, void *value, bool vp) {`
	`80`	`+void plugin::patch::SetPointer(uintptr_t address, injector::memory_pointer_raw value, bool vp) {`
`81`	`81`	`injector::WriteMemory(GetGlobalAddress(address), value, vp);`
`82`	`82`	`}`
`83`	`83`
`@@ -130,7 +130,7 @@ void plugin::patch::GetRaw(uintptr_t address,void* ret, size_t size, bool vp) {`
`130`	`130`	`injector::ReadMemoryRaw(GetGlobalAddress(address), ret, size, vp);`
`131`	`131`	`}`
`132`	`132`
`133`		`-void plugin::patch::RedirectShortJump(uintptr_t address, void* dest, bool vp) {`
	`133`	`+void plugin::patch::RedirectShortJump(uintptr_t address, injector::memory_pointer_raw dest, bool vp) {`
`134`	`134`
`135`	`135`	`uintptr_t GlobalAddress = GetGlobalAddress(address);`
`136`	`136`	`injector::WriteMemory<uint8_t>(GlobalAddress, 0xEB, vp);`
Original file line number	Diff line number	Diff line change
`@@ -204,7 +204,7 @@ namespace plugin {`
`204`	`204`	`}`
`205`	`205`
`206`	`206`	`CSprite2d SpriteLoader::GetSprite(std::string const& name) {`
`207`		`- CSprite2d sprite;`
	`207`	`+ CSprite2d sprite = {};`
`208`	`208`	`auto s = spritesMap.find(name);`
`209`	`209`	`if (s != spritesMap.end())`
`210`	`210`	`sprite.m_pTexture = s->second;`
`@@ -213,7 +213,7 @@ namespace plugin {`
`213`	`213`	`}`
`214`	`214`
`215`	`215`	`CSprite2d SpriteLoader::GetSprite(uint32_t id) {`
`216`		`- CSprite2d sprite;`
	`216`	`+ CSprite2d sprite = {};`
`217`	`217`
`218`	`218`	`auto s = spritesMapIndex.find(id);`
`219`	`219`	`if (s != spritesMapIndex.end())`
`@@ -233,7 +233,7 @@ namespace plugin {`
`233`	`233`	`mipMap = on;`
`234`	`234`	`}`
`235`	`235`
`236`		`- void SpriteLoader::SetExtension(std::string ext) {`
	`236`	`+ void SpriteLoader::SetExtension(std::string const& ext) {`
`237`	`237`	`extension = ext;`
`238`	`238`	`}`
`239`	`239`
Original file line number	Diff line number	Diff line change
`@@ -64,7 +64,7 @@ namespace plugin {`
`64`	`64`	`CSprite2d GetSprite(uint32_t id);`
`65`	`65`	`texClass* GetTex(std::string const& name);`
`66`	`66`	`void SetMipMapOn(bool on);`
`67`		`- void SetExtension(std::string ext);`
	`67`	`+ void SetExtension(std::string const& ext);`
`68`	`68`	`uint32_t GetMemoryUsed();`
`69`	`69`	`};`
`70`	`70`	`}`