Merge pull request #12 from Fire-Head/master

Pad done

src/Camera.cpp

@@ -15,6 +15,8 @@ const float DefaultFOV = 80.0f;	// actually 70.0f
 
 CCamera &TheCamera = *(CCamera*)0x6FACF8;
 
+WRAPPER Bool CCam::Using3rdPersonMouseCam() { EAXJMP(0x457460); }
+
 WRAPPER void CCamera::DrawBordersForWideScreen(void) { EAXJMP(0x46B430); }
 
 bool

src/Camera.h

@@ -161,6 +161,7 @@ struct CCam
 	CPed         *m_pLastPedLookedAt;// So interpolation works 
 	bool        m_bFirstPersonRunAboutActive;
 
+	Bool Using3rdPersonMouseCam();
 
 	void GetVectorsReadyForRW(void);
 	CVector DoAverageOnVector(const CVector &vec);

src/Clock.cpp

@@ -3,6 +3,10 @@
 #include "Timer.h"
 #include "Pad.h"
 #include "Clock.h"
+#include "Stats.h"
+
+_TODO("gbFastTime");
+Bool &gbFastTime = *(Bool*)0x95CDBB;
 
 uint8  &CClock::ms_nGameClockHours = *(uint8*)0x95CDA6;
 uint8  &CClock::ms_nGameClockMinutes = *(uint8*)0x95CDC8;
