Merge pull request #16 from erorcun/master

Some CPed functions

src/PedStat.h

@@ -0,0 +1,20 @@
+#pragma once
+#include "common.h"
+
+struct PedStat {
+	uint32 m_id;
+	char m_name[24];
+	int32 m_fleeDistance;
+	int32 m_headingChangeRate;
+	int8 m_fear;
+	int8 m_temper;
+	int8 m_lawfulness;
+	int8 m_sexiness;
+	int32 m_attackStrength;
+	int32 m_defendWeakness;
+	int16 m_flags;
+	uint8 unknown1;
+	uint8 unknown2;
+};
+
+static_assert(sizeof(PedStat) == 0x34, "PedStat: error");

src/Stats.cpp

@@ -2,3 +2,4 @@
 #include "Stats.h"
 
 Int32 &CStats::DaysPassed = *(Int32*)0x8F2BB8;
+Int32 &CStats::HeadShots = *(Int32*)0x8F647C;

src/Stats.h

@@ -4,4 +4,5 @@ class CStats
 {
 public:
 	static Int32 &DaysPassed;
+	static Int32 &HeadShots;
 };

src/audio/DMAudio.h

@@ -1,6 +1,6 @@
 #pragma once
 
-enum eSound {
+enum eSound : int16 {
 	SOUND_CAR_DOOR_CLOSE_BONNET = 0,
 	SOUND_CAR_DOOR_CLOSE_BUMPER = 1,
 	SOUND_CAR_DOOR_CLOSE_FRONT_LEFT = 2,
@@ -95,8 +95,8 @@ enum eSound {
 	SOUND_RAMPAGE_FAILED = 91,
 	SOUND_RAMPAGE_KILL = 92,
 	SOUND_RAMPAGE_CAR_BLOWN = 93,
-	SOUND_EVIDENCE_PICKUP = 94,
-	SOUND_UNLOAD_GOLD = 95,
+	_SOUND_EVIDENCE_PICKUP = 94,
+	_SOUND_UNLOAD_GOLD = 95,
 	SOUND_PAGER = 96,
 	SOUND_PED_DEATH = 97,
 	SOUND_PED_DAMAGE = 98,
@@ -140,16 +140,16 @@ enum eSound {
 	SOUND_INJURED_PED_MALE_OUCH = 136,
 	SOUND_INJURED_PED_FEMALE = 137,
 	SOUND_8A = 138,
-	SOUND_RACE_START_3 = 139,
-	SOUND_RACE_START_2 = 140,
-	SOUND_RACE_START_1 = 141,
-	SOUND_RACE_START_GO = 142,
+	_SOUND_RACE_START_3 = 139,
+	_SOUND_RACE_START_2 = 140,
+	_SOUND_RACE_START_1 = 141,
+	_SOUND_RACE_START_GO = 142,
 	SOUND_SPLASH = 143,
 	SOUND_WATER_FALL = 144,
 	SOUND_SPLATTER = 145,
 	SOUND_CAR_PED_COLLISION = 146,
 	SOUND_CLOCK_TICK = 147,
-	SOUND_PART_MISSION_COMPLETE = 148,
+	_SOUND_PART_MISSION_COMPLETE = 148,
 	SOUND_FRONTEND_MENU_STARTING = 149,
 	SOUND_FRONTEND_MENU_COMPLETED = 150,
 	SOUND_FRONTEND_MENU_DENIED = 151,

src/entities/Ped.cpp

@@ -2,6 +2,9 @@
 #include "patcher.h"
 #include "Ped.h"
 #include "Pools.h"
+#include "Particle.h"
+#include "Stats.h"
+#include "World.h"
 
 Bool &CPed::bNastyLimbsCheat = *(Bool*)0x95CD44;
 Bool &CPed::bPedCheat2 = *(Bool*)0x95CD5A;
@@ -11,6 +14,9 @@ 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); }
 
 WRAPPER void CPed::KillPedWithCar(CVehicle *veh, float impulse) { EAXJMP(0x4EC430); }
+WRAPPER void CPed::Say(eSound audio) { EAXJMP(0x4E5A10); }
+WRAPPER void CPed::SetDie(AnimationId anim, float arg1, float arg2) { EAXJMP(0x4D37D0); }
+WRAPPER void CPed::SpawnFlyingComponent(int, signed char) { EAXJMP(0x4EB060); }
 
 static char ObjectiveText[34][28] = {
 	"No Obj",
@@ -175,3 +181,246 @@ CPed::UseGroundColModel(void)
 		m_nPedState == PED_DIE ||
 		m_nPedState == PED_DEAD;
 }
+
+void
+CPed::AddWeaponModel(int id)
+{
+	RpAtomic* atm;
+
+	if (id != -1) {
+		atm = (RpAtomic*)CModelInfo::GetModelInfo(id)->CreateInstance();
+		RwFrameDestroy(RpAtomicGetFrame(atm));
+		RpAtomicSetFrame(atm, GetNodeFrame(PED_HANDR));
+		RpClumpAddAtomic((RpClump*)m_rwObject, atm);
+		m_wepModelID = id;
+	}
+}
+
+void
+CPed::AimGun()
+{
+	RwV3d pos;
+	CVector vector;
+
+	if (m_pSeekTarget) {
+		if (m_pSeekTarget->m_status == STATUS_PHYSICS) {
+			m_pSeekTarget->m_pedIK.GetComponentPosition(&pos, 1);
+			vector.x = pos.x;
+			vector.y = pos.y;
+			vector.z = pos.z;
+		} else {
+			vector = *(m_pSeekTarget->GetPosition());
+		}
+		CPed::Say(SOUND_PED_ATTACK);
+
+		m_ped_flagB2 = m_pedIK.PointGunAtPosition(&vector);
+		if (m_pPedFight != m_pSeekTarget) {
+			CPed::SetLookFlag(m_pSeekTarget, 1);
+		}
+
+	} else {
+		if (CPed::IsPlayer()) {
+			m_ped_flagB2 = m_pedIK.PointGunInDirection(m_fLookDirection, ((CPlayerPed*)this)->m_fFPSMoveHeading);
+		} else {
+			m_ped_flagB2 = m_pedIK.PointGunInDirection(m_fLookDirection, 0.0f);
+		}
+	}
+}
+
+
+// After I finished this I realized it's only for SCM opcode...
+void
+CPed::ApplyHeadShot(eWeaponType weaponType, CVector pos, bool evenOnPlayer)
+{
+	CVector pos2 = CVector(
+		pos.x,
+		pos.y,
+		pos.z + 0.1f
+	);
+
+	if (!CPed::IsPlayer() || evenOnPlayer) {
+		++CStats::HeadShots;
+
+		// BUG: This condition will always return true.
+		if (m_nPedState != PED_PASSENGER || m_nPedState != PED_TAXI_PASSENGER) {
+			CPed::SetDie(ANIM_KO_SHOT_FRONT1, 4.0f, 0.0f);
+		}
+
+		m_ped_flagC20 = 1;
+		m_nPedStateTimer = CTimer::GetTimeInMilliseconds() + 150;
+
+		CParticle::AddParticle(PARTICLE_TEST, pos2,
+								CVector(
+									0.0f,
+									0.0f,
+									0.0f
+								), NULL, 0.2f, 0, 0, 0, 0);
+
+		if (CEntity::GetIsOnScreen()) {
+			for(int i=0; i < 32; i++) {
+				CParticle::AddParticle(PARTICLE_BLOOD_SMALL,
+										pos2,
+										CVector(
+											0.0f,
+											0.0f,
+											0.03f
+										), NULL, 0.0f, 0, 0, 0, 0);
+			}
+
+			for (int i = 0; i < 16; i++) {
+				CParticle::AddParticle(PARTICLE_DEBRIS2,
+										pos2,
+										CVector(
+											0.0f,
+											0.0f,
+											0.01f
+										), NULL, 0.0f, 0, 0, 0, 0);
+			}
+		}
+	}
+}
+
+void
+CPed::RemoveBodyPart(PedNode nodeId, char arg4)
+{
+	RwFrame *frame;
+	RwFrame *fp;
+	RwV3d zero;
+
+	frame = GetNodeFrame(nodeId);
+	if (frame) {
+		if (CGame::nastyGame) {
+			if (nodeId != PED_HEAD)
+				CPed::SpawnFlyingComponent(nodeId, arg4);
+
+			RecurseFrameChildrenVisibilityCB(frame, 0);
+			zero.x = 0.0f;
+			zero.z = 0.0f;
+			zero.y = 0.0f;
+			for (fp = RwFrameGetParent(frame); fp; fp = RwFrameGetParent(frame))
+				RwV3dTransformPoints(&zero, &zero, 1, &fp->modelling);
+
+			if (CEntity::GetIsOnScreen()) {
+				CParticle::AddParticle(PARTICLE_TEST, zero,
+					CVector(
+						0.0f,
+						0.0f,
+						0.0f
+					), NULL, 0.2f, 0, 0, 0, 0);
+
+				for (int i = 0; i < 16; i++) {
+					CParticle::AddParticle(PARTICLE_BLOOD_SMALL,
+						zero,
+						CVector(
+							0.0f,
+							0.0f,
+							0.03f
+						), NULL, 0.0f, 0, 0, 0, 0);
+				}
+			}
+			m_ped_flagC20 = 1;
+			m_bodyPartBleeding = nodeId;
+		}
+	} else {
+		printf("Trying to remove ped component");
+	}
+}
+
+RwObject*
+CPed::SetPedAtomicVisibilityCB(RwObject *object, void *data)
+{
+	RwObject *result = object;
+	if (!data)
+		RpAtomicSetFlags(object, 0);
+
+	return result;
+}
+
+RwFrame*
+CPed::RecurseFrameChildrenVisibilityCB(RwFrame *frame, void *data)
+{
+	RwFrameForAllObjects(frame, SetPedAtomicVisibilityCB, data);
+	RwFrameForAllChildren(frame, RecurseFrameChildrenVisibilityCB, 0);
+	return frame;
+}
+
+void
+CPed::SetLookFlag(CPed *to, bool set)
+{
+	if (m_lookTimer < CTimer::GetTimeInMilliseconds()) {
+		m_ped_flagA10 = 1;
+		m_ped_flagA40 = 0;
+		m_pPedFight = to;
+		m_pPedFight->RegisterReference((CEntity**)&m_pPedFight);
+		m_fLookDirection = 999999.0f;
+		m_lookTimer = 0;
+		m_ped_flagA20_look = set;
+		if (m_nPedState != PED_DRIVING) {
+			m_pedIK.m_flags &= ~(1 << 2);
+		}
+	}
+}
+
+void
+CPed::SetLookFlag(float angle, bool set)
+{
+	if (m_lookTimer < CTimer::GetTimeInMilliseconds()) {
+		m_ped_flagA10 = 1;
+		m_ped_flagA40 = 0;
+		m_pPedFight = 0;
+		m_fLookDirection = angle;
+		m_lookTimer = 0;
+		m_ped_flagA20_look = set;
+		if (m_nPedState != PED_DRIVING) {
+			m_pedIK.m_flags &= ~(1 << 2);
+		}
+	}
+}
+
+void
+CPed::SetLookTimer(int time)
+{
+	if (CTimer::GetTimeInMilliseconds() > m_lookTimer) {
+		m_lookTimer = CTimer::GetTimeInMilliseconds() + time;
+	}
+}
+
+bool
+CPed::OurPedCanSeeThisOne(CEntity* who)
+{
+	float xDiff;
+	float yDiff;
+	float distance;
+	CColPoint colpoint;
+	CEntity* ent;
+	CVector ourPos;
+	CVector itsPos;
+
+	ourPos = this->GetPosition();
+	itsPos = who->GetPosition();
+
+	xDiff = itsPos.x - ourPos.x;
+	yDiff = itsPos.y - ourPos.y;
+
+	if ((yDiff * this->GetUp().y) + (xDiff * this->GetUp().x) < 0.0f)
+		return 0;
+
+	distance = sqrt(yDiff * yDiff + xDiff * xDiff);
+
+	if (distance < 40.0f)
+		return 0;
+
+	ourPos.z += 1.0f;
+	return CWorld::ProcessLineOfSight(ourPos, itsPos, colpoint, ent, 1, 0, 0, 0, 0, 0, 0) == 0;
+}
+
+STARTPATCHES
+	InjectHook(0x4CF8F0, &CPed::AddWeaponModel, PATCH_JUMP);
+	InjectHook(0x4C6AA0, &CPed::AimGun, PATCH_JUMP);
+	InjectHook(0x4EB470, &CPed::ApplyHeadShot, PATCH_JUMP);
+	InjectHook(0x4EAEE0, &CPed::RemoveBodyPart, PATCH_JUMP);
+	InjectHook(0x4C6460, (void (CPed::*)(CPed*, bool)) &CPed::SetLookFlag, PATCH_JUMP);
+	InjectHook(0x4C63E0, (void (CPed::*)(float, bool)) &CPed::SetLookFlag, PATCH_JUMP);
+	InjectHook(0x4D12E0, &CPed::SetLookTimer, PATCH_JUMP);
+	InjectHook(0x4C5700, &CPed::OurPedCanSeeThisOne, PATCH_JUMP);
+ENDPATCHES

src/entities/Ped.h

@@ -3,6 +3,11 @@
 #include "Physical.h"
 #include "Weapon.h"
 #include "PathFind.h"
+#include "PedIK.h"
+#include "AnimManager.h"
+#include "AnimBlendClumpData.h"
+#include "PedStat.h"
+#include "DMAudio.h"
 
 enum {
 	PED_MAX_WEAPONS = 13
@@ -93,7 +98,7 @@ public:
 	uint8 m_ped_flagA4 : 1;
 	uint8 m_ped_flagA8 : 1;
 	uint8 m_ped_flagA10 : 1;
-	uint8 m_ped_flagA20 : 1;
+	uint8 m_ped_flagA20_look : 1;
 	uint8 m_ped_flagA40 : 1;
 	uint8 m_ped_flagA80 : 1;
 	uint8 m_ped_flagB1 : 1;
@@ -160,7 +165,19 @@ public:
 	uint8 m_ped_flagI20 : 1;
 	uint8 m_ped_flagI40 : 1;
 	uint8 m_ped_flagI80 : 1;
-	uint8 stuff1[199];
+	uint8 stuff10[15];
+	int32 m_field_16C;
+	uint8 stuff12[44];
+	int32 m_pEventEntity;
+	float m_fAngleToEvent;
+	AnimBlendFrameData *m_pFrames[PED_NODE_MAX];
+	int32 m_animGroup;
+	int32 m_pVehicleAnim;
+	CVector2D m_vecAnimMoveDelta;
+	CVector m_vecOffsetSeek;
+	CPedIK m_pedIK; 
+	uint8 stuff1[8];
+	uint32 m_nPedStateTimer;
 	int32 m_nPedState;
 	int32 m_nLastPedState;
 	int32 m_nMoveState;
@@ -185,27 +202,57 @@ public:
 	CEntity *m_pCurrentPhysSurface;
 	CVector m_vecOffsetFromPhysSurface;
 	CEntity *m_pCurSurface;
-	uint8 stuff3[16];
+	uint8 stuff3[12];
+	CPed* m_pSeekTarget;
 	CVehicle *m_pMyVehicle;
 	Bool bInVehicle;
 	uint8 stuff4[23];
 	int32 m_nPedType;
-
-	uint8 stuff5[28];
+	PedStat *m_pedStats;
+	uint8 stuff5[24];
 	CEntity *m_pCollidingEntity;
 	uint8 stuff6[12];
 	CWeapon m_weapons[PED_MAX_WEAPONS];
 	int32 stuff7;
 	uint8 m_currentWeapon;
-	uint8 stuff[163];
+	uint8 stuff[3];
+	int32 m_pPointGunAt;
+	CVector m_vecHitLastPos;
+	uint8 stuff8[12];
+	CPed *m_pPedFight;
+	float m_fLookDirection;
+	int32 m_wepModelID;
+	uint32 m_leaveCarTimer;
+	uint32 m_getUpTimer;
+	uint32 m_lookTimer;
+	uint8 stuff9[34];
+	uint8 m_bodyPartBleeding;
+	uint8 m_field_4F3;
+	CPed *m_nearPeds[10];
+	uint8 stuff11[32];
 
 	static void *operator new(size_t);
 	static void operator delete(void*, size_t);
 
 	bool IsPlayer(void) { return m_nPedType == 0 || m_nPedType== 1 || m_nPedType == 2 || m_nPedType == 3; }
 	bool UseGroundColModel(void);
+	void AddWeaponModel(int id);
+	void AimGun();
 	void KillPedWithCar(CVehicle *veh, float impulse);
+	void Say(eSound audio);
+	void SetLookFlag(CPed *to, bool set);
+	void SetLookFlag(float angle, bool set);
+	void SetLookTimer(int time);
+	void SetDie(AnimationId anim, float arg1, float arg2);
+	void ApplyHeadShot(eWeaponType weaponType, CVector pos, bool evenOnPlayer);
+	void RemoveBodyPart(PedNode nodeId, char arg4);
+	void SpawnFlyingComponent(int, signed char);
+	bool OurPedCanSeeThisOne(CEntity* who);
+	static RwObject *SetPedAtomicVisibilityCB(RwObject *object, void *data);
+	static RwFrame *RecurseFrameChildrenVisibilityCB(RwFrame *frame, void *data);
+
 	CWeapon *GetWeapon(void) { return &m_weapons[m_currentWeapon]; }
+	RwFrame* GetNodeFrame(int nodeId) { return m_pFrames[nodeId]->frame; }
 
 	static Bool &bNastyLimbsCheat;
 	static Bool &bPedCheat2;
@@ -218,4 +265,8 @@ static_assert(offsetof(CPed, m_nPedType) == 0x32C, "CPed: error");
 static_assert(offsetof(CPed, m_pCollidingEntity) == 0x34C, "CPed: error");
 static_assert(offsetof(CPed, m_weapons) == 0x35C, "CPed: error");
 static_assert(offsetof(CPed, m_currentWeapon) == 0x498, "CPed: error");
+static_assert(offsetof(CPed, m_lookTimer) == 0x4CC, "CPed: error");
+static_assert(offsetof(CPed, m_bodyPartBleeding) == 0x4F2, "CPed: error");
+static_assert(offsetof(CPed, m_field_16C) == 0x16C, "CPed: error");
+static_assert(offsetof(CPed, m_pEventEntity) == 0x19C, "CPed: error");
 static_assert(sizeof(CPed) == 0x53C, "CPed: error");

src/entities/PedIK.cpp

@@ -0,0 +1,7 @@
+#include "common.h"
+#include "patcher.h"
+#include "Ped.h"
+
+WRAPPER void CPedIK::GetComponentPosition(RwV3d* pos, int id) { EAXJMP(0x4ED0F0); }
+WRAPPER bool CPedIK::PointGunInDirection(float phi, float theta) { EAXJMP(0x4ED9B0); }
+WRAPPER bool CPedIK::PointGunAtPosition(CVector* position) { EAXJMP(0x4ED920); }

src/entities/PedIK.h

@@ -0,0 +1,26 @@
+#pragma once
+#include "common.h"
+
+struct LimbOrientation
+{
+	float phi;
+	float theta;
+};
+
+class CPed;
+
+class CPedIK
+{
+public:
+	CPed* m_ped;
+	LimbOrientation m_headOrient;
+	LimbOrientation m_torsoOrient;
+	LimbOrientation m_upperArmOrient;
+	LimbOrientation m_lowerArmOrient;
+	int32 m_flags;
+
+	void GetComponentPosition(RwV3d* pos, int id);
+	bool PointGunInDirection(float phi, float theta);
+	bool PointGunAtPosition(CVector* position);
+};
+static_assert(sizeof(CPedIK) == 0x28, "CPedIK: error");

src/modelinfo/PedModelInfo.h

@@ -15,8 +15,7 @@ enum PedNode {
 	PED_FOOTL,
 	PED_FOOTR,
 	PED_LOWERLEGR,
-	// This is not valid apparently
-	PED_LOWERLEGL,
+	PED_NODE_MAX// Not valid: PED_LOWERLEGL
 };
 
 class CPedModelInfo : public CClumpModelInfo