18 files changed, 583 insertions, 8 deletions

diff --git a/src/control/AutoPilot.cpp b/src/control/AutoPilot.cpp
index 69511bc8..96a1fedf 100644
--- a/src/control/AutoPilot.cpp
+++ b/src/control/AutoPilot.cpp
@@ -44,4 +44,83 @@ void CAutoPilot::RemoveOnePathNode()
 	--m_nPathFindNodesCount;
 	for (int i = 0; i < m_nPathFindNodesCount; i++)
 		m_aPathFindNodesInfo[i] = m_aPathFindNodesInfo[i + 1];
-}
\ No newline at end of file
+}
+
+#ifdef COMPATIBLE_SAVES
+void CAutoPilot::Save(uint8*& buf)
+{
+	WriteSaveBuf<int32>(buf, m_nCurrentRouteNode);
+	WriteSaveBuf<int32>(buf, m_nNextRouteNode);
+	WriteSaveBuf<int32>(buf, m_nPrevRouteNode);
+	WriteSaveBuf<uint32>(buf, m_nTimeEnteredCurve);
+	WriteSaveBuf<uint32>(buf, m_nTimeToSpendOnCurrentCurve);
+	WriteSaveBuf<uint32>(buf, m_nCurrentPathNodeInfo);
+	WriteSaveBuf<uint32>(buf, m_nNextPathNodeInfo);
+	WriteSaveBuf<uint32>(buf, m_nPreviousPathNodeInfo);
+	WriteSaveBuf<uint32>(buf, m_nAntiReverseTimer);
+	WriteSaveBuf<uint32>(buf, m_nTimeToStartMission);
+	WriteSaveBuf<int8>(buf, m_nPreviousDirection);
+	WriteSaveBuf<int8>(buf, m_nCurrentDirection);
+	WriteSaveBuf<int8>(buf, m_nNextDirection);
+	WriteSaveBuf<int8>(buf, m_nCurrentLane);
+	WriteSaveBuf<int8>(buf, m_nNextLane);
+	WriteSaveBuf<uint8>(buf, m_nDrivingStyle);
+	WriteSaveBuf<uint8>(buf, m_nCarMission);
+	WriteSaveBuf<uint8>(buf, m_nTempAction);
+	WriteSaveBuf<uint32>(buf, m_nTimeTempAction);
+	WriteSaveBuf<float>(buf, m_fMaxTrafficSpeed);
+	WriteSaveBuf<uint8>(buf, m_nCruiseSpeed);
+	uint8 flags = 0;
+	if (m_bSlowedDownBecauseOfCars) flags |= BIT(0);
+	if (m_bSlowedDownBecauseOfPeds) flags |= BIT(1);
+	if (m_bStayInCurrentLevel) flags |= BIT(2);
+	if (m_bStayInFastLane) flags |= BIT(3);
+	if (m_bIgnorePathfinding) flags |= BIT(4);
+	WriteSaveBuf<uint8>(buf, flags);
+	SkipSaveBuf(buf, 2);
+	WriteSaveBuf<float>(buf, m_vecDestinationCoors.x);
+	WriteSaveBuf<float>(buf, m_vecDestinationCoors.y);
+	WriteSaveBuf<float>(buf, m_vecDestinationCoors.z);
+	SkipSaveBuf(buf, 32);
+	WriteSaveBuf<int16>(buf, m_nPathFindNodesCount);
+	SkipSaveBuf(buf, 6);
+}
+
+void CAutoPilot::Load(uint8*& buf)
+{
+	m_nCurrentRouteNode = ReadSaveBuf<int32>(buf);
+	m_nNextRouteNode = ReadSaveBuf<int32>(buf);
+	m_nPrevRouteNode = ReadSaveBuf<int32>(buf);
+	m_nTimeEnteredCurve = ReadSaveBuf<uint32>(buf);
+	m_nTimeToSpendOnCurrentCurve = ReadSaveBuf<uint32>(buf);
+	m_nCurrentPathNodeInfo = ReadSaveBuf<uint32>(buf);
+	m_nNextPathNodeInfo = ReadSaveBuf<uint32>(buf);
+	m_nPreviousPathNodeInfo = ReadSaveBuf<uint32>(buf);
+	m_nAntiReverseTimer = ReadSaveBuf<uint32>(buf);
+	m_nTimeToStartMission = ReadSaveBuf<uint32>(buf);
+	m_nPreviousDirection = ReadSaveBuf<int8>(buf);
+	m_nCurrentDirection = ReadSaveBuf<int8>(buf);
+	m_nNextDirection = ReadSaveBuf<int8>(buf);
+	m_nCurrentLane = ReadSaveBuf<int8>(buf);
+	m_nNextLane = ReadSaveBuf<int8>(buf);
+	m_nDrivingStyle = (eCarDrivingStyle)ReadSaveBuf<uint8>(buf);
+	m_nCarMission = (eCarMission)ReadSaveBuf<uint8>(buf);
+	m_nTempAction = (eCarTempAction)ReadSaveBuf<uint8>(buf);
+	m_nTimeTempAction = ReadSaveBuf<uint32>(buf);
+	m_fMaxTrafficSpeed = ReadSaveBuf<float>(buf);
+	m_nCruiseSpeed = ReadSaveBuf<uint8>(buf);
+	uint8 flags = ReadSaveBuf<uint8>(buf);
+	m_bSlowedDownBecauseOfCars = !!(flags & BIT(0));
+	m_bSlowedDownBecauseOfPeds = !!(flags & BIT(1));
+	m_bStayInCurrentLevel = !!(flags & BIT(2));
+	m_bStayInFastLane = !!(flags & BIT(3));
+	m_bIgnorePathfinding = !!(flags & BIT(4));
+	SkipSaveBuf(buf, 2);
+	m_vecDestinationCoors.x = ReadSaveBuf<float>(buf);
+	m_vecDestinationCoors.y = ReadSaveBuf<float>(buf);
+	m_vecDestinationCoors.z = ReadSaveBuf<float>(buf);
+	SkipSaveBuf(buf, 32);
+	m_nPathFindNodesCount = ReadSaveBuf<int16>(buf);
+	SkipSaveBuf(buf, 6);
+}
+#endif
\ No newline at end of file
diff --git a/src/control/AutoPilot.h b/src/control/AutoPilot.h
index e1066071..4c356f96 100644
--- a/src/control/AutoPilot.h
+++ b/src/control/AutoPilot.h
@@ -120,5 +120,10 @@ public:
 
 	void ModifySpeed(float);
 	void RemoveOnePathNode();