@@ -30,26 +34,37 @@ CClock::Initialise(uint32 scale)
 void
 CClock::Update(void)
 {
-	if(CPad::GetPad(1)->GetRightShoulder1()){
+	if(CPad::GetPad(1)->GetRightShoulder1())
+	{
 		ms_nGameClockMinutes += 8;
 		ms_nLastClockTick = CTimer::GetTimeInMilliseconds();
-		if(ms_nGameClockMinutes >= 60){
+		
+		if(ms_nGameClockMinutes >= 60)
+		{
 			ms_nGameClockHours++;
 			ms_nGameClockMinutes = 0;
 			if(ms_nGameClockHours >= 24)
 				ms_nGameClockHours = 0;
 		}
-	}else
+		
-	if(CTimer::GetTimeInMilliseconds() - ms_nLastClockTick >
+	}
-	   ms_nMillisecondsPerGameMinute){
+	else if(CTimer::GetTimeInMilliseconds() - ms_nLastClockTick > ms_nMillisecondsPerGameMinute || gbFastTime)
+	{
 		ms_nGameClockMinutes++;
 		ms_nLastClockTick += ms_nMillisecondsPerGameMinute;
-		if(ms_nGameClockMinutes >= 60){
+		
+		if ( gbFastTime )
+			ms_nLastClockTick = CTimer::GetTimeInMilliseconds();
+		
+		if(ms_nGameClockMinutes >= 60)
+		{
 			ms_nGameClockHours++;
 			ms_nGameClockMinutes = 0;
 			if(ms_nGameClockHours >= 24)
+			{
+				CStats::DaysPassed++;
 				ms_nGameClockHours = 0;
-				// TODO: stats days passed
+			}
 		}
 	}
 	ms_nGameClockSeconds +=

src/ControllerConfig.cpp

@@ -18,6 +18,9 @@ WRAPPER void CControllerConfigManager::InitDefaultControlConfiguration() { EAXJM
 WRAPPER void CControllerConfigManager::InitDefaultControlConfigMouse(CMouseControllerState const &mousestate) { EAXJMP(0x58BD00); }
 WRAPPER Int32 CControllerConfigManager::GetJoyButtonJustDown() { EAXJMP(0x58B7D0); }
 WRAPPER void CControllerConfigManager::InitDefaultControlConfigJoyPad(unsigned int buttons) { EAXJMP(0x58BD90); }
+WRAPPER void CControllerConfigManager::ClearSimButtonPressCheckers() { EAXJMP(0x58D220); }
+WRAPPER void CControllerConfigManager::AffectPadFromKeyBoard() { EAXJMP(0x58D0C0); }
+WRAPPER void CControllerConfigManager::AffectPadFromMouse() { EAXJMP(0x58D1A0); }
 
 void CControllerConfigManager::LoadSettings(Int32 file)
 {

src/ControllerConfig.h

@@ -46,6 +46,9 @@ public:
 	void InitDefaultControlConfiguration();
 	void InitDefaultControlConfigMouse(CMouseControllerState const &mousestate);
 	void InitDefaultControlConfigJoyPad(unsigned int buttons);
+	void ClearSimButtonPressCheckers();
+	void AffectPadFromKeyBoard();
+	void AffectPadFromMouse();
 	
 };
 

src/CutsceneMgr.h

@@ -6,6 +6,7 @@ class CCutsceneMgr
 {
 	static bool &ms_running;
 	static bool &ms_cutsceneProcessing;
+	
 public:
 	static CDirectory *&ms_pCutsceneDir;
 

src/Frontend.cpp

@@ -10,6 +10,7 @@ Bool &CMenuManager::m_PrefsVsync = *(Bool*)0x5F2E58;
 Bool &CMenuManager::m_PrefsAllowNastyGame = *(Bool*)0x5F2E64;
 Bool &CMenuManager::m_bStartUpFrontEndRequested = *(Bool*)0x95CCF4;
 Bool &CMenuManager::m_PrefsFrameLimiter = *(Bool*)0x5F2E60;
+Bool &CMenuManager::m_PrefsUseVibration = *(Bool*)0x95CD92;
 
 CMenuManager &FrontEndMenuManager = *(CMenuManager*)0x8F59D8;
 

src/Frontend.h

@@ -91,6 +91,7 @@ public:
 	static Bool &m_PrefsAllowNastyGame;
 	static Bool &m_bStartUpFrontEndRequested;
 	static Bool &m_PrefsFrameLimiter;
+	static Bool &m_PrefsUseVibration;
 
 	void Process(void);
 	void DrawFrontEnd(void);

src/Game.cpp

@@ -8,6 +8,7 @@ bool &CGame::nastyGame = *(bool*)0x5F4DD4;
 bool &CGame::frenchGame = *(bool*)0x95CDCB;
 bool &CGame::germanGame = *(bool*)0x95CD1E;
 bool &CGame::noProstitutes = *(bool*)0x95CDCF;
+bool &CGame::playingIntro = *(bool*)0x95CDC2;
 
 WRAPPER void CGame::Process(void) { EAXJMP(0x48C850); }
 WRAPPER Bool CGame::InitialiseOnceBeforeRW(void) { EAXJMP(0x48BB80); }

src/Game.h

@@ -17,6 +17,7 @@ public:
 	static bool &frenchGame;
 	static bool &germanGame;
 	static bool &noProstitutes;
+	static bool &playingIntro;
 
 	static void Process(void);
 	static Bool InitialiseOnceBeforeRW(void);

src/Pad.h

@@ -71,21 +71,21 @@ public:
 
 	void Clear(void);
 };
-static_assert(sizeof(CControllerState) == 0x2A, "CControllerState: error");
+VALIDATE_SIZE(CControllerState, 0x2A);
 
 class CMouseControllerState
 {
 public:
 	//uint32 btns;	// bit 0-2 button 1-3
 
-	UInt8 LMB;
+	Bool LMB;
-	UInt8 RMB;
+	Bool RMB;
-	UInt8 MMB;
+	Bool MMB;
-	UInt8 WHEELUP;
+	Bool WHEELUP;
-	UInt8 WHEELDN;
+	Bool WHEELDN;
-	UInt8 MXB1;
+	Bool MXB1;
-	UInt8 MXB2;
+	Bool MXB2;
-	UInt8 _pad0;
+	char _pad0;
 	
 	Float x, y;
 	
@@ -164,6 +164,15 @@ public:
 
 VALIDATE_SIZE(CKeyboardState, 0x270);
 
+enum
+{
+	// taken from miss2
+	PAD1 = 0,
+	PAD2,
+	
+	MAX_PADS
+};
+
 class CPad
 {
 public:
@@ -176,60 +185,183 @@ public:
 	int16 Phase;
 	int16 Mode;
 	int16 ShakeDur;
-	int8 ShakeFreq;
+	UInt8 ShakeFreq;
 	int8 bHornHistory[5];
-	int8 iCurrHornHistory;
+	UInt8 iCurrHornHistory;
-	int8 DisablePlayerControls;
+	Bool DisablePlayerControls;
-	int8 JustOutOfFrontEnd;
 	int8 bApplyBrakes;
-	int32 unk[3];
+	Char _unk[12]; //int32 unk[3];
+	char _pad0[3];
 	int32 LastTimeTouched;
 	int32 AverageWeapon;
 	int32 AverageEntries;
 	
-	static CPad *Pads;	//[2];
+	CPad() { }
+	~CPad() { }
+
+	static Bool &bDisplayNoControllerMessage;
+	static Bool &bObsoleteControllerMessage;
+	static Bool &m_bMapPadOneToPadTwo;
+	
 	static CKeyboardState &OldKeyState;
 	static CKeyboardState &NewKeyState;
 	static CKeyboardState &TempKeyState;
+	static Char KeyBoardCheatString[18];
 	static CMouseControllerState &OldMouseControllerState;
 	static CMouseControllerState &NewMouseControllerState;
 	static CMouseControllerState &PCTempMouseControllerState;
 	
-	static Bool &m_bMapPadOneToPadTwo;
 	
-	int GetLeftShoulder1(void) { return NewState.LeftShoulder1; }
-	int GetLeftShoulder2(void) { return NewState.LeftShoulder2; }
-	int GetRightShoulder1(void) { return NewState.RightShoulder1; }
-	int GetRightShoulder2(void) { return NewState.RightShoulder2; }
 	
-	bool ForceCameraBehindPlayer(void);
+	
-	bool GetWeapon(void);
+	void Clear(Bool bResetPlayerControls);
-	bool GetLookBehindForCar(void);
+	void ClearMouseHistory();
-	bool GetLookBehindForPed(void);
+	void UpdateMouse();
-	bool GetLookLeft(void);
+	CControllerState ReconcileTwoControllersInput(CControllerState const &State1, CControllerState const &State2);
-	bool GetLookRight(void);
+	void StartShake(Int16 nDur, UInt8 nFreq);
+	void StartShake_Distance(Int16 nDur, UInt8 nFreq, Float fX, Float fY, Float fz);
+	void StartShake_Train(Float fX, Float fY);
+	void AddToPCCheatString(Char c);
+
+	static void UpdatePads(void);
+	void ProcessPCSpecificStuff(void);
+	void Update(Int16 unk);
+	
+	static void DoCheats(void);
+	void DoCheats(Int16 unk);
 	
 	static void StopPadsShaking(void);
-	static void ResetCheats(void);
+	void StopShaking(Int16 unk);
-	static void UpdatePads(void);
+	
-	static CPad *GetPad(int n) { return &Pads[n]; }
+	static CPad *GetPad(Int32 pad);
+	
+	Int16 GetSteeringLeftRight(void);
+	Int16 GetSteeringUpDown(void);
+	Int16 GetCarGunUpDown(void);
+	Int16 GetCarGunLeftRight(void);
+	Int16 GetPedWalkLeftRight(void);
+	Int16 GetPedWalkUpDown(void);
+	Int16 GetAnalogueUpDown(void);
+	Bool GetLookLeft(void);
+	Bool GetLookRight(void);
+	Bool GetLookBehindForCar(void);
+	Bool GetLookBehindForPed(void);
+	Bool GetHorn(void);
+	Bool HornJustDown(void);
+	Bool GetCarGunFired(void);
+	Bool CarGunJustDown(void);
+	Int16 GetHandBrake(void);
+	Int16 GetBrake(void);
+	Bool GetExitVehicle(void);
+	Bool ExitVehicleJustDown(void);
+	Int32 GetWeapon(void);
+	Bool WeaponJustDown(void);
+	Int16 GetAccelerate(void);
+	Bool CycleCameraModeUpJustDown(void);
+	Bool CycleCameraModeDownJustDown(void);
+	Bool ChangeStationJustDown(void);
+	Bool CycleWeaponLeftJustDown(void);
+	Bool CycleWeaponRightJustDown(void);
+	Bool GetTarget(void);
+	Bool TargetJustDown(void);
+	Bool JumpJustDown(void);
+	Bool GetSprint(void);
+	Bool ShiftTargetLeftJustDown(void);
+	Bool ShiftTargetRightJustDown(void);
+	Bool GetAnaloguePadUp(void);
+	Bool GetAnaloguePadDown(void);
+	Bool GetAnaloguePadLeft(void);
+	Bool GetAnaloguePadRight(void);
+	Bool GetAnaloguePadLeftJustUp(void);
+	Bool GetAnaloguePadRightJustUp(void);
+	Bool ForceCameraBehindPlayer(void);
+	Bool SniperZoomIn(void);
+	Bool SniperZoomOut(void);
+	Int16 SniperModeLookLeftRight(void);
+	Int16 SniperModeLookUpDown(void);
+	Int16 LookAroundLeftRight(void);
+	Int16 LookAroundUpDown(void);
+	void ResetAverageWeapon(void);
 	static void PrintErrorMessage(void);
+	static void ResetCheats(void);
+	static Char *EditString(Char *pStr, Int32 nSize);
+	static Int32 *EditCodesForControls(Int32 *pRsKeys, Int32 nSize);
 
-	void AddToPCCheatString(Char c);
+	// mouse
-	void Clear(Bool unk);
-	
-	//
-	
 	inline Bool GetLeftMouseJustDown() { return !!(NewMouseControllerState.LMB && !OldMouseControllerState.LMB); }
 
-	inline Bool GetEnterJustDown() { return !!(NewKeyState.ENTER && !OldKeyState.ENTER); }
+	// keyboard
-	inline Bool GetExtEnterJustDown() { return !!(NewKeyState.EXTENTER && !OldKeyState.EXTENTER); }
+	
 	inline Bool GetCharJustDown(Char c) { return !!(NewKeyState.VK_KEYS[c] && !OldKeyState.VK_KEYS[c]); }
-	inline Bool GetLeftAltJustDown() { return !!(NewKeyState.LALT && !OldKeyState.LALT); }
+	inline Bool GetFJustDown(Int32 n)   { return !!(NewKeyState.F[n] && !OldKeyState.F[n]); }
-	inline Bool GetRightAltJustDown() { return !!(NewKeyState.RALT && !OldKeyState.RALT); }
+	inline Bool GetEscapeJustDown()     { return !!(NewKeyState.ESC && !OldKeyState.ESC); }
-	inline Bool GetTabJustDown() { return !!(NewKeyState.TAB && !OldKeyState.TAB); }
+	inline Bool GetInsertJustDown()     { return !!(NewKeyState.INS && !OldKeyState.INS); }
+	inline Bool GetDeleteJustDown()     { return !!(NewKeyState.DEL && !OldKeyState.DEL); }
+	inline Bool GetHomeJustDown()       { return !!(NewKeyState.HOME && !OldKeyState.HOME); }
+	inline Bool GetEndJustDown()        { return !!(NewKeyState.END && !OldKeyState.END); }
+	inline Bool GetPageUpJustDown()     { return !!(NewKeyState.PGUP && !OldKeyState.PGUP); }
+	inline Bool GetPageDownJustDown()   { return !!(NewKeyState.PGDN && !OldKeyState.PGDN); }
+	inline Bool GetUpJustDown()         { return !!(NewKeyState.UP && !OldKeyState.UP); }
+	inline Bool GetDownJustDown()       { return !!(NewKeyState.DOWN && !OldKeyState.DOWN); }
+	inline Bool GetLeftJustDown()       { return !!(NewKeyState.LEFT && !OldKeyState.LEFT); }
+	inline Bool GetRightJustDown()      { return !!(NewKeyState.RIGHT && !OldKeyState.RIGHT); }
+	inline Bool GetScrollLockJustDown() { return !!(NewKeyState.SCROLLLOCK && !OldKeyState.SCROLLLOCK); }
+	inline Bool GetPauseJustDown()      { return !!(NewKeyState.PAUSE && !OldKeyState.PAUSE); }
+	inline Bool GetNumLockJustDown()    { return !!(NewKeyState.NUMLOCK && !OldKeyState.NUMLOCK); }
+	inline Bool GetDivideJustDown()     { return !!(NewKeyState.DIV && !OldKeyState.DIV); }
+	inline Bool GetTimesJustDown()      { return !!(NewKeyState.MUL && !OldKeyState.MUL); }
+	inline Bool GetMinusJustDown()      { return !!(NewKeyState.SUB && !OldKeyState.SUB); }
+	inline Bool GetPlusJustDown()       { return !!(NewKeyState.ADD && !OldKeyState.ADD); }
+	inline Bool GetPadEnterJustDown()   { return !!(NewKeyState.ENTER && !OldKeyState.ENTER); } //  GetEnterJustDown
+	inline Bool GetPadDelJustDown()     { return !!(NewKeyState.DECIMAL && !OldKeyState.DECIMAL); }
+	inline Bool GetPad1JustDown()       { return !!(NewKeyState.NUM1 && !OldKeyState.NUM1); }
+	inline Bool GetPad2JustDown()       { return !!(NewKeyState.NUM2 && !OldKeyState.NUM2); }
+	inline Bool GetPad3JustDown()       { return !!(NewKeyState.NUM3 && !OldKeyState.NUM3); }
+	inline Bool GetPad4JustDown()       { return !!(NewKeyState.NUM4 && !OldKeyState.NUM4); }
+	inline Bool GetPad5JustDown()       { return !!(NewKeyState.NUM5 && !OldKeyState.NUM5); }
+	inline Bool GetPad6JustDown()       { return !!(NewKeyState.NUM6 && !OldKeyState.NUM6); }
+	inline Bool GetPad7JustDown()       { return !!(NewKeyState.NUM7 && !OldKeyState.NUM7); }
+	inline Bool GetPad8JustDown()       { return !!(NewKeyState.NUM8 && !OldKeyState.NUM8); }
+	inline Bool GetPad9JustDown()       { return !!(NewKeyState.NUM9 && !OldKeyState.NUM9); }
+	inline Bool GetPad0JustDown()       { return !!(NewKeyState.NUM0 && !OldKeyState.NUM0); }
+	inline Bool GetBackspaceJustDown()  { return !!(NewKeyState.BACKSP && !OldKeyState.BACKSP); }
+	inline Bool GetTabJustDown()        { return !!(NewKeyState.TAB && !OldKeyState.TAB); }
+	inline Bool GetCapsLockJustDown()   { return !!(NewKeyState.CAPSLOCK && !OldKeyState.CAPSLOCK); }
+	inline Bool GetEnterJustDown()      { return !!(NewKeyState.EXTENTER && !OldKeyState.EXTENTER); }
+	inline Bool GetLeftShiftJustDown()  { return !!(NewKeyState.LSHIFT && !OldKeyState.LSHIFT); }
+	inline Bool GetShiftJustDown()      { return !!(NewKeyState.SHIFT && !OldKeyState.SHIFT); }
+	inline Bool GetRightShiftJustDown() { return !!(NewKeyState.RSHIFT && !OldKeyState.RSHIFT); }
+	inline Bool GetLeftCtrlJustDown()   { return !!(NewKeyState.LCTRL && !OldKeyState.LCTRL); }
+	inline Bool GetRightCtrlJustDown()  { return !!(NewKeyState.RCTRL && !OldKeyState.RCTRL); }
+	inline Bool GetLeftAltJustDown()    { return !!(NewKeyState.LALT && !OldKeyState.LALT); }
+	inline Bool GetRightAltJustDown()   { return !!(NewKeyState.RALT && !OldKeyState.RALT); }
+	inline Bool GetLeftWinJustDown()    { return !!(NewKeyState.LWIN && !OldKeyState.LWIN); }
+	inline Bool GetRightWinJustDown()   { return !!(NewKeyState.RWIN && !OldKeyState.RWIN); }
+	inline Bool GetAppsJustDown()       { return !!(NewKeyState.APPS && !OldKeyState.APPS); }
+	
+	// pad
+
+	inline Bool GetTriangleJustDown()       { return !!(NewState.Triangle && !OldState.Triangle); }
+	inline Bool GetCircleJustDown()         { return !!(NewState.Circle && !OldState.Circle); }
+	inline Bool GetCrossJustDown()          { return !!(NewState.Cross && !OldState.Cross); }
+	inline Bool GetSquareJustDown()         { return !!(NewState.Square && !OldState.Square); }
+	inline Bool GetDPadUpJustDown()         { return !!(NewState.DPadUp && !OldState.DPadUp); }
+	inline Bool GetDPadDownJustDown()       { return !!(NewState.DPadDown && !OldState.DPadDown); }
+	inline Bool GetDPadLeftJustDown()       { return !!(NewState.DPadLeft && !OldState.DPadLeft); }
+	inline Bool GetDPadRightJustDown()      { return !!(NewState.DPadRight && !OldState.DPadRight); }
+	inline Bool GetLeftShoulder1JustDown()  { return !!(NewState.LeftShoulder1 && !OldState.LeftShoulder1); }
+	inline Bool GetLeftShoulder2JustDown()  { return !!(NewState.LeftShoulder2 && !OldState.LeftShoulder2); }
+	inline Bool GetRightShoulder1JustDown() { return !!(NewState.RightShoulder1 && !OldState.RightShoulder1); }
+	inline Bool GetRightShoulder2JustDown() { return !!(NewState.RightShoulder2 && !OldState.RightShoulder2); }
+	
+	inline Int32 GetLeftShoulder1(void)  { return NewState.LeftShoulder1; }
+	inline Int32 GetLeftShoulder2(void)  { return NewState.LeftShoulder2; }
+	inline Int32 GetRightShoulder1(void) { return NewState.RightShoulder1; }
+	inline Int32 GetRightShoulder2(void) { return NewState.RightShoulder2; }
 };
-static_assert(sizeof(CPad) == 0xFC, "CPad: error");
+VALIDATE_SIZE(CPad, 0xFC);
 
 #define IsButtonJustDown(pad, btn) \
 	(!(pad)->OldState.btn && (pad)->NewState.btn)
+	
+void LittleTest(void);

src/Stats.cpp

@@ -0,0 +1,4 @@
+#include "common.h"
+#include "Stats.h"
+
+Int32 &CStats::DaysPassed = *(Int32*)0x8F2BB8;

src/Stats.h

@@ -0,0 +1,7 @@
+#pragma once
+
+class CStats
+{
+public:
+	static Int32 &DaysPassed;
+};

src/Timer.h

@@ -20,6 +20,7 @@ public:
 	static uint32 GetTimeInMilliseconds(void) { return m_snTimeInMilliseconds; }
 	
 	static inline Bool GetIsPaused() { return m_UserPause || m_CodePause; }
+	static inline void SetTimeScale(Float ts) { ms_fTimeScale = ts; }
 	
 	static void Initialise(void);
 	static void Shutdown(void);

src/Weather.cpp

@@ -28,3 +28,8 @@ bool &CWeather::bScriptsForceRain = *(bool*)0x95CD7D;
 bool &CWeather::Stored_StateStored = *(bool*)0x95CDC1;
 
 WRAPPER void CWeather::RenderRainStreaks(void) { EAXJMP(0x524550); }
+
+void CWeather::ReleaseWeather()
+{
+	ForcedWeatherType = -1;
+}

src/Weather.h

@@ -34,4 +34,6 @@ public:
 	static bool &Stored_StateStored;
 
 	static void RenderRainStreaks(void);
+	
+	static void ReleaseWeather();
 };

src/control/Population.cpp

@@ -0,0 +1,4 @@
+#include "common.h"
+#include "Population.h"
+
+Bool &CPopulation::ms_bGivePedsWeapons = *(Bool*)0x95CCF6;

src/control/Population.h

@@ -0,0 +1,7 @@
+#pragma once
+
+class CPopulation
+{
+public:
+	static Bool &ms_bGivePedsWeapons;
+};

src/control/Replay.cpp

@@ -3,5 +3,6 @@
 #include "Replay.h"
 
 uint8 &CReplay::Mode = *(uint8*)0x95CD5B;
+Bool &CReplay::bPlayingBackFromFile = *(Bool*)0x95CD58;
 
 WRAPPER void CReplay::Display(void) { EAXJMP(0x595EE0); }

src/control/Replay.h

@@ -3,11 +3,11 @@
 class CReplay
 {
 public:
+	static void Display(void);
 	enum {
 		MODE_1
 	};
 
 	static uint8 &Mode;
-
+	static Bool &bPlayingBackFromFile;
-	static void Display(void);
 };

src/entities/Ped.cpp

@@ -3,6 +3,10 @@
 #include "Ped.h"
 #include "Pools.h"
 
+Bool &CPed::bNastyLimbsCheat = *(Bool*)0x95CD44;
+Bool &CPed::bPedCheat2 = *(Bool*)0x95CD5A;
+Bool &CPed::bPedCheat3 = *(Bool*)0x95CD59;
+	
 void *CPed::operator new(size_t sz) { return CPools::GetPedPool()->New();  }
 void CPed::operator delete(void *p, size_t sz) { CPools::GetPedPool()->Delete((CPed*)p); }
 

src/entities/Ped.h

@@ -188,6 +188,10 @@ public:
 	bool UseGroundColModel(void);
 	void KillPedWithCar(CVehicle *veh, float impulse);
 	CWeapon *GetWeapon(void) { return &m_weapons[m_currentWeapon]; }
+	
+	static Bool &bNastyLimbsCheat;
+	static Bool &bPedCheat2;
+	static Bool &bPedCheat3;
 };
 static_assert(offsetof(CPed, m_nPedState) == 0x224, "CPed: error");
 static_assert(offsetof(CPed, m_pCurSurface) == 0x2FC, "CPed: error");

src/entities/Vehicle.cpp

@@ -3,5 +3,11 @@
 #include "Vehicle.h"
 #include "Pools.h"
 
+Bool &CVehicle::bWheelsOnlyCheat = *(Bool *)0x95CD78;
+Bool &CVehicle::bAllDodosCheat = *(Bool *)0x95CD75;
+Bool &CVehicle::bCheat3 = *(Bool *)0x95CD66;
+Bool &CVehicle::bCheat4 = *(Bool *)0x95CD65;
+Bool &CVehicle::bCheat5 = *(Bool *)0x95CD64;
+	
 void *CVehicle::operator new(size_t sz) { return CPools::GetVehiclePool()->New();  }
 void CVehicle::operator delete(void *p, size_t sz) { CPools::GetVehiclePool()->Delete((CVehicle*)p); }

src/entities/Vehicle.h

@@ -62,6 +62,12 @@ uint8 m_extra2;
 	bool IsTrain(void) { return m_vehType == VEHICLE_TYPE_TRAIN; }
 	bool IsHeli(void) { return m_vehType == VEHICLE_TYPE_HELI; }
 	bool IsPlane(void) { return m_vehType == VEHICLE_TYPE_PLANE; }
+	
+	static Bool &bWheelsOnlyCheat;
+	static Bool &bAllDodosCheat;
+	static Bool &bCheat3;
+	static Bool &bCheat4;
+	static Bool &bCheat5;
 };
 static_assert(sizeof(CVehicle) == 0x288, "CVehicle: error");
 static_assert(offsetof(CVehicle, m_pCurSurface) == 0x1E0, "CVehicle: error");

src/skel/win/win.cpp

@@ -1995,7 +1995,7 @@ _WinMain(HINSTANCE instance,
 							++gGameState;
 						else if ( CPad::GetPad(0)->GetLeftMouseJustDown() )
 							++gGameState;
-						else if ( CPad::GetPad(0)->GetEnterJustDown() || CPad::GetPad(0)->GetExtEnterJustDown() )
+						else if ( CPad::GetPad(0)->GetPadEnterJustDown() || CPad::GetPad(0)->GetEnterJustDown() )
 							++gGameState;
 						else if ( CPad::GetPad(0)->GetCharJustDown(' ') )
 							++gGameState;
@@ -2031,7 +2031,7 @@ _WinMain(HINSTANCE instance,
 							++gGameState;
 						else if ( CPad::GetPad(0)->GetLeftMouseJustDown() )
 							++gGameState;
-						else if ( CPad::GetPad(0)->GetEnterJustDown() || CPad::GetPad(0)->GetExtEnterJustDown() )
+						else if ( CPad::GetPad(0)->GetPadEnterJustDown() || CPad::GetPad(0)->GetEnterJustDown() )
 							++gGameState;
 						else if ( CPad::GetPad(0)->GetCharJustDown(' ') )
 							++gGameState;