The-Homebrew-Cloud/re3-wiiu
2
0
Fork 0
mirror of https://gitlab.com/GaryOderNichts/re3-wiiu.git synced 2024-12-27 10:11:49 +01:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #406 from Nick007J/master

Browse Source 
Pools load/save
This commit is contained in:
Filip Gawin 2020-04-14 00:11:22 +02:00 committed by GitHub
commit aa3b7869e5
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
4 changed files with 343 additions and 10 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

345
src/core/Pools.cpp
View File

@ -1,8 +1,14 @@
#include "common.h"
#include "patcher.h"
#include "Pools.h"
#include "World.h"
#include "Boat.h"
#include "CarCtrl.h"
#include "Population.h"
#include "ProjectileInfo.h"
#include "Streaming.h"
#include "Wanted.h"
#include "World.h"
CCPtrNodePool *&CPools::ms_pPtrNodePool = *(CCPtrNodePool**)0x943044;
CEntryInfoNodePool *&CPools::ms_pEntryInfoNodePool = *(CEntryInfoNodePool**)0x941448;
@ -14,13 +20,6 @@ CObjectPool *&CPools::ms_pObjectPool = *(CObjectPool**)0x880E28;
CDummyPool *&CPools::ms_pDummyPool = *(CDummyPool**)0x8F2C18;
CAudioScriptObjectPool *&CPools::ms_pAudioScriptObjectPool = *(CAudioScriptObjectPool**)0x8F1B6C;
WRAPPER void CPools::LoadObjectPool(uint8* buf, uint32 size) { EAXJMP(0x4a2550); }
WRAPPER void CPools::LoadPedPool(uint8* buf, uint32 size) { EAXJMP(0x4a2b50); }
WRAPPER void CPools::LoadVehiclePool(uint8* buf, uint32 size) { EAXJMP(0x4a1b40); }
WRAPPER void CPools::SaveObjectPool(uint8* buf, uint32 *size) { EAXJMP(0x4a22d0); }
WRAPPER void CPools::SavePedPool(uint8* buf, uint32 *size) { EAXJMP(0x4a29b0); }
WRAPPER void CPools::SaveVehiclePool(uint8* buf, uint32 *size) { EAXJMP(0x4a2080); }
void
CPools::Initialise(void)
{
@ -99,6 +98,333 @@ CPools::MakeSureSlotInObjectPoolIsEmpty(int32 slot)
}
}
void CPools::LoadVehiclePool(uint8* buf, uint32 size)
{
INITSAVEBUF
int nNumCars = ReadSaveBuf<int>(buf);
int nNumBoats = ReadSaveBuf<int>(buf);
for (int i = 0; i < nNumCars + nNumBoats; i++) {
uint32 type = ReadSaveBuf<uint32>(buf);
int16 model = ReadSaveBuf<int16>(buf);
CStreaming::RequestModel(model, STREAMFLAGS_DEPENDENCY);
CStreaming::LoadAllRequestedModels(false);
int32 slot = ReadSaveBuf<int32>(buf);
CVehicle* pVehicle;
char* vbuf = new char[max(sizeof(CAutomobile), sizeof(CBoat))];
if (type == VEHICLE_TYPE_BOAT) {
memcpy(vbuf, buf, sizeof(CBoat));
SkipSaveBuf(buf, sizeof(CBoat));
CBoat* pBoat = new(slot) CBoat(model, RANDOM_VEHICLE);
pVehicle = pBoat;
--CCarCtrl::NumRandomCars; // why?
}
else if (type == VEHICLE_TYPE_CAR) {
memcpy(vbuf, buf, sizeof(CAutomobile));
SkipSaveBuf(buf, sizeof(CAutomobile));
CStreaming::RequestModel(model, 0); // is it needed?
CStreaming::LoadAllRequestedModels(false);
CAutomobile* pAutomobile = new(slot) CAutomobile(model, RANDOM_VEHICLE);
pVehicle = pAutomobile;
CCarCtrl::NumRandomCars--; // why?
pAutomobile->Damage = ((CAutomobile*)vbuf)->Damage;
pAutomobile->SetupDamageAfterLoad();
}
else
assert(0);
CVehicle* pBufferVehicle = (CVehicle*)vbuf;
pVehicle->GetMatrix() = pBufferVehicle->GetMatrix();
pVehicle->VehicleCreatedBy = pBufferVehicle->VehicleCreatedBy;
pVehicle->m_currentColour1 = pBufferVehicle->m_currentColour1;
pVehicle->m_currentColour2 = pBufferVehicle->m_currentColour2;
pVehicle->m_nAlarmState = pBufferVehicle->m_nAlarmState;
pVehicle->m_nNumMaxPassengers = pBufferVehicle->m_nNumMaxPassengers;
pVehicle->field_1D0[0] = pBufferVehicle->field_1D0[0];
pVehicle->field_1D0[1] = pBufferVehicle->field_1D0[1];
pVehicle->field_1D0[2] = pBufferVehicle->field_1D0[2];
pVehicle->field_1D0[3] = pBufferVehicle->field_1D0[3];
pVehicle->m_fSteerAngle = pBufferVehicle->m_fSteerAngle;
pVehicle->m_fGasPedal = pBufferVehicle->m_fGasPedal;
pVehicle->m_fBrakePedal = pBufferVehicle->m_fBrakePedal;
pVehicle->bIsLawEnforcer = pBufferVehicle->bIsLawEnforcer;
pVehicle->bIsLocked = pBufferVehicle->bIsLocked;
pVehicle->bEngineOn = pBufferVehicle->bEngineOn;
pVehicle->bIsHandbrakeOn = pBufferVehicle->bIsHandbrakeOn;
pVehicle->bLightsOn = pBufferVehicle->bLightsOn;
pVehicle->bFreebies = pBufferVehicle->bFreebies;
pVehicle->m_fHealth = pBufferVehicle->m_fHealth;
pVehicle->m_nCurrentGear = pBufferVehicle->m_nCurrentGear;
pVehicle->m_fChangeGearTime = pBufferVehicle->m_fChangeGearTime;
pVehicle->m_nTimeOfDeath = pBufferVehicle->m_nTimeOfDeath;
#ifdef FIX_BUGS //must be copypaste
pVehicle->m_nBombTimer = pBufferVehicle->m_nBombTimer;
#else
pVehicle->m_nTimeOfDeath = pBufferVehicle->m_nTimeOfDeath;
#endif
pVehicle->m_nDoorLock = pBufferVehicle->m_nDoorLock;
pVehicle->m_status = pBufferVehicle->m_status;
pVehicle->m_type = pBufferVehicle->m_type;
(pVehicle->GetAddressOfEntityProperties())[0] = (pBufferVehicle->GetAddressOfEntityProperties())[0];
(pVehicle->GetAddressOfEntityProperties())[1] = (pBufferVehicle->GetAddressOfEntityProperties())[1];
pVehicle->AutoPilot = pBufferVehicle->AutoPilot;
CWorld::Add(pVehicle);
delete[] vbuf;
}
VALIDATESAVEBUF(size)
}
void CPools::SaveVehiclePool(uint8* buf, uint32* size)
{
INITSAVEBUF
int nNumCars = 0;
int nNumBoats = 0;
int nPoolSize = GetVehiclePool()->GetSize();
for (int i = 0; i < nPoolSize; i++) {
CVehicle* pVehicle = GetVehiclePool()->GetSlot(i);
if (!pVehicle)
continue;
bool bHasPassenger = false;
for (int j = 0; j < ARRAY_SIZE(pVehicle->pPassengers); j++) {
if (pVehicle->pPassengers[i])
bHasPassenger = true;
}
if (!pVehicle->pDriver && !bHasPassenger) {
if (pVehicle->IsCar() && pVehicle->VehicleCreatedBy == MISSION_VEHICLE)
++nNumCars;
if (pVehicle->IsBoat() && pVehicle->VehicleCreatedBy == MISSION_VEHICLE)
++nNumBoats;
}
}
*size = nNumCars * (sizeof(uint32) + sizeof(int16) + sizeof(int32) + sizeof(CAutomobile)) + sizeof(int) +
nNumBoats * (sizeof(uint32) + sizeof(int16) + sizeof(int32) + sizeof(CBoat)) + sizeof(int);
WriteSaveBuf(buf, nNumCars);
WriteSaveBuf(buf, nNumBoats);
for (int i = 0; i < nPoolSize; i++) {
CVehicle* pVehicle = GetVehiclePool()->GetSlot(i);
if (!pVehicle)
continue;
bool bHasPassenger = false;
for (int j = 0; j < ARRAY_SIZE(pVehicle->pPassengers); j++) {
if (pVehicle->pPassengers[j])
bHasPassenger = true;
}
if (!pVehicle->pDriver && !bHasPassenger) {
if (pVehicle->IsCar() && pVehicle->VehicleCreatedBy == MISSION_VEHICLE) {
WriteSaveBuf(buf, (uint32)pVehicle->m_vehType);
WriteSaveBuf(buf, pVehicle->m_modelIndex);
WriteSaveBuf(buf, GetVehicleRef(pVehicle));
memcpy(buf, pVehicle, sizeof(CAutomobile));
SkipSaveBuf(buf, sizeof(CAutomobile));
}
if (pVehicle->IsBoat() && pVehicle->VehicleCreatedBy == MISSION_VEHICLE) {
WriteSaveBuf(buf, (uint32)pVehicle->m_vehType);
WriteSaveBuf(buf, pVehicle->m_modelIndex);
WriteSaveBuf(buf, GetVehicleRef(pVehicle));
memcpy(buf, pVehicle, sizeof(CBoat));
SkipSaveBuf(buf, sizeof(CBoat));
}
}
}
VALIDATESAVEBUF(*size)
}
void CPools::SaveObjectPool(uint8* buf, uint32* size)
{
INITSAVEBUF
CProjectileInfo::RemoveAllProjectiles();
CObject::DeleteAllTempObjects();
int nObjects = 0;
int nPoolSize = GetObjectPool()->GetSize();
for (int i = 0; i < nPoolSize; i++) {
CObject* pObject = GetObjectPool()->GetSlot(i);
if (!pObject)
continue;
if (pObject->ObjectCreatedBy == MISSION_OBJECT)
++nObjects;
}
*size = nObjects * (sizeof(int16) + sizeof(int) + sizeof(CCompressedMatrixNotAligned) + sizeof(uint32) +
sizeof(float) + sizeof(CCompressedMatrixNotAligned) + sizeof(uint32) + sizeof(int8) + 7 * sizeof(bool) + sizeof(float) +
sizeof(int8) + sizeof(int8) + sizeof(uint32) + 2 * sizeof(uint32)) + sizeof(int);
WriteSaveBuf(buf, nObjects);
for (int i = 0; i < nPoolSize; i++) {
CObject* pObject = GetObjectPool()->GetSlot(i);
if (!pObject)
continue;
if (pObject->ObjectCreatedBy == MISSION_OBJECT) {
bool bIsPickup = pObject->bIsPickup;
bool bFlag2 = pObject->m_obj_flag2;
bool bOutOfStock = pObject->bOutOfStock;
bool bGlassCracked = pObject->bGlassCracked;
bool bGlassBroken = pObject->bGlassBroken;
bool bHasBeenDamaged = pObject->bHasBeenDamaged;
bool bUseVehicleColours = pObject->bUseVehicleColours;
CCompressedMatrixNotAligned tmp;
WriteSaveBuf(buf, pObject->m_modelIndex);
WriteSaveBuf(buf, GetObjectRef(pObject));
tmp.CompressFromFullMatrix(pObject->GetMatrix());
WriteSaveBuf(buf, tmp);
WriteSaveBuf(buf, (uint32)0); // game writes ununitialized data here
WriteSaveBuf(buf, pObject->m_fUprootLimit);
tmp.CompressFromFullMatrix(pObject->m_objectMatrix);
WriteSaveBuf(buf, tmp);
WriteSaveBuf(buf, (uint32)0); // same
WriteSaveBuf(buf, pObject->ObjectCreatedBy);
WriteSaveBuf(buf, bIsPickup);
WriteSaveBuf(buf, bFlag2);
WriteSaveBuf(buf, bOutOfStock);
WriteSaveBuf(buf, bGlassCracked);
WriteSaveBuf(buf, bGlassBroken);
WriteSaveBuf(buf, bHasBeenDamaged);
WriteSaveBuf(buf, bUseVehicleColours);
WriteSaveBuf(buf, pObject->m_fCollisionDamageMultiplier);
WriteSaveBuf(buf, pObject->m_nCollisionDamageEffect);
WriteSaveBuf(buf, pObject->m_nSpecialCollisionResponseCases);
WriteSaveBuf(buf, pObject->m_nEndOfLifeTime);
WriteSaveBuf(buf, (pObject->GetAddressOfEntityProperties())[0]);
WriteSaveBuf(buf, (pObject->GetAddressOfEntityProperties())[1]);
}
}
VALIDATESAVEBUF(*size)
}
void CPools::LoadObjectPool(uint8* buf, uint32 size)
{
INITSAVEBUF
int nObjects = ReadSaveBuf<int>(buf);
for (int i = 0; i < nObjects; i++) {
int16 mi = ReadSaveBuf<int16>(buf);
int ref = ReadSaveBuf<int>(buf);
char* obuf = new char[sizeof(CObject)];
CObject* pBufferObject = (CObject*)obuf;
CCompressedMatrixNotAligned tmp;
tmp = ReadSaveBuf<CCompressedMatrixNotAligned>(buf);
tmp.DecompressIntoFullMatrix(pBufferObject->GetMatrix());
ReadSaveBuf<uint32>(buf);
pBufferObject->m_fUprootLimit = ReadSaveBuf<float>(buf);
tmp = ReadSaveBuf<CCompressedMatrixNotAligned>(buf);
tmp.DecompressIntoFullMatrix(pBufferObject->m_objectMatrix);
ReadSaveBuf<uint32>(buf);
pBufferObject->ObjectCreatedBy = ReadSaveBuf<int8>(buf);
pBufferObject->bIsPickup = ReadSaveBuf<bool>(buf);
pBufferObject->m_flagE2 = ReadSaveBuf<bool>(buf);
pBufferObject->bOutOfStock = ReadSaveBuf<bool>(buf);
pBufferObject->bGlassCracked = ReadSaveBuf<bool>(buf);
pBufferObject->bGlassBroken = ReadSaveBuf<bool>(buf);
pBufferObject->bHasBeenDamaged = ReadSaveBuf<bool>(buf);
pBufferObject->bUseVehicleColours = ReadSaveBuf<bool>(buf);
pBufferObject->m_fCollisionDamageMultiplier = ReadSaveBuf<float>(buf);
pBufferObject->m_nCollisionDamageEffect = ReadSaveBuf<uint8>(buf);
pBufferObject->m_nSpecialCollisionResponseCases = ReadSaveBuf<uint8>(buf);
pBufferObject->m_nEndOfLifeTime = ReadSaveBuf<uint32>(buf);
(pBufferObject->GetAddressOfEntityProperties())[0] = ReadSaveBuf<uint32>(buf);
(pBufferObject->GetAddressOfEntityProperties())[1] = ReadSaveBuf<uint32>(buf);
if (GetObjectPool()->GetSlot(ref >> 8))
CPopulation::ConvertToDummyObject(GetObjectPool()->GetSlot(ref >> 8));
CObject* pObject = new(ref) CObject(mi, false);
pObject->GetMatrix() = pBufferObject->GetMatrix();
pObject->m_fUprootLimit = pBufferObject->m_fUprootLimit;
pObject->m_objectMatrix = pBufferObject->m_objectMatrix;
pObject->ObjectCreatedBy = pBufferObject->ObjectCreatedBy;
pObject->bIsPickup = pBufferObject->bIsPickup;
pObject->m_flagE2 = pBufferObject->m_flagE2;
pObject->bOutOfStock = pBufferObject->bOutOfStock;
pObject->bGlassCracked = pBufferObject->bGlassCracked;
pObject->bGlassBroken = pBufferObject->bGlassBroken;
pObject->bHasBeenDamaged = pBufferObject->bHasBeenDamaged;
pObject->bUseVehicleColours = pBufferObject->bUseVehicleColours;
pObject->m_fCollisionDamageMultiplier = pBufferObject->m_fCollisionDamageMultiplier;
pObject->m_nCollisionDamageEffect = pBufferObject->m_nCollisionDamageEffect;
pObject->m_nSpecialCollisionResponseCases = pBufferObject->m_nSpecialCollisionResponseCases;
pObject->m_nEndOfLifeTime = pBufferObject->m_nEndOfLifeTime;
(pObject->GetAddressOfEntityProperties())[0] = (pBufferObject->GetAddressOfEntityProperties())[0];
(pObject->GetAddressOfEntityProperties())[1] = (pBufferObject->GetAddressOfEntityProperties())[1];
pObject->bHasCollided = false;
CWorld::Add(pObject);
delete[] obuf;
}
VALIDATESAVEBUF(size)
}
void CPools::SavePedPool(uint8* buf, uint32* size)
{
INITSAVEBUF
int nNumPeds = 0;
int nPoolSize = GetPedPool()->GetSize();
for (int i = 0; i < nPoolSize; i++) {
CPed* pPed = GetPedPool()->GetSlot(i);
if (!pPed)
continue;
if (!pPed->bInVehicle && pPed->m_nPedType == PEDTYPE_PLAYER1)
nNumPeds++;
}
*size = sizeof(int) + nNumPeds * (sizeof(uint32) + sizeof(int16) + sizeof(int) + sizeof(CPlayerPed) +
sizeof(CWanted::MaximumWantedLevel) + sizeof(CWanted::nMaximumWantedLevel) + MAX_MODEL_NAME);
WriteSaveBuf(buf, nNumPeds);
for (int i = 0; i < nPoolSize; i++) {
CPed* pPed = GetPedPool()->GetSlot(i);
if (!pPed)
continue;
if (!pPed->bInVehicle && pPed->m_nPedType == PEDTYPE_PLAYER1) {
WriteSaveBuf(buf, pPed->m_nPedType);
WriteSaveBuf(buf, pPed->m_modelIndex);
WriteSaveBuf(buf, GetPedRef(pPed));
memcpy(buf, pPed, sizeof(CPlayerPed));
SkipSaveBuf(buf, sizeof(CPlayerPed));
WriteSaveBuf(buf, CWanted::MaximumWantedLevel);
WriteSaveBuf(buf, CWanted::nMaximumWantedLevel);
memcpy(buf, CModelInfo::GetModelInfo(pPed->GetModelIndex())->GetName(), MAX_MODEL_NAME);
SkipSaveBuf(buf, MAX_MODEL_NAME);
}
}
VALIDATESAVEBUF(*size);
}
void CPools::LoadPedPool(uint8* buf, uint32 size)
{
INITSAVEBUF
int nPeds = ReadSaveBuf<int>(buf);
for (int i = 0; i < nPeds; i++) {
uint32 pedtype = ReadSaveBuf<uint32>(buf);
int16 model = ReadSaveBuf<int16>(buf);
int ref = ReadSaveBuf<int>(buf);
char* pbuf = new char[sizeof(CPlayerPed)];
CPlayerPed* pBufferPlayer = (CPlayerPed*)pbuf;
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
memcpy(pbuf, buf, sizeof(CPlayerPed));
SkipSaveBuf(buf, sizeof(CPlayerPed));
CWanted::MaximumWantedLevel = ReadSaveBuf<int32>(buf);
CWanted::nMaximumWantedLevel = ReadSaveBuf<int32>(buf);
memcpy(name, buf, MAX_MODEL_NAME);
SkipSaveBuf(buf, MAX_MODEL_NAME);
}
CStreaming::RequestSpecialModel(model, name, STREAMFLAGS_DONT_REMOVE);
CStreaming::LoadAllRequestedModels(false);
if (pedtype == PEDTYPE_PLAYER1) {
CPlayerPed* pPlayerPed = new(ref) CPlayerPed();
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;
pPed = pPlayerPed;
}
pPed->GetPosition() = pBufferPlayer->GetPosition();
pPed->m_fHealth = pBufferPlayer->m_fHealth;
pPed->m_fArmour = pBufferPlayer->m_fArmour;
pPed->CharCreatedBy = pBufferPlayer->CharCreatedBy;
pPed->m_currentWeapon = 0;
pPed->m_maxWeaponTypeAllowed = pBufferPlayer->m_maxWeaponTypeAllowed;
for (int i = 0; i < WEAPONTYPE_TOTAL_INVENTORY_WEAPONS; i++)
pPed->m_weapons[i] = pBufferPlayer->m_weapons[i];
if (pedtype == PEDTYPE_PLAYER1) {
pPed->m_wepAccuracy = 100;
CWorld::Players[0].m_pPed = (CPlayerPed*)pPed;
}
CWorld::Add(pPed);
delete[] pbuf;
}
VALIDATESAVEBUF(size)
}
STARTPATCHES
InjectHook(0x4A1770, CPools::Initialise, PATCH_JUMP);
@ -111,4 +437,7 @@ STARTPATCHES
InjectHook(0x4A1B00, CPools::GetObjectRef, PATCH_JUMP);
InjectHook(0x4A1B20, CPools::GetObject, PATCH_JUMP);
InjectHook(0x4A2DB0, CPools::MakeSureSlotInObjectPoolIsEmpty, PATCH_JUMP);
InjectHook(0x4A1B40, CPools::LoadVehiclePool, PATCH_JUMP);
InjectHook(0x4A2550, CPools::LoadObjectPool, PATCH_JUMP);
InjectHook(0x4A2B50, CPools::LoadPedPool, PATCH_JUMP);
ENDPATCHES

