9 files changed, 364 insertions, 17 deletions

diff --git a/README.md b/README.md
index 97aa6962..0817340f 100644
--- a/README.md
+++ b/README.md
@@ -51,7 +51,6 @@ CCrane
 CCranes
 CCullZone
 CCullZones
-CEmergencyPed
 CExplosion
 CFallingGlassPane
 CFire
@@ -64,6 +63,7 @@ CMenuManager
 CMotionBlurStreaks
 CPacManPickups
 CPedIK
+CPedPath
 CPlayerPed
 CProjectile
 CProjectileInfo
diff --git a/src/audio/sampman.cpp b/src/audio/sampman.cpp
index 9c79e1b1..6edb6028 100644
--- a/src/audio/sampman.cpp
+++ b/src/audio/sampman.cpp
@@ -352,7 +352,11 @@ _ResolveLink(char const *path, char *out)
 						OutputDebugString(fd.cFileName);
 						
 						strcpy(out, filepath);
-						
+						// FIX: Release the objects. Taken from SA.
+#ifdef FIX_BUGS
+						ppf->Release();
+						psl->Release();
+#endif
 						return true;
 					}
 				}
diff --git a/src/control/PathFind.cpp b/src/control/PathFind.cpp
index 3c16202b..dad879b1 100644
--- a/src/control/PathFind.cpp
+++ b/src/control/PathFind.cpp
@@ -309,7 +309,7 @@ CPathFind::CountFloodFillGroups(uint8 type)
 				if(m_pathNodes[l].group == 0){
 					m_pathNodes[l].group = n;
 					if(m_pathNodes[l].group == 0)
-						m_pathNodes[l].group = 0x80;	// ???
+						m_pathNodes[l].group = INT8_MIN;
 					m_pathNodes[l].next = node;
 					node = &m_pathNodes[l];
 				}
diff --git a/src/control/PathFind.h b/src/control/PathFind.h
index 0b20ea5a..70b431f6 100644
--- a/src/control/PathFind.h
+++ b/src/control/PathFind.h
@@ -36,7 +36,7 @@ struct CPathNode
 	uint8 bDisabled : 1;
 	uint8 bBetweenLevels : 1;
 