+#ifdef COMPATIBLE_SAVES
+	void Save(uint8*& buf);
+	void Load(uint8*& buf);
+#endif
+
 };
 static_assert(sizeof(CAutoPilot) == 0x70, "CAutoPilot: error");
diff --git a/src/core/Pools.cpp b/src/core/Pools.cpp
index e82fa6e2..4306cf09 100644
--- a/src/core/Pools.cpp
+++ b/src/core/Pools.cpp
@@ -110,13 +110,24 @@ INITSAVEBUF
 		CStreaming::LoadAllRequestedModels(false);
 		int32 slot = ReadSaveBuf<int32>(buf);
 		CVehicle* pVehicle;
-		char* vbuf = new char[Max(sizeof(CAutomobile), sizeof(CBoat))];
+#ifdef COMPATIBLE_SAVES
+		if (type == VEHICLE_TYPE_BOAT)
+			pVehicle = new(slot) CBoat(model, RANDOM_VEHICLE);
+		else if (type == VEHICLE_TYPE_CAR)
+			pVehicle = new(slot) CAutomobile(model, RANDOM_VEHICLE);
+		else
+			assert(0);
+		--CCarCtrl::NumRandomCars;
+		pVehicle->Load(buf);
+		CWorld::Add(pVehicle);
+#else
+		char* vbuf = new char[Max(CAutomobile::nSaveStructSize, CBoat::nSaveStructSize)];
 		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?
+			--CCarCtrl::NumRandomCars;
 		}
 		else if (type == VEHICLE_TYPE_CAR) {
 			memcpy(vbuf, buf, sizeof(CAutomobile));
@@ -168,6 +179,7 @@ INITSAVEBUF
 		pVehicle->AutoPilot = pBufferVehicle->AutoPilot;
 		CWorld::Add(pVehicle);
 		delete[] vbuf;
+#endif
 	}
 VALIDATESAVEBUF(size)
 }
@@ -184,7 +196,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 +206,8 @@ 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) + CAutomobile::nSaveStructSize) + sizeof(int) +
+		nNumBoats * (sizeof(uint32) + sizeof(int16) + sizeof(int32) + CBoat::nSaveStructSize) + sizeof(int);
 	WriteSaveBuf(buf, nNumCars);
 	WriteSaveBuf(buf, nNumBoats);
 	for (int i = 0; i < nPoolSize; i++) {
@@ -208,6 +220,14 @@ INITSAVEBUF
 				bHasPassenger = true;
 		}
 		if (!pVehicle->pDriver && !bHasPassenger) {
+#ifdef COMPATIBLE_SAVES
+			if ((pVehicle->IsCar() || pVehicle->IsBoat()) && pVehicle->VehicleCreatedBy == MISSION_VEHICLE) {
+				WriteSaveBuf<uint32>(buf, pVehicle->m_vehType);
+				WriteSaveBuf<int16>(buf, pVehicle->m_modelIndex);
+				WriteSaveBuf<int32>(buf, GetVehicleRef(pVehicle));
+				pVehicle->Save(buf);
+			}
+#else
 			if (pVehicle->IsCar() && pVehicle->VehicleCreatedBy == MISSION_VEHICLE) {
 				WriteSaveBuf(buf, (uint32)pVehicle->m_vehType);
 				WriteSaveBuf(buf, pVehicle->m_modelIndex);
@@ -222,6 +242,7 @@ INITSAVEBUF
 				memcpy(buf, pVehicle, sizeof(CBoat));
 				SkipSaveBuf(buf, sizeof(CBoat));
 			}
+#endif
 		}
 	}
 VALIDATESAVEBUF(*size)
@@ -279,8 +300,12 @@ INITSAVEBUF
 			WriteSaveBuf(buf, pObject->m_nCollisionDamageEffect);
 			WriteSaveBuf(buf, pObject->m_nSpecialCollisionResponseCases);
 			WriteSaveBuf(buf, pObject->m_nEndOfLifeTime);
+#ifdef COMPATIBLE_SAVES
+			pObject->SaveEntityFlags(buf);
+#else
 			WriteSaveBuf(buf, (pObject->GetAddressOfEntityProperties())[0]);
 			WriteSaveBuf(buf, (pObject->GetAddressOfEntityProperties())[1]);
+#endif
 		}
 	}
 VALIDATESAVEBUF(*size)
