mirror of
https://github.com/halpz/re3.git
synced 2025-07-26 02:42:42 +00:00
the great reorganization
This commit is contained in:
aap
@ -1,18 +0,0 @@
|
||||
#include "common.h"
|
||||
#include "patcher.h"
|
||||
#include "Automobile.h"
|
||||
|
||||
CAutomobile::CAutomobile(int mi, uint8 owner)
|
||||
{
|
||||
ctor(mi, owner);
|
||||
}
|
||||
|
||||
WRAPPER CAutomobile* CAutomobile::ctor(int, uint8) { EAXJMP(0x52C6B0); }
|
||||
|
||||
WRAPPER void CAutomobile::SetDoorDamage(int32, uint32, bool) { EAXJMP(0x530200); }
|
||||
WRAPPER void CAutomobile::SetPanelDamage(int32, uint32, bool) { EAXJMP(0x5301A0); }
|
||||
WRAPPER void CAutomobile::SetBumperDamage(int32, uint32, bool) { EAXJMP(0x530120); }
|
||||
|
||||
STARTPATCHES
|
||||
InjectHook(0x52D170, &CAutomobile::dtor, PATCH_JUMP);
|
||||
ENDPATCHES
|
||||
@ -1,68 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "DamageManager.h"
|
||||
#include "Vehicle.h"
|
||||
|
||||
struct CDoor
|
||||
{
|
||||
float m_fAngleWhenOpened;
|
||||
float m_fAngleWhenClosed;
|
||||
char field_8;
|
||||
char field_9;
|
||||
char field_10;
|
||||
char field_11;
|
||||
float m_fAngle;
|
||||
float m_fPreviousAngle;
|
||||
float m_fAngularVelocity;
|
||||
CVector m_vecVelocity;
|
||||
};
|
||||
|
||||
class CAutomobile : public CVehicle
|
||||
{
|
||||
public:
|
||||
// 0x288
|
||||
CDamageManager Damage;
|
||||
CDoor Doors[6];
|
||||
RwFrame *m_aCarNodes[NUM_CAR_NODES];
|
||||
CColPoint m_aWheelColPoints[4];
|
||||
float m_aWheelDist[4];
|
||||
float m_aWheelDistPrev[4];
|
||||
float m_aWheelSkidThing[4];
|
||||
int field_49C;
|
||||
bool m_aWheelSkidmarkMuddy[4];
|
||||
bool m_aWheelSkidmarkBloody[4];
|
||||
float m_aWheelRotation[4];
|
||||
float m_aWheelPosition[4];
|
||||
float m_aWheelSpeed[4];
|
||||
uint8 stuff3[12];
|
||||
uint32 m_nBusDoorTimerEnd;
|
||||
uint32 m_nBusDoorTimerStart;
|
||||
float m_aSuspensionRange[4];
|
||||
float m_aSuspensionLineLength[4];
|
||||
float m_fHeightAboveRoad;
|
||||
float m_fImprovedHandling;
|
||||
uint8 stuff6[32];
|
||||
CPhysical *m_aGroundPhysical[4]; // physicals touching wheels
|
||||
CVector m_aGroundOffset[4]; // from ground object to colpoint
|
||||
CEntity *m_pBlowUpEntity;
|
||||
float m_weaponThingA; // TODO
|
||||
float m_weaponThingB; // TODO
|
||||
float m_fCarGunLR;
|
||||
float m_fCarGunUD;
|
||||
float m_fWindScreenRotation;
|
||||
uint8 stuff4[4];
|
||||
uint8 m_nWheelsOnGround_2;
|
||||
uint8 m_nWheelsOnGround;
|
||||
uint8 m_nWheelsOnGroundPrev;
|
||||
uint8 stuff5[5];
|
||||
int32 m_aWheelState[4];
|
||||
|
||||
CAutomobile(int, uint8);
|
||||
CAutomobile* ctor(int, uint8);
|
||||
void SetDoorDamage(int32, uint32, bool); /* TODO: eDoors */
|
||||
void SetPanelDamage(int32, uint32, bool); /* TODO: ePanels */
|
||||
void SetBumperDamage(int32, uint32, bool); /* TODO: ePanels */
|
||||
void dtor() { this->CAutomobile::~CAutomobile(); }
|
||||
};
|
||||
static_assert(sizeof(CAutomobile) == 0x5A8, "CAutomobile: error");
|
||||
static_assert(offsetof(CAutomobile, m_aWheelDist) == 0x46C, "CAutomobile: error");
|
||||
@ -1,14 +0,0 @@
|
||||
#include "common.h"
|
||||
#include "patcher.h"
|
||||
#include "Boat.h"
|
||||
|
||||
CBoat::CBoat(int mi, uint8 owner)
|
||||
{
|
||||
ctor(mi, owner);
|
||||
}
|
||||
|
||||
WRAPPER CBoat* CBoat::ctor(int, uint8) { EAXJMP(0x53E3E0); }
|
||||
|
||||
STARTPATCHES
|
||||
InjectHook(0x53E790, &CBoat::dtor, PATCH_JUMP);
|
||||
ENDPATCHES
|
||||
@ -1,17 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "Vehicle.h"
|
||||
|
||||
class CBoat : public CVehicle
|
||||
{
|
||||
public:
|
||||
// 0x288
|
||||
uint8 stuff1[57];
|
||||
bool m_bIsAnchored;
|
||||
uint8 stuff[450];
|
||||
|
||||
CBoat(int, uint8);
|
||||
CBoat* ctor(int, uint8);
|
||||
void dtor() { this->CBoat::~CBoat(); };
|
||||
};
|
||||
static_assert(sizeof(CBoat) == 0x484, "CBoat: error");
|
||||
@ -1,19 +0,0 @@
|
||||
#include "common.h"
|
||||
#include "patcher.h"
|
||||
#include "CivilianPed.h"
|
||||
|
||||
WRAPPER void CCivilianPed::ProcessControl(void) { EAXJMP(0x4BFFE0); }
|
||||
|
||||
CCivilianPed::CCivilianPed(int pedtype, int mi) : CPed(pedtype)
|
||||
{
|
||||
CPed::SetModelIndex(mi);
|
||||
for (int i = 0; i < 10; i++)
|
||||
{
|
||||
m_nearPeds[i] = nil;
|
||||
}
|
||||
}
|
||||
|
||||
STARTPATCHES
|
||||
InjectHook(0x4BFF30, &CCivilianPed::ctor, PATCH_JUMP);
|
||||
InjectHook(0x4BFFC0, &CCivilianPed::dtor, PATCH_JUMP);
|
||||
ENDPATCHES
|
||||
@ -1,16 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "Ped.h"
|
||||
|
||||
class CCivilianPed : public CPed
|
||||
{
|
||||
public:
|
||||
CCivilianPed(int, int);
|
||||
virtual ~CCivilianPed(void) { }
|
||||
|
||||
virtual void ProcessControl(void);
|
||||
|
||||
CCivilianPed *ctor(int pedtype, int mi) { return ::new (this) CCivilianPed(pedtype, mi); };
|
||||
void dtor(void) { this->CCivilianPed::~CCivilianPed(); }
|
||||
};
|
||||
static_assert(sizeof(CCivilianPed) == 0x53C, "CCivilianPed: error");
|
||||
@ -1,14 +0,0 @@
|
||||
#include "common.h"
|
||||
#include "patcher.h"
|
||||
#include "CopPed.h"
|
||||
|
||||
CCopPed::~CCopPed()
|
||||
{
|
||||
ClearPursuit();
|
||||
}
|
||||
|
||||
WRAPPER void CCopPed::ClearPursuit(void) { EAXJMP(0x4C28C0); }
|
||||
|
||||
STARTPATCHES
|
||||
InjectHook(0x4C13E0, &CCopPed::dtor, PATCH_JUMP);
|
||||
ENDPATCHES
|
||||
@ -1,73 +0,0 @@
|
||||
#pragma once
|
||||
#include "Ped.h"
|
||||
|
||||
enum eCrimeType
|
||||
{
|
||||
CRIME_NONE,
|
||||
CRIME_POSSESSION_GUN,
|
||||
CRIME_HIT_PED,
|
||||
CRIME_HIT_COP,
|
||||
CRIME_SHOOT_PED,
|
||||
CRIME_SHOOT_COP,
|
||||
CRIME_STEAL_CAR,
|
||||
CRIME_RUN_REDLIGHT,
|
||||
CRIME_RECKLESS_DRIVING,
|
||||
CRIME_SPEEDING,
|
||||
CRIME_RUNOVER_PED,
|
||||
CRIME_RUNOVER_COP,
|
||||
CRIME_SHOOT_HELI,
|
||||
CRIME_PED_BURNED,
|
||||
CRIME_COP_BURNED,
|
||||
CRIME_VEHICLE_BURNED,
|
||||
CRIME_DESTROYED_CESSNA,
|
||||
};
|
||||
|
||||
enum eCopType
|
||||
{
|
||||
COP_STREET = 0,
|
||||
COP_FBI = 1,
|
||||
COP_SWAT = 2,
|
||||
COP_ARMY = 3,
|
||||
};
|
||||
|
||||
class CCrime
|
||||
{
|
||||
public:
|
||||
eCrimeType m_eCrimeType;
|
||||
CEntity *m_pVictim;
|
||||
int32 m_nCrimeTime;
|
||||
CVector m_vecCrimePos;
|
||||
int8 m_bReported;
|
||||
int8 m_bMultiplier;
|
||||
int8 pad_20[2];
|
||||
};
|
||||
|
||||
class CCopPed : public CPed
|
||||
{
|
||||
public:
|
||||
int16 m_wRoadblockNode;
|
||||
int8 field_1342;
|
||||
int8 field_1343;
|
||||
float m_fDistanceToTarget;
|
||||
int8 m_bIsInPursuit;
|
||||
int8 m_bIsDisabledCop;
|
||||
int8 field_1350;
|
||||
int8 field_1351;
|
||||
int8 m_bZoneDisabledButClose;
|
||||
int8 m_bZoneDisabled;
|
||||
int8 field_1354;
|
||||
int8 field_1355;
|
||||
int32 field_1356;
|
||||
eCopType m_nCopType;
|
||||
int8 field_1364;
|
||||
int8 field_1365;
|
||||
int8 field_1366;
|
||||
int8 field_1367;
|
||||
|
||||
~CCopPed();
|
||||
void dtor(void) { this->CCopPed::~CCopPed(); }
|
||||
|
||||
void ClearPursuit(void);
|
||||
};
|
||||
|
||||
static_assert(sizeof(CCopPed) == 0x558, "CCopPed: error");
|
||||
@ -1,118 +0,0 @@
|
||||
#include "common.h"
|
||||
#include <rpskin.h>
|
||||
#include "patcher.h"
|
||||
#include "main.h"
|
||||
#include "RwHelper.h"
|
||||
#include "RpAnimBlend.h"
|
||||
#include "AnimBlendClumpData.h"
|
||||
#include "Directory.h"
|
||||
#include "CutsceneMgr.h"
|
||||
#include "Streaming.h"
|
||||
#include "CutsceneHead.h"
|
||||
|
||||
|
||||
CCutsceneHead::CCutsceneHead(CObject *obj)
|
||||
{
|
||||
RpAtomic *atm;
|
||||
|
||||
assert(RwObjectGetType(obj->m_rwObject) == rpCLUMP);
|
||||
m_pHeadNode = RpAnimBlendClumpFindFrame((RpClump*)obj->m_rwObject, "Shead")->frame;
|
||||
atm = (RpAtomic*)GetFirstObject(m_pHeadNode);
|
||||
if(atm){
|
||||
assert(RwObjectGetType(atm) == rpATOMIC);
|
||||
RpAtomicSetFlags(atm, RpAtomicGetFlags(atm) & ~rpATOMICRENDER);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
CCutsceneHead::CreateRwObject(void)
|
||||
{
|
||||
RpAtomic *atm;
|
||||
|
||||
CEntity::CreateRwObject();
|
||||
assert(RwObjectGetType(m_rwObject) == rpCLUMP);
|
||||
atm = GetFirstAtomic((RpClump*)m_rwObject);
|
||||
RpSkinAtomicSetHAnimHierarchy(atm, RpHAnimFrameGetHierarchy(GetFirstChild(RpClumpGetFrame((RpClump*)m_rwObject))));
|
||||
}
|
||||
|
||||
void
|
||||
CCutsceneHead::DeleteRwObject(void)
|
||||
{
|
||||
CEntity::DeleteRwObject();
|
||||
}
|
||||
|
||||
void
|
||||
CCutsceneHead::ProcessControl(void)
|
||||
{
|
||||
RpAtomic *atm;
|
||||
RpHAnimHierarchy *hier;
|
||||
|
||||
CPhysical::ProcessControl();
|
||||
|
||||
m_matrix.SetRotateY(PI/2);
|
||||
m_matrix = CMatrix(RwFrameGetLTM(m_pHeadNode)) * m_matrix;
|
||||
UpdateRwFrame();
|
||||
|
||||
assert(RwObjectGetType(m_rwObject) == rpCLUMP);
|
||||
atm = GetFirstAtomic((RpClump*)m_rwObject);
|
||||
hier = RpSkinAtomicGetHAnimHierarchy(atm);
|
||||
RpHAnimHierarchyAddAnimTime(hier, CTimer::GetTimeStepNonClipped()/50.0f);
|
||||
}
|
||||
|
||||
void
|
||||
CCutsceneHead::Render(void)
|
||||
{
|
||||
RpAtomic *atm;
|
||||
|
||||
m_matrix.SetRotateY(PI/2);
|
||||
m_matrix = CMatrix(RwFrameGetLTM(m_pHeadNode)) * m_matrix;
|
||||
UpdateRwFrame();
|
||||
|
||||
assert(RwObjectGetType(m_rwObject) == rpCLUMP);
|
||||
atm = GetFirstAtomic((RpClump*)m_rwObject);
|
||||
RpHAnimHierarchyUpdateMatrices(RpSkinAtomicGetHAnimHierarchy(atm));
|
||||
|
||||
CObject::Render();
|
||||
}
|
||||
|
||||
void
|
||||
CCutsceneHead::PlayAnimation(const char *animName)
|
||||
{
|
||||
RpAtomic *atm;
|
||||
RpHAnimHierarchy *hier;
|
||||
RpHAnimAnimation *anim;
|
||||
uint32 offset, size;
|
||||
RwStream *stream;
|
||||
|
||||
assert(RwObjectGetType(m_rwObject) == rpCLUMP);
|
||||
atm = GetFirstAtomic((RpClump*)m_rwObject);
|
||||
hier = RpSkinAtomicGetHAnimHierarchy(atm);
|
||||
|
||||
sprintf(gString, "%s.anm", animName);
|
||||
|
||||
if(CCutsceneMgr::ms_pCutsceneDir->FindItem(gString, offset, size)){
|
||||
stream = RwStreamOpen(rwSTREAMFILENAME, rwSTREAMREAD, "ANIM\\CUTS.IMG");
|
||||
assert(stream);
|
||||
|
||||
CStreaming::MakeSpaceFor(size*2048);
|
||||
CStreaming::ImGonnaUseStreamingMemory();
|
||||
|
||||
RwStreamSkip(stream, offset*2048);
|
||||
if(RwStreamFindChunk(stream, rwID_HANIMANIMATION, nil, nil)){
|
||||
anim = RpHAnimAnimationStreamRead(stream);
|
||||
RpHAnimHierarchySetCurrentAnim(hier, anim);
|
||||
}
|
||||
|
||||
CStreaming::IHaveUsedStreamingMemory();
|
||||
|
||||
RwStreamClose(stream, nil);
|
||||
}
|
||||
}
|
||||
|
||||
STARTPATCHES
|
||||
InjectHook(0x4BA650, &CCutsceneHead::CreateRwObject_, PATCH_JUMP);
|
||||
InjectHook(0x4BA690, &CCutsceneHead::DeleteRwObject_, PATCH_JUMP);
|
||||
InjectHook(0x4BA760, &CCutsceneHead::ProcessControl_, PATCH_JUMP);
|
||||
InjectHook(0x4BA800, &CCutsceneHead::Render_, PATCH_JUMP);
|
||||
InjectHook(0x4BA6A0, &CCutsceneHead::PlayAnimation, PATCH_JUMP);
|
||||
ENDPATCHES
|
||||
@ -1,24 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "CutsceneObject.h"
|
||||
|
||||
class CCutsceneHead : public CCutsceneObject
|
||||
{
|
||||
public:
|
||||
RwFrame *m_pHeadNode;
|
||||
|
||||
CCutsceneHead(CObject *obj);
|
||||
|
||||
void CreateRwObject(void);
|
||||
void DeleteRwObject(void);
|
||||
void ProcessControl(void);
|
||||
void Render(void);
|
||||
|
||||
void PlayAnimation(const char *animName);
|
||||
|
||||
void CreateRwObject_(void) { CCutsceneHead::CreateRwObject(); }
|
||||
void DeleteRwObject_(void) { CCutsceneHead::DeleteRwObject(); }
|
||||
void ProcessControl_(void) { CCutsceneHead::ProcessControl(); }
|
||||
void Render_(void) { CCutsceneHead::Render(); }
|
||||
};
|
||||
static_assert(sizeof(CCutsceneHead) == 0x19C, "CCutsceneHead: error");
|
||||
@ -1,100 +0,0 @@
|
||||
#include "common.h"
|
||||
#include "patcher.h"
|
||||
#include "main.h"
|
||||
#include "Lights.h"
|
||||
#include "PointLights.h"
|
||||
#include "RpAnimBlend.h"
|
||||
#include "AnimBlendClumpData.h"
|
||||
#include "Renderer.h"
|
||||
#include "ModelIndices.h"
|
||||
#include "Shadows.h"
|
||||
#include "Timecycle.h"
|
||||
#include "CutsceneObject.h"
|
||||
|
||||
CCutsceneObject::CCutsceneObject(void)
|
||||
{
|
||||
m_status = STATUS_SIMPLE;
|
||||
bUsesCollision = false;
|
||||
bStreamingDontDelete = true;
|
||||
ObjectCreatedBy = CUTSCENE_OBJECT;
|
||||
m_fMass = 1.0f;
|
||||
m_fTurnMass = 1.0f;
|
||||
}
|
||||
|
||||
void
|
||||
CCutsceneObject::SetModelIndex(uint32 id)
|
||||
{
|
||||
CEntity::SetModelIndex(id);
|
||||
assert(RwObjectGetType(m_rwObject) == rpCLUMP);
|
||||
RpAnimBlendClumpInit((RpClump*)m_rwObject);
|
||||
(*RPANIMBLENDCLUMPDATA(m_rwObject))->velocity = &m_vecMoveSpeed;
|
||||
(*RPANIMBLENDCLUMPDATA(m_rwObject))->frames[0].flag |= AnimBlendFrameData::VELOCITY_EXTRACTION_3D;
|
||||
}
|
||||
|
||||
void
|
||||
CCutsceneObject::ProcessControl(void)
|
||||
{
|
||||
CPhysical::ProcessControl();
|
||||
|
||||
if(CTimer::GetTimeStep() < 1/100.0f)
|
||||
m_vecMoveSpeed *= 100.0f;
|
||||
else
|
||||
m_vecMoveSpeed *= 1.0f/CTimer::GetTimeStep();
|
||||
|
||||
ApplyMoveSpeed();
|
||||
}
|
||||
|
||||
void
|
||||
CCutsceneObject::PreRender(void)
|
||||
{
|
||||
if(IsPedModel(GetModelIndex()))
|
||||
CShadows::StoreShadowForPedObject(this,
|
||||
CTimeCycle::m_fShadowDisplacementX[CTimeCycle::m_CurrentStoredValue],
|
||||
CTimeCycle::m_fShadowDisplacementY[CTimeCycle::m_CurrentStoredValue],
|
||||
CTimeCycle::m_fShadowFrontX[CTimeCycle::m_CurrentStoredValue],
|
||||
CTimeCycle::m_fShadowFrontY[CTimeCycle::m_CurrentStoredValue],
|
||||
CTimeCycle::m_fShadowSideX[CTimeCycle::m_CurrentStoredValue],
|
||||
CTimeCycle::m_fShadowSideY[CTimeCycle::m_CurrentStoredValue]);
|
||||
}
|
||||
|
||||
void
|
||||
CCutsceneObject::Render(void)
|
||||
{
|
||||
CObject::Render();
|
||||
}
|
||||
|
||||
bool
|
||||
CCutsceneObject::SetupLighting(void)
|
||||
{
|
||||
ActivateDirectional();
|
||||
SetAmbientColoursForPedsCarsAndObjects();
|
||||
|
||||
if(bRenderScorched){
|
||||
WorldReplaceNormalLightsWithScorched(Scene.world, 0.1f);
|
||||
}else{
|
||||
CVector coors = GetPosition();
|
||||
float lighting = CPointLights::GenerateLightsAffectingObject(&coors);
|
||||
if(!bHasBlip && lighting != 1.0f){
|
||||
SetAmbientAndDirectionalColours(lighting);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
void
|
||||
CCutsceneObject::RemoveLighting(bool reset)
|
||||
{
|
||||
CRenderer::RemoveVehiclePedLights(this, reset);
|
||||
}
|
||||
|
||||
STARTPATCHES
|
||||
InjectHook(0x4BA960, &CCutsceneObject::dtor, PATCH_JUMP);
|
||||
InjectHook(0x4BA980, &CCutsceneObject::SetModelIndex_, PATCH_JUMP);
|
||||
InjectHook(0x4BA9C0, &CCutsceneObject::ProcessControl_, PATCH_JUMP);
|
||||
InjectHook(0x4BAA40, &CCutsceneObject::PreRender_, PATCH_JUMP);
|
||||
InjectHook(0x4BAAA0, &CCutsceneObject::Render_, PATCH_JUMP);
|
||||
InjectHook(0x4A7E70, &CCutsceneObject::SetupLighting_, PATCH_JUMP);
|
||||
InjectHook(0x4A7F00, &CCutsceneObject::RemoveLighting_, PATCH_JUMP);
|
||||
ENDPATCHES
|
||||
@ -1,25 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "Object.h"
|
||||
|
||||
class CCutsceneObject : public CObject
|
||||
{
|
||||
public:
|
||||
CCutsceneObject(void);
|
||||
|
||||
virtual void SetModelIndex(uint32 id);
|
||||
virtual void ProcessControl(void);
|
||||
virtual void PreRender(void);
|
||||
virtual void Render(void);
|
||||
virtual bool SetupLighting(void);
|
||||
virtual void RemoveLighting(bool reset);
|
||||
|
||||
void dtor(void) { this->CCutsceneObject::~CCutsceneObject(); }
|
||||
void SetModelIndex_(uint32 id) { CCutsceneObject::SetModelIndex(id); }
|
||||
void ProcessControl_(void) { CCutsceneObject::ProcessControl(); }
|
||||
void PreRender_(void) { CCutsceneObject::PreRender(); }
|
||||
void Render_(void) { CCutsceneObject::Render(); }
|
||||
bool SetupLighting_(void) { return CCutsceneObject::SetupLighting(); }
|
||||
void RemoveLighting_(bool reset) { CCutsceneObject::RemoveLighting(reset); }
|
||||
};
|
||||
static_assert(sizeof(CCutsceneObject) == 0x198, "CCutsceneObject: error");
|
||||
@ -1,17 +0,0 @@
|
||||
#include "common.h"
|
||||
#include "patcher.h"
|
||||
#include "DummyObject.h"
|
||||
#include "Pools.h"
|
||||
|
||||
CDummyObject::CDummyObject(CObject *obj)
|
||||
{
|
||||
SetModelIndexNoCreate(obj->GetModelIndex());
|
||||
if(obj->m_rwObject)
|
||||
AttachToRwObject(obj->m_rwObject);
|
||||
obj->DetachFromRwObject();
|
||||
m_level = obj->m_level;
|
||||
}
|
||||
|
||||
STARTPATCHES
|
||||
InjectHook(0x4BAB70, &CDummyObject::dtor, PATCH_JUMP);
|
||||
ENDPATCHES
|
||||
@ -1,14 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "Dummy.h"
|
||||
|
||||
class CObject;
|
||||
|
||||
class CDummyObject : public CDummy
|
||||
{
|
||||
public:
|
||||
CDummyObject(void) {}
|
||||
CDummyObject(CObject *obj);
|
||||
void dtor(void) { this->CDummyObject::~CDummyObject(); }
|
||||
};
|
||||
static_assert(sizeof(CDummyObject) == 0x68, "CDummyObject: error");
|
||||
@ -1,11 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "Dummy.h"
|
||||
|
||||
// actually unused
|
||||
class CDummyPed : CDummy
|
||||
{
|
||||
int32 pedType;
|
||||
int32 unknown;
|
||||
};
|
||||
static_assert(sizeof(CDummyPed) == 0x70, "CDummyPed: error");
|
||||
@ -1,7 +0,0 @@
|
||||
#include "common.h"
|
||||
#include "patcher.h"
|
||||
#include "EmergencyPed.h"
|
||||
|
||||
STARTPATCHES
|
||||
InjectHook(0x4C2EF0, &CEmergencyPed::dtor, PATCH_JUMP);
|
||||
ENDPATCHES
|
||||
@ -1,13 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "Ped.h"
|
||||
|
||||
class CEmergencyPed : public CPed
|
||||
{
|
||||
public:
|
||||
// 0x53C
|
||||
uint8 stuff[24];
|
||||
|
||||
void dtor(void) { this->CEmergencyPed::~CEmergencyPed(); }
|
||||
};
|
||||
static_assert(sizeof(CEmergencyPed) == 0x554, "CEmergencyPed: error");
|
||||
@ -1,15 +0,0 @@
|
||||
#include "common.h"
|
||||
#include "patcher.h"
|
||||
#include "Heli.h"
|
||||
|
||||
CHeli::CHeli(int mi, uint8 owner)
|
||||
{
|
||||
ctor(mi, owner);
|
||||
}
|
||||
|
||||
WRAPPER CHeli* CHeli::ctor(int, uint8) { EAXJMP(0x547220); }
|
||||
WRAPPER void CHeli::SpecialHeliPreRender(void) { EAXJMP(0x54AE10); }
|
||||
|
||||
STARTPATCHES
|
||||
InjectHook(0x5474A0, &CHeli::dtor, PATCH_JUMP);
|
||||
ENDPATCHES
|
||||
@ -1,17 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "Vehicle.h"
|
||||
|
||||
class CHeli : public CVehicle
|
||||
{
|
||||
public:
|
||||
// 0x288
|
||||
uint8 stuff[180];
|
||||
|
||||
CHeli(int, uint8);
|
||||
CHeli* ctor(int, uint8);
|
||||
void dtor(void) { this->CHeli::~CHeli(); }
|
||||
|
||||
static void SpecialHeliPreRender(void);
|
||||
};
|
||||
static_assert(sizeof(CHeli) == 0x33C, "CHeli: error");
|
||||
@ -1,93 +0,0 @@
|
||||
#include "common.h"
|
||||
#include "patcher.h"
|
||||
#include "main.h"
|
||||
#include "Lights.h"
|
||||
#include "Pools.h"
|
||||
#include "Radar.h"
|
||||
#include "Object.h"
|
||||
|
||||
WRAPPER void CObject::ObjectDamage(float amount) { EAXJMP(0x4BB240); }
|
||||
|
||||
int16 &CObject::nNoTempObjects = *(int16*)0x95CCA2;
|
||||
|
||||
void *CObject::operator new(size_t sz) { return CPools::GetObjectPool()->New(); }
|
||||
void CObject::operator delete(void *p, size_t sz) { CPools::GetObjectPool()->Delete((CObject*)p); }
|
||||
|
||||
CObject::CObject(void)
|
||||
{
|
||||
m_type = ENTITY_TYPE_OBJECT;
|
||||
m_fUprootLimit = 0.0f;
|
||||
m_nCollisionDamageEffect = 0;
|
||||
m_nSpecialCollisionResponseCases = COLLRESPONSE_NONE;
|
||||
m_bCameraToAvoidThisObject = false;
|
||||
ObjectCreatedBy = 0;
|
||||
m_nEndOfLifeTime = 0;
|
||||
// m_nRefModelIndex = -1; // duplicate
|
||||
// bUseVehicleColours = false; // duplicate
|
||||
m_colour2 = 0;
|
||||
m_colour1 = m_colour2;
|
||||
field_172 = 0;
|
||||
bIsPickup = false;
|
||||
m_obj_flag2 = false;
|
||||
m_obj_flag4 = false;
|
||||
m_obj_flag8 = false;
|
||||
m_obj_flag10 = false;
|
||||
bHasBeenDamaged = false;
|
||||
m_nRefModelIndex = -1;
|
||||
bUseVehicleColours = false;
|
||||
m_pCurSurface = nil;
|
||||
m_pCollidingEntity = nil;
|
||||
}
|
||||
|
||||
CObject::~CObject(void)
|
||||
{
|
||||
CRadar::ClearBlipForEntity(BLIP_OBJECT, CPools::GetObjectPool()->GetIndex(this));
|
||||
|
||||
if(m_nRefModelIndex != -1)
|
||||
CModelInfo::GetModelInfo(m_nRefModelIndex)->RemoveRef();
|
||||
|
||||
if(ObjectCreatedBy == TEMP_OBJECT && nNoTempObjects != 0)
|
||||
nNoTempObjects--;
|
||||
}
|
||||
|
||||
void
|
||||
CObject::Render(void)
|
||||
{
|
||||
if(m_flagD80)
|
||||
return;
|
||||
|
||||
if(m_nRefModelIndex != -1 && ObjectCreatedBy == TEMP_OBJECT && bUseVehicleColours){
|
||||
CVehicleModelInfo *mi = (CVehicleModelInfo*)CModelInfo::GetModelInfo(m_nRefModelIndex);
|
||||
assert(mi->m_type == MITYPE_VEHICLE);
|
||||
mi->SetVehicleColour(m_colour1, m_colour2);
|
||||
}
|
||||
|
||||
CEntity::Render();
|
||||
}
|
||||
|
||||
bool
|
||||
CObject::SetupLighting(void)
|
||||
{
|
||||
DeActivateDirectional();
|
||||
SetAmbientColours();
|
||||
|
||||
if(bRenderScorched){
|
||||
WorldReplaceNormalLightsWithScorched(Scene.world, 0.1f);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void
|
||||
CObject::RemoveLighting(bool reset)
|
||||
{
|
||||
if(reset)
|
||||
WorldReplaceScorchedLightsWithNormal(Scene.world);
|
||||
}
|
||||
|
||||
WRAPPER void CObject::DeleteAllTempObjectInArea(CVector, float) { EAXJMP(0x4BBED0); }
|
||||
|
||||
STARTPATCHES
|
||||
InjectHook(0x4BAE00, &CObject::dtor, PATCH_JUMP);
|
||||
InjectHook(0x4BB1E0, &CObject::Render_, PATCH_JUMP);
|
||||
ENDPATCHES
|
||||
@ -1,81 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "Physical.h"
|
||||
|
||||
enum {
|
||||
GAME_OBJECT = 1,
|
||||
MISSION_OBJECT = 2,
|
||||
TEMP_OBJECT = 3,
|
||||
CUTSCENE_OBJECT = 4,
|
||||
};
|
||||
|
||||
enum {
|
||||
COLLRESPONSE_NONE,
|
||||
COLLRESPONSE_CHANGE_MODEL,
|
||||
COLLRESPONSE_SPLIT_MODEL,
|
||||
COLLRESPONSE_SMASH_COMPLETELY,
|
||||
COLLRESPONSE_CHANGE_THEN_SMASH,
|
||||
COLLRESPONSE_UNKNOWN5,
|
||||
|
||||
COLLRESPONSE_SMASH_CARDBOARD_COMPLETELY = 50,
|
||||
COLLRESPONSE_SMASH_WOODENBOX_COMPLETELY = 60,
|
||||
COLLRESPONSE_SMASH_TRAFFICCONE_COMPLETELY = 70,
|
||||
COLLRESPONSE_SMASH_BARPOST_COMPLETELY = 80,
|
||||
|
||||
};
|
||||
|
||||
class CVehicle;
|
||||
|
||||
class CObject : public CPhysical
|
||||
{
|
||||
public:
|
||||
CMatrix m_objectMatrix;
|
||||
float m_fUprootLimit;
|
||||
int8 ObjectCreatedBy;
|
||||
int8 bIsPickup : 1;
|
||||
int8 m_obj_flag2 : 1;
|
||||
int8 m_obj_flag4 : 1;
|
||||
int8 m_obj_flag8 : 1;
|
||||
int8 m_obj_flag10 : 1;
|
||||
int8 bHasBeenDamaged : 1;
|
||||
int8 bUseVehicleColours : 1;
|
||||
int8 m_obj_flag80 : 1;
|
||||
int8 field_172;
|
||||
int8 field_173;
|
||||
float m_fCollisionDamageMultiplier;
|
||||
uint8 m_nCollisionDamageEffect;
|
||||
uint8 m_nSpecialCollisionResponseCases;
|
||||
bool m_bCameraToAvoidThisObject;
|
||||
int8 field_17B;
|
||||
int8 field_17C;
|
||||
int8 field_17D;
|
||||
int8 field_17E;
|
||||
int8 field_17F;
|
||||
int32 m_nEndOfLifeTime;
|
||||
int16 m_nRefModelIndex;
|
||||
int8 field_186;
|
||||
int8 field_187;
|
||||
CEntity *m_pCurSurface;
|
||||
CEntity *m_pCollidingEntity;
|
||||
int8 m_colour1, m_colour2;
|
||||
|
||||
static int16 &nNoTempObjects;
|
||||
|
||||
static void *operator new(size_t);
|
||||
static void operator delete(void*, size_t);
|
||||
|
||||
CObject(void);
|
||||
~CObject(void);
|
||||
|
||||
void Render(void);
|
||||
bool SetupLighting(void);
|
||||
void RemoveLighting(bool reset);
|
||||
|
||||
void ObjectDamage(float amount);
|
||||
|
||||
static void DeleteAllTempObjectInArea(CVector, float);
|
||||
|
||||
void dtor(void) { this->CObject::~CObject(); }
|
||||
void Render_(void) { CObject::Render(); }
|
||||
};
|
||||
static_assert(sizeof(CObject) == 0x198, "CObject: error");
|
||||
2949
src/entities/Ped.cpp
2949
src/entities/Ped.cpp
File diff suppressed because it is too large
Load Diff
@ -1,577 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "Physical.h"
|
||||
#include "Weapon.h"
|
||||
#include "PedStats.h"
|
||||
#include "PedType.h"
|
||||
#include "PedIK.h"
|
||||
#include "AnimManager.h"
|
||||
#include "AnimBlendClumpData.h"
|
||||
#include "AnimBlendAssociation.h"
|
||||
#include "WeaponInfo.h"
|
||||
#include "Fire.h"
|
||||
|
||||
struct CPathNode;
|
||||
|
||||
enum eWaitState : uint32 {
|
||||
WAITSTATE_FALSE,
|
||||
WAITSTATE_TRAFFIC_LIGHTS,
|
||||
WAITSTATE_CROSS_ROAD,
|
||||
WAITSTATE_CROSS_ROAD_LOOK,
|
||||
WAITSTATE_LOOK_PED,
|
||||
WAITSTATE_LOOK_SHOP,
|
||||
WAITSTATE_LOOK_ACCIDENT,
|
||||
WAITSTATE_FACEOFF_GANG,
|
||||
WAITSTATE_DOUBLEBACK,
|
||||
WAITSTATE_HITWALL,
|
||||
WAITSTATE_TURN180,
|
||||
WAITSTATE_SURPRISE,
|
||||
WAITSTATE_STUCK,
|
||||
WAITSTATE_LOOK_ABOUT,
|
||||
WAITSTATE_PLAYANIM_DUCK,
|
||||
WAITSTATE_PLAYANIM_COWER,
|
||||
WAITSTATE_PLAYANIM_TAXI,
|
||||
WAITSTATE_PLAYANIM_HANDSUP,
|
||||
WAITSTATE_PLAYANIM_HANDSCOWER,
|
||||
WAITSTATE_PLAYANIM_CHAT,
|
||||
WAITSTATE_FINISH_FLEE
|
||||
};
|
||||
|
||||
enum eObjective : uint32 {
|
||||
OBJECTIVE_NONE,
|
||||
OBJECTIVE_IDLE,
|
||||
OBJECTIVE_FLEE_TILL_SAFE,
|
||||
OBJECTIVE_GUARD_SPOT,
|
||||
OBJECTIVE_GUARD_AREA,
|
||||
OBJECTIVE_WAIT_IN_CAR,
|
||||
OBJECTIVE_WAIT_IN_CAR_THEN_GETOUT,
|
||||
OBJECTIVE_KILL_CHAR_ON_FOOT,
|
||||
OBJECTIVE_KILL_CHAR_ANY_MEANS,
|
||||
OBJECTIVE_FLEE_CHAR_ON_FOOT_TILL_SAFE,
|
||||
OBJECTIVE_FLEE_CHAR_ON_FOOT_ALWAYS,
|
||||
OBJECTIVE_GOTO_CHAR_ON_FOOT,
|
||||
OBJECTIVE_FOLLOW_PED_IN_FORMATION,
|
||||
OBJECTIVE_LEAVE_VEHICLE,
|
||||
OBJECTIVE_ENTER_CAR_AS_PASSENGER,
|
||||
OBJECTIVE_ENTER_CAR_AS_DRIVER,
|
||||
OBJECTIVE_FOLLOW_CAR_IN_CAR,
|
||||
OBJECTIVE_FIRE_AT_OBJ_FROM_VEHICLE,
|
||||
OBJECTIVE_DESTROY_OBJ,
|
||||
OBJECTIVE_DESTROY_CAR,
|
||||
OBJECTIVE_GOTO_AREA_ANY_MEANS,
|
||||
OBJECTIVE_GOTO_AREA_ON_FOOT,
|
||||
OBJECTIVE_RUN_TO_AREA,
|
||||
OBJECTIVE_23,
|
||||
OBJECTIVE_24,
|
||||
OBJECTIVE_FIGHT_CHAR,
|
||||
OBJECTIVE_SET_LEADER,
|
||||
OBJECTIVE_FOLLOW_ROUTE,
|
||||
OBJECTIVE_SOLICIT,
|
||||
OBJECTIVE_HAIL_TAXI,
|
||||
OBJECTIVE_CATCH_TRAIN,
|
||||
OBJECTIVE_BUY_ICE_CREAM,
|
||||
OBJECTIVE_STEAL_ANY_CAR,
|
||||
OBJECTIVE_MUG_CHAR,
|
||||
OBJECTIVE_FLEE_CAR,
|
||||
OBJECTIVE_35
|
||||
};
|
||||
|
||||
enum eVehEnter : uint16 {
|
||||
VEHICLE_ENTER_FRONT_RIGHT = 11,
|
||||
VEHICLE_ENTER_REAR_RIGHT = 12,
|
||||
VEHICLE_ENTER_FRONT_LEFT = 15,
|
||||
VEHICLE_ENTER_REAR_LEFT = 16,
|
||||
};
|
||||
|
||||
enum {
|
||||
RANDOM_CHAR = 1,
|
||||
MISSION_CHAR,
|
||||
};
|
||||
|
||||
enum PedLineUpPhase {
|
||||
LINE_UP_TO_CAR_START,
|
||||
LINE_UP_TO_CAR_END,
|
||||
LINE_UP_TO_CAR_2
|
||||
};
|
||||
|
||||
enum PedOnGroundState {
|
||||
NO_PED,
|
||||
PED_BELOW_PLAYER,
|
||||
PED_ON_THE_FLOOR,
|
||||
PED_DEAD_ON_THE_FLOOR
|
||||
};
|
||||
|
||||
enum PedState
|
||||
{
|
||||
PED_NONE,
|
||||
PED_IDLE,
|
||||
PED_LOOK_ENTITY,
|
||||
PED_LOOK_HEADING,
|
||||
PED_WANDER_RANGE,
|
||||
PED_WANDER_PATH,
|
||||
PED_SEEK_POS,
|
||||
PED_SEEK_ENTITY,
|
||||
PED_FLEE_POS,
|
||||
PED_FLEE_ENTITY,
|
||||
PED_PURSUE,
|
||||
PED_FOLLOW_PATH,
|
||||
PED_SNIPER_MODE,
|
||||
PED_ROCKET_ODE,
|
||||
PED_DUMMY,
|
||||
PED_PAUSE,
|
||||
PED_ATTACK,
|
||||
PED_FIGHT,
|
||||
PED_FACE_PHONE,
|
||||
PED_MAKE_CALL,
|
||||
PED_CHAT,
|
||||
PED_MUG,
|
||||
PED_AIM_GUN,
|
||||
PED_AI_CONTROL,
|
||||
PED_SEEK_CAR,
|
||||
PED_SEEK_IN_BOAT,
|
||||
PED_FOLLOW_ROUTE,
|
||||
PED_CPR,
|
||||
PED_SOLICIT,
|
||||
PED_BUY_ICECREAM,
|
||||
PED_INVESTIGATE,
|
||||
PED_STEP_AWAY,
|
||||
PED_ON_FIRE,
|
||||
|
||||
PED_UNKNOWN, // HANG_OUT in Fire_Head's idb
|
||||
|
||||
PED_STATES_NO_AI,
|
||||
PED_JUMP,
|
||||
PED_FALL,
|
||||
PED_GETUP,
|
||||
PED_STAGGER,
|
||||
PED_DIVE_AWAY,
|
||||
|
||||
PED_STATES_NO_ST,
|
||||
PED_ENTER_TRAIN,
|
||||
PED_EXIT_TRAIN,
|
||||
PED_ARREST_PLAYER,
|
||||
PED_DRIVING,
|
||||
PED_PASSENGER,
|
||||
PED_TAXI_PASSENGER,
|
||||
PED_OPEN_DOOR,
|
||||
PED_DIE,
|
||||
PED_DEAD,
|
||||
PED_CARJACK,
|
||||
PED_DRAG_FROM_CAR,
|
||||
PED_ENTER_CAR,
|
||||
PED_STEAL_CAR,
|
||||
PED_EXIT_CAR,
|
||||
PED_HANDS_UP,
|
||||
PED_ARRESTED,
|
||||
};
|
||||
|
||||
enum eMoveState {
|
||||
PEDMOVE_NONE,
|
||||
PEDMOVE_STILL,
|
||||
PEDMOVE_WALK,
|
||||
PEDMOVE_RUN,
|
||||
PEDMOVE_SPRINT,
|
||||
};
|
||||
|
||||
class CVehicle;
|
||||
|
||||
class CPed : public CPhysical
|
||||
{
|
||||
public:
|
||||
// 0x128
|
||||
CStoredCollPoly m_collPoly;
|
||||
float m_fCollisionSpeed;
|
||||
|
||||
// cf. https://github.com/DK22Pac/plugin-sdk/blob/master/plugin_sa/game_sa/CPed.h from R*
|
||||
uint8 bIsStanding : 1;
|
||||
uint8 m_ped_flagA2 : 1;
|
||||
uint8 m_ped_flagA4 : 1; // stores (CTimer::GetTimeInMilliseconds() < m_lastHitTime)
|
||||
uint8 bIsPointingGunAt : 1;
|
||||
uint8 bIsLooking : 1;
|
||||
uint8 m_ped_flagA20 : 1; // "look" method? - probably missing in SA
|
||||
uint8 bIsRestoringLook : 1;
|
||||
uint8 bIsAimingGun : 1;
|
||||
|
||||
uint8 bIsRestoringGun : 1;
|
||||
uint8 bCanPointGunAtTarget : 1;
|
||||
uint8 bIsTalking : 1;
|
||||
uint8 bIsInTheAir : 1;
|
||||
uint8 bIsLanding : 1;
|
||||
uint8 m_ped_flagB20 : 1;
|
||||
uint8 m_ped_flagB40 : 1;
|
||||
uint8 m_ped_flagB80 : 1;
|
||||
|
||||
uint8 m_ped_flagC1 : 1;
|
||||
uint8 bRespondsToThreats : 1;
|
||||
uint8 m_ped_flagC4 : 1; // false when in bus, bRenderPedInCar?
|
||||
uint8 m_ped_flagC8 : 1;
|
||||
uint8 m_ped_flagC10 : 1;
|
||||
uint8 m_ped_flagC20 : 1; // just left some body part?
|
||||
uint8 m_ped_flagC40 : 1;
|
||||
uint8 m_ped_flagC80 : 1;
|
||||
|
||||
uint8 m_ped_flagD1 : 1;
|
||||
uint8 m_ped_flagD2 : 1;
|
||||
uint8 m_ped_flagD4 : 1;
|
||||
uint8 m_ped_flagD8 : 1;
|
||||
uint8 m_ped_flagD10 : 1;
|
||||
uint8 m_ped_flagD20 : 1;
|
||||
uint8 m_ped_flagD40 : 1; // reset when objective changes
|
||||
uint8 m_ped_flagD80 : 1;
|
||||
|
||||
uint8 m_ped_flagE1 : 1;
|
||||
uint8 m_ped_flagE2 : 1;
|
||||
uint8 bNotAllowedToDuck : 1;
|
||||
uint8 bCrouchWhenShooting : 1;
|
||||
uint8 bIsDucking : 1; // set if you don't want ped to attack
|
||||
uint8 m_ped_flagE20 : 1;
|
||||
uint8 bDoBloodyFootprints : 1;
|
||||
uint8 m_ped_flagE80 : 1;
|
||||
|
||||
uint8 m_ped_flagF1 : 1;
|
||||
uint8 m_ped_flagF2 : 1;
|
||||
uint8 m_ped_flagF4 : 1;
|
||||
uint8 m_ped_flagF8 : 1;
|
||||
uint8 m_ped_flagF10 : 1;
|
||||
uint8 m_ped_flagF20 : 1;
|
||||
uint8 m_ped_flagF40 : 1;
|
||||
uint8 m_ped_flagF80 : 1;
|
||||
|
||||
uint8 m_ped_flagG1 : 1;
|
||||
uint8 m_ped_flagG2 : 1;
|
||||
uint8 m_ped_flagG4 : 1;
|
||||
uint8 m_ped_flagG8 : 1;
|
||||
uint8 m_ped_flagG10 : 1;
|
||||
uint8 m_ped_flagG20 : 1;
|
||||
uint8 m_ped_flagG40 : 1;
|
||||
uint8 m_ped_flagG80 : 1;
|
||||
|
||||
uint8 m_ped_flagH1 : 1;
|
||||
uint8 m_ped_flagH2 : 1;
|
||||
uint8 m_ped_flagH4 : 1;
|
||||
uint8 m_ped_flagH8 : 1;
|
||||
uint8 m_ped_flagH10 : 1;
|
||||
uint8 m_ped_flagH20 : 1;
|
||||
uint8 m_ped_flagH40 : 1;
|
||||
uint8 m_ped_flagH80 : 1;
|
||||
|
||||
uint8 m_ped_flagI1 : 1;
|
||||
uint8 m_ped_flagI2 : 1;
|
||||
uint8 m_ped_flagI4 : 1;
|
||||
uint8 bRecordedForReplay : 1;
|
||||
uint8 m_ped_flagI10 : 1;
|
||||
uint8 m_ped_flagI20 : 1;
|
||||
uint8 m_ped_flagI40 : 1;
|
||||
uint8 m_ped_flagI80 : 1;
|
||||
|
||||
uint8 stuff10[3];
|
||||
uint8 CharCreatedBy;
|
||||
uint8 field_161;
|
||||
uint8 pad_162[2];
|
||||
eObjective m_objective;
|
||||
eObjective m_prevObjective;
|
||||
CPed *m_pedInObjective;
|
||||
CVehicle *m_carInObjective;
|
||||
uint32 field_174;
|
||||
uint32 field_178;
|
||||
uint32 field_17C;
|
||||
CPed *m_leader;
|
||||
uint32 m_pedFormation;
|
||||
uint32 m_fearFlags;
|
||||
CEntity *m_threatEntity;
|
||||
CVector2D m_eventOrThread;
|
||||
uint32 m_eventType;
|
||||
CEntity* m_pEventEntity;
|
||||
float m_fAngleToEvent;
|
||||
AnimBlendFrameData *m_pFrames[PED_NODE_MAX];
|
||||
AssocGroupId m_animGroup;
|
||||
CAnimBlendAssociation *m_pVehicleAnim;
|
||||
CVector2D m_vecAnimMoveDelta;
|
||||
CVector m_vecOffsetSeek;
|
||||
CPedIK m_pedIK;
|
||||
float m_actionX;
|
||||
float m_actionY;
|
||||
uint32 m_nPedStateTimer;
|
||||
PedState m_nPedState;
|
||||
PedState m_nLastPedState;
|
||||
eMoveState m_nMoveState;
|
||||
int32 m_nStoredActionState;
|
||||
int32 m_nPrevActionState;
|
||||
eWaitState m_nWaitState;
|
||||
uint32 m_nWaitTimer;
|
||||
void *m_pPathNodesStates[8];
|
||||
CVector2D m_stPathNodeStates[10];
|
||||
uint16 m_nPathNodes;
|
||||
uint8 m_nCurPathNode;
|
||||
int8 m_nPathState;
|
||||
private:
|
||||
int8 _pad2B5[3];
|
||||
public:
|
||||
CPathNode *m_pNextPathNode;
|
||||
CPathNode *m_pLastPathNode;
|
||||
float m_fHealth;
|
||||
float m_fArmour;
|
||||
int16 m_routeLastPoint;
|
||||
uint16 m_routePoints;
|
||||
int16 m_routePos;
|
||||
int16 m_routeType;
|
||||
int16 m_routeCurDir;
|
||||
uint16 field_2D2;
|
||||
CVector2D m_moved;
|
||||
float m_fRotationCur;
|
||||
float m_fRotationDest;
|
||||
float m_headingRate;
|
||||
eVehEnter m_vehEnterType;
|
||||
uint16 m_walkAroundType;
|
||||
CEntity *m_pCurrentPhysSurface;
|
||||
CVector m_vecOffsetFromPhysSurface;
|
||||
CEntity *m_pCurSurface;
|
||||
CVector m_vecSeekVehicle;
|
||||
CEntity *m_pSeekTarget;
|
||||
CVehicle *m_pMyVehicle;
|
||||
bool bInVehicle;
|
||||
uint8 pad_315[3];
|
||||
uint32 field_318;
|
||||
uint8 field_31C;
|
||||
uint8 field_31D;
|
||||
int16 m_phoneId;
|
||||
uint32 m_lookingForPhone;
|
||||
uint32 m_phoneTalkTimer;
|
||||
void *m_lastAccident;
|
||||
int32 m_nPedType;
|
||||
CPedStats *m_pedStats;
|
||||
float m_fleeFromPosX;
|
||||
float m_fleeFromPosY;
|
||||
CEntity *m_fleeFrom;
|
||||
uint32 m_fleeTimer;
|
||||
uint32 field_344;
|
||||
uint32 m_lastThreatTimer;
|
||||
CEntity *m_pCollidingEntity;
|
||||
uint8 m_stateUnused;
|
||||
uint8 pad_351[3];
|
||||
uint32 m_timerUnused;
|
||||
CEntity *m_targetUnused;
|
||||
CWeapon m_weapons[NUM_PED_WEAPONTYPES];
|
||||
eWeaponType m_storedWeapon;
|
||||
uint8 m_currentWeapon; // eWeaponType
|
||||
uint8 m_maxWeaponTypeAllowed; // eWeaponType
|
||||
uint8 m_wepSkills;
|
||||
uint8 m_wepAccuracy;
|
||||
CEntity *m_pPointGunAt;
|
||||
CVector m_vecHitLastPos;
|
||||
uint32 m_lastHitState;
|
||||
uint8 m_fightFlags1;
|
||||
uint8 m_fightFlags2;
|
||||
uint8 pad_4B2[2];
|
||||
CFire* m_pFire;
|
||||
CEntity *m_pLookTarget;
|
||||
float m_fLookDirection;
|
||||
int32 m_wepModelID;
|
||||
uint32 m_leaveCarTimer;
|
||||
uint32 m_getUpTimer;
|
||||
uint32 m_lookTimer;
|
||||
uint32 m_standardTimer;
|
||||
uint32 m_attackTimer;
|
||||
uint32 m_lastHitTime;
|
||||
uint32 m_hitRecoverTimer;
|
||||
uint32 m_objectiveTimer;
|
||||
uint32 m_duckTimer;
|
||||
uint32 field_4E8;
|
||||
int32 m_bloodyFootprintCount;
|
||||
uint8 stuff9[2];
|
||||
int8 m_bodyPartBleeding; // PedNode
|
||||
uint8 m_field_4F3;
|
||||
CPed *m_nearPeds[10];
|
||||
uint16 m_numNearPeds;
|
||||
int8 m_lastWepDam;
|
||||
uint8 pad_51F;
|
||||
uint8 field_520;
|
||||
uint8 pad_521[3];
|
||||
uint32 m_talkTimer;
|
||||
uint16 m_talkTypeLast;
|
||||
uint16 m_talkType;
|
||||
CVector m_vecSeekPosEx;
|
||||
float m_seekExAngle;
|
||||
|
||||
static void *operator new(size_t);
|
||||
static void *operator new(size_t, int);
|
||||
static void operator delete(void*, size_t);
|
||||
static void operator delete(void*, int);
|
||||
|
||||
CPed(uint32 pedType);
|
||||
virtual ~CPed(void);
|
||||
|
||||
virtual void SetModelIndex(uint32 mi);
|
||||
virtual void ProcessControl(void);
|
||||
virtual void Teleport(CVector);
|
||||
virtual void PreRender(void);
|
||||
virtual void Render(void);
|
||||
virtual bool SetupLighting(void);
|
||||
virtual void RemoveLighting(bool);
|
||||
virtual void FlagToDestroyWhenNextProcessed(void);
|
||||
virtual int32 ProcessEntityCollision(CEntity*, CColPoint*);
|
||||
virtual void SetMoveAnim(void);
|
||||
|
||||
CPed* ctor(uint32 pedType) { return ::new (this) CPed(pedType); }
|
||||
void dtor(void) { this->CPed::~CPed(); }
|
||||
|
||||
void AddWeaponModel(int id);
|
||||
void AimGun(void);
|
||||
void KillPedWithCar(CVehicle *veh, float impulse);
|
||||
void Say(uint16 audio);
|
||||
void SetLookFlag(CEntity *target, bool unknown);
|
||||
void SetLookFlag(float direction, bool unknown);
|
||||
void SetLookTimer(int time);
|
||||
void SetDie(AnimationId anim, float arg1, float arg2);
|
||||
void ApplyHeadShot(eWeaponType weaponType, CVector pos, bool evenOnPlayer);
|
||||
void RemoveBodyPart(PedNode nodeId, int8 unknown);
|
||||
void SpawnFlyingComponent(int, int8 unknown);
|
||||
bool OurPedCanSeeThisOne(CEntity *target);
|
||||
void Avoid(void);
|
||||
void Attack(void);
|
||||
void ClearAimFlag(void);
|
||||
void ClearLookFlag(void);
|
||||
void RestorePreviousState(void);
|
||||
void ClearAttack(void);
|
||||
bool IsPedHeadAbovePos(float zOffset);
|
||||
void RemoveWeaponModel(int modelId);
|
||||
void SetCurrentWeapon(uint32 weaponType);
|
||||
void Duck(void);
|
||||
void ClearDuck(void);
|
||||
void ClearPointGunAt(void);
|
||||
void BeingDraggedFromCar(void);
|
||||
void RestartNonPartialAnims(void);
|
||||
void LineUpPedWithCar(PedLineUpPhase phase);
|
||||
void SetPedPositionInCar(void);
|
||||
void PlayFootSteps(void);
|
||||
void QuitEnteringCar(void);
|
||||
void BuildPedLists(void);
|
||||
uint32 GiveWeapon(eWeaponType weaponType, uint32 ammo);
|
||||
void CalculateNewOrientation(void);
|
||||
float WorkOutHeadingForMovingFirstPerson(float);
|
||||
void CalculateNewVelocity(void);
|
||||
bool CanPedJumpThis(int32);
|
||||
bool CanSeeEntity(CEntity*, float);
|
||||
void RestorePreviousObjective(void);
|
||||
void SetIdle(void);
|
||||
void SetObjective(eObjective, void*);
|
||||
void SetObjective(eObjective);
|
||||
void SetObjective(eObjective, int16, int16);
|
||||
void ClearChat(void);
|
||||
void InformMyGangOfAttack(CEntity*);
|
||||
void SetFollowRoute(int16, int16);
|
||||
void ReactToAttack(CEntity*);
|
||||
void SetDuck(uint32);
|
||||
void RegisterThreatWithGangPeds(CEntity*);
|
||||
bool TurnBody(void);
|
||||
void Chat(void);
|
||||
|
||||
// Static methods
|
||||
static void GetLocalPositionToOpenCarDoor(CVector *output, CVehicle *veh, uint32 enterType, float offset);
|
||||
static void GetPositionToOpenCarDoor(CVector *output, CVehicle *veh, uint32 enterType, float seatPosMult);
|
||||
static void GetPositionToOpenCarDoor(CVector* output, CVehicle* veh, uint32 enterType);
|
||||
|
||||
// Callbacks
|
||||
static RwObject *SetPedAtomicVisibilityCB(RwObject *object, void *data);
|
||||
static RwFrame *RecurseFrameChildrenVisibilityCB(RwFrame *frame, void *data);
|
||||
static void PedGetupCB(CAnimBlendAssociation *assoc, void *arg);
|
||||
static void PedStaggerCB(CAnimBlendAssociation *assoc, void *arg);
|
||||
static void PedEvadeCB(CAnimBlendAssociation *assoc, void *arg);
|
||||
static void FinishDieAnimCB(CAnimBlendAssociation *assoc, void *arg);
|
||||
static void FinishedWaitCB(CAnimBlendAssociation *assoc, void *arg);
|
||||
static void FinishLaunchCB(CAnimBlendAssociation *assoc, void *arg);
|
||||
static void FinishHitHeadCB(CAnimBlendAssociation *assoc, void *arg);
|
||||
static void PedAnimGetInCB(CAnimBlendAssociation *assoc, void *arg);
|
||||
static void PedAnimDoorOpenCB(CAnimBlendAssociation *assoc, void *arg);
|
||||
static void PedAnimPullPedOutCB(CAnimBlendAssociation *assoc, void *arg);
|
||||
static void PedAnimDoorCloseCB(CAnimBlendAssociation *assoc, void *arg);
|
||||
static void SetInCarCB(CAnimBlendAssociation *assoc, void *arg);
|
||||
static void PedSetOutCarCB(CAnimBlendAssociation *assoc, void *arg);
|
||||
static void PedAnimAlignCB(CAnimBlendAssociation *assoc, void *arg);
|
||||
static void PedSetDraggedOutCarCB(CAnimBlendAssociation *assoc, void *arg);
|
||||
static void PedAnimStepOutCarCB(CAnimBlendAssociation *assoc, void *arg);
|
||||
static void PedSetInTrainCB(CAnimBlendAssociation *assoc, void *arg);
|
||||
static void PedSetOutTrainCB(CAnimBlendAssociation *assoc, void *arg);
|
||||
static void FinishedAttackCB(CAnimBlendAssociation *assoc, void *arg);
|
||||
static void FinishFightMoveCB(CAnimBlendAssociation *assoc, void *arg);
|
||||
static void PedAnimDoorCloseRollingCB(CAnimBlendAssociation *assoc, void *arg);
|
||||
static void FinishJumpCB(CAnimBlendAssociation *assoc, void *arg);
|
||||
static void PedLandCB(CAnimBlendAssociation *assoc, void *arg);
|
||||
static void RestoreHeadingRateCB(CAnimBlendAssociation *assoc, void *arg);
|
||||
static void PedSetQuickDraggedOutCarPositionCB(CAnimBlendAssociation *assoc, void *arg);
|
||||
static void PedSetDraggedOutCarPositionCB(CAnimBlendAssociation *assoc, void *arg);
|
||||
|
||||
// functions that I see unnecessary to hook
|
||||
bool IsPlayer(void);
|
||||
bool UseGroundColModel(void);
|
||||
bool CanSetPedState(void);
|
||||
bool IsPedInControl(void);
|
||||
bool CanPedDriveOff(void);
|
||||
bool CanBeDeleted(void);
|
||||
bool CanStrafeOrMouseControl(void);
|
||||
bool CanPedReturnToState(void);
|
||||
void SetMoveState(eMoveState);
|
||||
bool IsTemporaryObjective(eObjective objective);
|
||||
void SetObjectiveTimer(int);
|
||||
bool SelectGunIfArmed(void);
|
||||
bool IsPointerValid(void);
|
||||
void SortPeds(CPed**, int, int);
|
||||
void ForceStoredObjective(eObjective);
|
||||
void SetStoredObjective(void);
|
||||
void SetLeader(CEntity* leader);
|
||||
void SetPedStats(ePedStats);
|
||||
bool IsGangMember(void);
|
||||
|
||||
bool HasWeapon(uint8 weaponType) { return m_weapons[weaponType].m_eWeaponType == weaponType; }
|
||||
CWeapon &GetWeapon(uint8 weaponType) { return m_weapons[weaponType]; }
|
||||
CWeapon *GetWeapon(void) { return &m_weapons[m_currentWeapon]; }
|
||||
RwFrame *GetNodeFrame(int nodeId) { return m_pFrames[nodeId]->frame; }
|
||||
static uint8 GetVehEnterExitFlag(eVehEnter vehEnter) {
|
||||
switch (vehEnter) {
|
||||
case VEHICLE_ENTER_FRONT_RIGHT:
|
||||
return 4;
|
||||
case VEHICLE_ENTER_REAR_RIGHT:
|
||||
return 8;
|
||||
case VEHICLE_ENTER_FRONT_LEFT:
|
||||
return 1;
|
||||
case VEHICLE_ENTER_REAR_LEFT:
|
||||
return 2;
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
PedState GetPedState(void) { return m_nPedState; }
|
||||
void SetPedState(PedState state) { m_nPedState = state; }
|
||||
|
||||
// to make patching virtual functions possible
|
||||
void SetModelIndex_(uint32 mi) { CPed::SetModelIndex(mi); }
|
||||
void FlagToDestroyWhenNextProcessed_(void) { CPed::FlagToDestroyWhenNextProcessed(); }
|
||||
bool SetupLighting_(void) { return CPed::SetupLighting(); }
|
||||
void RemoveLighting_(bool reset) { CPed::RemoveLighting(reset); }
|
||||
void Teleport_(CVector pos) { CPed::Teleport(pos); }
|
||||
|
||||
// set by 0482:set_threat_reaction_range_multiplier opcode
|
||||
static uint16 &distanceMultToCountPedNear;
|
||||
|
||||
static CVector &offsetToOpenRegularCarDoor;
|
||||
static CVector &offsetToOpenLowCarDoor;
|
||||
static CVector &offsetToOpenVanDoor;
|
||||
static bool &bNastyLimbsCheat;
|
||||
static bool &bPedCheat2;
|
||||
static bool &bPedCheat3;
|
||||
};
|
||||
|
||||
void FinishFuckUCB(CAnimBlendAssociation *assoc, void *arg);
|
||||
|
||||
static_assert(offsetof(CPed, m_nPedState) == 0x224, "CPed: error");
|
||||
static_assert(offsetof(CPed, m_pCurSurface) == 0x2FC, "CPed: error");
|
||||
static_assert(offsetof(CPed, m_pMyVehicle) == 0x310, "CPed: error");
|
||||
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_pedInObjective) == 0x16C, "CPed: error");
|
||||
static_assert(offsetof(CPed, m_pEventEntity) == 0x19C, "CPed: error");
|
||||
static_assert(sizeof(CPed) == 0x53C, "CPed: error");
|
||||
@ -1,109 +0,0 @@
|
||||
#include "common.h"
|
||||
#include "patcher.h"
|
||||
#include "PedIK.h"
|
||||
#include "Ped.h"
|
||||
|
||||
WRAPPER bool CPedIK::PointGunInDirection(float phi, float theta) { EAXJMP(0x4ED9B0); }
|
||||
WRAPPER bool CPedIK::PointGunAtPosition(CVector *position) { EAXJMP(0x4ED920); }
|
||||
WRAPPER void CPedIK::ExtractYawAndPitchLocal(RwMatrixTag*, float*, float*) { EAXJMP(0x4ED2C0); }
|
||||
WRAPPER void CPedIK::ExtractYawAndPitchWorld(RwMatrixTag*, float*, float*) { EAXJMP(0x4ED140); }
|
||||
|
||||
CPedIK::CPedIK(CPed *ped)
|
||||
{
|
||||
m_ped = ped;
|
||||
m_flags = 0;
|
||||
m_headOrient.phi = 0.0f;
|
||||
m_headOrient.theta = 0.0f;
|
||||
m_torsoOrient.phi = 0.0f;
|
||||
m_torsoOrient.theta = 0.0f;
|
||||
m_upperArmOrient.phi = 0.0f;
|
||||
m_upperArmOrient.theta = 0.0f;
|
||||
m_lowerArmOrient.phi = 0.0f;
|
||||
m_lowerArmOrient.theta = 0.0f;
|
||||
}
|
||||
|
||||
void
|
||||
CPedIK::RotateTorso(AnimBlendFrameData *animBlend, LimbOrientation *limb, bool changeRoll)
|
||||
{
|
||||
RwFrame *f = animBlend->frame;
|
||||
RwMatrix *mat = CPedIK::GetWorldMatrix(RwFrameGetParent(f), RwMatrixCreate());
|
||||
|
||||
RwV3d upVector = { mat->right.z, mat->up.z, mat->at.z };
|
||||
RwV3d rightVector;
|
||||
RwV3d pos = RwFrameGetMatrix(f)->pos;
|
||||
|
||||
// rotation == 0 -> looking in y direction
|
||||
// left? vector
|
||||
float c = cos(m_ped->m_fRotationCur);
|
||||
float s = sin(m_ped->m_fRotationCur);
|
||||
rightVector.x = -(c*mat->right.x + s*mat->right.y);
|
||||
rightVector.y = -(c*mat->up.x + s*mat->up.y);
|
||||
rightVector.z = -(c*mat->at.x + s*mat->at.y);
|
||||
|
||||
if(changeRoll){
|
||||
// Used when aiming only involves over the legs.(canAimWithArm)
|
||||
// Automatically changes roll(forward rotation) axis of the parts above upper legs while moving, based on position of upper legs.
|
||||
// Not noticeable in normal conditions...
|
||||
|
||||
RwV3d forwardVector;
|
||||
CVector inversedForward = CrossProduct(CVector(0.0f, 0.0f, 1.0f), mat->up);
|
||||
inversedForward.Normalise();
|
||||
float dotProduct = DotProduct(mat->at, inversedForward);
|
||||
if(dotProduct > 1.0f) dotProduct = 1.0f;
|
||||
if(dotProduct < -1.0f) dotProduct = -1.0f;
|
||||
float alpha = acos(dotProduct);
|
||||
|
||||
if(mat->at.z < 0.0f)
|
||||
alpha = -alpha;
|
||||
|
||||
forwardVector.x = s * mat->right.x - c * mat->right.y;
|
||||
forwardVector.y = s * mat->up.x - c * mat->up.y;
|
||||
forwardVector.z = s * mat->at.x - c * mat->at.y;
|
||||
|
||||
float curYaw, curPitch;
|
||||
CPedIK::ExtractYawAndPitchWorld(mat, &curYaw, &curPitch);
|
||||
RwMatrixRotate(RwFrameGetMatrix(f), &rightVector, RADTODEG(limb->theta), rwCOMBINEPOSTCONCAT);
|
||||
RwMatrixRotate(RwFrameGetMatrix(f), &upVector, RADTODEG(limb->phi - (curYaw - m_ped->m_fRotationCur)), rwCOMBINEPOSTCONCAT);
|
||||
RwMatrixRotate(RwFrameGetMatrix(f), &forwardVector, RADTODEG(alpha), rwCOMBINEPOSTCONCAT);
|
||||
}else{
|
||||
// pitch
|
||||
RwMatrixRotate(RwFrameGetMatrix(f), &rightVector, RADTODEG(limb->theta), rwCOMBINEPOSTCONCAT);
|
||||
// yaw
|
||||
RwMatrixRotate(RwFrameGetMatrix(f), &upVector, RADTODEG(limb->phi), rwCOMBINEPOSTCONCAT);
|
||||
}
|
||||
RwFrameGetMatrix(f)->pos = pos;
|
||||
RwMatrixDestroy(mat);
|
||||
}
|
||||
|
||||
void
|
||||
CPedIK::GetComponentPosition(RwV3d *pos, PedNode node)
|
||||
{
|
||||
RwFrame *f;
|
||||
RwMatrix *mat;
|
||||
|
||||
f = m_ped->GetNodeFrame(node);
|
||||
mat = RwFrameGetMatrix(f);
|
||||
*pos = mat->pos;
|
||||
|
||||
for (f = RwFrameGetParent(f); f; f = RwFrameGetParent(f))
|
||||
RwV3dTransformPoints(pos, pos, 1, RwFrameGetMatrix(f));
|
||||
}
|
||||
|
||||
RwMatrix*
|
||||
CPedIK::GetWorldMatrix(RwFrame *source, RwMatrix *destination)
|
||||
{
|
||||
RwFrame *i;
|
||||
|
||||
*destination = *RwFrameGetMatrix(source);
|
||||
|
||||
for (i = RwFrameGetParent(source); i; i = RwFrameGetParent(i))
|
||||
RwMatrixTransform(destination, RwFrameGetMatrix(i), rwCOMBINEPOSTCONCAT);
|
||||
|
||||
return destination;
|
||||
}
|
||||
|
||||
STARTPATCHES
|
||||
InjectHook(0x4ED0F0, &CPedIK::GetComponentPosition, PATCH_JUMP);
|
||||
InjectHook(0x4ED060, &CPedIK::GetWorldMatrix, PATCH_JUMP);
|
||||
InjectHook(0x4EDDB0, &CPedIK::RotateTorso, PATCH_JUMP);
|
||||
ENDPATCHES
|
||||
@ -1,40 +0,0 @@
|
||||
#pragma once
|
||||
#include "common.h"
|
||||
#include "PedModelInfo.h"
|
||||
#include "AnimBlendClumpData.h"
|
||||
|
||||
struct LimbOrientation
|
||||
{
|
||||
float phi;
|
||||
float theta;
|
||||
};
|
||||
|
||||
class CPed;
|
||||
|
||||
class CPedIK
|
||||
{
|
||||
public:
|
||||
// TODO
|
||||
enum {
|
||||
FLAG_1 = 1,
|
||||
FLAG_2 = 2, // related to looking somewhere
|
||||
FLAG_4 = 4, // aims with arm
|
||||
};
|
||||
|
||||
CPed *m_ped;
|
||||
LimbOrientation m_headOrient;
|
||||
LimbOrientation m_torsoOrient;
|
||||
LimbOrientation m_upperArmOrient;
|
||||
LimbOrientation m_lowerArmOrient;
|
||||
int32 m_flags;
|
||||
|
||||
CPedIK(CPed *ped);
|
||||
bool PointGunInDirection(float phi, float theta);
|
||||
bool PointGunAtPosition(CVector *position);
|
||||
void GetComponentPosition(RwV3d *pos, PedNode node);
|
||||
static RwMatrix *GetWorldMatrix(RwFrame *source, RwMatrix *destination);
|
||||
void RotateTorso(AnimBlendFrameData* animBlend, LimbOrientation* limb, bool changeRoll);
|
||||
void ExtractYawAndPitchLocal(RwMatrixTag*, float*, float*);
|
||||
void ExtractYawAndPitchWorld(RwMatrixTag*, float*, float*);
|
||||
};
|
||||
static_assert(sizeof(CPedIK) == 0x28, "CPedIK: error");
|
||||
@ -1897,10 +1897,10 @@ CPhysical::ProcessCollision(void)
|
||||
CVehicle *veh = (CVehicle*)this;
|
||||
if(veh->m_vehType == VEHICLE_TYPE_CAR){
|
||||
CAutomobile *car = (CAutomobile*)this;
|
||||
car->m_aWheelDist[0] = 1.0f;
|
||||
car->m_aWheelDist[1] = 1.0f;
|
||||
car->m_aWheelDist[2] = 1.0f;
|
||||
car->m_aWheelDist[3] = 1.0f;
|
||||
car->m_aSuspensionSpringRatio[0] = 1.0f;
|
||||
car->m_aSuspensionSpringRatio[1] = 1.0f;
|
||||
car->m_aSuspensionSpringRatio[2] = 1.0f;
|
||||
car->m_aSuspensionSpringRatio[3] = 1.0f;
|
||||
}else if(veh->m_vehType == VEHICLE_TYPE_BIKE){
|
||||
assert(0 && "TODO - but unused");
|
||||
}
|
||||
|
||||
@ -1,19 +0,0 @@
|
||||
#include "common.h"
|
||||
#include "patcher.h"
|
||||
#include "Plane.h"
|
||||
|
||||
CPlane::CPlane(int mi, uint8 owner)
|
||||
{
|
||||
ctor(mi, owner);
|
||||
}
|
||||
|
||||
WRAPPER CPlane* CPlane::ctor(int, uint8) { EAXJMP(0x54B170); }
|
||||
|
||||
CPlane::~CPlane()
|
||||
{
|
||||
DeleteRwObject();
|
||||
}
|
||||
|
||||
STARTPATCHES
|
||||
InjectHook(0x54B270, &CPlane::dtor, PATCH_JUMP);
|
||||
ENDPATCHES
|
||||
@ -1,18 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "common.h"
|
||||
#include "Vehicle.h"
|
||||
|
||||
class CPlane : public CVehicle
|
||||
{
|
||||
public:
|
||||
// 0x288
|
||||
uint8 stuff[20];
|
||||
|
||||
CPlane(int, uint8);
|
||||
~CPlane(void);
|
||||
CPlane* ctor(int, uint8);
|
||||
void dtor(void) { this->CPlane::~CPlane(); }
|
||||
void FlagToDestroyWhenNextProcessed() { bRemoveFromWorld = true; }
|
||||
};
|
||||
static_assert(sizeof(CPlane) == 0x29C, "CPlane: error");
|
||||
@ -1,5 +0,0 @@
|
||||
#include "common.h"
|
||||
#include "patcher.h"
|
||||
#include "PlayerInfo.h"
|
||||
|
||||
WRAPPER void CPlayerInfo::MakePlayerSafe(bool) { EAXJMP(0x4A1400); }
|
||||
@ -1,72 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "Collision.h"
|
||||
|
||||
enum eWastedBustedState
|
||||
{
|
||||
WBSTATE_PLAYING,
|
||||
WBSTATE_WASTED,
|
||||
WBSTATE_BUSTED,
|
||||
WBSTATE_FAILED_CRITICAL_MISSION,
|
||||
};
|
||||
|
||||
class CVehicle;
|
||||
class CPlayerPed;
|
||||
class CCivilianPed;
|
||||
|
||||
class CPlayerInfo
|
||||
{
|
||||
public:
|
||||
CPlayerPed *m_pPed;
|
||||
CVehicle *m_pRemoteVehicle;
|
||||
CColModel m_ColModel;
|
||||
CVehicle *m_pVehicleEx;
|
||||
char m_aPlayerName[70];
|
||||
int32 m_nMoney;
|
||||
int32 m_nVisibleMoney;
|
||||
int32 m_nCollectedPackages;
|
||||
int32 m_nTotalPackages;
|
||||
int32 field_188;
|
||||
int32 m_nSwitchTaxiTime;
|
||||
bool m_bSwitchTaxi;
|
||||
int8 field_197;
|
||||
int8 field_198;
|
||||
int8 field_199;
|
||||
int32 m_nNextSexFrequencyUpdateTime;
|
||||
int32 m_nNextSexMoneyUpdateTime;
|
||||
int32 m_nSexFrequency;
|
||||
CCivilianPed *m_pHooker;
|
||||
int8 m_WBState; // eWastedBustedState
|
||||
int8 field_217;
|
||||
int8 field_218;
|
||||
int8 field_219;
|
||||
int32 m_nWBTime;
|
||||
bool m_bInRemoteMode;
|
||||
int8 field_225;
|
||||
int8 field_226;
|
||||
int8 field_227;
|
||||
int32 m_nTimeLostRemoteCar;
|
||||
int32 m_nTimeLastHealthLoss;
|
||||
int32 m_nTimeLastArmourLoss;
|
||||
int32 field_240;
|
||||
int32 m_nUpsideDownCounter;
|
||||
int32 field_248;
|
||||
int16 m_nTrafficMultiplier;
|
||||
int8 field_254;
|
||||
int8 field_255;
|
||||
float m_fRoadDensity;
|
||||
int32 m_nPreviousTimeRewardedForExplosion;
|
||||
int32 m_nExplosionsSinceLastReward;
|
||||
int32 field_268;
|
||||
int32 field_272;
|
||||
bool m_bInfiniteSprint;
|
||||
bool m_bFastReload;
|
||||
bool m_bGetOutOfJailFree;
|
||||
bool m_bGetOutOfHospitalFree;
|
||||
uint8 m_aSkinName[32];
|
||||
RwTexture *m_pSkinTexture;
|
||||
|
||||
void MakePlayerSafe(bool);
|
||||
};
|
||||
|
||||
static_assert(sizeof(CPlayerInfo) == 0x13C, "CPlayerInfo: error");
|
||||
@ -1,14 +0,0 @@
|
||||
#include "common.h"
|
||||
#include "patcher.h"
|
||||
#include "PlayerPed.h"
|
||||
|
||||
CPlayerPed::~CPlayerPed()
|
||||
{
|
||||
delete m_pWanted;
|
||||
}
|
||||
|
||||
WRAPPER void CPlayerPed::ReApplyMoveAnims(void) { EAXJMP(0x4F07C0); }
|
||||
|
||||
STARTPATCHES
|
||||
InjectHook(0x4EFB30, &CPlayerPed::dtor, PATCH_JUMP);
|
||||
ENDPATCHES
|
||||
@ -1,48 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "Ped.h"
|
||||
#include "Wanted.h"
|
||||
|
||||
class CPlayerPed : public CPed
|
||||
{
|
||||
public:
|
||||
CWanted *m_pWanted;
|
||||
CCopPed *m_pArrestingCop;
|
||||
float m_fMoveSpeed;
|
||||
float m_fCurrentStamina;
|
||||
float m_fMaxStamina;
|
||||
float m_fStaminaProgress;
|
||||
bool m_bWeaponSlot;
|
||||
bool m_bSpeedTimerFlag;
|
||||
bool m_bShouldEvade;
|
||||
int8 field_1367;
|
||||
int32 m_nSpeedTimer;
|
||||
int32 m_nShotDelay;
|
||||
float field_1376;
|
||||
int8 field_1380; // set if can't attack, why?
|
||||
int8 field_1381;
|
||||
int8 field_1382;
|
||||
int8 field_1383;
|
||||
CEntity *m_pEvadingFrom;
|
||||
int32 m_nTargettableObjects[4];
|
||||
bool m_bAdrenalineActive;
|
||||
bool m_bHasLockOnTarget;
|
||||
int8 field_1406;
|
||||
int8 field_1407;
|
||||
bool m_bAdrenalineTime;
|
||||
bool m_bCanBeDamaged;
|
||||
int8 field_1413;
|
||||
int8 field_1414;
|
||||
int8 field_1415;
|
||||
CVector field_1416[6];
|
||||
int32 field_1488[6];
|
||||
float m_fWalkAngle;
|
||||
float m_fFPSMoveHeading;
|
||||
|
||||
~CPlayerPed();
|
||||
|
||||
void dtor(void) { this->CPlayerPed::~CPlayerPed(); }
|
||||
void ReApplyMoveAnims(void);
|
||||
};
|
||||
|
||||
static_assert(sizeof(CPlayerPed) == 0x5F0, "CPlayerPed: error");
|
||||
@ -1,5 +0,0 @@
|
||||
#include "common.h"
|
||||
#include "patcher.h"
|
||||
#include "PlayerSkin.h"
|
||||
|
||||
WRAPPER void CPlayerSkin::BeginFrontEndSkinEdit() { EAXJMP(0x59BC70); }
|
||||
@ -1,7 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
class CPlayerSkin
|
||||
{
|
||||
public:
|
||||
static void BeginFrontEndSkinEdit();
|
||||
};
|
||||
@ -1,7 +0,0 @@
|
||||
#include "common.h"
|
||||
#include "patcher.h"
|
||||
#include "Projectile.h"
|
||||
|
||||
STARTPATCHES
|
||||
InjectHook(0x4BFED0, &CProjectile::dtor, PATCH_JUMP);
|
||||
ENDPATCHES
|
||||
@ -1,11 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "Object.h"
|
||||
|
||||
class CProjectile : public CObject
|
||||
{
|
||||
public:
|
||||
void dtor(void) { this->CProjectile::~CProjectile(); }
|
||||
};
|
||||
@ -1,14 +0,0 @@
|
||||
#include "common.h"
|
||||
#include "patcher.h"
|
||||
#include "Train.h"
|
||||
|
||||
CTrain::CTrain(int mi, uint8 owner)
|
||||
{
|
||||
ctor(mi, owner);
|
||||
}
|
||||
|
||||
WRAPPER CTrain* CTrain::ctor(int, uint8) { EAXJMP(0x54E2A0); }
|
||||
|
||||
STARTPATCHES
|
||||
InjectHook(0x54E450, &CTrain::dtor, PATCH_JUMP);
|
||||
ENDPATCHES
|
||||
@ -1,26 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "common.h"
|
||||
#include "patcher.h"
|
||||
#include "Vehicle.h"
|
||||
|
||||
enum
|
||||
{
|
||||
TRAIN_DOOR_STATE2 = 2
|
||||
};
|
||||
|
||||
class CTrain : public CVehicle
|
||||
{
|
||||
public:
|
||||
// 0x288
|
||||
uint8 stuff1[20];
|
||||
uint8 m_trackId;
|
||||
uint8 stuff2[7];
|
||||
int16 m_doorState;
|
||||
uint8 stuff3[62];
|
||||
|
||||
CTrain(int, uint8);
|
||||
CTrain* ctor(int, uint8);
|
||||
void dtor(void) { this->CTrain::~CTrain(); }
|
||||
};
|
||||
static_assert(sizeof(CTrain) == 0x2E4, "CTrain: error");
|
||||
@ -1,489 +0,0 @@
|
||||
#include "common.h"
|
||||
#include "main.h"
|
||||
#include "patcher.h"
|
||||
#include "Timer.h"
|
||||
#include "Vehicle.h"
|
||||
#include "Pools.h"
|
||||
#include "HandlingMgr.h"
|
||||
#include "CarCtrl.h"
|
||||
#include "Population.h"
|
||||
#include "ModelIndices.h"
|
||||
#include "World.h"
|
||||
#include "Lights.h"
|
||||
#include "PointLights.h"
|
||||
#include "Renderer.h"
|
||||
#include "DMAudio.h"
|
||||
#include "Radar.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;
|
||||
bool &CVehicle::m_bDisableMouseSteering = *(bool *)0x60252C;
|
||||
|
||||
void *CVehicle::operator new(size_t sz) { return CPools::GetVehiclePool()->New(); }
|
||||
void *CVehicle::operator new(size_t sz, int handle) { return CPools::GetVehiclePool()->New(handle); }
|
||||
void CVehicle::operator delete(void *p, size_t sz) { CPools::GetVehiclePool()->Delete((CVehicle*)p); }
|
||||
void CVehicle::operator delete(void *p, int handle) { CPools::GetVehiclePool()->Delete((CVehicle*)p); }
|
||||
|
||||
CVehicle::~CVehicle()
|
||||
{
|
||||
m_nAlarmState = 0;
|
||||
if (m_audioEntityId >= 0){
|
||||
DMAudio.DestroyEntity(m_audioEntityId);
|
||||
m_audioEntityId = -5;
|
||||
}
|
||||
CRadar::ClearBlipForEntity(BLIP_CAR, CPools::GetVehiclePool()->GetIndex(this));
|
||||
if (pDriver)
|
||||
pDriver->FlagToDestroyWhenNextProcessed();
|
||||
for (int i = 0; i < m_nNumMaxPassengers; i++){
|
||||
if (pPassengers[i])
|
||||
pPassengers[i]->FlagToDestroyWhenNextProcessed();
|
||||
}
|
||||
if (m_pCarFire)
|
||||
m_pCarFire->Extinguish();
|
||||
CCarCtrl::UpdateCarCount(this, true);
|
||||
if (bIsAmbulanceOnDuty){
|
||||
CCarCtrl::NumAmbulancesOnDuty--;
|
||||
bIsAmbulanceOnDuty = false;
|
||||
}
|
||||
if (bIsFireTruckOnDuty){
|
||||
CCarCtrl::NumFiretrucksOnDuty--;
|
||||
bIsFireTruckOnDuty = false;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
CVehicle::SetModelIndex(uint32 id)
|
||||
{
|
||||
CEntity::SetModelIndex(id);
|
||||
m_aExtras[0] = CVehicleModelInfo::ms_compsUsed[0];
|
||||
m_aExtras[1] = CVehicleModelInfo::ms_compsUsed[1];
|
||||
m_nNumMaxPassengers = CVehicleModelInfo::GetMaximumNumberOfPassengersFromNumberOfDoors(id);
|
||||
}
|
||||
|
||||
bool
|
||||
CVehicle::SetupLighting(void)
|
||||
{
|
||||
ActivateDirectional();
|
||||
SetAmbientColoursForPedsCarsAndObjects();
|
||||
|
||||
if(bRenderScorched){
|
||||
WorldReplaceNormalLightsWithScorched(Scene.world, 0.1f);
|
||||
}else{
|
||||
CVector coors = GetPosition();
|
||||
float lighting = CPointLights::GenerateLightsAffectingObject(&coors);
|
||||
if(!bHasBlip && lighting != 1.0f){
|
||||
SetAmbientAndDirectionalColours(lighting);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
void
|
||||
CVehicle::RemoveLighting(bool reset)
|
||||
{
|
||||
CRenderer::RemoveVehiclePedLights(this, reset);
|
||||
}
|
||||
|
||||
float
|
||||
CVehicle::GetHeightAboveRoad(void)
|
||||
{
|
||||
return -1.0f * CModelInfo::GetModelInfo(GetModelIndex())->GetColModel()->boundingBox.min.z;
|
||||
}
|
||||
|
||||
|
||||
bool
|
||||
CVehicle::IsLawEnforcementVehicle(void)
|
||||
{
|
||||
switch(GetModelIndex()){
|
||||
case MI_FBICAR:
|
||||
case MI_POLICE:
|
||||
case MI_ENFORCER:
|
||||
case MI_PREDATOR:
|
||||
case MI_RHINO:
|
||||
case MI_BARRACKS:
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
bool
|
||||
CVehicle::UsesSiren(uint32 id)
|
||||
{
|
||||
switch(id){
|
||||
case MI_FIRETRUCK:
|
||||
case MI_AMBULAN:
|
||||
case MI_FBICAR:
|
||||
case MI_MRWHOOP:
|
||||
case MI_POLICE:
|
||||
case MI_ENFORCER:
|
||||
case MI_PREDATOR:
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
bool
|
||||
CVehicle::IsVehicleNormal(void)
|
||||
{
|
||||
if(pDriver && m_nNumPassengers == 0 && m_status != STATUS_WRECKED){
|
||||
switch(GetModelIndex())
|
||||
case MI_FIRETRUCK:
|
||||
case MI_AMBULAN:
|
||||
case MI_TAXI:
|
||||
case MI_POLICE:
|
||||
case MI_ENFORCER:
|
||||
case MI_BUS:
|
||||
case MI_RHINO:
|
||||
case MI_BARRACKS:
|
||||
case MI_DODO:
|
||||
case MI_COACH:
|
||||
case MI_CABBIE:
|
||||
case MI_RCBANDIT:
|
||||
case MI_BORGNINE:
|
||||
return false;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool
|
||||
CVehicle::CarHasRoof(void)
|
||||
{
|
||||
if((m_handling->Flags & HANDLING_HAS_NO_ROOF) == 0)
|
||||
return true;
|
||||
if(m_aExtras[0] && m_aExtras[1])
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool
|
||||
CVehicle::IsUpsideDown(void)
|
||||
{
|
||||
if(GetUp().z > -0.9f)
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool
|
||||
CVehicle::IsOnItsSide(void)
|
||||
{
|
||||
if(GetRight().z < 0.8f && GetRight().z > -0.8f)
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool
|
||||
CVehicle::CanBeDeleted(void)
|
||||
{
|
||||
int i;
|
||||
|
||||
if(m_nNumGettingIn || m_nGettingOutFlags)
|
||||
return false;
|
||||
|
||||
if(pDriver){
|
||||
// This looks like it was inlined
|
||||
if(pDriver->CharCreatedBy == MISSION_CHAR)
|
||||
return false;
|
||||
if(pDriver->GetPedState() != PED_DRIVING &&
|
||||
pDriver->GetPedState() != PED_DEAD)
|
||||
return false;
|
||||
}
|
||||
|
||||
for(i = 0; i < 8; i++){
|
||||
// Same check as above
|
||||
if(pPassengers[i]){
|
||||
if(pPassengers[i]->CharCreatedBy == MISSION_CHAR)
|
||||
return false;
|
||||
if(pPassengers[i]->GetPedState() != PED_DRIVING &&
|
||||
pPassengers[i]->GetPedState() != PED_DEAD)
|
||||
return false;
|
||||
}
|
||||
// and then again... probably because something was inlined
|
||||
if(pPassengers[i]){
|
||||
if(pPassengers[i]->GetPedState() != PED_DRIVING &&
|
||||
pPassengers[i]->GetPedState() != PED_DEAD)
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
switch(VehicleCreatedBy){
|
||||
case RANDOM_VEHICLE: return true;
|
||||
case MISSION_VEHICLE: return false;
|
||||
case PARKED_VEHICLE: return true;
|
||||
case PERMANENT_VEHICLE: return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool
|
||||
CVehicle::CanPedOpenLocks(CPed *ped)
|
||||
{
|
||||
if(m_nDoorLock == CARLOCK_LOCKED ||
|
||||
m_nDoorLock == CARLOCK_COP_CAR ||
|
||||
m_nDoorLock == CARLOCK_LOCKED_PLAYER_INSIDE)
|
||||
return false;
|
||||
if(ped->IsPlayer() && m_nDoorLock == CARLOCK_LOCKOUT_PLAYER_ONLY)
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool
|
||||
CVehicle::CanPedEnterCar(void)
|
||||
{
|
||||
CVector up = GetUp();
|
||||
// can't enter when car is on side
|
||||
if(up.z > 0.1f || up.z < -0.1f){
|
||||
// also when car is moving too fast
|
||||
if(m_vecMoveSpeed.MagnitudeSqr() > sq(0.2f))
|
||||
return false;
|
||||
if(m_vecTurnSpeed.MagnitudeSqr() > sq(0.2f))
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool
|
||||
CVehicle::CanPedExitCar(void)
|
||||
{
|
||||
CVector up = GetUp();
|
||||
if(up.z > 0.1f || up.z < -0.1f){
|
||||
// can't exit when car is moving too fast
|
||||
if(m_vecMoveSpeed.MagnitudeSqr() > 0.005f)
|
||||
return false;
|
||||
// if car is slow enough, check turn speed
|
||||
if(fabs(m_vecTurnSpeed.x) > 0.01f ||
|
||||
fabs(m_vecTurnSpeed.y) > 0.01f ||
|
||||
fabs(m_vecTurnSpeed.z) > 0.01f)
|
||||
return false;
|
||||
return true;
|
||||
}else{
|
||||
// What is this? just > replaced by >= ??
|
||||
|
||||
// can't exit when car is moving too fast
|
||||
if(m_vecMoveSpeed.MagnitudeSqr() >= 0.005f)
|
||||
return false;
|
||||
// if car is slow enough, check turn speed
|
||||
if(fabs(m_vecTurnSpeed.x) >= 0.01f ||
|
||||
fabs(m_vecTurnSpeed.y) >= 0.01f ||
|
||||
fabs(m_vecTurnSpeed.z) >= 0.01f)
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
CVehicle::ChangeLawEnforcerState(uint8 enable)
|
||||
{
|
||||
if (enable) {
|
||||
if (!bIsLawEnforcer) {
|
||||
bIsLawEnforcer = true;
|
||||
CCarCtrl::NumLawEnforcerCars++;
|
||||
}
|
||||
} else {
|
||||
if (bIsLawEnforcer) {
|
||||
bIsLawEnforcer = false;
|
||||
CCarCtrl::NumLawEnforcerCars--;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
CPed*
|
||||
CVehicle::SetUpDriver(void)
|
||||
{
|
||||
if(pDriver)
|
||||
return pDriver;
|
||||
if(VehicleCreatedBy != RANDOM_VEHICLE)
|
||||
return nil;
|
||||
|
||||
pDriver = CPopulation::AddPedInCar(this);
|
||||
pDriver->m_pMyVehicle = this;
|
||||
pDriver->m_pMyVehicle->RegisterReference((CEntity**)&pDriver->m_pMyVehicle);
|
||||
pDriver->bInVehicle = true;
|
||||
pDriver->SetPedState(PED_DRIVING);
|
||||
if(bIsBus)
|
||||
pDriver->m_ped_flagC4 = false;
|
||||
return pDriver;
|
||||
}
|
||||
|
||||
CPed*
|
||||
CVehicle::SetupPassenger(int n)
|
||||
{
|
||||
if(pPassengers[n])
|
||||
return pPassengers[n];
|
||||
|
||||
pPassengers[n] = CPopulation::AddPedInCar(this);
|
||||
pPassengers[n]->m_pMyVehicle = this;
|
||||
pPassengers[n]->m_pMyVehicle->RegisterReference((CEntity**)&pPassengers[n]->m_pMyVehicle);
|
||||
pPassengers[n]->bInVehicle = true;
|
||||
pPassengers[n]->SetPedState(PED_DRIVING);
|
||||
if(bIsBus)
|
||||
pPassengers[n]->m_ped_flagC4 = false;
|
||||
return pPassengers[n];
|
||||
}
|
||||
|
||||
void
|
||||
CVehicle::SetDriver(CPed *driver)
|
||||
{
|
||||
pDriver = driver;
|
||||
pDriver->RegisterReference((CEntity**)&pDriver);
|
||||
|
||||
if(bFreebies && driver == FindPlayerPed()){
|
||||
if(GetModelIndex() == MI_AMBULAN)
|
||||
FindPlayerPed()->m_fHealth = min(FindPlayerPed()->m_fHealth + 20.0f, 100.0f);
|
||||
else if(GetModelIndex() == MI_TAXI)
|
||||
CWorld::Players[CWorld::PlayerInFocus].m_nMoney += 25;
|
||||
else if(GetModelIndex() == MI_POLICE)
|
||||
driver->GiveWeapon(WEAPONTYPE_SHOTGUN, 5);
|
||||
else if(GetModelIndex() == MI_ENFORCER)
|
||||
driver->m_fArmour = max(driver->m_fArmour, 100.0f);
|
||||
else if(GetModelIndex() == MI_CABBIE || GetModelIndex() == MI_BORGNINE)
|
||||
CWorld::Players[CWorld::PlayerInFocus].m_nMoney += 25;
|
||||
bFreebies = false;
|
||||
}
|
||||
|
||||
ApplyTurnForce(0.0f, 0.0f, -0.2f*driver->m_fMass,
|
||||
driver->GetPosition().x - GetPosition().x,
|
||||
driver->GetPosition().y - GetPosition().y,
|
||||
0.0f);
|
||||
}
|
||||
|
||||
bool
|
||||
CVehicle::AddPassenger(CPed *passenger)
|
||||
{
|
||||
int i;
|
||||
|
||||
ApplyTurnForce(0.0f, 0.0f, -0.2f*passenger->m_fMass,
|
||||
passenger->GetPosition().x - GetPosition().x,
|
||||
passenger->GetPosition().y - GetPosition().y,
|
||||
0.0f);
|
||||
|
||||
for(i = 0; i < m_nNumMaxPassengers; i++)
|
||||
if(pPassengers[i] == nil){
|
||||
pPassengers[i] = passenger;
|
||||
m_nNumPassengers++;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool
|
||||
CVehicle::AddPassenger(CPed *passenger, uint8 n)
|
||||
{
|
||||
if(bIsBus)
|
||||
return AddPassenger(passenger);
|
||||
|
||||
ApplyTurnForce(0.0f, 0.0f, -0.2f*passenger->m_fMass,
|
||||
passenger->GetPosition().x - GetPosition().x,
|
||||
passenger->GetPosition().y - GetPosition().y,
|
||||
0.0f);
|
||||
|
||||
if(n < m_nNumMaxPassengers && pPassengers[n] == nil){
|
||||
pPassengers[n] = passenger;
|
||||
m_nNumPassengers++;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void
|
||||
CVehicle::RemoveDriver(void)
|
||||
{
|
||||
m_status = STATUS_ABANDONED;
|
||||
pDriver = nil;
|
||||
}
|
||||
|
||||
void
|
||||
CVehicle::RemovePassenger(CPed *p)
|
||||
{
|
||||
if (IsTrain()){
|
||||
for (int i = 0; i < 8; i++){
|
||||
if (pPassengers[i] == p) {
|
||||
pPassengers[i] = nil;
|
||||
m_nNumPassengers--;
|
||||
return;
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
for (int i = 0; i < m_nNumMaxPassengers; i++){
|
||||
if (pPassengers[i] == p){
|
||||
pPassengers[i] = nil;
|
||||
m_nNumPassengers--;
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
CVehicle::ProcessCarAlarm(void)
|
||||
{
|
||||
uint32 step;
|
||||
|
||||
if(m_nAlarmState == 0 || m_nAlarmState == -1)
|
||||
return;
|
||||
|
||||
step = CTimer::GetTimeStepInMilliseconds();
|
||||
if((uint16)m_nAlarmState < step)
|
||||
m_nAlarmState = 0;
|
||||
else
|
||||
m_nAlarmState -= step;
|
||||
}
|
||||
|
||||
bool
|
||||
CVehicle::IsSphereTouchingVehicle(float sx, float sy, float sz, float radius)
|
||||
{
|
||||
float x, y, z;
|
||||
// sphere relative to vehicle
|
||||
CVector sph = CVector(sx, sy, sz) - GetPosition();
|
||||
CColModel *colmodel = CModelInfo::GetModelInfo(GetModelIndex())->GetColModel();
|
||||
|
||||
x = DotProduct(sph, GetRight());
|
||||
if(colmodel->boundingBox.min.x - radius > x ||
|
||||
colmodel->boundingBox.max.x + radius < x)
|
||||
return false;
|
||||
y = DotProduct(sph, GetForward());
|
||||
if(colmodel->boundingBox.min.y - radius > y ||
|
||||
colmodel->boundingBox.max.y + radius < y)
|
||||
return false;
|
||||
z = DotProduct(sph, GetUp());
|
||||
if(colmodel->boundingBox.min.z - radius > z ||
|
||||
colmodel->boundingBox.max.z + radius < z)
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
STARTPATCHES
|
||||
InjectHook(0x551170, &CVehicle::SetModelIndex_, PATCH_JUMP);
|
||||
InjectHook(0x4A7DD0, &CVehicle::SetupLighting_, PATCH_JUMP);
|
||||
InjectHook(0x4A7E60, &CVehicle::RemoveLighting_, PATCH_JUMP);
|
||||
InjectHook(0x417E60, &CVehicle::GetHeightAboveRoad_, PATCH_JUMP);
|
||||
|
||||
InjectHook(0x552880, &CVehicle::IsLawEnforcementVehicle, PATCH_JUMP);
|
||||
InjectHook(0x552820, &CVehicle::ChangeLawEnforcerState, PATCH_JUMP);
|
||||
InjectHook(0x552200, &CVehicle::UsesSiren, PATCH_JUMP);
|
||||
InjectHook(0x5527E0, &CVehicle::IsVehicleNormal, PATCH_JUMP);
|
||||
InjectHook(0x552B70, &CVehicle::CarHasRoof, PATCH_JUMP);
|
||||
InjectHook(0x552230, &CVehicle::IsUpsideDown, PATCH_JUMP);
|
||||
InjectHook(0x552260, &CVehicle::IsOnItsSide, PATCH_JUMP);
|
||||
InjectHook(0x5511B0, &CVehicle::CanBeDeleted, PATCH_JUMP);
|
||||
InjectHook(0x5522A0, &CVehicle::CanPedOpenLocks, PATCH_JUMP);
|
||||
InjectHook(0x5522F0, &CVehicle::CanPedEnterCar, PATCH_JUMP);
|
||||
InjectHook(0x5523C0, &CVehicle::CanPedExitCar, PATCH_JUMP);
|
||||
InjectHook(0x5520C0, &CVehicle::SetUpDriver, PATCH_JUMP);
|
||||
InjectHook(0x552160, &CVehicle::SetupPassenger, PATCH_JUMP);
|
||||
InjectHook(0x551F20, &CVehicle::SetDriver, PATCH_JUMP);
|
||||
InjectHook(0x551D90, (bool (CVehicle::*)(CPed*))&CVehicle::AddPassenger, PATCH_JUMP);
|
||||
InjectHook(0x551E10, (bool (CVehicle::*)(CPed*,uint8))&CVehicle::AddPassenger, PATCH_JUMP);
|
||||
InjectHook(0x5520A0, &CVehicle::RemoveDriver, PATCH_JUMP);
|
||||
InjectHook(0x551EB0, &CVehicle::RemovePassenger, PATCH_JUMP);
|
||||
InjectHook(0x5525A0, &CVehicle::ProcessCarAlarm, PATCH_JUMP);
|
||||
InjectHook(0x552620, &CVehicle::IsSphereTouchingVehicle, PATCH_JUMP);
|
||||
ENDPATCHES
|
||||
@ -1,240 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "Physical.h"
|
||||
#include "AutoPilot.h"
|
||||
|
||||
class CPed;
|
||||
class CFire;
|
||||
struct tHandlingData;
|
||||
|
||||
enum {
|
||||
RANDOM_VEHICLE = 1,
|
||||
MISSION_VEHICLE = 2,
|
||||
PARKED_VEHICLE = 3,
|
||||
PERMANENT_VEHICLE = 4,
|
||||
};
|
||||
|
||||
enum eCarLock {
|
||||
CARLOCK_NOT_USED,
|
||||
CARLOCK_UNLOCKED,
|
||||
CARLOCK_LOCKED,
|
||||
CARLOCK_LOCKOUT_PLAYER_ONLY,
|
||||
CARLOCK_LOCKED_PLAYER_INSIDE,
|
||||
CARLOCK_COP_CAR,
|
||||
CARLOCK_FORCE_SHUT_DOORS,
|
||||
CARLOCK_SKIP_SHUT_DOORS
|
||||
};
|
||||
|
||||
|
||||
enum eCarNodes
|
||||
{
|
||||
CAR_WHEEL_RF = 1,
|
||||
CAR_WHEEL_RM,
|
||||
CAR_WHEEL_RB,
|
||||
CAR_WHEEL_LF,
|
||||
CAR_WHEEL_LM,
|
||||
CAR_WHEEL_LB,
|
||||
CAR_BUMP_FRONT,
|
||||
CAR_BUMP_REAR,
|
||||
CAR_WING_RF,
|
||||
CAR_WING_RR,
|
||||
CAR_DOOR_RF,
|
||||
CAR_DOOR_RR,
|
||||
CAR_WING_LF,
|
||||
CAR_WING_LR,
|
||||
CAR_DOOR_LF,
|
||||
CAR_DOOR_LR,
|
||||
CAR_BONNET,
|
||||
CAR_BOOT,
|
||||
CAR_WINDSCREEN,
|
||||
NUM_CAR_NODES,
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
CAR_POS_HEADLIGHTS,
|
||||
CAR_POS_TAILLIGHTS,
|
||||
CAR_POS_FRONTSEAT,
|
||||
CAR_POS_BACKSEAT,
|
||||
CAR_POS_EXHAUST = 9,
|
||||
};
|
||||
|
||||
enum eDoors
|
||||
{
|
||||
DOOR_BONNET = 0,
|
||||
DOOR_BOOT,
|
||||
DOOR_FRONT_LEFT,
|
||||
DOOR_FRONT_RIGHT,
|
||||
DOOR_REAR_LEFT,
|
||||
DOOR_REAR_RIGHT
|
||||
};
|
||||
|
||||
class CVehicle : public CPhysical
|
||||
{
|
||||
public:
|
||||
// 0x128
|
||||
tHandlingData *m_handling;
|
||||
CAutoPilot m_autoPilot;
|
||||
uint8 m_currentColour1;
|
||||
uint8 m_currentColour2;
|
||||
uint8 m_aExtras[2];
|
||||
int16 m_nAlarmState; // m_nWantedStarsOnEnter on DK22
|
||||
int16 m_nMissionValue;
|
||||
CPed *pDriver;
|
||||
CPed *pPassengers[8];
|
||||
uint8 m_nNumPassengers;
|
||||
int8 m_nNumGettingIn;
|
||||
int8 m_nGettingInFlags;
|
||||
int8 m_nGettingOutFlags;
|
||||
uint8 m_nNumMaxPassengers;
|
||||
char field_1CD[19];
|
||||
CEntity *m_pCurSurface;
|
||||
CFire *m_pCarFire;
|
||||
float m_fSteerAngle;
|
||||
float m_fGasPedal;
|
||||
float m_fBreakPedal;
|
||||
uint8 VehicleCreatedBy;
|
||||
|
||||
// cf. https://github.com/DK22Pac/plugin-sdk/blob/master/plugin_sa/game_sa/CVehicle.h from R*
|
||||
uint8 bIsLawEnforcer: 1; // Is this guy chasing the player at the moment
|
||||
uint8 bIsAmbulanceOnDuty: 1; // Ambulance trying to get to an accident
|
||||
uint8 bIsFireTruckOnDuty: 1; // Firetruck trying to get to a fire
|
||||
uint8 bIsLocked: 1; // Is this guy locked by the script (cannot be removed)
|
||||
uint8 bEngineOn: 1; // For sound purposes. Parked cars have their engines switched off (so do destroyed cars)
|
||||
uint8 bIsHandbrakeOn: 1; // How's the handbrake doing ?
|
||||
uint8 bLightsOn: 1; // Are the lights switched on ?
|
||||
uint8 bFreebies: 1; // Any freebies left in this vehicle ?
|
||||
|
||||
uint8 bIsVan: 1; // Is this vehicle a van (doors at back of vehicle)
|
||||
uint8 bIsBus: 1; // Is this vehicle a bus
|
||||
uint8 bIsBig: 1; // Is this vehicle a bus
|
||||
uint8 bLowVehicle: 1; // Need this for sporty type cars to use low getting-in/out anims
|
||||
uint8 m_veh_flagB10 : 1;
|
||||
uint8 m_veh_flagB20 : 1;
|
||||
uint8 m_veh_flagB40 : 1;
|
||||
uint8 m_veh_flagB80 : 1;
|
||||
|
||||
uint8 m_veh_flagC1 : 1;
|
||||
uint8 m_veh_flagC2 : 1;
|
||||
uint8 m_veh_flagC4 : 1;
|
||||
uint8 m_veh_flagC8 : 1;
|
||||
uint8 m_veh_flagC10 : 1;
|
||||
uint8 m_veh_flagC20 : 1;
|
||||
uint8 m_veh_flagC40 : 1;
|
||||
uint8 m_veh_flagC80 : 1;
|
||||
|
||||
uint8 m_veh_flagD1 : 1;
|
||||
uint8 m_veh_flagD2 : 1;
|
||||
uint8 m_veh_flagD4 : 1;
|
||||
uint8 m_veh_flagD8 : 1;
|
||||
uint8 bRecordedForReplay : 1;
|
||||
uint8 m_veh_flagD20 : 1;
|
||||
uint8 m_veh_flagD40 : 1;
|
||||
uint8 m_veh_flagD80 : 1;
|
||||
|
||||
int8 field_1F9;
|
||||
uint8 m_nAmmoInClip; // Used to make the guns on boat do a reload (20 by default)
|
||||
int8 field_1FB;
|
||||
int8 field_1FC[4];
|
||||
float m_fHealth; // 1000.0f = full health. 0 -> explode
|
||||
uint8 m_nCurrentGear;
|
||||
int8 field_205[3];
|
||||
int field_208;
|
||||
uint32 m_nGunFiringTime; // last time when gun on vehicle was fired (used on boats)
|
||||
uint32 m_nTimeOfDeath;
|
||||
int16 field_214;
|
||||
int16 m_nBombTimer; // goes down with each frame
|
||||
CPed *m_pWhoDetonatedMe;
|
||||
float field_21C;
|
||||
float field_220;
|
||||
eCarLock m_nDoorLock;
|
||||
int8 m_nLastWeaponDamage; // see eWeaponType, -1 if no damage
|
||||
int8 m_nRadioStation;
|
||||
int8 field_22A;
|
||||
int8 field_22B;
|
||||
uint8 m_nCarHornTimer;
|
||||
int8 field_22D;
|
||||
uint8 m_nSirenOrAlarm;
|
||||
int8 field_22F;
|
||||
// TODO: this is an array
|
||||
CStoredCollPoly m_frontCollPoly; // poly which is under front part of car
|
||||
CStoredCollPoly m_rearCollPoly; // poly which is under rear part of car
|
||||
float m_fSteerRatio;
|
||||
eVehicleType m_vehType;
|
||||
|
||||
static void *operator new(size_t);
|
||||
static void *operator new(size_t sz, int slot);
|
||||
static void operator delete(void*, size_t);
|
||||
static void operator delete(void*, int);
|
||||
|
||||
~CVehicle(void);
|
||||
// from CEntity
|
||||
void SetModelIndex(uint32 i);
|
||||
bool SetupLighting(void);
|
||||
void RemoveLighting(bool);
|
||||
void FlagToDestroyWhenNextProcessed(void) {}
|
||||
|
||||
virtual void ProcessControlInputs(uint8) {}
|
||||
virtual void GetComponentWorldPosition(int32 component, CVector &pos) {}
|
||||
virtual bool IsComponentPresent(int32 component) { return false; }
|
||||
virtual void SetComponentRotation(int32 component, CVector rotation) {}
|
||||
virtual void OpenDoor(int32, eDoors door, float) {}
|
||||
virtual void ProcessOpenDoor(uint32, uint32, float) {}
|
||||
virtual bool IsDoorReady(eDoors door) { return false; }
|
||||
virtual bool IsDoorFullyOpen(eDoors door) { return false; }
|
||||
virtual bool IsDoorClosed(eDoors door) { return false; }
|
||||
virtual bool IsDoorMissing(eDoors door) { return false; }
|
||||
virtual void RemoveRefsToVehicle(CEntity *ent) {}
|
||||
virtual void BlowUpCar(CEntity *ent) {}
|
||||
virtual bool SetUpWheelColModel(CColModel *colModel) { return false; }
|
||||
virtual void BurstTyre(uint8 tyre) {}
|
||||
virtual bool IsRoomForPedToLeaveCar(uint32, CVector *) { return false;}
|
||||
virtual float GetHeightAboveRoad(void);
|
||||
virtual void PlayCarHorn(void) {}
|
||||
|
||||
bool IsCar(void) { return m_vehType == VEHICLE_TYPE_CAR; }
|
||||
bool IsBoat(void) { return m_vehType == VEHICLE_TYPE_BOAT; }
|
||||
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; }
|
||||
bool IsLawEnforcementVehicle(void);
|
||||
void ChangeLawEnforcerState(uint8 enable);
|
||||
bool UsesSiren(uint32 id);
|
||||
bool IsVehicleNormal(void);
|
||||
bool CarHasRoof(void);
|
||||
bool IsUpsideDown(void);
|
||||
bool IsOnItsSide(void);
|
||||
bool CanBeDeleted(void);
|
||||
bool CanPedOpenLocks(CPed *ped);
|
||||
bool CanPedEnterCar(void);
|
||||
bool CanPedExitCar(void);
|
||||
// do these two actually return something?
|
||||
CPed *SetUpDriver(void);
|
||||
CPed *SetupPassenger(int n);
|
||||
void SetDriver(CPed *driver);
|
||||
bool AddPassenger(CPed *passenger);
|
||||
bool AddPassenger(CPed *passenger, uint8 n);
|
||||
void RemovePassenger(CPed *passenger);
|
||||
void RemoveDriver(void);
|
||||
void ProcessCarAlarm(void);
|
||||
bool IsSphereTouchingVehicle(float sx, float sy, float sz, float radius);
|
||||
|
||||
static bool &bWheelsOnlyCheat;
|
||||
static bool &bAllDodosCheat;
|
||||
static bool &bCheat3;
|
||||
static bool &bCheat4;
|
||||
static bool &bCheat5;
|
||||
static bool &m_bDisableMouseSteering;
|
||||
|
||||
|
||||
void dtor(void) { CVehicle::~CVehicle(); }
|
||||
void SetModelIndex_(uint32 id) { CVehicle::SetModelIndex(id); }
|
||||
bool SetupLighting_(void) { return CVehicle::SetupLighting(); }
|
||||
void RemoveLighting_(bool reset) { CVehicle::RemoveLighting(reset); }
|
||||
float GetHeightAboveRoad_(void) { return CVehicle::GetHeightAboveRoad(); }
|
||||
};
|
||||
|
||||
static_assert(sizeof(CVehicle) == 0x288, "CVehicle: error");
|
||||
static_assert(offsetof(CVehicle, m_pCurSurface) == 0x1E0, "CVehicle: error");
|
||||
static_assert(offsetof(CVehicle, m_nAlarmState) == 0x1A0, "CVehicle: error");
|
||||
static_assert(offsetof(CVehicle, m_nLastWeaponDamage) == 0x228, "CVehicle: error");
|
||||
Reference in New Issue
Block a user