mirror of
https://gitlab.com/GaryOderNichts/re3-wiiu.git
synced 2024-11-25 02:26:52 +01:00
458 lines
10 KiB
C++
458 lines
10 KiB
C++
#include "common.h"
|
|
#include "patcher.h"
|
|
#include "Pools.h"
|
|
#include "Particle.h"
|
|
#include "Stats.h"
|
|
#include "World.h"
|
|
#include "DMaudio.h"
|
|
#include "Ped.h"
|
|
#include "PedType.h"
|
|
#include "General.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); }
|
|
|
|
WRAPPER void CPed::KillPedWithCar(CVehicle *veh, float impulse) { EAXJMP(0x4EC430); }
|
|
WRAPPER void CPed::Say(uint16 audio) { EAXJMP(0x4E5A10); }
|
|
WRAPPER void CPed::SetDie(AnimationId anim, float arg1, float arg2) { EAXJMP(0x4D37D0); }
|
|
WRAPPER void CPed::SpawnFlyingComponent(int, int8) { EAXJMP(0x4EB060); }
|
|
|
|
static char ObjectiveText[34][28] = {
|
|
"No Obj",
|
|
"Wait on Foot",
|
|
"Flee on Foot Till Safe",
|
|
"Guard Spot",
|
|
"Guard Area",
|
|
"Wait in Car",
|
|
"Wait in Car then Getout",
|
|
"Kill Char on Foot",
|
|
"Kill Char Any Means",
|
|
"Flee Char on Foot Till Safe",
|
|
"Flee Char on Foot Always",
|
|
"GoTo Char on Foot",
|
|
"Follow Char in Formation",
|
|
"Leave Car",
|
|
"Enter Car as Passenger",
|
|
"Enter Car as Driver",
|
|
"Follow Car in Car",
|
|
"Fire at Obj from Vehicle",
|
|
"Destroy Obj",
|
|
"Destroy Car",
|
|
"GoTo Area Any Means",
|
|
"GoTo Area on Foot",
|
|
"Run to Area",
|
|
"GoTo Area in Car",
|
|
"Follow Car on Foot Woffset",
|
|
"Guard Attack",
|
|
"Set Leader",
|
|
"Follow Route",
|
|
"Solicit",
|
|
"Take Taxi",
|
|
"Catch Train",
|
|
"Buy IceCream",
|
|
"Steal Any Car",
|
|
"Mug Char",
|
|
};
|
|
|
|
static char StateText[56][18] = {
|
|
"None", // 1
|
|
"Idle",
|
|
"Look Entity",
|
|
"Look Heading",
|
|
"Wander Range",
|
|
"Wander Path",
|
|
"Seek Pos",
|
|
"Seek Entity",
|
|
"Flee Pos",
|
|
"Flee Entity",
|
|
"Pursue",
|
|
"Follow Path",
|
|
"Sniper Mode",
|
|
"Rocket Mode",
|
|
"Dummy",
|
|
"Pause",
|
|
"Attack",
|
|
"Fight",
|
|
"Face Phone",
|
|
"Make Call",
|
|
"Chat",
|
|
"Mug",
|
|
"AimGun",
|
|
"AI Control",
|
|
"Seek Car",
|
|
"Seek InBoat",
|
|
"Follow Route",
|
|
"C.P.R.",
|
|
"Solicit",
|
|
"Buy IceCream",
|
|
"Investigate",
|
|
"Step away",
|
|
"STATES_NO_AI",
|
|
"On Fire",
|
|
"Jump",
|
|
"Fall",
|
|
"GetUp",
|
|
"Stagger",
|
|
"Dive away",
|
|
"STATES_NO_ST",
|
|
"Enter Train",
|
|
"Exit Train",
|
|
"Arrest Plyr",
|
|
"Driving",
|
|
"Passenger",
|
|
"Taxi Passngr",
|
|
"Open Door",
|
|
"Die",
|
|
"Dead",
|
|
"CarJack",
|
|
"Drag fm Car",
|
|
"Enter Car",
|
|
"Steal Car",
|
|
"Exit Car",
|
|
"Hands Up",
|
|
"Arrested",
|
|
};
|
|
|
|
static char PersonalityTypeText[32][18] = {
|
|
"Player",
|
|
"Cop",
|
|
"Medic",
|
|
"Fireman",
|
|
"Gang 1",
|
|
"Gang 2",
|
|
"Gang 3",
|
|
"Gang 4",
|
|
"Gang 5",
|
|
"Gang 6",
|
|
"Gang 7",
|
|
"Street Guy",
|
|
"Suit Guy",
|
|
"Sensible Guy",
|
|
"Geek Guy",
|
|
"Old Guy",
|
|
"Tough Guy",
|
|
"Street Girl",
|
|
"Suit Girl",
|
|
"Sensible Girl",
|
|
"Geek Girl",
|
|
"Old Girl",
|
|
"Tough Girl",
|
|
"Tramp",
|
|
"Tourist",
|
|
"Prostitute",
|
|
"Criminal",
|
|
"Busker",
|
|
"Taxi Driver",
|
|
"Psycho",
|
|
"Steward",
|
|
"Sports Fan",
|
|
};
|
|
|
|
static char WaitStateText[21][16] = {
|
|
"No Wait",
|
|
"Traffic Lights",
|
|
"Pause CrossRoad",
|
|
"Look CrossRoad",
|
|
"Look Ped",
|
|
"Look Shop",
|
|
"Look Accident",
|
|
"FaceOff Gang",
|
|
"Double Back",
|
|
"Hit Wall",
|
|
"Turn 180deg",
|
|
"Surprised",
|
|
"Ped Stuck",
|
|
"Look About",
|
|
"Play Duck",
|
|
"Play Cower",
|
|
"Play Taxi",
|
|
"Play HandsUp",
|
|
"Play HandsCower",
|
|
"Play Chat",
|
|
"Finish Flee",
|
|
};
|
|
|
|
bool
|
|
CPed::IsPlayer(void)
|
|
{
|
|
return m_nPedType == PEDTYPE_PLAYER1 || m_nPedType== PEDTYPE_PLAYER2 ||
|
|
m_nPedType == PEDTYPE_PLAYER3 || m_nPedType == PEDTYPE_PLAYER4;
|
|
}
|
|
|
|
bool
|
|
CPed::UseGroundColModel(void)
|
|
{
|
|
return m_nPedState == PED_FALL ||
|
|
m_nPedState == PED_DIVE_AWAY ||
|
|
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);
|
|
|
|
bCanPointGunAtTarget = m_pedIK.PointGunAtPosition(&vector);
|
|
if (m_pLookTarget != m_pSeekTarget) {
|
|
CPed::SetLookFlag(m_pSeekTarget, 1);
|
|
}
|
|
|
|
} else {
|
|
if (CPed::IsPlayer()) {
|
|
bCanPointGunAtTarget = m_pedIK.PointGunInDirection(m_fLookDirection, ((CPlayerPed*)this)->m_fFPSMoveHeading);
|
|
} else {
|
|
bCanPointGunAtTarget = m_pedIK.PointGunInDirection(m_fLookDirection, 0.0f);
|
|
}
|
|
}
|
|
}
|
|
|
|
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), nil, 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),
|
|
nil, 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),
|
|
nil, 0.0f, 0, 0, 0, 0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
CPed::RemoveBodyPart(PedNode nodeId, int8 unk)
|
|
{
|
|
RwFrame *frame;
|
|
RwFrame *fp;
|
|
RwV3d zero;
|
|
|
|
frame = GetNodeFrame(nodeId);
|
|
if (frame) {
|
|
if (CGame::nastyGame) {
|
|
if (nodeId != PED_HEAD)
|
|
CPed::SpawnFlyingComponent(nodeId, unk);
|
|
|
|
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),
|
|
nil, 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),
|
|
nil, 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)
|
|
{
|
|
if (data == 0)
|
|
RpAtomicSetFlags(object, 0);
|
|
return object;
|
|
}
|
|
|
|
RwFrame*
|
|
CPed::RecurseFrameChildrenVisibilityCB(RwFrame *frame, void *data)
|
|
{
|
|
RwFrameForAllObjects(frame, SetPedAtomicVisibilityCB, data);
|
|
RwFrameForAllChildren(frame, RecurseFrameChildrenVisibilityCB, 0);
|
|
return frame;
|
|
}
|
|
|
|
void
|
|
CPed::SetLookFlag(CPed *target, bool unknown)
|
|
{
|
|
if (m_lookTimer < CTimer::GetTimeInMilliseconds()) {
|
|
bIsLooking = true;
|
|
bIsRestoringLook = false;
|
|
m_pLookTarget = target;
|
|
m_pLookTarget->RegisterReference((CEntity**)&m_pLookTarget);
|
|
m_fLookDirection = 999999.0f;
|
|
m_lookTimer = 0;
|
|
m_ped_flagA20_look = unknown;
|
|
if (m_nPedState != PED_DRIVING) {
|
|
m_pedIK.m_flags &= ~CPedIK::FLAG_2;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
CPed::SetLookFlag(float direction, bool unknown)
|
|
{
|
|
if (m_lookTimer < CTimer::GetTimeInMilliseconds()) {
|
|
bIsLooking = true;
|
|
bIsRestoringLook = false;
|
|
m_pLookTarget = nil;
|
|
m_fLookDirection = direction;
|
|
m_lookTimer = 0;
|
|
m_ped_flagA20_look = unknown;
|
|
if (m_nPedState != PED_DRIVING) {
|
|
m_pedIK.m_flags &= ~CPedIK::FLAG_2;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
CPed::SetLookTimer(int time)
|
|
{
|
|
if (CTimer::GetTimeInMilliseconds() > m_lookTimer) {
|
|
m_lookTimer = CTimer::GetTimeInMilliseconds() + time;
|
|
}
|
|
}
|
|
|
|
bool
|
|
CPed::OurPedCanSeeThisOne(CEntity *target)
|
|
{
|
|
CColPoint colpoint;
|
|
CEntity *ent;
|
|
|
|
CVector2D dist = CVector2D(target->GetPosition()) - CVector2D(this->GetPosition());
|
|
|
|
// Check if target is behind ped
|
|
if (DotProduct2D(dist, CVector2D(this->GetForward())) < 0.0f)
|
|
return 0;
|
|
|
|
// Check if target is too far away
|
|
if (dist.Magnitude() < 40.0f)
|
|
return 0;
|
|
|
|
// Check line of sight from head
|
|
CVector headPos = this->GetPosition();
|
|
headPos.z += 1.0f;
|
|
return !CWorld::ProcessLineOfSight(headPos, target->GetPosition(), colpoint, ent, true, false, false, false, false, false);
|
|
}
|
|
|
|
void
|
|
CPed::Avoid(void)
|
|
{
|
|
CPed *nearestPed;
|
|
|
|
if(m_pedStats->m_temper > m_pedStats->m_fear && m_pedStats->m_temper > 50)
|
|
return;
|
|
|
|
if (CTimer::GetTimeInMilliseconds() > m_nPedStateTimer) {
|
|
|
|
if (m_nMoveState != PEDMOVE_NONE && m_nMoveState != PEDMOVE_STILL) {
|
|
nearestPed = m_nearPeds[0];
|
|
|
|
if (nearestPed && nearestPed->m_nPedState != PED_DEAD && nearestPed != m_pSeekTarget && nearestPed != m_field_16C) {
|
|
|
|
// Check if this ped wants to avoid the nearest one
|
|
if (CPedType::GetAvoid(this->m_nPedType) & CPedType::GetFlag(nearestPed->m_nPedType)) {
|
|
|
|
// Further codes checks whether the distance between us and ped will be equal or below 1.0, if we walk up to him by 1.25 meters.
|
|
// If so, we want to avoid it, so we turn our body 45 degree and look to somewhere else.
|
|
|
|
// Game converts from radians to degress and back again here, doesn't make much sense
|
|
CVector2D forward(-sin(m_fRotationCur), cos(m_fRotationCur));
|
|
forward.Normalise(); // this is kinda pointless
|
|
|
|
// Move forward 1.25 meters
|
|
CVector2D testPosition = CVector2D(GetPosition()) + forward*1.25f;
|
|
|
|
// Get distance to ped we want to avoid
|
|
CVector2D distToPed = CVector2D(nearestPed->GetPosition()) - testPosition;
|
|
|
|
if (distToPed.Magnitude() <= 1.0f && CPed::OurPedCanSeeThisOne((CEntity*)nearestPed)) {
|
|
m_nPedStateTimer = CTimer::GetTimeInMilliseconds()
|
|
+ 500 + (m_randomSeed + 3 * CTimer::GetFrameCounter())
|
|
% 1000 / 5;
|
|
|
|
m_fRotationDest += DEGTORAD(45.0f);
|
|
if (!bIsLooking) {
|
|
CPed::SetLookFlag(nearestPed, 0);
|
|
CPed::SetLookTimer(CGeneral::GetRandomNumberInRange(0, 300) + 500);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
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);
|
|
InjectHook(0x4D2BB0, &CPed::Avoid, PATCH_JUMP);
|
|
ENDPATCHES
|