-	uint8 group;
+	int8 group;
 /*	For reference VC:
 	int16 prevIndex;
 	int16 nextIndex;
diff --git a/src/peds/EmergencyPed.cpp b/src/peds/EmergencyPed.cpp
index ae430c94..16468270 100644
--- a/src/peds/EmergencyPed.cpp
+++ b/src/peds/EmergencyPed.cpp
@@ -345,7 +345,6 @@ CEmergencyPed::MedicAI(void)
 				}
 				break;
 			case EMERGENCY_PED_PERFORM_CPR:
-				m_pRevivedPed = m_pRevivedPed;
 				if (!m_pRevivedPed || m_pRevivedPed->m_fHealth > 0.0f) {
 					m_nEmergencyPedState = EMERGENCY_PED_DETERMINE_NEXT_STATE;
 					break;
diff --git a/src/peds/Ped.cpp b/src/peds/Ped.cpp
index 68372ee8..d1928c04 100644
--- a/src/peds/Ped.cpp
+++ b/src/peds/Ped.cpp
@@ -529,7 +529,7 @@ CPed::CPed(uint32 pedType) : m_pedIK(this)
 
 	bStillOnValidPoly = false;
 	m_ped_flagG2 = true;
-	m_ped_flagG4 = false;
+	bResetWalkAnims = false;
 	bStartWanderPathOnFoot = false;
 	bOnBoat = false;
 	bBusJacked = false;
@@ -6856,7 +6856,7 @@ CPed::FinishJumpCB(CAnimBlendAssociation *animAssoc, void *arg)
 {
 	CPed *ped = (CPed*)arg;
 
-	ped->m_ped_flagG4 = true;
+	ped->bResetWalkAnims = true;
 	ped->bIsLanding = false;
 
 	animAssoc->blendDelta = -1000.0f;
diff --git a/src/peds/Ped.h b/src/peds/Ped.h
index 00b73bae..42d2335e 100644
--- a/src/peds/Ped.h
+++ b/src/peds/Ped.h
@@ -349,7 +349,7 @@ public:
 
 	uint8 bStillOnValidPoly : 1;
 	uint8 m_ped_flagG2 : 1;
-	uint8 m_ped_flagG4 : 1; // bResetWalkAnims?
+	uint8 bResetWalkAnims : 1;
 	uint8 bStartWanderPathOnFoot : 1; // exits the car if he's in it, reset after path found
 	uint8 bOnBoat : 1; // not just driver, may be just standing
 	uint8 bBusJacked : 1;
diff --git a/src/peds/PlayerPed.cpp b/src/peds/PlayerPed.cpp
index 69cc316a..7c946dda 100644
--- a/src/peds/PlayerPed.cpp
+++ b/src/peds/PlayerPed.cpp
@@ -5,20 +5,15 @@
 #include "WeaponEffects.h"
 #include "ModelIndices.h"
 #include "World.h"
+#include "RpAnimBlend.h"
+#include "General.h"
 
 CPlayerPed::~CPlayerPed()
 {
 	delete m_pWanted;
 }
 
-WRAPPER void CPlayerPed::ReApplyMoveAnims(void) { EAXJMP(0x4F07C0); }
-WRAPPER void CPlayerPed::SetupPlayerPed(int32) { EAXJMP(0x4EFB60); }
-WRAPPER void CPlayerPed::DeactivatePlayerPed(int32) { EAXJMP(0x4EFC00); }
-WRAPPER void CPlayerPed::ReactivatePlayerPed(int32) { EAXJMP(0x4EFC20); }
 WRAPPER void CPlayerPed::KeepAreaAroundPlayerClear(void) { EAXJMP(0x4F3460); }
-WRAPPER void CPlayerPed::MakeChangesForNewWeapon(int8) { EAXJMP(0x4F2560); }
-WRAPPER void CPlayerPed::SetInitialState(void) { EAXJMP(0x4EFC40); }
-WRAPPER void CPlayerPed::SetMoveAnim(void) { EAXJMP(0x4F3760); }
 WRAPPER void CPlayerPed::ProcessControl(void) { EAXJMP(0x4EFD90); }
 
 CPlayerPed::CPlayerPed(void) : CPed(PEDTYPE_PLAYER1)
@@ -31,7 +26,7 @@ CPlayerPed::CPlayerPed(void) : CPed(PEDTYPE_PLAYER1)
 	m_pWanted->Initialise();
 	m_pArrestingCop = nil;
 	m_currentWeapon = WEAPONTYPE_UNARMED;
-	m_nSelectedWepSlot = 0;
+	m_nSelectedWepSlot = WEAPONTYPE_UNARMED;
 	m_nSpeedTimer = 0;
 	m_bSpeedTimerFlag = 0;
 	m_pPointGunAt = nil;
@@ -113,17 +108,364 @@ CPlayerPed::GetPlayerInfoForThisPlayerPed()
 	return nil;

 }
 
+void

+CPlayerPed::SetupPlayerPed(int32 index)

+{

+	CPlayerPed *player = new CPlayerPed();

+	CWorld::Players[index].m_pPed = player;

+

+	player->SetOrientation(0.0f, 0.0f, 0.0f);

+

+	CWorld::Add(player);

+	player->m_wepAccuracy = 100;
+}
+
+void

+CPlayerPed::DeactivatePlayerPed(int32 index)

+{

+	CWorld::Remove(CWorld::Players[index].m_pPed);
+}
+
+void

+CPlayerPed::ReactivatePlayerPed(int32 index)

+{

+	CWorld::Add(CWorld::Players[index].m_pPed);
+}
+
+void

+CPlayerPed::UseSprintEnergy(void)

+{

+	if (m_fCurrentStamina > -150.0f && !CWorld::Players[CWorld::PlayerInFocus].m_bInfiniteSprint

+		&& !m_bAdrenalineActive) {

+		m_fCurrentStamina = m_fCurrentStamina - CTimer::GetTimeStep();

+		m_fStaminaProgress = m_fStaminaProgress + CTimer::GetTimeStep();

+	}

+

+	if (m_fStaminaProgress >= 500.0f) {

+		m_fStaminaProgress = 0;

+		if (m_fMaxStamina < 1000.0f)

+			m_fMaxStamina += 10.0f;

+	}

+}
+
+void

+CPlayerPed::MakeChangesForNewWeapon(int8 weapon)

+{

+	if (m_nPedState == PED_SNIPER_MODE) {

+		RestorePreviousState();

+		TheCamera.ClearPlayerWeaponMode();

+	}

+	SetCurrentWeapon(weapon);

+

+	GetWeapon()->m_nAmmoInClip = min(GetWeapon()->m_nAmmoTotal, CWeaponInfo::GetWeaponInfo(GetWeapon()->m_eWeaponType)->m_nAmountofAmmunition);

+

+	if (!(CWeaponInfo::GetWeaponInfo(GetWeapon()->m_eWeaponType)->m_bCanAim))

+		ClearWeaponTarget();

+

+	CAnimBlendAssociation *weaponAnim = RpAnimBlendClumpGetAssociation(GetClump(), CWeaponInfo::GetWeaponInfo(WEAPONTYPE_SNIPERRIFLE)->m_AnimToPlay);

+	if (weaponAnim) {

+		weaponAnim->SetRun();

+		weaponAnim->flags |= ASSOC_FADEOUTWHENDONE;

+	}

+	TheCamera.ClearPlayerWeaponMode();
+}
+
+void

+CPlayerPed::ReApplyMoveAnims(void)

+{

+	static AnimationId moveAnims[] = { ANIM_WALK, ANIM_RUN, ANIM_SPRINT, ANIM_IDLE_STANCE, ANIM_WALK_START };

+

+	for(int i = 0; i < ARRAY_SIZE(moveAnims); i++) {

+		CAnimBlendAssociation *curMoveAssoc = RpAnimBlendClumpGetAssociation(GetClump(), moveAnims[i]);

+		if (curMoveAssoc) {

+			if (strcmp(CAnimManager::GetAnimAssociation(m_animGroup, moveAnims[i])->hierarchy->name, curMoveAssoc->hierarchy->name) != 0) {

+				CAnimBlendAssociation *newMoveAssoc = CAnimManager::AddAnimation(GetClump(), m_animGroup, moveAnims[i]);

+				newMoveAssoc->blendDelta = curMoveAssoc->blendDelta;

+				newMoveAssoc->blendAmount = curMoveAssoc->blendAmount;

+				curMoveAssoc->blendDelta = -1000.0f;

+				curMoveAssoc->flags |= ASSOC_DELETEFADEDOUT;

+			}

+		}

+	}

+}
+
+void

+CPlayerPed::SetInitialState(void)

+{

+	m_bAdrenalineActive = false;

+	m_nAdrenalineTime = 0;

+	CTimer::SetTimeStep(1.0f);

+	m_pSeekTarget = nil;

+	m_vecSeekPos = { 0.0f, 0.0f, 0.0f };

+	m_fleeFromPosX = 0.0f;

+	m_fleeFromPosY = 0.0f;

+	m_fleeFrom = nil;

+	m_fleeTimer = 0;

+	m_objective = OBJECTIVE_NONE;

+	m_prevObjective = OBJECTIVE_NONE;

+	bUsesCollision = true;

+	ClearAimFlag();

+	ClearLookFlag();

+	bIsPointingGunAt = false;

+	bRenderPedInCar = true;

+	if (m_pFire)

+		m_pFire->Extinguish();

+	RpAnimBlendClumpRemoveAllAssociations(GetClump());

+	m_nPedState = PED_IDLE;

+	SetMoveState(PEDMOVE_STILL);

+	m_nLastPedState = PED_NONE;

+	m_animGroup = ASSOCGRP_PLAYER;

+	m_fMoveSpeed = 0.0f;

+	m_nSelectedWepSlot = WEAPONTYPE_UNARMED;

+	m_bShouldEvade = false;

+	m_pEvadingFrom = nil;

+	bIsPedDieAnimPlaying = false;

+	SetRealMoveAnim();

+	m_bCanBeDamaged = true;

+	m_pedStats->m_temper = 50;

+	m_fWalkAngle = 0.0f;

+}
+
+void

+CPlayerPed::SetRealMoveAnim(void)

+{

+	CAnimBlendAssociation *curWalkAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_WALK);

+	CAnimBlendAssociation *curRunAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_RUN);

+	CAnimBlendAssociation *curSprintAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_SPRINT);

+	CAnimBlendAssociation *curWalkStartAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_WALK_START);

+	CAnimBlendAssociation *curIdleAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_IDLE_STANCE);

+	CAnimBlendAssociation *curRunStopAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_RUN_STOP);

+	CAnimBlendAssociation *curRunStopRAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_RUN_STOP_R);

+	if (bResetWalkAnims) {

+		if (curWalkAssoc)

+			curWalkAssoc->SetCurrentTime(0.0f);

+		if (curRunAssoc)

+			curRunAssoc->SetCurrentTime(0.0f);

+		if (curSprintAssoc)

+			curSprintAssoc->SetCurrentTime(0.0f);

+		bResetWalkAnims = false;

+	}

+

+	if (!curIdleAssoc)

+		curIdleAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_IDLE_TIRED);

+	if (!curIdleAssoc)

+		curIdleAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_FIGHT_IDLE);

+

+	if ((!curRunStopAssoc || !(curRunStopAssoc->IsRunning())) && (!curRunStopRAssoc || !(curRunStopRAssoc->IsRunning()))) {

+

+		if (curRunStopAssoc && curRunStopAssoc->blendDelta >= 0.0f || curRunStopRAssoc && curRunStopRAssoc->blendDelta >= 0.0f) {

+			if (curRunStopAssoc) {

+				curRunStopAssoc->flags |= ASSOC_DELETEFADEDOUT;

+				curRunStopAssoc->blendAmount = 1.0f;

+				curRunStopAssoc->blendDelta = -8.0f;

+			} else if (curRunStopRAssoc) {

+				curRunStopRAssoc->flags |= ASSOC_DELETEFADEDOUT;

+				curRunStopRAssoc->blendAmount = 1.0f;

+				curRunStopRAssoc->blendDelta = -8.0f;

+			}

+			

+			RestoreHeadingRate();

+			if (!curIdleAssoc) {

+				if (m_fCurrentStamina < 0.0f && !CWorld::TestSphereAgainstWorld(GetPosition(), 0.0f,

+						nil, true, false, false, false, false, false)) {

+					curIdleAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_IDLE_TIRED, 8.0f);

+

+				} else {

+					curIdleAssoc = CAnimManager::BlendAnimation(GetClump(), m_animGroup, ANIM_IDLE_STANCE, 8.0f);

+				}

+				m_nWaitTimer = CTimer::GetTimeInMilliseconds() + CGeneral::GetRandomNumberInRange(2500, 4000);

+			}

+			curIdleAssoc->blendAmount = 0.0f;

+			curIdleAssoc->blendDelta = 8.0f;

+

+		} else if (m_fMoveSpeed == 0.0f && !curSprintAssoc) {

+			if (!curIdleAssoc) {

+				if (m_fCurrentStamina < 0.0f && !CWorld::TestSphereAgainstWorld(GetPosition(), 0.0f,

+						nil, true, false, false, false, false, false)) {

+					curIdleAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_IDLE_TIRED, 4.0f);

+					

+				} else {

+					curIdleAssoc = CAnimManager::BlendAnimation(GetClump(), m_animGroup, ANIM_IDLE_STANCE, 4.0f);

+				}

+

+				m_nWaitTimer = CTimer::GetTimeInMilliseconds() + CGeneral::GetRandomNumberInRange(2500, 4000);

+			}

+

+			if (m_fCurrentStamina > 0.0f && curIdleAssoc->animId == ANIM_IDLE_TIRED) {

+				CAnimManager::BlendAnimation(GetClump(), m_animGroup, ANIM_IDLE_STANCE, 4.0f);

+

+			} else if (m_nPedState != PED_FIGHT) {

+				if (m_fCurrentStamina < 0.0f && curIdleAssoc->animId != ANIM_IDLE_TIRED

+					&& !CWorld::TestSphereAgainstWorld(GetPosition(), 0.0f, nil, true, false, false, false, false, false)) {

+					CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_IDLE_TIRED, 4.0f);

+

+				} else if (curIdleAssoc->animId != ANIM_IDLE_STANCE) {

+					CAnimManager::BlendAnimation(GetClump(), m_animGroup, ANIM_IDLE_STANCE, 4.0f);

+				}

+			}

+

+			m_nMoveState = PEDMOVE_STILL;

+		} else {

+			if (curIdleAssoc) {

+				if (curWalkStartAssoc) {

+					curWalkStartAssoc->blendAmount = 1.0f;

+					curWalkStartAssoc->blendDelta = 0.0f;

+				} else {

+					curWalkStartAssoc = CAnimManager::AddAnimation(GetClump(), m_animGroup, ANIM_WALK_START);

+				}

+				if (curWalkAssoc)

+					curWalkAssoc->SetCurrentTime(0.0f);

+				if (curRunAssoc)

+					curRunAssoc->SetCurrentTime(0.0f);

+

+				delete curIdleAssoc;

+				delete RpAnimBlendClumpGetAssociation(GetClump(), ANIM_IDLE_TIRED);

+				delete RpAnimBlendClumpGetAssociation(GetClump(), ANIM_FIGHT_IDLE);

+				delete curSprintAssoc;

+

+				curSprintAssoc = nil;

+				m_nMoveState = PEDMOVE_WALK;

+			}

+			if (curRunStopAssoc) {

+				delete curRunStopAssoc;

+				RestoreHeadingRate();

+			}

+			if (curRunStopRAssoc) {

+				delete curRunStopRAssoc;

+				RestoreHeadingRate();

+			}

+			if (!curWalkAssoc) {

+				curWalkAssoc = CAnimManager::AddAnimation(GetClump(), m_animGroup, ANIM_WALK);

+				curWalkAssoc->blendAmount = 0.0f;

+			}

+			if (!curRunAssoc) {

+				curRunAssoc = CAnimManager::AddAnimation(GetClump(), m_animGroup, ANIM_RUN);

+				curRunAssoc->blendAmount = 0.0f;

+			}

+			if (curWalkStartAssoc && !(curWalkStartAssoc->IsRunning())) {

+				delete curWalkStartAssoc;

+				curWalkStartAssoc = nil;

+				curWalkAssoc->SetRun();

+				curRunAssoc->SetRun();

+			}

+			if (m_nMoveState == PEDMOVE_SPRINT) {

+				if (m_fCurrentStamina < 0.0f && (m_fCurrentStamina <= -150.0f || !curSprintAssoc || curSprintAssoc->blendDelta < 0.0f))

+					m_nMoveState = PEDMOVE_STILL;

+

+				if (curWalkStartAssoc)

+					m_nMoveState = PEDMOVE_STILL;

+			}

+

+			if (curSprintAssoc && (m_nMoveState != PEDMOVE_SPRINT || m_fMoveSpeed < 0.4f)) {

+				if (curSprintAssoc->blendAmount == 0.0f) {

+					curSprintAssoc->blendDelta = -1000.0f;

+					curSprintAssoc->flags |= ASSOC_DELETEFADEDOUT;

+

+				} else if (curSprintAssoc->blendDelta >= 0.0f || curSprintAssoc->blendAmount >= 0.8f) {

+					if (m_fMoveSpeed < 0.4f) {

+						AnimationId runStopAnim;

+						if (curSprintAssoc->currentTime / curSprintAssoc->hierarchy->totalLength < 0.5) // double

+							runStopAnim = ANIM_RUN_STOP;

+						else

+							runStopAnim = ANIM_RUN_STOP_R;

+						CAnimBlendAssociation* newRunStopAssoc = CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, runStopAnim);

+						newRunStopAssoc->blendAmount = 1.0f;

+						newRunStopAssoc->SetDeleteCallback(RestoreHeadingRateCB, this);

+						m_headingRate = 0.0f;

+						curSprintAssoc->flags |= ASSOC_DELETEFADEDOUT;

+						curSprintAssoc->blendDelta = -1000.0f;

+						curWalkAssoc->flags &= ~ASSOC_RUNNING;

+						curWalkAssoc->blendAmount = 0.0f;

+						curWalkAssoc->blendDelta = 0.0f;

+						curRunAssoc->flags &= ~ASSOC_RUNNING;

+						curRunAssoc->blendAmount = 0.0f;

+						curRunAssoc->blendDelta = 0.0f;

+					} else if (curSprintAssoc->blendDelta < 0.0f) {

+						curSprintAssoc->flags |= ASSOC_DELETEFADEDOUT;

+						curSprintAssoc->blendDelta = -1.0f;

+						curRunAssoc->blendDelta = 1.0f;

+					}

+				} else if (m_fMoveSpeed < 1.0f) {

+					curSprintAssoc->blendDelta = -8.0f;

+					curRunAssoc->blendDelta = 8.0f;

+				}

+			} else if (curWalkStartAssoc) {

+				curWalkAssoc->flags &= ~ASSOC_RUNNING;

+				curRunAssoc->flags &= ~ASSOC_RUNNING;

+				curWalkAssoc->blendAmount = 0.0f;

+				curRunAssoc->blendAmount = 0.0f;

+

+			} else if (m_nMoveState == PEDMOVE_SPRINT) {

+				if (curSprintAssoc) {

+					if (curSprintAssoc->blendDelta < 0.0f) {

+						curSprintAssoc->blendDelta = 2.0f;

+						curRunAssoc->blendDelta = -2.0f;

+					}

+				} else {

+					curWalkAssoc->blendAmount = 0.0f;

+					curRunAssoc->blendAmount = 1.0f;

+					curSprintAssoc = CAnimManager::BlendAnimation(GetClump(), m_animGroup, ANIM_SPRINT, 2.0f);

+				}

+				UseSprintEnergy();

+			} else {

+				if (m_fMoveSpeed < 1.0f) {

+					curWalkAssoc->blendAmount = 1.0f;

+					curRunAssoc->blendAmount = 0.0f;

+					m_nMoveState = PEDMOVE_WALK;

+				} else if (m_fMoveSpeed < 2.0f) {

+					curWalkAssoc->blendAmount = 2.0f - m_fMoveSpeed;

+					curRunAssoc->blendAmount = m_fMoveSpeed - 1.0f;

+					m_nMoveState = PEDMOVE_RUN;

+				} else {

+					curWalkAssoc->blendAmount = 0.0f;

+					curRunAssoc->blendAmount = 1.0f;

+					m_nMoveState = PEDMOVE_RUN;

+				}

+			}

+		}

+	}

+	if (m_bAdrenalineActive) {

+		if (CTimer::GetTimeInMilliseconds() > m_nAdrenalineTime) {

+			m_bAdrenalineActive = false;

+			CTimer::SetTimeScale(1.0f);

+			if (curWalkStartAssoc)

+				curWalkStartAssoc->speed = 1.0f;

+			if (curWalkAssoc)

+				curWalkAssoc->speed = 1.0f;

+			if (curRunAssoc)

+				curRunAssoc->speed = 1.0f;

+			if (curSprintAssoc)

+				curSprintAssoc->speed = 1.0f;

+		} else {

+			CTimer::SetTimeScale(1.0f / 3);

+			if (curWalkStartAssoc)

+				curWalkStartAssoc->speed = 2.0f;

+			if (curWalkAssoc)

+				curWalkAssoc->speed = 2.0f;

+			if (curRunAssoc)

+				curRunAssoc->speed = 2.0f;

+			if (curSprintAssoc)

+				curSprintAssoc->speed = 2.0f;

+		}

+	}

+}
+
 class CPlayerPed_ : public CPlayerPed
 {
 public:
 	CPlayerPed* ctor(void) { return ::new (this) CPlayerPed(); }
 	void dtor(void) { CPlayerPed::~CPlayerPed(); }
+	void SetMoveAnim_(void) { CPlayerPed::SetMoveAnim(); }
 };
 
 STARTPATCHES
 	InjectHook(0x4EF7E0, &CPlayerPed_::ctor, PATCH_JUMP);
 	InjectHook(0x4EFB30, &CPlayerPed_::dtor, PATCH_JUMP);
+	InjectHook(0x4F3760, &CPlayerPed_::SetMoveAnim_, PATCH_JUMP);
 	InjectHook(0x4F28A0, &CPlayerPed::ClearWeaponTarget, PATCH_JUMP);
 	InjectHook(0x4F3700, &CPlayerPed::AnnoyPlayerPed, PATCH_JUMP);
 	InjectHook(0x4F36C0, &CPlayerPed::GetPlayerInfoForThisPlayerPed, PATCH_JUMP);
+	InjectHook(0x4F2560, &CPlayerPed::MakeChangesForNewWeapon, PATCH_JUMP);
+	InjectHook(0x4F07C0, &CPlayerPed::ReApplyMoveAnims, PATCH_JUMP);
+	InjectHook(0x4F0880, &CPlayerPed::SetRealMoveAnim, PATCH_JUMP);
 ENDPATCHES
diff --git a/src/peds/PlayerPed.h b/src/peds/PlayerPed.h
index bd24ecd0..1de1b442 100644
--- a/src/peds/PlayerPed.h
+++ b/src/peds/PlayerPed.h
@@ -41,6 +41,7 @@ public:
 
 	CPlayerPed();
 	~CPlayerPed();
+	void SetMoveAnim() { };
 
 	void ReApplyMoveAnims(void);
 	void ClearWeaponTarget(void);
@@ -50,10 +51,11 @@ public:
 	void AnnoyPlayerPed(bool);
 	void MakeChangesForNewWeapon(int8);
 	void SetInitialState(void);
-	void SetMoveAnim(void);
 	void ProcessControl(void);
 	void ClearAdrenaline(void);
+	void UseSprintEnergy(void);
 	class CPlayerInfo *GetPlayerInfoForThisPlayerPed();
+	void SetRealMoveAnim(void);
 
 	static void SetupPlayerPed(int32);
 	static void DeactivatePlayerPed(int32);