@@ -315,12 +340,17 @@ INITSAVEBUF
 		pBufferObject->m_nCollisionDamageEffect = ReadSaveBuf<uint8>(buf);
 		pBufferObject->m_nSpecialCollisionResponseCases = ReadSaveBuf<uint8>(buf);
 		pBufferObject->m_nEndOfLifeTime = ReadSaveBuf<uint32>(buf);
+#ifndef COMPATIBLE_SAVES
 		(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);
 		pObject->GetMatrix() = pBufferObject->GetMatrix();
+#ifdef COMPATIBLE_SAVES
+		pObject->LoadEntityFlags(buf);
+#endif
 		pObject->m_fUprootLimit = pBufferObject->m_fUprootLimit;
 		pObject->m_objectMatrix = pBufferObject->m_objectMatrix;
 		pObject->ObjectCreatedBy = pBufferObject->ObjectCreatedBy;
@@ -335,8 +365,10 @@ INITSAVEBUF
 		pObject->m_nCollisionDamageEffect = pBufferObject->m_nCollisionDamageEffect;
 		pObject->m_nSpecialCollisionResponseCases = pBufferObject->m_nSpecialCollisionResponseCases;
 		pObject->m_nEndOfLifeTime = pBufferObject->m_nEndOfLifeTime;
+#ifndef COMPATIBLE_SAVES
 		(pObject->GetAddressOfEntityProperties())[0] = (pBufferObject->GetAddressOfEntityProperties())[0];
 		(pObject->GetAddressOfEntityProperties())[1] = (pBufferObject->GetAddressOfEntityProperties())[1];
+#endif
 		pObject->bHasCollided = false;
 		CWorld::Add(pObject);
 		delete[] obuf;
@@ -356,7 +388,7 @@ 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) + CPlayerPed::nSaveStructSize +
 		sizeof(CWanted::MaximumWantedLevel) + sizeof(CWanted::nMaximumWantedLevel) + MAX_MODEL_NAME);
 	WriteSaveBuf(buf, nNumPeds);
 	for (int i = 0; i < nPoolSize; i++) {
@@ -367,8 +399,12 @@ INITSAVEBUF
 			WriteSaveBuf(buf, pPed->m_nPedType);
 			WriteSaveBuf(buf, pPed->m_modelIndex);
 			WriteSaveBuf(buf, GetPedRef(pPed));
+#ifdef COMPATIBLE_SAVES
+			pPed->Save(buf);
+#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,6 +422,34 @@ INITSAVEBUF
 		uint32 pedtype = ReadSaveBuf<uint32>(buf);
 		int16 model = ReadSaveBuf<int16>(buf);
 		int ref = ReadSaveBuf<int>(buf);
+#ifdef COMPATIBLE_SAVES
+		CPed* pPed;
+
+		char name[MAX_MODEL_NAME];
+		// Unfortunate hack: player model is stored after ped structure.
+		// It could be avoided by just using "player" because in practice it is always true.
+		memcpy(name, buf + CPlayerPed::nSaveStructSize + 2 * sizeof(int32), MAX_MODEL_NAME);
+		CStreaming::RequestSpecialModel(model, name, STREAMFLAGS_DONT_REMOVE);
+		CStreaming::LoadAllRequestedModels(false);
+
+		if (pedtype == PEDTYPE_PLAYER1)
+			pPed = new(ref) CPlayerPed();
+		else
+			assert(0);
+
+		pPed->Load(buf);
+		if (pedtype == PEDTYPE_PLAYER1) {
+			CWanted::MaximumWantedLevel = ReadSaveBuf<int32>(buf);
+			CWanted::nMaximumWantedLevel = ReadSaveBuf<int32>(buf);
+			SkipSaveBuf(buf, MAX_MODEL_NAME);
+		}
+
+		if (pedtype == PEDTYPE_PLAYER1) {
+			pPed->m_wepAccuracy = 100;
+			CWorld::Players[0].m_pPed = (CPlayerPed*)pPed;
+		}
+		CWorld::Add(pPed);
+#else
 		char* pbuf = new char[sizeof(CPlayerPed)];
 		CPlayerPed* pBufferPlayer = (CPlayerPed*)pbuf;
 		CPed* pPed;
@@ -416,12 +480,14 @@ 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];
+
 		if (pedtype == PEDTYPE_PLAYER1) {
 			pPed->m_wepAccuracy = 100;
 			CWorld::Players[0].m_pPed = (CPlayerPed*)pPed;
 		}
 		CWorld::Add(pPed);
 		delete[] pbuf;
+#endif
 	}
 VALIDATESAVEBUF(size)
 }
diff --git a/src/core/config.h b/src/core/config.h
index 01684afd..0d57f55d 100644
--- a/src/core/config.h
+++ b/src/core/config.h
@@ -226,6 +226,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!)
diff --git a/src/entities/Entity.cpp b/src/entities/Entity.cpp
index ee4faa82..2a6211d6 100644
--- a/src/entities/Entity.cpp
+++ b/src/entities/Entity.cpp
@@ -920,3 +920,108 @@ CEntity::AddSteamsFromGround(CPtrList& list)
 		pNode = pNode->next;
 	}
 }
