From 00c1a2351700802c9e0b7035582b427281d8e427 Mon Sep 17 00:00:00 2001 From: Linewalker Date: Sat, 25 Dec 2021 03:07:19 +0100 Subject: [PATCH] Online 1.58 initial commit --- App.config | 14 + Config/Offsets.cs | 1398 +++++++++++++++++ Config/Patterns.cs | 215 +++ GTAVCSMM.csproj | 101 ++ GTAVCSMM.sln | 30 + Helpers/JOAAT.cs | 93 ++ Helpers/Key.cs | 45 + Helpers/KeysMgr.cs | 113 ++ Helpers/Manager.cs | 165 ++ Helpers/Speeder.cs | 134 ++ Memory/Mem.cs | 124 ++ Program.cs | 2407 ++++++++++++++++++++++++++++++ Properties/AssemblyInfo.cs | 36 + Properties/Resources.Designer.cs | 63 + Properties/Resources.resx | 120 ++ Properties/Settings.Designer.cs | 26 + Properties/Settings.settings | 7 + README.md | 18 + Settings/Addresses.cs | 85 ++ Settings/TSettings.cs | 660 ++++++++ app.manifest | 76 + gtavcsmm.ico | Bin 0 -> 46440 bytes 22 files changed, 5930 insertions(+) create mode 100644 App.config create mode 100644 Config/Offsets.cs create mode 100644 Config/Patterns.cs create mode 100644 GTAVCSMM.csproj create mode 100644 GTAVCSMM.sln create mode 100644 Helpers/JOAAT.cs create mode 100644 Helpers/Key.cs create mode 100644 Helpers/KeysMgr.cs create mode 100644 Helpers/Manager.cs create mode 100644 Helpers/Speeder.cs create mode 100644 Memory/Mem.cs create mode 100644 Program.cs create mode 100644 Properties/AssemblyInfo.cs create mode 100644 Properties/Resources.Designer.cs create mode 100644 Properties/Resources.resx create mode 100644 Properties/Settings.Designer.cs create mode 100644 Properties/Settings.settings create mode 100644 README.md create mode 100644 Settings/Addresses.cs create mode 100644 Settings/TSettings.cs create mode 100644 app.manifest create mode 100644 gtavcsmm.ico diff --git a/App.config b/App.config new file mode 100644 index 0000000..c6b6e74 --- /dev/null +++ b/App.config @@ -0,0 +1,14 @@ + + + + + + + + + + + + + + diff --git a/Config/Offsets.cs b/Config/Offsets.cs new file mode 100644 index 0000000..c588d77 --- /dev/null +++ b/Config/Offsets.cs @@ -0,0 +1,1398 @@ +namespace GTAVCSMM.Config +{ + class Offsets + { + #region World Offsets + // World Offsets + private int _ReadValuePointer = 3; + private int _ReadValuePointer2 = 6; + private int _MovePointer = 7; + private int _MovePointer2 = 10; + private int _MovePointer3 = 0x89; + + public int ReadValuePointer + { + get + { + return _ReadValuePointer; + } + } + + public int ReadValuePointer2 + { + get + { + return _ReadValuePointer2; + } + } + + public int MovePointer + { + get + { + return _MovePointer; + } + } + + public int MovePointer2 + { + get + { + return _MovePointer2; + } + } + + public int MovePointer3 + { + get + { + return _MovePointer3; + } + } + #endregion + + #region CNetworkPlayerMgr + // CNetworkPlayerMgr + private int _pCNetPlayerInfo = 0xA0; + private int _pCNetPed = 0x1E8; + private int _oNumPlayers = 0x180; + private int _oRid = 0x090; + + public int pCNetPlayerInfo + { + get + { + return _pCNetPlayerInfo; + } + } + + public int pCNetPed + { + get + { + return _pCNetPed; + } + } + + public int oNumPlayers + { + get + { + return _oNumPlayers; + } + } + + public int oRid + { + get + { + return _oRid; + } + } + #endregion + + #region AutoConnect + // Landing Page Offsets for AutoConnect function / story mode. + private int _oStartupFlow = 0x2B0; + private int _oGTAOnline = 0xF0; + + public int oStartupFlow + { + get + { + return _oStartupFlow; + } + } + + public int oGTAOnline + { + get + { + return _oGTAOnline; + } + } + #endregion + + #region CPedFactory + // CPedFactory (WorldPTR) + private int _pCPed = 0x08; + + public int pCPed + { + get + { + return _pCPed; + } + } + #endregion + + #region CPed Offsets + // CPed Offsets + private int _oEntityType = 0x2B; // int 156:Player 152:Other + private int _pCNavigation = 0x30; + private int _oVisualX = 0x90; + private int _oVisualY = 0x94; + private int _oVisualZ = 0x98; // float, vector3 + private int _oGod = 0x189; // int8 0:false 1:true + private int _oHostility = 0x18C; + private int _oHealth = 0x280; // float + private int _oHealthMax = 0x2A0; + private int _pAttackers = 0x2A8; + private int _pCVehicle = 0xD30; + private int _oRagdoll = 0x10B8; // int 32:false 1/0:true + private int _pCPlayerInfo = 0x10C8; + private int _pCPedWeaponManager = 0x10D8; + private int _oSeatbelt = 0x145C; // byte 55:false 56:true + private int _oInVehicle = 0x1618; // int 16:false 0:true (perhaps 0xE52) + private int _pedArmor = 0x1530; // not working what + + public int oEntityType + { + get + { + return _oEntityType; + } + } + + public int pCNavigation + { + get + { + return _pCNavigation; + } + } + + public int oVisualX + { + get + { + return _oVisualX; + } + } + + public int oVisualY + { + get + { + return _oVisualY; + } + } + + public int oVisualZ + { + get + { + return _oVisualZ; + } + } + + public int oGod + { + get + { + return _oGod; + } + } + + public int oHostility + { + get + { + return _oHostility; + } + } + + public int oHealth + { + get + { + return _oHealth; + } + } + + public int oHealthMax + { + get + { + return _oHealthMax; + } + } + + public int pAttackers + { + get + { + return _pAttackers; + } + } + + public int pCVehicle + { + get + { + return _pCVehicle; + } + } + + public int oRagdoll + { + get + { + return _oRagdoll; + } + } + + public int pCPlayerInfo + { + get + { + return _pCPlayerInfo; + } + } + + public int pCPedWeaponManager + { + get + { + return _pCPedWeaponManager; + } + } + + public int oSeatbelt + { + get + { + return _oSeatbelt; + } + } + + public int oInVehicle + { + get + { + return _oInVehicle; + } + } + + public int pedArmor + { + get + { + return _pedArmor; + } + } + #endregion + + #region CNavigation Offsets + // CNavigation Offsets + private int _oHeading = 0x20; // float + private int _oHeading2 = 0x24; + private int _oRotation = 0x30; + private int _oRotation2 = 0x34; + private int _oRotation3 = 0x38; // float, vector3 + private int _oPositionX = 0x50; + private int _oPositionY = 0x54; + private int _oPositionZ = 0x58; + + public int oHeading + { + get + { + return _oHeading; + } + } + + public int oHeading2 + { + get + { + return _oHeading2; + } + } + + public int oRotation + { + get + { + return _oRotation; + } + } + + public int oRotation2 + { + get + { + return _oRotation2; + } + } + + public int oRotation3 + { + get + { + return _oRotation3; + } + } + + public int oPositionX + { + get + { + return _oPositionX; + } + } + + public int oPositionY + { + get + { + return _oPositionY; + } + } + + public int oPositionZ + { + get + { + return _oPositionZ; + } + } + #endregion + + #region CPlayerInfo Offsets + // CPlayerInfo Offsets + private int _oName = 0xA4; // string[20] + private int _oSwimSpeed = 0x170; // float + private int _oFrameFlags = 0x219; + private int _oWalkSpeed = 0x18C; + private int _oWanted = 0x888; // int8 + private int _oRunSpeed = 0xCF0; // float + private int _oStamina = 0xCF4; + private int _oStaminaRegen = 0xCF8; + + public int oName + { + get + { + return _oName; + } + } + + public int oSwimSpeed + { + get + { + return _oSwimSpeed; + } + } + + public int oFrameFlags + { + get + { + return _oFrameFlags; + } + } + + public int oWalkSpeed + { + get + { + return _oWalkSpeed; + } + } + + public int oWanted + { + get + { + return _oWanted; + } + } + + public int oRunSpeed + { + get + { + return _oRunSpeed; + } + } + + public int oStamina + { + get + { + return _oStamina; + } + } + + public int oStaminaRegen + { + get + { + return _oStaminaRegen; + } + } + #endregion + + #region CPedWeaponManager Offsets + // CPedWeaponManager Offsets + private int _pCWeaponInfo = 0x20; + private int _oImpactType = 0x20; // int 3:bullet 5:explosion + private int _oImpactExplosion = 0x24; // int32 + private int _oImpactType2 = 0x54; // int + private int _pCAmmoInfo = 0x60; + private int _pCVehicleWeapon = 0x70; + private int _oSpread = 0x7C; // float + private int _oDamage = 0xB0; + private int _oForce = 0xD8; + private int _oForcePed = 0xDC; + private int _oForceVehicle = 0xE0; + private int _oForceFlying = 0xE4; + private int _oPenetration = 0x110; + private int _oMuzzleVelocity = 0x11C; + private int _oBulletBatch = 0x124; + private int _oReloadVehicleMult = 0x130; + private int _oReloadMult = 0x134; + private int _oShotTime = 0x13C; + private int _oLockRange = 0x288; + private int _oRange = 0x28C; + private int _pCAmmoWrap = 0x8; + private int _oMaxAmmo = 0x28; + private int _pCAmmo = 0x0; + private int _oCurrentAmmo = 0x18; + public int pCWeaponInfo + { + get + { + return _pCWeaponInfo; + } + } + public int oImpactType + { + get + { + return _oImpactType; + } + } + public int oImpactExplosion + { + get + { + return _oImpactExplosion; + } + } + public int oImpactType2 + { + get + { + return _oImpactType2; + } + } + public int pCAmmoInfo + { + get + { + return _pCAmmoInfo; + } + } + public int pCVehicleWeapon + { + get + { + return _pCVehicleWeapon; + } + } + public int oSpread + { + get + { + return _oSpread; + } + } + public int oDamage + { + get + { + return _oDamage; + } + } + public int oForce + { + get + { + return _oForce; + } + } + public int oForcePed + { + get + { + return _oForcePed; + } + } + public int oForceVehicle + { + get + { + return _oForceVehicle; + } + } + public int oForceFlying + { + get + { + return _oForceFlying; + } + } + public int oPenetration + { + get + { + return _oPenetration; + } + } + public int oMuzzleVelocity + { + get + { + return _oMuzzleVelocity; + } + } + public int oBulletBatch + { + get + { + return _oBulletBatch; + } + } + public int oReloadVehicleMult + { + get + { + return _oReloadVehicleMult; + } + } + public int oReloadMult + { + get + { + return _oReloadMult; + } + } + public int oShotTime + { + get + { + return _oShotTime; + } + } + public int oLockRange + { + get + { + return _oLockRange; + } + } + public int oRange + { + get + { + return _oRange; + } + } + public int pCAmmoWrap + { + get + { + return _pCAmmoWrap; + } + } + public int oMaxAmmo + { + get + { + return _oMaxAmmo; + } + } + public int pCAmmo + { + get + { + return _pCAmmo; + } + } + public int oCurrentAmmo + { + get + { + return oCurrentAmmo; + } + } + #endregion + + #region CVehicle Offsets + // CVehicle Offsets + private int _pCModelInfo = 0x20; + private int _oVInvisibility = 0x2C; // int + private int _pCVehicleDrawHandler = 0x48; + private int _oVPositionX = 0x90; + private int _oVPositionY = 0x94; + private int _oVPositionZ = 0x98; // float, vector3 + private int _oVState = 0xD8; // int 0:Player 1:NPC 2:Unused 3:Destroyed + private int _oVBurnt = 0x18A; // int 64:off 72:on + private int _oVHealth = 0x280; // float + private int _oVHealthMax = 0x2A0; + private int _oVBoostSpeed = 0x120; + private int _oVBoost = 0x320; + private int _oVBoostRecharge = 0x324; + private int _oVHealth2 = 0x840; + private int _oVHealth3 = 0x844; // used + private int _oVEngineHealth = 0x908; // used + private int _pCHandlingData = 0x938; + private int _oVDirt = 0x9F8; // float + private int _oBulletproofTires = 0x943; // int + private int _oLightMult = 0xA14; // float + private int _oVGravity = 0xC5C; // float + private int _oCurPassenger = 0xC62; + private int _oMk2Missiles = 0x12A4; // int + private int _oAircraftBomb = 0x12B4; + private int _oCountermeasures = 0x12B8; + public int pCModelInfo + { + get + { + return _pCModelInfo; + } + } + public int oVInvisibility + { + get + { + return _oVInvisibility; + } + } + public int pCVehicleDrawHandler + { + get + { + return _pCVehicleDrawHandler; + } + } + public int oVPositionX + { + get + { + return _oVPositionX; + } + } + public int oVPositionY + { + get + { + return _oVPositionY; + } + } + public int oVPositionZ + { + get + { + return _oVPositionZ; + } + } + public int oVState + { + get + { + return _oVState; + } + } + public int oVBurnt + { + get + { + return _oVBurnt; + } + } + public int oVHealth + { + get + { + return _oVHealth; + } + } + public int oVHealthMax + { + get + { + return _oVHealthMax; + } + } + public int oVBoostSpeed + { + get + { + return _oVBoostSpeed; + } + } + public int oVBoost + { + get + { + return _oVBoost; + } + } + public int oVBoostRecharge + { + get + { + return _oVBoostRecharge; + } + } + public int oVHealth2 + { + get + { + return _oVHealth2; + } + } + public int oVHealth3 + { + get + { + return _oVHealth3; + } + } + public int oVEngineHealth + { + get + { + return _oVEngineHealth; + } + } + public int pCHandlingData + { + get + { + return _pCHandlingData; + } + } + public int oVDirt + { + get + { + return _oVDirt; + } + } + public int oBulletproofTires + { + get + { + return _oBulletproofTires; + } + } + public int oLightMult + { + get + { + return _oLightMult; + } + } + public int oVGravity + { + get + { + return _oVGravity; + } + } + public int oCurPassenger + { + get + { + return _oCurPassenger; + } + } + public int oMk2Missiles + { + get + { + return _oMk2Missiles; + } + } + public int oAircraftBomb + { + get + { + return _oAircraftBomb; + } + } + public int oCountermeasures + { + get + { + return _oCountermeasures; + } + } + #endregion + + #region CHandlingData Offsets + // CHandlingData Offsets + private int _oMass = 0xC; // float + private int _oBouyancy = 0x40; // float + private int _oAcceleration = 0x4C; + private int _oDriveInertia = 0x54; + private int _oInitialDriveForce = 0x60; + private int _oBrakeForce = 0x6C; + private int _oHandbrakeForce = 0x7C; + private int _oTractionCurveMax = 0x88; + private int _oTractionCurveMin = 0x90; + private int _oCollisionMult = 0xF0; + private int _oWeaponMult = 0xF4; + private int _oDeformationMult = 0xF8; + private int _oEngineMult = 0xFC; + private int _oThrust = 0x338; + public int oMass + { + get + { + return _oMass; + } + } + public int oBouyancy + { + get + { + return _oBouyancy; + } + } + public int oAcceleration + { + get + { + return _oAcceleration; + } + } + public int oDriveInertia + { + get + { + return _oDriveInertia; + } + } + public int oInitialDriveForce + { + get + { + return _oInitialDriveForce; + } + } + public int oBrakeForce + { + get + { + return _oBrakeForce; + } + } + public int oHandbrakeForce + { + get + { + return _oHandbrakeForce; + } + } + public int oTractionCurveMax + { + get + { + return _oTractionCurveMax; + } + } + public int oTractionCurveMin + { + get + { + return _oTractionCurveMin; + } + } + public int oCollisionMult + { + get + { + return _oCollisionMult; + } + } + public int oWeaponMult + { + get + { + return _oWeaponMult; + } + } + public int oDeformationMult + { + get + { + return _oDeformationMult; + } + } + public int oEngineMult + { + get + { + return _oEngineMult; + } + } + public int oThrust + { + get + { + return _oThrust; + } + } + #endregion + + #region CVehicleDrawHandler Offsets + // CVehicleDrawHandler Offsets + private int _pCVehicleVisual = 0x20; + private int _oNeonR = 0x3A2; // int + private int _oNeonG = 0x3A1; + private int _oNeonB = 0x3A0; + private int _oNeonLeft = 0x402; + private int _oNeonRight = 0x403; + private int _oNeonFront = 0x404; + private int _oNeonBack = 0x405; + private int _oEMS = 0x3D6; + private int _oBrakes = 0x3D7; + private int _oTransmission = 0x3D8; + private int _oHorn = 0x3D9; + private int _oSuspension = 0x3DA; + private int _oArmor = 0x3DB; + private int _oTurbo = 0x3DD; + private int _oXenonLight = 0x3E1; + private int _oSmokeR = 0x3FC; + private int _oSmokeG = 0x3FD; + private int _oSmokeB = 0x3FE; + private int _oWindows = 0x3FF; + private int _oColorLight = 0x406; + public int pCVehicleVisual + { + get + { + return _pCVehicleVisual; + } + } + public int oNeonR + { + get + { + return _oNeonR; + } + } + public int oNeonG + { + get + { + return _oNeonG; + } + } + public int oNeonB + { + get + { + return _oNeonB; + } + } + public int oNeonLeft + { + get + { + return _oNeonLeft; + } + } + public int oNeonRight + { + get + { + return _oNeonRight; + } + } + public int oNeonFront + { + get + { + return _oNeonFront; + } + } + public int oNeonBack + { + get + { + return _oNeonBack; + } + } + public int oEMS + { + get + { + return _oEMS; + } + } + public int oBrakes + { + get + { + return _oBrakes; + } + } + public int oTransmission + { + get + { + return _oTransmission; + } + } + public int oHorn + { + get + { + return _oHorn; + } + } + public int oSuspension + { + get + { + return _oSuspension; + } + } + public int oArmor + { + get + { + return _oArmor; + } + } + public int oTurbo + { + get + { + return _oTurbo; + } + } + public int oXenonLight + { + get + { + return _oXenonLight; + } + } + public int oSmokeR + { + get + { + return _oSmokeR; + } + } + public int oSmokeG + { + get + { + return _oSmokeG; + } + } + public int oSmokeB + { + get + { + return _oSmokeB; + } + } + public int oWindows + { + get + { + return _oWindows; + } + } + public int oColorLight + { + get + { + return _oColorLight; + } + } + #endregion + + #region CVehicleVisual + // CVehicleVisual + private int _oPrimaryR = 0xA6; // int + private int _oPrimaryG = 0xA5; + private int _oPrimaryB = 0xA4; + private int _oSecondaryR = 0xAA; + private int _oSecondaryG = 0xA9; + private int _oSecondaryB = 0xA8; + private int _oLicensePlate = 0x130; // dword / byte array[8] + public int oPrimaryR + { + get + { + return _oPrimaryR; + } + } + public int oPrimaryG + { + get + { + return _oPrimaryG; + } + } + public int oPrimaryB + { + get + { + return _oPrimaryB; + } + } + public int oSecondaryR + { + get + { + return _oSecondaryR; + } + } + public int oSecondaryG + { + get + { + return _oSecondaryR; + } + } + public int oSecondaryB + { + get + { + return _oSecondaryB; + } + } + public int oLicensePlate + { + get + { + return _oLicensePlate; + } + } + #endregion + + #region CModelInfo + // CModelInfo + private int _oModelHash = 0x18; // int + private int _oCamDist = 0x38; // float + private int _oVName = 0x298; // string[10] + private int _oVMaker = 0x2A4; // string[10] + private int _oVExtras = 0x58B; // short + private int _oVParachute = 0x58C; + public int oModelHash + { + get + { + return _oModelHash; + } + } + public int oCamDist + { + get + { + return _oCamDist; + } + } + public int oVName + { + get + { + return _oVName; + } + } + public int oVMaker + { + get + { + return _oVMaker; + } + } + public int oVExtras + { + get + { + return _oVExtras; + } + } + public int oVParachute + { + get + { + return _oVParachute; + } + } + #endregion + + #region CReplayInterface Offsets + // CReplayInterface Offsets and more below + private int _pCPedInterface = 0x18; + private int _pVehList = 0x180; + private int _oVehNum = 0x190; + private int _pPedList = 0x100; + private int _oPedNum = 0x110; + public int pCPedInterface + { + get + { + return _pCPedInterface; + } + } + public int pVehList + { + get + { + return _pVehList; + } + } + public int oVehNum + { + get + { + return _oVehNum; + } + } + public int pPedList + { + get + { + return _pPedList; + } + } + public int oPedNum + { + get + { + return _oPedNum; + } + } + #endregion + + #region CPickupData/CReplayInterface Offsets + // CPickupData/CReplayInterface Offsets from DMKiller + private int _pBST = 0x160; + private int _pFixVeh = 0x228; + private int _pPickupList = 0x100; + private int _oPickupNum = 0x110; + private int _pDroppedPickupData = 0x490; + private int _pCPickupInterface = 0x20; + public int pBST + { + get + { + return _pBST; + } + } + public int pFixVeh + { + get + { + return _pFixVeh; + } + } + public int pPickupList + { + get + { + return _pPickupList; + } + } + public int oPickupNum + { + get + { + return _oPickupNum; + } + } + public int pDroppedPickupData + { + get + { + return _pDroppedPickupData; + } + } + public int pCPickupInterface + { + get + { + return _pCPickupInterface; + } + } + #endregion + + #region Vehicle Menus Globals + // Vehicle Menus Globals + private int _oVMCreate = 2463533; // Create any vehicle. + private int _oVMYCar = 2544210; // Get my car. + private int _oVGETIn = 2409299; // Spawn into vehicle. + private int _oVMSlots = 1323703; // Get vehicle slots. + public int oVMCreate + { + get + { + return _oVMCreate; + } + } + public int oVMYCar + { + get + { + return _oVMYCar; + } + } + public int oVGETIn + { + get + { + return _oVGETIn; + } + } + public int oVMSlots + { + get + { + return _oVMSlots; + } + } + #endregion + + #region Some Player / Network times associated Globals + // Some Player / Network times associated Globals + private int _oPlayerGA = 2441237; + private int _oPlayerIDHelp = 2426865; + private int _oNETTimeHelp = 2441237; + public int oPlayerGA + { + get + { + return _oPlayerGA; + } + } + public int oPlayerIDHelp + { + get + { + return _oPlayerIDHelp; + } + } + public int oNETTimeHelp + { + get + { + return _oNETTimeHelp; + } + } + #endregion + } +} diff --git a/Config/Patterns.cs b/Config/Patterns.cs new file mode 100644 index 0000000..c390c88 --- /dev/null +++ b/Config/Patterns.cs @@ -0,0 +1,215 @@ +namespace GTAVCSMM.Config +{ + class Patterns + { + #region Global Patterns + private byte[] _globalptr = new byte[] { 0x4C, 0x8D, 0x05, 0x0, 0x0, 0x0, 0x0, 0x4D, 0x8B, 0x08, 0x4D, 0x85, 0xC9, 0x74, 0x11 }; + private string _globalptr_mask = "xxx????xxxxxxxx"; + + private byte[] _worldptr = new byte[] { 0x48, 0x8B, 0x05, 0x0, 0x0, 0x0, 0x0, 0x45, 0x0, 0x0, 0x0, 0x0, 0x48, 0x8B, 0x48, 0x08, 0x48, 0x85, 0xC9, 0x74, 0x07 }; + private string _worldptr_mask = "xxx????x????xxxxxxxxx"; + + private byte[] _blipptr = new byte[] { 0x4C, 0x8D, 0x05, 0x0, 0x0, 0x0, 0x0, 0x0F, 0xB7, 0xC1 }; + private string _blipptr_mask = "xxx????xxx"; + + private byte[] _replayinterfaceptr = new byte[] { 0x48, 0x8D, 0x0D, 0x0, 0x0, 0x0, 0x0, 0x48, 0x8B, 0xD7, 0xE8, 0x0, 0x0, 0x0, 0x0, 0x48, 0x8D, 0x0D, 0x0, 0x0, 0x0, 0x0, 0x8A, 0xD8, 0xE8 }; + private string _replayinterfaceptr_mask = "xxx????xxxx????xxx????xxx"; + + private byte[] _localscriptsptr = new byte[] { 0x48, 0x8B, 0x05, 0x0, 0x0, 0x0, 0x0, 0x8B, 0xCF, 0x48, 0x8B, 0x0C, 0xC8, 0x39, 0x59, 0x68 }; + private string _localscriptsptr_mask = "xxx????xxxxxxxxx"; + + private byte[] _playercountptr = new byte[] { 0x48, 0x8B, 0x0D, 0x0, 0x0, 0x0, 0x0, 0xE8, 0x0, 0x0, 0x0, 0x0, 0x48, 0x8B, 0xC8, 0xE8, 0x0, 0x0, 0x0, 0x0, 0x48, 0x8B, 0xCF }; + private string _playercountptr_mask = "xxx????x????xxxx????xxx"; + + private byte[] _pickupdataptr = new byte[] { 0x48, 0x8B, 0x05, 0x0, 0x0, 0x0, 0x0, 0x48, 0x8B, 0x1C, 0xF8, 0x8B }; + private string _pickupdataptr_mask = "xxx????xxxxx"; + + private byte[] _weatheraddr = new byte[] { 0x48, 0x83, 0xEC, 0x0, 0x8B, 0x05, 0x0, 0x0, 0x0, 0x0, 0x8B, 0x3D, 0x0, 0x0, 0x0, 0x0, 0x49 }; + private string _weatheraddr_mask = "xxx?xx????xx????x"; + + private byte[] _settingsptr = new byte[] { 0x44, 0x39, 0x05, 0x0, 0x0, 0x0, 0x0, 0x75, 0x0D }; + private string _settingsptr_mask = "xxx????xx"; + + private byte[] _aimcpedptr = new byte[] { 0x48, 0x8B, 0x0D, 0x0, 0x0, 0x0, 0x0, 0x48, 0x85, 0xC9, 0x74, 0x0C, 0x48, 0x8D, 0x15, 0x0, 0x0, 0x0, 0x0, 0xE8, 0x0, 0x0, 0x0, 0x0, 0x48, 0x89, 0x1D }; + private string _aimcpedptr_mask = "xxx????xxxxxxxx????x????xxx"; + + private byte[] _friendlistptr = new byte[] { 0x48, 0x8B, 0x0D, 0x0, 0x0, 0x0, 0x0, 0x8B, 0xC6, 0x48, 0x8D, 0x5C, 0x24, 0x70 }; + private string _friendlistptr_mask = "xxx????xxxxxxx"; + + public byte[] GlobalPTR + { + get + { + return _globalptr; + } + } + public string GlobalPTR_Mask + { + get + { + return _globalptr_mask; + } + } + + public byte[] WorldPTR + { + get + { + return _worldptr; + } + } + + public string WorldPTR_Mask + { + get + { + return _worldptr_mask; + } + } + + public byte[] BlipPTR + { + get + { + return _blipptr; + } + } + + public string BlipPTR_Mask + { + get + { + return _blipptr_mask; + } + } + + public byte[] ReplayInterfacePTR + { + get + { + return _replayinterfaceptr; + } + } + + public string ReplayInterfacePTR_Mask + { + get + { + return _replayinterfaceptr_mask; + } + } + + public byte[] LocalScriptsPTR + { + get + { + return _localscriptsptr; + } + } + + public string LocalScriptsPTR_Mask + { + get + { + return _localscriptsptr_mask; + } + } + + public byte[] PlayerCountPTR + { + get + { + return _playercountptr; + } + } + + public string PlayerCountPTR_Mask + { + get + { + return _playercountptr_mask; + } + } + + public byte[] PickupDataPTR + { + get + { + return _pickupdataptr; + } + } + + public string PickupDataPTR_Mask + { + get + { + return _pickupdataptr_mask; + } + } + + public byte[] WeatherADDR + { + get + { + return _weatheraddr; + } + } + + public string WeatherADDR_Mask + { + get + { + return _weatheraddr_mask; + } + } + + public byte[] SettingsPTR + { + get + { + return _settingsptr; + } + } + + public string SettingsPTR_Mask + { + get + { + return _settingsptr_mask; + } + } + + public byte[] AimCPedPTR + { + get + { + return _aimcpedptr; + } + } + + public string AimCPedPTR_Mask + { + get + { + return _aimcpedptr_mask; + } + } + + public byte[] FriendlistPTR + { + get + { + return _friendlistptr; + } + } + + public string FriendlistPTR_Mask + { + get + { + return _friendlistptr_mask; + } + } + #endregion + } +} diff --git a/GTAVCSMM.csproj b/GTAVCSMM.csproj new file mode 100644 index 0000000..cdc75f9 --- /dev/null +++ b/GTAVCSMM.csproj @@ -0,0 +1,101 @@ + + + + + Debug + AnyCPU + {B727A908-C9EA-4CFA-8C2F-B209847607A4} + WinExe + GTAVCSMM + GTAVCSMM + v4.8 + 512 + true + true + + + + app.manifest + + + true + bin\x64\Debug\ + DEBUG;TRACE + full + x64 + default + prompt + true + + + bin\x64\Release\ + TRACE + true + pdbonly + x64 + default + prompt + true + + + gtavcsmm.ico + + + + ..\..\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.8\System.dll + + + + + + ..\..\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.8\Microsoft.CSharp.dll + + + + + + + + + + + + + + + + + + + + + + + ResXFileCodeGenerator + Resources.Designer.cs + Designer + + + True + Resources.resx + True + + + + SettingsSingleFileGenerator + Settings.Designer.cs + + + True + Settings.settings + True + + + + + + + + + + \ No newline at end of file diff --git a/GTAVCSMM.sln b/GTAVCSMM.sln new file mode 100644 index 0000000..cdba9fb --- /dev/null +++ b/GTAVCSMM.sln @@ -0,0 +1,30 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 14 +VisualStudioVersion = 14.0.25420.1 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GTAVCSMM", "GTAVCSMM.csproj", "{B727A908-C9EA-4CFA-8C2F-B209847607A4}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Debug|x64 = Debug|x64 + Release|Any CPU = Release|Any CPU + Release|x64 = Release|x64 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {B727A908-C9EA-4CFA-8C2F-B209847607A4}.Debug|Any CPU.ActiveCfg = Debug|x64 + {B727A908-C9EA-4CFA-8C2F-B209847607A4}.Debug|Any CPU.Build.0 = Debug|x64 + {B727A908-C9EA-4CFA-8C2F-B209847607A4}.Debug|x64.ActiveCfg = Debug|x64 + {B727A908-C9EA-4CFA-8C2F-B209847607A4}.Debug|x64.Build.0 = Debug|x64 + {B727A908-C9EA-4CFA-8C2F-B209847607A4}.Release|Any CPU.ActiveCfg = Release|x64 + {B727A908-C9EA-4CFA-8C2F-B209847607A4}.Release|x64.ActiveCfg = Release|x64 + {B727A908-C9EA-4CFA-8C2F-B209847607A4}.Release|x64.Build.0 = Release|x64 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {1A9868FA-81ED-4632-83D7-1937FB01B5BC} + EndGlobalSection +EndGlobal diff --git a/Helpers/JOAAT.cs b/Helpers/JOAAT.cs new file mode 100644 index 0000000..de6ba37 --- /dev/null +++ b/Helpers/JOAAT.cs @@ -0,0 +1,93 @@ +/// +/// Represents a class for generating hash keys compatible with the JOAAT hash algorithm. +/// +namespace GTAVCSMM.Helpers +{ + public class JOAAT + { + // copied directly from the game -- performs uppercase to lowercase conversions amongst other things + private static readonly byte[] m_LookupTable = { + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, + 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, + 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F, + 0x40, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, + 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x5B, 0x2F, 0x5D, 0x5E, 0x5F, + 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, + 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F, + 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, + 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, + 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, + 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, + 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, + 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, + 0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF, + 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF, + }; + + private static uint GetHashKeySubString(string str, uint initialHash) + { + var hash = initialHash; + for (int i = 0; i < str.Length; i++) + { + hash += m_LookupTable[str[i]]; + hash += (hash << 10); + hash ^= (hash >> 6); + } + return hash; + } + + private static uint GetHashKeyFinalize(string str, uint initialHash) + { + var hash = GetHashKeySubString(str, initialHash); + hash += (hash << 3); + hash ^= (hash >> 11); + hash += (hash << 15); + return hash; + } + + /// + /// Gets the hash key of the specified string. + /// + /// The string used to generate a hash key. + /// A case-insensitive JOAAT hash key. + public static uint GetHashKey(string str) + { + return GetHashKey(str, 0); + } + + /// + /// Gets the hash key of the specified string, using an initial hash key value. + /// + /// The string used to generate a hash key. + /// The initial hash key value used to generate the result. + /// A case-insensitive JOAAT hash key. + public static uint GetHashKey(string str, uint initialHash) + { + return GetHashKeyFinalize(str, initialHash); + } + + /// + /// Gets the hash key of the specified string concatenated with an additional string. + /// + /// The string used to generate a hash key. + /// The additional string to concatenate to the input string. + /// A case-insensitive JOAAT hash key. + public static uint GetHashKey(string str, string concat) + { + return GetHashKey(str, concat, 0); + } + + /// + /// Gets the hash key of the specified string concatenated with an additional string, using an initial hash key value. + /// + /// The string used to generate a hash key. + /// The additional string to concatenate to the input string. + /// The initial hash key value used to generate the result. + /// A case-insensitive JOAAT hash key. + public static uint GetHashKey(string str, string concat, uint initialHash) + { + return GetHashKeyFinalize(concat, GetHashKeySubString(str, initialHash)); + } + } +} \ No newline at end of file diff --git a/Helpers/Key.cs b/Helpers/Key.cs new file mode 100644 index 0000000..d4e457b --- /dev/null +++ b/Helpers/Key.cs @@ -0,0 +1,45 @@ +using System; + +namespace GTAVCSMM.Helpers +{ + class Key + { + private string keyName; + private int keyId; + private bool keyDown; + + public Key(int keyId, string keyName) + { + this.keyId = keyId; + this.keyName = keyName; + } + + public string Name + { + get + { + return keyName; + } + } + + public int Id + { + get + { + return keyId; + } + } + + public bool IsKeyDown + { + get + { + return keyDown; + } + set + { + keyDown = value; + } + } + } +} diff --git a/Helpers/KeysMgr.cs b/Helpers/KeysMgr.cs new file mode 100644 index 0000000..b027cab --- /dev/null +++ b/Helpers/KeysMgr.cs @@ -0,0 +1,113 @@ +using System; +using System.Threading; +using System.Collections.Generic; +using System.Runtime.InteropServices; + +namespace GTAVCSMM.Helpers +{ + class KeysMgr + { + // Keys holder + private Dictionary keys; + + // Update thread + private Thread thread; + private int interval = 20; // ms + + // Keys events + public delegate void KeyHandler(int Id, string Name); + public event KeyHandler KeyUpEvent; + public event KeyHandler KeyDownEvent; + + // Key Up + protected void OnKeyUp(int Id, string Name) + { + if (KeyUpEvent != null) + { + KeyUpEvent(Id, Name); + } + } + + // Key Down + protected void OnKeyDown(int Id, string Name) + { + if (KeyDownEvent != null) + { + KeyDownEvent(Id, Name); + } + } + + // Init + public KeysMgr() + { + keys = new Dictionary(); + thread = new Thread(new ParameterizedThreadStart(Update)); + thread.Start(); + } + + // Add key + public void AddKey(int keyId, string keyName) + { + if (!keys.ContainsKey(keyId)) + { + keys.Add(keyId, new Key(keyId, keyName)); + } + } + + // Add key + public void AddKey(System.Windows.Forms.Keys key) + { + int keyId = (int)key; + if (!keys.ContainsKey(keyId)) + { + keys.Add(keyId, new Key(keyId, key.ToString())); + } + } + + // Is Key Down + public bool IsKeyDown(int keyId) + { + Key value; + if (keys.TryGetValue(keyId, out value)) + { + return value.IsKeyDown; + } + return false; + } + + // Update Thread + private void Update(object sender) + { + while (true) + { + if (keys.Count > 0) + { + List keysData = new List(keys.Values); + if (keysData != null && keysData.Count > 0) + { + foreach (Key key in keysData) + { + if (Convert.ToBoolean(Manager.GetKeyState(key.Id) & Manager.KEY_PRESSED)) + { + if (!key.IsKeyDown) + { + key.IsKeyDown = true; + OnKeyDown(key.Id, key.Name); + } + } + else + { + if (key.IsKeyDown) + { + key.IsKeyDown = false; + OnKeyUp(key.Id, key.Name); + } + } + } + } + } + Thread.Sleep(interval); + } + } + } +} diff --git a/Helpers/Manager.cs b/Helpers/Manager.cs new file mode 100644 index 0000000..208cfcc --- /dev/null +++ b/Helpers/Manager.cs @@ -0,0 +1,165 @@ +using System; +using System.Runtime.InteropServices; + +namespace GTAVCSMM.Helpers +{ + class Manager + { + // READ FLAGS + public static uint PROCESS_VM_READ = 0x0010; + public static uint PROCESS_VM_WRITE = 0x0020; + public static uint PROCESS_VM_OPERATION = 0x0008; + public static uint PAGE_READWRITE = 0x0004; + + // WINDOW FLAGS + public static uint WS_MAXIMIZE = 0x1000000; + public static uint WS_CAPTION = 0xC00000; // WS_BORDER or WS_DLGFRAME + public static uint WS_BORDER = 0x800000; + public static uint WS_VISIBLE = 0x10000000; + public static int GWL_STYLE = (-16); + + // KEY PRESSED + public const int KEY_PRESSED = 0x8000; + + //MOUSE BUTTONS + public const int VK_LEFTBUTTON = 0x01; + public const int VK_MIDBUTTON = 0x04; + public const int VK_RIGHTBUTTON = 0X02; + public const int VK_LBUTTON = VK_LEFTBUTTON; + public const int VK_MBUTTON = VK_MIDBUTTON; + public const int VK_RBUTTON = VK_RIGHTBUTTON; + + // KEYBOARD + public const int VK_CANCEL = 0x03; + public const int VK_BACKSPACE = 0x08; + public const int VK_TAB = 0x09; + public const int VK_CLEAR = 0x0C; + public const int VK_ENTER = 0x0D; + public const int VK_SHIFT = 0x10; // Any of the 2 shift keys + public const int VK_LSHIFT = 0xA0; // Left Shift Key + public const int VK_RSHIFT = 0xA1; // Right shift key + public const int VK_CTRL = 0x11; // Any of the 2 CTRL keys + public const int VK_LCTRL = 0xA2; // Left CTRL key + public const int VK_RCTRL = 0xA3; // Right CTRL key + public const int VK_ALT = 0x12; // Any of the 2 ALT keys + public const int VK_LMENU = 0xA4; // Left ALT key + public const int VK_RMENU = 0xA5; // Right ALT key + public const int VK_CAPSLOCK = 0x14; + public const int VK_ESCAPE = 0x1B; + public const int VK_SPACE = 0x20; + public const int VK_LEFT = 0x25; + public const int VK_UP = 0x26; + public const int VK_RIGHT = 0x27; + public const int VK_DOWN = 0x28; + public const int VK_SELECT = 0x29; + public const int VK_INSERT = 0x2D; + public const int VK_DELETE = 0x2E; + public const int VK_HELP = 0x2F; + + // KEYBOARD NUMBERS + public const int VK_KEYB0 = 0x30; + public const int VK_KEYB1 = 0x31; + public const int VK_KEYB2 = 0x32; + public const int VK_KEYB3 = 0x33; + public const int VK_KEYB4 = 0x34; + public const int VK_KEYB5 = 0x35; + public const int VK_KEYB6 = 0x36; + public const int VK_KEYB7 = 0x37; + public const int VK_KEYB8 = 0x38; + public const int VK_KEYB9 = 0x39; + + // NUMPAD + public const int VK_NUMLOCK = 0x90; + public const int VK_NUMPAD0 = 0x60; + public const int VK_NUMPAD1 = 0x61; + public const int VK_NUMPAD2 = 0x62; + public const int VK_NUMPAD3 = 0x63; + public const int VK_NUMPAD4 = 0x64; + public const int VK_NUMPAD5 = 0x65; + public const int VK_NUMPAD6 = 0x66; + public const int VK_NUMPAD7 = 0x67; + public const int VK_NUMPAD8 = 0x68; + public const int VK_NUMPAD9 = 0x69; + public const int VK_MULTIPLY = 0x6A; + public const int VK_ADD = 0x6B; + public const int VK_SEPARATOR = 0x6C; + public const int VK_SUBTRACT = 0x6D; + public const int VK_DECIMAL = 0x6E; + public const int VK_DIVIDE = 0x6F; + + // FUNCTION KEYS + public const int VK_F1 = 0x70; + public const int VK_F2 = 0x71; + public const int VK_F3 = 0x72; + public const int VK_F4 = 0x73; + public const int VK_F5 = 0x74; + public const int VK_F6 = 0x75; + public const int VK_F7 = 0x76; + public const int VK_F8 = 0x77; + public const int VK_F9 = 0x78; + public const int VK_F10 = 0x79; + public const int VK_F11 = 0x7A; + public const int VK_F12 = 0x7B; + public const int VK_F13 = 0x7C; + public const int VK_F14 = 0x7D; + public const int VK_F15 = 0x7E; + public const int VK_F16 = 0x7F; + public const int VK_F17 = 0x80; + public const int VK_F18 = 0x81; + public const int VK_F19 = 0x82; + public const int VK_F20 = 0x83; + public const int VK_F21 = 0x84; + public const int VK_F22 = 0x85; + public const int VK_F23 = 0x86; + public const int VK_F24 = 0x87; + + // LETTERS + public const int VK_A = 0x41; + public const int VK_B = 0x42; + public const int VK_C = 0x43; + public const int VK_D = 0x44; + public const int VK_E = 0x45; + public const int VK_F = 0x46; + public const int VK_G = 0x47; + public const int VK_H = 0x48; + public const int VK_I = 0x49; + public const int VK_J = 0x4A; + public const int VK_K = 0x4B; + public const int VK_L = 0x4C; + public const int VK_M = 0x4D; + public const int VK_N = 0x4E; + public const int VK_O = 0x4F; + public const int VK_P = 0x50; + public const int VK_Q = 0x51; + public const int VK_R = 0x52; + public const int VK_S = 0x53; + public const int VK_T = 0x54; + public const int VK_U = 0x55; + public const int VK_V = 0x56; + public const int VK_W = 0x57; + public const int VK_X = 0x58; + public const int VK_Y = 0x59; + public const int VK_Z = 0x5A; + + [DllImport("user32.dll")] + public static extern short GetKeyState(int KeyStates); + + //These will be needed for function hooking (infinite ammo) + //Expect an update with that included + [DllImport("kernel32.dll")] + public static extern IntPtr OpenProcess(UInt32 dwAccess, bool inherit, int pid); + + [DllImport("kernel32.dll")] + public static extern bool CloseHandle(IntPtr handle); + + [DllImport("kernel32.dll", SetLastError = true)] + public static extern bool VirtualProtectEx(IntPtr hProcess, IntPtr lpAddress, UInt32 dwSize, uint flNewProtect, out uint lpflOldProtect); + + [DllImport("kernel32.dll", SetLastError = true)] + public static extern bool ReadProcessMemory(IntPtr hProcess, Int64 lpBaseAddress, [In, Out] byte[] lpBuffer, UInt64 dwSize, out IntPtr lpNumberOfBytesRead); + + [DllImport("kernel32.dll")] + public static extern bool WriteProcessMemory(IntPtr hProcess, Int64 lpBaseAddress, [In, Out] byte[] lpBuffer, UInt64 dwSize, out IntPtr lpNumberOfBytesWritten); + + } +} diff --git a/Helpers/Speeder.cs b/Helpers/Speeder.cs new file mode 100644 index 0000000..2d0a147 --- /dev/null +++ b/Helpers/Speeder.cs @@ -0,0 +1,134 @@ +using System; +using System.Diagnostics; +using System.Runtime.InteropServices; + +namespace GTAVCSMM.Helpers +{ + + public static class Speeder + { + public static bool Suspend(int process) + { + try + { + // Obtain process instance. + Process proc = Process.GetProcessById(process); + + if (proc == null) + return false; + + // Obtain thread handle. + ProcessThread thread = proc.Threads[0]; + IntPtr lpThreadHandle = NativeAPI.OpenThread(NativeAPI.ThreadAccess.SUSPEND_RESUME, false, (uint)thread.Id); + if (lpThreadHandle == IntPtr.Zero) + return false; + + NativeAPI.SuspendThread(lpThreadHandle); + NativeAPI.CloseHandle(lpThreadHandle); + + return true; + } + catch { return false; } + } + + public static bool Resume(int process, bool bForceResume = false) + { + try + { + // Obtain process instance. + Process proc = Process.GetProcessById(process); + if (proc == null) + return false; + + // Obtain thread handle. + ProcessThread thread = proc.Threads[0]; + IntPtr lpThreadHandle = NativeAPI.OpenThread(NativeAPI.ThreadAccess.SUSPEND_RESUME, false, (uint)thread.Id); + if (lpThreadHandle == IntPtr.Zero) + return false; + + if (bForceResume == true) + while (NativeAPI.ResumeThread(lpThreadHandle) != 0) ; + else + NativeAPI.ResumeThread(lpThreadHandle); + + NativeAPI.CloseHandle(lpThreadHandle); + return true; + } + catch { return false; } + } + + #region "Native Win32 API Definitions" + /// + /// Native Win32 API Definitions + /// + /// API needed in order to do the required tasks of + /// loading, injection, and remote export calling. + /// + internal class NativeAPI + { + /// + /// kernel32.CloseHandle + /// + /// + /// + [DllImport("kernel32.dll", SetLastError = true)] + [return: MarshalAs(UnmanagedType.Bool)] + public static extern bool CloseHandle( + IntPtr hObject + ); + + /// + /// kernel32.OpenThread + /// + /// + /// + /// + /// + [DllImport("kernel32.dll")] + public static extern IntPtr OpenThread( + ThreadAccess dwDesiredAccess, + bool bInheritHandle, + uint dwThreadId + ); + + + /// + /// kernel32.ResumeThread + /// + /// + /// + [DllImport("kernel32.dll")] + public static extern uint ResumeThread( + IntPtr hThread + ); + + /// + /// kernel32.SuspendThread + /// + /// + /// + [DllImport("kernel32.dll")] + public static extern uint SuspendThread( + IntPtr hThread + ); + + /// + /// Thread access flags. + /// + [Flags] + public enum ThreadAccess : int + { + TERMINATE = (0x0001), + SUSPEND_RESUME = (0x0002), + GET_CONTEXT = (0x0008), + SET_CONTEXT = (0x0010), + SET_INFORMATION = (0x0020), + QUERY_INFORMATION = (0x0040), + SET_THREAD_TOKEN = (0x0080), + IMPERSONATE = (0x0100), + DIRECT_IMPERSONATION = (0x0200) + } + } + #endregion + } +} diff --git a/Memory/Mem.cs b/Memory/Mem.cs new file mode 100644 index 0000000..8028bfd --- /dev/null +++ b/Memory/Mem.cs @@ -0,0 +1,124 @@ +using System; +using System.Diagnostics; +using System.Runtime.InteropServices; +using System.Text; + +namespace GTAVCSMM.Memory +{ + class Mem + { + + [DllImport("kernel32.dll")] + public static extern int WriteProcessMemory(IntPtr Handle, long Address, byte[] buffer, int Size, int BytesWritten = 0); + [DllImport("kernel32.dll")] + public static extern int ReadProcessMemory(IntPtr Handle, long Address, byte[] buffer, int Size, int BytesRead = 0); + + public Process Proc; + public long BaseAddress; + + public Mem(string process) + { + try + { + Proc = Process.GetProcessesByName(process)[0]; + BaseAddress = Proc.MainModule.BaseAddress.ToInt64(); + } + catch { throw new Exception(); } + } + + public IntPtr GetProcHandle() + { + try { return Proc.Handle; } catch { return IntPtr.Zero; } + } + + public long GetPtrAddr(long Pointer, int[] Offset = null) + { + byte[] Buffer = new byte[8]; + + ReadProcessMemory(GetProcHandle(), Pointer, Buffer, Buffer.Length); + + if (Offset != null) + { + for (int x = 0; x < (Offset.Length - 1); x++) + { + Pointer = BitConverter.ToInt64(Buffer, 0) + Offset[x]; + ReadProcessMemory(GetProcHandle(), Pointer, Buffer, Buffer.Length); + } + + Pointer = BitConverter.ToInt64(Buffer, 0) + Offset[Offset.Length - 1]; + } + + return Pointer; + } + + public long FindPattern(byte[] pattern, string mask) + { + int moduleSize = Proc.MainModule.ModuleMemorySize; + + if (moduleSize == 0) throw new Exception($"Size of module {Proc.MainModule.ModuleName} is INVALID."); + + byte[] moduleBytes = new byte[moduleSize]; + ReadProcessMemory(GetProcHandle(), BaseAddress, moduleBytes, moduleSize); + + for (long i = 0; i < moduleSize; i++) + { + for (int l = 0; l < mask.Length; l++) + //dirty hack heh + if (!(mask[l] == '?' || moduleBytes[l + i] == pattern[l])) goto SKIP; + + return i; + SKIP:; + } + return 0; + } + + public byte[] ReadBytes(long BasePTR, int[] offset, int Length) + { + byte[] Buffer = new byte[Length]; + ReadProcessMemory(GetProcHandle(), GetPtrAddr(BaseAddress + BasePTR, offset), Buffer, Length); + return Buffer; + } + + public byte[] ReadBytes_new(long BasePTR, int[] offset, int Length) + { + byte[] Buffer = new byte[Length]; + ReadProcessMemory(GetProcHandle(), BasePTR, Buffer, Length); + return Buffer; + } + + public void Write(long BasePTR, int[] offset, byte[] Bytes) => WriteProcessMemory(GetProcHandle(), GetPtrAddr(BaseAddress + BasePTR, offset), Bytes, Bytes.Length); + + public void Write(long BasePTR, int[] offset, bool b) => Write(BasePTR, offset, b ? new byte[] { 0x01 } : new byte[] { 0x00 }); + public void Write(long BasePTR, int[] offset, float Value) => Write(BasePTR, offset, BitConverter.GetBytes(Value)); + public void Write(long BasePTR, int[] offset, double Value) => Write(BasePTR, offset, BitConverter.GetBytes(Value)); + public void Write(long BasePTR, int[] offset, int Value) => Write(BasePTR, offset, BitConverter.GetBytes(Value)); + public void Write(long BasePTR, int[] offset, string String) => Write(BasePTR, offset, new ASCIIEncoding().GetBytes(String)); + public void Write(long BasePTR, int[] offset, long Value) => Write(BasePTR, offset, BitConverter.GetBytes(Value)); + public void Write(long BasePTR, int[] offset, uint Value) => Write(BasePTR, offset, BitConverter.GetBytes(Value)); + public void Write(long BasePTR, int[] offset, byte Value) => Write(BasePTR, offset, new byte[] { Value }); + + public void writeInt(long BasePTR, int[] offset, int Value) + { + WriteProcessMemory(Proc.Handle, BasePTR, BitConverter.GetBytes(Value), 4); + } + public void writePointer(long BasePTR, int[] offset, long Value) + { + WriteProcessMemory(Proc.Handle, BasePTR, BitConverter.GetBytes(Value), 8); + } + public void writeFloat(long BasePTR, int[] offset, float Value) + { + WriteProcessMemory(Proc.Handle, BasePTR, BitConverter.GetBytes(Value), 8); + } + + public bool ReadBool(long BasePTR, int[] offset) => ReadByte(BasePTR, offset) != 0x00; + public float ReadFloat(long BasePTR, int[] offset) => BitConverter.ToSingle(ReadBytes(BasePTR, offset, 4), 0); + public double ReadDouble(long BasePTR, int[] offset) => BitConverter.ToDouble(ReadBytes(BasePTR, offset, 8), 0); + public int ReadInt(long BasePTR, int[] offset) => BitConverter.ToInt32(ReadBytes(BasePTR, offset, 4), 0); + public uint ReadUInt(long BasePTR, int[] offset) => BitConverter.ToUInt32(ReadBytes(BasePTR, offset, 4), 0); + public string ReadString(long BasePTR, int[] offset, int size) => new ASCIIEncoding().GetString(ReadBytes(BasePTR, offset, size)); + public long ReadPointer(long BasePTR, int[] offset) => BitConverter.ToInt64(ReadBytes(BasePTR, offset, 8), 0); + public byte ReadByte(long BasePTR, int[] offset) => ReadBytes(BasePTR, offset, 1)[0]; + public string ReadStr(long BasePTR, int[] offset, int size) => new ASCIIEncoding().GetString(ReadBytes_new(BasePTR, offset, size)); + + } +} \ No newline at end of file diff --git a/Program.cs b/Program.cs new file mode 100644 index 0000000..8692fc0 --- /dev/null +++ b/Program.cs @@ -0,0 +1,2407 @@ +using GTAVCSMM.Config; +using GTAVCSMM.Helpers; +using GTAVCSMM.Memory; +using GTAVCSMM.Settings; +using System; +using System.Diagnostics; +using System.Linq; +using System.Runtime.InteropServices; +using System.Threading; +using System.Windows.Forms; + +namespace GTAVCSMM +{ + static class Program + { + private const int WH_KEYBOARD_LL = 13; + private const int WM_KEYDOWN = 0x0100; + private static LowLevelKeyboardProc _proc = HookCallback; + private static IntPtr _hookID = IntPtr.Zero; + const int SW_HIDE = 0; + + [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)] + private static extern IntPtr SetWindowsHookEx(int idHook, + LowLevelKeyboardProc lpfn, IntPtr hMod, uint dwThreadId); + + [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)] + [return: MarshalAs(UnmanagedType.Bool)] + private static extern bool UnhookWindowsHookEx(IntPtr hhk); + + [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)] + private static extern IntPtr CallNextHookEx(IntPtr hhk, int nCode, + IntPtr wParam, IntPtr lParam); + + [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)] + private static extern IntPtr GetModuleHandle(string lpModuleName); + + [DllImport("user32.dll")] + static extern bool ShowWindow(IntPtr hWnd, int nCmdShow); + + private static bool isHidden = false; + private static IntPtr formHandle; + + private static int menuMainLvl = 0; + private static int LastMenuMainLvl = 0; + private static int menuLvl = 0; + private static int LastMenuLvl = 0; + private static int menuItm = 0; + private static int LastMenuItm = 0; + private static Form mainForm = new Form(); + private static ListBox listBx = new ListBox(); + private static Label label1 = new Label(); + private static Label label2 = new Label(); + private static string lastNavigation = string.Empty; + + #region WINDOW SETUP + + public const string WINDOW_NAME = "Grand Theft Auto V"; + public static IntPtr handle = FindWindow(null, WINDOW_NAME); + + public static RECT rect; + + public struct RECT + { + public int left, top, right, bottom; + } + + [DllImport("user32.dll", SetLastError = true)] + static extern IntPtr FindWindow(string IpClassName, string IpWindowName); + + [DllImport("user32.dll")] + static extern int SetWindowLong(IntPtr hWnd, int nIndex, int dwNewLong); + + [DllImport("user32.dll", SetLastError = true)] + static extern int GetWindowLong(IntPtr hWnd, int nIndex); + + [DllImport("user32.dll")] + public static extern bool GetWindowRect(IntPtr hwnd, out RECT IpRect); + + public static Offsets offsets = new Offsets(); + public static Addresses addresses = new Addresses(); + public static Patterns pattern = new Patterns(); + public static TSettings settings = new TSettings(); + public static Mem Mem; + public static Thread _getPointer; + public static Thread _freezeGame; + + public static System.Windows.Forms.Timer ProcessTimer = new System.Windows.Forms.Timer(); + public static System.Windows.Forms.Timer MemoryTimer = new System.Windows.Forms.Timer(); + public static System.Windows.Forms.Timer fastTimer = new System.Windows.Forms.Timer(); + + #endregion + + #region PROCESS INFO + private static bool bGodMode = false; + private static bool bgodState = false; + private static bool bNeverWanted = false; + private static bool bNoRagdoll = false; + private static bool bUndeadOffRadar = false; + private static bool bSeatBelt = false; + private static bool bSuperJump = false; + private static bool bExplosiveAmmo = false; + private static bool bDisableCollision = false; + private static bool bVehicleGodMode = false; + private static int frameFlagCount = 0; + + [DllImport("user32.dll")] + static extern short GetAsyncKeyState(System.Windows.Forms.Keys vKey); + + [DllImport("user32.dll")] + public static extern void mouse_event(int a, int b, int c, int d, int damnIwonderifpeopleactuallyreadsthis); + #endregion + + #region METHODS + public static void pGODMODE() + { + if (bGodMode) + { + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.oGod }, 1); + if (!settings.pgodm) + { + Activate(); + } + settings.pgodm = true; + } + else + { + if (settings.pgodm) + { + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.oGod }, 0); + settings.pgodm = false; + Deactivate(); + } + } + } + + public static void pNEVERWANTED() + { + if (bNeverWanted) + { + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPlayerInfo, offsets.oWanted }, 0); + if (!settings.pnwanted) + { + Activate(); + } + settings.pnwanted = true; + } + else + { + if (settings.pnwanted) + { + settings.pnwanted = false; + Deactivate(); + } + } + } + + public static void pNORAGDOLL() + { + if (bNoRagdoll) + { + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.oRagdoll }, 1); + if (!settings.pnragdoll) + { + Activate(); + } + settings.pnragdoll = true; + } + else + { + if (settings.pnragdoll) + { + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.oRagdoll }, 32); + settings.pnragdoll = false; + Deactivate(); + } + } + } + + public static void pUNDEADOFFRADAR() + { + if (bUndeadOffRadar) + { + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.oHealthMax }, 0); + if (!settings.puoffradar) + { + Activate(); + } + settings.puoffradar = true; + } + else + { + if (settings.puoffradar) + { + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.oHealthMax }, 328f); + settings.puoffradar = false; + Deactivate(); + } + } + } + + public static void pSEATBELT() + { + if (bSeatBelt) + { + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.oSeatbelt }, -55); + if (!settings.psbelt) + { + Activate(); + } + settings.psbelt = true; + } + else + { + if (settings.psbelt) + { + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.oSeatbelt }, -56); + settings.psbelt = false; + Deactivate(); + } + } + } + + public static void pSUPERJUMP() + { + if (bSuperJump) + { + if (!settings.psjump) + { + frameFlagCount = frameFlagCount + 64; + Activate(); + } + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPlayerInfo, offsets.oFrameFlags }, frameFlagCount); + settings.psjump = true; + } + else + { + if (settings.psjump) + { + frameFlagCount = frameFlagCount - 64; + Deactivate(); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPlayerInfo, offsets.oFrameFlags }, frameFlagCount); + settings.psjump = false; + } + } + } + + public static void pEXPLOSIVEAMMO() + { + if (bExplosiveAmmo) + { + if (!settings.psexammo) + { + frameFlagCount = frameFlagCount + 8; + Activate(); + } + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPlayerInfo, offsets.oFrameFlags }, frameFlagCount); + settings.psexammo = true; + } + else + { + if (settings.psexammo) + { + frameFlagCount = frameFlagCount - 8; + Deactivate(); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPlayerInfo, offsets.oFrameFlags }, frameFlagCount); + settings.psexammo = false; + } + } + } + public static void pDISABLECOLLISION() + { + long paddr = Mem.ReadPointer(settings.WorldPTR, new int[] { offsets.pCPed, 0x30, 0x10, 0x20, 0x70, 0x0 }); + long paddr2 = Mem.GetPtrAddr(paddr + 0x2C, null); + + if (bDisableCollision) + { + Mem.writeFloat(paddr2, null, -1.0f); + if (!settings.pdiscol) + { + Activate(); + } + settings.pdiscol = true; + } + else + { + if (settings.pdiscol) + { + Mem.writeFloat(paddr2, null, 0.25f); + settings.pdiscol = false; + Deactivate(); + } + } + } + public static void vGODMODE() + { + long paddr = Mem.ReadPointer(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCVehicle }); + if (paddr > 0) + { + long paddr2 = Mem.GetPtrAddr(paddr + offsets.oGod, null); + if (bVehicleGodMode) + { + Mem.writeInt(paddr2, null, 1); + if (!settings.vgodm) + { + Activate(); + } + settings.vgodm = true; + } + else + { + if (settings.vgodm) + { + Mem.writeInt(paddr2, null, 0); + settings.vgodm = false; + Deactivate(); + } + } + } + } + + public static void getPointer() + { + try + { + Mem = new Mem(settings.gameName); + + var processes = Process.GetProcessesByName(settings.gameName); + foreach (var p in processes) + { + if (p.Id > 0) + { + settings.gameProcess = p.Id; + } + } + + // GlobalPTR + long addr = Mem.FindPattern(pattern.GlobalPTR, pattern.GlobalPTR_Mask); + settings.GlobalPTR = addr + Mem.ReadInt(addr + 3, null) + 7; + + // WorldPTR + long addr2 = Mem.FindPattern(pattern.WorldPTR, pattern.WorldPTR_Mask); + settings.WorldPTR = addr2 + Mem.ReadInt(addr2 + 3, null) + 7; + + // BlipPTR + long addr3 = Mem.FindPattern(pattern.BlipPTR, pattern.BlipPTR_Mask); + settings.BlipPTR = addr3 + Mem.ReadInt(addr3 + 3, null) + 7; + + // ReplayInterfacePTR + long addr4 = Mem.FindPattern(pattern.ReplayInterfacePTR, pattern.ReplayInterfacePTR_Mask); + settings.ReplayInterfacePTR = addr4 + Mem.ReadInt(addr4 + 3, null) + 7; + + // LocalScriptsPTR + long addr5 = Mem.FindPattern(pattern.LocalScriptsPTR, pattern.LocalScriptsPTR_Mask); + settings.LocalScriptsPTR = addr5 + Mem.ReadInt(addr5 + 3, null) + 7; + + // PlayerCountPTR + long addr6 = Mem.FindPattern(pattern.PlayerCountPTR, pattern.PlayerCountPTR_Mask); + settings.PlayerCountPTR = addr6 + Mem.ReadInt(addr6 + 3, null) + 7; + + // PickupDataPTR + long addr7 = Mem.FindPattern(pattern.PickupDataPTR, pattern.PickupDataPTR_Mask); + settings.PickupDataPTR = addr7 + Mem.ReadInt(addr7 + 3, null) + 7; + + // WeatherADDR + long addr8 = Mem.FindPattern(pattern.WeatherADDR, pattern.WeatherADDR_Mask); + settings.WeatherADDR = addr8 + Mem.ReadInt(addr8 + 6, null) + 10; + + // SettingsPTR + long addr9 = Mem.FindPattern(pattern.SettingsPTR, pattern.SettingsPTR_Mask); + settings.SettingsPTR = addr9 + Mem.ReadInt(addr9 + 3, null) - Convert.ToInt64("0x89", 16); + + // AimCPedPTR + long addr10 = Mem.FindPattern(pattern.AimCPedPTR, pattern.AimCPedPTR_Mask); + settings.AimCPedPTR = addr10 + Mem.ReadInt(addr10 + 3, null) + 7; + + // FriendlistPTR + long addr11 = Mem.FindPattern(pattern.FriendlistPTR, pattern.FriendlistPTR_Mask); + settings.FriendlistPTR = addr11 + Mem.ReadInt(addr11 + 3, null) + 7; + } + catch + { + MessageBox.Show("GTA is not Running!", "Serious Error", MessageBoxButtons.OK, MessageBoxIcon.Error); + Quit(); + } + _getPointer.Abort(); + } + + public static void freezeGame() + { + Console.WriteLine("Freezing game"); + Speeder.Suspend(settings.gameProcess); + Thread.Sleep(10000); + Speeder.Resume(settings.gameProcess); + _freezeGame.Abort(); + } + #endregion + + + #region TIMERS + + private static void ProcessTimer_Tick(object sender, EventArgs e) + { + + } + + private static void MemoryTimer_Tick(object sender, EventArgs e) + { + pGODMODE(); + pNEVERWANTED(); + pNORAGDOLL(); + pUNDEADOFFRADAR(); + pSEATBELT(); + pDISABLECOLLISION(); + vGODMODE(); + } + + private static void fastTimer_Tick(object sender, EventArgs e) + { + pSUPERJUMP(); + pEXPLOSIVEAMMO(); + } + + #endregion + + private static void Quit() + { + Environment.Exit(0); + } + + //audio response to actions + public static void Activate() + { + Console.Beep(523, 75); + Console.Beep(587, 75); + Console.Beep(700, 75); + } + + public static void Deactivate() + { + Console.Beep(700, 75); + Console.Beep(587, 75); + Console.Beep(523, 75); + } + + public static void Toggle() + { + Console.Beep(523, 75); + Console.Beep(523, 75); + Console.Beep(523, 75); + } + + /// + /// The main entry point for the application. + /// + [STAThread] + static void Main() + { + bool createdNew = true; + using (Mutex mutex = new Mutex(true, "GTA5TrainerCS", out createdNew)) + + if (createdNew) + { + _getPointer = new Thread(getPointer) { IsBackground = true }; + _getPointer.Start(); + + // + // listBx + // + listBx.BackColor = System.Drawing.Color.FromArgb(((int)(((byte)(255)))), ((int)(((byte)(255)))), ((int)(((byte)(128))))); + listBx.BorderStyle = System.Windows.Forms.BorderStyle.None; + listBx.Font = new System.Drawing.Font("Arial", 13.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + listBx.FormattingEnabled = true; + listBx.ItemHeight = 24; + listBx.Location = new System.Drawing.Point(6, 50); + listBx.Margin = new System.Windows.Forms.Padding(10); + listBx.MaximumSize = new System.Drawing.Size(290, 500); + listBx.Name = "listBox1"; + listBx.Size = new System.Drawing.Size(290, 480); + listBx.TabIndex = 0; + + // + // label1 + // + label1.AutoSize = true; + label1.BackColor = System.Drawing.Color.FromArgb(((int)(((byte)(255)))), ((int)(((byte)(255)))), ((int)(((byte)(128))))); + label1.Font = new System.Drawing.Font("Arial Black", 18F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + label1.Location = new System.Drawing.Point(1, 9); + label1.Name = "label1"; + label1.Size = new System.Drawing.Size(168, 33); + label1.TabIndex = 1; + label1.Text = "GTAVCSMM"; + // + // label2 + // + label2.AutoSize = true; + label2.Font = new System.Drawing.Font("Arial", 15.75F, ((System.Drawing.FontStyle)((System.Drawing.FontStyle.Bold | System.Drawing.FontStyle.Italic))), System.Drawing.GraphicsUnit.Point, ((byte)(0))); + label2.Location = new System.Drawing.Point(162, 16); + label2.Name = "label2"; + label2.Size = new System.Drawing.Size(65, 24); + label2.TabIndex = 2; + label2.Text = "o1.58"; + // + // fastTimer + // + fastTimer.Enabled = true; + fastTimer.Interval = 1; + fastTimer.Tick += new System.EventHandler(fastTimer_Tick); + // + // ProcessTimer + // + ProcessTimer.Enabled = true; + ProcessTimer.Interval = 100; + ProcessTimer.Tick += new System.EventHandler(ProcessTimer_Tick); + // + // MemoryTimer + // + MemoryTimer.Enabled = true; + MemoryTimer.Interval = 100; + MemoryTimer.Tick += new System.EventHandler(MemoryTimer_Tick); + // + // Form1 + // + mainForm.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + mainForm.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + mainForm.AutoSize = true; + mainForm.AutoSizeMode = System.Windows.Forms.AutoSizeMode.GrowAndShrink; + mainForm.BackColor = System.Drawing.Color.FromArgb(((int)(((byte)(255)))), ((int)(((byte)(255)))), ((int)(((byte)(128))))); + mainForm.ClientSize = new System.Drawing.Size(207, 116); + mainForm.Controls.Add(label2); + mainForm.Controls.Add(label1); + mainForm.Controls.Add(listBx); + mainForm.FormBorderStyle = System.Windows.Forms.FormBorderStyle.None; + mainForm.KeyPreview = true; + mainForm.Name = "Form1"; + mainForm.Opacity = 0.8D; + mainForm.ShowIcon = false; + mainForm.ShowInTaskbar = false; + mainForm.Text = "GTAVCSMM"; + mainForm.TopMost = true; + + formHandle = mainForm.Handle; + listboxStyle(); + listboxFill(0, 0); + _hookID = SetHook(_proc); + + mainForm.FormBorderStyle = FormBorderStyle.None; + int InitialStyle = GetWindowLong(mainForm.Handle, -10); + SetWindowLong(mainForm.Handle, -10, InitialStyle | 0x800000 | 0x20); + GetWindowRect(handle, out rect); + mainForm.Top = rect.top - 20; + mainForm.Left = rect.left + 30; + + mainForm.Show(); + + Application.EnableVisualStyles(); + Application.Run(); + + } + } + + public static void listboxStyle() + { + } + + public static void listboxFill(int mainMenulevel, int menulevel) + { + listBx.Items.Clear(); + switch (mainMenulevel) + { + case 0: + /* + * Mainlevel 0 + */ + listBx.Items.Add("Main \t\t\t ►"); // 0,0 + listBx.Items.Add("Session \t\t\t ►"); // 0,1 + listBx.Items.Add("Player \t\t\t ►"); // 0,2 + listBx.Items.Add("Vehicle \t\t\t ►"); // 0,3 + listBx.Items.Add("Weapon \t\t\t ►"); // 0,4 + listBx.Items.Add("Teleport \t\t\t ►"); // 0,5 + listBx.Items.Add("Tunables \t\t\t ►"); // 0,6 + listBx.Items.Add("Online Services \t\t ►"); // 0,7 + + menuMainLvl = 0; + menuLvl = 0; + + LastMenuMainLvl = 0; + LastMenuLvl = 0; + LastMenuItm = 0; + break; + + case 1: + switch (menulevel) + { + case 0: + listBx.Items.Add("Re-Init"); + listBx.Items.Add("Quit (Del)"); + + menuMainLvl = 1; + menuLvl = 0; + + LastMenuMainLvl = 0; + LastMenuLvl = 1; + LastMenuItm = 0; + break; + + case 1: + listBx.Items.Add("Join Public Session"); + listBx.Items.Add("New Public Session"); + listBx.Items.Add("Solo Session"); + listBx.Items.Add("Leave Online"); + listBx.Items.Add("Empty Session (10 Sec. Freeze)"); + listBx.Items.Add("Invite Only Session"); + listBx.Items.Add("Find Friend Session"); + listBx.Items.Add("Closed Friend Session"); + listBx.Items.Add("Crew Session"); + listBx.Items.Add("Join Crew Session"); + listBx.Items.Add("Closed Crew Session"); + /* + listBx.Items.Add("Disconnect"); + */ + + menuMainLvl = 1; + menuLvl = 1; + + LastMenuMainLvl = 0; + LastMenuLvl = 1; + LastMenuItm = 1; + break; + + case 2: + listBx.Items.Add("God Mode (F6)"); + listBx.Items.Add("Super Jump"); + listBx.Items.Add("Never Wanted (F7)"); + listBx.Items.Add("Seatbelt"); + listBx.Items.Add("No Ragdoll"); + listBx.Items.Add("Undead Off-Radar"); + listBx.Items.Add("Disable Collision"); + listBx.Items.Add("Skills \t\t\t ►"); + listBx.Items.Add("Swim Speed \t\t ►"); + listBx.Items.Add("Stealth Speed \t\t ►"); + listBx.Items.Add("Run Speed \t\t ►"); + listBx.Items.Add("Wanted Level \t\t ►"); + + menuMainLvl = 1; + menuLvl = 2; + + LastMenuMainLvl = 0; + LastMenuLvl = 1; + LastMenuItm = 2; + break; + + case 3: + listBx.Items.Add("God Mode"); + + menuMainLvl = 1; + menuLvl = 3; + + LastMenuMainLvl = 0; + LastMenuLvl = 1; + LastMenuItm = 3; + break; + + case 4: + listBx.Items.Add("Explosive Ammo"); + listBx.Items.Add("Long Range"); + + menuMainLvl = 1; + menuLvl = 4; + + LastMenuMainLvl = 0; + LastMenuLvl = 1; + LastMenuItm = 4; + break; + + case 5: + listBx.Items.Add("Waypoint (F8)"); + listBx.Items.Add("Objective"); + listBx.Items.Add("Locations \t\t ►"); + + menuMainLvl = 1; + menuLvl = 5; + + LastMenuMainLvl = 0; + LastMenuLvl = 1; + LastMenuItm = 5; + break; + + case 6: + listBx.Items.Add("RP Multipler \t\t ►"); + listBx.Items.Add("REP Multipler \t\t ►"); + listBx.Items.Add("Nightclub Popularity"); + + menuMainLvl = 1; + menuLvl = 6; + + LastMenuMainLvl = 0; + LastMenuLvl = 1; + LastMenuItm = 6; + break; + + case 7: + listBx.Items.Add("Get Lucky Wheel Price \t ►"); + + menuMainLvl = 1; + menuLvl = 7; + + LastMenuMainLvl = 0; + LastMenuLvl = 1; + LastMenuItm = 7; + break; + } + break; + + case 2: + switch (menulevel) + { + case 7: + listBx.Items.Add("Stamina"); + listBx.Items.Add("Strength"); + listBx.Items.Add("Lung Capacity"); + listBx.Items.Add("Driving"); + listBx.Items.Add("Flying"); + listBx.Items.Add("Shooting"); + listBx.Items.Add("Stealth"); + + menuMainLvl = 2; + menuLvl = 7; + + LastMenuMainLvl = 1; + LastMenuLvl = 2; + LastMenuItm = 7; + break; + + case 8: + listBx.Items.Add("Swim Speed = 0.0"); + listBx.Items.Add("Swim Speed = 0.5"); + listBx.Items.Add("Swim Speed = 1.0 (Default)"); + listBx.Items.Add("Swim Speed = 1.5"); + listBx.Items.Add("Swim Speed = 2.0"); + listBx.Items.Add("Swim Speed = 2.5"); + listBx.Items.Add("Swim Speed = 3.0"); + listBx.Items.Add("Swim Speed = 3.5"); + listBx.Items.Add("Swim Speed = 4.0"); + listBx.Items.Add("Swim Speed = 4.5"); + listBx.Items.Add("Swim Speed = 5.0"); + + menuMainLvl = 2; + menuLvl = 8; + + LastMenuMainLvl = 1; + LastMenuLvl = 2; + LastMenuItm = 8; + break; + + case 9: + listBx.Items.Add("Stealth Speed = 0.0"); + listBx.Items.Add("Stealth Speed = 0.5"); + listBx.Items.Add("Stealth Speed = 1.0 (Default)"); + listBx.Items.Add("Stealth Speed = 1.5"); + listBx.Items.Add("Stealth Speed = 2.0"); + listBx.Items.Add("Stealth Speed = 2.5"); + listBx.Items.Add("Stealth Speed = 3.0"); + listBx.Items.Add("Stealth Speed = 3.5"); + listBx.Items.Add("Stealth Speed = 4.0"); + listBx.Items.Add("Stealth Speed = 4.5"); + listBx.Items.Add("Stealth Speed = 5.0"); + + menuMainLvl = 2; + menuLvl = 9; + + LastMenuMainLvl = 1; + LastMenuLvl = 2; + LastMenuItm = 9; + break; + + case 10: + listBx.Items.Add("Run Speed = 0.0"); + listBx.Items.Add("Run Speed = 0.5"); + listBx.Items.Add("Run Speed = 1.0 (Default)"); + listBx.Items.Add("Run Speed = 1.5"); + listBx.Items.Add("Run Speed = 2.0"); + listBx.Items.Add("Run Speed = 2.5"); + listBx.Items.Add("Run Speed = 3.0"); + listBx.Items.Add("Run Speed = 3.5"); + listBx.Items.Add("Run Speed = 4.0"); + listBx.Items.Add("Run Speed = 4.5"); + listBx.Items.Add("Run Speed = 5.0"); + + menuMainLvl = 2; + menuLvl = 10; + + LastMenuMainLvl = 1; + LastMenuLvl = 2; + LastMenuItm = 10; + break; + + case 11: + listBx.Items.Add("Wanted Level = 0"); + listBx.Items.Add("Wanted Level = 1"); + listBx.Items.Add("Wanted Level = 2"); + listBx.Items.Add("Wanted Level = 3"); + listBx.Items.Add("Wanted Level = 4"); + listBx.Items.Add("Wanted Level = 5"); + + menuMainLvl = 2; + menuLvl = 11; + + LastMenuMainLvl = 1; + LastMenuLvl = 2; + LastMenuItm = 11; + break; + } + break; + + case 5: + switch (menulevel) + { + case 2: + listBx.Items.Add("Nightclub"); + listBx.Items.Add("Arcade"); + listBx.Items.Add("Office"); + listBx.Items.Add("Bunker"); + listBx.Items.Add("Facility"); + listBx.Items.Add("Hangar"); + listBx.Items.Add("Yacht"); + listBx.Items.Add("Kosatka"); + listBx.Items.Add("Sell Vehicles & Cargo"); + listBx.Items.Add("MC Clubhouse"); + listBx.Items.Add("Meth Lab"); + listBx.Items.Add("Cocaine Lockup"); + listBx.Items.Add("Weed Farm"); + listBx.Items.Add("Counterfeit Cash"); + listBx.Items.Add("Document Forgery"); + listBx.Items.Add("Casino"); + listBx.Items.Add("LS Car Meet"); + + menuMainLvl = 5; + menuLvl = 1; + + LastMenuMainLvl = 1; + LastMenuLvl = 5; + LastMenuItm = 2; + break; + } + break; + + case 6: + switch (menulevel) + { + case 0: + listBx.Items.Add("RP x 1.0"); + listBx.Items.Add("RP x 2.0"); + listBx.Items.Add("RP x 3.0"); + listBx.Items.Add("RP x 5.0"); + listBx.Items.Add("RP x 10.0"); + listBx.Items.Add("RP x 15.0"); + listBx.Items.Add("RP x 20.0"); + listBx.Items.Add("RP x 25.0"); + listBx.Items.Add("RP x 30.0"); + listBx.Items.Add("RP x 35.0"); + listBx.Items.Add("RP x 40.0"); + listBx.Items.Add("RP x 50.0"); + listBx.Items.Add("RP x 100.0"); + + menuMainLvl = 6; + menuLvl = 0; + + LastMenuMainLvl = 1; + LastMenuLvl = 6; + LastMenuItm = 0; + break; + + case 1: + listBx.Items.Add("REP x 1.0"); + listBx.Items.Add("REP x 2.0"); + listBx.Items.Add("REP x 3.0"); + listBx.Items.Add("REP x 5.0"); + listBx.Items.Add("REP x 10.0"); + listBx.Items.Add("REP x 15.0"); + listBx.Items.Add("REP x 20.0"); + listBx.Items.Add("REP x 25.0"); + listBx.Items.Add("REP x 30.0"); + listBx.Items.Add("REP x 35.0"); + listBx.Items.Add("REP x 40.0"); + listBx.Items.Add("REP x 50.0"); + listBx.Items.Add("REP x 100.0"); + listBx.Items.Add("REP x 200.0"); + listBx.Items.Add("REP x 300.0"); + listBx.Items.Add("REP x 500.0"); + listBx.Items.Add("REP x 1000.0"); + + menuMainLvl = 6; + menuLvl = 1; + + LastMenuMainLvl = 1; + LastMenuLvl = 6; + LastMenuItm = 1; + break; + } + break; + + case 7: + switch (menulevel) + { + case 0: + listBx.Items.Add("Clothes (0)"); + listBx.Items.Add("RP (1)"); + listBx.Items.Add("Cash (1)"); + listBx.Items.Add("Chips (1)"); + listBx.Items.Add("Discount"); + listBx.Items.Add("RP (2)"); + listBx.Items.Add("Cash (2)"); + listBx.Items.Add("Chips (2)"); + listBx.Items.Add("Clothes (2)"); + listBx.Items.Add("RP (3)"); + listBx.Items.Add("Chips (3)"); + listBx.Items.Add("Mystery Price"); + listBx.Items.Add("Clothes (3)"); + listBx.Items.Add("RP (4)"); + listBx.Items.Add("Chips (4)"); + listBx.Items.Add("Clothes (4)"); + listBx.Items.Add("RP (5)"); + listBx.Items.Add("Podium Vehicle"); + + menuMainLvl = 7; + menuLvl = 0; + + LastMenuMainLvl = 1; + LastMenuLvl = 7; + LastMenuItm = 0; + break; + } + break; + } + listBx.SelectedIndex = 0; + mainForm.TopMost = true; + } + + public static void runitem(int mainMenulevel, int menulevel, int menuItem) + { + Console.WriteLine("Command to run: " + mainMenulevel + " " + menulevel + " " + menuItem); + switch (mainMenulevel) + { + case 0: + switch (menulevel) + { + case 0: + switch (menuItem) + { + case 0: + listboxFill(1, 0); + break; + case 1: + listboxFill(1, 1); + break; + case 2: + listboxFill(1, 2); + break; + case 3: + listboxFill(1, 3); + break; + case 4: + listboxFill(1, 4); + break; + case 5: + listboxFill(1, 5); + break; + case 6: + listboxFill(1, 6); + break; + case 7: + listboxFill(1, 7); + break; + } + break; + } + break; + + case 1: + switch (menulevel) + { + case 0: + switch (menuItem) + { + case 0: + // Re-Init + Console.WriteLine("Nothing to do"); + break; + case 1: + Quit(); + break; + } + break; + case 1: + switch (menuItem) + { + case 0: + Activate(); + LoadSession(0); + break; + case 1: + Activate(); + LoadSession(1); + break; + case 2: + Activate(); + LoadSession(10); + break; + case 3: + Activate(); + LoadSession(-1); + break; + case 4: + Activate(); + _freezeGame = new Thread(freezeGame) { IsBackground = true }; + _freezeGame.Start(); + break; + case 5: + Activate(); + LoadSession(11); + break; + case 6: + Activate(); + LoadSession(9); + break; + case 7: + Activate(); + LoadSession(6); + break; + case 8: + Activate(); + LoadSession(3); + break; + case 9: + Activate(); + LoadSession(12); + break; + case 10: + Activate(); + LoadSession(2); + break; + /* + case 11: + Activate(); + LoadSession(-2); + break; + */ + } + break; + case 2: + switch (menuItem) + { + case 0: + bGodMode = !bGodMode; + break; + case 1: + bSuperJump = !bSuperJump; + break; + case 2: + bNeverWanted = !bNeverWanted; + break; + case 3: + bSeatBelt = !bSeatBelt; + break; + case 4: + bNoRagdoll = !bNoRagdoll; + break; + case 5: + bUndeadOffRadar = !bUndeadOffRadar; + break; + case 6: + bDisableCollision = !bDisableCollision; + break; + case 7: + listboxFill(2, 7); + break; + case 8: + listboxFill(2, 8); + break; + case 9: + listboxFill(2, 9); + break; + case 10: + listboxFill(2, 10); + break; + case 11: + listboxFill(2, 11); + break; + } + break; + case 3: + switch (menuItem) + { + case 0: + bVehicleGodMode = !bVehicleGodMode; + break; + } + break; + case 4: + switch (menuItem) + { + case 0: + bExplosiveAmmo = !bExplosiveAmmo; + break; + case 1: + Activate(); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPedWeaponManager, offsets.pCWeaponInfo, offsets.oRange }, 250F); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPedWeaponManager, offsets.pCWeaponInfo, offsets.oLockRange }, 250F); + break; + } + break; + case 5: + switch (menuItem) + { + case 0: + if (bGodMode) + { + bgodState = true; + } + else + { + bGodMode = true; + bgodState = false; + } + Activate(); + teleportWaypoint(); + if (!bgodState) + { + bGodMode = false; + } + break; + case 1: + Activate(); + + if (bGodMode) + { + bgodState = true; + } + else + { + bGodMode = true; + bgodState = false; + } + int[] tpIdArray = new int[] { 1 }; + int[] tpColArray = new int[] { 5, 60, 66 }; + teleportBlip(tpIdArray, tpColArray); + if (!bgodState) + { + bGodMode = false; + } + break; + case 2: + listboxFill(5, 2); + break; + } + break; + case 6: + switch (menuItem) + { + case 0: + listboxFill(6, 0); + break; + case 1: + listboxFill(6, 1); + break; + case 2: + Activate(); + setStat("MP0_CLUB_POPULARITY", 1000); + setStat("MP1_CLUB_POPULARITY", 1000); + break; + } + break; + case 7: + switch (menuItem) + { + case 0: + listboxFill(7, 0); + break; + } + break; + + } + break; + case 2: + switch (menulevel) + { + case 7: + switch (menuItem) + { + case 0: + Activate(); + setStat("MP0_SCRIPT_INCREASE_STAM", 100); + setStat("MP1_SCRIPT_INCREASE_STAM", 100); + break; + case 1: + Activate(); + setStat("MP0_SCRIPT_INCREASE_STRN", 100); + setStat("MP1_SCRIPT_INCREASE_STRN", 100); + break; + case 2: + Activate(); + setStat("MP0_SCRIPT_INCREASE_LUNG", 100); + setStat("MP1_SCRIPT_INCREASE_LUNG", 100); + break; + case 3: + Activate(); + setStat("MP0_SCRIPT_INCREASE_DRIV", 100); + setStat("MP1_SCRIPT_INCREASE_DRIV", 100); + break; + case 4: + Activate(); + setStat("MP0_SCRIPT_INCREASE_FLY", 100); + setStat("MP1_SCRIPT_INCREASE_FLY", 100); + break; + case 5: + Activate(); + setStat("MP0_SCRIPT_INCREASE_SHO", 100); + setStat("MP1_SCRIPT_INCREASE_SHO", 100); + break; + case 6: + Activate(); + setStat("MP0_SCRIPT_INCREASE_STL", 100); + setStat("MP1_SCRIPT_INCREASE_STL", 100); + break; + } + break; + + case 8: + switch (menuItem) + { + case 0: + Activate(); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPlayerInfo, offsets.oSwimSpeed }, 0.0f); + break; + case 1: + Activate(); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPlayerInfo, offsets.oSwimSpeed }, 0.5f); + break; + case 2: + Activate(); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPlayerInfo, offsets.oSwimSpeed }, 1.0f); + break; + case 3: + Activate(); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPlayerInfo, offsets.oSwimSpeed }, 1.5f); + break; + case 4: + Activate(); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPlayerInfo, offsets.oSwimSpeed }, 2.0f); + break; + case 5: + Activate(); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPlayerInfo, offsets.oSwimSpeed }, 2.5f); + break; + case 6: + Activate(); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPlayerInfo, offsets.oSwimSpeed }, 3.0f); + break; + case 7: + Activate(); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPlayerInfo, offsets.oSwimSpeed }, 3.5f); + break; + case 8: + Activate(); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPlayerInfo, offsets.oSwimSpeed }, 4.0f); + break; + case 9: + Activate(); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPlayerInfo, offsets.oSwimSpeed }, 4.5f); + break; + case 10: + Activate(); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPlayerInfo, offsets.oSwimSpeed }, 5.0f); + break; + } + break; + + case 9: + switch (menuItem) + { + case 0: + Activate(); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPlayerInfo, offsets.oWalkSpeed }, 0.0f); + break; + case 1: + Activate(); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPlayerInfo, offsets.oWalkSpeed }, 0.5f); + break; + case 2: + Activate(); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPlayerInfo, offsets.oWalkSpeed }, 1.0f); + break; + case 3: + Activate(); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPlayerInfo, offsets.oWalkSpeed }, 1.5f); + break; + case 4: + Activate(); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPlayerInfo, offsets.oWalkSpeed }, 2.0f); + break; + case 5: + Activate(); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPlayerInfo, offsets.oWalkSpeed }, 2.5f); + break; + case 6: + Activate(); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPlayerInfo, offsets.oWalkSpeed }, 3.0f); + break; + case 7: + Activate(); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPlayerInfo, offsets.oWalkSpeed }, 3.5f); + break; + case 8: + Activate(); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPlayerInfo, offsets.oWalkSpeed }, 4.0f); + break; + case 9: + Activate(); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPlayerInfo, offsets.oWalkSpeed }, 4.5f); + break; + case 10: + Activate(); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPlayerInfo, offsets.oWalkSpeed }, 5.0f); + break; + } + break; + + case 10: + switch (menuItem) + { + case 0: + Activate(); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPlayerInfo, offsets.oRunSpeed }, 0.0f); + break; + case 1: + Activate(); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPlayerInfo, offsets.oRunSpeed }, 0.5f); + break; + case 2: + Activate(); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPlayerInfo, offsets.oRunSpeed }, 1.0f); + break; + case 3: + Activate(); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPlayerInfo, offsets.oRunSpeed }, 1.5f); + break; + case 4: + Activate(); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPlayerInfo, offsets.oRunSpeed }, 2.0f); + break; + case 5: + Activate(); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPlayerInfo, offsets.oRunSpeed }, 2.5f); + break; + case 6: + Activate(); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPlayerInfo, offsets.oRunSpeed }, 3.0f); + break; + case 7: + Activate(); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPlayerInfo, offsets.oRunSpeed }, 3.5f); + break; + case 8: + Activate(); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPlayerInfo, offsets.oRunSpeed }, 4.0f); + break; + case 9: + Activate(); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPlayerInfo, offsets.oRunSpeed }, 4.5f); + break; + case 10: + Activate(); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPlayerInfo, offsets.oRunSpeed }, 5.0f); + break; + } + break; + + case 11: + switch (menuItem) + { + case 0: + Activate(); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPlayerInfo, offsets.oWanted }, 0); + break; + case 1: + Activate(); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPlayerInfo, offsets.oWanted }, 1); + break; + case 2: + Activate(); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPlayerInfo, offsets.oWanted }, 2); + break; + case 3: + Activate(); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPlayerInfo, offsets.oWanted }, 3); + break; + case 4: + Activate(); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPlayerInfo, offsets.oWanted }, 4); + break; + case 5: + Activate(); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPlayerInfo, offsets.oWanted }, 5); + break; + } + break; + } + break; + + case 4: + switch (menulevel) + { + case 0: + switch (menuItem) + { + case 0: + Activate(); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPedWeaponManager, offsets.pCWeaponInfo, offsets.oImpactType }, 2); + break; + case 1: + Activate(); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPedWeaponManager, offsets.pCWeaponInfo, offsets.oImpactType }, 3); + break; + case 2: + Activate(); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPedWeaponManager, offsets.pCWeaponInfo, offsets.oImpactType }, 5); + break; + } + break; + + case 1: + switch (menuItem) + { + case 0: + Activate(); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPedWeaponManager, offsets.pCWeaponInfo, offsets.oImpactExplosion }, -1); + break; + case 1: + Activate(); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPedWeaponManager, offsets.pCWeaponInfo, offsets.oImpactExplosion }, 0); + break; + case 2: + Activate(); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCPedWeaponManager, offsets.pCWeaponInfo, offsets.oImpactExplosion }, 59); + break; + } + break; + } + break; + + case 5: + switch (menulevel) + { + case 1: + switch (menuItem) + { + case 0: + Activate(); + + if (bGodMode) + { + bgodState = true; + } + else + { + bGodMode = true; + bgodState = false; + } + int[] tpIdArray = new int[] { 614 }; + int[] tpColArray = new int[] { }; + teleportBlip(tpIdArray, tpColArray); + if (!bgodState) + { + bGodMode = false; + } + break; + case 1: + Activate(); + + if (bGodMode) + { + bgodState = true; + } + else + { + bGodMode = true; + bgodState = false; + } + tpIdArray = new int[] { 740 }; + tpColArray = new int[] { }; + teleportBlip(tpIdArray, tpColArray); + if (!bgodState) + { + bGodMode = false; + } + break; + case 2: + Activate(); + + if (bGodMode) + { + bgodState = true; + } + else + { + bGodMode = true; + bgodState = false; + } + tpIdArray = new int[] { 475 }; + tpColArray = new int[] { }; + teleportBlip(tpIdArray, tpColArray); + if (!bgodState) + { + bGodMode = false; + } + break; + case 3: + Activate(); + + if (bGodMode) + { + bgodState = true; + } + else + { + bGodMode = true; + bgodState = false; + } + tpIdArray = new int[] { 557 }; + tpColArray = new int[] { }; + teleportBlip(tpIdArray, tpColArray); + if (!bgodState) + { + bGodMode = false; + } + break; + case 4: + Activate(); + + if (bGodMode) + { + bgodState = true; + } + else + { + bGodMode = true; + bgodState = false; + } + tpIdArray = new int[] { 590 }; + tpColArray = new int[] { }; + teleportBlip(tpIdArray, tpColArray); + if (!bgodState) + { + bGodMode = false; + } + break; + case 5: + Activate(); + + if (bGodMode) + { + bgodState = true; + } + else + { + bGodMode = true; + bgodState = false; + } + tpIdArray = new int[] { 569 }; + tpColArray = new int[] { }; + teleportBlip(tpIdArray, tpColArray); + if (!bgodState) + { + bGodMode = false; + } + break; + case 6: + Activate(); + + if (bGodMode) + { + bgodState = true; + } + else + { + bGodMode = true; + bgodState = false; + } + tpIdArray = new int[] { 455 }; + tpColArray = new int[] { }; + teleportBlip(tpIdArray, tpColArray); + if (!bgodState) + { + bGodMode = false; + } + break; + case 7: + Activate(); + + if (bGodMode) + { + bgodState = true; + } + else + { + bGodMode = true; + bgodState = false; + } + tpIdArray = new int[] { 760 }; + tpColArray = new int[] { }; + teleportBlip(tpIdArray, tpColArray); + if (!bgodState) + { + bGodMode = false; + } + break; + case 8: + Activate(); + + if (bGodMode) + { + bgodState = true; + } + else + { + bGodMode = true; + bgodState = false; + } + tpIdArray = new int[] { 64, 427, 478, 423, 501, 556 }; + tpColArray = new int[] { 2, 3 }; + teleportBlip(tpIdArray, tpColArray, 2); + + /* + Location loc = new Location { x = 721.968f, y = -821.941f, z = 25.153f }; + Teleport(loc); + */ + if (!bgodState) + { + bGodMode = false; + } + break; + case 9: + Activate(); + + if (bGodMode) + { + bgodState = true; + } + else + { + bGodMode = true; + bgodState = false; + } + tpIdArray = new int[] { 492 }; + tpColArray = new int[] { }; + teleportBlip(tpIdArray, tpColArray); + if (!bgodState) + { + bGodMode = false; + } + break; + case 10: + Activate(); + + if (bGodMode) + { + bgodState = true; + } + else + { + bGodMode = true; + bgodState = false; + } + tpIdArray = new int[] { 499 }; + tpColArray = new int[] { }; + teleportBlip(tpIdArray, tpColArray); + if (!bgodState) + { + bGodMode = false; + } + break; + case 11: + Activate(); + + if (bGodMode) + { + bgodState = true; + } + else + { + bGodMode = true; + bgodState = false; + } + tpIdArray = new int[] { 497 }; + tpColArray = new int[] { }; + teleportBlip(tpIdArray, tpColArray); + if (!bgodState) + { + bGodMode = false; + } + break; + case 12: + Activate(); + + if (bGodMode) + { + bgodState = true; + } + else + { + bGodMode = true; + bgodState = false; + } + tpIdArray = new int[] { 496 }; + tpColArray = new int[] { }; + teleportBlip(tpIdArray, tpColArray); + if (!bgodState) + { + bGodMode = false; + } + break; + case 13: + Activate(); + + if (bGodMode) + { + bgodState = true; + } + else + { + bGodMode = true; + bgodState = false; + } + tpIdArray = new int[] { 500 }; + tpColArray = new int[] { }; + teleportBlip(tpIdArray, tpColArray); + if (!bgodState) + { + bGodMode = false; + } + break; + case 14: + Activate(); + + if (bGodMode) + { + bgodState = true; + } + else + { + bGodMode = true; + bgodState = false; + } + tpIdArray = new int[] { 498 }; + tpColArray = new int[] { }; + teleportBlip(tpIdArray, tpColArray); + if (!bgodState) + { + bGodMode = false; + } + break; + case 15: + Activate(); + + if (bGodMode) + { + bgodState = true; + } + else + { + bGodMode = true; + bgodState = false; + } + Location loc = new Location { x = 918.2499f, y = 50.25024f, z = 80.89696f }; + Teleport(loc); + if (!bgodState) + { + bGodMode = false; + } + break; + case 16: + Activate(); + + if (bGodMode) + { + bgodState = true; + } + else + { + bGodMode = true; + bgodState = false; + } + loc = new Location { x = 777f, y = -1876f, z = 29.29654f }; + Teleport(loc); + if (!bgodState) + { + bGodMode = false; + } + break; + } + break; + } + break; + + case 6: + switch (menulevel) + { + case 0: + switch (menuItem) + { + case 0: + Activate(); + setRPMultipler(1.0f); + break; + case 1: + Activate(); + setRPMultipler(2.0f); + break; + case 2: + Activate(); + setRPMultipler(3.0f); + break; + case 3: + Activate(); + setRPMultipler(5.0f); + break; + case 4: + Activate(); + setRPMultipler(10.0f); + break; + case 5: + Activate(); + setRPMultipler(15.0f); + break; + case 6: + Activate(); + setRPMultipler(20.0f); + break; + case 7: + Activate(); + setRPMultipler(25.0f); + break; + case 8: + Activate(); + setRPMultipler(30.0f); + break; + case 9: + Activate(); + setRPMultipler(35.0f); + break; + case 10: + Activate(); + setRPMultipler(40.0f); + break; + case 11: + Activate(); + setRPMultipler(50.0f); + break; + case 12: + Activate(); + setRPMultipler(100.0f); + break; + } + break; + + case 1: + switch (menuItem) + { + case 0: + Activate(); + setREPMultipler(1.0f); + break; + case 1: + Activate(); + setREPMultipler(2.0f); + break; + case 2: + Activate(); + setREPMultipler(3.0f); + break; + case 3: + Activate(); + setREPMultipler(5.0f); + break; + case 4: + Activate(); + setREPMultipler(10.0f); + break; + case 5: + Activate(); + setREPMultipler(15.0f); + break; + case 6: + Activate(); + setREPMultipler(20.0f); + break; + case 7: + Activate(); + setREPMultipler(25.0f); + break; + case 8: + Activate(); + setREPMultipler(30.0f); + break; + case 9: + Activate(); + setREPMultipler(35.0f); + break; + case 10: + Activate(); + setREPMultipler(40.0f); + break; + case 11: + Activate(); + setREPMultipler(50.0f); + break; + case 12: + Activate(); + setREPMultipler(100.0f); + break; + case 13: + Activate(); + setREPMultipler(200.0f); + break; + case 14: + Activate(); + setREPMultipler(300.0f); + break; + case 15: + Activate(); + setREPMultipler(500.0f); + break; + case 16: + Activate(); + setREPMultipler(1000.0f); + break; + } + break; + } + break; + + case 7: + switch (menulevel) + { + case 0: + switch (menuItem) + { + case 0: + Activate(); + getLuckyWheelPrice(1); + break; + case 1: + Activate(); + getLuckyWheelPrice(2); + break; + case 2: + Activate(); + getLuckyWheelPrice(3); + break; + case 3: + Activate(); + getLuckyWheelPrice(4); + break; + case 4: + Activate(); + getLuckyWheelPrice(5); + break; + case 5: + Activate(); + getLuckyWheelPrice(6); + break; + case 6: + Activate(); + getLuckyWheelPrice(7); + break; + case 7: + Activate(); + getLuckyWheelPrice(8); + break; + case 8: + Activate(); + getLuckyWheelPrice(9); + break; + case 9: + Activate(); + getLuckyWheelPrice(10); + break; + case 10: + Activate(); + getLuckyWheelPrice(11); + break; + case 11: + Activate(); + getLuckyWheelPrice(12); + break; + case 12: + Activate(); + getLuckyWheelPrice(13); + break; + case 13: + Activate(); + getLuckyWheelPrice(14); + break; + case 14: + Activate(); + getLuckyWheelPrice(15); + break; + case 15: + Activate(); + getLuckyWheelPrice(16); + break; + case 16: + Activate(); + getLuckyWheelPrice(17); + break; + case 17: + Activate(); + getLuckyWheelPrice(18); + break; + } + break; + } + break; + } + + } + + public static void runSingleItem() + { + Console.WriteLine("Command to run backward: " + LastMenuMainLvl + " " + LastMenuLvl + " " + LastMenuItm); + int oldMenuItm = LastMenuItm; + listboxFill(LastMenuMainLvl, LastMenuLvl); + listBx.SelectedIndex = oldMenuItm; + } + + private static void mainlistup() + { + if (listBx.SelectedIndex > 0) + { + listBx.SelectedIndex = listBx.SelectedIndex - 1; + menuItm = listBx.SelectedIndex; + } + } + + private static void mainlistdown() + { + if (listBx.SelectedIndex < listBx.Items.Count - 1) + { + listBx.SelectedIndex = listBx.SelectedIndex + 1; + menuItm = listBx.SelectedIndex; + } + } + + public static void showHideOverlay() + { + if (!isHidden) + { + isHidden = true; + ShowWindow(formHandle, SW_HIDE); + } + else + { + isHidden = false; + ShowWindow(formHandle, 1); + } + } + + private static IntPtr SetHook(LowLevelKeyboardProc proc) + { + using (Process curProcess = Process.GetCurrentProcess()) + using (ProcessModule curModule = curProcess.MainModule) + { + return SetWindowsHookEx(WH_KEYBOARD_LL, proc, + GetModuleHandle(curModule.ModuleName), 0); + } + } + + private delegate IntPtr LowLevelKeyboardProc( + int nCode, IntPtr wParam, IntPtr lParam); + + private static IntPtr HookCallback( + int nCode, IntPtr wParam, IntPtr lParam) + { + if (nCode >= 0 && wParam == (IntPtr)WM_KEYDOWN) + { + int vkCode = Marshal.ReadInt32(lParam); + if ((Keys)vkCode == Keys.F5) + { + showHideOverlay(); + } + else if ((Keys)vkCode == Keys.NumPad0) + { + if (!isHidden) + { + if (menuMainLvl <= 0) + { + isHidden = true; + ShowWindow(formHandle, SW_HIDE); + } + else + { + runSingleItem(); + } + } + } + else if ((Keys)vkCode == Keys.NumPad5) + { + runitem(menuMainLvl, menuLvl, listBx.SelectedIndex); + } + else if ((Keys)vkCode == Keys.Up || (Keys)vkCode == Keys.Down || (Keys)vkCode == Keys.Left || (Keys)vkCode == Keys.Right) + { + if (!isHidden) + { + return (IntPtr)1; + } + } + else if ((Keys)vkCode == Keys.NumPad2) + { + if (!isHidden) + { + mainlistdown(); + } + } + else if ((Keys)vkCode == Keys.NumPad8) + { + if (!isHidden) + { + mainlistup(); + } + } + else if ((Keys)vkCode == Keys.Delete) + { + if (!isHidden) + { + Quit(); + } + } + } + return CallNextHookEx(_hookID, nCode, wParam, lParam); + } + + public static void LoadSession(int id) + { + if (id == -1) + { + _SG_Int(1574587 + 2, -1); + _SG_Int(1574587, 1); + Thread.Sleep(200); + _SG_Int(1574587, 0); + } + else if (id == -2) + { + _SG_Int(1574587 + 2, 1); + Thread.Sleep(200); + _SG_Int(1574587, 0); + } + else + { + _SG_Int(1575004, id); + _SG_Int(1574587, 1); + Thread.Sleep(200); + _SG_Int(1574587, 0); + } + } + + public static void getLuckyWheelPrice(int id) + { + string script = "casino_lucky_wheel"; + int Index = 274 + 14; + long scriptAddr = GetLocalScript(script); + if (scriptAddr > 0 && id > 0) + { + long scriptAddr2 = scriptAddr + (8 * Index); + Console.WriteLine(scriptAddr2); + int scriptInt = Mem.ReadInt(scriptAddr2, null); + Console.WriteLine(scriptInt); + Mem.writeInt(scriptAddr2, null, id); + } + } + + #region Teleport part + + private static void teleportWaypoint() + { + Teleport(WaypointCoords); + } + public static void setRPMultipler(float m) + { + _SG_Float(262145 + 1, m); + } + + public static void setREPMultipler(float m) + { + _SG_Float(262145 + 31278, m); // Street Race + _SG_Float(262145 + 31279, m); // Pursuit Race + _SG_Float(262145 + 31280, m); // Scramble + _SG_Float(262145 + 31281, m); // Head 2 Head + _SG_Float(262145 + 31283, m); // Car Meet + _SG_Float(262145 + 31284, m); // Test Track + } + + private static void Teleport(Location l) + { + if (Mem.ReadInt(settings.WorldPTR, new int[] { offsets.pCPed, offsets.oInVehicle }) == 0) + { + CarX = l.x; + CarY = l.y; + CarZ = l.z; + } + else + { + PlayerX = l.x; + PlayerY = l.y; + PlayerZ = l.z; + } + } + + private static void teleportBlip(int[] ID, int[] color, int height = 0) + { + Location tmpLoc = getBlipCoords(ID, color); + Location returnLoc = new Location + { + x = tmpLoc.x, + y = tmpLoc.y, + z = tmpLoc.z + height + 3 + }; + Console.WriteLine("New location: " + returnLoc.x + ", " + returnLoc.y + ", " + returnLoc.z); + Teleport(tmpLoc); + } + + private static Location WaypointCoords + { + get + { + float tX = Mem.ReadFloat(settings.WorldPTR, new int[] { offsets.pCPed, offsets.oRotation, offsets.oPositionX }); + float tY = Mem.ReadFloat(settings.WorldPTR, new int[] { offsets.pCPed, offsets.oRotation, offsets.oPositionY }); + float tZ = Mem.ReadFloat(settings.WorldPTR, new int[] { offsets.pCPed, offsets.oRotation, offsets.oPositionZ }); + Console.WriteLine("New location: " + tX + ", " + tY + ", " + tZ); + for (int i = 2000; i > 1; i--) + { + if (Mem.ReadInt(settings.BlipPTR + (i * 8), new int[] { 0x48 }) == 84 && Mem.ReadInt(settings.BlipPTR + (i * 8), new int[] { 0x40 }) == 8) + { + return new Location + { + x = Mem.ReadFloat(settings.BlipPTR + (i * 8), new int[] { 0x10 }), + y = Mem.ReadFloat(settings.BlipPTR + (i * 8), new int[] { 0x14 }), + z = -210F + }; + } + } + return new Location { x = PlayerX, y = PlayerY, z = PlayerZ }; + } + } + + private static Location getBlipCoords(int[] id, int[] color = null) + { + Location tempLocation = new Location { }; + for (int i = 2000; i > 1; i--) + { + long blip = settings.BlipPTR + (i * 8); + int blipId = Mem.ReadInt(blip, new int[] { 0x40 }); + int blipColor = Mem.ReadInt(blip, new int[] { 0x48 }); + if (id.Contains(blipId)) + { + tempLocation = new Location + { + x = Mem.ReadFloat(blip, new int[] { 0x10 }), + y = Mem.ReadFloat(blip, new int[] { 0x14 }), + z = Mem.ReadFloat(blip, new int[] { 0x18 }) + }; + + if(color.Contains(blipColor)) + { + tempLocation = new Location + { + x = Mem.ReadFloat(blip, new int[] { 0x10 }), + y = Mem.ReadFloat(blip, new int[] { 0x14 }), + z = Mem.ReadFloat(blip, new int[] { 0x18 }) + }; + } + } + } + return new Location { x = tempLocation.x, y = tempLocation.y, z = tempLocation.z }; + } + + public static float PlayerX + { + get { return Mem.ReadFloat(settings.WorldPTR, new int[] { offsets.pCPed, offsets.oRotation, offsets.oPositionX }); } + set + { + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.oRotation, offsets.oPositionX }, value); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.oVisualX }, value); + } + } + public static float PlayerY + { + get { return Mem.ReadFloat(settings.WorldPTR, new int[] { offsets.pCPed, offsets.oRotation, offsets.oPositionX }); } + set + { + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.oRotation, offsets.oPositionY }, value); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.oVisualY }, value); + } + } + public static float PlayerZ + { + get { return Mem.ReadFloat(settings.WorldPTR, new int[] { offsets.pCPed, offsets.oRotation, offsets.oPositionX }); } + set + { + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.oRotation, offsets.oPositionZ }, value); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.oVisualZ }, value); + } + } + + public static float CarX + { + get { return Mem.ReadFloat(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCVehicle, offsets.pCNavigation, offsets.oPositionX }); } + set + { + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCVehicle, offsets.pCNavigation, offsets.oPositionX }, value); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCVehicle, offsets.pCNavigation, offsets.oVPositionX }, value); + } + } + public static float CarY + { + get { return Mem.ReadFloat(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCVehicle, offsets.pCNavigation, offsets.oPositionY }); } + set + { + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCVehicle, offsets.pCNavigation, offsets.oPositionY }, value); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCVehicle, offsets.pCNavigation, offsets.oVPositionY }, value); + } + } + public static float CarZ + { + get { return Mem.ReadFloat(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCVehicle, offsets.pCNavigation, offsets.oPositionZ }); } + set + { + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCVehicle, offsets.pCNavigation, offsets.oPositionZ }, value); + Mem.Write(settings.WorldPTR, new int[] { offsets.pCPed, offsets.pCVehicle, offsets.pCNavigation, offsets.oVPositionZ }, value); + } + } + #endregion + + #region Global Addresses function + public static long GA(long Index) + { + long p = settings.GlobalPTR + (8 * (Index >> 0x12 & 0x3F)); + long p_ga = Mem.ReadPointer(p, null); + long p_ga_final = p_ga + (8 * (Index & 0x3FFFF)); + return p_ga_final; + } + public static long _GG_Int(int Index) + { + return Mem.ReadInt(GA(Index), null); + } + public static float _GG_Float(int Index) + { + return Mem.ReadFloat(GA(Index), null); + } + public static string _GG_String(int Index, int size) + { + return Mem.ReadString(GA(Index), null, size); + } + public static void _SG_Int(int Index, int value) + { + Mem.writeInt(GA(Index), null, value); + } + public static void _SG_Float(int Index, float value) + { + Mem.writeFloat(GA(Index), null, value); + } + public static void _SG_String(int Index, string value) + { + Mem.Write(GA(Index), null, value); + } + + public static void setStat(string stat, int value) + { + long oldhash = _GG_Int(1655444 + 4); + long oldvalue = _GG_Int(1020252 + 5526); + _SG_Int(1655444 + 4, (int)JOAAT.GetHashKey(stat)); + _SG_Int(1020252 + 5526, value); + _SG_Int(1644209 + 1139, -1); + Thread.Sleep(1000); + _SG_Int(1655444 + 4, (int)oldhash); + _SG_Int(1020252 + 5526, (int)oldvalue); + } + public static long GetLocalScript(string name) + { + int size = name.Length; + for (int i = 0; i <= 52; i++) + { + long lc_p = Mem.ReadPointer(settings.LocalScriptsPTR, new int[] { (i * 8), 0xB0 }); + string lc_n = Mem.ReadString(settings.LocalScriptsPTR, new int[] { (i * 8), 0xD0 }, size); + if (lc_n == name) + { + i = 53; + Console.WriteLine(lc_p); + return (lc_p); + } + } + return 0; + } + #endregion + + } + struct Location { public float x, y, z; } +} diff --git a/Properties/AssemblyInfo.cs b/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..3881573 --- /dev/null +++ b/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("GTAV C# MM")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("GTAV C# MM")] +[assembly: AssemblyCopyright("Copyright © 2021")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("b728a908-c9ea-4cfa-8c2f-b209847607a8")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/Properties/Resources.Designer.cs b/Properties/Resources.Designer.cs new file mode 100644 index 0000000..290086f --- /dev/null +++ b/Properties/Resources.Designer.cs @@ -0,0 +1,63 @@ +//------------------------------------------------------------------------------ +// +// Dieser Code wurde von einem Tool generiert. +// Laufzeitversion:4.0.30319.42000 +// +// Änderungen an dieser Datei können falsches Verhalten verursachen und gehen verloren, wenn +// der Code erneut generiert wird. +// +//------------------------------------------------------------------------------ + +namespace GTAVCSMM.Properties { + using System; + + + /// + /// Eine stark typisierte Ressourcenklasse zum Suchen von lokalisierten Zeichenfolgen usw. + /// + // Diese Klasse wurde von der StronglyTypedResourceBuilder automatisch generiert + // -Klasse über ein Tool wie ResGen oder Visual Studio automatisch generiert. + // Um einen Member hinzuzufügen oder zu entfernen, bearbeiten Sie die .ResX-Datei und führen dann ResGen + // mit der /str-Option erneut aus, oder Sie erstellen Ihr VS-Projekt neu. + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + internal class Resources { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal Resources() { + } + + /// + /// Gibt die zwischengespeicherte ResourceManager-Instanz zurück, die von dieser Klasse verwendet wird. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Resources.ResourceManager ResourceManager { + get { + if (object.ReferenceEquals(resourceMan, null)) { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("GTAVCSMM.Properties.Resources", typeof(Resources).Assembly); + resourceMan = temp; + } + return resourceMan; + } + } + + /// + /// Überschreibt die CurrentUICulture-Eigenschaft des aktuellen Threads für alle + /// Ressourcenzuordnungen, die diese stark typisierte Ressourcenklasse verwenden. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Globalization.CultureInfo Culture { + get { + return resourceCulture; + } + set { + resourceCulture = value; + } + } + } +} diff --git a/Properties/Resources.resx b/Properties/Resources.resx new file mode 100644 index 0000000..1af7de1 --- /dev/null +++ b/Properties/Resources.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/Properties/Settings.Designer.cs b/Properties/Settings.Designer.cs new file mode 100644 index 0000000..52a9672 --- /dev/null +++ b/Properties/Settings.Designer.cs @@ -0,0 +1,26 @@ +//------------------------------------------------------------------------------ +// +// Dieser Code wurde von einem Tool generiert. +// Laufzeitversion:4.0.30319.42000 +// +// Änderungen an dieser Datei können falsches Verhalten verursachen und gehen verloren, wenn +// der Code erneut generiert wird. +// +//------------------------------------------------------------------------------ + +namespace GTAVCSMM.Properties { + + + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "14.0.0.0")] + internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase { + + private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings()))); + + public static Settings Default { + get { + return defaultInstance; + } + } + } +} diff --git a/Properties/Settings.settings b/Properties/Settings.settings new file mode 100644 index 0000000..3964565 --- /dev/null +++ b/Properties/Settings.settings @@ -0,0 +1,7 @@ + + + + + + + diff --git a/README.md b/README.md new file mode 100644 index 0000000..b249b19 --- /dev/null +++ b/README.md @@ -0,0 +1,18 @@ +# GTAVCSMM +GTA5 CSharp Mod Menu + +Based on an idea by Nknights23 https://www.unknowncheats.me/forum/grand-theft-auto-v/463157-gta-simple-external-overlay.html + +With code from Complexicon https://github.com/Complexicon/BunkerMoney / https://www.unknowncheats.me/forum/grand-theft-auto-v/305760-bunkermoney-v3-0-a.html + +No external DLLs needed. + +New overlay menu. Navigate with Numpad: 8 Up, 2 Down, 5 Enter, 0 Back. Show/Hide: F5, quit: Del + +Casino Lucky Wheel: set the price before pressing the spin button. + ++++ Online 1.58 +++ + +Donations: https://www.buymeacoffee.com/linewalker85 + +... Code cleanup later ... diff --git a/Settings/Addresses.cs b/Settings/Addresses.cs new file mode 100644 index 0000000..2d61d87 --- /dev/null +++ b/Settings/Addresses.cs @@ -0,0 +1,85 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace GTAVCSMM.Settings +{ + class Addresses + { + private string _f_godm = "0x0"; + private string _f_nwanted = "0x0"; + private string _f_nragdoll = "0x0"; + private string _f_uoffradar = "0x0"; + private string _f_sbelt = "0x0"; + private string _f_sjump = "0x0"; + + public string f_godm + { + get + { + return _f_godm; + } + set + { + _f_godm = value; + } + } + public string f_nwanted + { + get + { + return _f_nwanted; + } + set + { + _f_nwanted = value; + } + } + public string f_nragdoll + { + get + { + return _f_nragdoll; + } + set + { + _f_nragdoll = value; + } + } + public string f_uoffradar + { + get + { + return _f_uoffradar; + } + set + { + _f_uoffradar = value; + } + } + public string f_sbelt + { + get + { + return _f_sbelt; + } + set + { + _f_sbelt = value; + } + } + public string f_sjump + { + get + { + return _f_sjump; + } + set + { + _f_sjump = value; + } + } + } +} diff --git a/Settings/TSettings.cs b/Settings/TSettings.cs new file mode 100644 index 0000000..499dd5f --- /dev/null +++ b/Settings/TSettings.cs @@ -0,0 +1,660 @@ +namespace GTAVCSMM.Settings +{ + class TSettings + { + #region Globals + private string _gameName = "GTA5"; + private int _gameProcess = 0; + private long _globalptr; + private long _worldptr; + private long _blipptr; + private long _replayinterfaceptr; + private long _localscriptsptr; + private long _playercountptr; + private long _pickupdataptr; + private long _weatheraddr; + private long _settingsptr; + private long _aimcpedptr; + private long _friendlistptr; + + public string gameName + { + get + { + return _gameName; + } + } + + public int gameProcess + { + get + { + return _gameProcess; + } + set + { + _gameProcess = value; + } + } + + public long GlobalPTR + { + get + { + return _globalptr; + } + set + { + _globalptr = value; + } + } + + public long WorldPTR + { + get + { + return _worldptr; + } + set + { + _worldptr = value; + } + } + + public long BlipPTR + { + get + { + return _blipptr; + } + set + { + _blipptr = value; + } + } + + public long ReplayInterfacePTR + { + get + { + return _replayinterfaceptr; + } + set + { + _replayinterfaceptr = value; + } + } + + public long LocalScriptsPTR + { + get + { + return _localscriptsptr; + } + set + { + _localscriptsptr = value; + } + } + + public long PlayerCountPTR + { + get + { + return _playercountptr; + } + set + { + _playercountptr = value; + } + } + + public long PickupDataPTR + { + get + { + return _pickupdataptr; + } + set + { + _pickupdataptr = value; + } + } + + public long WeatherADDR + { + get + { + return _weatheraddr; + } + set + { + _weatheraddr = value; + } + } + + public long SettingsPTR + { + get + { + return _settingsptr; + } + set + { + _settingsptr = value; + } + } + + public long AimCPedPTR + { + get + { + return _aimcpedptr; + } + set + { + _aimcpedptr = value; + } + } + + public long FriendlistPTR + { + get + { + return _friendlistptr; + } + set + { + _friendlistptr = value; + } + } + #endregion + + #region Trainer settings + private int _aConnect = 0; + private int _aFKtoggle = 0; + private int _aGodMode = 0; + private int _aLogPlayers = 0; + private int _aDarkMode = 0; + private int _player_tracking = 0; + //tbl_origPlayersList = {} + private int _pictureGrabOFF = 0; + //player_watch = {} + //tbl_Players = {} + //tbl_PlayersAll = {} + //tbl_Tracking = {} + private int _markMyRid = -1; + private int _myCPed = -1; + + private bool _GlobalPTRFound = false; + private bool _WorldPTRFound = false; + private bool _BlipPTRFound = false; + private bool _ReplayInterfacePTRFound = false; + private bool _LocalScriptsPTRFound = false; + private bool _PlayerCountPTRFound = false; + private bool _PickupDataPTRFound = false; + private bool _WeatherADDRFound = false; + private bool _SettingsPTRFound = false; + private bool _AimCPedPTRFound = false; + private bool _FriendlistPTRFound = false; + + public int aConnect + { + get + { + return _aConnect; + } + set + { + _aConnect = value; + } + } + + public int aFKtoggle + { + get + { + return _aFKtoggle; + } + set + { + _aFKtoggle = value; + } + } + + public int aGodMode + { + get + { + return _aGodMode; + } + set + { + _aGodMode = value; + } + } + + public int aLogPlayers + { + get + { + return _aLogPlayers; + } + set + { + _aLogPlayers = value; + } + } + + public int aDarkMode + { + get + { + return _aDarkMode; + } + set + { + _aDarkMode = value; + } + } + + public int player_tracking + { + get + { + return _player_tracking; + } + set + { + _player_tracking = value; + } + } + + public int pictureGrabOFF + { + get + { + return _pictureGrabOFF; + } + set + { + _pictureGrabOFF = value; + } + } + + public int markMyRid + { + get + { + return _markMyRid; + } + set + { + _markMyRid = value; + } + } + + public int myCPed + { + get + { + return _myCPed; + } + set + { + _myCPed = value; + } + } + + public bool GlobalPTRFound + { + get + { + return _GlobalPTRFound; + } + set + { + _GlobalPTRFound = value; + } + } + + public bool WorldPTRFound + { + get + { + return _WorldPTRFound; + } + set + { + _WorldPTRFound = value; + } + } + + public bool BlipPTRFound + { + get + { + return _BlipPTRFound; + } + set + { + _BlipPTRFound = value; + } + } + + public bool ReplayInterfacePTRFound + { + get + { + return _ReplayInterfacePTRFound; + } + set + { + _ReplayInterfacePTRFound = value; + } + } + + public bool LocalScriptsPTRFound + { + get + { + return _LocalScriptsPTRFound; + } + set + { + _LocalScriptsPTRFound = value; + } + } + + public bool PlayerCountPTRFound + { + get + { + return _PlayerCountPTRFound; + } + set + { + _PlayerCountPTRFound = value; + } + } + + public bool PickupDataPTRFound + { + get + { + return _PickupDataPTRFound; + } + set + { + _PickupDataPTRFound = value; + } + } + + public bool WeatherADDRFound + { + get + { + return _WeatherADDRFound; + } + set + { + _WeatherADDRFound = value; + } + } + + public bool SettingsPTRFound + { + get + { + return _SettingsPTRFound; + } + set + { + _SettingsPTRFound = value; + } + } + + public bool AimCPedPTRFound + { + get + { + return _AimCPedPTRFound; + } + set + { + _AimCPedPTRFound = value; + } + } + + public bool FriendlistPTRFound + { + get + { + return _FriendlistPTRFound; + } + set + { + _FriendlistPTRFound = value; + } + } + #endregion + + private bool _pgodm = false; + private bool _pgodm_last_hit = false; + private bool _pnwanted = false; + private bool _pnwanted_last_hit = false; + private bool _pnragdoll = false; + private bool _pnragdoll_last_hit = false; + private bool _puoffradar = false; + private bool _puoffradar_last_hit = false; + private bool _psbelt = false; + private bool _psbelt_last_hit = false; + private bool _psjump = false; + private bool _psjump_last_hit = false; + private bool _psexammo = false; + private bool _psexammo_last_hit = false; + private bool _pdiscol = false; + private bool _pdiscol_last_hit = false; + private bool _vgodm = false; + private bool _vgodm_last_hit = false; + + public bool pgodm + { + get + { + return _pgodm; + } + set + { + _pgodm = value; + } + } + public bool pgodm_last_hit + { + get + { + return _pgodm_last_hit; + } + set + { + _pgodm_last_hit = value; + } + } + public bool pnwanted + { + get + { + return _pnwanted; + } + set + { + _pnwanted = value; + } + } + public bool pnwanted_last_hit + { + get + { + return _pnwanted_last_hit; + } + set + { + _pnwanted_last_hit = value; + } + } + public bool pnragdoll + { + get + { + return _pnragdoll; + } + set + { + _pnragdoll = value; + } + } + public bool pnragdoll_last_hit + { + get + { + return _pnragdoll_last_hit; + } + set + { + _pnragdoll_last_hit = value; + } + } + public bool puoffradar + { + get + { + return _puoffradar; + } + set + { + _puoffradar = value; + } + } + public bool puoffradar_last_hit + { + get + { + return _puoffradar_last_hit; + } + set + { + _puoffradar_last_hit = value; + } + } + public bool psbelt + { + get + { + return _psbelt; + } + set + { + _psbelt = value; + } + } + public bool psbelt_last_hit + { + get + { + return _psbelt_last_hit; + } + set + { + _psbelt_last_hit = value; + } + } + public bool psjump + { + get + { + return _psjump; + } + set + { + _psjump = value; + } + } + public bool psjump_last_hit + { + get + { + return _psjump_last_hit; + } + set + { + _psjump_last_hit = value; + } + } + public bool psexammo + { + get + { + return _psexammo; + } + set + { + _psexammo = value; + } + } + public bool psexammo_last_hit + { + get + { + return _psexammo_last_hit; + } + set + { + _psexammo_last_hit = value; + } + } + public bool pdiscol + { + get + { + return _pdiscol; + } + set + { + _pdiscol = value; + } + } + public bool pdiscol_last_hit + { + get + { + return _pdiscol_last_hit; + } + set + { + _pdiscol_last_hit = value; + } + } + public bool vgodm + { + get + { + return _vgodm; + } + set + { + _vgodm = value; + } + } + public bool vgodm_last_hit + { + get + { + return _vgodm_last_hit; + } + set + { + _vgodm_last_hit = value; + } + } + } +} diff --git a/app.manifest b/app.manifest new file mode 100644 index 0000000..d72e750 --- /dev/null +++ b/app.manifest @@ -0,0 +1,76 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/gtavcsmm.ico b/gtavcsmm.ico new file mode 100644 index 0000000000000000000000000000000000000000..035bef6225992f2fa6d085eee063919f622b4033 GIT binary patch literal 46440 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 literal 0 HcmV?d00001