1
src/entities/Entity.h
View File

@ -90,6 +90,7 @@ public:
CReference *m_pFirstReference;
CColModel *GetColModel(void) { return CModelInfo::GetModelInfo(m_modelIndex)->GetColModel(); }
uint32* GetAddressOfEntityProperties() { /* AWFUL */ return (uint32*)((char*)&m_rwObject + sizeof(m_rwObject)); }
CEntity(void);
~CEntity(void);

4
src/modelinfo/BaseModelInfo.h
View File

@ -2,6 +2,8 @@
#include "Collision.h"
#define MAX_MODEL_NAME (24)
enum ModeInfoType : uint8
{
MITYPE_NA = 0,
@ -21,7 +23,7 @@ class CBaseModelInfo
{
protected:
// TODO?: make more things protected
char m_name[24];
char m_name[MAX_MODEL_NAME];
CColModel *m_colModel;
C2dEffect *m_twodEffects;
int16 m_objectId;

3
src/vehicles/Vehicle.h
View File

@ -130,7 +130,8 @@ public:
int8 m_nGettingInFlags;
int8 m_nGettingOutFlags;
uint8 m_nNumMaxPassengers;
char field_1CD[19];
char field_1CD[3];
float field_1D0[4];
CEntity *m_pCurGroundEntity;
CFire *m_pCarFire;
float m_fSteerAngle;