+
+#ifdef COMPATIBLE_SAVES
+void
+CEntity::SaveEntityFlags(uint8*& buf)
+{
+	uint32 tmp = 0;
+	tmp |= (m_type & (BIT(3) - 1));
+	tmp |= (m_status & (BIT(5) - 1)) << 3;
+
+	if (bUsesCollision) tmp |= BIT(8);
+	if (bCollisionProcessed) tmp |= BIT(9);
+	if (bIsStatic)  tmp |= BIT(10);
+	if (bHasContacted) tmp |= BIT(11);
+	if (bPedPhysics) tmp |= BIT(12);
+	if (bIsStuck) tmp |= BIT(13);
+	if (bIsInSafePosition) tmp |= BIT(14);
+	if (bUseCollisionRecords) tmp |= BIT(15);
+
+	if (bWasPostponed) tmp |= BIT(16);
+	if (bExplosionProof) tmp |= BIT(17);
+	if (bIsVisible)  tmp |= BIT(18);
+	if (bHasCollided) tmp |= BIT(19);
+	if (bRenderScorched) tmp |= BIT(20);
+	if (bHasBlip) tmp |= BIT(21);
+	if (bIsBIGBuilding) tmp |= BIT(22);
+	if (bRenderDamaged) tmp |= BIT(23);
+
+	if (bBulletProof) tmp |= BIT(24);
+	if (bFireProof) tmp |= BIT(25);
+	if (bCollisionProof)  tmp |= BIT(26);
+	if (bMeleeProof) tmp |= BIT(27);
+	if (bOnlyDamagedByPlayer) tmp |= BIT(28);
+	if (bStreamingDontDelete) tmp |= BIT(29);
+	if (bZoneCulled) tmp |= BIT(30);
+	if (bZoneCulled2) tmp |= BIT(31);
+
+	WriteSaveBuf<uint32>(buf, tmp);
+
+	tmp = 0;
+
+	if (bRemoveFromWorld) tmp |= BIT(0);
+	if (bHasHitWall) tmp |= BIT(1);
+	if (bImBeingRendered)  tmp |= BIT(2);
+	if (bTouchingWater) tmp |= BIT(3);
+	if (bIsSubway) tmp |= BIT(4);
+	if (bDrawLast) tmp |= BIT(5);
+	if (bNoBrightHeadLights) tmp |= BIT(6);
+	if (bDoNotRender) tmp |= BIT(7);
+
+	if (bDistanceFade) tmp |= BIT(8);
+	if (m_flagE2) tmp |= BIT(9);
+
+	WriteSaveBuf<uint32>(buf, tmp);
+}
+
+void
+CEntity::LoadEntityFlags(uint8*& buf)
+{
+	uint32 tmp = ReadSaveBuf<uint32>(buf);
+	m_type = (tmp & ((BIT(3) - 1)));
+	m_status = ((tmp >> 3) & (BIT(5) - 1));
+
+	bUsesCollision = !!(tmp & BIT(8));
+	bCollisionProcessed = !!(tmp & BIT(9));
+	bIsStatic = !!(tmp & BIT(10));
+	bHasContacted = !!(tmp & BIT(11));
+	bPedPhysics = !!(tmp & BIT(12));
+	bIsStuck = !!(tmp & BIT(13));
+	bIsInSafePosition = !!(tmp & BIT(14));
+	bUseCollisionRecords = !!(tmp & BIT(15));
+
+	bWasPostponed = !!(tmp & BIT(16));
+	bExplosionProof = !!(tmp & BIT(17));
+	bIsVisible = !!(tmp & BIT(18));
+	bHasCollided = !!(tmp & BIT(19));
+	bRenderScorched = !!(tmp & BIT(20));
+	bHasBlip = !!(tmp & BIT(21));
+	bIsBIGBuilding = !!(tmp & BIT(22));
+	bRenderDamaged = !!(tmp & BIT(23));
+
+	bBulletProof = !!(tmp & BIT(24));
+	bFireProof = !!(tmp & BIT(25));
+	bCollisionProof = !!(tmp & BIT(26));
+	bMeleeProof = !!(tmp & BIT(27));
+	bOnlyDamagedByPlayer = !!(tmp & BIT(28));
+	bStreamingDontDelete = !!(tmp & BIT(29));
+	bZoneCulled = !!(tmp & BIT(30));
+	bZoneCulled2 = !!(tmp & BIT(31));
+
+	tmp = ReadSaveBuf<uint32>(buf);
+
+	bRemoveFromWorld = !!(tmp & BIT(0));
+	bHasHitWall = !!(tmp & BIT(1));
+	bImBeingRendered = !!(tmp & BIT(2));
+	bTouchingWater = !!(tmp & BIT(3));
+	bIsSubway = !!(tmp & BIT(4));
+	bDrawLast = !!(tmp & BIT(5));
+	bNoBrightHeadLights = !!(tmp & BIT(6));
+	bDoNotRender = !!(tmp & BIT(7));
+
+	bDistanceFade = !!(tmp & BIT(8));
+	m_flagE2 = !!(tmp & BIT(9));
+}
+
+#endif
diff --git a/src/entities/Entity.h b/src/entities/Entity.h
index 15a7a602..dbe2c08b 100644
--- a/src/entities/Entity.h
+++ b/src/entities/Entity.h
@@ -98,7 +98,12 @@ public:
 	eEntityStatus GetStatus() const { return (eEntityStatus)m_status; }
 	void SetStatus(eEntityStatus status) { m_status = status; }
 	CColModel *GetColModel(void) { return CModelInfo::GetModelInfo(m_modelIndex)->GetColModel(); }
+#ifdef COMPATIBLE_SAVES
+	void SaveEntityFlags(uint8*& buf);
+	void LoadEntityFlags(uint8*& buf);
+#else
 	uint32* GetAddressOfEntityProperties() { /* AWFUL */ return (uint32*)((char*)&m_rwObject + sizeof(m_rwObject)); }
