summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorerorcun <erayorcunus@gmail.com>2019-12-23 23:29:00 +0100
committerGitHub <noreply@github.com>2019-12-23 23:29:00 +0100
commit458ae30b6f4d3beb1cc2db1538b1659578b588bd (patch)
tree32108d0204bd8d51c203fb9d553c52df816befbf
parentMerge pull request #281 from erorcun/erorcun (diff)
parentCEmergencyPed done (diff)
downloadre3-458ae30b6f4d3beb1cc2db1538b1659578b588bd.tar
re3-458ae30b6f4d3beb1cc2db1538b1659578b588bd.tar.gz
re3-458ae30b6f4d3beb1cc2db1538b1659578b588bd.tar.bz2
re3-458ae30b6f4d3beb1cc2db1538b1659578b588bd.tar.lz
re3-458ae30b6f4d3beb1cc2db1538b1659578b588bd.tar.xz
re3-458ae30b6f4d3beb1cc2db1538b1659578b588bd.tar.zst
re3-458ae30b6f4d3beb1cc2db1538b1659578b588bd.zip
Diffstat (limited to '')
-rw-r--r--src/control/AccidentManager.cpp16
-rw-r--r--src/control/AccidentManager.h1
-rw-r--r--src/peds/EmergencyPed.cpp436
-rw-r--r--src/peds/EmergencyPed.h34
4 files changed, 456 insertions, 31 deletions
diff --git a/src/control/AccidentManager.cpp b/src/control/AccidentManager.cpp
index 46d254fc..a42280b7 100644
--- a/src/control/AccidentManager.cpp
+++ b/src/control/AccidentManager.cpp
@@ -8,7 +8,8 @@ CAccidentManager& gAccidentManager = *(CAccidentManager*)0x87FD10;
WRAPPER void CAccidentManager::Update(void) { EAXJMP(0x456710); }
-uint16 CAccidentManager::CountActiveAccidents()
+uint16
+CAccidentManager::CountActiveAccidents()
{
uint16 accidents = 0;
for (int i = 0; i < NUM_ACCIDENTS; i++){
@@ -18,7 +19,8 @@ uint16 CAccidentManager::CountActiveAccidents()
return accidents;
}
-CAccident* CAccidentManager::FindNearestAccident(CVector vecPos, float* pDistance)
+CAccident*
+CAccidentManager::FindNearestAccident(CVector vecPos, float* pDistance)
{
for (int i = 0; i < MAX_MEDICS_TO_ATTEND_ACCIDENT; i++){
int accidentId = -1;
@@ -44,4 +46,14 @@ CAccident* CAccidentManager::FindNearestAccident(CVector vecPos, float* pDistanc
return &m_aAccidents[accidentId];
}
return nil;
+}
+
+bool
+CAccidentManager::UnattendedAccidents(void)
+{
+ for (int i = 0; i < NUM_ACCIDENTS; i++) {
+ if (m_aAccidents[i].m_pVictim && m_aAccidents[i].m_nMedicsAttending == 0)
+ return true;
+ }
+ return false;
} \ No newline at end of file
diff --git a/src/control/AccidentManager.h b/src/control/AccidentManager.h
index 6d7f25c8..6a3088e7 100644
--- a/src/control/AccidentManager.h
+++ b/src/control/AccidentManager.h
@@ -21,6 +21,7 @@ class CAccidentManager
};
public:
uint16 CountActiveAccidents();
+ bool UnattendedAccidents();
CAccident* FindNearestAccident(CVector, float*);
void Update(void);
};
diff --git a/src/peds/EmergencyPed.cpp b/src/peds/EmergencyPed.cpp
index cbcfb403..ae430c94 100644
--- a/src/peds/EmergencyPed.cpp
+++ b/src/peds/EmergencyPed.cpp
@@ -2,37 +2,429 @@
#include "patcher.h"
#include "EmergencyPed.h"
#include "ModelIndices.h"
-
-class CEmergencyPed_ : public CEmergencyPed
-{
-public:
- CEmergencyPed *ctor(int pedtype) { return ::new (this) CEmergencyPed(pedtype); };
- void dtor(void) { CEmergencyPed::~CEmergencyPed(); }
-};
-
-WRAPPER void CEmergencyPed::ProcessControl(void) { EAXJMP(0x4C2F10); }
+#include "Vehicle.h"
+#include "Fire.h"
+#include "General.h"
+#include "CarCtrl.h"
+#include "AccidentManager.h"
CEmergencyPed::CEmergencyPed(uint32 type) : CPed(type)
{
switch (type){
- case PEDTYPE_EMERGENCY:
- SetModelIndex(MI_MEDIC);
- m_pRevivedPed = nil;
- field_1360 = 0;
- break;
- case PEDTYPE_FIREMAN:
- SetModelIndex(MI_FIREMAN);
- m_pRevivedPed = nil;
- break;
- default:
- break;
+ case PEDTYPE_EMERGENCY:
+ SetModelIndex(MI_MEDIC);
+ m_pRevivedPed = nil;
+ field_1360 = 0;
+ break;
+ case PEDTYPE_FIREMAN:
+ SetModelIndex(MI_FIREMAN);
+ m_pRevivedPed = nil;
+ break;
+ default:
+ break;
}
- m_nEmergencyPedState = 0;
+ m_nEmergencyPedState = EMERGENCY_PED_READY;
m_pAttendedAccident = nil;
- field_1356 = 0;
+ m_bStartedToCPR = false;
+}
+
+bool
+CEmergencyPed::InRange(CPed *victim)
+{
+ if (!m_pMyVehicle)
+ return true;
+
+ if ((m_pMyVehicle->GetPosition() - victim->GetPosition()).Magnitude() > 30.0f)
+ return false;
+
+ return true;
}
+void
+CEmergencyPed::ProcessControl(void)
+{
+ if (m_nZoneLevel > LEVEL_NONE && m_nZoneLevel != CCollision::ms_collisionInMemory)
+ return;
+
+ CPed::ProcessControl();
+ if (bWasPostponed)
+ return;
+
+ if(!DyingOrDead()) {
+ GetWeapon()->Update(m_audioEntityId);
+
+ if (IsPedInControl() && m_moved.Magnitude() > 0.0f)
+ Avoid();
+
+ switch (m_nPedState) {
+ case PED_SEEK_POS:
+ Seek();
+ break;
+ case PED_SEEK_ENTITY:
+ if (m_pSeekTarget) {
+ m_vecSeekPos = m_pSeekTarget->GetPosition();
+ Seek();
+ } else {
+ ClearSeek();
+ }
+ break;
+ default:
+ break;
+ }
+
+ switch (m_nPedType) {
+ case PEDTYPE_EMERGENCY:
+ if (IsPedInControl() || m_nPedState == PED_DRIVING)
+ MedicAI();
+ break;
+ case PEDTYPE_FIREMAN:
+ if (IsPedInControl())
+ FiremanAI();
+ break;
+ default:
+ return;
+ }
+ }
+}
+
+// This function was buggy and incomplete in both III and VC, firemen had to be in 5.0m range of fire etc. etc.
+// Copied some code from MedicAI to make it work.
+void
+CEmergencyPed::FiremanAI(void)
+{
+ float fireDist;
+ CFire *nearestFire;
+
+ switch (m_nEmergencyPedState) {
+ case EMERGENCY_PED_READY:
+ nearestFire = gFireManager.FindNearestFire(GetPosition(), &fireDist);
+ if (nearestFire) {
+ m_nPedState = PED_NONE;
+ SetSeek(nearestFire->m_vecPos, 1.0f);
+ SetMoveState(PEDMOVE_RUN);
+ m_nEmergencyPedState = EMERGENCY_PED_DETERMINE_NEXT_STATE;
+ m_pAttendedFire = nearestFire;
+#ifdef FIX_BUGS
+ bIsRunning = true;
+ ++nearestFire->m_nFiremenPuttingOut;
+#endif
+ }
+ break;
+ case EMERGENCY_PED_DETERMINE_NEXT_STATE:
+ nearestFire = gFireManager.FindNearestFire(GetPosition(), &fireDist);
+ if (nearestFire && nearestFire != m_pAttendedFire) {
+ m_nPedState = PED_NONE;
+ SetSeek(nearestFire->m_vecPos, 1.0f);
+ SetMoveState(PEDMOVE_RUN);
+#ifdef FIX_BUGS
+ bIsRunning = true;
+ if (m_pAttendedFire) {
+ --m_pAttendedFire->m_nFiremenPuttingOut;
+ }
+ ++nearestFire->m_nFiremenPuttingOut;
+ m_pAttendedFire = nearestFire;
+ } else if (!nearestFire) {
+#else
+ m_pAttendedFire = nearestFire;
+ } else {
+#endif
+ m_nEmergencyPedState = EMERGENCY_PED_STOP;
+ }
+
+ // "Extinguish" the fire (Will overwrite the stop decision above if the attended and nearest fires are same)
+ if (fireDist < 5.0f) {
+ SetIdle();
+ m_nEmergencyPedState = EMERGENCY_PED_STAND_STILL;
+ }
+ break;
+ case EMERGENCY_PED_STAND_STILL:
+ if (!m_pAttendedFire->m_bIsOngoing)
+ m_nEmergencyPedState = EMERGENCY_PED_STOP;
+
+ // Leftover
+ // fireDist = 30.0f;
+ nearestFire = gFireManager.FindNearestFire(GetPosition(), &fireDist);
+ if (nearestFire) {
+#ifdef FIX_BUGS
+ if(nearestFire != m_pAttendedFire && (nearestFire->m_vecPos - GetPosition()).Magnitude() < 30.0f)
+#endif
+ m_nEmergencyPedState = EMERGENCY_PED_DETERMINE_NEXT_STATE;
+ }
+ Say(SOUND_PED_EXTINGUISHING_FIRE);
+ break;
+ case EMERGENCY_PED_STOP:
+#ifdef FIX_BUGS
+ bIsRunning = false;
+ if (m_pAttendedFire)
+#endif
+ --m_pAttendedFire->m_nFiremenPuttingOut;
+
+ m_nPedState = PED_NONE;
+ SetWanderPath(CGeneral::GetRandomNumber() & 7);
+ m_pAttendedFire = nil;
+ m_nEmergencyPedState = EMERGENCY_PED_READY;
+ SetMoveState(PEDMOVE_WALK);
+ break;
+ }
+}
+
+void
+CEmergencyPed::MedicAI(void)
+{
+ float distToEmergency;
+ if (!bInVehicle && IsPedInControl()) {
+ ScanForThreats();
+ if (m_threatEntity && m_threatEntity->IsPed() && ((CPed*)m_threatEntity)->IsPlayer()) {
+ if (((CPed*)m_threatEntity)->GetWeapon()->IsTypeMelee()) {
+ SetObjective(OBJECTIVE_KILL_CHAR_ON_FOOT, m_threatEntity);
+ } else {
+ SetFlee(m_threatEntity, 6000);
+ Say(SOUND_PED_FLEE_SPRINT);
+ }
+ return;
+ }
+ }
+
+ if (InVehicle()) {
+ if (m_pMyVehicle->IsCar() && m_objective != OBJECTIVE_LEAVE_VEHICLE) {
+ if (gAccidentManager.FindNearestAccident(m_pMyVehicle->GetPosition(), &distToEmergency)
+ && distToEmergency < 25.0f && m_pMyVehicle->m_vecMoveSpeed.Magnitude() < 0.01f) {
+
+ m_pMyVehicle->AutoPilot.m_nCarMission = MISSION_NONE;
+ SetObjective(OBJECTIVE_LEAVE_VEHICLE, m_pMyVehicle);
+ Say(SOUND_PED_LEAVE_VEHICLE);
+ } else if (m_pMyVehicle->pDriver == this && m_nPedState == PED_DRIVING
+ && m_pMyVehicle->AutoPilot.m_nCarMission == MISSION_NONE && !(CGeneral::GetRandomNumber() & 31)) {
+
+ bool waitUntilMedicEntersCar = false;
+ for (int i = 0; i < m_numNearPeds; ++i) {
+ CPed *nearPed = m_nearPeds[i];
+ if (nearPed->m_nPedType == PEDTYPE_EMERGENCY) {
+ if ((nearPed->m_nPedState == PED_SEEK_CAR || nearPed->m_nPedState == PED_ENTER_CAR)
+ && nearPed->m_pMyVehicle == m_pMyVehicle) {
+ waitUntilMedicEntersCar = true;
+ break;
+ }
+ }
+ }
+ if (!waitUntilMedicEntersCar) {
+ CCarCtrl::JoinCarWithRoadSystem(m_pMyVehicle);
+ m_pMyVehicle->AutoPilot.m_nCarMission = MISSION_CRUISE;
+ m_pMyVehicle->m_bSirenOrAlarm = 0;
+ m_pMyVehicle->AutoPilot.m_nCruiseSpeed = 12;
+ m_pMyVehicle->AutoPilot.m_nDrivingStyle = DRIVINGSTYLE_SLOW_DOWN_FOR_CARS;
+ if (m_pMyVehicle->bIsAmbulanceOnDuty) {
+ m_pMyVehicle->bIsAmbulanceOnDuty = false;
+ --CCarCtrl::NumAmbulancesOnDuty;
+ }
+ }
+ }
+ }
+ }
+
+ CVector headPos, midPos;
+ CAccident *nearestAccident;
+ if (IsPedInControl()) {
+ switch (m_nEmergencyPedState) {
+ case EMERGENCY_PED_READY:
+ nearestAccident = gAccidentManager.FindNearestAccident(GetPosition(), &distToEmergency);
+ field_1360 = 0;
+ if (nearestAccident) {
+ m_pRevivedPed = nearestAccident->m_pVictim;
+ m_pRevivedPed->RegisterReference((CEntity**)&m_pRevivedPed);
+ m_pRevivedPed->m_pedIK.GetComponentPosition((RwV3d*)&midPos, PED_MID);
+ m_pRevivedPed->m_pedIK.GetComponentPosition((RwV3d*)&headPos, PED_HEAD);
+ SetSeek((headPos + midPos) * 0.5f, 1.0f);
+ SetObjective(OBJECTIVE_NONE);
+ bIsRunning = true;
+ m_nEmergencyPedState = EMERGENCY_PED_DETERMINE_NEXT_STATE;
+ m_pAttendedAccident = nearestAccident;
+ ++m_pAttendedAccident->m_nMedicsAttending;
+ } else {
+ if (m_pMyVehicle) {
+ if (!bInVehicle) {
+ if (m_objective == OBJECTIVE_ENTER_CAR_AS_DRIVER || m_pMyVehicle->pDriver || m_pMyVehicle->m_nGettingInFlags) {
+
+ CPed* driver = m_pMyVehicle->pDriver;
+ if (driver && driver->m_nPedType != PEDTYPE_EMERGENCY && m_objective != OBJECTIVE_KILL_CHAR_ON_FOOT) {
+ SetObjective(OBJECTIVE_KILL_CHAR_ON_FOOT, driver);
+ } else if (m_objective != OBJECTIVE_ENTER_CAR_AS_DRIVER
+ && m_objective != OBJECTIVE_ENTER_CAR_AS_PASSENGER
+ && m_objective != OBJECTIVE_KILL_CHAR_ON_FOOT) {
+ SetObjective(OBJECTIVE_ENTER_CAR_AS_PASSENGER, m_pMyVehicle);
+ }
+ } else {
+ SetObjective(OBJECTIVE_ENTER_CAR_AS_DRIVER, m_pMyVehicle);
+ }
+ }
+ } else if (m_nPedState != PED_WANDER_PATH) {
+ SetWanderPath(CGeneral::GetRandomNumber() & 7);
+ }
+ }
+ break;
+ case EMERGENCY_PED_DETERMINE_NEXT_STATE:
+ nearestAccident = gAccidentManager.FindNearestAccident(GetPosition(), &distToEmergency);
+ if (nearestAccident) {
+ if (nearestAccident != m_pAttendedAccident || m_nPedState != PED_SEEK_POS) {
+ m_pRevivedPed = nearestAccident->m_pVictim;
+ m_pRevivedPed->RegisterReference((CEntity**)&m_pRevivedPed);
+ if (!InRange(m_pRevivedPed)) {
+ m_nEmergencyPedState = EMERGENCY_PED_STOP;
+ break;
+ }
+ m_pRevivedPed->m_pedIK.GetComponentPosition((RwV3d*)&midPos, PED_MID);
+ m_pRevivedPed->m_pedIK.GetComponentPosition((RwV3d*)&headPos, PED_HEAD);
+ SetSeek((headPos + midPos) * 0.5f, nearestAccident->m_nMedicsPerformingCPR * 0.5f + 1.0f);
+ SetObjective(OBJECTIVE_NONE);
+ bIsRunning = true;
+ --m_pAttendedAccident->m_nMedicsAttending;
+ ++nearestAccident->m_nMedicsAttending;
+ m_pAttendedAccident = nearestAccident;
+ }
+ } else {
+ m_nEmergencyPedState = EMERGENCY_PED_STOP;
+ bIsRunning = false;
+ }
+ if (distToEmergency < 5.0f) {
+ if (m_pRevivedPed->m_pFire) {
+ bIsRunning = false;
+ SetMoveState(PEDMOVE_STILL);
+ } else if (distToEmergency < 4.5f) {
+ bIsRunning = false;
+ SetMoveState(PEDMOVE_WALK);
+ if (distToEmergency < 1.0f
+ || distToEmergency < 4.5f && m_pAttendedAccident->m_nMedicsPerformingCPR) {
+ m_nEmergencyPedState = EMERGENCY_PED_START_CPR;
+ }
+ }
+ }
+ break;
+ case EMERGENCY_PED_START_CPR:
+ if (!m_pRevivedPed || m_pRevivedPed->m_fHealth > 0.0f || m_pRevivedPed->bFadeOut) {
+ m_nEmergencyPedState = EMERGENCY_PED_DETERMINE_NEXT_STATE;
+ } else {
+ m_pRevivedPed->m_bloodyFootprintCount = CTimer::GetTimeInMilliseconds();
+ SetMoveState(PEDMOVE_STILL);
+ m_nPedState = PED_CPR;
+ m_nLastPedState = PED_CPR;
+ SetLookFlag(m_pRevivedPed, 0);
+ SetLookTimer(500);
+ Say(SOUND_PED_HEALING);
+ if (m_pAttendedAccident->m_nMedicsPerformingCPR) {
+ SetIdle();
+ m_nEmergencyPedState = EMERGENCY_PED_STAND_STILL;
+ } else {
+ m_nEmergencyPedState = EMERGENCY_PED_FACE_TO_PATIENT;
+ m_pVehicleAnim = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_CPR, 4.0f);
+ bIsDucking = true;
+ }
+ SetLookTimer(2000);
+ ++m_pAttendedAccident->m_nMedicsPerformingCPR;
+ m_bStartedToCPR = true;
+ }
+ break;
+ case EMERGENCY_PED_FACE_TO_PATIENT:
+ if (!m_pRevivedPed || m_pRevivedPed->m_fHealth > 0.0f)
+ m_nEmergencyPedState = EMERGENCY_PED_DETERMINE_NEXT_STATE;
+ else {
+ m_pRevivedPed->m_pedIK.GetComponentPosition((RwV3d*)&midPos, PED_MID);
+ m_pRevivedPed->m_pedIK.GetComponentPosition((RwV3d*)&headPos, PED_HEAD);
+ midPos = (headPos + midPos) * 0.5f;
+ m_fRotationDest = CGeneral::GetRadianAngleBetweenPoints(
+ midPos.x, midPos.y,
+ GetPosition().x, GetPosition().y);
+ m_fRotationDest = CGeneral::LimitAngle(m_fRotationDest);
+ m_pLookTarget = m_pRevivedPed;
+ m_pLookTarget->RegisterReference((CEntity**)&m_pLookTarget);
+ TurnBody();
+
+ if (Abs(m_fRotationCur - m_fRotationDest) < DEGTORAD(45.0f))
+ m_nEmergencyPedState = EMERGENCY_PED_PERFORM_CPR;
+ else
+ m_fRotationCur = (m_fRotationCur + m_fRotationDest) * 0.5f;
+ }
+ 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;
+ }
+ m_pRevivedPed->m_pedIK.GetComponentPosition((RwV3d*)&midPos, PED_MID);
+ m_pRevivedPed->m_pedIK.GetComponentPosition((RwV3d*)&headPos, PED_HEAD);
+ midPos = (headPos + midPos) * 0.5f;
+ m_fRotationDest = CGeneral::GetRadianAngleBetweenPoints(
+ midPos.x, midPos.y,
+ GetPosition().x, GetPosition().y);
+ m_fRotationDest = CGeneral::LimitAngle(m_fRotationDest);
+ m_pLookTarget = m_pRevivedPed;
+ m_pLookTarget->RegisterReference((CEntity**)&m_pLookTarget);
+ TurnBody();
+ if (CTimer::GetTimeInMilliseconds() <= m_lookTimer) {
+ SetMoveState(PEDMOVE_STILL);
+ break;
+ }
+ m_nEmergencyPedState = EMERGENCY_PED_STOP_CPR;
+ m_nPedState = PED_NONE;
+ SetMoveState(PEDMOVE_WALK);
+ m_pVehicleAnim = nil;
+ if (!m_pRevivedPed->bBodyPartJustCameOff) {
+ m_pRevivedPed->m_fHealth = 100.0f;
+ m_pRevivedPed->m_nPedState = PED_NONE;
+ m_pRevivedPed->m_nLastPedState = PED_WANDER_PATH;
+ m_pRevivedPed->SetGetUp();
+ m_pRevivedPed->bUsesCollision = true;
+ m_pRevivedPed->SetMoveState(PEDMOVE_WALK);
+ m_pRevivedPed->RestartNonPartialAnims();
+ m_pRevivedPed->bIsPedDieAnimPlaying = false;
+ m_pRevivedPed->m_ped_flagH1 = false;
+ m_pRevivedPed->m_pCollidingEntity = nil;
+ }
+ break;
+ case EMERGENCY_PED_STOP_CPR:
+ m_nEmergencyPedState = EMERGENCY_PED_STOP;
+ bIsDucking = true;
+ break;
+ case EMERGENCY_PED_STAND_STILL:
+ if (!m_pRevivedPed || m_pRevivedPed->m_fHealth > 0.0f)
+ m_nEmergencyPedState = EMERGENCY_PED_DETERMINE_NEXT_STATE;
+ else {
+ if (!m_pAttendedAccident->m_pVictim)
+ m_nEmergencyPedState = EMERGENCY_PED_DETERMINE_NEXT_STATE;
+ if (!m_pAttendedAccident->m_nMedicsPerformingCPR)
+ m_nEmergencyPedState = EMERGENCY_PED_DETERMINE_NEXT_STATE;
+ if (gAccidentManager.UnattendedAccidents())
+ m_nEmergencyPedState = EMERGENCY_PED_DETERMINE_NEXT_STATE;
+ }
+ break;
+ case EMERGENCY_PED_STOP:
+ m_bStartedToCPR = false;
+ m_nPedState = PED_NONE;
+ if (m_pAttendedAccident) {
+ m_pAttendedAccident->m_pVictim = nil;
+ --m_pAttendedAccident->m_nMedicsAttending;
+ m_pAttendedAccident = nil;
+ }
+ SetWanderPath(CGeneral::GetRandomNumber() & 7);
+ m_pRevivedPed = nil;
+ m_nEmergencyPedState = EMERGENCY_PED_READY;
+ SetMoveState(PEDMOVE_WALK);
+ break;
+ }
+ }
+}
+
+class CEmergencyPed_ : public CEmergencyPed
+{
+public:
+ CEmergencyPed* ctor(int pedtype) { return ::new (this) CEmergencyPed(pedtype); };
+ void dtor(void) { CEmergencyPed::~CEmergencyPed(); }
+ void ProcessControl_(void) { CEmergencyPed::ProcessControl(); }
+};
+
STARTPATCHES
InjectHook(0x4C2E40, &CEmergencyPed_::ctor, PATCH_JUMP);
InjectHook(0x4C2EF0, &CEmergencyPed_::dtor, PATCH_JUMP);
+ InjectHook(0x4C2F10, &CEmergencyPed_::ProcessControl_, PATCH_JUMP);
+ InjectHook(0x4C3EC0, &CEmergencyPed::InRange, PATCH_JUMP);
ENDPATCHES
diff --git a/src/peds/EmergencyPed.h b/src/peds/EmergencyPed.h
index f55fa4e2..5693e908 100644
--- a/src/peds/EmergencyPed.h
+++ b/src/peds/EmergencyPed.h
@@ -1,20 +1,40 @@
#pragma once
-#include "Fire.h"
#include "Ped.h"
+class CAccident;
+class CFire;
+
+enum EmergencyPedState
+{
+ EMERGENCY_PED_READY = 0x0,
+ EMERGENCY_PED_DETERMINE_NEXT_STATE = 0x1, // you can set that anytime you want
+ EMERGENCY_PED_START_CPR = 0x2,
+ EMERGENCY_PED_FLAG_4 = 0x4, // unused
+ EMERGENCY_PED_FLAG_8 = 0x8, // unused
+ EMERGENCY_PED_FACE_TO_PATIENT = 0x10, // for CPR
+ EMERGENCY_PED_PERFORM_CPR = 0x20,
+ EMERGENCY_PED_STOP_CPR = 0x40,
+ EMERGENCY_PED_STAND_STILL = 0x80, // waiting colleagues for medics, "extinguishing" fire for firemen
+ EMERGENCY_PED_STOP = 0x100,
+};
+
class CEmergencyPed : public CPed
{
public:
// 0x53C
- CPed* m_pRevivedPed;
- int32 m_nEmergencyPedState; // looks like flags
- void* m_pAttendedAccident; //TODO: CAccident*
- CFire* m_pAttendedFire;
- int8 field_1356;
- int32 field_1360;
+ CPed *m_pRevivedPed;
+ EmergencyPedState m_nEmergencyPedState;
+ CAccident *m_pAttendedAccident;
+ CFire *m_pAttendedFire;
+ bool m_bStartedToCPR; // set but unused(?)
+ int32 field_1360; // also something for medics, unused(?)
CEmergencyPed(uint32);
+ ~CEmergencyPed() { }
+ bool InRange(CPed*);
void ProcessControl(void);
+ void FiremanAI(void);
+ void MedicAI(void);
};
static_assert(sizeof(CEmergencyPed) == 0x554, "CEmergencyPed: error");