mirror of
https://git.rip/DMCA_FUCKER/re3.git
synced 2024-12-23 11:40:00 +00:00
pools compatibility
This commit is contained in:
parent
fbca45239d
commit
74fde1397e
2
librw
2
librw
|
@ -1 +1 @@
|
|||
Subproject commit 43190a51f799a3ef315c0b6245b70ee3a09a64ac
|
||||
Subproject commit d8d13d44293a58b58d51c3a8e91e3ea76c6d6feb
|
|
@ -110,17 +110,31 @@ INITSAVEBUF
|
|||
CStreaming::LoadAllRequestedModels(false);
|
||||
int32 slot = ReadSaveBuf<int32>(buf);
|
||||
CVehicle* pVehicle;
|
||||
#ifdef COMPATIBLE_SAVES
|
||||
char* vbuf = new char[Max(sizeof(CAutomobile_FS), sizeof(CBoat_FS))];
|
||||
#else
|
||||
char* vbuf = new char[Max(sizeof(CAutomobile), sizeof(CBoat))];
|
||||
#endif
|
||||
if (type == VEHICLE_TYPE_BOAT) {
|
||||
#ifdef COMPATIBLE_SAVES
|
||||
memcpy(vbuf, buf, sizeof(CBoat_FS));
|
||||
SkipSaveBuf(buf, sizeof(CBoat_FS));
|
||||
#else
|
||||
memcpy(vbuf, buf, sizeof(CBoat));
|
||||
SkipSaveBuf(buf, sizeof(CBoat));
|
||||
#endif
|
||||
CBoat* pBoat = new(slot) CBoat(model, RANDOM_VEHICLE);
|
||||
pVehicle = pBoat;
|
||||
--CCarCtrl::NumRandomCars; // why?
|
||||
}
|
||||
else if (type == VEHICLE_TYPE_CAR) {
|
||||
#ifdef COMPATIBLE_SAVES
|
||||
memcpy(vbuf, buf, sizeof(CAutomobile_FS));
|
||||
SkipSaveBuf(buf, sizeof(CAutomobile_FS));
|
||||
#else
|
||||
memcpy(vbuf, buf, sizeof(CAutomobile));
|
||||
SkipSaveBuf(buf, sizeof(CAutomobile));
|
||||
#endif
|
||||
CStreaming::RequestModel(model, 0); // is it needed?
|
||||
CStreaming::LoadAllRequestedModels(false);
|
||||
CAutomobile* pAutomobile = new(slot) CAutomobile(model, RANDOM_VEHICLE);
|
||||
|
@ -131,6 +145,10 @@ INITSAVEBUF
|
|||
}
|
||||
else
|
||||
assert(0);
|
||||
#ifdef COMPATIBLE_SAVES
|
||||
CVehicle_FS* pBufferVehicle = (CVehicle_FS*)vbuf;
|
||||
pBufferVehicle->Restore(pVehicle);
|
||||
#else
|
||||
CVehicle* pBufferVehicle = (CVehicle*)vbuf;
|
||||
pVehicle->GetMatrix() = pBufferVehicle->GetMatrix();
|
||||
pVehicle->VehicleCreatedBy = pBufferVehicle->VehicleCreatedBy;
|
||||
|
@ -166,6 +184,7 @@ INITSAVEBUF
|
|||
(pVehicle->GetAddressOfEntityProperties())[0] = (pBufferVehicle->GetAddressOfEntityProperties())[0];
|
||||
(pVehicle->GetAddressOfEntityProperties())[1] = (pBufferVehicle->GetAddressOfEntityProperties())[1];
|
||||
pVehicle->AutoPilot = pBufferVehicle->AutoPilot;
|
||||
#endif
|
||||
CWorld::Add(pVehicle);
|
||||
delete[] vbuf;
|
||||
}
|
||||
|
@ -184,7 +203,7 @@ INITSAVEBUF
|
|||
continue;
|
||||
bool bHasPassenger = false;
|
||||
for (int j = 0; j < ARRAY_SIZE(pVehicle->pPassengers); j++) {
|
||||
if (pVehicle->pPassengers[i])
|
||||
if (pVehicle->pPassengers[j])
|
||||
bHasPassenger = true;
|
||||
}
|
||||
if (!pVehicle->pDriver && !bHasPassenger) {
|
||||
|
@ -194,8 +213,20 @@ INITSAVEBUF
|
|||
++nNumBoats;
|
||||
}
|
||||
}
|
||||
*size = nNumCars * (sizeof(uint32) + sizeof(int16) + sizeof(int32) + sizeof(CAutomobile)) + sizeof(int) +
|
||||
nNumBoats * (sizeof(uint32) + sizeof(int16) + sizeof(int32) + sizeof(CBoat)) + sizeof(int);
|
||||
*size = nNumCars * (sizeof(uint32) + sizeof(int16) + sizeof(int32) +
|
||||
#ifdef COMPATIBLE_SAVES
|
||||
sizeof(CAutomobile_FS)) +
|
||||
#else
|
||||
sizeof(CAutomobile)) +
|
||||
#endif
|
||||
sizeof(int) +
|
||||
nNumBoats * (sizeof(uint32) + sizeof(int16) + sizeof(int32) +
|
||||
#ifdef COMPATIBLE_SAVES
|
||||
sizeof(CBoat_FS)) +
|
||||
#else
|
||||
sizeof(CBoat)) +
|
||||
#endif
|
||||
sizeof(int);
|
||||
WriteSaveBuf(buf, nNumCars);
|
||||
WriteSaveBuf(buf, nNumBoats);
|
||||
for (int i = 0; i < nPoolSize; i++) {
|
||||
|
@ -212,8 +243,15 @@ INITSAVEBUF
|
|||
WriteSaveBuf(buf, (uint32)pVehicle->m_vehType);
|
||||
WriteSaveBuf(buf, pVehicle->m_modelIndex);
|
||||
WriteSaveBuf(buf, GetVehicleRef(pVehicle));
|
||||
#ifdef COMPATIBLE_SAVES
|
||||
((CVehicle_FS*)buf)->Store(pVehicle);
|
||||
SkipSaveBuf(buf, sizeof(CVehicle_FS));
|
||||
WriteSaveBuf(buf, ((CAutomobile*)pVehicle)->Damage);
|
||||
SkipSaveBuf(buf, sizeof(CAutomobile_FS) - sizeof(CVehicle_FS) - sizeof(CDamageManager));
|
||||
#else
|
||||
memcpy(buf, pVehicle, sizeof(CAutomobile));
|
||||
SkipSaveBuf(buf, sizeof(CAutomobile));
|
||||
#endif
|
||||
}
|
||||
if (pVehicle->IsBoat() && pVehicle->VehicleCreatedBy == MISSION_VEHICLE) {
|
||||
WriteSaveBuf(buf, (uint32)pVehicle->m_vehType);
|
||||
|
@ -279,8 +317,14 @@ INITSAVEBUF
|
|||
WriteSaveBuf(buf, pObject->m_nCollisionDamageEffect);
|
||||
WriteSaveBuf(buf, pObject->m_nSpecialCollisionResponseCases);
|
||||
WriteSaveBuf(buf, pObject->m_nEndOfLifeTime);
|
||||
#ifdef COMPATIBLE_SAVES
|
||||
CEntityProperties properties;
|
||||
properties.Store(pObject);
|
||||
WriteSaveBuf(buf, properties);
|
||||
#else
|
||||
WriteSaveBuf(buf, (pObject->GetAddressOfEntityProperties())[0]);
|
||||
WriteSaveBuf(buf, (pObject->GetAddressOfEntityProperties())[1]);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
VALIDATESAVEBUF(*size)
|
||||
|
@ -315,8 +359,12 @@ INITSAVEBUF
|
|||
pBufferObject->m_nCollisionDamageEffect = ReadSaveBuf<uint8>(buf);
|
||||
pBufferObject->m_nSpecialCollisionResponseCases = ReadSaveBuf<uint8>(buf);
|
||||
pBufferObject->m_nEndOfLifeTime = ReadSaveBuf<uint32>(buf);
|
||||
#ifdef COMPATIBLE_SAVES
|
||||
CEntityProperties properties = ReadSaveBuf<CEntityProperties>(buf);
|
||||
#else
|
||||
(pBufferObject->GetAddressOfEntityProperties())[0] = ReadSaveBuf<uint32>(buf);
|
||||
(pBufferObject->GetAddressOfEntityProperties())[1] = ReadSaveBuf<uint32>(buf);
|
||||
#endif
|
||||
if (GetObjectPool()->GetSlot(ref >> 8))
|
||||
CPopulation::ConvertToDummyObject(GetObjectPool()->GetSlot(ref >> 8));
|
||||
CObject* pObject = new(ref) CObject(mi, false);
|
||||
|
@ -335,8 +383,12 @@ INITSAVEBUF
|
|||
pObject->m_nCollisionDamageEffect = pBufferObject->m_nCollisionDamageEffect;
|
||||
pObject->m_nSpecialCollisionResponseCases = pBufferObject->m_nSpecialCollisionResponseCases;
|
||||
pObject->m_nEndOfLifeTime = pBufferObject->m_nEndOfLifeTime;
|
||||
#ifdef COMPATIBLE_SAVES
|
||||
properties.Restore(pObject);
|
||||
#else
|
||||
(pObject->GetAddressOfEntityProperties())[0] = (pBufferObject->GetAddressOfEntityProperties())[0];
|
||||
(pObject->GetAddressOfEntityProperties())[1] = (pBufferObject->GetAddressOfEntityProperties())[1];
|
||||
#endif
|
||||
pObject->bHasCollided = false;
|
||||
CWorld::Add(pObject);
|
||||
delete[] obuf;
|
||||
|
@ -356,7 +408,12 @@ INITSAVEBUF
|
|||
if (!pPed->bInVehicle && pPed->m_nPedType == PEDTYPE_PLAYER1)
|
||||
nNumPeds++;
|
||||
}
|
||||
*size = sizeof(int) + nNumPeds * (sizeof(uint32) + sizeof(int16) + sizeof(int) + sizeof(CPlayerPed) +
|
||||
*size = sizeof(int) + nNumPeds * (sizeof(uint32) + sizeof(int16) + sizeof(int) +
|
||||
#ifdef COMPATIBLE_SAVES
|
||||
sizeof(CPlayerPed_FS) +
|
||||
#else
|
||||
sizeof(CPlayerPed) +
|
||||
#endif
|
||||
sizeof(CWanted::MaximumWantedLevel) + sizeof(CWanted::nMaximumWantedLevel) + MAX_MODEL_NAME);
|
||||
WriteSaveBuf(buf, nNumPeds);
|
||||
for (int i = 0; i < nPoolSize; i++) {
|
||||
|
@ -367,8 +424,14 @@ INITSAVEBUF
|
|||
WriteSaveBuf(buf, pPed->m_nPedType);
|
||||
WriteSaveBuf(buf, pPed->m_modelIndex);
|
||||
WriteSaveBuf(buf, GetPedRef(pPed));
|
||||
#ifdef COMPATIBLE_SAVES
|
||||
((CPlayerPed_FS*)buf)->StorePlayerPed((CPlayerPed*)pPed);
|
||||
((CPlayerPed_FS*)buf)->StorePed(pPed);
|
||||
SkipSaveBuf(buf, sizeof(CPlayerPed_FS));
|
||||
#else
|
||||
memcpy(buf, pPed, sizeof(CPlayerPed));
|
||||
SkipSaveBuf(buf, sizeof(CPlayerPed));
|
||||
#endif
|
||||
WriteSaveBuf(buf, CWanted::MaximumWantedLevel);
|
||||
WriteSaveBuf(buf, CWanted::nMaximumWantedLevel);
|
||||
memcpy(buf, CModelInfo::GetModelInfo(pPed->GetModelIndex())->GetName(), MAX_MODEL_NAME);
|
||||
|
@ -386,14 +449,24 @@ INITSAVEBUF
|
|||
uint32 pedtype = ReadSaveBuf<uint32>(buf);
|
||||
int16 model = ReadSaveBuf<int16>(buf);
|
||||
int ref = ReadSaveBuf<int>(buf);
|
||||
#ifdef COMPATIBLE_SAVES
|
||||
char* pbuf = new char[sizeof(CPlayerPed_FS)];
|
||||
CPlayerPed_FS* pBufferPlayer = (CPlayerPed_FS*)buf;
|
||||
#else
|
||||
char* pbuf = new char[sizeof(CPlayerPed)];
|
||||
CPlayerPed* pBufferPlayer = (CPlayerPed*)pbuf;
|
||||
#endif
|
||||
CPed* pPed;
|
||||
char name[MAX_MODEL_NAME];
|
||||
// the code implies that there was idea to load non-player ped
|
||||
if (pedtype == PEDTYPE_PLAYER1) { // always true
|
||||
#ifdef COMPATIBLE_SAVES
|
||||
memcpy(pbuf, buf, sizeof(CPlayerPed_FS));
|
||||
SkipSaveBuf(buf, sizeof(CPlayerPed_FS));
|
||||
#else
|
||||
memcpy(pbuf, buf, sizeof(CPlayerPed));
|
||||
SkipSaveBuf(buf, sizeof(CPlayerPed));
|
||||
#endif
|
||||
CWanted::MaximumWantedLevel = ReadSaveBuf<int32>(buf);
|
||||
CWanted::nMaximumWantedLevel = ReadSaveBuf<int32>(buf);
|
||||
memcpy(name, buf, MAX_MODEL_NAME);
|
||||
|
@ -403,11 +476,19 @@ INITSAVEBUF
|
|||
CStreaming::LoadAllRequestedModels(false);
|
||||
if (pedtype == PEDTYPE_PLAYER1) {
|
||||
CPlayerPed* pPlayerPed = new(ref) CPlayerPed();
|
||||
#ifdef COMPATIBLE_SAVES
|
||||
pBufferPlayer->RestorePlayerPed(pPlayerPed);
|
||||
#else
|
||||
for (int i = 0; i < ARRAY_SIZE(pPlayerPed->m_nTargettableObjects); i++)
|
||||
pPlayerPed->m_nTargettableObjects[i] = pBufferPlayer->m_nTargettableObjects[i];
|
||||
pPlayerPed->m_fMaxStamina = pBufferPlayer->m_fMaxStamina;
|
||||
#endif
|
||||
pPed = pPlayerPed;
|
||||
}
|
||||
#ifdef COMPATIBLE_SAVES
|
||||
pBufferPlayer->RestorePed(pPed);
|
||||
pPed->m_currentWeapon = 0;
|
||||
#else
|
||||
pPed->GetPosition() = pBufferPlayer->GetPosition();
|
||||
pPed->m_fHealth = pBufferPlayer->m_fHealth;
|
||||
pPed->m_fArmour = pBufferPlayer->m_fArmour;
|
||||
|
@ -416,6 +497,7 @@ INITSAVEBUF
|
|||
pPed->m_maxWeaponTypeAllowed = pBufferPlayer->m_maxWeaponTypeAllowed;
|
||||
for (int i = 0; i < WEAPONTYPE_TOTAL_INVENTORY_WEAPONS; i++)
|
||||
pPed->m_weapons[i] = pBufferPlayer->m_weapons[i];
|
||||
#endif
|
||||
if (pedtype == PEDTYPE_PLAYER1) {
|
||||
pPed->m_wepAccuracy = 100;
|
||||
CWorld::Players[0].m_pPed = (CPlayerPed*)pPed;
|
||||
|
|
534
src/core/Pools.h
534
src/core/Pools.h
|
@ -59,3 +59,537 @@ public:
|
|||
static void SavePedPool(uint8 *buf, uint32 *size);
|
||||
static void SaveVehiclePool(uint8 *buf, uint32 *size);
|
||||
};
|
||||
|
||||
#ifdef COMPATIBLE_SAVES
|
||||
|
||||
// Following stuff allows changing structures like CPed, CAutomobile and CBoat without breaking compatibility with original saves.
|
||||
|
||||
// For saving we have to assume that sizeof(void*) == 4, so we use int32 everywhere.
|
||||
// It will break some pointers, but saving them makes no sense anyway.
|
||||
|
||||
struct CEntityProperties
|
||||
{
|
||||
// these properties are defined exactly as in original game
|
||||
|
||||
uint32 m_type : 3;
|
||||
uint32 m_status : 5;
|
||||
|
||||
// flagsA
|
||||
uint32 bUsesCollision : 1; // does entity use collision
|
||||
uint32 bCollisionProcessed : 1; // has object been processed by a ProcessEntityCollision function
|
||||
uint32 bIsStatic : 1; // is entity static
|
||||
uint32 bHasContacted : 1; // has entity processed some contact forces
|
||||
uint32 bPedPhysics : 1;
|
||||
uint32 bIsStuck : 1; // is entity stuck
|
||||
uint32 bIsInSafePosition : 1; // is entity in a collision free safe position
|
||||
uint32 bUseCollisionRecords : 1;
|
||||
|
||||
// flagsB
|
||||
uint32 bWasPostponed : 1; // was entity control processing postponed
|
||||
uint32 bExplosionProof : 1;
|
||||
uint32 bIsVisible : 1; //is the entity visible
|
||||
uint32 bHasCollided : 1;
|
||||
uint32 bRenderScorched : 1;
|
||||
uint32 bHasBlip : 1;
|
||||
uint32 bIsBIGBuilding : 1; // Set if this entity is a big building
|
||||
// VC inserts one more flag here: if drawdist <= 2000
|
||||
uint32 bRenderDamaged : 1; // use damaged LOD models for objects with applicable damage
|
||||
|
||||
// flagsC
|
||||
uint32 bBulletProof : 1;
|
||||
uint32 bFireProof : 1;
|
||||
uint32 bCollisionProof : 1;
|
||||
uint32 bMeleeProof : 1;
|
||||
uint32 bOnlyDamagedByPlayer : 1;
|
||||
uint32 bStreamingDontDelete : 1; // Dont let the streaming remove this
|
||||
uint32 bZoneCulled : 1;
|
||||
uint32 bZoneCulled2 : 1; // only treadables+10m
|
||||
|
||||
// flagsD
|
||||
uint32 bRemoveFromWorld : 1; // remove this entity next time it should be processed
|
||||
uint32 bHasHitWall : 1; // has collided with a building (changes subsequent collisions)
|
||||
uint32 bImBeingRendered : 1; // don't delete me because I'm being rendered
|
||||
uint32 bTouchingWater : 1; // used by cBuoyancy::ProcessBuoyancy
|
||||
uint32 bIsSubway : 1; // set when subway, but maybe different meaning?
|
||||
uint32 bDrawLast : 1; // draw object last
|
||||
uint32 bNoBrightHeadLights : 1;
|
||||
uint32 bDoNotRender : 1;
|
||||
|
||||
// flagsE
|
||||
uint32 bDistanceFade : 1; // Fade entity because it is far away
|
||||
uint32 m_flagE2 : 1;
|
||||
|
||||
void Store(CEntity* pEntity)
|
||||
{
|
||||
m_type = pEntity->m_type;
|
||||
m_status = pEntity->m_status;
|
||||
bUsesCollision = pEntity->bUsesCollision;
|
||||
bCollisionProcessed = pEntity->bCollisionProcessed;
|
||||
bIsStatic = pEntity->bIsStatic;
|
||||
bHasContacted = pEntity->bHasContacted;
|
||||
bPedPhysics = pEntity->bPedPhysics;
|
||||
bIsStuck = pEntity->bIsStuck;
|
||||
bIsInSafePosition = pEntity->bIsInSafePosition;
|
||||
bUseCollisionRecords = pEntity->bUseCollisionRecords;
|
||||
bWasPostponed = pEntity->bWasPostponed;
|
||||
bExplosionProof = pEntity->bExplosionProof;
|
||||
bIsVisible = pEntity->bIsVisible;
|
||||
bHasCollided = pEntity->bHasCollided;
|
||||
bRenderScorched = pEntity->bRenderScorched;
|
||||
bHasBlip = pEntity->bHasBlip;
|
||||
bIsBIGBuilding = pEntity->bIsBIGBuilding;
|
||||
bRenderDamaged = pEntity->bRenderDamaged;
|
||||
bBulletProof = pEntity->bBulletProof;
|
||||
bFireProof = pEntity->bFireProof;
|
||||
bCollisionProof = pEntity->bCollisionProof;
|
||||
bMeleeProof = pEntity->bMeleeProof;
|
||||
bOnlyDamagedByPlayer = pEntity->bOnlyDamagedByPlayer;
|
||||
bStreamingDontDelete = pEntity->bStreamingDontDelete;
|
||||
bZoneCulled = pEntity->bZoneCulled;
|
||||
bZoneCulled2 = pEntity->bZoneCulled2;
|
||||
bRemoveFromWorld = pEntity->bRemoveFromWorld;
|
||||
bHasHitWall = pEntity->bHasHitWall;
|
||||
bImBeingRendered = pEntity->bImBeingRendered;
|
||||
bTouchingWater = pEntity->bTouchingWater;
|
||||
bIsSubway = pEntity->bIsSubway;
|
||||
bDrawLast = pEntity->bDrawLast;
|
||||
bNoBrightHeadLights = pEntity->bNoBrightHeadLights;
|
||||
bDoNotRender = pEntity->bDoNotRender;
|
||||
bDistanceFade = pEntity->bDistanceFade;
|
||||
m_flagE2 = pEntity->m_flagE2;
|
||||
}
|
||||
|
||||
void Restore(CEntity* pEntity)
|
||||
{
|
||||
pEntity->m_type = m_type;
|
||||
pEntity->m_status = m_status;
|
||||
pEntity->bUsesCollision = bUsesCollision;
|
||||
pEntity->bCollisionProcessed = bCollisionProcessed;
|
||||
pEntity->bIsStatic = bIsStatic;
|
||||
pEntity->bHasContacted = bHasContacted;
|
||||
pEntity->bPedPhysics = bPedPhysics;
|
||||
pEntity->bIsStuck = bIsStuck;
|
||||
pEntity->bIsInSafePosition = bIsInSafePosition;
|
||||
pEntity->bUseCollisionRecords = bUseCollisionRecords;
|
||||
pEntity->bWasPostponed = bWasPostponed;
|
||||
pEntity->bExplosionProof = bExplosionProof;
|
||||
pEntity->bIsVisible = bIsVisible;
|
||||
pEntity->bHasCollided = bHasCollided;
|
||||
pEntity->bRenderScorched = bRenderScorched;
|
||||
pEntity->bHasBlip = bHasBlip;
|
||||
pEntity->bIsBIGBuilding = bIsBIGBuilding;
|
||||
pEntity->bRenderDamaged = bRenderDamaged;
|
||||
pEntity->bBulletProof = bBulletProof;
|
||||
pEntity->bFireProof = bFireProof;
|
||||
pEntity->bCollisionProof = bCollisionProof;
|
||||
pEntity->bMeleeProof = bMeleeProof;
|
||||
pEntity->bOnlyDamagedByPlayer = bOnlyDamagedByPlayer;
|
||||
pEntity->bStreamingDontDelete = bStreamingDontDelete;
|
||||
pEntity->bZoneCulled = bZoneCulled;
|
||||
pEntity->bZoneCulled2 = bZoneCulled2;
|
||||
pEntity->bRemoveFromWorld = bRemoveFromWorld;
|
||||
pEntity->bHasHitWall = bHasHitWall;
|
||||
pEntity->bImBeingRendered = bImBeingRendered;
|
||||
pEntity->bTouchingWater = bTouchingWater;
|
||||
pEntity->bIsSubway = bIsSubway;
|
||||
pEntity->bDrawLast = bDrawLast;
|
||||
pEntity->bNoBrightHeadLights = bNoBrightHeadLights;
|
||||
pEntity->bDoNotRender = bDoNotRender;
|
||||
pEntity->bDistanceFade = bDistanceFade;
|
||||
pEntity->m_flagE2 = m_flagE2;
|
||||
}
|
||||
};
|
||||
|
||||
VALIDATE_SIZE(CEntityProperties, 8);
|
||||
|
||||
struct CAutoPilot_FS
|
||||
{
|
||||
int32 m_nCurrentRouteNode;
|
||||
int32 m_nNextRouteNode;
|
||||
int32 m_nPrevRouteNode;
|
||||
uint32 m_nTimeEnteredCurve;
|
||||
uint32 m_nTimeToSpendOnCurrentCurve;
|
||||
uint32 m_nCurrentPathNodeInfo;
|
||||
uint32 m_nNextPathNodeInfo;
|
||||
uint32 m_nPreviousPathNodeInfo;
|
||||
uint32 m_nAntiReverseTimer;
|
||||
uint32 m_nTimeToStartMission;
|
||||
int8 m_nPreviousDirection;
|
||||
int8 m_nCurrentDirection;
|
||||
int8 m_nNextDirection;
|
||||
int8 m_nCurrentLane;
|
||||
int8 m_nNextLane;
|
||||
uint8 m_nDrivingStyle;
|
||||
uint8 m_nCarMission;
|
||||
uint8 m_nTempAction;
|
||||
uint32 m_nTimeTempAction;
|
||||
float m_fMaxTrafficSpeed;
|
||||
uint8 m_nCruiseSpeed;
|
||||
uint8 m_bSlowedDownBecauseOfCars : 1;
|
||||
uint8 m_bSlowedDownBecauseOfPeds : 1;
|
||||
uint8 m_bStayInCurrentLevel : 1;
|
||||
uint8 m_bStayInFastLane : 1;
|
||||
uint8 m_bIgnorePathfinding : 1;
|
||||
float m_vecDestinationCoors[3];
|
||||
int32 m_aPathFindNodesInfo[8]; // CPathNode* [NUM_PATH_NODES_IN_AUTOPILOT]
|
||||
int16 m_nPathFindNodesCount;
|
||||
int32 m_pTargetCar;
|
||||
|
||||
void Store(CAutoPilot* pAutoPilot)
|
||||
{
|
||||
m_nCurrentRouteNode = pAutoPilot->m_nCurrentRouteNode;
|
||||
m_nNextRouteNode = pAutoPilot->m_nNextRouteNode;
|
||||
m_nPrevRouteNode = pAutoPilot->m_nPrevRouteNode;
|
||||
m_nTimeEnteredCurve = pAutoPilot->m_nTimeEnteredCurve;
|
||||
m_nTimeToSpendOnCurrentCurve = pAutoPilot->m_nTimeToSpendOnCurrentCurve;
|
||||
m_nCurrentPathNodeInfo = pAutoPilot->m_nCurrentPathNodeInfo;
|
||||
m_nNextPathNodeInfo = pAutoPilot->m_nNextPathNodeInfo;
|
||||
m_nPreviousPathNodeInfo = pAutoPilot->m_nPreviousPathNodeInfo;
|
||||
m_nAntiReverseTimer = pAutoPilot->m_nAntiReverseTimer;
|
||||
m_nTimeToStartMission = pAutoPilot->m_nTimeToStartMission;
|
||||
m_nPreviousDirection = pAutoPilot->m_nPreviousDirection;
|
||||
m_nCurrentDirection = pAutoPilot->m_nCurrentDirection;
|
||||
m_nNextDirection = pAutoPilot->m_nNextDirection;
|
||||
m_nCurrentLane = pAutoPilot->m_nCurrentLane;
|
||||
m_nNextLane = pAutoPilot->m_nNextLane;
|
||||
m_nDrivingStyle = pAutoPilot->m_nDrivingStyle;
|
||||
m_nCarMission = pAutoPilot->m_nCarMission;
|
||||
m_nTempAction = pAutoPilot->m_nTempAction;
|
||||
m_nTimeTempAction = pAutoPilot->m_nTimeTempAction;
|
||||
m_fMaxTrafficSpeed = pAutoPilot->m_fMaxTrafficSpeed;
|
||||
m_nCruiseSpeed = pAutoPilot->m_nCruiseSpeed;
|
||||
m_bSlowedDownBecauseOfCars = pAutoPilot->m_bSlowedDownBecauseOfCars;
|
||||
m_bSlowedDownBecauseOfPeds = pAutoPilot->m_bSlowedDownBecauseOfPeds;
|
||||
m_bStayInCurrentLevel = pAutoPilot->m_bStayInCurrentLevel;
|
||||
m_bStayInFastLane = pAutoPilot->m_bStayInFastLane;
|
||||
m_bIgnorePathfinding = pAutoPilot->m_bIgnorePathfinding;
|
||||
m_vecDestinationCoors[0] = pAutoPilot->m_vecDestinationCoors.x;
|
||||
m_vecDestinationCoors[1] = pAutoPilot->m_vecDestinationCoors.y;
|
||||
m_vecDestinationCoors[2] = pAutoPilot->m_vecDestinationCoors.z;
|
||||
for (int i = 0; i < 8; i++)
|
||||
m_aPathFindNodesInfo[i] = 0;
|
||||
m_nPathFindNodesCount = pAutoPilot->m_nPathFindNodesCount;
|
||||
m_pTargetCar = 0;
|
||||
}
|
||||
|
||||
void Restore(CAutoPilot* pAutoPilot)
|
||||
{
|
||||
pAutoPilot->m_nCurrentRouteNode = m_nCurrentRouteNode;
|
||||
pAutoPilot->m_nNextRouteNode = m_nNextRouteNode;
|
||||
pAutoPilot->m_nPrevRouteNode = m_nPrevRouteNode;
|
||||
pAutoPilot->m_nTimeEnteredCurve = m_nTimeEnteredCurve;
|
||||
pAutoPilot->m_nTimeToSpendOnCurrentCurve = m_nTimeToSpendOnCurrentCurve;
|
||||
pAutoPilot->m_nCurrentPathNodeInfo = m_nCurrentPathNodeInfo;
|
||||
pAutoPilot->m_nNextPathNodeInfo = m_nNextPathNodeInfo;
|
||||
pAutoPilot->m_nPreviousPathNodeInfo = m_nPreviousPathNodeInfo;
|
||||
pAutoPilot->m_nAntiReverseTimer = m_nAntiReverseTimer;
|
||||
pAutoPilot->m_nTimeToStartMission = m_nTimeToStartMission;
|
||||
pAutoPilot->m_nPreviousDirection = m_nPreviousDirection;
|
||||
pAutoPilot->m_nCurrentDirection = m_nCurrentDirection;
|
||||
pAutoPilot->m_nNextDirection = m_nNextDirection;
|
||||
pAutoPilot->m_nCurrentLane = m_nCurrentLane;
|
||||
pAutoPilot->m_nNextLane = m_nNextLane;
|
||||
pAutoPilot->m_nDrivingStyle = (eCarDrivingStyle)m_nDrivingStyle;
|
||||
pAutoPilot->m_nCarMission = (eCarMission)m_nCarMission;
|
||||
pAutoPilot->m_nTempAction = (eCarTempAction)m_nTempAction;
|
||||
pAutoPilot->m_nTimeTempAction = m_nTimeTempAction;
|
||||
pAutoPilot->m_fMaxTrafficSpeed = m_fMaxTrafficSpeed;
|
||||
pAutoPilot->m_nCruiseSpeed = m_nCruiseSpeed;
|
||||
pAutoPilot->m_bSlowedDownBecauseOfCars = m_bSlowedDownBecauseOfCars;
|
||||
pAutoPilot->m_bSlowedDownBecauseOfPeds = m_bSlowedDownBecauseOfPeds;
|
||||
pAutoPilot->m_bStayInCurrentLevel = m_bStayInCurrentLevel;
|
||||
pAutoPilot->m_bStayInFastLane = m_bStayInFastLane;
|
||||
pAutoPilot->m_bIgnorePathfinding = m_bIgnorePathfinding;
|
||||
pAutoPilot->m_vecDestinationCoors.x = m_vecDestinationCoors[0];
|
||||
pAutoPilot->m_vecDestinationCoors.y = m_vecDestinationCoors[1];
|
||||
pAutoPilot->m_vecDestinationCoors.z = m_vecDestinationCoors[2];
|
||||
for (int i = 0; i < NUM_PATH_NODES_IN_AUTOPILOT; i++)
|
||||
pAutoPilot->m_aPathFindNodesInfo[i] = nil;
|
||||
pAutoPilot->m_nPathFindNodesCount = m_nPathFindNodesCount;
|
||||
pAutoPilot->m_pTargetCar = nil;
|
||||
}
|
||||
};
|
||||
|
||||
struct CMatrix_FS
|
||||
{
|
||||
float right[3];
|
||||
uint8 gap1[4];
|
||||
float forward[3];
|
||||
uint8 gap2[4];
|
||||
float up[3];
|
||||
uint8 gap3[4];
|
||||
float pos[3];
|
||||
uint8 gap4[12];
|
||||
|
||||
void Store(CMatrix* pMatrix)
|
||||
{
|
||||
right[0] = pMatrix->GetRight().x;
|
||||
right[1] = pMatrix->GetRight().y;
|
||||
right[2] = pMatrix->GetRight().z;
|
||||
forward[0] = pMatrix->GetForward().x;
|
||||
forward[1] = pMatrix->GetForward().y;
|
||||
forward[2] = pMatrix->GetForward().z;
|
||||
up[0] = pMatrix->GetUp().x;
|
||||
up[1] = pMatrix->GetUp().y;
|
||||
up[2] = pMatrix->GetUp().z;
|
||||
pos[0] = pMatrix->GetPosition().x;
|
||||
pos[1] = pMatrix->GetPosition().y;
|
||||
pos[2] = pMatrix->GetPosition().z;
|
||||
}
|
||||
|
||||
void Restore(CMatrix* pMatrix)
|
||||
{
|
||||
CMatrix tmp;
|
||||
tmp.GetRight().x = right[0];
|
||||
tmp.GetRight().y = right[1];
|
||||
tmp.GetRight().z = right[2];
|
||||
tmp.GetForward().x = forward[0];
|
||||
tmp.GetForward().y = forward[1];
|
||||
tmp.GetForward().z = forward[2];
|
||||
tmp.GetUp().x = up[0];
|
||||
tmp.GetUp().y = up[1];
|
||||
tmp.GetUp().z = up[2];
|
||||
tmp.GetPosition().x = pos[0];
|
||||
tmp.GetPosition().y = pos[1];
|
||||
tmp.GetPosition().z = pos[2];
|
||||
*pMatrix = tmp;
|
||||
}
|
||||
};
|
||||
|
||||
VALIDATE_SIZE(CMatrix_FS, 72);
|
||||
|
||||
struct CVehicle_FS
|
||||
{
|
||||
uint32 vtable;
|
||||
CMatrix_FS matrix;
|
||||
uint8 gap1[4];
|
||||
CEntityProperties properties;
|
||||
uint8 gap2[212];
|
||||
CAutoPilot_FS AutoPilot;
|
||||
uint8 m_currentColour1;
|
||||
uint8 m_currentColour2;
|
||||
uint8 gap3[2];
|
||||
int16 m_nAlarmState;
|
||||
int8 gap4[43];
|
||||
uint8 m_nNumMaxPassengers;
|
||||
float field_1D0[4];
|
||||
uint8 gap5[8];
|
||||
float m_fSteerAngle;
|
||||
float m_fGasPedal;
|
||||
float m_fBrakePedal;
|
||||
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 gap_b1 : 1;
|
||||
uint8 gap_b2 : 1;
|
||||
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 gap6[3];
|
||||
|
||||
uint8 gap7[6];
|
||||
float m_fHealth; // 1000.0f = full health. 250.0f = fire. 0 -> explode
|
||||
uint8 m_nCurrentGear;
|
||||
float m_fChangeGearTime;
|
||||
uint8 gap8[4];
|
||||
uint32 m_nTimeOfDeath;
|
||||
uint8 gap9[2];
|
||||
int16 m_nBombTimer;
|
||||
uint8 gap10[12];
|
||||
int8 m_nDoorLock;
|
||||
uint8 gap11[96];
|
||||
|
||||
void Store(CVehicle* pVehicle)
|
||||
{
|
||||
matrix.Store(&pVehicle->GetMatrix());
|
||||
VehicleCreatedBy = pVehicle->VehicleCreatedBy;
|
||||
m_currentColour1 = pVehicle->m_currentColour1;
|
||||
m_currentColour2 = pVehicle->m_currentColour2;
|
||||
m_nAlarmState = pVehicle->m_nAlarmState;
|
||||
m_nNumMaxPassengers = pVehicle->m_nNumMaxPassengers;
|
||||
field_1D0[0] = pVehicle->field_1D0[0];
|
||||
field_1D0[1] = pVehicle->field_1D0[1];
|
||||
field_1D0[2] = pVehicle->field_1D0[2];
|
||||
field_1D0[3] = pVehicle->field_1D0[3];
|
||||
m_fSteerAngle = pVehicle->m_fSteerAngle;
|
||||
m_fGasPedal = pVehicle->m_fGasPedal;
|
||||
m_fBrakePedal = pVehicle->m_fBrakePedal;
|
||||
bIsLawEnforcer = pVehicle->bIsLawEnforcer;
|
||||
bIsLocked = pVehicle->bIsLocked;
|
||||
bEngineOn = pVehicle->bEngineOn;
|
||||
bIsHandbrakeOn = pVehicle->bIsHandbrakeOn;
|
||||
bLightsOn = pVehicle->bLightsOn;
|
||||
bFreebies = pVehicle->bFreebies;
|
||||
m_fHealth = pVehicle->m_fHealth;
|
||||
m_nCurrentGear = pVehicle->m_nCurrentGear;
|
||||
m_fChangeGearTime = pVehicle->m_fChangeGearTime;
|
||||
m_nTimeOfDeath = pVehicle->m_nTimeOfDeath;
|
||||
#ifdef FIX_BUGS //must be copypaste
|
||||
m_nBombTimer = pVehicle->m_nBombTimer;
|
||||
#else
|
||||
m_nTimeOfDeath = pVehicle->m_nTimeOfDeath;
|
||||
#endif
|
||||
m_nDoorLock = pVehicle->m_nDoorLock;
|
||||
properties.Store(pVehicle);
|
||||
AutoPilot.Store(&pVehicle->AutoPilot);
|
||||
}
|
||||
|
||||
void Restore(CVehicle* pVehicle)
|
||||
{
|
||||
matrix.Restore(&pVehicle->GetMatrix());
|
||||
pVehicle->VehicleCreatedBy = VehicleCreatedBy;
|
||||
pVehicle->m_currentColour1 = m_currentColour1;
|
||||
pVehicle->m_currentColour2 = m_currentColour2;
|
||||
pVehicle->m_nAlarmState = m_nAlarmState;
|
||||
pVehicle->m_nNumMaxPassengers = m_nNumMaxPassengers;
|
||||
pVehicle->field_1D0[0] = field_1D0[0];
|
||||
pVehicle->field_1D0[1] = field_1D0[1];
|
||||
pVehicle->field_1D0[2] = field_1D0[2];
|
||||
pVehicle->field_1D0[3] = field_1D0[3];
|
||||
pVehicle->m_fSteerAngle = m_fSteerAngle;
|
||||
pVehicle->m_fGasPedal = m_fGasPedal;
|
||||
pVehicle->m_fBrakePedal = m_fBrakePedal;
|
||||
pVehicle->bIsLawEnforcer = bIsLawEnforcer;
|
||||
pVehicle->bIsLocked = bIsLocked;
|
||||
pVehicle->bEngineOn = bEngineOn;
|
||||
pVehicle->bIsHandbrakeOn = bIsHandbrakeOn;
|
||||
pVehicle->bLightsOn = bLightsOn;
|
||||
pVehicle->bFreebies = bFreebies;
|
||||
pVehicle->m_fHealth = m_fHealth;
|
||||
pVehicle->m_nCurrentGear = m_nCurrentGear;
|
||||
pVehicle->m_fChangeGearTime = m_fChangeGearTime;
|
||||
pVehicle->m_nTimeOfDeath = m_nTimeOfDeath;
|
||||
#ifdef FIX_BUGS //must be copypaste
|
||||
pVehicle->m_nBombTimer = m_nBombTimer;
|
||||
#else
|
||||
pVehicle->m_nTimeOfDeath = m_nTimeOfDeath;
|
||||
#endif
|
||||
pVehicle->m_nDoorLock = (eCarLock)m_nDoorLock;
|
||||
properties.Restore(pVehicle);
|
||||
AutoPilot.Restore(&pVehicle->AutoPilot);
|
||||
}
|
||||
};
|
||||
|
||||
VALIDATE_SIZE(CVehicle_FS, 648);
|
||||
|
||||
static_assert(sizeof(CDamageManager) < 1448 - sizeof(CVehicle_FS), "CDamageManager size too big to keep saves compatible");
|
||||
|
||||
struct CAutomobile_FS
|
||||
{
|
||||
CVehicle_FS vehicle;
|
||||
CDamageManager Damage;
|
||||
char gap[1448 - sizeof(CVehicle_FS) - sizeof(CDamageManager)]; // even allows increasing size of CDamageManager
|
||||
};
|
||||
|
||||
struct CBoat_FS
|
||||
{
|
||||
CVehicle_FS vehicle;
|
||||
char gap[1156 - sizeof(CVehicle_FS)];
|
||||
};
|
||||
|
||||
VALIDATE_SIZE(CAutomobile_FS, 1448);
|
||||
VALIDATE_SIZE(CBoat_FS, 1156);
|
||||
|
||||
struct CWeapon_FS
|
||||
{
|
||||
int32 m_eWeaponType;
|
||||
int32 m_eWeaponState;
|
||||
uint32 m_nAmmoInClip;
|
||||
uint32 m_nAmmoTotal;
|
||||
uint32 m_nTimer;
|
||||
bool m_bAddRotOffset;
|
||||
|
||||
void Store(CWeapon* pWeapon)
|
||||
{
|
||||
m_eWeaponType = pWeapon->m_eWeaponType;
|
||||
m_eWeaponState = pWeapon->m_eWeaponState;
|
||||
m_nAmmoInClip = pWeapon->m_nAmmoInClip;
|
||||
m_nAmmoTotal = pWeapon->m_nAmmoTotal;
|
||||
m_nTimer = pWeapon->m_nTimer;
|
||||
m_bAddRotOffset = pWeapon->m_bAddRotOffset;
|
||||
}
|
||||
|
||||
void Restore(CWeapon* pWeapon)
|
||||
{
|
||||
pWeapon->m_eWeaponType = (eWeaponType)m_eWeaponType;
|
||||
pWeapon->m_eWeaponState = (eWeaponState)m_eWeaponState;
|
||||
pWeapon->m_nAmmoInClip = m_nAmmoInClip;
|
||||
pWeapon->m_nAmmoTotal = m_nAmmoTotal;
|
||||
pWeapon->m_nTimer = m_nTimer;
|
||||
pWeapon->m_bAddRotOffset = m_bAddRotOffset;
|
||||
}
|
||||
};
|
||||
|
||||
static_assert(WEAPONTYPE_TOTAL_INVENTORY_WEAPONS == 13,
|
||||
"Saving struct needs to be changed by adding new weapons to existing space; or COMPATIBLE_SAVES needs to be undefined");
|
||||
|
||||
struct CPlayerPed_FS
|
||||
{
|
||||
int32 vtable;
|
||||
int8 gap[48];
|
||||
float pos[3];
|
||||
uint8 gap_2[288];
|
||||
uint8 CharCreatedBy;
|
||||
uint8 gap_3[351];
|
||||
float m_fHealth;
|
||||
float m_fArmour;
|
||||
uint8 gap_4[148];
|
||||
|
||||
CWeapon_FS m_weapons[13];
|
||||
int32 m_storedWeapon;
|
||||
uint8 m_currentWeapon;
|
||||
uint8 m_maxWeaponTypeAllowed;
|
||||
uint8 gap_5[178];
|
||||
float m_fMaxStamina;
|
||||
uint8 gap_6[28];
|
||||
int32 m_nTargettableObjects[4];
|
||||
uint8 gap_7[116];
|
||||
|
||||
void StorePlayerPed(CPlayerPed* pPlayerPed)
|
||||
{
|
||||
for (int i = 0; i < 4; i++)
|
||||
m_nTargettableObjects[i] = pPlayerPed->m_nTargettableObjects[i];
|
||||
m_fMaxStamina = pPlayerPed->m_fMaxStamina;
|
||||
}
|
||||
|
||||
void StorePed(CPed* pPed)
|
||||
{
|
||||
pos[0] = pPed->GetPosition().x;
|
||||
pos[1] = pPed->GetPosition().y;
|
||||
pos[2] = pPed->GetPosition().z;
|
||||
m_fHealth = pPed->m_fHealth;
|
||||
m_fArmour = pPed->m_fArmour;
|
||||
CharCreatedBy = pPed->CharCreatedBy;
|
||||
m_maxWeaponTypeAllowed = pPed->m_maxWeaponTypeAllowed;
|
||||
for (int i = 0; i < 13; i++)
|
||||
m_weapons[i].Store(&pPed->m_weapons[i]);
|
||||
}
|
||||
|
||||
void RestorePlayerPed(CPlayerPed* pPlayerPed)
|
||||
{
|
||||
for (int i = 0; i < 4; i++)
|
||||
pPlayerPed->m_nTargettableObjects[i] = m_nTargettableObjects[i];
|
||||
pPlayerPed->m_fMaxStamina = m_fMaxStamina;
|
||||
}
|
||||
|
||||
void RestorePed(CPed* pPed)
|
||||
{
|
||||
pPed->GetPosition().x = pos[0];
|
||||
pPed->GetPosition().y = pos[1];
|
||||
pPed->GetPosition().z = pos[2];
|
||||
pPed->m_fHealth = m_fHealth;
|
||||
pPed->m_fArmour = m_fArmour;
|
||||
pPed->CharCreatedBy = CharCreatedBy;
|
||||
pPed->m_maxWeaponTypeAllowed = m_maxWeaponTypeAllowed;
|
||||
for (int i = 0; i < 13; i++)
|
||||
m_weapons[i].Restore(&pPed->m_weapons[i]);
|
||||
}
|
||||
};
|
||||
|
||||
VALIDATE_SIZE(CPlayerPed_FS, 1520);
|
||||
|
||||
#endif
|
||||
|
|
|
@ -223,6 +223,8 @@ enum Config {
|
|||
#define USE_MEASUREMENTS_IN_METERS // makes game use meters instead of feet in script
|
||||
#define USE_PRECISE_MEASUREMENT_CONVERTION // makes game convert feet to meeters more precisely
|
||||
|
||||
#define COMPATIBLE_SAVES // this allows changing structs while keeping saves compatible
|
||||
|
||||
// Replay
|
||||
//#define DONT_FIX_REPLAY_BUGS // keeps various bugs in CReplay, some of which are fairly cool!
|
||||
//#define USE_BETA_REPLAY_MODE // adds another replay mode, a few seconds slomo (caution: buggy!)
|
||||
|
|
|
@ -91,7 +91,9 @@ public:
|
|||
CReference *m_pFirstReference;
|
||||
|
||||
CColModel *GetColModel(void) { return CModelInfo::GetModelInfo(m_modelIndex)->GetColModel(); }
|
||||
#ifndef COMPATIBLE_SAVES
|
||||
uint32* GetAddressOfEntityProperties() { /* AWFUL */ return (uint32*)((char*)&m_rwObject + sizeof(m_rwObject)); }
|
||||
#endif
|
||||
|
||||
CEntity(void);
|
||||
~CEntity(void);
|
||||
|
|
Loading…
Reference in a new issue