+#endif
 
 	CEntity(void);
 	~CEntity(void);
diff --git a/src/peds/Ped.cpp b/src/peds/Ped.cpp
index 20fa93da..e7972541 100644
--- a/src/peds/Ped.cpp
+++ b/src/peds/Ped.cpp
@@ -17732,3 +17732,45 @@ CPed::SetExitBoat(CVehicle *boat)
 	// Not there in VC.
 	CWaterLevel::FreeBoatWakeArray();
 }
+
+#ifdef COMPATIBLE_SAVES
+void
+CPed::Save(uint8*& buf)
+{
+	SkipSaveBuf(buf, 52);
+	WriteSaveBuf<float>(buf, GetPosition().x);
+	WriteSaveBuf<float>(buf, GetPosition().y);
+	WriteSaveBuf<float>(buf, GetPosition().z);
+	SkipSaveBuf(buf, 288);
+	WriteSaveBuf<uint8>(buf, CharCreatedBy);
+	SkipSaveBuf(buf, 351);
+	WriteSaveBuf<float>(buf, m_fHealth);
+	WriteSaveBuf<float>(buf, m_fArmour);
+	SkipSaveBuf(buf, 148);
+	for (int i = 0; i < 13; i++) // has to be hardcoded
+		m_weapons[i].Save(buf);
+	SkipSaveBuf(buf, 5);
+	WriteSaveBuf<uint8>(buf, m_maxWeaponTypeAllowed);
+	SkipSaveBuf(buf, 162);
+}
+
+void
+CPed::Load(uint8*& buf)
+{
+	SkipSaveBuf(buf, 52);
+	GetPosition().x = ReadSaveBuf<float>(buf);
+	GetPosition().y = ReadSaveBuf<float>(buf);
+	GetPosition().z = ReadSaveBuf<float>(buf);
+	SkipSaveBuf(buf, 288);
+	CharCreatedBy = ReadSaveBuf<uint8>(buf);
+	SkipSaveBuf(buf, 351);
+	m_fHealth = ReadSaveBuf<float>(buf);
+	m_fArmour = ReadSaveBuf<float>(buf);
+	SkipSaveBuf(buf, 148);
+	for (int i = 0; i < 13; i++) // has to be hardcoded
+		m_weapons[i].Load(buf);
+	SkipSaveBuf(buf, 5);
+	m_maxWeaponTypeAllowed = ReadSaveBuf<uint8>(buf);
+	SkipSaveBuf(buf, 162);
+}
+#endif
diff --git a/src/peds/Ped.h b/src/peds/Ped.h
index 91322151..9f105e7a 100644
--- a/src/peds/Ped.h
+++ b/src/peds/Ped.h
@@ -886,6 +886,11 @@ public:
 #ifdef PED_SKIN
 	void renderLimb(int node);
 #endif
+
+#ifdef COMPATIBLE_SAVES
+	virtual void Save(uint8*& buf);
+	virtual void Load(uint8*& buf);
+#endif
 };
 
 void FinishFuckUCB(CAnimBlendAssociation *assoc, void *arg);
diff --git a/src/peds/PlayerPed.cpp b/src/peds/PlayerPed.cpp
index dc44983d..6d0d394d 100644
--- a/src/peds/PlayerPed.cpp
+++ b/src/peds/PlayerPed.cpp
@@ -19,6 +19,13 @@
 
 #define PAD_MOVE_TO_GAME_WORLD_MOVE 60.0f
 
+const uint32 CPlayerPed::nSaveStructSize =
+#ifdef COMPATIBLE_SAVES
+	1520;
+#else
+	sizeof(CPlayerPed);
+#endif
+
 CPlayerPed::~CPlayerPed()
 {
 	delete m_pWanted;
@@ -1504,3 +1511,33 @@ CPlayerPed::ProcessControl(void)
 		UpdateRpHAnim();
 #endif
 }
+
+#ifdef COMPATIBLE_SAVES
+void
+CPlayerPed::Save(uint8*& buf)
+{
+	CPed::Save(buf);
+	SkipSaveBuf(buf, 16);
+	WriteSaveBuf<float>(buf, m_fMaxStamina);
+	SkipSaveBuf(buf, 28);
+	WriteSaveBuf<int32>(buf, m_nTargettableObjects[0]);
+	WriteSaveBuf<int32>(buf, m_nTargettableObjects[1]);
+	WriteSaveBuf<int32>(buf, m_nTargettableObjects[2]);
+	WriteSaveBuf<int32>(buf, m_nTargettableObjects[3]);
+	SkipSaveBuf(buf, 116);
+}
+
+void
+CPlayerPed::Load(uint8*& buf)
+{
+	CPed::Load(buf);
+	SkipSaveBuf(buf, 16);
+	m_fMaxStamina = ReadSaveBuf<float>(buf);
+	SkipSaveBuf(buf, 28);
+	m_nTargettableObjects[0] = ReadSaveBuf<int32>(buf);
+	m_nTargettableObjects[1] = ReadSaveBuf<int32>(buf);
+	m_nTargettableObjects[2] = ReadSaveBuf<int32>(buf);
+	m_nTargettableObjects[3] = ReadSaveBuf<int32>(buf);
+	SkipSaveBuf(buf, 116);
+}
+#endif
diff --git a/src/peds/PlayerPed.h b/src/peds/PlayerPed.h
index b8bd57e4..61b70f89 100644
--- a/src/peds/PlayerPed.h
+++ b/src/peds/PlayerPed.h
@@ -75,6 +75,13 @@ public:
 	static void SetupPlayerPed(int32);
 	static void DeactivatePlayerPed(int32);
 	static void ReactivatePlayerPed(int32);
