diff --git a/BitInfo.txt b/BitInfo.txt new file mode 100644 index 0000000..ab0de5d --- /dev/null +++ b/BitInfo.txt @@ -0,0 +1,58 @@ +BIT ARRAY +00719780 + +INGAME: +00 - NULL +01 - digital throttle +02 - digital reverse +03 - digital left +04 - digital right +05 - ebrake +06 - NOS +07 - shift up +08 - shift down +09 - look back +10 - change cam +11 - P2 start / debug camera spawn car / 5 key and Q key +12 - pause +13 - unk +14 - reset car +15 - unk +FE CONTROLS +16 - up +17 - down +18 - left +19 - right +20 - accept +21 - ? start? +22 - H key (HELP?) +23 - back +24 - C key - select? +25 - L2 +26 - R2 +27 - left shoulder +28 - right shoulder +29 - car orbit up +30 - car orbit left +31 - car orbit down +from 00719784 ( counting up bits with 32 offset ) +32 - car orbit right +// Player 2??? +33 - HOME key +34 - END key +35 - P key? +36 - quit game / Q key +37 - R key +38 - debug camera up +39 - debug camera down +40 - d.c. left +41 - d.c. right +42 - U key +43 - Y key +44 - Z key +45 - colon +46 - quote " key +47 - T key / 4 ingame - debug camera turbo +48 - 6 key - debug camera super turbo +50 - O key +51 - activate debug camera diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..4a97a60 --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2022 Lovro Pleše + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/NFSU_ConsoleButtonHashes.h b/NFSU_ConsoleButtonHashes.h new file mode 100644 index 0000000..a105893 --- /dev/null +++ b/NFSU_ConsoleButtonHashes.h @@ -0,0 +1,28 @@ +#pragma once + +#define XBOXA_HASH 0x0408D061 +#define XBOXB_HASH 0x0408D062 +#define XBOXX_HASH 0x0408D078 +#define XBOXY_HASH 0x0408D079 +#define XBOXBACK_HASH 0x594DAA91 +#define XBOXSTART_HASH 0x8441012E +#define XBOXLT_HASH 0x8522DE40 + +#define PSCIRCLE_HASH 0xF6D884F4 +#define PSCROSS_HASH 0xE8780F8C +#define PSL2_HASH 0x001B30E0 +#define PSOPTIONS_HASH 0x7E1FA26E +#define PSSHARE_HASH 0xE993E015 +#define PSSQUARE_HASH 0x1CBD7073 +#define PSTRIANGLE_HASH 0x5F176458 + +#define PC_TUTORIAL 0xA35C52C5 +#define PC_X 0x001AEF69 +#define PC_PERFORMANCE 0x04BDFDA3 +#define PC_HELP 0xC51A8C5A +#define PC_DELETE 0x6C9A44A4 +#define PC_CREATEROOM 0x4073AF02 +#define PC_CUSTOM 0x6B6AB9EC +#define PC_BACK 0xC5172FE2 +#define PC_QUIT 0xC51FBF74 + diff --git a/NFSU_JoyBitInfo.h b/NFSU_JoyBitInfo.h new file mode 100644 index 0000000..288d280 --- /dev/null +++ b/NFSU_JoyBitInfo.h @@ -0,0 +1,56 @@ +#pragma once + +#define NFSUJOY_NULL 0 +#define NFSUJOY_DIGITAL_THROTTLE 1 +#define NFSUJOY_DIGITAL_REVERSE 2 +#define NFSUJOY_DIGITAL_LEFT 3 +#define NFSUJOY_DIGITAL_RIGHT 4 +#define NFSUJOY_EBRAKE 5 +#define NFSUJOY_NOS 6 +#define NFSUJOY_SHIFTUP 7 +#define NFSUJOY_SHIFTDOWN 8 +#define NFSUJOY_LOOKBACK 9 +#define NFSUJOY_CHANGECAM 10 +#define NFSUJOY_BIT11 11 +#define NFSUJOY_PAUSE 12 +#define NFSUJOY_BIT13 13 +#define NFSUJOY_RESETCAR 14 +#define NFSUJOY_BIT15 15 +#define NFSUJOY_FE_UP 16 +#define NFSUJOY_FE_DOWN 17 +#define NFSUJOY_FE_LEFT 18 +#define NFSUJOY_FE_RIGHT 19 +#define NFSUJOY_FE_ACCEPT 20 +#define NFSUJOY_FE_BIT21 21 +#define NFSUJOY_FE_BIT22 22 +#define NFSUJOY_FE_BACK 23 +#define NFSUJOY_FE_BIT24 24 +#define NFSUJOY_FE_L2 25 +#define NFSUJOY_FE_R2 26 +#define NFSUJOY_FE_L1 27 +#define NFSUJOY_FE_R1 28 +#define NFSUJOY_FE_ORBIT_UP 29 +#define NFSUJOY_FE_ORBIT_LEFT 30 +#define NFSUJOY_FE_ORBIT_DOWN 31 +// second bits start from zero +#define NFSUJOY_FE_ORBIT_RIGHT 0 +#define NFSUJOY_BIT33 1 +#define NFSUJOY_BIT34 2 +#define NFSUJOY_BIT35 3 +#define NFSUJOY_BIT36 4 +#define NFSUJOY_BIT37 5 +#define NFSUJOY_DEBUGCAM_LOOKUP 6 +#define NFSUJOY_DEBUGCAM_LOOKDOWN 7 +#define NFSUJOY_DEBUGCAM_LOOKLEFT 8 +#define NFSUJOY_DEBUGCAM_LOOKRIGHT 9 +#define NFSUJOY_DEBUGCAM_MOVEDOWN 10 +#define NFSUJOY_DEBUGCAM_MOVEFORWARD 11 +#define NFSUJOY_DEBUGCAM_MOVEBACKWARD 12 +#define NFSUJOY_DEBUGCAM_MOVELEFT 13 +#define NFSUJOY_DEBUGCAM_MOVERIGHT 14 +#define NFSUJOY_DEBUGCAM_TURBO 15 +#define NFSUJOY_DEBUGCAM_SUPERTURBO 16 +#define NFSUJOY_DEBUGCAM_SLOW 17 +#define NFSUJOY_DEBUGCAM_MOVEUP 18 +#define NFSUJOY_DEBUGCAM_ACTIVATE 19 +// other bits unknown... \ No newline at end of file diff --git a/NFSU_XtendedInput.filters b/NFSU_XtendedInput.filters new file mode 100644 index 0000000..95c6df3 --- /dev/null +++ b/NFSU_XtendedInput.filters @@ -0,0 +1,33 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hh;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + Header Files + + + Header Files + + + + + Source Files + + + Source Files + + + \ No newline at end of file diff --git a/NFSU_XtendedInput.ini b/NFSU_XtendedInput.ini new file mode 100644 index 0000000..c08546e --- /dev/null +++ b/NFSU_XtendedInput.ini @@ -0,0 +1,3 @@ +[Icons] +ControllerIconMode = 0 // 0 = Xbox, 1 = PlayStation 4 -- MAKE SURE TO DISABLE WIDESCREEN FIX'S BUTTON ICONS FIRST (they're dymamically changing!) +FirstControlDevice = 0 // 0 = Keyboard, 1 = Controller -- for setting the first state diff --git a/NFSU_XtendedInput.sln b/NFSU_XtendedInput.sln new file mode 100644 index 0000000..0eca694 --- /dev/null +++ b/NFSU_XtendedInput.sln @@ -0,0 +1,22 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 14 +VisualStudioVersion = 14.0.25420.1 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "DebugOpts", "NFSU_XtendedInput.vcxproj", "{3C558AD9-5F9C-4A14-8F07-800F46C132C7}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|x86 = Debug|x86 + Release|x86 = Release|x86 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {3C558AD9-5F9C-4A14-8F07-800F46C132C7}.Debug|x86.ActiveCfg = Debug|Win32 + {3C558AD9-5F9C-4A14-8F07-800F46C132C7}.Debug|x86.Build.0 = Debug|Win32 + {3C558AD9-5F9C-4A14-8F07-800F46C132C7}.Release|x86.ActiveCfg = Release|Win32 + {3C558AD9-5F9C-4A14-8F07-800F46C132C7}.Release|x86.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/NFSU_XtendedInput.sln.bak b/NFSU_XtendedInput.sln.bak new file mode 100644 index 0000000..eae6243 --- /dev/null +++ b/NFSU_XtendedInput.sln.bak @@ -0,0 +1,22 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 14 +VisualStudioVersion = 14.0.25420.1 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "DebugOpts", "ConsoleAttachment.vcxproj", "{3C558AD9-5F9C-4A14-8F07-800F46C132C7}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|x86 = Debug|x86 + Release|x86 = Release|x86 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {3C558AD9-5F9C-4A14-8F07-800F46C132C7}.Debug|x86.ActiveCfg = Debug|Win32 + {3C558AD9-5F9C-4A14-8F07-800F46C132C7}.Debug|x86.Build.0 = Debug|Win32 + {3C558AD9-5F9C-4A14-8F07-800F46C132C7}.Release|x86.ActiveCfg = Release|Win32 + {3C558AD9-5F9C-4A14-8F07-800F46C132C7}.Release|x86.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/NFSU_XtendedInput.vcxproj b/NFSU_XtendedInput.vcxproj new file mode 100644 index 0000000..1c4e9aa --- /dev/null +++ b/NFSU_XtendedInput.vcxproj @@ -0,0 +1,113 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + {3C558AD9-5F9C-4A14-8F07-800F46C132C7} + Win32Proj + QRHiddenOptions + NFSU_XtendedInput + 10.0 + + + + DynamicLibrary + true + v143 + MultiByte + + + DynamicLibrary + false + v143 + true + MultiByte + + + + + + + + + + + + + true + .asi + $(ProjectName) + + + false + .asi + $(ProjectName) + + + + Use + Level3 + Disabled + WIN32;_DEBUG;_WINDOWS;_USRDLL;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions) + + + Windows + true + + + + + Level4 + Use + MaxSpeed + true + true + WIN32;NDEBUG;_WINDOWS;_USRDLL;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions) + MultiThreadedDLL + + + Windows + true + true + true + + + + + + + + + + + false + + + false + + + + + Create + Create + + + + + + + + + + + + + \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..0814c1a --- /dev/null +++ b/README.md @@ -0,0 +1,99 @@ +# NFS Underground - Xtended Input + +This is an plugin for NFS Underground which brings XInput support to the game. + +Currently work in progress, but fully usable and playable! + +Planned to bring to other NFS games in the future! + +## Features + +- Automatic texture and text swapping for button icons - dynamically detects when you use either a keyboard or a controller (Disable Widescreen Fix's button icons to see the effect) + +- Choice between Xbox and PS4 icons (from WS Fix) + +## Button mappings + +They are currently fixed and can't be changed without recompiling the code, but it should suit most, if not all players. + +### Ingame + +- Throttle: Right Trigger + +- Brake: Left Trigger + +- Steering: Left Stick X axis + +- Digital steering: D-Pad Left & Right + +- E-Brake: A button + +- NOS: B button + +- Look back: X button + +- Change camera: Y button + +- Shift up/down: Right Stick Y axis up/down + +- Pause: Menu/Start + +- Quit game: Windows/Back button + +### FrontEnd + +- Navigation: D-Pad & Left Analog Stick + +- Accept: A button + +- Back: B button + +- Left shoulder & Right shoulder buttons: mapped to their respective equivalents + +- L2: Left Trigger + +- R2: Right Trigger + +- Quit game: Windows/Back button + +Some extra notes about FrontEnd: PC version has had some changes to console navigation and complicated some things + +- Vinyl color changing: X button + +This button is NOT marked anywhere on the screen because the menu has to normally be invoked by the mouse. + +### Debug camera + +Currently does NOT support analog inputs. You can only use digital inputs. You must use a controller on the second port to invoke it and use it. + +- Activation: Windows/Back + +- Move forward: A button + +- Move backward: Y button + +- Move left: X button + +- Move right: B button + +- Move up: Left Shoulder + +- Move down: Left Trigger + +- Look up/down/left/right: D-Pad + +- Turbo: Right Shoulder + +- Super Turbo: Right Trigger + +## TODO list: + +- Check the top of the source file, but to sum it up - lower level and more direct access to the game would be nice! + +- Currently KILLS Direct Input, beware + +# Credits + +- ThirteenAG & AeroWidescreen - for the great button icons! + +- LINK/2012 - injector diff --git a/UG_ConsoleButtons/AAED1FC1.ini b/UG_ConsoleButtons/AAED1FC1.ini new file mode 100644 index 0000000..66ff2a4 --- /dev/null +++ b/UG_ConsoleButtons/AAED1FC1.ini @@ -0,0 +1,426 @@ +[TPK] +Name = CONSOLEBUTTONS +Version = 4 +Filename = ConsoleButtons +FilenameHash = 0xAAED1FC1 +Animations = 0 + +[0408D061] +File = UG_ConsoleButtons\AAED1FC1\XBOXA.dds +Name = XBOXA +ClassNameHash = 0x1A93CF +ShiftWidth = 5 +ShiftHeight = 5 +ImageCompressionType = 0x24 +PaletteCompressionType = 0x0 +NumPaletteEntries = 0 +TilableUV = 0 +BiasLevel = 0 +RenderingOrder = 5 +ScrollType = 0 +UsedFlag = 0 +ApplyAlphaSorting = 0 +AlphaUsageType = 2 +AlphaBlendType = 1 +Flags = 0x0 +MipmapBiasType = 0 +ScrollTimeStep = 0 +ScrollSpeedS = 0 +ScrollSpeedT = 0 +OffsetS = 0 +OffsetT = 256 +ScaleS = 256 +ScaleT = 0 +PixelFormatUnk1 = 0x1 +PixelFormatUnk2 = 0x5 +PixelFormatUnk3 = 0x6 + +[0408D062] +File = UG_ConsoleButtons\AAED1FC1\XBOXB.dds +Name = XBOXB +ClassNameHash = 0x1A93CF +ShiftWidth = 5 +ShiftHeight = 5 +ImageCompressionType = 0x24 +PaletteCompressionType = 0x0 +NumPaletteEntries = 0 +TilableUV = 0 +BiasLevel = 0 +RenderingOrder = 5 +ScrollType = 0 +UsedFlag = 0 +ApplyAlphaSorting = 0 +AlphaUsageType = 2 +AlphaBlendType = 1 +Flags = 0x0 +MipmapBiasType = 0 +ScrollTimeStep = 0 +ScrollSpeedS = 0 +ScrollSpeedT = 0 +OffsetS = 0 +OffsetT = 256 +ScaleS = 256 +ScaleT = 0 +PixelFormatUnk1 = 0x1 +PixelFormatUnk2 = 0x5 +PixelFormatUnk3 = 0x6 + +[0408D078] +File = UG_ConsoleButtons\AAED1FC1\XBOXX.dds +Name = XBOXX +ClassNameHash = 0x1A93CF +ShiftWidth = 5 +ShiftHeight = 5 +ImageCompressionType = 0x24 +PaletteCompressionType = 0x0 +NumPaletteEntries = 0 +TilableUV = 0 +BiasLevel = 0 +RenderingOrder = 5 +ScrollType = 0 +UsedFlag = 0 +ApplyAlphaSorting = 0 +AlphaUsageType = 2 +AlphaBlendType = 1 +Flags = 0x0 +MipmapBiasType = 0 +ScrollTimeStep = 0 +ScrollSpeedS = 0 +ScrollSpeedT = 0 +OffsetS = 0 +OffsetT = 256 +ScaleS = 256 +ScaleT = 0 +PixelFormatUnk1 = 0x1 +PixelFormatUnk2 = 0x5 +PixelFormatUnk3 = 0x6 + +[0408D079] +File = UG_ConsoleButtons\AAED1FC1\XBOXY.dds +Name = XBOXY +ClassNameHash = 0x1A93CF +ShiftWidth = 5 +ShiftHeight = 5 +ImageCompressionType = 0x24 +PaletteCompressionType = 0x0 +NumPaletteEntries = 0 +TilableUV = 0 +BiasLevel = 0 +RenderingOrder = 5 +ScrollType = 0 +UsedFlag = 0 +ApplyAlphaSorting = 0 +AlphaUsageType = 2 +AlphaBlendType = 1 +Flags = 0x0 +MipmapBiasType = 0 +ScrollTimeStep = 0 +ScrollSpeedS = 0 +ScrollSpeedT = 0 +OffsetS = 0 +OffsetT = 256 +ScaleS = 256 +ScaleT = 0 +PixelFormatUnk1 = 0x1 +PixelFormatUnk2 = 0x5 +PixelFormatUnk3 = 0x6 + +[594DAA91] +File = UG_ConsoleButtons\AAED1FC1\XBOXBACK.dds +Name = XBOXBACK +ClassNameHash = 0x1A93CF +ShiftWidth = 5 +ShiftHeight = 5 +ImageCompressionType = 0x24 +PaletteCompressionType = 0x0 +NumPaletteEntries = 0 +TilableUV = 0 +BiasLevel = 0 +RenderingOrder = 5 +ScrollType = 0 +UsedFlag = 0 +ApplyAlphaSorting = 0 +AlphaUsageType = 2 +AlphaBlendType = 1 +Flags = 0x0 +MipmapBiasType = 0 +ScrollTimeStep = 0 +ScrollSpeedS = 0 +ScrollSpeedT = 0 +OffsetS = 0 +OffsetT = 256 +ScaleS = 256 +ScaleT = 0 +PixelFormatUnk1 = 0x1 +PixelFormatUnk2 = 0x5 +PixelFormatUnk3 = 0x6 + +[8441012E] +File = UG_ConsoleButtons\AAED1FC1\XBOXSTART.dds +Name = XBOXSTART +ClassNameHash = 0x1A93CF +ShiftWidth = 5 +ShiftHeight = 5 +ImageCompressionType = 0x24 +PaletteCompressionType = 0x0 +NumPaletteEntries = 0 +TilableUV = 0 +BiasLevel = 0 +RenderingOrder = 5 +ScrollType = 0 +UsedFlag = 0 +ApplyAlphaSorting = 0 +AlphaUsageType = 2 +AlphaBlendType = 1 +Flags = 0x0 +MipmapBiasType = 0 +ScrollTimeStep = 0 +ScrollSpeedS = 0 +ScrollSpeedT = 0 +OffsetS = 0 +OffsetT = 256 +ScaleS = 256 +ScaleT = 0 +PixelFormatUnk1 = 0x1 +PixelFormatUnk2 = 0x5 +PixelFormatUnk3 = 0x6 + +[8522DE40] +File = UG_ConsoleButtons\AAED1FC1\XBOXLT.dds +Name = XBOXLT +ClassNameHash = 0x1A93CF +ShiftWidth = 5 +ShiftHeight = 5 +ImageCompressionType = 0x24 +PaletteCompressionType = 0x0 +NumPaletteEntries = 0 +TilableUV = 0 +BiasLevel = 0 +RenderingOrder = 5 +ScrollType = 0 +UsedFlag = 0 +ApplyAlphaSorting = 0 +AlphaUsageType = 2 +AlphaBlendType = 1 +Flags = 0x0 +MipmapBiasType = 0 +ScrollTimeStep = 0 +ScrollSpeedS = 0 +ScrollSpeedT = 0 +OffsetS = 0 +OffsetT = 256 +ScaleS = 256 +ScaleT = 0 +PixelFormatUnk1 = 0x1 +PixelFormatUnk2 = 0x5 +PixelFormatUnk3 = 0x6 + +[F6D884F4] +File = UG_ConsoleButtons\AAED1FC1\PSCIRCLE.dds +Name = PSCIRCLE +ClassNameHash = 0x1A93CF +ShiftWidth = 5 +ShiftHeight = 5 +ImageCompressionType = 0x24 +PaletteCompressionType = 0x0 +NumPaletteEntries = 0 +TilableUV = 0 +BiasLevel = 0 +RenderingOrder = 5 +ScrollType = 0 +UsedFlag = 0 +ApplyAlphaSorting = 0 +AlphaUsageType = 2 +AlphaBlendType = 1 +Flags = 0x0 +MipmapBiasType = 0 +ScrollTimeStep = 0 +ScrollSpeedS = 0 +ScrollSpeedT = 0 +OffsetS = 0 +OffsetT = 256 +ScaleS = 256 +ScaleT = 0 +PixelFormatUnk1 = 0x1 +PixelFormatUnk2 = 0x5 +PixelFormatUnk3 = 0x6 + +[E8780F8C] +File = UG_ConsoleButtons\AAED1FC1\PSCROSS.dds +Name = PSCROSS +ClassNameHash = 0x1A93CF +ShiftWidth = 5 +ShiftHeight = 5 +ImageCompressionType = 0x24 +PaletteCompressionType = 0x0 +NumPaletteEntries = 0 +TilableUV = 0 +BiasLevel = 0 +RenderingOrder = 5 +ScrollType = 0 +UsedFlag = 0 +ApplyAlphaSorting = 0 +AlphaUsageType = 2 +AlphaBlendType = 1 +Flags = 0x0 +MipmapBiasType = 0 +ScrollTimeStep = 0 +ScrollSpeedS = 0 +ScrollSpeedT = 0 +OffsetS = 0 +OffsetT = 256 +ScaleS = 256 +ScaleT = 0 +PixelFormatUnk1 = 0x1 +PixelFormatUnk2 = 0x5 +PixelFormatUnk3 = 0x6 + +[001B30E0] +File = UG_ConsoleButtons\AAED1FC1\PSL2.dds +Name = PSL2 +ClassNameHash = 0x1A93CF +ShiftWidth = 5 +ShiftHeight = 5 +ImageCompressionType = 0x24 +PaletteCompressionType = 0x0 +NumPaletteEntries = 0 +TilableUV = 0 +BiasLevel = 0 +RenderingOrder = 5 +ScrollType = 0 +UsedFlag = 0 +ApplyAlphaSorting = 0 +AlphaUsageType = 2 +AlphaBlendType = 1 +Flags = 0x0 +MipmapBiasType = 0 +ScrollTimeStep = 0 +ScrollSpeedS = 0 +ScrollSpeedT = 0 +OffsetS = 0 +OffsetT = 256 +ScaleS = 256 +ScaleT = 0 +PixelFormatUnk1 = 0x1 +PixelFormatUnk2 = 0x5 +PixelFormatUnk3 = 0x6 + +[7E1FA26E] +File = UG_ConsoleButtons\AAED1FC1\PSOPTIONS.dds +Name = PSOPTIONS +ClassNameHash = 0x1A93CF +ShiftWidth = 5 +ShiftHeight = 5 +ImageCompressionType = 0x24 +PaletteCompressionType = 0x0 +NumPaletteEntries = 0 +TilableUV = 0 +BiasLevel = 0 +RenderingOrder = 5 +ScrollType = 0 +UsedFlag = 0 +ApplyAlphaSorting = 0 +AlphaUsageType = 2 +AlphaBlendType = 1 +Flags = 0x0 +MipmapBiasType = 0 +ScrollTimeStep = 0 +ScrollSpeedS = 0 +ScrollSpeedT = 0 +OffsetS = 0 +OffsetT = 256 +ScaleS = 256 +ScaleT = 0 +PixelFormatUnk1 = 0x1 +PixelFormatUnk2 = 0x5 +PixelFormatUnk3 = 0x6 + +[E993E015] +File = UG_ConsoleButtons\AAED1FC1\PSSHARE.dds +Name = PSSHARE +ClassNameHash = 0x1A93CF +ShiftWidth = 5 +ShiftHeight = 5 +ImageCompressionType = 0x24 +PaletteCompressionType = 0x0 +NumPaletteEntries = 0 +TilableUV = 0 +BiasLevel = 0 +RenderingOrder = 5 +ScrollType = 0 +UsedFlag = 0 +ApplyAlphaSorting = 0 +AlphaUsageType = 2 +AlphaBlendType = 1 +Flags = 0x0 +MipmapBiasType = 0 +ScrollTimeStep = 0 +ScrollSpeedS = 0 +ScrollSpeedT = 0 +OffsetS = 0 +OffsetT = 256 +ScaleS = 256 +ScaleT = 0 +PixelFormatUnk1 = 0x1 +PixelFormatUnk2 = 0x5 +PixelFormatUnk3 = 0x6 + +[1CBD7073] +File = UG_ConsoleButtons\AAED1FC1\PSSQUARE.dds +Name = PSSQUARE +ClassNameHash = 0x1A93CF +ShiftWidth = 5 +ShiftHeight = 5 +ImageCompressionType = 0x24 +PaletteCompressionType = 0x0 +NumPaletteEntries = 0 +TilableUV = 0 +BiasLevel = 0 +RenderingOrder = 5 +ScrollType = 0 +UsedFlag = 0 +ApplyAlphaSorting = 0 +AlphaUsageType = 2 +AlphaBlendType = 1 +Flags = 0x0 +MipmapBiasType = 0 +ScrollTimeStep = 0 +ScrollSpeedS = 0 +ScrollSpeedT = 0 +OffsetS = 0 +OffsetT = 256 +ScaleS = 256 +ScaleT = 0 +PixelFormatUnk1 = 0x1 +PixelFormatUnk2 = 0x5 +PixelFormatUnk3 = 0x6 + +[5F176458] +File = UG_ConsoleButtons\AAED1FC1\PSTRIANGLE.dds +Name = PSTRIANGLE +ClassNameHash = 0x1A93CF +ShiftWidth = 5 +ShiftHeight = 5 +ImageCompressionType = 0x24 +PaletteCompressionType = 0x0 +NumPaletteEntries = 0 +TilableUV = 0 +BiasLevel = 0 +RenderingOrder = 5 +ScrollType = 0 +UsedFlag = 0 +ApplyAlphaSorting = 0 +AlphaUsageType = 2 +AlphaBlendType = 1 +Flags = 0x0 +MipmapBiasType = 0 +ScrollTimeStep = 0 +ScrollSpeedS = 0 +ScrollSpeedT = 0 +OffsetS = 0 +OffsetT = 256 +ScaleS = 256 +ScaleT = 0 +PixelFormatUnk1 = 0x1 +PixelFormatUnk2 = 0x5 +PixelFormatUnk3 = 0x6 diff --git a/UG_ConsoleButtons/AAED1FC1/PSCIRCLE.dds b/UG_ConsoleButtons/AAED1FC1/PSCIRCLE.dds new file mode 100644 index 0000000..cfb19c3 Binary files /dev/null and b/UG_ConsoleButtons/AAED1FC1/PSCIRCLE.dds differ diff --git a/UG_ConsoleButtons/AAED1FC1/PSCROSS.dds b/UG_ConsoleButtons/AAED1FC1/PSCROSS.dds new file mode 100644 index 0000000..71b066e Binary files /dev/null and b/UG_ConsoleButtons/AAED1FC1/PSCROSS.dds differ diff --git a/UG_ConsoleButtons/AAED1FC1/PSL2.dds b/UG_ConsoleButtons/AAED1FC1/PSL2.dds new file mode 100644 index 0000000..f57815a Binary files /dev/null and b/UG_ConsoleButtons/AAED1FC1/PSL2.dds differ diff --git a/UG_ConsoleButtons/AAED1FC1/PSOPTIONS.dds b/UG_ConsoleButtons/AAED1FC1/PSOPTIONS.dds new file mode 100644 index 0000000..8837e2e Binary files /dev/null and b/UG_ConsoleButtons/AAED1FC1/PSOPTIONS.dds differ diff --git a/UG_ConsoleButtons/AAED1FC1/PSSHARE.dds b/UG_ConsoleButtons/AAED1FC1/PSSHARE.dds new file mode 100644 index 0000000..1cc4aaa Binary files /dev/null and b/UG_ConsoleButtons/AAED1FC1/PSSHARE.dds differ diff --git a/UG_ConsoleButtons/AAED1FC1/PSSQUARE.dds b/UG_ConsoleButtons/AAED1FC1/PSSQUARE.dds new file mode 100644 index 0000000..887ba30 Binary files /dev/null and b/UG_ConsoleButtons/AAED1FC1/PSSQUARE.dds differ diff --git a/UG_ConsoleButtons/AAED1FC1/PSTRIANGLE.dds b/UG_ConsoleButtons/AAED1FC1/PSTRIANGLE.dds new file mode 100644 index 0000000..4cb9e1a Binary files /dev/null and b/UG_ConsoleButtons/AAED1FC1/PSTRIANGLE.dds differ diff --git a/UG_ConsoleButtons/AAED1FC1/XBOXA.dds b/UG_ConsoleButtons/AAED1FC1/XBOXA.dds new file mode 100644 index 0000000..d276eee Binary files /dev/null and b/UG_ConsoleButtons/AAED1FC1/XBOXA.dds differ diff --git a/UG_ConsoleButtons/AAED1FC1/XBOXB.dds b/UG_ConsoleButtons/AAED1FC1/XBOXB.dds new file mode 100644 index 0000000..2912ee2 Binary files /dev/null and b/UG_ConsoleButtons/AAED1FC1/XBOXB.dds differ diff --git a/UG_ConsoleButtons/AAED1FC1/XBOXBACK.dds b/UG_ConsoleButtons/AAED1FC1/XBOXBACK.dds new file mode 100644 index 0000000..41cb5f5 Binary files /dev/null and b/UG_ConsoleButtons/AAED1FC1/XBOXBACK.dds differ diff --git a/UG_ConsoleButtons/AAED1FC1/XBOXLT.dds b/UG_ConsoleButtons/AAED1FC1/XBOXLT.dds new file mode 100644 index 0000000..f30de57 Binary files /dev/null and b/UG_ConsoleButtons/AAED1FC1/XBOXLT.dds differ diff --git a/UG_ConsoleButtons/AAED1FC1/XBOXSTART.dds b/UG_ConsoleButtons/AAED1FC1/XBOXSTART.dds new file mode 100644 index 0000000..6796016 Binary files /dev/null and b/UG_ConsoleButtons/AAED1FC1/XBOXSTART.dds differ diff --git a/UG_ConsoleButtons/AAED1FC1/XBOXX.dds b/UG_ConsoleButtons/AAED1FC1/XBOXX.dds new file mode 100644 index 0000000..b250b72 Binary files /dev/null and b/UG_ConsoleButtons/AAED1FC1/XBOXX.dds differ diff --git a/UG_ConsoleButtons/AAED1FC1/XBOXY.dds b/UG_ConsoleButtons/AAED1FC1/XBOXY.dds new file mode 100644 index 0000000..2005389 Binary files /dev/null and b/UG_ConsoleButtons/AAED1FC1/XBOXY.dds differ diff --git a/dllmain.cpp b/dllmain.cpp new file mode 100644 index 0000000..3218294 --- /dev/null +++ b/dllmain.cpp @@ -0,0 +1,767 @@ +// NFS Underground - Xtended Input plugin +// Bringing native XInput to NFS +// by Xan/Tenjoin + +// TODO: hook input scanners instead -- they're a better and more accurate target than the joypad input buffer +// TODO: bring rumble/vibration function +// TODO: remapping? +// TODO: bring back P2 controls if possible +// TODO: kill DInput enough so that it doesn't detect XInput controllers but still detects wheels +// TODO: properly restore console FrontEnd objects (help messages, controller icons) -- partially done, HELP menu still needs to be restored + +#include "stdafx.h" +#include "stdio.h" +#include +#include +#include "NFSU_JoyBitInfo.h" +#include "NFSU_ConsoleButtonHashes.h" +#include "includes\injector\injector.hpp" +#include "includes\IniReader.h" + +#if (_WIN32_WINNT >= 0x0602 /*_WIN32_WINNT_WIN8*/) +#include +#pragma comment(lib,"xinput.lib") +#else +#include +#pragma comment(lib,"xinput9_1_0.lib") +#endif + +#define MAX_CONTROLLERS 4 // XInput handles up to 4 controllers +#define INPUT_DEADZONE ( 0.24f * FLOAT(0x7FFF) ) // Default to 24% of the +/- 32767 range. This is a reasonable default value but can be altered if needed. + +#define TRIGGER_ACTIVATION_THRESHOLD 0x20 +#define SHIFT_ANALOG_THRESHOLD 0x5000 +#define FEUPDOWN_ANALOG_THRESHOLD 0x3FFF + +#define JOYBUTTONS1_ADDR 0x00719780 +#define JOYBUTTONS2_ADDR 0x00719784 +#define THROTTLE_AXIS_ADDR 0x00719788 +#define BRAKE_AXIS_ADDR 0x00719789 +#define STEER_AXIS_ADDR 0x0071978A +#define FE_WINDOWS_KEY_CODE_ADDR 0x007363B1 +#define GAMEFLOWMANAGER_STATUS_ADDR 0x0077A920 +#define CURRENT_MENUPKG_ADDR 0x72CDD0 +#define FEMOUSECURSOR_BUTTONPRESS_ADDR 0x007064B0 +#define FEMOUSECURSOR_CARORBIT_X_ADDR 0x007064A4 +#define FEMOUSECURSOR_CARORBIT_Y_ADDR 0x007064A8 + +bool bCarOrbitState = 0; +bool bCarOrbitOldState = 0; +float CarOrbitDivisor = 0.5; + +bool bLoadedConsoleButtonTex = false; +char LastFEngPackage[128]; +char CurrentSplashText[64]; + +#define LASTCONTROLLED_KB 0 +#define LASTCONTROLLED_CONTROLLER 1 +unsigned int LastControlledDevice = 0; // 0 = keyboard, 1 = controller +unsigned int LastControlledDeviceOldState = 0; + +#define CONTROLLERICON_XBOXONE 0 +#define CONTROLLERICON_PS4 1 +unsigned int ControllerIconMode = 0; // 0 = Xbox (One and later only for now), 1 = PlayStation (4 only now) -- planned to add: Nintendo (Wii/U Classic Controller, Switch), PS3/PS2, Xbox 360 + +// for triggering the over-zelaous inputs once in a tick... +WORD bQuitButtonOldState = 0; +WORD bZButtonOldState = 0; +WORD bXButtonOldState = 0; + +struct CONTROLLER_STATE +{ + XINPUT_STATE state; + bool bConnected; +}g_Controllers[MAX_CONTROLLERS]; + +enum ResourceFileType +{ + RESOURCE_FILE_NONE = 0, + RESOURCE_FILE_GLOBAL = 1, + RESOURCE_FILE_FRONTEND = 2, + RESOURCE_FILE_INGAME = 3, + RESOURCE_FILE_TRACK = 4, + RESOURCE_FILE_NIS = 5, + RESOURCE_FILE_CAR = 6, + RESOURCE_FILE_LANGUAGE = 7, + RESOURCE_FILE_REPLAY = 8, +}; + +void*(*CreateResourceFile)(char* filename, int ResType, int unk1, int unk2, int unk3) = (void*(*)(char*, int, int, int, int))0x004482F0; +void(*ServiceResourceLoading)() = (void(*)())0x004483C0; +unsigned int(*GetTextureInfo)(unsigned int hash, int unk, int unk2) = (unsigned int(*)(unsigned int, int, int))0x005461C0; + +unsigned int GameWndProcAddr = 0; +LRESULT(WINAPI* GameWndProc)(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam); + +LRESULT WINAPI CustomWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) +{ + if (msg == WM_KEYDOWN) + LastControlledDevice = LASTCONTROLLED_KB; + + return GameWndProc(hWnd, msg, wParam, lParam); +} + +unsigned int ResourceFile_BeginLoading_Addr = 0x00448110; +void __stdcall ResourceFile_BeginLoading(void* ResourceFile, void* unk1, int unk2) +{ + _asm + { + mov edx, ResourceFile + mov ecx, unk2 + mov eax, unk1 + call ResourceFile_BeginLoading_Addr + } +} + +void __stdcall LoadResourceFile(char* filename, int ResType, int unk1, void* unk2, int unk3, int unk4, int unk5) +{ + ResourceFile_BeginLoading(CreateResourceFile(filename, ResType, unk1, unk4, unk5), unk2, unk3); +} + +unsigned int FEHashUpper_Addr = 0x004FD230; +unsigned int __stdcall FEHashUpper(const char* instr) +{ + unsigned int result = 0; + _asm + { + mov edx, instr + call FEHashUpper_Addr + mov result, eax + } + return result; +} + +// entrypoint: 0x004B0CB9 +unsigned int FECarOrbitCave_Exit1 = 0x004B0CC1; +unsigned int FECarOrbitCave_Exit2 = 0x4B0D37; +static bool bOrbitingWithRightStick = 0; +void __declspec(naked) FECarOrbitCave() +{ + // using assembly here because MSVC insists on using the ebp register... + _asm + { + mov al, ds:FEMOUSECURSOR_BUTTONPRESS_ADDR + mov cl, bOrbitingWithRightStick + or al, cl + mov bCarOrbitState, al + } + + if (bCarOrbitState != bCarOrbitOldState) + { + // on the change to false, for precisely 1 tick allow the variables to be updated + _asm + { + mov al, bCarOrbitState + mov bCarOrbitOldState, al + jmp FECarOrbitCave_Exit1 + } + } + + if (bCarOrbitState) + _asm jmp FECarOrbitCave_Exit1 + _asm jmp FECarOrbitCave_Exit2 +} + +// texture & control stuff +unsigned int FEPkgMgr_FindPackage_Addr = 0x004F65D0; +unsigned int FEPackageManager_FindPackage_Addr = 0x004F3F90; +unsigned int FEngFindObject_Addr = 0x004FFB70; +unsigned int FEngSendMessageToPackage_Addr = 0x004C96C0; +unsigned int FEPrintf_Addr = 0x004F68A0; +#pragma runtime_checks( "", off ) +int __stdcall FEPrintf(void* FEString, char* format) +{ + _asm + { + mov eax, FEString + push format + call FEPrintf_Addr + } +} +#pragma runtime_checks( "", restore ) +void __stdcall FEngSendMessageToPackage(unsigned int msg, char* dest) +{ + _asm + { + push msg + mov eax, dest + call FEngSendMessageToPackage_Addr + add esp, 4 + } +} + +unsigned int __stdcall FEPkgMgr_FindPackage(const char* pkgname) +{ + unsigned int result = 0; + _asm + { + mov eax, pkgname + call FEPkgMgr_FindPackage_Addr + mov result, eax + } + return result; +} + +unsigned int __stdcall FEPackageManager_FindPackage(const char* pkgname) +{ + unsigned int result = 0; + _asm + { + push 0x00746104 + mov eax, pkgname + call FEPackageManager_FindPackage_Addr + mov result, eax + } + return result; +} + +unsigned int __stdcall _FEngFindObject(const char* pkg, int hash) +{ + unsigned int result = 0; + _asm + { + mov ecx, hash + mov edx, pkg + call FEngFindObject_Addr + mov result, eax + } + return result; +} + +unsigned int __stdcall FEngFindObject(const char* pkg, int hash) +{ + char* pkgname = (char*)FEPkgMgr_FindPackage(pkg); + if (!pkgname) + return 0; + else + return _FEngFindObject(pkgname, hash); +} + +unsigned int __stdcall FEngSetTextureHash(unsigned int FEImage, int hash) +{ + int v2; + + if (FEImage) + { + if (*(int*)(FEImage + 36) != hash) + { + v2 = *(int*)(FEImage + 28); + *(int*)(FEImage + 36) = hash; + *(int*)(FEImage + 28) = v2 | 0x400000; + } + } + return FEImage; +} + +int __stdcall FEngFindString(const char* pkgname, int hash) +{ + int result; // r3 + + result = FEngFindObject(pkgname, hash); + if (!result || *(int*)(result + 24) != 2) + result = 0; + return result; +} + +int __stdcall FEngFindImage(const char* pkgname, int hash) +{ + int result; + + result = FEngFindObject(pkgname, hash); + if (!result || *(int*)(result + 24) != 1) + result = 0; + return result; +} + +void SnoopLastFEPackage(char* format, char* pkg) +{ + strcpy(LastFEngPackage, pkg); +} + +void SetPCFEButtons(char* pkgname) +{ + int FEImage = 0; + if (FEImage = FEngFindImage(pkgname, 0x06749436)) // DeleteProfile_hotkey + FEngSetTextureHash(FEImage, PC_DELETE); + if (FEImage = FEngFindImage(pkgname, 0xA7615A5D)) // DeletePersona_hotkey + FEngSetTextureHash(FEImage, PC_DELETE); + if (FEImage = FEngFindImage(pkgname, 0x6E1D75B7)) // Default_hotkey + FEngSetTextureHash(FEImage, PC_CREATEROOM); + if (FEImage = FEngFindImage(pkgname, 0x83A65176)) // Stock_hotkey + FEngSetTextureHash(FEImage, PC_CREATEROOM); + if (FEImage = FEngFindImage(pkgname, 0xC8754FA4)) // Performance_hotkey + FEngSetTextureHash(FEImage, PC_PERFORMANCE); + if (FEImage = FEngFindImage(pkgname, 0xA16A1877)) // Changecolor_hotkey -- during car color changer + FEngSetTextureHash(FEImage, PC_X); + if (FEImage = FEngFindImage(pkgname, 0xBDD6AEEA)) // DecalColor_hotkey + FEngSetTextureHash(FEImage, PC_CREATEROOM); + if (FEImage = FEngFindImage(pkgname, 0x548F2015)) // Quit_hotkey + FEngSetTextureHash(FEImage, PC_QUIT); + if (FEImage = FEngFindImage(pkgname, 0x55DAFA35)) // customize_hotkey + FEngSetTextureHash(FEImage, PC_CUSTOM); + if (FEImage = FEngFindImage(pkgname, 0x571A8D51)) // Next_hotkey -- the "accept" button + FEngSetTextureHash(FEImage, PC_X); + if (FEImage = FEngFindImage(pkgname, 0x2A1208C3)) // Back_hotkey + FEngSetTextureHash(FEImage, PC_BACK); + if (FEImage = FEngFindImage(pkgname, 0x6340B325)) // PC_tutorial_01 (tutorial key) + FEngSetTextureHash(FEImage, PC_TUTORIAL); + if (FEImage = FEngFindImage(pkgname, 0x6340B326)) // PC_tutorial_02 (tutorial key) + FEngSetTextureHash(FEImage, PC_TUTORIAL); + + // set splash screen text + if (FEHashUpper(pkgname) == 0x2729D8C3) // if we're in LS_Splash_PC.fng + { + wcstombs(CurrentSplashText, *(wchar_t**)(FEngFindString("LS_Splash_PC.fng", 0x13CF446D) + 0x60), 0x800); + if (FEHashUpper(CurrentSplashText) != 0xE7126192) // "Press enter to continue" -- TODO: multi-lingual support... + FEPrintf((void*)FEngFindString("LS_Splash_PC.fng", 0x13CF446D), "Press enter to continue"); // mouse_click text object + } +} + +void SetPCIGButtons(char* pkgname) +{ + int FEImage = 0; + if (FEImage = FEngFindImage(pkgname, 0x571A8D51)) // Next_hotkey -- the "accept" button + FEngSetTextureHash(FEImage, PC_X); + if (FEImage = FEngFindImage(pkgname, 0x2A1208C3)) // Back_hotkey + FEngSetTextureHash(FEImage, PC_BACK); + if (FEImage = FEngFindImage(pkgname, 0x548F2015)) // Quit_hotkey + FEngSetTextureHash(FEImage, PC_QUIT); +} + +void SetXboxFEButtons(char* pkgname) +{ + int FEImage = 0; + if (FEImage = FEngFindImage(pkgname, 0x06749436)) // DeleteProfile_hotkey + FEngSetTextureHash(FEImage, XBOXY_HASH); + if (FEImage = FEngFindImage(pkgname, 0xA7615A5D)) // DeletePersona_hotkey + FEngSetTextureHash(FEImage, XBOXY_HASH); + if (FEImage = FEngFindImage(pkgname, 0x6E1D75B7)) // Default_hotkey + FEngSetTextureHash(FEImage, XBOXY_HASH); + if (FEImage = FEngFindImage(pkgname, 0x83A65176)) // Stock_hotkey + FEngSetTextureHash(FEImage, XBOXY_HASH); + //if (FEImage = FEngFindImage(pkgname, 0xAD7303C0)) // CreateGame_hotkey + // FEngSetTextureHash(FEImage, XBOXY_HASH); + if (FEImage = FEngFindImage(pkgname, 0xC8754FA4)) // Performance_hotkey + FEngSetTextureHash(FEImage, XBOXX_HASH); + if (FEImage = FEngFindImage(pkgname, 0xA16A1877)) // Changecolor_hotkey -- during car color changer + FEngSetTextureHash(FEImage, XBOXA_HASH); + if (FEImage = FEngFindImage(pkgname, 0xBDD6AEEA)) // DecalColor_hotkey + FEngSetTextureHash(FEImage, XBOXY_HASH); + if (FEImage = FEngFindImage(pkgname, 0x548F2015)) // Quit_hotkey + FEngSetTextureHash(FEImage, XBOXBACK_HASH); + if (FEImage = FEngFindImage(pkgname, 0x55DAFA35)) // customize_hotkey + FEngSetTextureHash(FEImage, XBOXX_HASH); + if (FEImage = FEngFindImage(pkgname, 0x571A8D51)) // Next_hotkey -- the "accept" button + FEngSetTextureHash(FEImage, XBOXA_HASH); + if (FEImage = FEngFindImage(pkgname, 0x2A1208C3)) // Back_hotkey + FEngSetTextureHash(FEImage, XBOXB_HASH); + if (FEImage = FEngFindImage(pkgname, 0x6340B325)) // PC_tutorial_01 (tutorial key) + FEngSetTextureHash(FEImage, XBOXLT_HASH); + if (FEImage = FEngFindImage(pkgname, 0x6340B326)) // PC_tutorial_02 (tutorial key) + FEngSetTextureHash(FEImage, XBOXLT_HASH); + + + + // set splash screen text + if (FEHashUpper(pkgname) == 0x2729D8C3) // if we're in LS_Splash_PC.fng + { + wcstombs(CurrentSplashText, *(wchar_t**)(FEngFindString("LS_Splash_PC.fng", 0x13CF446D) + 0x60), 0x800); + if (FEHashUpper(CurrentSplashText) != 0x544518FD) // "Press MENU button" + FEPrintf((void*)FEngFindString("LS_Splash_PC.fng", 0x13CF446D), "Press MENU/A button"); // mouse_click text object + } +} + +void SetXboxIGButtons(char* pkgname) +{ + int FEImage = 0; + if (FEImage = FEngFindImage(pkgname, 0x571A8D51)) // Next_hotkey -- the "accept" button + FEngSetTextureHash(FEImage, XBOXA_HASH); + if (FEImage = FEngFindImage(pkgname, 0x2A1208C3)) // Back_hotkey + FEngSetTextureHash(FEImage, XBOXB_HASH); + if (FEImage = FEngFindImage(pkgname, 0x548F2015)) // Quit_hotkey + FEngSetTextureHash(FEImage, XBOXBACK_HASH); +} + +void SetPlayStationFEButtons(char* pkgname) +{ + int FEImage = 0; + if (FEImage = FEngFindImage(pkgname, 0x06749436)) // DeleteProfile_hotkey + FEngSetTextureHash(FEImage, PSTRIANGLE_HASH); + if (FEImage = FEngFindImage(pkgname, 0xA7615A5D)) // DeletePersona_hotkey + FEngSetTextureHash(FEImage, PSTRIANGLE_HASH); + if (FEImage = FEngFindImage(pkgname, 0x6E1D75B7)) // Default_hotkey + FEngSetTextureHash(FEImage, PSTRIANGLE_HASH); + if (FEImage = FEngFindImage(pkgname, 0x83A65176)) // Stock_hotkey + FEngSetTextureHash(FEImage, PSTRIANGLE_HASH); + //if (FEImage = FEngFindImage(pkgname, 0xAD7303C0)) // CreateGame_hotkey + // FEngSetTextureHash(FEImage, PSTRIANGLE_HASH); + if (FEImage = FEngFindImage(pkgname, 0xC8754FA4)) // Performance_hotkey + FEngSetTextureHash(FEImage, PSSQUARE_HASH); + if (FEImage = FEngFindImage(pkgname, 0xA16A1877)) // Changecolor_hotkey -- during car color changer + FEngSetTextureHash(FEImage, PSCROSS_HASH); + if (FEImage = FEngFindImage(pkgname, 0xBDD6AEEA)) // DecalColor_hotkey + FEngSetTextureHash(FEImage, PSTRIANGLE_HASH); + if (FEImage = FEngFindImage(pkgname, 0x548F2015)) // Quit_hotkey + FEngSetTextureHash(FEImage, PSSHARE_HASH); + if (FEImage = FEngFindImage(pkgname, 0x55DAFA35)) // customize_hotkey + FEngSetTextureHash(FEImage, PSSQUARE_HASH); + if (FEImage = FEngFindImage(pkgname, 0x571A8D51)) // Next_hotkey -- the "accept" button + FEngSetTextureHash(FEImage, PSCROSS_HASH); + if (FEImage = FEngFindImage(pkgname, 0x2A1208C3)) // Back_hotkey + FEngSetTextureHash(FEImage, PSCIRCLE_HASH); + if (FEImage = FEngFindImage(pkgname, 0x6340B325)) // PC_tutorial_01 (tutorial key) + FEngSetTextureHash(FEImage, PSL2_HASH); + if (FEImage = FEngFindImage(pkgname, 0x6340B326)) // PC_tutorial_02 (tutorial key) + FEngSetTextureHash(FEImage, PSL2_HASH); + + // set splash screen text + if (FEHashUpper(pkgname) == 0x2729D8C3) // if we're in LS_Splash_PC.fng + { + wcstombs(CurrentSplashText, *(wchar_t**)(FEngFindString("LS_Splash_PC.fng", 0x13CF446D) + 0x60), 0x800); + if (FEHashUpper(CurrentSplashText) != 0x0BACC2D4) // "Press OPTIONS button" + FEPrintf((void*)FEngFindString("LS_Splash_PC.fng", 0x13CF446D), "Press OPTIONS/X button"); // mouse_click text object + } +} + +void SetPlayStationIGButtons(char* pkgname) +{ + int FEImage = 0; + if (FEImage = FEngFindImage(pkgname, 0x571A8D51)) // Next_hotkey -- the "accept" button + FEngSetTextureHash(FEImage, PSCROSS_HASH); + if (FEImage = FEngFindImage(pkgname, 0x2A1208C3)) // Back_hotkey + FEngSetTextureHash(FEImage, PSCIRCLE_HASH); + if (FEImage = FEngFindImage(pkgname, 0x548F2015)) // Quit_hotkey + FEngSetTextureHash(FEImage, PSSHARE_HASH); +} + +void __stdcall SetControllerFEng(char* pkgname) +{ + if (!bLoadedConsoleButtonTex) + { + LoadResourceFile("GLOBAL\\UG_ConsoleButtons.tpk", RESOURCE_FILE_NONE, 0, NULL, 0, 0, 0); + ServiceResourceLoading(); + bLoadedConsoleButtonTex = true; + } + + if (*(int*)GAMEFLOWMANAGER_STATUS_ADDR == 3) + { + if (LastControlledDevice == LASTCONTROLLED_CONTROLLER) + { + switch (ControllerIconMode) + { + case CONTROLLERICON_PS4: + SetPlayStationFEButtons(pkgname); + break; + case CONTROLLERICON_XBOXONE: + default: + SetXboxFEButtons(pkgname); + break; + } + } + if (LastControlledDevice == LASTCONTROLLED_KB) + SetPCFEButtons(pkgname); + + } + if (*(int*)GAMEFLOWMANAGER_STATUS_ADDR == 6) + { + if (LastControlledDevice == LASTCONTROLLED_CONTROLLER) + { + switch (ControllerIconMode) + { + case CONTROLLERICON_PS4: + SetPlayStationIGButtons(pkgname); + break; + case CONTROLLERICON_XBOXONE: + default: + SetXboxIGButtons(pkgname); + break; + } + } + if (LastControlledDevice == LASTCONTROLLED_KB) + SetPCIGButtons(pkgname); + } +} + +// entrypoint: 0x004F7C08 +unsigned int FEngGlobalCaveExit = 0x004F7C0E; +unsigned int FEngGlobalCaveEBP = 0; +unsigned int FEngGlobalCaveESI = 0; +char* CurrentFEngPackage = NULL; +void __declspec(naked) FEngGlobalCave() +{ + _asm mov FEngGlobalCaveEBP, ebp + _asm mov FEngGlobalCaveESI, esi + CurrentFEngPackage = *(char**)(FEngGlobalCaveESI + 0xC); + SetControllerFEng(CurrentFEngPackage); + _asm + { + mov esi, FEngGlobalCaveESI + mov ebp, FEngGlobalCaveEBP + cmp ebp, 0xC519BFC3 + jmp FEngGlobalCaveExit + } +} + +void DummyFunc() +{ + return; +} + +HRESULT UpdateControllerState() +{ + DWORD dwResult; + + dwResult = XInputGetState(0, &g_Controllers[0].state); + + if (dwResult == ERROR_SUCCESS) + g_Controllers[0].bConnected = true; + else + g_Controllers[0].bConnected = false; + + dwResult = XInputGetState(1, &g_Controllers[1].state); + + if (dwResult == ERROR_SUCCESS) + g_Controllers[1].bConnected = true; + else + g_Controllers[1].bConnected = false; + + return S_OK; +} + +void ReadXInput() +{ + std::bitset<32> b1(*(int*)JOYBUTTONS1_ADDR); + std::bitset<32> b2(*(int*)JOYBUTTONS2_ADDR); + bool bLastWasKeyboard = false; + + if (g_Controllers[0].bConnected) + { + WORD wButtons = g_Controllers[0].state.Gamepad.wButtons; + + // Zero value if thumbsticks are within the dead zone + if ((g_Controllers[0].state.Gamepad.sThumbLX < INPUT_DEADZONE && + g_Controllers[0].state.Gamepad.sThumbLX > -INPUT_DEADZONE) && + (g_Controllers[0].state.Gamepad.sThumbLY < INPUT_DEADZONE && + g_Controllers[0].state.Gamepad.sThumbLY > -INPUT_DEADZONE)) + { + g_Controllers[0].state.Gamepad.sThumbLX = 0; + g_Controllers[0].state.Gamepad.sThumbLY = 0; + } + + if ((g_Controllers[0].state.Gamepad.sThumbRX < INPUT_DEADZONE && + g_Controllers[0].state.Gamepad.sThumbRX > -INPUT_DEADZONE) && + (g_Controllers[0].state.Gamepad.sThumbRY < INPUT_DEADZONE && + g_Controllers[0].state.Gamepad.sThumbRY > -INPUT_DEADZONE)) + { + g_Controllers[0].state.Gamepad.sThumbRX = 0; + g_Controllers[0].state.Gamepad.sThumbRY = 0; + } + + if (wButtons || g_Controllers[0].state.Gamepad.sThumbLX || g_Controllers[0].state.Gamepad.sThumbLY || g_Controllers[0].state.Gamepad.sThumbRX || g_Controllers[0].state.Gamepad.sThumbRY || g_Controllers[0].state.Gamepad.bRightTrigger || g_Controllers[0].state.Gamepad.bLeftTrigger) + LastControlledDevice = LASTCONTROLLED_CONTROLLER; + + *(unsigned char*)THROTTLE_AXIS_ADDR = g_Controllers[0].state.Gamepad.bRightTrigger; + *(unsigned char*)BRAKE_AXIS_ADDR = g_Controllers[0].state.Gamepad.bLeftTrigger; + *(char*)STEER_AXIS_ADDR = (char)(((float)(g_Controllers[0].state.Gamepad.sThumbLX) / (float)(0x7FFF)) * (float)(0x7F)) + 0x80; + + b1[NFSUJOY_DIGITAL_LEFT] = b1[NFSUJOY_DIGITAL_LEFT] ? !(wButtons & XINPUT_GAMEPAD_DPAD_LEFT) : b1[NFSUJOY_DIGITAL_LEFT]; + b1[NFSUJOY_DIGITAL_RIGHT] = b1[NFSUJOY_DIGITAL_RIGHT] ? !(wButtons & XINPUT_GAMEPAD_DPAD_RIGHT) : b1[NFSUJOY_DIGITAL_RIGHT]; + + b1[NFSUJOY_PAUSE] = b1[NFSUJOY_PAUSE] ? !(wButtons & XINPUT_GAMEPAD_START) : b1[NFSUJOY_PAUSE]; + b1[NFSUJOY_NOS] = b1[NFSUJOY_NOS] ? !(wButtons & XINPUT_GAMEPAD_B) : b1[NFSUJOY_NOS]; + b1[NFSUJOY_EBRAKE] = b1[NFSUJOY_EBRAKE] ? !(wButtons & XINPUT_GAMEPAD_A) : b1[NFSUJOY_EBRAKE]; + b1[NFSUJOY_RESETCAR] = b1[NFSUJOY_RESETCAR] ? !(wButtons & XINPUT_GAMEPAD_BACK) : b1[NFSUJOY_RESETCAR]; + b1[NFSUJOY_LOOKBACK] = b1[NFSUJOY_LOOKBACK] ? !(wButtons & XINPUT_GAMEPAD_X) : b1[NFSUJOY_LOOKBACK]; + b1[NFSUJOY_CHANGECAM] = b1[NFSUJOY_CHANGECAM] ? !(wButtons & XINPUT_GAMEPAD_Y) : b1[NFSUJOY_CHANGECAM]; + b1[NFSUJOY_SHIFTUP] = b1[NFSUJOY_SHIFTUP] ? !(g_Controllers[0].state.Gamepad.sThumbRY > SHIFT_ANALOG_THRESHOLD) : b1[NFSUJOY_SHIFTUP]; + b1[NFSUJOY_SHIFTDOWN] = b1[NFSUJOY_SHIFTDOWN] ? !(g_Controllers[0].state.Gamepad.sThumbRY < -SHIFT_ANALOG_THRESHOLD) : b1[NFSUJOY_SHIFTDOWN]; + + b1[NFSUJOY_FE_UP] = b1[NFSUJOY_FE_UP] ? !(wButtons & XINPUT_GAMEPAD_DPAD_UP) : b1[NFSUJOY_FE_UP]; + b1[NFSUJOY_FE_DOWN] = b1[NFSUJOY_FE_DOWN] ? !(wButtons & XINPUT_GAMEPAD_DPAD_DOWN) : b1[NFSUJOY_FE_DOWN]; + b1[NFSUJOY_FE_UP] = b1[NFSUJOY_FE_UP] ? !(g_Controllers[0].state.Gamepad.sThumbLY > FEUPDOWN_ANALOG_THRESHOLD) : b1[NFSUJOY_FE_UP]; + b1[NFSUJOY_FE_DOWN] = b1[NFSUJOY_FE_DOWN] ? !(g_Controllers[0].state.Gamepad.sThumbLY < -FEUPDOWN_ANALOG_THRESHOLD) : b1[NFSUJOY_FE_DOWN]; + + b1[NFSUJOY_FE_LEFT] = b1[NFSUJOY_FE_LEFT] ? !(wButtons & XINPUT_GAMEPAD_DPAD_LEFT) : b1[NFSUJOY_FE_LEFT]; + b1[NFSUJOY_FE_RIGHT] = b1[NFSUJOY_FE_RIGHT] ? !(wButtons & XINPUT_GAMEPAD_DPAD_RIGHT) : b1[NFSUJOY_FE_RIGHT]; + b1[NFSUJOY_FE_ACCEPT] = b1[NFSUJOY_FE_ACCEPT] ? !(wButtons & XINPUT_GAMEPAD_A) : b1[NFSUJOY_FE_ACCEPT]; + b1[NFSUJOY_FE_BACK] = b1[NFSUJOY_FE_BACK] ? !(wButtons & XINPUT_GAMEPAD_B) : b1[NFSUJOY_FE_BACK]; + b1[NFSUJOY_FE_BIT24] = b1[NFSUJOY_FE_BIT24] ? !(wButtons & XINPUT_GAMEPAD_X) : b1[NFSUJOY_FE_BIT24]; + b1[NFSUJOY_FE_BIT22] = b1[NFSUJOY_FE_BIT22] ? !(wButtons & XINPUT_GAMEPAD_Y) : b1[NFSUJOY_FE_BIT22]; + b1[NFSUJOY_FE_L1] = b1[NFSUJOY_FE_L1] ? !(wButtons & XINPUT_GAMEPAD_LEFT_SHOULDER) : b1[NFSUJOY_FE_L1]; + b1[NFSUJOY_FE_R1] = b1[NFSUJOY_FE_R1] ? !(wButtons & XINPUT_GAMEPAD_RIGHT_SHOULDER) : b1[NFSUJOY_FE_R1]; + b1[NFSUJOY_FE_L2] = b1[NFSUJOY_FE_L2] ? !(g_Controllers[0].state.Gamepad.bLeftTrigger > TRIGGER_ACTIVATION_THRESHOLD) : b1[NFSUJOY_FE_L2]; + b1[NFSUJOY_FE_R2] = b1[NFSUJOY_FE_R2] ? !(g_Controllers[0].state.Gamepad.bRightTrigger > TRIGGER_ACTIVATION_THRESHOLD) : b1[NFSUJOY_FE_R2]; + // splash screen start button + if (FEHashUpper(LastFEngPackage) == 0x2729D8C3) + b1[NFSUJOY_FE_ACCEPT] = b1[NFSUJOY_FE_ACCEPT] ? !(wButtons & XINPUT_GAMEPAD_START) : b1[NFSUJOY_FE_ACCEPT]; + + // car orbiting + if ((g_Controllers[0].state.Gamepad.sThumbRX != 0) || (g_Controllers[0].state.Gamepad.sThumbRY != 0)) + { + bOrbitingWithRightStick = true; + if (g_Controllers[0].state.Gamepad.sThumbRX != 0) + *(int*)FEMOUSECURSOR_CARORBIT_X_ADDR = -g_Controllers[0].state.Gamepad.sThumbRX; + if (g_Controllers[0].state.Gamepad.sThumbRY != 0) + *(int*)FEMOUSECURSOR_CARORBIT_Y_ADDR = g_Controllers[0].state.Gamepad.sThumbRY; + CarOrbitDivisor = 0.000031f; + } + else + { + bOrbitingWithRightStick = false; + CarOrbitDivisor = 0.5; + if (!*(bool*)FEMOUSECURSOR_BUTTONPRESS_ADDR) + { + *(int*)FEMOUSECURSOR_CARORBIT_X_ADDR = 0; + *(int*)FEMOUSECURSOR_CARORBIT_Y_ADDR = 0; + } + } + if (*(bool*)FEMOUSECURSOR_BUTTONPRESS_ADDR) + CarOrbitDivisor = 0.5; + + // tester + //b2[NFSUJOY_BIT33] = !(wButtons & XINPUT_GAMEPAD_DPAD_UP); + + // TODO: these are a lil' buggy + if (*(int*)GAMEFLOWMANAGER_STATUS_ADDR == 3) + { + if ((wButtons & XINPUT_GAMEPAD_X) != bXButtonOldState) + { + if (wButtons & XINPUT_GAMEPAD_X) // trigger once only on button down state + { + if (FEHashUpper((char*)CURRENT_MENUPKG_ADDR) == 0x1F549740) // MU_GaragePerformanceCategory.fng + *(char*)FE_WINDOWS_KEY_CODE_ADDR = 'P'; // performance stats + else if (FEHashUpper((char*)CURRENT_MENUPKG_ADDR) == 0xF53C6787) // MU_GarageVinylLayerV2.fng -- call the color picker when X is pressed!!! + FEngSendMessageToPackage(0xC519BFC0, "MU_GarageVinylLayerV2.fng"); + else + *(char*)FE_WINDOWS_KEY_CODE_ADDR = 'C'; // customize car + } + bXButtonOldState = wButtons & XINPUT_GAMEPAD_X; + } + + if ((wButtons & XINPUT_GAMEPAD_Y)) + *(char*)FE_WINDOWS_KEY_CODE_ADDR = 'D'; // delete profile + + if (((wButtons & XINPUT_GAMEPAD_Y) != bZButtonOldState) && (FEHashUpper((char*)CURRENT_MENUPKG_ADDR) != 0xFD6DFFB3)) // except in MU_UG_NewOrLoad_PC2.fng + { + if ((wButtons & XINPUT_GAMEPAD_Y)) // trigger once only on button down state + *(char*)FE_WINDOWS_KEY_CODE_ADDR = 'Z'; // reset to default, decal color, etc... + bZButtonOldState = (wButtons & XINPUT_GAMEPAD_Y); + } + + //if ((wButtons & XINPUT_GAMEPAD_B)) + // *(char*)FE_WINDOWS_KEY_CODE_ADDR = 0x1B; // escape + + if ((g_Controllers[0].state.Gamepad.bLeftTrigger > TRIGGER_ACTIVATION_THRESHOLD)) + *(char*)FE_WINDOWS_KEY_CODE_ADDR = 'T'; // tutorial + } + if ((wButtons & XINPUT_GAMEPAD_BACK) != bQuitButtonOldState) + { + if ((wButtons & XINPUT_GAMEPAD_BACK)) // trigger once only on button down state + *(char*)FE_WINDOWS_KEY_CODE_ADDR = 'Q'; + bQuitButtonOldState = (wButtons & XINPUT_GAMEPAD_BACK); + } + } + // controller 2 - debug camera and other stuff + if (g_Controllers[1].bConnected) + { + WORD wButtons = g_Controllers[1].state.Gamepad.wButtons; + b2[NFSUJOY_DEBUGCAM_ACTIVATE] = b2[NFSUJOY_DEBUGCAM_ACTIVATE] ? !(wButtons & XINPUT_GAMEPAD_BACK) : b2[NFSUJOY_DEBUGCAM_ACTIVATE]; + b2[NFSUJOY_DEBUGCAM_MOVEFORWARD] = b2[NFSUJOY_DEBUGCAM_MOVEFORWARD] ? !(wButtons & XINPUT_GAMEPAD_A) : b2[NFSUJOY_DEBUGCAM_MOVEFORWARD]; + b2[NFSUJOY_DEBUGCAM_MOVEBACKWARD] = b2[NFSUJOY_DEBUGCAM_MOVEBACKWARD] ? !(wButtons & XINPUT_GAMEPAD_Y) : b2[NFSUJOY_DEBUGCAM_MOVEBACKWARD]; + b2[NFSUJOY_DEBUGCAM_MOVELEFT] = b2[NFSUJOY_DEBUGCAM_MOVELEFT] ? !(wButtons & XINPUT_GAMEPAD_X) : b2[NFSUJOY_DEBUGCAM_MOVELEFT]; + b2[NFSUJOY_DEBUGCAM_MOVERIGHT] = b2[NFSUJOY_DEBUGCAM_MOVERIGHT] ? !(wButtons & XINPUT_GAMEPAD_B) : b2[NFSUJOY_DEBUGCAM_MOVERIGHT]; + b2[NFSUJOY_DEBUGCAM_MOVEUP] = b2[NFSUJOY_DEBUGCAM_MOVEUP] ? !(wButtons & XINPUT_GAMEPAD_LEFT_SHOULDER) : b2[NFSUJOY_DEBUGCAM_MOVEUP]; + b2[NFSUJOY_DEBUGCAM_MOVEDOWN] = b2[NFSUJOY_DEBUGCAM_MOVEDOWN] ? !(g_Controllers[1].state.Gamepad.bLeftTrigger > TRIGGER_ACTIVATION_THRESHOLD) : b2[NFSUJOY_DEBUGCAM_MOVEDOWN]; + b2[NFSUJOY_DEBUGCAM_LOOKUP] = b2[NFSUJOY_DEBUGCAM_LOOKUP] ? !(wButtons & XINPUT_GAMEPAD_DPAD_UP) : b2[NFSUJOY_DEBUGCAM_LOOKUP]; + b2[NFSUJOY_DEBUGCAM_LOOKDOWN] = b2[NFSUJOY_DEBUGCAM_LOOKDOWN] ? !(wButtons & XINPUT_GAMEPAD_DPAD_DOWN) : b2[NFSUJOY_DEBUGCAM_LOOKDOWN]; + b2[NFSUJOY_DEBUGCAM_LOOKLEFT] = b2[NFSUJOY_DEBUGCAM_LOOKLEFT] ? !(wButtons & XINPUT_GAMEPAD_DPAD_LEFT) : b2[NFSUJOY_DEBUGCAM_LOOKLEFT]; + b2[NFSUJOY_DEBUGCAM_LOOKRIGHT] = b2[NFSUJOY_DEBUGCAM_LOOKRIGHT] ? !(wButtons & XINPUT_GAMEPAD_DPAD_RIGHT) : b2[NFSUJOY_DEBUGCAM_LOOKRIGHT]; + b2[NFSUJOY_DEBUGCAM_TURBO] = b2[NFSUJOY_DEBUGCAM_TURBO] ? !(wButtons & XINPUT_GAMEPAD_RIGHT_SHOULDER) : b2[NFSUJOY_DEBUGCAM_TURBO]; + b2[NFSUJOY_DEBUGCAM_SUPERTURBO] = b2[NFSUJOY_DEBUGCAM_SUPERTURBO] ? !(g_Controllers[1].state.Gamepad.bRightTrigger > TRIGGER_ACTIVATION_THRESHOLD) : b2[NFSUJOY_DEBUGCAM_SUPERTURBO]; + } + + // write bits back + *(int*)JOYBUTTONS1_ADDR = b1.to_ulong(); + *(int*)JOYBUTTONS2_ADDR = b2.to_ulong(); +} + +void __stdcall ReadControllerData() +{ + UpdateControllerState(); + ReadXInput(); +} + +// entrypoint: 0x004065AD +unsigned int JoyEventCaveExit = 0x004065B6; +unsigned int SavedObj = 0; +void __declspec(naked) JoyEventCave() +{ + _asm mov SavedObj, esi + + ReadControllerData(); + + _asm + { + mov esi, SavedObj + mov eax, [esi+8] + mov edi, ds:JOYBUTTONS1_ADDR + jmp JoyEventCaveExit + } +} + +void InitConfig() +{ + CIniReader inireader(""); + + ControllerIconMode = inireader.ReadInteger("Icons", "ControllerIconMode", 0); + LastControlledDevice = inireader.ReadInteger("Icons", "FirstControlDevice", 0); +} + +int Init() +{ + // kill DInput8 joypad reading & event generation -- TODO: try to kill dinput from ever being created if possible + injector::MakeCALL(0x0040A7B5, DummyFunc, true); + injector::MakeCALL(0x00401921, DummyFunc, true); + injector::MakeCALL(0x0040164C, DummyFunc, true); + injector::MakeJMP(0x004071B8, 0x004075D1, true); + // hook the reading for XInput + injector::MakeJMP(0x004065AD, JoyEventCave, true); + // hook for car orbiting with right stick (hooking mouse inputs) + bugfix (adding a slight delay to give time for the actual vars to be read and updated) + injector::MakeJMP(0x004B0CB9, FECarOrbitCave, true); + injector::WriteMemory(0x004B0CE7, (int)&CarOrbitDivisor, true); + injector::WriteMemory(0x004B0D17, (int)&CarOrbitDivisor, true); + // hook FEng globally in FEPkgMgr_SendMessageToPackage + injector::MakeJMP(0x004F7C08, FEngGlobalCave, true); + // snoop last activated FEng package + injector::MakeCALL(0x004F3BC3, SnoopLastFEPackage, true); + + // this kills DInput enumeration COMPLETELY -- even the keyboard + //injector::MakeJMP(0x00405695, 0x004056AA, true); + // kill DInput8 enumeration for joypads only + injector::MakeJMP(0x00418E4B, 0x00418E68, true); + + // dereference the current WndProc from the game executable and write to the function pointer (to maximize compatibility) + GameWndProcAddr = *(unsigned int*)0x4088FC; + GameWndProc = (LRESULT(WINAPI*)(HWND, UINT, WPARAM, LPARAM))GameWndProcAddr; + injector::WriteMemory(0x4088FC, (unsigned int)&CustomWndProc, true); + + // Init state + ZeroMemory(g_Controllers, sizeof(CONTROLLER_STATE) * MAX_CONTROLLERS); + + InitConfig(); + + return 0; +} + + +BOOL APIENTRY DllMain(HMODULE /*hModule*/, DWORD reason, LPVOID /*lpReserved*/) +{ + if (reason == DLL_PROCESS_ATTACH) + { + freopen("CON", "w", stdout); + freopen("CON", "w", stderr); + Init(); + } + return TRUE; +} + diff --git a/includes/IniReader.h b/includes/IniReader.h new file mode 100644 index 0000000..1ca2d4d --- /dev/null +++ b/includes/IniReader.h @@ -0,0 +1,103 @@ +#ifndef INIREADER_H +#define INIREADER_H + +#include "stdafx.h" +#include +#include +using namespace std; +#pragma warning(disable:4996) +EXTERN_C IMAGE_DOS_HEADER __ImageBase; + +class CIniReader +{ +public: + CIniReader(char* szFileName) + { + char moduleName[MAX_PATH]; + char dllPath[MAX_PATH]; + char iniName[MAX_PATH]; + char* tempPointer; + + GetModuleFileName((HINSTANCE)&__ImageBase, moduleName, MAX_PATH); + tempPointer = strrchr(moduleName, '.'); + *tempPointer = '\0'; + tempPointer = strrchr(moduleName, '\\'); + strncpy(iniName, tempPointer + 1, 255); + strcat(iniName, ".ini"); + strncpy(dllPath, moduleName, (tempPointer - moduleName + 1)); + dllPath[tempPointer - moduleName + 1] = '\0'; + if (strcmp(szFileName, "") == 0) + { + strcat(dllPath, iniName); + } + else { + strcat(dllPath, szFileName); + } + + memset(m_szFileName, 0x00, 255); + memcpy(m_szFileName, dllPath, strlen(dllPath)); + } + int ReadInteger(char* szSection, char* szKey, int iDefaultValue) + { + int iResult = GetPrivateProfileInt(szSection, szKey, iDefaultValue, m_szFileName); + return iResult; + } + float ReadFloat(char* szSection, char* szKey, float fltDefaultValue) + { + char szResult[255]; + char szDefault[255]; + float fltResult; + _snprintf(szDefault, 255, "%f", fltDefaultValue); + GetPrivateProfileString(szSection, szKey, szDefault, szResult, 255, m_szFileName); + fltResult = (float)atof(szResult); + return fltResult; + } + bool ReadBoolean(char* szSection, char* szKey, bool bolDefaultValue) + { + char szResult[255]; + char szDefault[255]; + bool bolResult; + _snprintf(szDefault, 255, "%s", bolDefaultValue ? "True" : "False"); + GetPrivateProfileString(szSection, szKey, szDefault, szResult, 255, m_szFileName); + bolResult = (strcmp(szResult, "True") == 0 || + strcmp(szResult, "true") == 0) ? true : false; + return bolResult; + } + char* ReadString(char* szSection, char* szKey, const char* szDefaultValue) + { + char* szResult = new char[255]; + memset(szResult, 0x00, 255); + GetPrivateProfileString(szSection, szKey, + szDefaultValue, szResult, 255, m_szFileName); + return szResult; + } + void WriteInteger(char* szSection, char* szKey, int iValue) + { + char szValue[255]; + _snprintf(szValue, 255, "%s%d", " ", iValue); + WritePrivateProfileString(szSection, szKey, szValue, m_szFileName); + } + void WriteFloat(char* szSection, char* szKey, float fltValue) + { + char szValue[255]; + _snprintf(szValue, 255, "%s%f", " ", fltValue); + WritePrivateProfileString(szSection, szKey, szValue, m_szFileName); + } + void WriteBoolean(char* szSection, char* szKey, bool bolValue) + { + char szValue[255]; + _snprintf(szValue, 255, "%s%s", " ", bolValue ? "True" : "False"); + WritePrivateProfileString(szSection, szKey, szValue, m_szFileName); + } + void WriteString(char* szSection, char* szKey, char* szValue) + { + WritePrivateProfileString(szSection, szKey, szValue, m_szFileName); + } + char* GetIniPath() + { + return m_szFileName; + } +private: + char m_szFileName[MAX_PATH]; +}; +#endif//INIREADER_H \ No newline at end of file diff --git a/includes/injector/LICENSE b/includes/injector/LICENSE new file mode 100644 index 0000000..65960fb --- /dev/null +++ b/includes/injector/LICENSE @@ -0,0 +1,21 @@ +Copyright (C) 2012-2014 LINK/2012 + +This software is provided 'as-is', without any express or implied +warranty. In no event will the authors be held liable for any damages +arising from the use of this software. + +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it +freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + + 3. This notice may not be removed or altered from any source + distribution. + diff --git a/includes/injector/assembly.hpp b/includes/injector/assembly.hpp new file mode 100644 index 0000000..9854a34 --- /dev/null +++ b/includes/injector/assembly.hpp @@ -0,0 +1,179 @@ +/* + * Injectors - Useful Assembly Stuff + * + * Copyright (C) 2012-2014 LINK/2012 + * + * This software is provided 'as-is', without any express or implied + * warranty. In no event will the authors be held liable for any damages + * arising from the use of this software. + * + * Permission is granted to anyone to use this software for any purpose, + * including commercial applications, and to alter it and redistribute it + * freely, subject to the following restrictions: + * + * 1. The origin of this software must not be misrepresented; you must not + * claim that you wrote the original software. If you use this software + * in a product, an acknowledgment in the product documentation would be + * appreciated but is not required. + * + * 2. Altered source versions must be plainly marked as such, and must not be + * misrepresented as being the original software. + * + * 3. This notice may not be removed or altered from any source + * distribution. + * + */ +#pragma once + +// This header is very restrict about compiler and architecture +#ifndef _MSC_VER // MSVC is much more flexible when we're talking about inline assembly +#error Cannot use this header in another compiler other than MSVC +#endif +#ifndef _M_IX86 +#error Supported only in x86 +#endif + +// +#include +#include "injector.hpp" + +namespace injector +{ + struct reg_pack + { + // The ordering is very important, don't change + // The first field is the last to be pushed and first to be poped + + // PUSHFD / POPFD + uint32_t ef; + + // PUSHAD/POPAD -- must be the lastest fields (because of esp) + union + { + uint32_t arr[8]; + struct { uint32_t edi, esi, ebp, esp, ebx, edx, ecx, eax; }; + }; + + enum reg_name { + reg_edi, reg_esi, reg_ebp, reg_esp, reg_ebx, reg_edx, reg_ecx, reg_eax + }; + + enum ef_flag { + carry_flag = 0, parity_flag = 2, adjust_flag = 4, zero_flag = 6, sign_flag = 7, + direction_flag = 10, overflow_flag = 11 + }; + + uint32_t& operator[](size_t i) + { return this->arr[i]; } + const uint32_t& operator[](size_t i) const + { return this->arr[i]; } + + template // bit starts from 0, use ef_flag enum + bool flag() + { + return (this->ef & (1 << bit)) != 0; + } + + bool jnb() + { + return flag() == false; + } + }; + + // Lowest level stuff (actual assembly) goes on the following namespace + // PRIVATE! Skip this, not interesting for you. + namespace injector_asm + { + // Wrapper functor, so the assembly can use some templating + template + struct wrapper + { + static void call(reg_pack* regs) + { + T fun; fun(*regs); + } + }; + + // Constructs a reg_pack and calls the wrapper functor + template // where W is of type wrapper + inline void __declspec(naked) make_reg_pack_and_call() + { + _asm + { + // Construct the reg_pack structure on the stack + pushad // Pushes general purposes registers to reg_pack + add [esp+12], 4 // Add 4 to reg_pack::esp 'cuz of our return pointer, let it be as before this func is called + pushfd // Pushes EFLAGS to reg_pack + + // Call wrapper sending reg_pack as parameter + push esp + call W::call + add esp, 4 + + // Destructs the reg_pack from the stack + sub [esp+12+4], 4 // Fix reg_pack::esp before popping it (doesn't make a difference though) (+4 because eflags) + popfd // Warning: Do not use any instruction that changes EFLAGS after this (-> sub affects EF!! <-) + popad + + // Back to normal flow + ret + } + } + }; + + + /* + * MakeInline + * Makes inline assembly (but not assembly, an actual functor of type FuncT) at address + */ + template + void MakeInline(memory_pointer_tr at) + { + typedef injector_asm::wrapper functor; + if(false) functor::call(nullptr); // To instantiate the template, if not done _asm will fail + MakeCALL(at, injector_asm::make_reg_pack_and_call); + } + + /* + * MakeInline + * Same as above, but it NOPs everything between at and end (exclusive), then performs MakeInline + */ + template + void MakeInline(memory_pointer_tr at, memory_pointer_tr end) + { + MakeRangedNOP(at, end); + MakeInline(at); + } + + /* + * MakeInline + * Same as above, but (at,end) are template parameters. + * On this case the functor can be passed as argument since there will be one func instance for each at,end not just for each FuncT + */ + template + void MakeInline(FuncT func) + { + static std::unique_ptr static_func; + static_func.reset(new FuncT(std::move(func))); + + // Encapsulates the call to static_func + struct Caps + { + void operator()(reg_pack& regs) + { (*static_func)(regs); } + }; + + // Does the actual MakeInline + return MakeInline(lazy_pointer::get(), lazy_pointer::get()); + } + + /* + * MakeInline + * Same as above, but (end) is calculated by the length of a call instruction + */ + template + void MakeInline(FuncT func) + { + return MakeInline(func); + } +}; diff --git a/includes/injector/calling.hpp b/includes/injector/calling.hpp new file mode 100644 index 0000000..ebf3bdf --- /dev/null +++ b/includes/injector/calling.hpp @@ -0,0 +1,126 @@ +/* + * Injectors - Function Calls Using Variadic Templates + * + * Copyright (C) 2014 LINK/2012 + * + * This software is provided 'as-is', without any express or implied + * warranty. In no event will the authors be held liable for any damages + * arising from the use of this software. + * + * Permission is granted to anyone to use this software for any purpose, + * including commercial applications, and to alter it and redistribute it + * freely, subject to the following restrictions: + * + * 1. The origin of this software must not be misrepresented; you must not + * claim that you wrote the original software. If you use this software + * in a product, an acknowledgment in the product documentation would be + * appreciated but is not required. + * + * 2. Altered source versions must be plainly marked as such, and must not be + * misrepresented as being the original software. + * + * 3. This notice may not be removed or altered from any source + * distribution. + * + */ +#pragma once +#include "injector.hpp" +#include + +#if __cplusplus >= 201103L || _MSC_VER >= 1800 // MSVC 2013 +#else +#error "This feature is not supported on this compiler" +#endif + +namespace injector +{ + template + struct cstd; + + template + struct cstd + { + // Call function at @p returning @Ret with args @Args + static Ret call(memory_pointer_tr p, Args... a) + { + auto fn = (Ret(*)(Args...)) p.get(); + return fn(std::forward(a)...); + } + + template // Uses lazy pointer + static Ret call(Args... a) + { + return call(lazy_pointer::get(), std::forward(a)...); + } + }; + + template + struct stdcall; + + template + struct stdcall + { + // Call function at @p returning @Ret with args @Args + static Ret call(memory_pointer_tr p, Args... a) + { + auto fn = (Ret(__stdcall *)(Args...)) p.get(); + return fn(std::forward(a)...); + } + + template // Uses lazy pointer + static Ret call(Args... a) + { + return call(lazy_pointer::get(), std::forward(a)...); + } + }; + + template + struct fastcall; + + template + struct fastcall + { + // Call function at @p returning @Ret with args @Args + static Ret call(memory_pointer_tr p, Args... a) + { + auto fn = (Ret(__fastcall *)(Args...)) p.get();; + return fn(std::forward(a)...); + } + + template // Uses lazy pointer + static Ret call(Args... a) + { + return call(lazy_pointer::get(), std::forward(a)...); + } + }; + + template + struct thiscall; + + template + struct thiscall + { + // Call function at @p returning @Ret with args @Args + static Ret call(memory_pointer_tr p, Args... a) + { + auto fn = (Ret(__thiscall *)(Args...)) p.get(); + return fn(std::forward(a)...); + } + + // Call function at the index @i from the vtable of the object @a[0] + template + static Ret vtbl(Args... a) + { + auto obj = raw_ptr(std::get<0>(std::forward_as_tuple(a...))); + auto p = raw_ptr( (*obj.template get()) [i] ); + return call(p, std::forward(a)...); + } + + template // Uses lazy pointer + static Ret call(Args... a) + { + return call(lazy_pointer::get(), std::forward(a)...); + } + }; +} + diff --git a/includes/injector/gvm/gvm.hpp b/includes/injector/gvm/gvm.hpp new file mode 100644 index 0000000..a957929 --- /dev/null +++ b/includes/injector/gvm/gvm.hpp @@ -0,0 +1,232 @@ +/* + * Injectors - Base Header + * + * Copyright (C) 2012-2014 LINK/2012 + * + * This software is provided 'as-is', without any express or implied + * warranty. In no event will the authors be held liable for any damages + * arising from the use of this software. + * + * Permission is granted to anyone to use this software for any purpose, + * including commercial applications, and to alter it and redistribute it + * freely, subject to the following restrictions: + * + * 1. The origin of this software must not be misrepresented; you must not + * claim that you wrote the original software. If you use this software + * in a product, an acknowledgment in the product documentation would be + * appreciated but is not required. + * + * 2. Altered source versions must be plainly marked as such, and must not be + * misrepresented as being the original software. + * + * 3. This notice may not be removed or altered from any source + * distribution. + * + */ +#pragma once +#include +#include +#include + +namespace injector +{ + +#if 1 // GVM and Address Translator, Not very interesting for the users, so skip reading those... + +/* + * game_version_manager + * Detects the game, the game version and the game region + * This assumes the executable is decrypted, so, Silent's ASI Loader is recommended. + */ +#ifndef INJECTOR_OWN_GVM +#ifndef INJECTOR_GVM_DUMMY +class game_version_manager +{ + public: + // Set this if you would like that MessagesBox contain PluginName as caption + const char* PluginName; + + private: + char game, region, major, minor, majorRevision, minorRevision, cracker, steam; + + public: + game_version_manager() + { + #ifdef INJECTOR_GVM_PLUGIN_NAME + PluginName = INJECTOR_GVM_PLUGIN_NAME; + #else + PluginName = "LODLights.asi"; + #endif + + this->Clear(); + } + + + // Clear any information about game version + void Clear() + { + game = region = major = minor = cracker = steam = 0; + } + + // Checks if I don't know the game we are attached to + bool IsUnknown() { return game == 0; } + // Checks if this is the steam version + bool IsSteam() { return steam != 0; } + // Gets the game we are attached to (0, '3', 'V', 'S', 'I', 'E') + char GetGame() { return game; } + // Gets the region from the game we are attached to (0, 'U', 'E'); + char GetRegion() { return region; } + // Get major and minor version of the game (e.g. [major = 1, minor = 0] = 1.0) + int GetMajorVersion() { return major; } + int GetMinorVersion() { return minor; } + int GetMajorRevisionVersion() { return majorRevision; } + int GetMinorRevisionVersion() { return minorRevision; } + + bool IsHoodlum() { return cracker == 'H'; } + + // Region conditions + bool IsUS() { return region == 'U'; } + bool IsEU() { return region == 'E'; } + + // Game Conditions + bool IsIII() { return game == '3'; } + bool IsVC () { return game == 'V'; } + bool IsSA () { return game == 'S'; } + bool IsIV () { return game == 'I'; } + bool IsEFLC(){ return game == 'E'; } + + // Detects game, region and version; returns false if could not detect it + bool Detect(); + + // Gets the game version as text, the buffer must contain at least 32 bytes of space. + char* GetVersionText(char* buffer) + { + if(this->IsUnknown()) + { + strcpy(buffer, "UNKNOWN GAME"); + return buffer; + } + + const char* g = this->IsIII() ? "III" : this->IsVC() ? "VC" : this->IsSA() ? "SA" : this->IsIV() ? "IV" : this->IsEFLC() ? "EFLC" : "UNK"; + const char* r = this->IsUS()? "US" : this->IsEU()? "EURO" : "UNK_REGION"; + const char* s = this->IsSteam()? "Steam" : ""; + if (this->IsIII() || this->IsVC() || this->IsSA()) + sprintf(buffer, "GTA %s %d.%d %s%s", g, major, minor, r, s); + else + sprintf(buffer, "GTA %s %d.%d.%d.%d %s%s", g, major, minor, majorRevision, minorRevision, r, s); + return buffer; + } + + + public: + // Raises a error saying that you could not detect the game version + void RaiseCouldNotDetect() + { + MessageBoxA(0, + "Could not detect the game version\nContact the mod creator!", + PluginName, MB_ICONERROR + ); + } + + // Raises a error saying that the exe version is incompatible (and output the exe name) + void RaiseIncompatibleVersion() + { + char buf[128], v[32]; + sprintf(buf, + "An incompatible exe version has been detected! (%s)\nContact the mod creator!", + GetVersionText(v) + ); + MessageBoxA(0, buf, PluginName, MB_ICONERROR); + } +}; +#else // INJECTOR_GVM_DUMMY +class game_version_manager +{ + public: + bool Detect() { return true; } +}; +#endif // INJECTOR_GVM_DUMMY +#endif // INJECTOR_OWN_GVM + + +/* + * address_manager + * Address translator from 1.0 executables to other executables offsets + * Inherits from game_version_manager ;) + */ +class address_manager : public game_version_manager +{ + private: + address_manager() + { + this->Detect(); + } + + // You could implement your translator for the address your plugin uses + // If not implemented, the translator won't translate anything, just return the samething as before + #ifdef INJECTOR_GVM_HAS_TRANSLATOR + void* translator(void* p); + #else + void* translator(void* p) { return p; } + #endif + + public: + // Translates address p to the running executable pointer + void* translate(void* p) + { + return translator(p); + } + + + public: + // Address manager singleton + static address_manager& singleton() + { + static address_manager m; + return m; + } + + // Static version of translate() + static void* translate_address(void* p) + { + return singleton().translate(p); + } + + // + static void set_name(const char* modname) + { + singleton().PluginName = modname; + } + + public: + // Functors for memory translation: + + // Translates aslr translator + struct fn_mem_translator_aslr + { + void* operator()(void* p) const + { + static uintptr_t module = (uintptr_t)GetModuleHandle(NULL); + return (void*)((uintptr_t)(p)-(0x400000 - module)); + } + }; + + // Translates nothing translator + struct fn_mem_translator_nop + { + void* operator()(void* p) const + { return p; } + }; + + // Real translator + struct fn_mem_translator + { + void* operator()(void* p) const + { return translate_address(p); } + }; +}; + +#endif // #if 1 + + +} \ No newline at end of file diff --git a/includes/injector/gvm/translator.hpp b/includes/injector/gvm/translator.hpp new file mode 100644 index 0000000..c6ac430 --- /dev/null +++ b/includes/injector/gvm/translator.hpp @@ -0,0 +1,203 @@ +/* + * Injectors - Address Translation Management + * + * Copyright (C) 2014 LINK/2012 + * + * This software is provided 'as-is', without any express or implied + * warranty. In no event will the authors be held liable for any damages + * arising from the use of this software. + * + * Permission is granted to anyone to use this software for any purpose, + * including commercial applications, and to alter it and redistribute it + * freely, subject to the following restrictions: + * + * 1. The origin of this software must not be misrepresented; you must not + * claim that you wrote the original software. If you use this software + * in a product, an acknowledgment in the product documentation would be + * appreciated but is not required. + * + * 2. Altered source versions must be plainly marked as such, and must not be + * misrepresented as being the original software. + * + * 3. This notice may not be removed or altered from any source + * distribution. + * + */ +#pragma once + +#if !defined(INJECTOR_GVM_HAS_TRANSLATOR) +#error Missing INJECTOR_GVM_HAS_TRANSLATOR on compiler definitions +#endif + +/* + * This is a quick solution for address translations if you're too lazy to implement a proper address_manager::translator by yourself + * So, just call address_translator_manager::singleton().translate(p) from your address_manager::translator and that's it. + * It'll translate addresses based on 'address_translator' objects, when one gets constructed it turns into a possible translator. + * At the constructor of your derived 'address_translator' make the map object to have [addr_to_translate] = translated_addr; + * There's also the virtual method 'fallback' that will get called when the translation wasn't possible, you can do some fallback stuff here + * (such as return the pointer as is or output a error message) + */ + +#include "../injector.hpp" +#include +#include +#include + +namespace injector +{ + /* + * address_translator + * Base for an address translator + */ + class address_translator + { + private: + bool enabled; + void add(); + void remove(); + + protected: + friend class address_translator_manager; + std::map map; + + public: + address_translator() : enabled(true) + { + // Must have bounds filled with min ptr and max ptr to have search working properly + map.insert(std::make_pair(raw_ptr(0x00000000u), raw_ptr(0x00000000u))); + map.insert(std::make_pair(raw_ptr(0xffffffffu), raw_ptr(0xffffffffu))); + add(); + } + + ~address_translator() + { + remove(); + } + + virtual void* fallback(void*) const + { + return nullptr; + } + + + // Enables or disables this translator + void enable(bool enable_it) + { + if(enable_it) this->enable(); + else this->disable(); + } + + // Enables this translator + void enable() + { + this->enabled = true; + } + + // Disables this translator + void disable() + { + this->enabled = false; + } + + // Checks if this translator is enabled + bool is_enabled() const + { + return enabled; + } + }; + + /* + * address_translator_manager + * Manages the address_translator objects + */ + class address_translator_manager + { + protected: + friend class address_manager; + friend class address_translator; + + std::list translators; + + void add(const address_translator& t) + { + translators.push_front(&t); + } + + void remove(const address_translator& t) + { + translators.remove(&t); + } + + public: + // Translates the address p + void* translator(void* p); + + // Singleton object + static address_translator_manager& singleton() + { + static address_translator_manager mgr; + return mgr; + } + }; + + + + inline void* address_translator_manager::translator(void* p_) + { + static const size_t max_ptr_dist = 7; + + // Tries to find an address in a translator map + auto try_map = [](const std::map& map, memory_pointer_raw p) -> memory_pointer_raw + { + memory_pointer_raw result = nullptr; + + // Find first element in the map that is greater than or equal to p + auto it = map.lower_bound(p); + if(it != map.end()) + { + // If it's not exactly the address, get back one position on the table + if(it->first != p) --it; + + auto diff = (p - it->first).as_int(); // What's the difference between p and that address? + if(diff <= max_ptr_dist) // Could we live with this difference in hands? + result = it->second + raw_ptr(diff); // Yes, we can! + } + + return result; + }; + + + // + memory_pointer_raw result = nullptr; + + // Try to find translation for this pointer + auto& mgr = address_translator_manager::singleton().translators; + for(auto it = mgr.begin(); result == nullptr && it != mgr.end(); ++it) + { + auto& t = **it; + if(t.is_enabled()) result = try_map(t.map, p_); + } + + // If we couldn't translate the address, notify and try to fallback + if(result.is_null()) + { + for(auto it = mgr.begin(); result == nullptr && it != mgr.end(); ++it) + { + auto& t = **it; + if(t.is_enabled()) result = t.fallback(p_); + } + } + + return result.get(); + } + + inline void address_translator::add() + { + address_translator_manager::singleton().add(*this); + } + + inline void address_translator::remove() + { + address_translator_manager::singleton().remove(*this); + } +} diff --git a/includes/injector/hooking.hpp b/includes/injector/hooking.hpp new file mode 100644 index 0000000..ec7d797 --- /dev/null +++ b/includes/injector/hooking.hpp @@ -0,0 +1,687 @@ +/* + * Injectors - Classes for making your hooking life easy + * + * Copyright (C) 2013-2014 LINK/2012 + * + * This software is provided 'as-is', without any express or implied + * warranty. In no event will the authors be held liable for any damages + * arising from the use of this software. + * + * Permission is granted to anyone to use this software for any purpose, + * including commercial applications, and to alter it and redistribute it + * freely, subject to the following restrictions: + * + * 1. The origin of this software must not be misrepresented; you must not + * claim that you wrote the original software. If you use this software + * in a product, an acknowledgment in the product documentation would be + * appreciated but is not required. + * + * 2. Altered source versions must be plainly marked as such, and must not be + * misrepresented as being the original software. + * + * 3. This notice may not be removed or altered from any source + * distribution. + * + */ +#pragma once +#include "injector.hpp" +#include +#include +#include // for std::shared_ptr +#include + +namespace injector +{ + /* + * scoped_base + * Base for any scoped hooking type + * !!!! NOTICE !!!! --> Any derived which implements/reimplements restore() should implement a destructor calling it + */ + class scoped_base + { + public: + virtual ~scoped_base() {} + virtual void restore() = 0; + }; + + /* + * scoped_basic + * Base for scoped types which will need a buffer to save/restore stuff + */ + template // TODO specialize bufsize=0 to be dynamic + class scoped_basic : public scoped_base + { + private: + uint8_t buf[bufsize];// Saved content + memory_pointer_raw addr; // Data saved from this address + size_t size; // Size saved + bool saved; // Something saved? + bool vp; // Virtual protect? + + public: + + static const bool is_dynamic = false; + + // Restore the previosly saved data + // Problems may arise if someone else hooked the same place using the same method + virtual void restore() + { + #ifndef INJECTOR_SCOPED_NOSAVE_NORESTORE + if(this->saved) + { + WriteMemoryRaw(this->addr, this->buf, this->size, this->vp); + this->saved = false; + } + #endif + } + + // Save buffer at @addr with @size and virtual protect @vp + virtual void save(memory_pointer_tr addr, size_t size, bool vp) + { + #ifndef INJECTOR_SCOPED_NOSAVE_NORESTORE + assert(size <= bufsize); // Debug Safeness + this->restore(); // Restore anything we have saved + this->saved = true; // Mark that we have data save + this->addr = addr.get(); // Save address + this->size = size; // Save size + this->vp = vp; // Save virtual protect + ReadMemoryRaw(addr, buf, size, vp); // Save buffer + #endif + } + + public: + // Constructor, initialises + scoped_basic() : saved(false) + {} + + ~scoped_basic() + { + this->restore(); + } + + // No copy construction, we can't do this! Sure we can move construct :) + scoped_basic(const scoped_basic&) = delete; + scoped_basic(scoped_basic&& rhs) + { + *this = std::move(rhs); + } + + scoped_basic& operator=(const scoped_basic& rhs) = delete; + scoped_basic& operator=(scoped_basic&& rhs) + { + if(this->saved = rhs.saved) + { + assert(bufsize >= rhs.size); + + this->addr = rhs.addr; + this->size = rhs.size; + this->vp = rhs.vp; + memcpy(buf, rhs.buf, rhs.size); + + rhs.saved = false; + } + return *this; + } + }; + + /* + * RAII wrapper for memory writes + * Can save only basic and POD types + */ + template + class scoped_write : public scoped_basic + { + public: + // Save buffer at @addr with @size and virtual protect @vp and then overwrite it with @value + void write(memory_pointer_tr addr, void* value, size_t size, bool vp) + { + this->save(addr, size, vp); + return WriteMemoryRaw(addr, value, size, vp); + } + + // Save buffer at @addr with size sizeof(@value) and virtual protect @vp and then overwrite it with @value + template + void write(memory_pointer_tr addr, T value, bool vp = false) + { + this->save(addr, sizeof(T), vp); + return WriteMemory(addr, value, vp); + } + + // Constructors, move constructors, assigment operators........ + scoped_write() = default; + scoped_write(const scoped_write&) = delete; + scoped_write(scoped_write&& rhs) : scoped_basic(std::move(rhs)) {} + scoped_write& operator=(const scoped_write& rhs) = delete; + scoped_write& operator=(scoped_write&& rhs) + { scoped_basic::operator=(std::move(rhs)); return *this; } + }; + + /* + * RAII wrapper for filling + */ + template + class scoped_fill : public scoped_basic + { + public: + // Fills memory at @addr with value @value and size @size and virtual protect @vp + void fill(memory_pointer_tr addr, uint8_t value, size_t size, bool vp) + { + this->save(addr, size, vp); + return MemoryFill(addr, value, size, vp); + } + + // Constructors, move constructors, assigment operators........ + scoped_fill() = default; + scoped_fill(const scoped_fill&) = delete; + scoped_fill(scoped_fill&& rhs) : scoped_basic(std::move(rhs)) {} + scoped_fill& operator=(const scoped_fill& rhs) = delete; + scoped_fill& operator=(scoped_fill&& rhs) + { scoped_basic::operator=(std::move(rhs)); return *this; } + + scoped_fill(memory_pointer_tr addr, uint8_t value, size_t size, bool vp) + { fill(addr, value, vp); } + }; + + /* + * RAII wrapper for nopping + */ + template + class scoped_nop : public scoped_basic + { + public: + // Makes NOP at @addr with value @value and size @size and virtual protect @vp + void make_nop(memory_pointer_tr addr, size_t size = 1, bool vp = true) + { + this->save(addr, size, vp); + return MakeNOP(addr, size, vp); + } + + // Constructors, move constructors, assigment operators........ + scoped_nop() = default; + scoped_nop(const scoped_nop&) = delete; + scoped_nop(scoped_nop&& rhs) : scoped_basic(std::move(rhs)) {} + scoped_nop& operator=(const scoped_nop& rhs) = delete; + scoped_nop& operator=(scoped_nop&& rhs) + { scoped_basic::operator=(std::move(rhs)); return *this; } + + scoped_nop(memory_pointer_tr addr, size_t size = 1, bool vp = true) + { make_nop(addr, size, vp); } + }; + + /* + * RAII wrapper for MakeJMP + */ + class scoped_jmp : public scoped_basic<5> + { + public: + // Makes NOP at @addr with value @value and size @size and virtual protect @vp + memory_pointer_raw make_jmp(memory_pointer_tr at, memory_pointer_raw dest, bool vp = true) + { + this->save(at, 5, vp); + return MakeJMP(at, dest, vp); + } + + // Constructors, move constructors, assigment operators........ + scoped_jmp() = default; + scoped_jmp(const scoped_jmp&) = delete; + scoped_jmp(scoped_jmp&& rhs) : scoped_basic<5>(std::move(rhs)) {} + scoped_jmp& operator=(const scoped_jmp& rhs) = delete; + scoped_jmp& operator=(scoped_jmp&& rhs) + { scoped_basic<5>::operator=(std::move(rhs)); return *this; } + + scoped_jmp(memory_pointer_tr at, memory_pointer_raw dest, bool vp = true) + { make_jmp(at, dest, vp); } + }; + + /* + * RAII wrapper for MakeCALL + */ + class scoped_call : public scoped_basic<5> + { + public: + // Makes NOP at @addr with value @value and size @size and virtual protect @vp + memory_pointer_raw make_call(memory_pointer_tr at, memory_pointer_raw dest, bool vp = true) + { + this->save(at, 5, vp); + return MakeCALL(at, dest, vp); + } + + // Constructors, move constructors, assigment operators........ + scoped_call() = default; + scoped_call(const scoped_call&) = delete; + scoped_call(scoped_call&& rhs) : scoped_basic<5>(std::move(rhs)) {} + scoped_call& operator=(const scoped_call& rhs) = delete; + scoped_call& operator=(scoped_call&& rhs) + { scoped_basic<5>::operator=(std::move(rhs)); return *this; } + + scoped_call(memory_pointer_tr at, memory_pointer_raw dest, bool vp = true) + { make_call(at, dest, vp); } + }; + + +#if __cplusplus >= 201103L || _MSC_VER >= 1800 // C++11 or MSVC 2013 required for variadic templates + + /* + * function_hooker_manager + * Manages many function_hookers that points to the same address + * The need for this function arises because otherwise we would only be able to allow one hook per address using function_hookers + * This manager takes care of the amount of hooks placed in a particular address, calls the hooks and unhooks when necessary. + */ + template + class function_hooker_manager : protected scoped_call + { + private: + using func_type_raw = typename ToManage::func_type_raw; + using func_type = typename ToManage::func_type; + using functor_type = typename ToManage::functor_type; + using assoc_type = std::list>; + + // Only construction is allowed... by myself ofcourse... + function_hooker_manager() = default; + function_hooker_manager(const function_hooker_manager&) = delete; + function_hooker_manager(function_hooker_manager&&) = delete; + + // + func_type_raw original; // Pointer to the original function we've replaced + assoc_type assoc; // Association between owners of a hook and the hook (map) + bool has_hooked = false; // Is the hook already in place? + + // Find assoc iterator for the content owned by 'owned' + typename assoc_type::iterator find_assoc(const ToManage& owner) + { + for(auto it = assoc.begin(); it != assoc.end(); ++it) + if(it->first == &owner) return it; + return assoc.end(); + } + + // Adds a new item to the association map (or override if already in the map) + void add(const ToManage& hooker, functor_type functor) + { + auto it = find_assoc(hooker); + if(it != assoc.end()) + it->second = std::move(functor); + else + assoc.emplace_back(&hooker, std::move(functor)); + } + + public: + // Forwards the call to all the installed hooks + static Ret call_hooks(Args&... args) + { + auto& manager = *instance(); + + if(manager.assoc.size() == 0) // This may be uncommon but may happen (?), no hook installed + return manager.original(args...); + + // Functor for the original call + func_type original = [&manager](Args... args) -> Ret { + return manager.original(args...); + }; + + if(manager.assoc.size() == 1) + { + // We have only one hook, just use it directly no need to go further in complexity + auto& functor = manager.assoc.begin()->second; + return functor(std::move(original), args...); + } + else + { + // Build a serie of functors which captures the previous functor sending it to the next functor, + // that's what would happen if the hooks took place independent of the template staticness (AAAAAAA) + func_type next = std::move(original); + for(auto it = manager.assoc.begin(); it != manager.assoc.end(); ++it) + { + auto& functor = it->second; + next = [functor, next](Args... args) -> Ret + { + return functor(next, args...); + }; + } + return next(args...); + } + } + + public: + + // Installs a hook associated with the function_hooker 'hooker' which would call the specified 'functor' + // We need an auxiliar function pointer 'ptr' (to abstract calling conventions) which should forward itself to ^call_hooks + void make_call(const ToManage& hooker, functor_type functor, memory_pointer_raw ptr) + { + this->add(hooker, std::move(functor)); + + // Make sure we only hook this address for the manager once + if(!this->has_hooked) + { + // (the following cast is needed for __thiscall functions) + this->original = (func_type_raw) (void*) scoped_call::make_call(hooker.addr, ptr).get(); + this->has_hooked = true; + } + } + + // Restores the state of the call we've replaced in the game code + // All installed hooks gets uninstalled after this + void restore() + { + if(this->has_hooked) + { + this->has_hooked = false; + this->assoc.clear(); + return scoped_call::restore(); + } + } + + // Replaces the hook associated with 'from' to be associated with 'to' + // After this call the 'from' object has no association in this manager + void replace(const ToManage& from, const ToManage& to) + { + auto it = find_assoc(from); + if(it != assoc.end()) + { + auto functor = std::move(it->second); + assoc.erase(it); + this->add(to, std::move(functor)); + } + } + + // Removes the hook associated with the specified 'hooker' + // If the number of hooks reaches zero after the remotion, a restore will take place + void remove(const ToManage& hooker) + { + auto it = find_assoc(hooker); + if(it != assoc.end()) + { + assoc.erase(it); + if(assoc.size() == 0) this->restore(); + } + } + + // The instance of this specific manager + // This work as a shared pointer to avoid the static destruction of the manager even when a static function_hooker + // still wants to use it. + static std::shared_ptr instance() + { + static auto fm_ptr = std::shared_ptr(new function_hooker_manager()); + return fm_ptr; + } + + }; + + + /* + * function_hooker_base + * Base for any function_hooker, this class manages the relationship with the function hooker manager + */ + template + class function_hooker_base : public scoped_base + { + public: + static const uintptr_t addr = addr1; + + using func_type_raw = FuncType; + using func_type = std::function; + using functor_type = std::function; + using manager_type = function_hooker_manager; + + public: + // Constructors, move constructors, assigment operators........ + function_hooker_base(const function_hooker_base&) = delete; + function_hooker_base& operator=(const function_hooker_base& rhs) = delete; + + function_hooker_base() : manager(manager_type::instance()) + {} + + // + virtual ~function_hooker_base() + { + this->restore(); + } + + // The move constructor should do a replace in the manager + function_hooker_base(function_hooker_base&& rhs) + : scoped_base(std::move(rhs)), has_call(rhs.has_call), + manager(rhs.manager) // (don't move the manager!, every function_hooker should own one) + { + manager->replace(rhs, *this); + } + + // The move assignment operator should also do a replace in the manager + function_hooker_base& operator=(function_hooker_base&& rhs) + { + scoped_base::operator=(std::move(rhs)); + manager->replace(rhs, *this); + this->has_call = rhs.has_call; + this->manager = rhs.manager; // (don't move the manager! every function_hooker should own one) + return *this; + } + + // Deriveds should implement a proper make_call (yeah it's virtual so derived-deriveds can do some fest) + virtual void make_call(functor_type functor) = 0; + + // Restores the state of the call we've replaced in the game code + virtual void restore() + { + this->has_call = false; + manager->remove(*this); + } + + // Checkers whether a hook is installed + bool has_hooked() + { + return this->has_call; + } + + private: + bool has_call = false; // Has a hook installed? + std::shared_ptr manager; // **EVERY** function_hooker should have a ownership over it's manager_type + // this prevents the static destruction of the manager_type while it may be still needed. + + protected: // Forwarders to the function hooker manager + + void make_call(functor_type functor, memory_pointer_raw ptr) + { + this->has_call = true; + manager->make_call(*this, std::move(functor), ptr); + } + + static Ret call_hooks(Args&... a) + { + return manager_type::call_hooks(a...); + } + }; + + + + + /* + * function_hooker + * For standard conventions (usually __cdecl) + */ + template + struct function_hooker; + + template + class function_hooker + : public function_hooker_base + { + private: + using base = function_hooker_base; + + // The hook caller + static Ret call(Args... a) + { + return base::call_hooks(a...); + } + + public: + // Constructors, move constructors, assigment operators........ + function_hooker() = default; + function_hooker(const function_hooker&) = delete; + function_hooker(function_hooker&& rhs) : base(std::move(rhs)) {} + function_hooker& operator=(const function_hooker& rhs) = delete; + function_hooker& operator=(function_hooker&& rhs) + { base::operator=(std::move(rhs)); return *this; } + + // Makes the hook + void make_call(typename base::functor_type functor) + { + return base::make_call(std::move(functor), raw_ptr(call)); + } + }; + + + /* + * function_hooker_stdcall + * For stdcall conventions (__stdcall) + */ + template + struct function_hooker_stdcall; + + template + struct function_hooker_stdcall + : public function_hooker_base + { + private: + using base = function_hooker_base; + + // The hook caller + static Ret __stdcall call(Args... a) + { + return base::call_hooks(a...); + } + + public: + // Constructors, move constructors, assigment operators........ + function_hooker_stdcall() = default; + function_hooker_stdcall(const function_hooker_stdcall&) = delete; + function_hooker_stdcall(function_hooker_stdcall&& rhs) : base(std::move(rhs)) {} + function_hooker_stdcall& operator=(const function_hooker_stdcall& rhs) = delete; + function_hooker_stdcall& operator=(function_hooker_stdcall&& rhs) + { base::operator=(std::move(rhs)); return *this; } + + // Makes the hook + void make_call(typename base::functor_type functor) + { + return base::make_call(std::move(functor), raw_ptr(call)); + } + }; + + + /* + * function_hooker_fastcall + * For fastcall conventions (__fastcall) + */ + template + struct function_hooker_fastcall; + + template + struct function_hooker_fastcall + : public function_hooker_base + { + private: + using base = function_hooker_base; + + // The hook caller + static Ret __fastcall call(Args... a) + { + return base::call_hooks(a...); + } + + public: + // Constructors, move constructors, assigment operators........ + function_hooker_fastcall() = default; + function_hooker_fastcall(const function_hooker_fastcall&) = delete; + function_hooker_fastcall(function_hooker_fastcall&& rhs) : base(std::move(rhs)) {} + function_hooker_fastcall& operator=(const function_hooker_fastcall& rhs) = delete; + function_hooker_fastcall& operator=(function_hooker_fastcall&& rhs) + { base::operator=(std::move(rhs)); return *this; } + + // Makes the hook + void make_call(typename base::functor_type functor) + { + return base::make_call(std::move(functor), raw_ptr(call)); + } + }; + + + /* + * function_hooker_thiscall + * For thiscall conventions (__thiscall, class methods) + */ + template + struct function_hooker_thiscall; + + template + struct function_hooker_thiscall + : public function_hooker_base + { + private: + using base = function_hooker_base; + + // The hook caller + static Ret __thiscall call(Args... a) + { + return base::call_hooks(a...); + } + + public: + // Constructors, move constructors, assigment operators........ + function_hooker_thiscall() = default; + function_hooker_thiscall(const function_hooker_thiscall&) = delete; + function_hooker_thiscall(function_hooker_thiscall&& rhs) : base(std::move(rhs)) {} + function_hooker_thiscall& operator=(const function_hooker_thiscall& rhs) = delete; + function_hooker_thiscall& operator=(function_hooker_thiscall&& rhs) + { base::operator=(std::move(rhs)); return *this; } + + // Makes the hook + void make_call(typename base::functor_type functor) + { + return base::make_call(std::move(functor), raw_ptr(call)); + } + }; + + + + /******************* HELPERS ******************/ + + /* + * Adds a hook to be alive for the entire program lifetime + * That means the hook received will be alive until the program dies. + * Note: Parameter must be a rvalue + */ + template inline + T& add_static_hook(T&& hooker) + { + static std::list a; + return *a.emplace(a.end(), std::move(hooker)); + } + + /* + * Makes a hook which is alive until it gets out of scope + * 'T' must be any function_hooker object + */ + template inline + T make_function_hook(F functor) + { + T a; + a.make_call(std::move(functor)); + return a; + } + + /* + * Makes a hook which is alive for the entire lifetime of this program + * 'T' must be any function_hooker object + */ + template inline + T& make_static_hook(F functor) + { + return add_static_hook(make_function_hook(std::move(functor))); + } + + + // TODO when we have access to C++14 add a make_function_hook, make_stdcall_function_hook, and so on + // the problem behind implement it with C++11 is that lambdas cannot be generic and the first param of a hook is a functor pointing + // to the previous call pointer + +#endif + +} diff --git a/includes/injector/injector.hpp b/includes/injector/injector.hpp new file mode 100644 index 0000000..ffa3a02 --- /dev/null +++ b/includes/injector/injector.hpp @@ -0,0 +1,750 @@ +/* + * Injectors - Base Header + * + * Copyright (C) 2012-2014 LINK/2012 + * Copyright (C) 2014 Deji + * + * This software is provided 'as-is', without any express or implied + * warranty. In no event will the authors be held liable for any damages + * arising from the use of this software. + * + * Permission is granted to anyone to use this software for any purpose, + * including commercial applications, and to alter it and redistribute it + * freely, subject to the following restrictions: + * + * 1. The origin of this software must not be misrepresented; you must not + * claim that you wrote the original software. If you use this software + * in a product, an acknowledgment in the product documentation would be + * appreciated but is not required. + * + * 2. Altered source versions must be plainly marked as such, and must not be + * misrepresented as being the original software. + * + * 3. This notice may not be removed or altered from any source + * distribution. + * + */ +#pragma once +#define INJECTOR_HAS_INJECTOR_HPP +#include +#include +#include +#include "gvm/gvm.hpp" +/* + The following macros (#define) are relevant on this header: + + INJECTOR_GVM_HAS_TRANSLATOR + If defined, the user should provide their own address_manager::translator function. + That function is responssible for translating a void pointer (that mayn't be an actual pointer) into an actual address. + The meaning of that void pointer will be made by YOU when you send it to the functions that receive pointers on this library. + The default translator does nothing but returns that void pointer as the address. + + INJECTOR_GVM_OWN_DETECT + If defined, the user should provide it's own game detection function thought game_version_manager::Detect + By default it provide an good detection for the Grand Theft Auto series. + + INJECTOR_GVM_PLUGIN_NAME + If this is defined, it will be used as the plugin name used at error messages. + By default it will use ""Unknown Plugin Name" + + INJECTOR_GVM_DUMMY + If defined, the game_version_manager will be a dummy object + By default it provides a nice gvm for Grand Theft Auto series + + INJECTOR_OWN_GVM + If defined, the game_version_manager should be implemented by the user before including this library. + By default it provides a nice gvm for Grand Theft Auto series +*/ +#include "gvm/gvm.hpp" + + + +namespace injector +{ + + +/* + * auto_pointer + * Casts itself to another pointer type in the lhs + */ +union auto_pointer +{ + protected: + friend union memory_pointer_tr; + template friend union basic_memory_pointer; + + void* p; + uintptr_t a; + + 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) {} + + bool is_null() const { return this->p != nullptr; } + + #if __cplusplus >= 201103L || _MSC_VER >= 1800 + explicit operator bool() const { return is_null(); } + #endif + + auto_pointer get() const { return *this; } + template T* get() const { return (T*) this->p; } + template T* get_raw() const { return (T*) this->p; } + + template + operator T*() const { return reinterpret_cast(p); } +}; + +/* + * basic_memory_pointer + * A memory pointer class that is capable of many operations, including address translation + * MemTranslator is the translator functor + */ +template +union basic_memory_pointer +{ + protected: + void* p; + uintptr_t a; + + // Translates address p to the running executable pointer + static auto_pointer memory_translate(void* p) + { + return auto_pointer(MemTranslator()(p)); + } + + public: + basic_memory_pointer() : p(nullptr) {} + basic_memory_pointer(std::nullptr_t) : p(nullptr) {} + basic_memory_pointer(uintptr_t x) : a(x) {} + basic_memory_pointer(const auto_pointer& x) : p(x.p) {} + basic_memory_pointer(const basic_memory_pointer& rhs) : p(rhs.p) {} + + template + basic_memory_pointer(T* x) : p((void*)x) {} + + + + + // Gets the translated pointer (plus automatic casting to lhs) + auto_pointer get() const { return memory_translate(p); } + + // Gets the translated pointer (casted to T*) + template T* get() const { return get(); } + + // Gets the raw pointer, without translation (casted to T*) + template 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; } + basic_memory_pointer& operator=(uintptr_t x) { return a = x, *this; } + + /* Arithmetic */ + basic_memory_pointer operator+(const basic_memory_pointer& rhs) const + { return basic_memory_pointer(this->a + rhs.a); } + + basic_memory_pointer operator-(const basic_memory_pointer& rhs) const + { return basic_memory_pointer(this->a - rhs.a); } + + basic_memory_pointer operator*(const basic_memory_pointer& rhs) const + { return basic_memory_pointer(this->a * rhs.a); } + + basic_memory_pointer operator/(const basic_memory_pointer& rhs) const + { return basic_memory_pointer(this->a / rhs.a); } + + + /* Comparision */ + bool operator==(const basic_memory_pointer& rhs) const + { return this->a == rhs.a; } + + bool operator!=(const basic_memory_pointer& rhs) const + { return this->a != rhs.a; } + + bool operator<(const basic_memory_pointer& rhs) const + { return this->a < rhs.a; } + + bool operator<=(const basic_memory_pointer& rhs) const + { return this->a <= rhs.a; } + + bool operator>(const basic_memory_pointer& rhs) const + { return this->a > rhs.a; } + + bool operator>=(const basic_memory_pointer& rhs) const + { return this->a >=rhs.a; } + + bool is_null() const { return this->p == nullptr; } + uintptr_t as_int() const { return this->a; } // does not perform translation + + + +#if __cplusplus >= 201103L || _MSC_VER >= 1800 // MSVC 2013 + /* Conversion to other types */ + explicit operator uintptr_t() const + { return this->a; } // does not perform translation + explicit operator bool() const + { return this->p != nullptr; } +#else + //operator bool() -------------- Causes casting problems because of implicitness, use !is_null() + //{ return this->p != nullptr; } +#endif + +}; + + // Typedefs including memory translator for the above type +typedef basic_memory_pointer memory_pointer; +typedef basic_memory_pointer memory_pointer_raw; +typedef basic_memory_pointer memory_pointer_aslr; + + + +/* + * memory_pointer_tr + * Stores a basic_memory_pointer as a raw pointer from translated pointer + */ +union memory_pointer_tr +{ + protected: + void* p; + uintptr_t a; + + public: + template + memory_pointer_tr(const basic_memory_pointer& ptr) + : p(ptr.get()) + {} // Constructs from a basic_memory_pointer + + memory_pointer_tr(const auto_pointer& ptr) + : p(ptr.p) + {} // Constructs from a auto_pointer, probably comming from basic_memory_pointer::get + + memory_pointer_tr(const memory_pointer_tr& rhs) + : 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 + + // Just to be method-compatible with basic_memory_pointer ... + auto_pointer get() { return auto_pointer(p); } + template T* get() { return get(); } + template T* get_raw() { return get(); } + + memory_pointer_tr operator+(const uintptr_t& rhs) const + { return memory_pointer_raw(this->a + rhs); } + + memory_pointer_tr operator-(const uintptr_t& rhs) const + { return memory_pointer_raw(this->a - rhs); } + + memory_pointer_tr operator*(const uintptr_t& rhs) const + { return memory_pointer_raw(this->a * rhs); } + + memory_pointer_tr operator/(const uintptr_t& rhs) const + { return memory_pointer_raw(this->a / rhs); } + + bool is_null() const { return this->p == nullptr; } + uintptr_t as_int() const { return this->a; } + +#if __cplusplus >= 201103L + explicit operator uintptr_t() const + { return this->a; } +#else +#endif + +}; + + + + + + + +/* + * ProtectMemory + * Makes the address @addr have a protection of @protection + */ +inline bool ProtectMemory(memory_pointer_tr addr, size_t size, DWORD protection) +{ + return VirtualProtect(addr.get(), size, protection, &protection) != 0; +} + +/* + * UnprotectMemory + * Unprotect the memory at @addr with size @size so it have all accesses (execute, read and write) + * Returns the old protection to out_oldprotect + */ +inline bool UnprotectMemory(memory_pointer_tr addr, size_t size, DWORD& out_oldprotect) +{ + return VirtualProtect(addr.get(), size, PAGE_EXECUTE_READWRITE, &out_oldprotect) != 0; +} + +/* + * scoped_unprotect + * RAII wrapper for UnprotectMemory + * On construction unprotects the memory, on destruction reprotects the memory + */ +struct scoped_unprotect +{ + memory_pointer_raw addr; + size_t size; + DWORD dwOldProtect; + bool bUnprotected; + + scoped_unprotect(memory_pointer_tr addr, size_t size) + { + if(size == 0) bUnprotected = false; + else bUnprotected = UnprotectMemory(this->addr = addr.get(), this->size = size, dwOldProtect); + } + + ~scoped_unprotect() + { + if(bUnprotected) ProtectMemory(this->addr.get(), this->size, this->dwOldProtect); + } +}; + + + + + + + + +/* + * WriteMemoryRaw + * Writes into memory @addr the content of @value with a sizeof @size + * Does memory unprotection if @vp is true + */ +inline void WriteMemoryRaw(memory_pointer_tr addr, void* value, size_t size, bool vp) +{ + scoped_unprotect xprotect(addr, vp? size : 0); + memcpy(addr.get(), value, size); +} + +/* + * ReadMemoryRaw + * Reads the memory at @addr with a sizeof @size into address @ret + * Does memory unprotection if @vp is true + */ +inline void ReadMemoryRaw(memory_pointer_tr addr, void* ret, size_t size, bool vp) +{ + scoped_unprotect xprotect(addr, vp? size : 0); + memcpy(ret, addr.get(), size); +} + +/* + * MemoryFill + * Fills the memory at @addr with the byte @value doing it @size times + * Does memory unprotection if @vp is true + */ +inline void MemoryFill(memory_pointer_tr addr, uint8_t value, size_t size, bool vp) +{ + scoped_unprotect xprotect(addr, vp? size : 0); + memset(addr.get(), value, size); +} + +/* + * WriteObject + * Assigns the object @value into the same object type at @addr + * Does memory unprotection if @vp is true + */ +template +inline T& WriteObject(memory_pointer_tr addr, const T& value, bool vp = false) +{ + scoped_unprotect xprotect(addr, vp? sizeof(value) : 0); + return (*addr.get() = value); +} + +/* + * ReadObject + * Assigns the object @value with the value of the same object type at @addr + * Does memory unprotection if @vp is true + */ +template +inline T& ReadObject(memory_pointer_tr addr, T& value, bool vp = false) +{ + scoped_unprotect xprotect(addr, vp? sizeof(value) : 0); + return (value = *addr.get()); +} + + +/* + * WriteMemory + * Writes the object of type T into the address @addr + * Does memory unprotection if @vp is true + */ +template +inline void WriteMemory(memory_pointer_tr addr, T value, bool vp = false) +{ + WriteObject(addr, value, vp); +} + +/* + * ReadMemory + * Reads the object type T at address @addr + * Does memory unprotection if @vp is true + */ +template +inline T ReadMemory(memory_pointer_tr addr, bool vp = false) +{ + T value; + return ReadObject(addr, value, vp); +} + +/* + * AdjustPointer + * Searches in the range [@addr, @addr + @max_search] for a pointer in the range [@default_base, @default_end] and replaces + * it with the proper offset in the pointer @replacement_base. + * Does memory unprotection if @vp is true. + */ + inline memory_pointer_raw AdjustPointer(memory_pointer_tr addr, + memory_pointer_raw replacement_base, memory_pointer_tr default_base, memory_pointer_tr default_end, + size_t max_search = 8, bool vp = true) + { + scoped_unprotect xprotect(addr, vp? max_search + sizeof(void*) : 0); + for(size_t i = 0; i < max_search; ++i) + { + memory_pointer_raw ptr = ReadMemory(addr + i); + if(ptr >= default_base.get() && ptr <= default_end.get()) + { + auto result = replacement_base + (ptr - default_base.get()); + WriteMemory(addr + i, result.get()); + return result; + } + } + return nullptr; + } + + + + + + +/* + * GetAbsoluteOffset + * Gets absolute address based on relative offset @rel_value from instruction that ends at @end_of_instruction + */ +inline memory_pointer_raw GetAbsoluteOffset(int rel_value, memory_pointer_tr end_of_instruction) +{ + return end_of_instruction.get() + rel_value; +} + +/* + * GetRelativeOffset + * Gets relative offset based on absolute address @abs_value for instruction that ends at @end_of_instruction + */ +inline int GetRelativeOffset(memory_pointer_tr abs_value, memory_pointer_tr end_of_instruction) +{ + return uintptr_t(abs_value.get() - end_of_instruction.get()); +} + +/* + * ReadRelativeOffset + * Reads relative offset from address @at + */ +inline memory_pointer_raw ReadRelativeOffset(memory_pointer_tr at, size_t sizeof_addr = 4, bool vp = true) +{ + switch(sizeof_addr) + { + case 1: return (GetAbsoluteOffset(ReadMemory (at, vp), at+sizeof_addr)); + case 2: return (GetAbsoluteOffset(ReadMemory(at, vp), at+sizeof_addr)); + case 4: return (GetAbsoluteOffset(ReadMemory(at, vp), at+sizeof_addr)); + } + return nullptr; +} + +/* + * MakeRelativeOffset + * Writes relative offset into @at based on absolute destination @dest + */ +inline void MakeRelativeOffset(memory_pointer_tr at, memory_pointer_tr dest, size_t sizeof_addr = 4, bool vp = true) +{ + switch(sizeof_addr) + { + case 1: WriteMemory (at, static_cast (GetRelativeOffset(dest, at+sizeof_addr)), vp); + case 2: WriteMemory(at, static_cast(GetRelativeOffset(dest, at+sizeof_addr)), vp); + case 4: WriteMemory(at, static_cast(GetRelativeOffset(dest, at+sizeof_addr)), vp); + } +} + +/* + * GetBranchDestination + * Gets the destination of a branch instruction at address @at + * *** Works only with JMP and CALL for now *** + */ +inline memory_pointer_raw GetBranchDestination(memory_pointer_tr at, bool vp = true) +{ + switch(ReadMemory(at, vp)) + { + // We need to handle other instructions (and prefixes) later... + case 0xE8: // call rel + case 0xE9: // jmp rel + return ReadRelativeOffset(at + 1, 4, vp); + + case 0xFF: + switch(ReadMemory(at + 1, vp)) + { + case 0x15: // call dword ptr [addr] + case 0x25: // jmp dword ptr [addr] + return *(ReadMemory(at + 2, vp)); + } + break; + } + return nullptr; +} + +/* + * MakeJMP + * Creates a JMP instruction at address @at that jumps into address @dest + * If there was already a branch instruction there, returns the previosly destination of the branch + */ +inline memory_pointer_raw MakeJMP(memory_pointer_tr at, memory_pointer_raw dest, bool vp = true) +{ + auto p = GetBranchDestination(at, vp); + WriteMemory(at, 0xE9, vp); + MakeRelativeOffset(at+1, dest, 4, vp); + return p; +} + +/* + * MakeCALL + * Creates a CALL instruction at address @at that jumps into address @dest + * If there was already a branch instruction there, returns the previosly destination of the branch + */ +inline memory_pointer_raw MakeCALL(memory_pointer_tr at, memory_pointer_raw dest, bool vp = true) +{ + auto p = GetBranchDestination(at, vp); + WriteMemory(at, 0xE8, vp); + MakeRelativeOffset(at+1, dest, 4, vp); + return p; +} + +/* + * MakeJA + * Creates a JA instruction at address @at that jumps if above into address @dest + * If there was already a branch instruction there, returns the previosly destination of the branch + */ +inline void MakeJA(memory_pointer_tr at, memory_pointer_raw dest, bool vp = true) +{ + WriteMemory(at, 0x87F0, vp); + MakeRelativeOffset(at+2, dest, 4, vp); +} + +/* + * MakeNOP + * Creates a bunch of NOP instructions at address @at + */ +inline void MakeNOP(memory_pointer_tr at, size_t count = 1, bool vp = true) +{ + MemoryFill(at, 0x90, count, vp); +} + +/* + * MakeRangedNOP + * Creates a bunch of NOP instructions at address @at until address @until + */ +inline void MakeRangedNOP(memory_pointer_tr at, memory_pointer_tr until, bool vp = true) +{ + return MakeNOP(at, size_t(until.get_raw() - at.get_raw()), vp); +} + + +/* + * MakeRET + * Creates a RET instruction at address @at popping @pop values from the stack + * If @pop is equal to 0 it will use the 1 byte form of the instruction + */ +inline void MakeRET(memory_pointer_tr at, uint16_t pop = 0, bool vp = true) +{ + WriteMemory(at, pop? 0xC2 : 0xC3, vp); + if(pop) WriteMemory(at+1, pop, vp); +} + + + + + +/* + * lazy_pointer + * Lazy pointer, where it's final value will get evaluated only once when finally needed. + */ + template + struct lazy_pointer + { + public: + // Returns the final raw pointer + static auto_pointer get() + { + return xget().get(); + } + + template + static T* get() + { + return get().get(); + } + + private: + // Returns the final pointer + static memory_pointer_raw xget() + { + static void* ptr = nullptr; + if(!ptr) ptr = memory_pointer(addr).get(); + return memory_pointer_raw(ptr); + } +}; + + /* + * lazy_object + * Lazy object, where it's final object will get evaluated only once when finally needed. + */ + template + struct lazy_object + { + static T& get() + { + static T data; + static bool has_data = false; + if(!has_data) + { + ReadObject(addr, data, true); + has_data = true; + } + return data; + } + }; + + + /* + Helpers + */ + + template +inline memory_pointer mem_ptr(T p) +{ + return memory_pointer(p); +} + +template +inline memory_pointer_raw raw_ptr(T p) +{ + return memory_pointer_raw(p); +} + +template +inline memory_pointer_raw raw_ptr(basic_memory_pointer p) +{ + return raw_ptr(p.get()); +} + +template +inline memory_pointer_raw lazy_ptr() +{ + return lazy_pointer::get(); +} + +template +inline memory_pointer_aslr aslr_ptr(T p) +{ + return memory_pointer_aslr(p); +} + + + + + + +#ifndef INJECTOR_GVM_OWN_DETECT // Should we implement our detection method? + +// Detects game, region and version; returns false if could not detect it +inline bool game_version_manager::Detect() +{ + // Cleanup data + this->Clear(); + + // Find NT header + uintptr_t base = (uintptr_t) GetModuleHandleA(NULL); + IMAGE_DOS_HEADER* dos = (IMAGE_DOS_HEADER*)(base); + IMAGE_NT_HEADERS* nt = (IMAGE_NT_HEADERS*)(base + dos->e_lfanew); + + // Look for game and version thought the entry-point + // Thanks to Silent for many of the entry point offsets + switch (base + nt->OptionalHeader.AddressOfEntryPoint + 0x400000 - (DWORD)GetModuleHandle(NULL)) + { + case 0x5C1E70: // GTA III 1.0 + game = '3', major = 1, minor = 0, region = 0, steam = false; + return true; + + case 0x5C2130: // GTA III 1.1 + game = '3', major = 1, minor = 1, region = 0, steam = false; + return true; + + case 0x5C6FD0: // GTA III 1.1 (Cracked Steam Version) + case 0x9912ED: // GTA III 1.1 (Encrypted Steam Version) + game = '3', major = 1, minor = 1, region = 0, steam = true; + return true; + + case 0x667BF0: // GTA VC 1.0 + game = 'V', major = 1, minor = 0, region = 0, steam = false; + return true; + + case 0x667C40: // GTA VC 1.1 + game = 'V', major = 1, minor = 1, region = 0, steam = false; + return true; + + case 0x666BA0: // GTA VC 1.1 (Cracked Steam Version) + case 0xA402ED: // GTA VC 1.1 (Encrypted Steam Version) + game = 'V', major = 1, minor = 1, region = 0, steam = true; + return true; + + case 0x82457C: // GTA SA 1.0 US Cracked + case 0x824570: // GTA SA 1.0 US Compact + game = 'S', major = 1, minor = 0, region = 'U', steam = false; + cracker = injector::ReadMemory(raw_ptr(0x406A20), true) == 0xE9? 'H' : 0; + return true; + + case 0x8245BC: // GTA SA 1.0 EU Cracked (??????) + case 0x8245B0: // GTA SA 1.0 EU Cracked + game = 'S', major = 1, minor = 0, region = 'E', steam = false; + cracker = injector::ReadMemory(raw_ptr(0x406A20), true) == 0xE9? 'H' : 0; // just to say 'securom' + return true; + + case 0x8252FC: // GTA SA 1.1 US Cracked + game = 'S', major = 1, minor = 1, region = 'U', steam = false; + return true; + + case 0x82533C: // GTA SA 1.1 EU Cracked + game = 'S', major = 1, minor = 1, region = 'E', steam = false; + return true; + + case 0x85EC4A: // GTA SA 3.0 (Cracked Steam Version) + case 0xD3C3DB: // GTA SA 3.0 (Encrypted Steam Version) + game = 'S', major = 3, minor = 0, region = 0, steam = true; + return true; + + case 0xC965AD: // GTA IV 1.0.0.4 US + game = 'I', major = 1, minor = 0, majorRevision = 0, minorRevision = 4, region = 'U', steam = false; + return true; + + case 0xD0D011: // GTA IV 1.0.0.7 US + game = 'I', major = 1, minor = 0, majorRevision = 0, minorRevision = 7, region = 'U', steam = false; + return true; + + case 0xD0AF06: // GTA EFLC 1.1.2.0 US + game = 'E', major = 1, minor = 1, majorRevision = 2, minorRevision = 0, region = 'U', steam = false; + return true; + + default: + return false; + } +} + +#endif + + +} // namespace + diff --git a/includes/injector/utility.hpp b/includes/injector/utility.hpp new file mode 100644 index 0000000..0a5eafc --- /dev/null +++ b/includes/injector/utility.hpp @@ -0,0 +1,56 @@ +/* + * Injectors - Utility / Helpers + * + * Copyright (C) 2014 LINK/2012 + * + * This software is provided 'as-is', without any express or implied + * warranty. In no event will the authors be held liable for any damages + * arising from the use of this software. + * + * Permission is granted to anyone to use this software for any purpose, + * including commercial applications, and to alter it and redistribute it + * freely, subject to the following restrictions: + * + * 1. The origin of this software must not be misrepresented; you must not + * claim that you wrote the original software. If you use this software + * in a product, an acknowledgment in the product documentation would be + * appreciated but is not required. + * + * 2. Altered source versions must be plainly marked as such, and must not be + * misrepresented as being the original software. + * + * 3. This notice may not be removed or altered from any source + * distribution. + * + */ +#pragma once + +namespace injector +{ + template + T return_value() + { + return value; + } + + template + void* force_ptr(const T& fun) + { + auto ptr = fun; + return *(void**)&ptr; + } + + + // Helper structure to help calling back what was there before a hook + // e.g. hb.fun = MakeCALL(0x0, raw_ptr(my_hook)); + template + struct hook_back + { + typedef FuncType func_type; + + func_type fun; + + hook_back() : fun(nullptr) + {} + }; +}; diff --git a/includes/stdafx.h b/includes/stdafx.h new file mode 100644 index 0000000..f3a0737 --- /dev/null +++ b/includes/stdafx.h @@ -0,0 +1,16 @@ +// stdafx.h : include file for standard system include files, +// or project specific include files that are used frequently, but +// are changed infrequently +// + +#pragma once + +#include "targetver.h" + +#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers +// Windows Header Files: +#include + + + +// TODO: reference additional headers your program requires here diff --git a/stdafx.cpp b/stdafx.cpp new file mode 100644 index 0000000..fd4f341 --- /dev/null +++ b/stdafx.cpp @@ -0,0 +1 @@ +#include "stdafx.h" diff --git a/stdafx.h b/stdafx.h new file mode 100644 index 0000000..f3a0737 --- /dev/null +++ b/stdafx.h @@ -0,0 +1,16 @@ +// stdafx.h : include file for standard system include files, +// or project specific include files that are used frequently, but +// are changed infrequently +// + +#pragma once + +#include "targetver.h" + +#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers +// Windows Header Files: +#include + + + +// TODO: reference additional headers your program requires here diff --git a/targetver.h b/targetver.h new file mode 100644 index 0000000..87c0086 --- /dev/null +++ b/targetver.h @@ -0,0 +1,8 @@ +#pragma once + +// Including SDKDDKVer.h defines the highest available Windows platform. + +// If you wish to build your application for a previous Windows platform, include WinSDKVer.h and +// set the _WIN32_WINNT macro to the platform you wish to support before including SDKDDKVer.h. + +#include