+
+#ifdef COMPATIBLE_SAVES
+	virtual void Save(uint8*& buf);
+	virtual void Load(uint8*& buf);
+#endif
+
+	static const uint32 nSaveStructSize;
 };
 
 #ifndef PED_SKIN
diff --git a/src/vehicles/Automobile.cpp b/src/vehicles/Automobile.cpp
index e38c93ae..acca4d60 100644
--- a/src/vehicles/Automobile.cpp
+++ b/src/vehicles/Automobile.cpp
@@ -51,6 +51,13 @@ RwObject *GetCurrentAtomicObjectCB(RwObject *object, void *data);
 
 bool CAutomobile::m_sAllTaxiLights;
 
+const uint32 CAutomobile::nSaveStructSize =
+#ifdef COMPATIBLE_SAVES
+	1448;
+#else
+	sizeof(CAutomobile);
+#endif
+
 CAutomobile::CAutomobile(int32 id, uint8 CreatedBy)
  : CVehicle(CreatedBy)
 {
@@ -4580,3 +4587,22 @@ CAutomobile::SetAllTaxiLights(bool set)
 {
 	m_sAllTaxiLights = set;
 }
+
+#ifdef COMPATIBLE_SAVES
+void
+CAutomobile::Save(uint8*& buf)
+{
+	CVehicle::Save(buf);
+	WriteSaveBuf<CDamageManager>(buf, Damage);
+	SkipSaveBuf(buf, 800 - sizeof(CDamageManager));
+}
+
+void
+CAutomobile::Load(uint8*& buf)
+{
+	CVehicle::Load(buf);
+	Damage = ReadSaveBuf<CDamageManager>(buf);
+	SkipSaveBuf(buf, 800 - sizeof(CDamageManager));
+	SetupDamageAfterLoad();
+}
+#endif
diff --git a/src/vehicles/Automobile.h b/src/vehicles/Automobile.h
index 2de85a99..041302bf 100644
--- a/src/vehicles/Automobile.h
+++ b/src/vehicles/Automobile.h
@@ -188,9 +188,15 @@ public:
 	void HideAllComps(void);
 	void ShowAllComps(void);
 	void ReduceHornCounter(void);
+#ifdef COMPATIBLE_SAVES
+	virtual void Save(uint8*& buf);
+	virtual void Load(uint8*& buf);
+#endif
+	static const uint32 nSaveStructSize;
 
 	static void SetAllTaxiLights(bool set);
 };
+
 static_assert(sizeof(CAutomobile) == 0x5A8, "CAutomobile: error");
 
 inline uint8 GetCarDoorFlag(int32 carnode) {
diff --git a/src/vehicles/Boat.cpp b/src/vehicles/Boat.cpp
index 5e75dc21..1f80c43e 100644
--- a/src/vehicles/Boat.cpp
+++ b/src/vehicles/Boat.cpp
@@ -32,6 +32,13 @@ float WAKE_LIFETIME = 400.0f;
 
 CBoat *CBoat::apFrameWakeGeneratingBoats[4];
 
+const uint32 CBoat::nSaveStructSize =
+#ifdef COMPATIBLE_SAVES
+	1156;
+#else
+	sizeof(CBoat);
+#endif
+
 CBoat::CBoat(int mi, uint8 owner) : CVehicle(owner)
 {
 	CVehicleModelInfo *minfo = (CVehicleModelInfo*)CModelInfo::GetModelInfo(mi);
@@ -899,3 +906,19 @@ CBoat::AddWakePoint(CVector point)
 		m_nNumWakePoints = 1;
 	}
 }
+
+#ifdef COMPATIBLE_SAVES
+void
+CBoat::Save(uint8*& buf)
+{
+	CVehicle::Save(buf);
+	SkipSaveBuf(buf, 1156 - 648);
+}
+
+void
+CBoat::Load(uint8*& buf)
+{
+	CVehicle::Load(buf);
+	SkipSaveBuf(buf, 1156 - 648);
+}
+#endif
diff --git a/src/vehicles/Boat.h b/src/vehicles/Boat.h
index ba56e355..70407ab9 100644
--- a/src/vehicles/Boat.h
+++ b/src/vehicles/Boat.h
@@ -64,7 +64,14 @@ public:
 	static float IsVertexAffectedByWake(CVector vecVertex, CBoat *pBoat);
 	static void FillBoatList(void);
 
+#ifdef COMPATIBLE_SAVES
+	virtual void Save(uint8*& buf);
+	virtual void Load(uint8*& buf);
+#endif
+	static const uint32 nSaveStructSize;
+
 };
+
 static_assert(sizeof(CBoat) == 0x484, "CBoat: error");
 
 extern float MAX_WAKE_LENGTH;
diff --git a/src/vehicles/Vehicle.cpp b/src/vehicles/Vehicle.cpp
index 590e68f2..75f43515 100644
--- a/src/vehicles/Vehicle.cpp
+++ b/src/vehicles/Vehicle.cpp
@@ -1222,3 +1222,128 @@ DestroyVehicleAndDriverAndPassengers(CVehicle* pVehicle)
 	CWorld::Remove(pVehicle);
 	delete pVehicle;
 }
+
+#ifdef COMPATIBLE_SAVES
+void
+CVehicle::Save(uint8*& buf)
+{
+	SkipSaveBuf(buf, 4);
+	WriteSaveBuf<float>(buf, GetRight().x);
+	WriteSaveBuf<float>(buf, GetRight().y);
+	WriteSaveBuf<float>(buf, GetRight().z);
+	SkipSaveBuf(buf, 4);
+	WriteSaveBuf<float>(buf, GetForward().x);
+	WriteSaveBuf<float>(buf, GetForward().y);
+	WriteSaveBuf<float>(buf, GetForward().z);
+	SkipSaveBuf(buf, 4);
+	WriteSaveBuf<float>(buf, GetUp().x);
+	WriteSaveBuf<float>(buf, GetUp().y);
+	WriteSaveBuf<float>(buf, GetUp().z);
+	SkipSaveBuf(buf, 4);
+	WriteSaveBuf<float>(buf, GetPosition().x);
+	WriteSaveBuf<float>(buf, GetPosition().y);
+	WriteSaveBuf<float>(buf, GetPosition().z);
+	SkipSaveBuf(buf, 16);
+	SaveEntityFlags(buf);
+	SkipSaveBuf(buf, 212);
+	AutoPilot.Save(buf);
+	WriteSaveBuf<int8>(buf, m_currentColour1);
+	WriteSaveBuf<int8>(buf, m_currentColour2);
+	SkipSaveBuf(buf, 2);
+	WriteSaveBuf<int16>(buf, m_nAlarmState);
+	SkipSaveBuf(buf, 43);
+	WriteSaveBuf<uint8>(buf, m_nNumMaxPassengers);
+	SkipSaveBuf(buf, 2);
+	WriteSaveBuf<float>(buf, field_1D0[0]);
+	WriteSaveBuf<float>(buf, field_1D0[1]);
+	WriteSaveBuf<float>(buf, field_1D0[2]);
+	WriteSaveBuf<float>(buf, field_1D0[3]);
+	SkipSaveBuf(buf, 8);
+	WriteSaveBuf<float>(buf, m_fSteerAngle);
+	WriteSaveBuf<float>(buf, m_fGasPedal);
+	WriteSaveBuf<float>(buf, m_fBrakePedal);
+	WriteSaveBuf<uint8>(buf, VehicleCreatedBy);
+	uint8 flags = 0;
+	if (bIsLawEnforcer) flags |= BIT(0);
+	if (bIsLocked) flags |= BIT(3);
+	if (bEngineOn) flags |= BIT(4);
+	if (bIsHandbrakeOn) flags |= BIT(5);
+	if (bLightsOn) flags |= BIT(6);
+	if (bFreebies) flags |= BIT(7);
+	WriteSaveBuf<uint8>(buf, flags);
+	SkipSaveBuf(buf, 10);
+	WriteSaveBuf<float>(buf, m_fHealth);
+	WriteSaveBuf<uint8>(buf, m_nCurrentGear);
+	SkipSaveBuf(buf, 3);
+	WriteSaveBuf<float>(buf, m_fChangeGearTime);
+	SkipSaveBuf(buf, 4);
+	WriteSaveBuf<uint32>(buf, m_nTimeOfDeath);
+	SkipSaveBuf(buf, 2);
+	WriteSaveBuf<int16>(buf, m_nBombTimer);
+	SkipSaveBuf(buf, 12);
+	WriteSaveBuf<int8>(buf, m_nDoorLock);
+	SkipSaveBuf(buf, 99);
+}
+
+void
+CVehicle::Load(uint8*& buf)
+{
+	CMatrix tmp;
+	SkipSaveBuf(buf, 4);
+	tmp.GetRight().x = ReadSaveBuf<float>(buf);
+	tmp.GetRight().y = ReadSaveBuf<float>(buf);
+	tmp.GetRight().z = ReadSaveBuf<float>(buf);
+	SkipSaveBuf(buf, 4);
+	tmp.GetForward().x = ReadSaveBuf<float>(buf);
+	tmp.GetForward().y = ReadSaveBuf<float>(buf);
+	tmp.GetForward().z = ReadSaveBuf<float>(buf);
+	SkipSaveBuf(buf, 4);
+	tmp.GetUp().x = ReadSaveBuf<float>(buf);
+	tmp.GetUp().y = ReadSaveBuf<float>(buf);
+	tmp.GetUp().z = ReadSaveBuf<float>(buf);
+	SkipSaveBuf(buf, 4);
+	tmp.GetPosition().x = ReadSaveBuf<float>(buf);
+	tmp.GetPosition().y = ReadSaveBuf<float>(buf);
+	tmp.GetPosition().z = ReadSaveBuf<float>(buf);
+	m_matrix = tmp;
+	SkipSaveBuf(buf, 16);
+	LoadEntityFlags(buf);
+	SkipSaveBuf(buf, 212);
+	AutoPilot.Load(buf);
+	m_currentColour1 = ReadSaveBuf<int8>(buf);
+	m_currentColour2 = ReadSaveBuf<int8>(buf);
+	SkipSaveBuf(buf, 2);
+	m_nAlarmState = ReadSaveBuf<int16>(buf);
+	SkipSaveBuf(buf, 43);
+	m_nNumMaxPassengers = ReadSaveBuf<int8>(buf);
+	SkipSaveBuf(buf, 2);
+	field_1D0[0] = ReadSaveBuf<float>(buf);
+	field_1D0[1] = ReadSaveBuf<float>(buf);
+	field_1D0[2] = ReadSaveBuf<float>(buf);
+	field_1D0[3] = ReadSaveBuf<float>(buf);
+	SkipSaveBuf(buf, 8);
+	m_fSteerAngle = ReadSaveBuf<float>(buf);
+	m_fGasPedal = ReadSaveBuf<float>(buf);
+	m_fBrakePedal = ReadSaveBuf<float>(buf);
+	VehicleCreatedBy = ReadSaveBuf<uint8>(buf);
+	uint8 flags = ReadSaveBuf<uint8>(buf);
+	bIsLawEnforcer = !!(flags & BIT(0));
+	bIsLocked = !!(flags & BIT(3));
+	bEngineOn = !!(flags & BIT(4));
+	bIsHandbrakeOn = !!(flags & BIT(5));
+	bLightsOn = !!(flags & BIT(6));
+	bFreebies = !!(flags & BIT(7));
+	SkipSaveBuf(buf, 10);
+	m_fHealth = ReadSaveBuf<float>(buf);
+	m_nCurrentGear = ReadSaveBuf<uint8>(buf);
+	SkipSaveBuf(buf, 3);
+	m_fChangeGearTime = ReadSaveBuf<float>(buf);
+	SkipSaveBuf(buf, 4);
+	m_nTimeOfDeath = ReadSaveBuf<uint32>(buf);
+	SkipSaveBuf(buf, 2);
+	m_nBombTimer = ReadSaveBuf<int16>(buf);
+	SkipSaveBuf(buf, 12);
+	m_nDoorLock = (eCarLock)ReadSaveBuf<int8>(buf);
+	SkipSaveBuf(buf, 99);
+}
+#endif
diff --git a/src/vehicles/Vehicle.h b/src/vehicles/Vehicle.h
index cb4ac2cf..b6b6ea4b 100644
--- a/src/vehicles/Vehicle.h
+++ b/src/vehicles/Vehicle.h
@@ -231,6 +231,10 @@ public:
 	virtual bool IsRoomForPedToLeaveCar(uint32 component, CVector *forcedDoorPos) { return false;}
 	virtual float GetHeightAboveRoad(void);
 	virtual void PlayCarHorn(void) {}
+#ifdef COMPATIBLE_SAVES
+	virtual void Save(uint8*& buf);
+	virtual void Load(uint8*& buf);
+#endif
 
 	bool IsCar(void) { return m_vehType == VEHICLE_TYPE_CAR; }
 	bool IsBoat(void) { return m_vehType == VEHICLE_TYPE_BOAT; }
diff --git a/src/weapons/Weapon.cpp b/src/weapons/Weapon.cpp
index 9897e73f..e9b917de 100644
--- a/src/weapons/Weapon.cpp
+++ b/src/weapons/Weapon.cpp
@@ -2257,4 +2257,30 @@ bool
 CWeapon::ProcessLineOfSight(CVector const &point1, CVector const &point2, CColPoint &point, CEntity *&entity, eWeaponType type, CEntity *shooter, bool checkBuildings, bool checkVehicles, bool checkPeds, bool checkObjects, bool checkDummies, bool ignoreSeeThrough, bool ignoreSomeObjects)
 {
 	return CWorld::ProcessLineOfSight(point1, point2, point, entity, checkBuildings, checkVehicles, checkPeds, checkObjects, checkDummies, ignoreSeeThrough, ignoreSomeObjects);
-}
\ No newline at end of file
+}
+
+#ifdef COMPATIBLE_SAVES
+void
+CWeapon::Save(uint8*& buf)
+{
+	WriteSaveBuf<uint32>(buf, m_eWeaponType);
+	WriteSaveBuf<uint32>(buf, m_eWeaponState);
+	WriteSaveBuf<uint32>(buf, m_nAmmoInClip);
+	WriteSaveBuf<uint32>(buf, m_nAmmoTotal);
+	WriteSaveBuf<uint32>(buf, m_nTimer);
+	WriteSaveBuf<bool>(buf, m_bAddRotOffset);
+	SkipSaveBuf(buf, 3);
+}
+
+void
+CWeapon::Load(uint8*& buf)
+{
+	m_eWeaponType = (eWeaponType)ReadSaveBuf<uint32>(buf);
+	m_eWeaponState = (eWeaponState)ReadSaveBuf<uint32>(buf);
+	m_nAmmoInClip = ReadSaveBuf<uint32>(buf);
+	m_nAmmoTotal = ReadSaveBuf<uint32>(buf);
+	m_nTimer = ReadSaveBuf<uint32>(buf);
+	m_bAddRotOffset = ReadSaveBuf<bool>(buf);
+	SkipSaveBuf(buf, 3);
+}
+#endif
diff --git a/src/weapons/Weapon.h b/src/weapons/Weapon.h
index 2c3a9657..1b2c0320 100644
--- a/src/weapons/Weapon.h
+++ b/src/weapons/Weapon.h
@@ -67,6 +67,11 @@ public:
 	bool HasWeaponAmmoToBeUsed(void);
 	
 	static bool ProcessLineOfSight(CVector const &point1, CVector const &point2, CColPoint &point, CEntity *&entity, eWeaponType type, CEntity *shooter, bool checkBuildings, bool checkVehicles, bool checkPeds, bool checkObjects, bool checkDummies, bool ignoreSeeThrough, bool ignoreSomeObjects);
+
+#ifdef COMPATIBLE_SAVES
+	void Save(uint8*& buf);
+	void Load(uint8*& buf);
+#endif
 };
 VALIDATE_SIZE(CWeapon, 0x18);