25 files changed, 2528 insertions, 404 deletions

diff --git a/src/control/AutoPilot.cpp b/src/control/AutoPilot.cpp
index e3d5c9e9..70099291 100644
--- a/src/control/AutoPilot.cpp
+++ b/src/control/AutoPilot.cpp
@@ -6,9 +6,6 @@
 #include "Curves.h"
 #include "PathFind.h"
 
-#if 0
-WRAPPER void CAutoPilot::ModifySpeed(float) { EAXJMP(0x4137B0); }
-#else
 void CAutoPilot::ModifySpeed(float speed)
 {
 	m_fMaxTrafficSpeed = max(0.01f, speed);
@@ -41,7 +38,6 @@ void CAutoPilot::ModifySpeed(float speed)
 	m_nTimeEnteredCurve = CTimer::GetTimeInMilliseconds() - positionBetweenNodes * m_nSpeedScaleFactor;
 #endif
 }
-#endif
 
 void CAutoPilot::RemoveOnePathNode()
 {
diff --git a/src/control/Bridge.h b/src/control/Bridge.h
index 377c8bf8..63f41578 100644
--- a/src/control/Bridge.h
+++ b/src/control/Bridge.h
@@ -1,5 +1,6 @@
 #pragma once
-#include "Entity.h"
+
+class CEntity;
 
 enum bridgeStates {
     STATE_BRIDGE_LOCKED,
diff --git a/src/control/CarAI.cpp b/src/control/CarAI.cpp
index c5d62c48..e47e3d5e 100644
--- a/src/control/CarAI.cpp
+++ b/src/control/CarAI.cpp
@@ -9,6 +9,9 @@
 #include "HandlingMgr.h"
 #include "ModelIndices.h"
 #include "PlayerPed.h"
+#include "Wanted.h"
+#include "DMAudio.h"
+#include "Fire.h"
 #include "Pools.h"
 #include "Timer.h"
 #include "TrafficLights.h"
diff --git a/src/control/CarCtrl.cpp b/src/control/CarCtrl.cpp
index de8c799e..3174a253 100644
--- a/src/control/CarCtrl.cpp
+++ b/src/control/CarCtrl.cpp
@@ -19,6 +19,7 @@
 #include "Ped.h"
 #include "PlayerInfo.h"
 #include "PlayerPed.h"
+#include "Wanted.h"
 #include "Pools.h"
 #include "Renderer.h"
 #include "RoadBlocks.h"
@@ -27,7 +28,7 @@
 #include "Streaming.h"
 #include "VisibilityPlugins.h"
 #include "Vehicle.h"
-#include "Wanted.h"
+#include "Fire.h"
 #include "World.h"
 #include "Zones.h"
 
@@ -880,9 +881,7 @@ CCarCtrl::SlowCarOnRailsDownForTrafficAndLights(CVehicle* pVehicle)
 			pVehicle->AutoPilot.ModifySpeed(max(maxSpeed, curSpeed - 0.5f * CTimer::GetTimeStep()));
 	}
 }
-#if 0
-WRAPPER void CCarCtrl::SlowCarDownForPedsSectorList(CPtrList&, CVehicle*, float, float, float, float, float*, float) { EAXJMP(0x419300); }
-#else
+
 void CCarCtrl::SlowCarDownForPedsSectorList(CPtrList& lst, CVehicle* pVehicle, float x_inf, float y_inf, float x_sup, float y_sup, float* pSpeed, float curSpeed)
 {
 	float frontOffset = pVehicle->GetModelInfo()->GetColModel()->boundingBox.max.y;
@@ -990,7 +989,6 @@ void CCarCtrl::SlowCarDownForPedsSectorList(CPtrList& lst, CVehicle* pVehicle, f
 		}
 	}
 }
-#endif
 
 void CCarCtrl::SlowCarDownForCarsSectorList(CPtrList& lst, CVehicle* pVehicle, float x_inf, float y_inf, float x_sup, float y_sup, float* pSpeed, float curSpeed)
 {
@@ -1054,9 +1052,6 @@ void CCarCtrl::SlowCarDownForOtherCar(CEntity* pOtherEntity, CVehicle* pVehicle,
 	}
 }
 
-#if 0
-WRAPPER float CCarCtrl::TestCollisionBetween2MovingRects(CVehicle* pVehicleA, CVehicle* pVehicleB, float projectionX, float projectionY, CVector* pForwardA, CVector* pForwardB, uint8 id) { EAXJMP(0x41A020); }
-#else
 float CCarCtrl::TestCollisionBetween2MovingRects(CVehicle* pVehicleA, CVehicle* pVehicleB, float projectionX, float projectionY, CVector* pForwardA, CVector* pForwardB, uint8 id)
 {
 	CVector2D vecBToA = pVehicleA->GetPosition() - pVehicleB->GetPosition();
@@ -1179,7 +1174,6 @@ float CCarCtrl::TestCollisionBetween2MovingRects(CVehicle* pVehicleA, CVehicle*
 	}
 	return proximity;
 }
-#endif
 
 float CCarCtrl::FindAngleToWeaveThroughTraffic(CVehicle* pVehicle, CPhysical* pTarget, float angleToTarget, float angleForward)
 {
diff --git a/src/control/Curves.cpp b/src/control/Curves.cpp
index c5f64bf7..5c6ef06d 100644
--- a/src/control/Curves.cpp
+++ b/src/control/Curves.cpp
@@ -2,9 +2,6 @@
 #include "patcher.h"
 #include "Curves.h"
 
-#if 0
-WRAPPER float CCurves::CalcSpeedScaleFactor(CVector*, CVector*, float, float, float, float) { EAXJMP(0x420410); }
-#else
 float CCurves::CalcSpeedScaleFactor(CVector* pPoint1, CVector* pPoint2, float dir1X, float dir1Y, float dir2X, float dir2Y)
 {
 	CVector2D dir1(dir1X, dir1Y);
@@ -16,11 +13,7 @@ float CCurves::CalcSpeedScaleFactor(CVector* pPoint1, CVector* pPoint2, float di
 	else
 		return ((1.0f - dp) * 0.2f + 1.0f) * distance;
 }
-#endif
 
-#if 0
-WRAPPER void CCurves::CalcCurvePoint(CVector*, CVector*, CVector*, CVector*, float, int32, CVector*, CVector*) { EAXJMP(0x4204D0); }
-#else
 void CCurves::CalcCurvePoint(CVector* pPos1, CVector* pPos2, CVector* pDir1, CVector* pDir2, float between, int32 timeOnCurve, CVector* pOutPos, CVector* pOutDir)
 {
 	float actualFactor = CalcSpeedScaleFactor(pPos1, pPos2, pDir1->x, pDir1->y, pDir2->x, pDir2->y);
@@ -35,5 +28,4 @@ void CCurves::CalcCurvePoint(CVector* pPos1, CVector* pPos2, CVector* pDir1, CVe
 		(dir1.x * (1.0f - curveCoef) + dir2.x * curveCoef) / (timeOnCurve * 0.001f),
 		(dir1.y * (1.0f - curveCoef) + dir2.y * curveCoef) / (timeOnCurve * 0.001f),
 		0.0f);
-}
-#endif
\ No newline at end of file
+}
\ No newline at end of file
diff --git a/src/control/Darkel.cpp b/src/control/Darkel.cpp
index b7ae0726..b4d15abf 100644
--- a/src/control/Darkel.cpp
+++ b/src/control/Darkel.cpp
@@ -3,6 +3,7 @@
 #include "main.h"
 #include "Darkel.h"
 #include "PlayerPed.h"
+#include "Wanted.h"
 #include "Timer.h"
 #include "DMAudio.h"
 #include "Population.h"
@@ -161,9 +162,6 @@ CDarkel::ReadStatus()
 	return Status;
 }
 
-#if 0
-WRAPPER void CDarkel::RegisterCarBlownUpByPlayer(CVehicle *vehicle) { EAXJMP(0x421070); }
-#else
 void
 CDarkel::RegisterCarBlownUpByPlayer(CVehicle *vehicle)
 {
@@ -177,11 +175,7 @@ CDarkel::RegisterCarBlownUpByPlayer(CVehicle *vehicle)
 	RegisteredKills[vehicle->GetModelIndex()]++;
 	CStats::CarsExploded++;
 }
-#endif
 
-#if 0
-WRAPPER void CDarkel::RegisterKillByPlayer(CPed *victim, eWeaponType weapontype, bool headshot) { EAXJMP(0x420F60); }
-#else
 void
 CDarkel::RegisterKillByPlayer(CPed *victim, eWeaponType weapon, bool headshot)
 {
@@ -206,7 +200,6 @@ CDarkel::RegisterKillByPlayer(CPed *victim, eWeaponType weapon, bool headshot)
 		CStats::HeadsPopped++;
 	CStats::KillsSinceLastCheckpoint++;
 }
-#endif
 
 void
 CDarkel::RegisterKillNotByPlayer(CPed* victim, eWeaponType weapontype)
@@ -221,9 +214,6 @@ CDarkel::ResetModelsKilledByPlayer()
 		RegisteredKills[i] = 0;
 }
 
-#if 0
-WRAPPER void CDarkel::ResetOnPlayerDeath() { EAXJMP(0x420E70); }
-#else
 void
 CDarkel::ResetOnPlayerDeath()
 {
@@ -252,11 +242,7 @@ CDarkel::ResetOnPlayerDeath()
 		player->MakeChangesForNewWeapon(player->m_currentWeapon);
 	}
 }
-#endif
 
-#if 0
-WRAPPER void CDarkel::StartFrenzy(eWeaponType weaponType, int32 time, uint16 kill, int32 modelId0, wchar *text, int32 modelId2, int32 modelId3, int32 modelId4, bool standardSound, bool needHeadShot) { EAXJMP(0x4210E0); }
-#else
 void
 CDarkel::StartFrenzy(eWeaponType weaponType, int32 time, uint16 kill, int32 modelId0, wchar *text, int32 modelId2, int32 modelId3, int32 modelId4, bool standardSound, bool needHeadShot)
 {
@@ -305,7 +291,6 @@ CDarkel::StartFrenzy(eWeaponType weaponType, int32 time, uint16 kill, int32 mode
 	if (CDarkel::bStandardSoundAndMessages)
 		DMAudio.PlayFrontEndSound(SOUND_RAMPAGE_START, 0);
 }
-#endif
 
 void
 CDarkel::Update()
diff --git a/src/control/Darkel.h b/src/control/Darkel.h
index f17d7581..12ce4451 100644
--- a/src/control/Darkel.h
+++ b/src/control/Darkel.h
@@ -1,9 +1,9 @@
 #pragma once
-#include "Weapon.h"
 #include "ModelIndices.h"
 
 class CVehicle;
 class CPed;
+enum eWeaponType;
 
 enum
 {
diff --git a/src/control/GameLogic.cpp b/src/control/GameLogic.cpp
index 1e5b72c3..0abae7d6 100644
--- a/src/control/GameLogic.cpp
+++ b/src/control/GameLogic.cpp
@@ -9,6 +9,7 @@
 #include "CutsceneMgr.h"

 #include "World.h"

 #include "PlayerPed.h"

+#include "Wanted.h"

 #include "Camera.h"

 #include "Messages.h"

 #include "CarCtrl.h"

@@ -56,7 +57,7 @@ CGameLogic::SortOutStreamingAndMemory(const CVector &pos)
 	CStreaming::FlushRequestList();

 	CStreaming::DeleteRwObjectsAfterDeath(pos);

 	CStreaming::RemoveUnusedModelsInLoadedList();

-	CGame::DrasticTidyUpMemory();

+	CGame::DrasticTidyUpMemory(true);

 	CStreaming::LoadScene(pos);

 	CTimer::Update();

 }

diff --git a/src/control/Gangs.cpp b/src/control/Gangs.cpp
index f9cb4698..ac32ad98 100644
--- a/src/control/Gangs.cpp
+++ b/src/control/Gangs.cpp
@@ -1,7 +1,8 @@
 #include "common.h"
 #include "patcher.h"
 #include "ModelIndices.h"
-#include "Gangs.h"
+#include "Gangs.h"

+#include "Weapon.h"
 
 //CGangInfo(&CGangs::Gang)[NUM_GANGS] = *(CGangInfo(*)[NUM_GANGS])*(uintptr*)0x6EDF78;
 CGangInfo CGangs::Gang[NUM_GANGS];
@@ -13,7 +14,7 @@ CGangInfo::CGangInfo() :
 	m_Weapon2(WEAPONTYPE_UNARMED)
 {}
 
-void CGangs::Initialize(void)
+void CGangs::Initialise(void)
 {
 	Gang[GANG_MAFIA].m_nVehicleMI = MI_MAFIA;
 	Gang[GANG_TRIAD].m_nVehicleMI = MI_BELLYUP;
@@ -38,8 +39,8 @@ void CGangs::SetGangVehicleModel(int16 gang, int32 model)
 void CGangs::SetGangWeapons(int16 gang, int32 weapon1, int32 weapon2)
 {
 	CGangInfo *gi = GetGangInfo(gang);
-	gi->m_Weapon1 = (eWeaponType)weapon1;
-	gi->m_Weapon2 = (eWeaponType)weapon2;
+	gi->m_Weapon1 = weapon1;
+	gi->m_Weapon2 = weapon2;
 }
 
 void CGangs::SetGangPedModelOverride(int16 gang, int8 ovrd)
@@ -66,7 +67,7 @@ VALIDATESAVEBUF(*size);
 
 void CGangs::LoadAllGangData(uint8 *buf, uint32 size)
 {
-	Initialize();

+	Initialise();

 

 INITSAVEBUF

 	// original: SkipSaveBuf(buf, SAVE_HEADER_SIZE);

@@ -78,7 +79,7 @@ VALIDATESAVEBUF(size);
 }
 
 STARTPATCHES
-	InjectHook(0x4C3FB0, CGangs::Initialize, PATCH_JUMP);
+	InjectHook(0x4C3FB0, CGangs::Initialise, PATCH_JUMP);
 	InjectHook(0x4C4010, CGangs::SetGangVehicleModel, PATCH_JUMP);
 	InjectHook(0x4C4030, CGangs::SetGangWeapons, PATCH_JUMP);
 	InjectHook(0x4C4050, CGangs::SetGangPedModelOverride, PATCH_JUMP);
diff --git a/src/control/Gangs.h b/src/control/Gangs.h
index a348f259..dd7a7f93 100644
--- a/src/control/Gangs.h
+++ b/src/control/Gangs.h
@@ -1,13 +1,11 @@
 #pragma once
 
-#include "Weapon.h"
-
 struct CGangInfo
 {
 	int32 m_nVehicleMI;
 	int8 m_nPedModelOverride;
-	eWeaponType m_Weapon1;
-	eWeaponType m_Weapon2;
+	int32 m_Weapon1;
+	int32 m_Weapon2;
 
 	CGangInfo();
 };
@@ -30,7 +28,7 @@ enum {
 class CGangs
 {
 public:
-	static void Initialize(void);
+	static void Initialise(void);
 	static void SetGangVehicleModel(int16, int32);
 	static void SetGangWeapons(int16, int32, int32);
 	static void SetGangPedModelOverride(int16, int8);
diff --git a/src/control/Garages.cpp b/src/control/Garages.cpp
index 5ac15377..7e9fc0fa 100644
--- a/src/control/Garages.cpp
+++ b/src/control/Garages.cpp
@@ -1,152 +1,1384 @@
 #include "common.h"
 #include "patcher.h"
-#include "main.h"
-#include "ModelIndices.h"
 #include "Garages.h"
-#include "Timer.h"
+#include "main.h"
+
+#ifdef FIX_BUGS
+#include "Boat.h"
+#endif
+#include "DMAudio.h"
+#include "General.h"
 #include "Font.h"
+#include "HandlingMgr.h"
+#include "Hud.h"
 #include "Messages.h"
+#include "ModelIndices.h"
+#include "Pad.h"
+#include "Particle.h"
 #include "PlayerPed.h"
+#include "Replay.h"
+#include "Stats.h"
+#include "Streaming.h"
 #include "Text.h"
+#include "Timer.h"
+#include "Vehicle.h"
+#include "Wanted.h"
 #include "World.h"
 
-int32 &CGarages::BankVansCollected = *(int32 *)0x8F1B34;
-bool &CGarages::BombsAreFree = *(bool *)0x95CD7A;
-bool &CGarages::RespraysAreFree = *(bool *)0x95CD1D;
-int32 &CGarages::CarsCollected = *(int32 *)0x880E18;
-int32 (&CGarages::CarTypesCollected)[TOTAL_COLLECTCARS_GARAGES] = *(int32 (*)[TOTAL_COLLECTCARS_GARAGES])*(uintptr*)0x8E286C;
-int32 &CGarages::CrushedCarId = *(int32 *)0x943060;
-uint32 &CGarages::LastTimeHelpMessage = *(uint32 *)0x8F1B58;
-int32 &CGarages::MessageNumberInString = *(int32 *)0x885BA8;
-const char *CGarages::MessageIDString = (const char *)0x878358;
-int32 &CGarages::MessageNumberInString2 = *(int32 *)0x8E2C14;
-uint32 &CGarages::MessageStartTime = *(uint32 *)0x8F2530;
-uint32 &CGarages::MessageEndTime = *(uint32 *)0x8F597C;
-uint32 &CGarages::NumGarages = *(uint32 *)0x8F29F4;
-bool &CGarages::PlayerInGarage = *(bool *)0x95CD83;
-int32 &CGarages::PoliceCarsCollected = *(int32 *)0x941444;
-uint32 &CGarages::GarageToBeTidied = *(uint32 *)0x623570;
-
-CGarage(&CGarages::Garages)[NUM_GARAGES] = *(CGarage(*)[NUM_GARAGES])*(uintptr*)0x72BCD0;
-
-WRAPPER void CGarages::Init(void) { EAXJMP(0x421C60); }
-WRAPPER void CGarages::Update(void) { EAXJMP(0x421E40); }
-WRAPPER void CGarages::Load(uint8* buf, uint32 size) { EAXJMP(0x428940); }
-WRAPPER void CGarages::Save(uint8* buf, uint32 *size) { EAXJMP(0x4284e0); }
+#define CRUSHER_GARAGE_X1 (1135.5f)
+#define CRUSHER_GARAGE_Y1 (57.0f)
+#define CRUSHER_GARAGE_Z1 (-1.0f)
+#define CRUSHER_GARAGE_X2 (1149.5f)
+#define CRUSHER_GARAGE_Y2 (63.7f)
+#define CRUSHER_GARAGE_Z2 (3.5f)
 
-bool
-CGarages::IsModelIndexADoor(uint32 id)
+#define ROTATED_DOOR_OPEN_SPEED (0.015f)
+#define ROTATED_DOOR_CLOSE_SPEED (0.02f)
+#define DEFAULT_DOOR_OPEN_SPEED (0.035f)
+#define DEFAULT_DOOR_CLOSE_SPEED (0.04f)
+#define CRUSHER_CRANE_SPEED (0.005f)
+
+// Prices
+#define BOMB_PRICE (1000)
+#define RESPRAY_PRICE (1000)
+
+// Distances
+#define DISTANCE_TO_CALL_OFF_CHASE (10.0f)
+#define DISTANCE_FOR_MRWHOOP_HACK (4.0f)
+#define DISTANCE_TO_ACTIVATE_GARAGE (8.0f)
+#define DISTANCE_TO_ACTIVATE_KEEPCAR_GARAGE (17.0f)
+#define DISTANCE_TO_CLOSE_MISSION_GARAGE (30.0f)
+#define DISTANCE_TO_CLOSE_COLLECTSPECIFICCARS_GARAGE (25.0f)
+#define DISTANCE_TO_CLOSE_COLLECTCARS_GARAGE (40.0f)
+#define DISTANCE_TO_CLOSE_HIDEOUT_GARAGE_ON_FOOT (2.2f)
+#define DISTANCE_TO_CLOSE_HIDEOUT_GARAGE_IN_CAR (15.0f)
+#define DISTANCE_TO_FORCE_CLOSE_HIDEOUT_GARAGE (70.0f)
+#define DISTANCE_TO_OPEN_HIDEOUT_GARAGE_ON_FOOT (1.7f)
+#define DISTANCE_TO_OPEN_HIDEOUT_GARAGE_IN_CAR (10.0f)
+#define DISTANCE_TO_SHOW_HIDEOUT_MESSAGE (5.0f)
+
+#define DISTANCE_TO_CONSIDER_DOOR_FOR_GARAGE (20.0f)
+
+// Time
+#define TIME_TO_RESPRAY (2000)
+#define TIME_TO_SETUP_BOMB (2000)
+#define TIME_TO_CRUSH_CAR (3000)
+#define TIME_TO_PROCESS_KEEPCAR_GARAGE (2000)
+
+// Respray stuff
+#define FREE_RESPRAY_HEALTH_THRESHOLD (970.0f)
+#define NUM_PARTICLES_IN_RESPRAY (200)
+#define RESPRAY_CENTERING_COEFFICIENT (0.75f)
+
+// Bomb stuff
+#define KGS_OF_EXPLOSIVES_IN_BOMB (10)
+
+// Collect specific cars stuff
+#define REWARD_FOR_FIRST_POLICE_CAR (5000)
+#define REWARD_FOR_FIRST_BANK_VAN (5000)
+#define MAX_POLICE_CARS_TO_COLLECT (10)
+#define MAX_BANK_VANS_TO_COLLECT (10)
+
+// Collect cars stuff
+#define MAX_SPEED_TO_SHOW_COLLECTED_MESSAGE (0.03f)
+#define IMPORT_REWARD (1000)
+#define IMPORT_ALLCARS_REWARD (200000)
+
+// Crusher stuff
+#define CRUSHER_VEHICLE_TEST_SPAN (8)
+#define CRUSHER_MIN_REWARD (25)
+#define CRUSHER_MAX_REWARD (125)
+#define CRUSHER_REWARD_COEFFICIENT (1.0f/500000)
+
+// Hideout stuff
+#define MAX_STORED_CARS_IN_INDUSTRIAL (1)
+#define MAX_STORED_CARS_IN_COMMERCIAL (NUM_GARAGE_STORED_CARS)
+#define MAX_STORED_CARS_IN_SUBURBAN (NUM_GARAGE_STORED_CARS)
+#define LIMIT_CARS_IN_INDUSTRIAL (1)
+#define LIMIT_CARS_IN_COMMERCIAL (2)
+#define LIMIT_CARS_IN_SUBURBAN (3)
+#define HIDEOUT_DOOR_SPEED_COEFFICIENT (1.7f)
+#define TIME_BETWEEN_HIDEOUT_MESSAGES (18000)
+
+// Camera stuff
+#define MARGIN_FOR_CAMERA_COLLECTCARS (1.3f)
+#define MARGIN_FOR_CAMERA_DEFAULT (4.0f)
+
+const int32 gaCarsToCollectInCraigsGarages[TOTAL_COLLECTCARS_GARAGES][TOTAL_COLLECTCARS_CARS] =
 {
-	return id == MI_GARAGEDOOR1 ||
-		id == MI_GARAGEDOOR2 ||
-		id == MI_GARAGEDOOR3 ||
-		id == MI_GARAGEDOOR4 ||
-		id == MI_GARAGEDOOR5 ||
-		id == MI_GARAGEDOOR6 ||
-		id == MI_GARAGEDOOR7 ||
-		id == MI_GARAGEDOOR9 ||
-		id == MI_GARAGEDOOR10 ||
-		id == MI_GARAGEDOOR11 ||
-		id == MI_GARAGEDOOR12 ||
-		id == MI_GARAGEDOOR13 ||
-		id == MI_GARAGEDOOR14 ||
-		id == MI_GARAGEDOOR15 ||
-		id == MI_GARAGEDOOR16 ||
-		id == MI_GARAGEDOOR17 ||
-		id == MI_GARAGEDOOR18 ||
-		id == MI_GARAGEDOOR19 ||
-		id == MI_GARAGEDOOR20 ||
-		id == MI_GARAGEDOOR21 ||
-		id == MI_GARAGEDOOR22 ||
-		id == MI_GARAGEDOOR23 ||
-		id == MI_GARAGEDOOR24 ||
-		id == MI_GARAGEDOOR25 ||
-		id == MI_GARAGEDOOR26 ||
-		id == MI_GARAGEDOOR27 ||
-		id == MI_GARAGEDOOR28 ||
-		id == MI_GARAGEDOOR29 ||
-		id == MI_GARAGEDOOR30 ||
-		id == MI_GARAGEDOOR31 ||
-		id == MI_GARAGEDOOR32 ||
-		id == MI_CRUSHERBODY ||
-		id == MI_CRUSHERLID;
+	{ MI_SECURICA, MI_MOONBEAM, MI_COACH,    MI_FLATBED,  MI_LINERUN,  MI_TRASH,    MI_PATRIOT,  MI_MRWHOOP,  MI_BLISTA,   MI_MULE,     MI_YANKEE,   MI_BOBCAT,   MI_DODO,     MI_BUS,      MI_RUMPO,    MI_PONY     },
+	{ MI_SENTINEL, MI_CHEETAH,  MI_BANSHEE,  MI_IDAHO,    MI_INFERNUS, MI_TAXI,     MI_KURUMA,   MI_STRETCH,  MI_PEREN,    MI_STINGER,  MI_MANANA,   MI_LANDSTAL, MI_STALLION, MI_BFINJECT, MI_CABBIE,   MI_ESPERANT },
+	{ MI_LANDSTAL, MI_LANDSTAL, MI_LANDSTAL, MI_LANDSTAL, MI_LANDSTAL, MI_LANDSTAL, MI_LANDSTAL, MI_LANDSTAL, MI_LANDSTAL, MI_LANDSTAL, MI_LANDSTAL, MI_CHEETAH,  MI_TAXI,     MI_ESPERANT, MI_SENTINEL, MI_IDAHO    }
+};
+
+int32& CGarages::BankVansCollected = *(int32*)0x8F1B34;
+bool& CGarages::BombsAreFree = *(bool*)0x95CD7A;
+bool& CGarages::RespraysAreFree = *(bool*)0x95CD1D;
+int32& CGarages::CarsCollected = *(int32*)0x880E18;
+int32(&CGarages::CarTypesCollected)[TOTAL_COLLECTCARS_GARAGES] = *(int32(*)[TOTAL_COLLECTCARS_GARAGES]) * (uintptr*)0x8E286C;
+int32& CGarages::CrushedCarId = *(int32*)0x943060;
+uint32& CGarages::LastTimeHelpMessage = *(uint32*)0x8F1B58;
+int32& CGarages::MessageNumberInString = *(int32*)0x885BA8;
+char(&CGarages::MessageIDString)[MESSAGE_LENGTH] = *(char(*)[MESSAGE_LENGTH]) * (uintptr*)0x878358;
+int32& CGarages::MessageNumberInString2 = *(int32*)0x8E2C14;
+uint32& CGarages::MessageStartTime = *(uint32*)0x8F2530;
+uint32& CGarages::MessageEndTime = *(uint32*)0x8F597C;
+uint32& CGarages::NumGarages = *(uint32*)0x8F29F4;
+bool& CGarages::PlayerInGarage = *(bool*)0x95CD83;
+int32& CGarages::PoliceCarsCollected = *(int32*)0x941444;
+uint32& CGarages::GarageToBeTidied = *(uint32*)0x623570;
+CStoredCar(&CGarages::aCarsInSafeHouse1)[NUM_GARAGE_STORED_CARS] = *(CStoredCar(*)[NUM_GARAGE_STORED_CARS]) * (uintptr*)0x6FA210;
+CStoredCar(&CGarages::aCarsInSafeHouse2)[NUM_GARAGE_STORED_CARS] = *(CStoredCar(*)[NUM_GARAGE_STORED_CARS]) * (uintptr*)0x6FA300;
+CStoredCar(&CGarages::aCarsInSafeHouse3)[NUM_GARAGE_STORED_CARS] = *(CStoredCar(*)[NUM_GARAGE_STORED_CARS]) * (uintptr*)0x6FA3F0;
+int32& CGarages::AudioEntity = *(int32*)0x5ECEA8;
+CGarage(&CGarages::aGarages)[NUM_GARAGES] = *(CGarage(*)[NUM_GARAGES]) * (uintptr*)0x72BCD0;
+bool& CGarages::bCamShouldBeOutisde = *(bool*)0x95CDB2;
+
+void CGarages::Init(void)
+{
+	CrushedCarId = -1;
+	NumGarages = 0;
+	MessageEndTime = 0;
+	MessageStartTime = 0;
+	PlayerInGarage = false;
+	BombsAreFree = false;
+	CarsCollected = 0;
+	BankVansCollected = 0;
+	PoliceCarsCollected = 0;
+	for (int i = 0; i < TOTAL_COLLECTCARS_GARAGES; i++)
+		CarTypesCollected[i] = 0;
+	LastTimeHelpMessage = 0;
+	for (int i = 0; i < NUM_GARAGE_STORED_CARS; i++)
+		aCarsInSafeHouse1[i].Init();
+	for (int i = 0; i < NUM_GARAGE_STORED_CARS; i++)
+		aCarsInSafeHouse2[i].Init();
+	for (int i = 0; i < NUM_GARAGE_STORED_CARS; i++)
+		aCarsInSafeHouse3[i].Init();
+	AudioEntity = DMAudio.CreateEntity(AUDIOTYPE_GARAGE, (void*)1);
+	if (AudioEntity >= 0)
+		DMAudio.SetEntityStatus(AudioEntity, 1);
+	AddOne(
+		CRUSHER_GARAGE_X1, CRUSHER_GARAGE_Y1, CRUSHER_GARAGE_Z1,
+		CRUSHER_GARAGE_X2, CRUSHER_GARAGE_Y2, CRUSHER_GARAGE_Z2,
+		GARAGE_CRUSHER, 0);
 }
 
-bool CGarages::HasCarBeenCrushed(int32 handle)
+#ifndef PS2
+void CGarages::Shutdown(void)
 {
-	return CrushedCarId == handle;
+	NumGarages = 0;
+	if (AudioEntity < 0)
+		return;
+	DMAudio.DestroyEntity(AudioEntity);
+	AudioEntity = AEHANDLE_NONE;
 }
+#endif
 
-WRAPPER void CGarages::TriggerMessage(const char *text, int16, uint16 time, int16) { EAXJMP(0x426B20); }
-WRAPPER bool CGarages::IsPointWithinHideOutGarage(CVector&) { EAXJMP(0x428260); }
-WRAPPER bool CGarages::IsPointWithinAnyGarage(CVector&) { EAXJMP(0x428320); }
-WRAPPER void CGarages::PlayerArrestedOrDied() { EAXJMP(0x427F60); }
-WRAPPER int16 CGarages::AddOne(float, float, float, float, float, float, uint8, uint32) { EAXJMP(0x421FA0); }
-WRAPPER void CGarages::SetTargetCarForMissonGarage(int16, CVehicle*) { EAXJMP(0x426BD0); }
-WRAPPER bool CGarages::HasCarBeenDroppedOffYet(int16) { EAXJMP(0x426C20); }
-WRAPPER void CGarages::DeActivateGarage(int16) { EAXJMP(0x426C40); }
-WRAPPER void CGarages::ActivateGarage(int16) { EAXJMP(0x426C60); }
+void CGarages::Update(void)
+{
+	static int GarageToBeTidied = 0;
+#ifndef PS2
+	if (CReplay::IsPlayingBack())
+		return;
+#endif
+	bCamShouldBeOutisde = false;
+	TheCamera.pToGarageWeAreIn = nil;
+	TheCamera.pToGarageWeAreInForHackAvoidFirstPerson = nil;
+	for (int i = 0; i < NUM_GARAGES; i++) {
+		if (aGarages[i].IsUsed())
+			aGarages[i].Update();
+	}
+	if ((CTimer::GetFrameCounter() & 0xF) != 0xC)
+		return;
+	if (++GarageToBeTidied >= NUM_GARAGES)
+		GarageToBeTidied = 0;
+	if (!aGarages[GarageToBeTidied].IsUsed())
+		return;
+	if (!aGarages[GarageToBeTidied].IsFar())
+		aGarages[GarageToBeTidied].TidyUpGarageClose();
+	else
+		aGarages[GarageToBeTidied].TidyUpGarage();
+}
 
-int32 CGarages::QueryCarsCollected(int16 garage)
+int16 CGarages::AddOne(float X1, float Y1, float Z1, float X2, float Y2, float Z2, eGarageType type, int32 targetId)
 {
-	return 0;
+	if (NumGarages >= NUM_GARAGES) {
+		assert(0);
+		return NumGarages++;
+	}
+	CGarage* pGarage = &aGarages[NumGarages];
+	pGarage->m_fX1 = min(X1, X2);
+	pGarage->m_fX2 = max(X1, X2);
+	pGarage->m_fY1 = min(Y1, Y2);
+	pGarage->m_fY2 = max(Y1, Y2);
+	pGarage->m_fZ1 = min(Z1, Z2);
+	pGarage->m_fZ2 = max(Z1, Z2);
+	pGarage->m_pDoor1 = nil;
+	pGarage->m_pDoor2 = nil;
+	pGarage->m_fDoor1Z = Z1;
+	pGarage->m_fDoor2Z = Z1;
+	pGarage->m_eGarageType = type;
+	pGarage->m_bRecreateDoorOnNextRefresh = false;
+	pGarage->m_bRotatedDoor = false;
+	pGarage->m_bCameraFollowsPlayer = false;
+	pGarage->RefreshDoorPointers(true);
+	if (pGarage->m_pDoor1) {
+		pGarage->m_fDoor1Z = pGarage->m_pDoor1->GetPosition().z;
+		pGarage->m_fDoor1X = pGarage->m_pDoor1->GetPosition().x;
+		pGarage->m_fDoor1Y = pGarage->m_pDoor1->GetPosition().y;
+	}
+	if (pGarage->m_pDoor2) {
+		pGarage->m_fDoor2Z = pGarage->m_pDoor2->GetPosition().z;
+		pGarage->m_fDoor2X = pGarage->m_pDoor2->GetPosition().x;
+		pGarage->m_fDoor2Y = pGarage->m_pDoor2->GetPosition().y;
+	}
+	pGarage->m_fDoorHeight = pGarage->m_pDoor1 ? FindDoorHeightForMI(pGarage->m_pDoor1->GetModelIndex()) : 4.0f;
+	pGarage->m_fDoorPos = 0.0f;
+	pGarage->m_eGarageState = GS_FULLYCLOSED;
+	pGarage->m_nTimeToStartAction = 0;
+	pGarage->field_2 = false;
+	pGarage->m_nTargetModelIndex = targetId;
+	pGarage->field_96 = nil;
+	pGarage->m_bCollectedCarsState = 0;
+	pGarage->m_bDeactivated = false;
+	pGarage->m_bResprayHappened = false;
+	switch (type) {
+	case GARAGE_MISSION:
+	case GARAGE_COLLECTORSITEMS:
+	case GARAGE_COLLECTSPECIFICCARS:
+	case GARAGE_COLLECTCARS_1:
+	case GARAGE_COLLECTCARS_2:
+	case GARAGE_COLLECTCARS_3:
+	case GARAGE_FORCARTOCOMEOUTOF:
+	case GARAGE_60SECONDS:
+	case GARAGE_MISSION_KEEPCAR:
+	case GARAGE_FOR_SCRIPT_TO_OPEN:
+	case GARAGE_HIDEOUT_ONE:
+	case GARAGE_HIDEOUT_TWO:
+	case GARAGE_HIDEOUT_THREE:
+	case GARAGE_FOR_SCRIPT_TO_OPEN_AND_CLOSE:
+	case GARAGE_KEEPS_OPENING_FOR_SPECIFIC_CAR:
+	case GARAGE_MISSION_KEEPCAR_REMAINCLOSED:
+		pGarage->m_eGarageState = GS_FULLYCLOSED;
+		pGarage->m_fDoorPos = 0.0f;
+		break;
+	case GARAGE_BOMBSHOP1:
+	case GARAGE_BOMBSHOP2:
+	case GARAGE_BOMBSHOP3:
+	case GARAGE_RESPRAY:
+		pGarage->m_eGarageState = GS_OPENED;
+		pGarage->m_fDoorPos = pGarage->m_fDoorHeight;
+		break;
+	case GARAGE_CRUSHER:
+		pGarage->m_eGarageState = GS_OPENED;
+		pGarage->m_fDoorPos = HALFPI;
+		break;
+	default:
+		assert(false);
+	}
+	if (type == GARAGE_CRUSHER)
+		pGarage->UpdateCrusherAngle();
+	else
+		pGarage->UpdateDoorsHeight();
+	return NumGarages++;
 }
 
-void CGarages::GivePlayerDetonator()
+void CGarages::ChangeGarageType(int16 garage, eGarageType type, int32 mi)
 {
-	FindPlayerPed()->GiveWeapon(WEAPONTYPE_DETONATOR, 1);
-	FindPlayerPed()->GetWeapon(FindPlayerPed()->GetWeaponSlot(WEAPONTYPE_DETONATOR)).m_eWeaponState = WEAPONSTATE_READY;
+	CGarage* pGarage = &aGarages[garage];
+	pGarage->m_eGarageType = type;
+	pGarage->m_nTargetModelIndex = mi;
+	pGarage->m_eGarageState = GS_FULLYCLOSED;
+}
+
+void CGarage::Update()
+{
+	if (m_eGarageType != GARAGE_CRUSHER) {
+		switch (m_eGarageState) {
+		case GS_FULLYCLOSED:
+		case GS_OPENED:
+		case GS_CLOSING:
+		case GS_OPENING:
+		case GS_OPENEDCONTAINSCAR:
+		case GS_CLOSEDCONTAINSCAR:
+			if (FindPlayerPed() && !m_bCameraFollowsPlayer) {
+				CVehicle* pVehicle = FindPlayerVehicle();
+				if (IsEntityEntirelyInside3D(FindPlayerPed(), 0.25f)) {
+					TheCamera.pToGarageWeAreIn = this;
+					CGarages::bCamShouldBeOutisde = true;
+				}
+				if (pVehicle) {
+					if (IsEntityEntirelyOutside(pVehicle, 0.0f))
+						TheCamera.pToGarageWeAreInForHackAvoidFirstPerson = this;
+					if (pVehicle->GetModelIndex() == MI_MRWHOOP) {
+						if (pVehicle->IsWithinArea(
+							m_fX1 - DISTANCE_FOR_MRWHOOP_HACK,
+							m_fX2 + DISTANCE_FOR_MRWHOOP_HACK,
+							m_fY1 - DISTANCE_FOR_MRWHOOP_HACK,
+							m_fY2 + DISTANCE_FOR_MRWHOOP_HACK)) {
+							TheCamera.pToGarageWeAreIn = this;
+							CGarages::bCamShouldBeOutisde = true;
+						}
+					}
+				}
+			}
+		}
+	}
+	if (m_bDeactivated && m_eGarageState == GS_FULLYCLOSED)
+		return;
+	switch (m_eGarageType) {
+	case GARAGE_RESPRAY:
+		switch (m_eGarageState) {
+		case GS_OPENED:
+			if (IsStaticPlayerCarEntirelyInside() && !IsAnyOtherCarTouchingGarage(FindPlayerVehicle())) {
+				if (CGarages::IsCarSprayable(FindPlayerVehicle())) {
+					if (CWorld::Players[CWorld::PlayerInFocus].m_nMoney >= RESPRAY_PRICE || CGarages::RespraysAreFree) {
+						m_eGarageState = GS_CLOSING;
+						CPad::GetPad(0)->SetDisablePlayerControls(PLAYERCONTROL_GARAGE);
+						FindPlayerPed()->m_pWanted->m_bIgnoredByCops = true;
+					}
+					else {
+						CGarages::TriggerMessage("GA_3", -1, 4000, -1); // No more freebies. $1000 to respray!
+						m_eGarageState = GS_OPENEDCONTAINSCAR;
+						DMAudio.PlayFrontEndSound(SOUND_GARAGE_NO_MONEY, 1);
+					}
+				}
+				else {
+					CGarages::TriggerMessage("GA_1", -1, 4000, -1); // Whoa! I don't touch nothing THAT hot!
+					m_eGarageState = GS_OPENEDCONTAINSCAR;
+					DMAudio.PlayFrontEndSound(SOUND_GARAGE_BAD_VEHICLE, 1);
+				}
+			}
+			if (FindPlayerVehicle()) {
+				if (CalcDistToGarageRectangleSquared(FindPlayerVehicle()->GetPosition().x, FindPlayerVehicle()->GetPosition().y) < SQR(DISTANCE_TO_ACTIVATE_GARAGE))
+					CWorld::CallOffChaseForArea(
+						m_fX1 - DISTANCE_TO_CALL_OFF_CHASE,
+						m_fY1 - DISTANCE_TO_CALL_OFF_CHASE,
+						m_fX2 + DISTANCE_TO_CALL_OFF_CHASE,
+						m_fY2 + DISTANCE_TO_CALL_OFF_CHASE);
+			}
+			break;
+		case GS_CLOSING:
+			m_fDoorPos = max(0.0f, m_fDoorPos - (m_bRotatedDoor ? ROTATED_DOOR_CLOSE_SPEED : DEFAULT_DOOR_CLOSE_SPEED) * CTimer::GetTimeStep());
+			if (m_fDoorPos == 0.0f) {
+				m_eGarageState = GS_FULLYCLOSED;
+				m_nTimeToStartAction = CTimer::GetTimeInMilliseconds() + TIME_TO_RESPRAY;
+				DMAudio.PlayOneShot(CGarages::AudioEntity, SOUND_GARAGE_DOOR_CLOSED, 1.0f);
+				CStats::CheckPointReachedSuccessfully();
+			}
+			UpdateDoorsHeight();
+#ifdef FIX_BUGS
+			if (FindPlayerVehicle() && FindPlayerVehicle()->IsCar())
+#else
+			if (FindPlayerVehicle())
+#endif
+				((CAutomobile*)(FindPlayerVehicle()))->m_fFireBlowUpTimer = 0.0f;
+			CWorld::CallOffChaseForArea(
+				m_fX1 - DISTANCE_TO_CALL_OFF_CHASE,
+				m_fY1 - DISTANCE_TO_CALL_OFF_CHASE,
+				m_fX2 + DISTANCE_TO_CALL_OFF_CHASE,
+				m_fY2 + DISTANCE_TO_CALL_OFF_CHASE);
+			break;
+		case GS_FULLYCLOSED:
+			if (CTimer::GetTimeInMilliseconds() > m_nTimeToStartAction) {
+				m_eGarageState = GS_OPENING;
+				DMAudio.PlayFrontEndSound(SOUND_GARAGE_OPENING, 1);
+				bool bTakeMoney = false;
+				if (FindPlayerPed()->m_pWanted->m_nWantedLevel != 0)
+					bTakeMoney = true;
+				FindPlayerPed()->m_pWanted->Reset();
+				CPad::GetPad(0)->SetEnablePlayerControls(PLAYERCONTROL_GARAGE);
+				FindPlayerPed()->m_pWanted->m_bIgnoredByCops = true;
+#ifdef FIX_BUGS
+				bool bChangedColour = false;
+#else
+				bool bChangedColour;
+#endif
+				if (FindPlayerVehicle() && FindPlayerVehicle()->IsCar()) {
+					if (FindPlayerVehicle()->m_fHealth < FREE_RESPRAY_HEALTH_THRESHOLD)
+						bTakeMoney = true;
+					FindPlayerVehicle()->m_fHealth = 1000.0f;
+					((CAutomobile*)(FindPlayerVehicle()))->m_fFireBlowUpTimer = 0.0f;
+					((CAutomobile*)(FindPlayerVehicle()))->Fix();
+					if (FindPlayerVehicle()->GetUp().z < 0.0f) {
+						FindPlayerVehicle()->GetUp() = -FindPlayerVehicle()->GetUp();
+						FindPlayerVehicle()->GetRight() = -FindPlayerVehicle()->GetRight();
+					}
+					bChangedColour = false;
+					if (!((CAutomobile*)(FindPlayerVehicle()))->bFixedColour) {
+						uint8 colour1, colour2;
+						uint16 attempt;
+						((CVehicleModelInfo*)CModelInfo::GetModelInfo(FindPlayerVehicle()->GetModelIndex()))->ChooseVehicleColour(colour1, colour2);
+						for (attempt = 0; attempt < 10; attempt++) {
+							if (colour1 != FindPlayerVehicle()->m_currentColour1 || colour2 != FindPlayerVehicle()->m_currentColour2)
+								break;
+							((CVehicleModelInfo*)CModelInfo::GetModelInfo(FindPlayerVehicle()->GetModelIndex()))->ChooseVehicleColour(colour1, colour2);
+						}
+						bChangedColour = (attempt < 10);
+						FindPlayerVehicle()->m_currentColour1 = colour1;
+						FindPlayerVehicle()->m_currentColour2 = colour2;
+						if (bChangedColour) {
+							for (int i = 0; i < NUM_PARTICLES_IN_RESPRAY; i++) {
+								CVector pos;
+#ifdef FIX_BUGS
+								pos.x = CGeneral::GetRandomNumberInRange(m_fX1 + 0.5f, m_fX2 - 0.5f);
+								pos.y = CGeneral::GetRandomNumberInRange(m_fY1 + 0.5f, m_fY2 - 0.5f);
+								pos.z = CGeneral::GetRandomNumberInRange(m_fDoor1Z - 3.0f, m_fDoor1Z + 1.0f);
+#else
+								// wtf is this
+								pos.x = m_fX1 + 0.5f + (uint8)(CGeneral::GetRandomNumber()) / 256.0f * (m_fX2 - m_fX1 - 1.0f);
+								pos.y = m_fY1 + 0.5f + (uint8)(CGeneral::GetRandomNumber()) / 256.0f * (m_fY2 - m_fY1 - 1.0f);
+								pos.z = m_fDoor1Z - 3.0f + (uint8)(CGeneral::GetRandomNumber()) / 256.0f * 4.0f;
+#endif
+								CParticle::AddParticle(PARTICLE_GARAGEPAINT_SPRAY, pos, CVector(0.0f, 0.0f, 0.0f), nil, 0.0f, CVehicleModelInfo::ms_vehicleColourTable[colour1]);
+							}
+						}
+					}
+					CenterCarInGarage(FindPlayerVehicle());
+				}
+				if (bTakeMoney) {
+					if (!CGarages::RespraysAreFree)
+						CWorld::Players[CWorld::PlayerInFocus].m_nMoney = max(0, CWorld::Players[CWorld::PlayerInFocus].m_nMoney - RESPRAY_PRICE);
+					CGarages::TriggerMessage("GA_2", -1, 4000, -1); // New engine and paint job. The cops won't recognize you!
+				}
+				else if (bChangedColour) {
+					if (CGeneral::GetRandomTrueFalse())
+						CGarages::TriggerMessage("GA_15", -1, 4000, -1); // Hope you like the new color.
+					else
+						CGarages::TriggerMessage("GA_16", -1, 4000, -1); // Respray is complementary.
+				}
+				m_bResprayHappened = true;
+			}
+			CWorld::CallOffChaseForArea(
+				m_fX1 - DISTANCE_TO_CALL_OFF_CHASE,
+				m_fY1 - DISTANCE_TO_CALL_OFF_CHASE,
+				m_fX2 + DISTANCE_TO_CALL_OFF_CHASE,
+				m_fY2 + DISTANCE_TO_CALL_OFF_CHASE);
+			break;
+		case GS_OPENING:
+			m_fDoorPos = min(m_fDoorHeight, m_fDoorPos + (m_bRotatedDoor ? ROTATED_DOOR_OPEN_SPEED : DEFAULT_DOOR_OPEN_SPEED) * CTimer::GetTimeStep());
+			if (m_fDoorPos == m_fDoorHeight) {
+				m_eGarageState = GS_OPENEDCONTAINSCAR;
+				DMAudio.PlayOneShot(CGarages::AudioEntity, SOUND_GARAGE_DOOR_OPENED, 1.0f);
+			}
+			UpdateDoorsHeight();
+			break;
+		case GS_OPENEDCONTAINSCAR:
+			if (IsPlayerOutsideGarage())
+				m_eGarageState = GS_OPENED;
+			break;
+		//case GS_CLOSEDCONTAINSCAR:
+		//case GS_AFTERDROPOFF:
+		default:
+			break;
+		}
+		break;
+	case GARAGE_BOMBSHOP1:
+	case GARAGE_BOMBSHOP2:
+	case GARAGE_BOMBSHOP3:
+		switch (m_eGarageState) {
+		case GS_OPENED:
+			if (IsStaticPlayerCarEntirelyInside() && !IsAnyOtherCarTouchingGarage(FindPlayerVehicle())) {
+#ifdef FIX_BUGS // FindPlayerVehicle() can never be NULL here because IsStaticPlayerCarEntirelyInside() is true, and there is no IsCar() check
+				if (FindPlayerVehicle()->IsCar() && ((CAutomobile*)FindPlayerVehicle())->m_bombType) {
+#else
+				if (!FindPlayerVehicle() || ((CAutomobile*)FindPlayerVehicle())->m_bombType) {
+#endif
+					CGarages::TriggerMessage("GA_5", -1, 4000, -1); //"Your car is already fitted with a bomb"
+					m_eGarageState = GS_OPENEDCONTAINSCAR;
+					DMAudio.PlayFrontEndSound(SOUND_GARAGE_BOMB_ALREADY_SET, 1);
+					break;
+				}
+				if (!CGarages::BombsAreFree && CWorld::Players[CWorld::PlayerInFocus].m_nMoney < BOMB_PRICE) {
+					CGarages::TriggerMessage("GA_4", -1, 4000, -1); // "Car bombs are $1000 each"
+					m_eGarageState = GS_OPENEDCONTAINSCAR;
+					DMAudio.PlayFrontEndSound(SOUND_GARAGE_NO_MONEY, 1);
+					break;
+				}
+				m_eGarageState = GS_CLOSING;
+				CPad::GetPad(0)->SetDisablePlayerControls(PLAYERCONTROL_GARAGE);
+				FindPlayerPed()->m_pWanted->m_bIgnoredByCops = true;
+				}
+			break;
+		case GS_CLOSING:
+			m_fDoorPos = max(0.0f, m_fDoorPos - (m_bRotatedDoor ? ROTATED_DOOR_CLOSE_SPEED : DEFAULT_DOOR_CLOSE_SPEED) * CTimer::GetTimeStep());
+			if (m_fDoorPos == 0.0f) {
+				m_eGarageState = GS_FULLYCLOSED;
+				m_nTimeToStartAction = CTimer::GetTimeInMilliseconds() + TIME_TO_SETUP_BOMB;
+				DMAudio.PlayOneShot(CGarages::AudioEntity, SOUND_GARAGE_DOOR_CLOSED, 1.0f);
+			}
+			UpdateDoorsHeight();
+			break;
+		case GS_FULLYCLOSED:
+			if (CTimer::GetTimeInMilliseconds() > m_nTimeToStartAction) {
+				switch (m_eGarageType) {
+				case GARAGE_BOMBSHOP1: DMAudio.PlayFrontEndSound(SOUND_GARAGE_BOMB1_SET, 1); break;
+				case GARAGE_BOMBSHOP2: DMAudio.PlayFrontEndSound(SOUND_GARAGE_BOMB2_SET, 1); break;
+				case GARAGE_BOMBSHOP3: DMAudio.PlayFrontEndSound(SOUND_GARAGE_BOMB3_SET, 1); break;
+				}
+				m_eGarageState = GS_OPENING;
+				if (!CGarages::BombsAreFree)
+					CWorld::Players[CWorld::PlayerInFocus].m_nMoney = max(0, CWorld::Players[CWorld::PlayerInFocus].m_nMoney - BOMB_PRICE);
+				if (FindPlayerVehicle() && FindPlayerVehicle()->IsCar()) {
+					((CAutomobile*)(FindPlayerVehicle()))->m_bombType = CGarages::GetBombTypeForGarageType(m_eGarageType);
+					((CAutomobile*)(FindPlayerVehicle()))->m_pBombRigger = FindPlayerPed();
+					if (m_eGarageType == GARAGE_BOMBSHOP3)
+						CGarages::GivePlayerDetonator();
+					CStats::KgOfExplosivesUsed += KGS_OF_EXPLOSIVES_IN_BOMB;
+				}
+				switch (m_eGarageType) {
+				case GARAGE_BOMBSHOP1:
+					switch (CPad::GetPad(0)->Mode) {
+					case 0:
+					case 1:
+					case 2:
+						CHud::SetHelpMessage(TheText.Get("GA_6"), false); // Arm with ~h~~k~~PED_FIREWEAPON~ button~w~. Bomb will go off when engine is started.
+						break;
+					case 3:
+						CHud::SetHelpMessage(TheText.Get("GA_6B"), false); // Arm with ~h~~k~~PED_FIREWEAPON~ button~w~. Bomb will go off when engine is started.
+						break;
+					}
+					break;
+				case GARAGE_BOMBSHOP2:
+					switch (CPad::GetPad(0)->Mode) {
+					case 0:
+					case 1:
+					case 2:
+						CHud::SetHelpMessage(TheText.Get("GA_7"), false); // Park it, prime it by pressing the ~h~~k~~PED_FIREWEAPON~ button~w~ and LEG IT!
+						break;
+					case 3:
+						CHud::SetHelpMessage(TheText.Get("GA_7B"), false); // Park it, prime it by pressing the ~h~~k~~PED_FIREWEAPON~ button~w~ and LEG IT!
+						break;
+					}
+					break;
+				case GARAGE_BOMBSHOP3:
+					CHud::SetHelpMessage(TheText.Get("GA_8"), false); // Use the detonator to activate the bomb.
+					break;
+				}
+				CPad::GetPad(0)->SetEnablePlayerControls(PLAYERCONTROL_GARAGE);
+				FindPlayerPed()->m_pWanted->m_bIgnoredByCops = false;
+			}
+			break;
+		case GS_OPENING:
+			m_fDoorPos = min(m_fDoorHeight, m_fDoorPos + (m_bRotatedDoor ? ROTATED_DOOR_OPEN_SPEED : DEFAULT_DOOR_OPEN_SPEED) * CTimer::GetTimeStep());
+			if (m_fDoorPos == m_fDoorHeight) {
+				m_eGarageState = GS_OPENEDCONTAINSCAR;
+				DMAudio.PlayOneShot(CGarages::AudioEntity, SOUND_GARAGE_DOOR_OPENED, 1.0f);
+			}
+			UpdateDoorsHeight();
+			break;
+		case GS_OPENEDCONTAINSCAR:
+			if (IsPlayerOutsideGarage())
+				m_eGarageState = GS_OPENED;
+			break;
+		//case GS_CLOSEDCONTAINSCAR:
+		//case GS_AFTERDROPOFF:
+		default:
+			break;
+			}
+		break;
+	case GARAGE_MISSION:
+		switch (m_eGarageState) {
+		case GS_OPENED:
+			if (((CVector2D)FindPlayerCoors() - CVector2D(GetGarageCenterX(), GetGarageCenterY())).MagnitudeSqr() > SQR(DISTANCE_TO_CLOSE_MISSION_GARAGE)) {
+				if ((CTimer::GetFrameCounter() & 0x1F) == 0 && !IsAnyOtherCarTouchingGarage(nil)) {
+					m_eGarageState = GS_CLOSING;
+					m_bClosingWithoutTargetCar = true;
+				}
+			}
+			else if (!FindPlayerVehicle() && m_pTarget && IsEntityEntirelyInside3D(m_pTarget, 0.0f) &&
+				!IsAnyOtherCarTouchingGarage(m_pTarget) && IsEntityEntirelyOutside(FindPlayerPed(), 2.0f)) {
+				CPad::GetPad(0)->SetDisablePlayerControls(PLAYERCONTROL_GARAGE);
+				FindPlayerPed()->m_pWanted->m_bIgnoredByCops = true;
+				m_eGarageState = GS_CLOSING;
+				m_bClosingWithoutTargetCar = false;
+			}
+			break;
+		case GS_CLOSING:
+			m_fDoorPos = max(0.0f, m_fDoorPos - (m_bRotatedDoor ? ROTATED_DOOR_CLOSE_SPEED : DEFAULT_DOOR_CLOSE_SPEED) * CTimer::GetTimeStep());
+			if (m_fDoorPos == 0.0f) {
+				DMAudio.PlayOneShot(CGarages::AudioEntity, SOUND_GARAGE_DOOR_CLOSED, 1.0f);
+				if (m_bClosingWithoutTargetCar)
+					m_eGarageState = GS_FULLYCLOSED;
+				else {
+					if (m_pTarget) {
+						m_eGarageState = GS_CLOSEDCONTAINSCAR;
+						DestroyVehicleAndDriverAndPassengers(m_pTarget);
+						m_pTarget = nil;
+					}
+					else {
+						m_eGarageState = GS_FULLYCLOSED;
+					}
+					CPad::GetPad(0)->SetEnablePlayerControls(PLAYERCONTROL_GARAGE);
+					FindPlayerPed()->m_pWanted->m_bIgnoredByCops = false;
+				}
+			}
+			UpdateDoorsHeight();
+			break;
+		case GS_FULLYCLOSED:
+			if (FindPlayerVehicle() == m_pTarget && m_pTarget) {
+				if (CalcDistToGarageRectangleSquared(
+					FindPlayerVehicle()->GetPosition().x,
+					FindPlayerVehicle()->GetPosition().y) < SQR(DISTANCE_TO_ACTIVATE_GARAGE))
+					m_eGarageState = GS_OPENING;
+			}
+			break;
+		case GS_OPENING:
+			m_fDoorPos = min(m_fDoorHeight, m_fDoorPos + (m_bRotatedDoor ? ROTATED_DOOR_OPEN_SPEED : DEFAULT_DOOR_OPEN_SPEED) * CTimer::GetTimeStep());
+			if (m_fDoorPos == m_fDoorHeight) {
+				m_eGarageState = GS_OPENED;
+				DMAudio.PlayOneShot(CGarages::AudioEntity, SOUND_GARAGE_DOOR_OPENED, 1.0f);
+			}
+			UpdateDoorsHeight();
+			break;
+		//case GS_OPENEDCONTAINSCAR:
+		//case GS_CLOSEDCONTAINSCAR:
+		//case GS_AFTERDROPOFF:
+		default:
+			break;
+		}
+		break;
+	case GARAGE_COLLECTSPECIFICCARS:
+		switch (m_eGarageState) {
+		case GS_OPENED:
+			if (FindPlayerVehicle() && m_nTargetModelIndex == FindPlayerVehicle()->GetModelIndex()) {
+				m_pTarget = FindPlayerVehicle();
+				m_pTarget->RegisterReference((CEntity**)&m_pTarget);
+			}
+			if (!FindPlayerVehicle()) {
+				if (m_pTarget && IsEntityEntirelyInside3D(m_pTarget, 0.0f) && !IsAnyOtherCarTouchingGarage(m_pTarget)) {
+					if (IsEntityEntirelyOutside(FindPlayerPed(), 2.0f)) {
+						CPad::GetPad(0)->SetDisablePlayerControls(PLAYERCONTROL_GARAGE);
+						FindPlayerPed()->m_pWanted->m_bIgnoredByCops = true;
+						m_eGarageState = GS_CLOSING;
+					}
+				}
+				else if (Abs(FindPlayerCoors().x - GetGarageCenterX()) > DISTANCE_TO_CLOSE_COLLECTSPECIFICCARS_GARAGE ||
+					Abs(FindPlayerCoors().y - GetGarageCenterY()) > DISTANCE_TO_CLOSE_COLLECTSPECIFICCARS_GARAGE) {
+					m_eGarageState = GS_CLOSING;
+					m_pTarget = nil;
+				}
+			}
+			break;
+		case GS_CLOSING:
+			m_fDoorPos = max(0.0f, m_fDoorPos - (m_bRotatedDoor ? ROTATED_DOOR_CLOSE_SPEED : DEFAULT_DOOR_CLOSE_SPEED) * CTimer::GetTimeStep());
+			if (m_fDoorPos == 0.0f) {
+				m_eGarageState = GS_FULLYCLOSED;
+				DMAudio.PlayOneShot(CGarages::AudioEntity, SOUND_GARAGE_DOOR_CLOSED, 1.0f);
+				if (m_pTarget) {
+					DestroyVehicleAndDriverAndPassengers(m_pTarget);
+					m_pTarget = nil;
+					CPad::GetPad(0)->SetEnablePlayerControls(PLAYERCONTROL_GARAGE);
+					FindPlayerPed()->m_pWanted->m_bIgnoredByCops = false;
+					int16 reward;
+					switch (m_nTargetModelIndex) {
+					case MI_POLICE:
+						reward = REWARD_FOR_FIRST_POLICE_CAR * (MAX_POLICE_CARS_TO_COLLECT - CGarages::PoliceCarsCollected++) / MAX_POLICE_CARS_TO_COLLECT;
+						break;
+					case MI_SECURICA:
+						reward = REWARD_FOR_FIRST_BANK_VAN * (MAX_BANK_VANS_TO_COLLECT - CGarages::BankVansCollected++) / MAX_BANK_VANS_TO_COLLECT;
+						break;
+#ifdef FIX_BUGS // not possible though
+					default:
+						reward = 0;
+						break;
+#endif
+					}
+					if (reward > 0) {
+						CWorld::Players[CWorld::PlayerInFocus].m_nMoney += reward;
+						CGarages::TriggerMessage("GA_10", reward, 4000, -1); // Nice one. Here's your $~1~
+						DMAudio.PlayFrontEndSound(SOUND_GARAGE_VEHICLE_ACCEPTED, 1);
+					}
+					else {
+						CGarages::TriggerMessage("GA_11", -1, 4000, -1); // We got these wheels already. It's worthless to us!
+						DMAudio.PlayFrontEndSound(SOUND_GARAGE_VEHICLE_DECLINED, 1);
+					}
+				}
+			}
+			UpdateDoorsHeight();
+			break;
+		case GS_FULLYCLOSED:
+			if (FindPlayerVehicle() && m_nTargetModelIndex == FindPlayerVehicle()->GetModelIndex()) {
+				if (CalcDistToGarageRectangleSquared(FindPlayerVehicle()->GetPosition().x, FindPlayerVehicle()->GetPosition().y) < SQR(DISTANCE_TO_ACTIVATE_GARAGE))
+					m_eGarageState = GS_OPENING;
+			}
+			break;
+		case GS_OPENING:
+			if (FindPlayerVehicle() && m_nTargetModelIndex == FindPlayerVehicle()->GetModelIndex()) {
+				m_pTarget = FindPlayerVehicle();
+				m_pTarget->RegisterReference((CEntity**)&m_pTarget);
+			}
+			m_fDoorPos = min(m_fDoorHeight, m_fDoorPos + (m_bRotatedDoor ? ROTATED_DOOR_OPEN_SPEED : DEFAULT_DOOR_OPEN_SPEED) * CTimer::GetTimeStep());
+			if (m_fDoorPos == m_fDoorHeight) {
+				m_eGarageState = GS_OPENED;
+				DMAudio.PlayOneShot(CGarages::AudioEntity, SOUND_GARAGE_DOOR_OPENED, 1.0f);
+			}
+			UpdateDoorsHeight();
+			break;
+		//case GS_OPENEDCONTAINSCAR:
+		//case GS_CLOSEDCONTAINSCAR:
+		//case GS_AFTERDROPOFF:
+		default:
+			break;
+		}
+		break;
+	case GARAGE_COLLECTCARS_1:
+	case GARAGE_COLLECTCARS_2:
+	case GARAGE_COLLECTCARS_3:
+		switch (m_eGarageState) {
+		case GS_OPENED:
+			if (FindPlayerVehicle() && DoesCraigNeedThisCar(FindPlayerVehicle()->GetModelIndex())) {
+				m_pTarget = FindPlayerVehicle();
+				m_pTarget->RegisterReference((CEntity**)&m_pTarget);
+			}
+			if (Abs(FindPlayerCoors().x - GetGarageCenterX()) > DISTANCE_TO_CLOSE_COLLECTCARS_GARAGE ||
+				Abs(FindPlayerCoors().y - GetGarageCenterY()) > DISTANCE_TO_CLOSE_COLLECTCARS_GARAGE) {
+				m_eGarageState = GS_CLOSING;
+				m_pTarget = nil;
+				break;
+			}
+			if (m_pTarget && !FindPlayerVehicle() && IsEntityEntirelyInside3D(m_pTarget, 0.0f) &&
+				!IsAnyOtherCarTouchingGarage(m_pTarget) && IsEntityEntirelyOutside(FindPlayerPed(), 2.0f)) {
+#ifdef FIX_BUGS
+				if (!m_pTarget->IsCar() ||
+					((CAutomobile*)(m_pTarget))->Damage.GetEngineStatus() <= ENGINE_STATUS_ON_FIRE &&
+					((CAutomobile*)(m_pTarget))->m_fFireBlowUpTimer == 0.0f) {
+#else
+				if (((CAutomobile*)(m_pTarget))->Damage.GetEngineStatus() <= ENGINE_STATUS_ON_FIRE &&
+					((CAutomobile*)(m_pTarget))->m_fFireBlowUpTimer == 0.0f) {
+#endif
+					if (m_pTarget->m_status != STATUS_WRECKED) {
+						CPad::GetPad(0)->SetDisablePlayerControls(PLAYERCONTROL_GARAGE);
+						FindPlayerPed()->m_pWanted->m_bIgnoredByCops = true;
+						m_eGarageState = GS_CLOSING;
+						TheCamera.SetCameraDirectlyBehindForFollowPed_CamOnAString();
+					}
+				}
+			}
+			break;
+		case GS_CLOSING:
+			m_fDoorPos = max(0.0f, m_fDoorPos - (m_bRotatedDoor ? ROTATED_DOOR_CLOSE_SPEED : DEFAULT_DOOR_CLOSE_SPEED) * CTimer::GetTimeStep());
+			if (m_fDoorPos == 0.0f) {
+				m_eGarageState = GS_FULLYCLOSED;
+				DMAudio.PlayOneShot(CGarages::AudioEntity, SOUND_GARAGE_DOOR_CLOSED, 1.0f);
+				if (m_pTarget) {
+					MarkThisCarAsCollectedForCraig(m_pTarget->GetModelIndex());
+					DestroyVehicleAndDriverAndPassengers(m_pTarget);
+					m_pTarget = nil;
+					CPad::GetPad(0)->SetEnablePlayerControls(PLAYERCONTROL_GARAGE);
+					FindPlayerPed()->m_pWanted->m_bIgnoredByCops = false;
+				}
+			}
+			UpdateDoorsHeight();
+			break;
+		case GS_FULLYCLOSED:
+			if (FindPlayerVehicle() &&
+				CalcSmallestDistToGarageDoorSquared(
+					FindPlayerVehicle()->GetPosition().x,
+					FindPlayerVehicle()->GetPosition().y
+					) < SQR(DISTANCE_TO_ACTIVATE_GARAGE)) {
+				if (DoesCraigNeedThisCar(FindPlayerVehicle()->GetModelIndex())) {
+					if (FindPlayerVehicle()->VehicleCreatedBy == MISSION_VEHICLE)
+						CGarages::TriggerMessage("GA_1A", -1, 5000, -1); // Come back when you're not so busy...
+					else
+						m_eGarageState = GS_OPENING;
+				}
+				else {
+					if (HasCraigCollectedThisCar(FindPlayerVehicle()->GetModelIndex()))
+						CGarages::TriggerMessage("GA_20", -1, 5000, -1); // We got more of these than we can shift. Sorry man, no deal.
+					else if (FindPlayerSpeed().Magnitude() < MAX_SPEED_TO_SHOW_COLLECTED_MESSAGE)
+						CGarages::TriggerMessage("GA_19", -1, 5000, -1); // We're not interested in that model.
+				}
+			}
+			m_pTarget = nil;
+			break;
+		case GS_OPENING:
+			if (FindPlayerVehicle() && DoesCraigNeedThisCar(FindPlayerVehicle()->GetModelIndex())) {
+				m_pTarget = FindPlayerVehicle();
+				m_pTarget->RegisterReference((CEntity**)&m_pTarget);
+			}
+			m_fDoorPos = min(m_fDoorHeight, m_fDoorPos + (m_bRotatedDoor ? ROTATED_DOOR_OPEN_SPEED : DEFAULT_DOOR_OPEN_SPEED) * CTimer::GetTimeStep());
+			if (m_fDoorPos == m_fDoorHeight) {
+				m_eGarageState = GS_OPENED;
+				DMAudio.PlayOneShot(CGarages::AudioEntity, SOUND_GARAGE_DOOR_OPENED, 1.0f);
+			}
+			UpdateDoorsHeight();
+			break;
+		//case GS_OPENEDCONTAINSCAR:
+		//case GS_CLOSEDCONTAINSCAR:
+		//case GS_AFTERDROPOFF:
+		default:
+			break;
+		}
+		break;
+	case GARAGE_FORCARTOCOMEOUTOF:
+		switch (m_eGarageState) {
+		case GS_OPENED:
+			if (IsGarageEmpty())
+				m_eGarageState = GS_CLOSING;
+			break;
+		case GS_CLOSING:
+			m_fDoorPos = max(0.0f, m_fDoorPos - (m_bRotatedDoor ? ROTATED_DOOR_CLOSE_SPEED : DEFAULT_DOOR_CLOSE_SPEED) * CTimer::GetTimeStep());
+			if (m_fDoorPos == 0.0f) {
+				m_eGarageState = GS_FULLYCLOSED;
+				DMAudio.PlayOneShot(CGarages::AudioEntity, SOUND_GARAGE_DOOR_CLOSED, 1.0f);
+			}
+			if (!IsGarageEmpty())
+				m_eGarageState = GS_OPENING;
+			break;
+		case GS_FULLYCLOSED:
+			break;
+		case GS_OPENING:
+			m_fDoorPos = min(m_fDoorHeight, m_fDoorPos + (m_bRotatedDoor ? ROTATED_DOOR_OPEN_SPEED : DEFAULT_DOOR_OPEN_SPEED) * CTimer::GetTimeStep());
+			if (m_fDoorPos == m_fDoorHeight) {
+				m_eGarageState = GS_OPENED;
+				DMAudio.PlayOneShot(CGarages::AudioEntity, SOUND_GARAGE_DOOR_OPENED, 1.0f);
+			}
+			UpdateDoorsHeight();
+			break;
+		//case GS_OPENEDCONTAINSCAR:
+		//case GS_CLOSEDCONTAINSCAR:
+		//case GS_AFTERDROPOFF:
+		default:
+			break;
+		}
+		break;
+	case GARAGE_CRUSHER:
+		switch (m_eGarageState) {
+		case GS_OPENED:
+		{
+			int i = CPools::GetVehiclePool()->GetSize() * (CTimer::GetFrameCounter() % CRUSHER_VEHICLE_TEST_SPAN) / CRUSHER_VEHICLE_TEST_SPAN;
+			int end = CPools::GetVehiclePool()->GetSize() * (CTimer::GetFrameCounter() % CRUSHER_VEHICLE_TEST_SPAN + 1) / CRUSHER_VEHICLE_TEST_SPAN;
+			for (; i < end; i++) {
+				CVehicle* pVehicle = CPools::GetVehiclePool()->GetSlot(i);
+				if (!pVehicle)
+					continue;
+				if (pVehicle->IsCar() && IsEntityEntirelyInside3D(pVehicle, 0.0f)) {
+					m_eGarageState = GS_CLOSING;
+					m_pTarget = pVehicle;
+					m_pTarget->RegisterReference((CEntity**)&m_pTarget);
+				}
+			}
+			break;
+		}
+		case GS_CLOSING:
+			if (m_pTarget) {
+				m_fDoorPos = max(0.0f, m_fDoorPos - CRUSHER_CRANE_SPEED * CTimer::GetTimeStep());
+				if (m_fDoorPos < TWOPI / 5) {
+					m_pTarget->bUsesCollision = false;
+					m_pTarget->bAffectedByGravity = false;
+					m_pTarget->SetMoveSpeed(0.0f, 0.0f, 0.0f);
+				}
+				else {
+					m_pTarget->SetMoveSpeed(m_pTarget->GetMoveSpeed() * Pow(0.8f, CTimer::GetTimeStep()));
+				}
+				if (m_fDoorPos == 0.0f) {
+					CGarages::CrushedCarId = CPools::GetVehiclePool()->GetIndex(m_pTarget);
+					float reward = min(CRUSHER_MAX_REWARD, CRUSHER_MIN_REWARD + m_pTarget->pHandling->nMonetaryValue * m_pTarget->m_fHealth * CRUSHER_REWARD_COEFFICIENT);
+					CWorld::Players[CWorld::PlayerInFocus].m_nMoney += reward;
+					DestroyVehicleAndDriverAndPassengers(m_pTarget);
+					++CStats::CarsCrushed;
+					m_pTarget = nil;
+					m_eGarageState = GS_AFTERDROPOFF;
+					m_nTimeToStartAction = CTimer::GetTimeInMilliseconds() + TIME_TO_CRUSH_CAR;
+					DMAudio.PlayOneShot(CGarages::AudioEntity, SOUND_GARAGE_DOOR_CLOSED, 1.0f);
+				}
+			}
+			else
+				m_eGarageState = GS_OPENING;
+			UpdateCrusherAngle();
+			break;
+		case GS_AFTERDROPOFF:
+			if (CTimer::GetTimeInMilliseconds() <= m_nTimeToStartAction) {
+				UpdateCrusherShake((myrand() & 0xFF - 128) * 0.0002f, (myrand() & 0xFF - 128) * 0.0002f);
+			}
+			else {
+				UpdateCrusherShake(0.0f, 0.0f);
+				m_eGarageState = GS_OPENING;
+			}
+			break;
+		case GS_OPENING:
+			m_fDoorPos = min(HALFPI, m_fDoorPos + CTimer::GetTimeStep() * CRUSHER_CRANE_SPEED);
+			if (m_fDoorPos == HALFPI) {
+				m_eGarageState = GS_OPENED;
+				DMAudio.PlayOneShot(CGarages::AudioEntity, SOUND_GARAGE_DOOR_OPENED, 1.0f);
+			}
+			UpdateCrusherAngle();
+			break;
+		//case GS_FULLYCLOSED:
+		//case GS_CLOSEDCONTAINSCAR:
+		//case GS_OPENEDCONTAINSCAR:
+		default:
+			break;
+		}
+		if (!FindPlayerVehicle() && (CTimer::GetFrameCounter() & 0x1F) == 0x17 && IsEntityEntirelyInside(FindPlayerPed()))
+			FindPlayerPed()->InflictDamage(nil, WEAPONTYPE_RAMMEDBYCAR, 300.0f, PEDPIECE_TORSO, 0);
+		break;
+	case GARAGE_MISSION_KEEPCAR:
+	case GARAGE_MISSION_KEEPCAR_REMAINCLOSED:
+		switch (m_eGarageState) {
+		case GS_OPENED:
+			if (((CVector2D)FindPlayerCoors() - CVector2D(GetGarageCenterX(), GetGarageCenterY())).MagnitudeSqr() > SQR(DISTANCE_TO_CLOSE_MISSION_GARAGE) &&
+				!IsAnyOtherCarTouchingGarage(nil)) {
+				m_eGarageState = GS_CLOSING;
+				m_bClosingWithoutTargetCar = true;
+			}
+			else if (m_pTarget && m_pTarget == FindPlayerVehicle() && IsStaticPlayerCarEntirelyInside() && !IsAnyCarBlockingDoor()) {
+				CPad::GetPad(0)->SetDisablePlayerControls(PLAYERCONTROL_GARAGE);
+				FindPlayerPed()->m_pWanted->m_bIgnoredByCops = true;
+				m_eGarageState = GS_CLOSING;
+				m_bClosingWithoutTargetCar = false;
+			}
+			break;
+		case GS_CLOSING:
+			m_fDoorPos = max(0.0f, m_fDoorPos - (m_bRotatedDoor ? ROTATED_DOOR_CLOSE_SPEED : DEFAULT_DOOR_CLOSE_SPEED) * CTimer::GetTimeStep());
+			if (m_fDoorPos == 0.0f) {
+				DMAudio.PlayOneShot(CGarages::AudioEntity, SOUND_GARAGE_DOOR_CLOSED, 1.0f);
+				if (m_bClosingWithoutTargetCar)
+					m_eGarageState = GS_FULLYCLOSED;
+				else {
+					if (m_pTarget) {
+						m_eGarageState = GS_CLOSEDCONTAINSCAR;
+						m_nTimeToStartAction = CTimer::GetTimeInMilliseconds() + TIME_TO_PROCESS_KEEPCAR_GARAGE;
+						m_pTarget = nil;
+					}
+					else
+						m_eGarageState = GS_FULLYCLOSED;
+					CPad::GetPad(0)->SetEnablePlayerControls(PLAYERCONTROL_GARAGE);
+					FindPlayerPed()->m_pWanted->m_bIgnoredByCops = false;
+				}
+			}
+			UpdateDoorsHeight();
+			break;
+		case GS_FULLYCLOSED:
+			if (FindPlayerVehicle() == m_pTarget && m_pTarget &&
+				CalcDistToGarageRectangleSquared(
+					FindPlayerVehicle()->GetPosition().x,
+					FindPlayerVehicle()->GetPosition().y
+					) < SQR(DISTANCE_TO_ACTIVATE_KEEPCAR_GARAGE))
+				m_eGarageState = GS_OPENING;
+			break;
+		case GS_OPENING:
+			m_fDoorPos = min(m_fDoorHeight, m_fDoorPos + (m_bRotatedDoor ? ROTATED_DOOR_OPEN_SPEED : DEFAULT_DOOR_OPEN_SPEED) * CTimer::GetTimeStep());
+			if (m_fDoorPos == m_fDoorHeight) {
+				m_eGarageState = GS_OPENED;
+				DMAudio.PlayOneShot(CGarages::AudioEntity, SOUND_GARAGE_DOOR_OPENED, 1.0f);
+			}
+			UpdateDoorsHeight();
+			break;
+		case GS_CLOSEDCONTAINSCAR:
+			if (m_eGarageType == GARAGE_MISSION_KEEPCAR && CTimer::GetTimeInMilliseconds() > m_nTimeToStartAction)
+				m_eGarageState = GS_OPENING;
+			break;
+		//case GS_OPENEDCONTAINSCAR:
+		//case GS_AFTERDROPOFF:
+		default:
+			break;
+		}
+		break;
+	case GARAGE_FOR_SCRIPT_TO_OPEN:
+		switch (m_eGarageState) {
+		case GS_OPENING:
+			m_fDoorPos = min(m_fDoorHeight, m_fDoorPos + (m_bRotatedDoor ? ROTATED_DOOR_OPEN_SPEED : DEFAULT_DOOR_OPEN_SPEED) * CTimer::GetTimeStep());
+			if (m_fDoorPos == m_fDoorHeight) {
+				m_eGarageState = GS_OPENED;
+				DMAudio.PlayOneShot(CGarages::AudioEntity, SOUND_GARAGE_DOOR_OPENED, 1.0f);
+			}
+			UpdateDoorsHeight();
+			break;
+		//case GS_OPENED:
+		//case GS_CLOSING:
+		//case GS_FULLYCLOSED:
+		//case GS_OPENEDCONTAINSCAR:
+		//case GS_CLOSEDCONTAINSCAR:
+		//case GS_AFTERDROPOFF:
+		default:
+			break;
+		}
+		break;
+	case GARAGE_FOR_SCRIPT_TO_OPEN_AND_CLOSE:
+		switch (m_eGarageState) {
+		case GS_CLOSING:
+			m_fDoorPos = max(0.0f, m_fDoorPos - (m_bRotatedDoor ? ROTATED_DOOR_CLOSE_SPEED : DEFAULT_DOOR_CLOSE_SPEED) * CTimer::GetTimeStep());
+			if (m_fDoorPos == 0.0f) {
+				m_eGarageState = GS_FULLYCLOSED;
+				DMAudio.PlayOneShot(CGarages::AudioEntity, SOUND_GARAGE_DOOR_CLOSED, 1.0f);
+			}
+			UpdateDoorsHeight();
+			break;
+		case GS_OPENING:
+			m_fDoorPos = min(m_fDoorHeight, m_fDoorPos + (m_bRotatedDoor ? ROTATED_DOOR_OPEN_SPEED : DEFAULT_DOOR_OPEN_SPEED) * CTimer::GetTimeStep());
+			if (m_fDoorPos == m_fDoorHeight) {
+				m_eGarageState = GS_OPENED;
+				DMAudio.PlayOneShot(CGarages::AudioEntity, SOUND_GARAGE_DOOR_OPENED, 1.0f);
+			}
+			UpdateDoorsHeight();
+			break;
+		//case GS_OPENED:
+		//case GS_FULLYCLOSED:
+		//case GS_OPENEDCONTAINSCAR:
+		//case GS_CLOSEDCONTAINSCAR:
+		//case GS_AFTERDROPOFF:
+		default:
+			break;
+		}
+		break;
+	case GARAGE_HIDEOUT_ONE:
+	case GARAGE_HIDEOUT_TWO:
+	case GARAGE_HIDEOUT_THREE:
+		switch (m_eGarageState) {
+		case GS_OPENED:
+		{
+			float distance = CalcDistToGarageRectangleSquared(FindPlayerCoors().x, FindPlayerCoors().y);
+			// Close car doors either if player is far, or if he is in vehicle and garage is full,
+			// or if player is very very far so that we can remove whatever is blocking garage door without him noticing
+			if ((distance > SQR(DISTANCE_TO_CLOSE_HIDEOUT_GARAGE_IN_CAR) ||
+				!FindPlayerVehicle() && distance > SQR(DISTANCE_TO_CLOSE_HIDEOUT_GARAGE_ON_FOOT) &&
+				!IsAnyCarBlockingDoor()))
+				m_eGarageState = GS_CLOSING;
+			else if (FindPlayerVehicle() &&
+				CountCarsWithCenterPointWithinGarage(FindPlayerVehicle()) >=
+				CGarages::FindMaxNumStoredCarsForGarage(m_eGarageType)) {
+				m_eGarageState = GS_CLOSING;
+			}
+			else if (distance > SQR(DISTANCE_TO_FORCE_CLOSE_HIDEOUT_GARAGE)) {
+				m_eGarageState = GS_CLOSING;
+				RemoveCarsBlockingDoorNotInside();
+			}
+			break;
+		}
+		case GS_CLOSING:
+			m_fDoorPos = max(0.0f, m_fDoorPos - HIDEOUT_DOOR_SPEED_COEFFICIENT * (m_bRotatedDoor ? ROTATED_DOOR_CLOSE_SPEED : DEFAULT_DOOR_CLOSE_SPEED) * CTimer::GetTimeStep());
+			if (!IsPlayerOutsideGarage())
+				m_eGarageState = GS_OPENING;
+			else if (m_fDoorPos == 0.0f) {
+				DMAudio.PlayOneShot(CGarages::AudioEntity, SOUND_GARAGE_DOOR_CLOSED, 1.0f);
+				m_eGarageState = GS_FULLYCLOSED;
+				switch (m_eGarageType) {
+				case GARAGE_HIDEOUT_ONE:   StoreAndRemoveCarsForThisHideout(CGarages::aCarsInSafeHouse1, MAX_STORED_CARS_IN_INDUSTRIAL); break;
+				case GARAGE_HIDEOUT_TWO:   StoreAndRemoveCarsForThisHideout(CGarages::aCarsInSafeHouse2, MAX_STORED_CARS_IN_COMMERCIAL); break;
+				case GARAGE_HIDEOUT_THREE: StoreAndRemoveCarsForThisHideout(CGarages::aCarsInSafeHouse3, MAX_STORED_CARS_IN_SUBURBAN);   break;
+				}
+			}
+			UpdateDoorsHeight();
+			break;
+		case GS_FULLYCLOSED:
+		{
+			float distance = CalcDistToGarageRectangleSquared(FindPlayerCoors().x, FindPlayerCoors().y);
+			if (distance < SQR(DISTANCE_TO_OPEN_HIDEOUT_GARAGE_ON_FOOT) ||
+				distance < SQR(DISTANCE_TO_OPEN_HIDEOUT_GARAGE_IN_CAR) && FindPlayerVehicle()) {
+				if (FindPlayerVehicle() && CGarages::CountCarsInHideoutGarage(m_eGarageType) >= CGarages::FindMaxNumStoredCarsForGarage(m_eGarageType)) {
+					if (m_pDoor1) {
+						if (((CVector2D)FindPlayerVehicle()->GetPosition() - (CVector2D)m_pDoor1->GetPosition()).MagnitudeSqr() < SQR(DISTANCE_TO_SHOW_HIDEOUT_MESSAGE) &&
+							CTimer::GetTimeInMilliseconds() - CGarages::LastTimeHelpMessage > TIME_BETWEEN_HIDEOUT_MESSAGES) {
+							CHud::SetHelpMessage(TheText.Get("GA_21"), false); // You cannot store any more cars in this garage.
+							CGarages::LastTimeHelpMessage = CTimer::GetTimeInMilliseconds();
+						}
+					}
+				}
+				else {
+#ifdef FIX_BUGS
+					bool bCreatedAllCars = false;
+#else
+					bool bCraetedAllCars;
+#endif
+					switch (m_eGarageType) {
+					case GARAGE_HIDEOUT_ONE:   bCreatedAllCars = RestoreCarsForThisHideout(CGarages::aCarsInSafeHouse1); break;
+					case GARAGE_HIDEOUT_TWO:   bCreatedAllCars = RestoreCarsForThisHideout(CGarages::aCarsInSafeHouse2); break;
+					case GARAGE_HIDEOUT_THREE: bCreatedAllCars = RestoreCarsForThisHideout(CGarages::aCarsInSafeHouse3); break;
+					}
+					if (bCreatedAllCars)
+						m_eGarageState = GS_OPENING;
+				}
+			}
+			break;
+		}
+		case GS_OPENING:
+			m_fDoorPos = min(m_fDoorHeight, m_fDoorPos + HIDEOUT_DOOR_SPEED_COEFFICIENT * (m_bRotatedDoor ? ROTATED_DOOR_OPEN_SPEED : DEFAULT_DOOR_OPEN_SPEED) * CTimer::GetTimeStep());
+			if (m_fDoorPos == m_fDoorHeight) {
+				m_eGarageState = GS_OPENED;
+				DMAudio.PlayOneShot(CGarages::AudioEntity, SOUND_GARAGE_DOOR_OPENED, 1.0f);
+			}
+			UpdateDoorsHeight();
+			break;
+		//case GS_OPENEDCONTAINSCAR:
+		//case GS_CLOSEDCONTAINSCAR:
+		//case GS_AFTERDROPOFF:
+		default:
+			break;
+		}
+		break;
+	case GARAGE_KEEPS_OPENING_FOR_SPECIFIC_CAR:
+		switch (m_eGarageState) {
+		case GS_OPENED:
+			if (((CVector2D)FindPlayerCoors() - CVector2D(GetGarageCenterX(), GetGarageCenterY())).MagnitudeSqr() > SQR(DISTANCE_TO_CLOSE_MISSION_GARAGE)) {
+				if (m_pTarget && IsEntityEntirelyOutside(m_pTarget, 0.0f) && !IsAnyOtherCarTouchingGarage(nil)) {
+					m_eGarageState = GS_CLOSING;
+					m_bClosingWithoutTargetCar = true;
+				}
+			}
+			break;
+		case GS_CLOSING:
+			m_fDoorPos = max(0.0f, m_fDoorPos - (m_bRotatedDoor ? ROTATED_DOOR_CLOSE_SPEED : DEFAULT_DOOR_CLOSE_SPEED) * CTimer::GetTimeStep());
+			if (m_fDoorPos == 0.0f) {
+				m_eGarageState = GS_FULLYCLOSED;
+				DMAudio.PlayOneShot(CGarages::AudioEntity, SOUND_GARAGE_DOOR_CLOSED, 1.0f);
+			}
+			UpdateDoorsHeight();
+			break;
+		case GS_FULLYCLOSED:
+			if (FindPlayerVehicle() == m_pTarget && m_pTarget &&
+				CalcDistToGarageRectangleSquared(
+					FindPlayerVehicle()->GetPosition().x,
+					FindPlayerVehicle()->GetPosition().y
+					) < SQR(DISTANCE_TO_ACTIVATE_GARAGE))
+				m_eGarageState = GS_OPENING;
+			break;
+		case GS_OPENING:
+			m_fDoorPos = min(m_fDoorHeight, m_fDoorPos + (m_bRotatedDoor ? ROTATED_DOOR_OPEN_SPEED : DEFAULT_DOOR_OPEN_SPEED) * CTimer::GetTimeStep());
+			if (m_fDoorPos == m_fDoorHeight) {
+				m_eGarageState = GS_OPENED;
+				DMAudio.PlayOneShot(CGarages::AudioEntity, SOUND_GARAGE_DOOR_OPENED, 1.0f);
+			}
+			UpdateDoorsHeight();
+			break;
+		//case GS_OPENEDCONTAINSCAR:
+		//case GS_CLOSEDCONTAINSCAR:
+		//case GS_AFTERDROPOFF:
+		default:
+			break;
+		}
+		break;
+		//case GARAGE_COLLECTORSITEMS:
+		//case GARAGE_60SECONDS:
+	default:
+		break;
+	}
+}
+
+bool CGarage::IsStaticPlayerCarEntirelyInside()
+{
+	if (!FindPlayerVehicle())
+		return false;
+	if (!FindPlayerVehicle()->IsCar())
+		return false;
+	if (FindPlayerPed()->GetPedState() != PED_DRIVING)
+		return false;
+	if (FindPlayerPed()->m_objective == OBJECTIVE_LEAVE_VEHICLE)
+		return false;
+	CVehicle* pVehicle = FindPlayerVehicle();
+	if (pVehicle->GetPosition().x < m_fX1 || pVehicle->GetPosition().x > m_fX2 ||
+		pVehicle->GetPosition().y < m_fY1 || pVehicle->GetPosition().y > m_fY2)
+		return false;
+	if (Abs(pVehicle->GetSpeed().x) > 0.01f ||
+		Abs(pVehicle->GetSpeed().y) > 0.01f ||
+		Abs(pVehicle->GetSpeed().z) > 0.01f)
+		return false;
+	if (pVehicle->GetSpeed().MagnitudeSqr() > SQR(0.01f))
+		return false;
+	return IsEntityEntirelyInside3D(pVehicle, 0.0f);
 }
 
-WRAPPER bool CGarages::HasThisCarBeenCollected(int16 garage, uint8 id) { EAXJMP(0x426D50); }
-WRAPPER void CGarages::ChangeGarageType(int16 garage, eGarageType type, int32 mi) { EAXJMP(0x4222A0); }
-WRAPPER bool CGarages::HasResprayHappened(int16 garage) { EAXJMP(0x4274F0); }
-WRAPPER bool CGarages::IsThisCarWithinGarageArea(int16 garage, CEntity* pCar) { EAXJMP(0x427570); }
+bool CGarage::IsEntityEntirelyInside(CEntity * pEntity)
+{
+	if (pEntity->GetPosition().x < m_fX1 || pEntity->GetPosition().x > m_fX2 ||
+		pEntity->GetPosition().y < m_fY1 || pEntity->GetPosition().y > m_fY2)
+		return false;
+	CColModel* pColModel = CModelInfo::GetModelInfo(pEntity->GetModelIndex())->GetColModel();
+	for (int i = 0; i < pColModel->numSpheres; i++) {
+		CVector pos = pEntity->GetMatrix() * pColModel->spheres[i].center;
+		float radius = pColModel->spheres[i].radius;
+		if (pos.x - radius < m_fX1 || pos.x + radius > m_fX2 ||
+			pos.y - radius < m_fY1 || pos.y + radius > m_fY2)
+			return false;
+	}
+	return true;
+}
 
-void CGarage::OpenThisGarage()
+bool CGarage::IsEntityEntirelyInside3D(CEntity * pEntity, float fMargin)
 {
-	if (m_eGarageState == GS_FULLYCLOSED || m_eGarageState == GS_CLOSING || m_eGarageState == GS_CLOSEDCONTAINSCAR)
-		m_eGarageState = GS_OPENING;
+	if (pEntity->GetPosition().x < m_fX1 - fMargin || pEntity->GetPosition().x > m_fX2 + fMargin ||
+		pEntity->GetPosition().y < m_fY1 - fMargin || pEntity->GetPosition().y > m_fY2 + fMargin ||
+		pEntity->GetPosition().z < m_fZ1 - fMargin || pEntity->GetPosition().z > m_fZ2 + fMargin)
+		return false;
+	CColModel* pColModel = CModelInfo::GetModelInfo(pEntity->GetModelIndex())->GetColModel();
+	for (int i = 0; i < pColModel->numSpheres; i++) {
+		CVector pos = pEntity->GetMatrix() * pColModel->spheres[i].center;
+		float radius = pColModel->spheres[i].radius;
+		if (pos.x + radius < m_fX1 - fMargin || pos.x - radius > m_fX2 + fMargin ||
+			pos.y + radius < m_fY1 - fMargin || pos.y - radius > m_fY2 + fMargin ||
+			pos.z + radius < m_fZ1 - fMargin || pos.z - radius > m_fZ2 + fMargin)
+			return false;
+	}
+	return true;
 }
 
-bool CGarages::IsGarageOpen(int16 garage)
+bool CGarage::IsEntityEntirelyOutside(CEntity * pEntity, float fMargin)
 {
-	return Garages[garage].IsOpen();
+	if (pEntity->GetPosition().x > m_fX1 - fMargin && pEntity->GetPosition().x < m_fX2 + fMargin &&
+		pEntity->GetPosition().y > m_fY1 - fMargin && pEntity->GetPosition().y < m_fY2 + fMargin)
+		return false;
+	CColModel* pColModel = CModelInfo::GetModelInfo(pEntity->GetModelIndex())->GetColModel();
+	for (int i = 0; i < pColModel->numSpheres; i++) {
+		CVector pos = pEntity->GetMatrix() * pColModel->spheres[i].center;
+		float radius = pColModel->spheres[i].radius;
+		if (pos.x + radius > m_fX1 - fMargin && pos.x - radius < m_fX2 + fMargin &&
+			pos.y + radius > m_fY1 - fMargin && pos.y - radius < m_fY2 + fMargin)
+			return false;
+	}
+	return true;
 }
 
-bool CGarages::IsGarageClosed(int16 garage)
+bool CGarage::IsGarageEmpty()
 {
-	return Garages[garage].IsClosed();
+	int16 num;
+	CWorld::FindObjectsIntersectingCube(CVector(m_fX1, m_fY1, m_fZ1), CVector(m_fX2, m_fY2, m_fZ2), &num, 2, nil, false, true, true, false, false);
+	return num == 0;
 }
 
-void CGarage::CloseThisGarage()
+bool CGarage::IsPlayerOutsideGarage()
 {
-	if (m_eGarageState == GS_OPENED || m_eGarageState == GS_OPENING)
-		m_eGarageState = GS_CLOSING;
+	if (FindPlayerVehicle())
+		return IsEntityEntirelyOutside(FindPlayerVehicle(), 0.0f);
+	return IsEntityEntirelyOutside(FindPlayerPed(), 0.0f);
 }
 
-void CGarages::SetGarageDoorToRotate(int16 garage)
+bool CGarage::IsEntityTouching3D(CEntity * pEntity)
 {
-	if (Garages[garage].m_bRotatedDoor)
-		return;
-	Garages[garage].m_bRotatedDoor = true;
-	Garages[garage].m_fDoorHeight /= 2.0f;
-	Garages[garage].m_fDoorHeight -= 0.1f;
+	float radius = pEntity->GetBoundRadius();
+	if (pEntity->GetPosition().x - radius < m_fX1 || pEntity->GetPosition().x + radius > m_fX2 ||
+		pEntity->GetPosition().y - radius < m_fY1 || pEntity->GetPosition().y + radius > m_fY2 ||
+		pEntity->GetPosition().z - radius < m_fZ1 || pEntity->GetPosition().z + radius > m_fZ2)
+		return false;
+	CColModel* pColModel = CModelInfo::GetModelInfo(pEntity->GetModelIndex())->GetColModel();
+	for (int i = 0; i < pColModel->numSpheres; i++) {
+		CVector pos = pEntity->GetMatrix() * pColModel->spheres[i].center;
+		radius = pColModel->spheres[i].radius;
+		if (pos.x + radius > m_fX1 && pos.x - radius < m_fX2 &&
+			pos.y + radius > m_fY1 && pos.y - radius < m_fY2 &&
+			pos.z + radius > m_fZ1 && pos.z - radius < m_fZ2)
+			return false;
+	}
+	return true;
 }
 
-bool CGarages::HasImportExportGarageCollectedThisCar(int16 garage, int8 car)
+bool CGarage::EntityHasASphereWayOutsideGarage(CEntity * pEntity, float fMargin)
 {
-	return CarTypesCollected[GetCarsCollectedIndexForGarageType(Garages[garage].m_eGarageType)] & (1 << car);
+	CColModel* pColModel = CModelInfo::GetModelInfo(pEntity->GetModelIndex())->GetColModel();
+	for (int i = 0; i < pColModel->numSpheres; i++) {
+		CVector pos = pEntity->GetMatrix() * pColModel->spheres[i].center;
+		float radius = pColModel->spheres[i].radius;
+		if (pos.x + radius + fMargin < m_fX1 || pos.x - radius - fMargin > m_fX2 ||
+			pos.y + radius + fMargin < m_fY1 || pos.y - radius - fMargin > m_fY2 ||
+			pos.z + radius + fMargin < m_fZ1 || pos.z - radius - fMargin > m_fZ2)
+			return true;
+	}
+	return false;
 }
 
-void CGarages::SetLeaveCameraForThisGarage(int16 garage)
+bool CGarage::IsAnyOtherCarTouchingGarage(CVehicle * pException)
 {
-	Garages[garage].m_bCameraFollowsPlayer = true;
+	uint32 i = CPools::GetVehiclePool()->GetSize();
+	while (i--) {
+		CVehicle* pVehicle = CPools::GetVehiclePool()->GetSlot(i);
+		if (!pVehicle || pVehicle == pException)
+			continue;
+		if (!IsEntityTouching3D(pVehicle))
+			continue;
+		CColModel* pColModel = CModelInfo::GetModelInfo(pVehicle->GetModelIndex())->GetColModel();
+		for (int i = 0; i < pColModel->numSpheres; i++) {
+			CVector pos = pVehicle->GetMatrix() * pColModel->spheres[i].center;
+			float radius = pColModel->spheres[i].radius;
+			if (pos.x + radius > m_fX1 && pos.x - radius < m_fX2 &&
+				pos.y + radius > m_fY1 && pos.y - radius < m_fY2 &&
+				pos.z + radius > m_fZ1 && pos.z - radius < m_fZ2)
+				return true;
+		}
+	}
+	return false;
+}
+
+bool CGarage::IsAnyOtherPedTouchingGarage(CPed * pException)
+{
+	uint32 i = CPools::GetPedPool()->GetSize();
+	while (i--) {
+		CPed* pPed = CPools::GetPedPool()->GetSlot(i);
+		if (!pPed || pPed == pException)
+			continue;
+		if (!IsEntityTouching3D(pPed))
+			continue;
+		CColModel* pColModel = CModelInfo::GetModelInfo(pPed->GetModelIndex())->GetColModel();
+		for (int i = 0; i < pColModel->numSpheres; i++) {
+			CVector pos = pPed->GetMatrix() * pColModel->spheres[i].center;
+			float radius = pColModel->spheres[i].radius;
+			if (pos.x + radius > m_fX1 && pos.x - radius < m_fX2 &&
+				pos.y + radius > m_fY1 && pos.y - radius < m_fY2 &&
+				pos.z + radius > m_fZ1 && pos.z - radius < m_fZ2)
+				return true;
+		}
+	}
+	return false;
+}
+
+bool CGarage::IsAnyCarBlockingDoor()
+{
+	uint32 i = CPools::GetVehiclePool()->GetSize();
+	while (i--) {
+		CVehicle* pVehicle = CPools::GetVehiclePool()->GetSlot(i);
+		if (!pVehicle)
+			continue;
+		if (!IsEntityTouching3D(pVehicle))
+			continue;
+		CColModel* pColModel = CModelInfo::GetModelInfo(pVehicle->GetModelIndex())->GetColModel();
+		for (int i = 0; i < pColModel->numSpheres; i++) {
+			CVector pos = pVehicle->GetMatrix() * pColModel->spheres[i].center;
+			float radius = pColModel->spheres[i].radius;
+			if (pos.x + radius < m_fX1 || pos.x - radius > m_fX2 ||
+				pos.y + radius < m_fY1 || pos.y - radius > m_fY2 ||
+				pos.z + radius < m_fZ1 || pos.z - radius > m_fZ2)
+				return true;
+		}
+	}
+	return false;
+}
+
+int32 CGarage::CountCarsWithCenterPointWithinGarage(CEntity * pException)
+{
+	int32 total = 0;
+	uint32 i = CPools::GetVehiclePool()->GetSize();
+	while (i--) {
+		CVehicle* pVehicle = CPools::GetVehiclePool()->GetSlot(i);
+		if (!pVehicle || pVehicle == pException)
+			continue;
+		if (pVehicle->GetPosition().x > m_fX1 && pVehicle->GetPosition().x < m_fX2 &&
+			pVehicle->GetPosition().y > m_fY1 && pVehicle->GetPosition().y < m_fY2 &&
+			pVehicle->GetPosition().z > m_fZ1 && pVehicle->GetPosition().z < m_fZ2)
+			total++;
+	}
+	return total;
+}
+
+void CGarage::RemoveCarsBlockingDoorNotInside()
+{
+	uint32 i = CPools::GetVehiclePool()->GetSize();
+	while (i--) {
+		CVehicle* pVehicle = CPools::GetVehiclePool()->GetSlot(i);
+		if (!pVehicle)
+			continue;
+		if (!IsEntityTouching3D(pVehicle))
+			continue;
+		if (pVehicle->GetPosition().x < m_fX1 || pVehicle->GetPosition().x > m_fX2 ||
+			pVehicle->GetPosition().y < m_fY1 || pVehicle->GetPosition().y > m_fY2 ||
+			pVehicle->GetPosition().z < m_fZ1 || pVehicle->GetPosition().z > m_fZ2) {
+			if (pVehicle->bIsLocked && pVehicle->CanBeDeleted()) {
+				CWorld::Remove(pVehicle);
+				delete pVehicle;
+				return; // WHY?
+			}
+		}
+	}
 }
 
-#if 0
-WRAPPER void CGarages::PrintMessages(void) { EAXJMP(0x426310); }
-#else
 void CGarages::PrintMessages()
 {
 	if (CTimer::GetTimeInMilliseconds() > MessageStartTime && CTimer::GetTimeInMilliseconds() < MessageEndTime) {
@@ -159,8 +1391,11 @@ void CGarages::PrintMessages()
 		CFont::SetFontStyle(FONT_BANK);
 		CFont::SetColor(CRGBA(0, 0, 0, 255));
 
+#if defined(PS2) || defined (FIX_BUGS)
 		float y_offset = SCREEN_HEIGHT / 3; // THIS is PS2 calculation
-		// y_offset = SCREEN_HEIGHT / 2 - SCREEN_SCALE_Y(84.0f); // This is PC and results in text being written over some HUD elements
+#else
+		float y_offset = SCREEN_HEIGHT / 2 - SCREEN_SCALE_Y(84.0f); // This is PC and results in text being written over some HUD elements
+#endif
 
 		if (MessageNumberInString2 < 0) {
 			if (MessageNumberInString < 0) {
@@ -187,4 +1422,931 @@ void CGarages::PrintMessages()
 		}
 	}
 }
-#endif
\ No newline at end of file
+
+bool CGarages::IsCarSprayable(CVehicle * pVehicle)
+{
+	switch (pVehicle->GetModelIndex()) {
+	case MI_FIRETRUCK:
+	case MI_AMBULAN:
+	case MI_POLICE:
+	case MI_ENFORCER:
+	case MI_BUS:
+	case MI_RHINO:
+	case MI_BARRACKS:
+	case MI_DODO:
+	case MI_COACH:
+		return false;
+	default:
+		break;
+	}
+	return true;
+}
+
+void CGarage::UpdateDoorsHeight()
+{
+	RefreshDoorPointers(false);
+	if (m_pDoor1) {
+		m_pDoor1->GetPosition().z = m_fDoorPos + m_fDoor1Z;
+		if (m_bRotatedDoor)
+			BuildRotatedDoorMatrix(m_pDoor1, m_fDoorPos / m_fDoorHeight);
+		m_pDoor1->GetMatrix().UpdateRW();
+		m_pDoor1->UpdateRwFrame();
+	}
+	if (m_pDoor2) {
+		m_pDoor2->GetPosition().z = m_fDoorPos + m_fDoor2Z;
+		if (m_bRotatedDoor)
+			BuildRotatedDoorMatrix(m_pDoor2, m_fDoorPos / m_fDoorHeight);
+		m_pDoor2->GetMatrix().UpdateRW();
+		m_pDoor2->UpdateRwFrame();
+	}
+}
+
+void CGarage::BuildRotatedDoorMatrix(CEntity * pDoor, float fPosition)
+{
+	float fAngle = -fPosition * HALFPI;
+	CVector up(-Sin(fAngle) * pDoor->GetForward().y, Sin(fAngle) * pDoor->GetForward().z, Cos(fAngle));
+	pDoor->GetRight() = CrossProduct(up, pDoor->GetForward());
+	pDoor->GetUp() = up;
+}
+
+void CGarage::UpdateCrusherAngle()
+{
+	RefreshDoorPointers(false);
+	m_pDoor2->GetMatrix().SetRotateXOnly(TWOPI - m_fDoorPos);
+	m_pDoor2->GetMatrix().UpdateRW();
+	m_pDoor2->UpdateRwFrame();
+}
+
+void CGarage::UpdateCrusherShake(float X, float Y)
+{
+	RefreshDoorPointers(false);
+	m_pDoor1->GetPosition().x += X;
+	m_pDoor1->GetPosition().y += Y;
+	m_pDoor1->GetMatrix().UpdateRW();
+	m_pDoor1->UpdateRwFrame();
+	m_pDoor1->GetPosition().x -= X;
+	m_pDoor1->GetPosition().y -= Y;
+	m_pDoor2->GetPosition().x += X;
+	m_pDoor2->GetPosition().y += Y;
+	m_pDoor2->GetMatrix().UpdateRW();
+	m_pDoor2->UpdateRwFrame();
+	m_pDoor2->GetPosition().x -= X;
+	m_pDoor2->GetPosition().y -= Y;
+}
+
+// This is dumb but there is no way to avoid goto. What was there originally even?
+static bool DoINeedToRefreshPointer(CEntity * pDoor, bool bIsDummy, int8 nIndex)
+{
+	bool bNeedToFindDoorEntities = false;
+	if (pDoor) {
+		if (bIsDummy) {
+			if (CPools::GetDummyPool()->IsFreeSlot(CPools::GetDummyPool()->GetJustIndex((CDummy*)pDoor)))
+				return true;
+			if (nIndex != CPools::GetDummyPool()->GetIndex((CDummy*)pDoor))
+				bNeedToFindDoorEntities = true;
+			if (!CGarages::IsModelIndexADoor(pDoor->GetModelIndex()))
+				return true;
+		}
+		else {
+			if (CPools::GetObjectPool()->IsFreeSlot(CPools::GetObjectPool()->GetJustIndex((CObject*)pDoor)))
+				return true;
+			if (nIndex != CPools::GetObjectPool()->GetIndex((CObject*)pDoor))
+				bNeedToFindDoorEntities = true;
+			if (!CGarages::IsModelIndexADoor(pDoor->GetModelIndex()))
+				return true;
+		}
+	}
+	return bNeedToFindDoorEntities;
+}
+
+void CGarage::RefreshDoorPointers(bool bCreate)
+{
+	bool bNeedToFindDoorEntities = true;
+	if (!bCreate && !m_bRecreateDoorOnNextRefresh)
+		bNeedToFindDoorEntities = false;
+	m_bRecreateDoorOnNextRefresh = false;
+	if (DoINeedToRefreshPointer(m_pDoor1, m_bDoor1IsDummy, m_bDoor1PoolIndex))
+		bNeedToFindDoorEntities = true;
+	if (DoINeedToRefreshPointer(m_pDoor2, m_bDoor2IsDummy, m_bDoor2PoolIndex))
+		bNeedToFindDoorEntities = true;
+	if (bNeedToFindDoorEntities)
+		FindDoorsEntities();
+}
+
+void CGarages::TriggerMessage(const char* text, int16 num1, uint16 time, int16 num2)
+{
+	if (strcmp(text, MessageIDString) == 0 &&
+		CTimer::GetTimeInMilliseconds() >= MessageStartTime &&
+		CTimer::GetTimeInMilliseconds() <= MessageEndTime) {
+		if (CTimer::GetTimeInMilliseconds() - MessageStartTime <= 500)
+			return;
+		MessageStartTime = CTimer::GetTimeInMilliseconds() - 500;
+		MessageEndTime = CTimer::GetTimeInMilliseconds() - 500 + time;
+	}
+	else {
+		strcpy(MessageIDString, text);
+		MessageStartTime = CTimer::GetTimeInMilliseconds();
+		MessageEndTime = CTimer::GetTimeInMilliseconds() + time;
+	}
+	MessageNumberInString = num1;
+	MessageNumberInString2 = num2;
+}
+
+void CGarages::SetTargetCarForMissonGarage(int16 garage, CVehicle * pVehicle)
+{
+	assert(garage >= 0 && garage < NUM_GARAGES);
+	if (pVehicle) {
+		aGarages[garage].m_pTarget = pVehicle;
+		if (aGarages[garage].m_eGarageState == GS_CLOSEDCONTAINSCAR)
+			aGarages[garage].m_eGarageState = GS_FULLYCLOSED;
+	}
+	else
+		aGarages[garage].m_pTarget = nil;
+}
+
+bool CGarages::HasCarBeenDroppedOffYet(int16 garage)
+{
+	return aGarages[garage].m_eGarageState == GS_CLOSEDCONTAINSCAR;
+}
+
+void CGarages::DeActivateGarage(int16 garage)
+{
+	aGarages[garage].m_bDeactivated = true;
+}
+
+void CGarages::ActivateGarage(int16 garage)
+{
+	aGarages[garage].m_bDeactivated = false;
+	if (aGarages[garage].m_eGarageType == GARAGE_FORCARTOCOMEOUTOF && aGarages[garage].m_eGarageState == GS_FULLYCLOSED)
+		aGarages[garage].m_eGarageState = GS_OPENING;
+}
+
+int32 CGarages::QueryCarsCollected(int16 garage)
+{
+	return 0;
+}
+
+bool CGarages::HasImportExportGarageCollectedThisCar(int16 garage, int8 car)
+{
+	return CarTypesCollected[GetCarsCollectedIndexForGarageType(aGarages[garage].m_eGarageType)] & (BIT(car));
+}
+
+bool CGarages::IsGarageOpen(int16 garage)
+{
+	return aGarages[garage].IsOpen();
+}
+
+bool CGarages::IsGarageClosed(int16 garage)
+{
+	return aGarages[garage].IsClosed();
+}
+
+bool CGarages::HasThisCarBeenCollected(int16 garage, uint8 id)
+{
+	return aGarages[garage].m_bCollectedCarsState & BIT(id);
+}
+
+bool CGarage::DoesCraigNeedThisCar(int32 mi)
+{
+	if (mi == MI_CORPSE)
+		mi = MI_MANANA;
+	int ct = CGarages::GetCarsCollectedIndexForGarageType(m_eGarageType);
+	for (int i = 0; i < TOTAL_COLLECTCARS_CARS; i++) {
+		if (mi == gaCarsToCollectInCraigsGarages[ct][i])
+			return (CGarages::CarTypesCollected[ct] & BIT(i)) == 0;
+	}
+	return false;
+}
+
+bool CGarage::HasCraigCollectedThisCar(int32 mi)
+{
+	if (mi == MI_CORPSE)
+		mi = MI_MANANA;
+	int ct = CGarages::GetCarsCollectedIndexForGarageType(m_eGarageType);
+	for (int i = 0; i < TOTAL_COLLECTCARS_CARS; i++) {
+		if (mi == gaCarsToCollectInCraigsGarages[ct][i])
+			return CGarages::CarTypesCollected[ct] & BIT(i);
+	}
+	return false;
+}
+
+bool CGarage::MarkThisCarAsCollectedForCraig(int32 mi)
+{
+	if (mi == MI_CORPSE)
+		mi = MI_MANANA;
+	int ct = CGarages::GetCarsCollectedIndexForGarageType(m_eGarageType);
+	int index;
+	for (index = 0; index < TOTAL_COLLECTCARS_CARS; index++) {
+		if (mi == gaCarsToCollectInCraigsGarages[ct][index])
+			break;
+	}
+	if (index >= TOTAL_COLLECTCARS_CARS)
+		return false;
+	CGarages::CarTypesCollected[ct] |= BIT(index);
+	CWorld::Players[CWorld::PlayerInFocus].m_nMoney += IMPORT_REWARD;
+	for (int i = 0; i < TOTAL_COLLECTCARS_CARS; i++) {
+		if ((CGarages::CarTypesCollected[ct] & BIT(i)) == 0) {
+			CGarages::TriggerMessage("GA_13", -1, 5000, -1); // Delivered like a pro. Complete the list and there'll be a bonus for you.
+			return false;
+		}
+	}
+	CWorld::Players[CWorld::PlayerInFocus].m_nMoney += IMPORT_ALLCARS_REWARD;
+	CGarages::TriggerMessage("GA_14", -1, 5000, -1); // All the cars. NICE! Here's a little something.
+	return true;
+}
+
+void CGarage::OpenThisGarage()
+{
+	if (m_eGarageState == GS_FULLYCLOSED || m_eGarageState == GS_CLOSING || m_eGarageState == GS_CLOSEDCONTAINSCAR)
+		m_eGarageState = GS_OPENING;
+}
+
+void CGarage::CloseThisGarage()
+{
+	if (m_eGarageState == GS_OPENED || m_eGarageState == GS_OPENING)
+		m_eGarageState = GS_CLOSING;
+}
+
+float CGarage::CalcDistToGarageRectangleSquared(float X, float Y)
+{
+	float distX, distY;
+	if (X < m_fX1)
+		distX = m_fX1 - X;
+	else if (X > m_fX2)
+		distX = X - m_fX2;
+	else
+		distX = 0.0f;
+	if (Y < m_fY1)
+		distY = m_fY1 - X;
+	else if (Y > m_fY2)
+		distY = Y - m_fY2;
+	else
+		distY = 0.0f;
+	return SQR(distX) + SQR(distY);
+}
+
+float CGarage::CalcSmallestDistToGarageDoorSquared(float X, float Y)
+{
+	float dist1 = 10000000.0f;
+	float dist2 = 10000000.0f;
+	if (m_pDoor1)
+		dist1 = SQR(m_fDoor1X - X) + SQR(m_fDoor1Y - Y);
+	if (m_pDoor2)
+		dist2 = SQR(m_fDoor2X - X) + SQR(m_fDoor2Y - Y);
+	return min(dist1, dist2);
+}
+
+void CGarage::FindDoorsEntities()
+{
+	m_pDoor1 = false;
+	m_pDoor2 = false;
+	int xstart = max(0, CWorld::GetSectorIndexX(m_fX1));
+	int xend = min(NUMSECTORS_X - 1, CWorld::GetSectorIndexX(m_fX2));
+	int ystart = max(0, CWorld::GetSectorIndexY(m_fY1));
+	int yend = min(NUMSECTORS_Y - 1, CWorld::GetSectorIndexY(m_fY2));
+	assert(xstart <= xend);
+	assert(ystart <= yend);
+
+	CWorld::AdvanceCurrentScanCode();
+
+	for (int y = ystart; y <= yend; y++) {
+		for (int x = xstart; x <= xend; x++) {
+			CSector* s = CWorld::GetSector(x, y);
+			FindDoorsEntitiesSectorList(s->m_lists[ENTITYLIST_OBJECTS], false);
+			FindDoorsEntitiesSectorList(s->m_lists[ENTITYLIST_OBJECTS_OVERLAP], false);
+			FindDoorsEntitiesSectorList(s->m_lists[ENTITYLIST_DUMMIES], true);
+			FindDoorsEntitiesSectorList(s->m_lists[ENTITYLIST_DUMMIES_OVERLAP], true);
+		}
+	}
+	if (!m_pDoor1 || !m_pDoor2)
+		return;
+	if (m_pDoor1->GetModelIndex() == MI_CRUSHERBODY || m_pDoor1->GetModelIndex() == MI_CRUSHERLID)
+		return;
+	CVector2D vecDoor1ToGarage(m_pDoor1->GetPosition().x - GetGarageCenterX(), m_pDoor1->GetPosition().y - GetGarageCenterY());
+	CVector2D vecDoor2ToGarage(m_pDoor2->GetPosition().x - GetGarageCenterX(), m_pDoor2->GetPosition().y - GetGarageCenterY());
+	if (DotProduct2D(vecDoor1ToGarage, vecDoor2ToGarage) > 0.0f) {
+		if (vecDoor1ToGarage.MagnitudeSqr() >= vecDoor2ToGarage.MagnitudeSqr()) {
+			m_pDoor1 = m_pDoor2;
+			m_bDoor1IsDummy = m_bDoor2IsDummy;
+		}
+		m_pDoor2 = nil;
+		m_bDoor2IsDummy = false;
+	}
+}
+
+void CGarage::FindDoorsEntitiesSectorList(CPtrList& list, bool dummy)
+{
+	CPtrNode* node;
+	for (node = list.first; node; node = node->next) {
+		CEntity* pEntity = (CEntity*)node->item;
+		if (pEntity->m_scanCode == CWorld::GetCurrentScanCode())
+			continue;
+		pEntity->m_scanCode = CWorld::GetCurrentScanCode();
+		if (!pEntity || !CGarages::IsModelIndexADoor(pEntity->GetModelIndex()))
+			continue;
+		if (Abs(pEntity->GetPosition().x - GetGarageCenterX()) >= DISTANCE_TO_CONSIDER_DOOR_FOR_GARAGE)
+			continue;
+		if (Abs(pEntity->GetPosition().y - GetGarageCenterY()) >= DISTANCE_TO_CONSIDER_DOOR_FOR_GARAGE)
+			continue;
+		if (pEntity->GetModelIndex() == MI_CRUSHERBODY) {
+			m_pDoor1 = pEntity;
+			m_bDoor1IsDummy = dummy;
+			// very odd pool operations, they could have used GetJustIndex
+			if (dummy)
+				m_bDoor1PoolIndex = (CPools::GetDummyPool()->GetIndex((CDummy*)pEntity)) & 0x7F;
+			else
+				m_bDoor1PoolIndex = (CPools::GetObjectPool()->GetIndex((CObject*)pEntity)) & 0x7F;
+			continue;
+		}
+		if (pEntity->GetModelIndex() == MI_CRUSHERLID) {
+			m_pDoor2 = pEntity;
+			m_bDoor2IsDummy = dummy;
+			if (dummy)
+				m_bDoor2PoolIndex = (CPools::GetDummyPool()->GetIndex((CDummy*)pEntity)) & 0x7F;
+			else
+				m_bDoor2PoolIndex = (CPools::GetObjectPool()->GetIndex((CObject*)pEntity)) & 0x7F;
+			continue;
+		}
+		if (!m_pDoor1) {
+			m_pDoor1 = pEntity;
+			m_bDoor1IsDummy = dummy;
+			if (dummy)
+				m_bDoor1PoolIndex = (CPools::GetDummyPool()->GetIndex((CDummy*)pEntity)) & 0x7F;
+			else
+				m_bDoor1PoolIndex = (CPools::GetObjectPool()->GetIndex((CObject*)pEntity)) & 0x7F;
+			continue;
+		}
+		else {
+			m_pDoor2 = pEntity;
+			m_bDoor2IsDummy = dummy;
+			if (dummy)
+				m_bDoor2PoolIndex = (CPools::GetDummyPool()->GetIndex((CDummy*)pEntity)) & 0x7F;
+			else
+				m_bDoor2PoolIndex = (CPools::GetObjectPool()->GetIndex((CObject*)pEntity)) & 0x7F;
+		}
+	}
+}
+
+bool CGarages::HasResprayHappened(int16 garage)
+{
+	bool result = aGarages[garage].m_bResprayHappened;
+	aGarages[garage].m_bResprayHappened = false;
+	return result;
+}
+
+void CGarages::SetGarageDoorToRotate(int16 garage)
+{
+	if (aGarages[garage].m_bRotatedDoor)
+		return;
+	aGarages[garage].m_bRotatedDoor = true;
+	aGarages[garage].m_fDoorHeight /= 2.0f;
+	aGarages[garage].m_fDoorHeight -= 0.1f;
+}
+
+void CGarages::SetLeaveCameraForThisGarage(int16 garage)
+{
+	aGarages[garage].m_bCameraFollowsPlayer = true;
+}
+
+bool CGarages::IsThisCarWithinGarageArea(int16 garage, CEntity * pCar)
+{
+	return aGarages[garage].IsEntityEntirelyInside3D(pCar, 0.0f);
+}
+
+bool CGarages::HasCarBeenCrushed(int32 handle)
+{
+	return CrushedCarId == handle;
+}
+
+void CStoredCar::StoreCar(CVehicle* pVehicle)
+{
+	m_nModelIndex = pVehicle->GetModelIndex();
+	m_vecPos = pVehicle->GetPosition();
+	m_vecAngle = pVehicle->GetForward();
+	m_nPrimaryColor = pVehicle->m_currentColour1;
+	m_nSecondaryColor = pVehicle->m_currentColour2;
+	m_nRadioStation = pVehicle->m_nRadioStation;
+	m_nVariationA = pVehicle->m_aExtras[0];
+	m_nVariationB = pVehicle->m_aExtras[1];
+	m_bBulletproof = pVehicle->bBulletProof;
+	m_bFireproof = pVehicle->bFireProof;
+	m_bExplosionproof = pVehicle->bExplosionProof;
+	m_bCollisionproof = pVehicle->bCollisionProof;
+	m_bMeleeproof = pVehicle->bMeleeProof;
+	if (pVehicle->IsCar())
+		m_nCarBombType = ((CAutomobile*)pVehicle)->m_bombType;
+}
+
+CVehicle* CStoredCar::RestoreCar()
+{
+	CStreaming::RequestModel(m_nModelIndex, STREAMFLAGS_DEPENDENCY);
+	if (!CStreaming::HasModelLoaded(m_nModelIndex))
+		return nil;
+	CVehicleModelInfo::SetComponentsToUse(m_nVariationA, m_nVariationB);
+#ifdef FIX_BUGS
+	CVehicle* pVehicle;
+	if (CModelInfo::IsBoatModel(m_nModelIndex))
+		pVehicle = new CBoat(m_nModelIndex, RANDOM_VEHICLE);
+	else
+		pVehicle = new CAutomobile(m_nModelIndex, RANDOM_VEHICLE);
+#else
+	CVehicle* pVehicle = new CAutomobile(m_nModelIndex, RANDOM_VEHICLE);
+#endif
+	pVehicle->GetPosition() = m_vecPos;
+	pVehicle->m_status = STATUS_ABANDONED;
+	pVehicle->GetForward() = m_vecAngle;
+	pVehicle->GetRight() = CVector(m_vecAngle.y, -m_vecAngle.x, 0.0f);
+	pVehicle->GetUp() = CVector(0.0f, 0.0f, 1.0f);
+	pVehicle->pDriver = nil;
+	pVehicle->m_currentColour1 = m_nPrimaryColor;
+	pVehicle->m_currentColour2 = m_nSecondaryColor;
+	pVehicle->m_nRadioStation = m_nRadioStation;
+	pVehicle->bFreebies = false;
+#ifdef FIX_BUGS
+	((CAutomobile*)pVehicle)->m_bombType = m_nCarBombType;
+#endif
+	pVehicle->bHasBeenOwnedByPlayer = true;
+	pVehicle->m_nDoorLock = CARLOCK_UNLOCKED;
+	pVehicle->bBulletProof = m_bBulletproof;
+	pVehicle->bFireProof = m_bFireproof;
+	pVehicle->bExplosionProof = m_bExplosionproof;
+	pVehicle->bCollisionProof = m_bCollisionproof;
+	pVehicle->bMeleeProof = m_bMeleeproof;
+	return pVehicle;
+}
+
+void CGarage::StoreAndRemoveCarsForThisHideout(CStoredCar* aCars, int32 nMax)
+{
+	for (int i = 0; i < NUM_GARAGE_STORED_CARS; i++)
+		aCars[i].Clear();
+	int i = CPools::GetVehiclePool()->GetSize();
+	int index = 0;
+	while (i--) {
+		CVehicle* pVehicle = CPools::GetVehiclePool()->GetSlot(i);
+		if (!pVehicle)
+			continue;
+		if (pVehicle->GetPosition().x > m_fX1 && pVehicle->GetPosition().x < m_fX2 &&
+			pVehicle->GetPosition().y > m_fY1 && pVehicle->GetPosition().y < m_fY2 &&
+			pVehicle->GetPosition().z > m_fZ1 && pVehicle->GetPosition().z < m_fZ2) {
+			if (pVehicle->VehicleCreatedBy != MISSION_VEHICLE) {
+				if (index < max(NUM_GARAGE_STORED_CARS, nMax) && !EntityHasASphereWayOutsideGarage(pVehicle, 1.0f))
+					aCars[index++].StoreCar(pVehicle);
+				CWorld::Players[CWorld::PlayerInFocus].CancelPlayerEnteringCars(pVehicle);
+				CWorld::Remove(pVehicle);
+				delete pVehicle;
+			}
+		}
+	}
+	// why?
+	for (i = index; i < NUM_GARAGE_STORED_CARS; i++)
+		aCars[i].Clear();
+}
+
+bool CGarage::RestoreCarsForThisHideout(CStoredCar* aCars)
+{
+	for (int i = 0; i < NUM_GARAGE_STORED_CARS; i++) {
+		if (aCars[i].HasCar()) {
+			CVehicle* pVehicle = aCars[i].RestoreCar();
+			if (pVehicle) {
+				CWorld::Add(pVehicle);
+				aCars[i].Clear();
+			}
+		}
+	}
+	for (int i = 0; i < NUM_GARAGE_STORED_CARS; i++) {
+		if (aCars[i].HasCar())
+			return false;
+	}
+	return true;
+}
+
+bool CGarages::IsPointInAGarageCameraZone(CVector point)
+{
+	for (int i = 0; i < NUM_GARAGES; i++) {
+		switch (aGarages[i].m_eGarageType) {
+		case GARAGE_NONE:
+			break;
+		case GARAGE_COLLECTCARS_1:
+		case GARAGE_COLLECTCARS_2:
+		case GARAGE_COLLECTCARS_3:
+			if (aGarages[i].m_fX1 - MARGIN_FOR_CAMERA_COLLECTCARS <= point.x &&
+				aGarages[i].m_fX2 + MARGIN_FOR_CAMERA_COLLECTCARS >= point.x &&
+				aGarages[i].m_fY1 - MARGIN_FOR_CAMERA_COLLECTCARS <= point.y &&
+				aGarages[i].m_fY2 + MARGIN_FOR_CAMERA_COLLECTCARS >= point.y)
+				return true;
+			break;
+		default:
+			if (aGarages[i].m_fX1 - MARGIN_FOR_CAMERA_DEFAULT <= point.x &&
+				aGarages[i].m_fX2 + MARGIN_FOR_CAMERA_DEFAULT >= point.x &&
+				aGarages[i].m_fY1 - MARGIN_FOR_CAMERA_DEFAULT <= point.y &&
+				aGarages[i].m_fY2 + MARGIN_FOR_CAMERA_DEFAULT >= point.y)
+				return true;
+			break;
+		}
+	}
+	return false;
+}
+
+bool CGarages::CameraShouldBeOutside()
+{
+	return bCamShouldBeOutisde;
+}
+
+void CGarages::GivePlayerDetonator()
+{
+	FindPlayerPed()->GiveWeapon(WEAPONTYPE_DETONATOR, 1);
+	FindPlayerPed()->GetWeapon(FindPlayerPed()->GetWeaponSlot(WEAPONTYPE_DETONATOR)).m_eWeaponState = WEAPONSTATE_READY;
+}
+
+float CGarages::FindDoorHeightForMI(int32 mi)
+{
+	return CModelInfo::GetModelInfo(mi)->GetColModel()->boundingBox.max.z - CModelInfo::GetModelInfo(mi)->GetColModel()->boundingBox.min.z - 0.1f;
+}
+
+void CGarage::TidyUpGarage()
+{
+	uint32 i = CPools::GetVehiclePool()->GetSize();
+	while (i--) {
+		CVehicle* pVehicle = CPools::GetVehiclePool()->GetSlot(i);
+		if (!pVehicle || !pVehicle->IsCar())
+			continue;
+		if (pVehicle->GetPosition().x > m_fX1 && pVehicle->GetPosition().x < m_fX2 &&
+			pVehicle->GetPosition().y > m_fY1 && pVehicle->GetPosition().y < m_fY2 &&
+			pVehicle->GetPosition().z > m_fZ1 && pVehicle->GetPosition().z < m_fZ2) {
+			if (pVehicle->m_status == STATUS_WRECKED || pVehicle->GetUp().z < 0.5f) {
+				CWorld::Remove(pVehicle);
+				delete pVehicle;
+			}
+		}
+	}
+}
+
+void CGarage::TidyUpGarageClose()
+{
+	uint32 i = CPools::GetVehiclePool()->GetSize();
+	while (i--) {
+		CVehicle* pVehicle = CPools::GetVehiclePool()->GetSlot(i);
+		if (!pVehicle || !pVehicle->IsCar())
+			continue;
+		if (!pVehicle->IsCar() || pVehicle->m_status != STATUS_WRECKED || !IsEntityTouching3D(pVehicle))
+			continue;
+		bool bRemove = false;
+		if (m_eGarageState != GS_FULLYCLOSED) {
+			CColModel* pColModel = CModelInfo::GetModelInfo(pVehicle->GetModelIndex())->GetColModel();
+			for (int i = 0; i < pColModel->numSpheres; i++) {
+				CVector pos = pVehicle->GetMatrix() * pColModel->spheres[i].center;
+				float radius = pColModel->spheres[i].radius;
+				if (pos.x + radius < m_fX1 || pos.x - radius > m_fX2 ||
+					pos.y + radius < m_fY1 || pos.y - radius > m_fY2 ||
+					pos.z + radius < m_fZ1 || pos.z - radius > m_fZ2) {
+					bRemove = true;
+				}
+			}
+		}
+		else
+			bRemove = true;
+		if (bRemove) {
+			// no MISSION_VEHICLE check???
+			CWorld::Remove(pVehicle);
+			delete pVehicle;
+		}
+	}
+}
+
+void CGarages::PlayerArrestedOrDied()
+{
+	static int GarageToBeTidied = 0; // lol
+	for (int i = 0; i < NUM_GARAGES; i++) {
+		if (aGarages[i].m_eGarageType != GARAGE_NONE)
+			aGarages[i].PlayerArrestedOrDied();
+	}
+	MessageEndTime = 0;
+	MessageStartTime = 0;
+}
+
+void CGarage::PlayerArrestedOrDied()
+{
+	switch (m_eGarageType) {
+	case GARAGE_MISSION:
+	case GARAGE_COLLECTORSITEMS:
+	case GARAGE_COLLECTSPECIFICCARS:
+	case GARAGE_COLLECTCARS_1:
+	case GARAGE_COLLECTCARS_2:
+	case GARAGE_COLLECTCARS_3:
+	case GARAGE_FORCARTOCOMEOUTOF:
+	case GARAGE_60SECONDS:
+	case GARAGE_MISSION_KEEPCAR:
+	case GARAGE_FOR_SCRIPT_TO_OPEN:
+	case GARAGE_HIDEOUT_ONE:
+	case GARAGE_HIDEOUT_TWO:
+	case GARAGE_HIDEOUT_THREE:
+	case GARAGE_FOR_SCRIPT_TO_OPEN_AND_CLOSE:
+	case GARAGE_KEEPS_OPENING_FOR_SPECIFIC_CAR:
+	case GARAGE_MISSION_KEEPCAR_REMAINCLOSED:
+		switch (m_eGarageState) {
+		case GS_OPENED:
+		case GS_CLOSING:
+		case GS_OPENING:
+			m_eGarageState = GS_CLOSING;
+			break;
+		default:
+			break;
+		}
+		break;
+	case GARAGE_BOMBSHOP1:
+	case GARAGE_BOMBSHOP2:
+	case GARAGE_BOMBSHOP3:
+	case GARAGE_RESPRAY:
+	case GARAGE_CRUSHER:
+		switch (m_eGarageState) {
+		case GS_FULLYCLOSED:
+		case GS_CLOSING:
+		case GS_OPENING:
+			m_eGarageState = GS_OPENING;
+			break;
+		default:
+			break;
+		}
+		break;
+	default:
+		break;
+	}
+}
+
+void CGarage::CenterCarInGarage(CVehicle* pVehicle)
+{
+	if (IsAnyOtherCarTouchingGarage(FindPlayerVehicle()))
+		return;
+	if (IsAnyOtherPedTouchingGarage(FindPlayerPed()))
+		return;
+	CVector pos = pVehicle->GetPosition();
+	float garageX = GetGarageCenterX();
+	float garageY = GetGarageCenterY();
+	float offsetX = garageX - pos.x;
+	float offsetY = garageY - pos.y;
+	float offsetZ = pos.z - pos.z;
+	float distance = CVector(offsetX, offsetY, offsetZ).Magnitude();
+	if (distance < RESPRAY_CENTERING_COEFFICIENT) {
+		pVehicle->GetPosition().x = GetGarageCenterX();
+		pVehicle->GetPosition().y = GetGarageCenterY();
+	}
+	else {
+		pVehicle->GetPosition().x += offsetX * RESPRAY_CENTERING_COEFFICIENT / distance;
+		pVehicle->GetPosition().y += offsetY * RESPRAY_CENTERING_COEFFICIENT / distance;
+	}
+	if (!IsEntityEntirelyInside3D(pVehicle, 0.1f))
+		pVehicle->GetPosition() = pos;
+}
+
+void CGarages::CloseHideOutGaragesBeforeSave()
+{
+	for (int i = 0; i < NUM_GARAGES; i++) {
+		if (aGarages[i].m_eGarageType != GARAGE_HIDEOUT_ONE &&
+			aGarages[i].m_eGarageType != GARAGE_HIDEOUT_TWO &&
+			aGarages[i].m_eGarageType != GARAGE_HIDEOUT_THREE)
+			continue;
+		if (aGarages[i].m_eGarageState != GS_FULLYCLOSED &&
+			aGarages[i].m_eGarageType != GARAGE_HIDEOUT_ONE || !aGarages[i].IsAnyCarBlockingDoor()) {
+			aGarages[i].m_eGarageState = GS_FULLYCLOSED;
+			switch (aGarages[i].m_eGarageType) {
+			case GARAGE_HIDEOUT_ONE:
+				aGarages[i].StoreAndRemoveCarsForThisHideout(aCarsInSafeHouse1, NUM_GARAGE_STORED_CARS);
+				aGarages[i].RemoveCarsBlockingDoorNotInside();
+				break;
+			case GARAGE_HIDEOUT_TWO:
+				aGarages[i].StoreAndRemoveCarsForThisHideout(aCarsInSafeHouse2, NUM_GARAGE_STORED_CARS);
+				aGarages[i].RemoveCarsBlockingDoorNotInside();
+				break;
+			case GARAGE_HIDEOUT_THREE:
+				aGarages[i].StoreAndRemoveCarsForThisHideout(aCarsInSafeHouse3, NUM_GARAGE_STORED_CARS);
+				aGarages[i].RemoveCarsBlockingDoorNotInside();
+				break;
+			default:
+				break;
+			}
+		}
+		aGarages[i].m_fDoorPos = 0.0f;
+		aGarages[i].UpdateDoorsHeight();
+	}
+}
+
+int32 CGarages::CountCarsInHideoutGarage(eGarageType type)
+{
+	int32 total = 0;
+	for (int i = 0; i < NUM_GARAGE_STORED_CARS; i++) {
+		switch (type) {
+		case GARAGE_HIDEOUT_ONE:
+			total += (aCarsInSafeHouse1[i].HasCar());
+			break;
+		case GARAGE_HIDEOUT_TWO:
+			total += (aCarsInSafeHouse2[i].HasCar());
+			break;
+		case GARAGE_HIDEOUT_THREE:
+			total += (aCarsInSafeHouse3[i].HasCar());
+			break;
+		}
+	}
+	return total;
+}
+
+int32 CGarages::FindMaxNumStoredCarsForGarage(eGarageType type)
+{
+	switch (type) {
+	case GARAGE_HIDEOUT_ONE:
+		return LIMIT_CARS_IN_INDUSTRIAL;
+	case GARAGE_HIDEOUT_TWO:
+		return LIMIT_CARS_IN_COMMERCIAL;
+	case GARAGE_HIDEOUT_THREE:
+		return LIMIT_CARS_IN_SUBURBAN;
+	}
+	return 0;
+}
+
+bool CGarages::IsPointWithinHideOutGarage(CVector& point)
+{
+	for (int i = 0; i < NUM_GARAGES; i++) {
+		switch (aGarages[i].m_eGarageType) {
+		case GARAGE_HIDEOUT_ONE:
+		case GARAGE_HIDEOUT_TWO:
+		case GARAGE_HIDEOUT_THREE:
+			if (point.x > aGarages[i].m_fX1 && point.x < aGarages[i].m_fX2 &&
+				point.y > aGarages[i].m_fY1 && point.y < aGarages[i].m_fY2 &&
+				point.z > aGarages[i].m_fZ1 && point.z < aGarages[i].m_fZ2)
+				return true;
+		}
+	}
+	return false;
+}
+
+bool CGarages::IsPointWithinAnyGarage(CVector& point)
+{
+	for (int i = 0; i < NUM_GARAGES; i++) {
+		switch (aGarages[i].m_eGarageType) {
+		case GARAGE_NONE:
+			continue;
+		default:
+			if (point.x > aGarages[i].m_fX1 && point.x < aGarages[i].m_fX2 &&
+				point.y > aGarages[i].m_fY1 && point.y < aGarages[i].m_fY2 &&
+				point.z > aGarages[i].m_fZ1 && point.z < aGarages[i].m_fZ2)
+				return true;
+		}
+	}
+	return false;
+}
+
+void CGarages::SetAllDoorsBackToOriginalHeight()
+{
+	for (int i = 0; i < NUM_GARAGES; i++) {
+		switch (aGarages[i].m_eGarageType) {
+		case GARAGE_NONE:
+			continue;
+		default:
+			aGarages[i].RefreshDoorPointers(true);
+			if (aGarages[i].m_pDoor1) {
+				aGarages[i].m_pDoor1->GetPosition().z = aGarages[i].m_fDoor1Z;
+				if (aGarages[i].m_pDoor1->IsObject())
+					((CObject*)aGarages[i].m_pDoor1)->m_objectMatrix.GetPosition().z = aGarages[i].m_fDoor1Z;
+				if (aGarages[i].m_bRotatedDoor)
+					aGarages[i].BuildRotatedDoorMatrix(aGarages[i].m_pDoor1, 0.0f);
+				aGarages[i].m_pDoor1->GetMatrix().UpdateRW();
+				aGarages[i].m_pDoor1->UpdateRwFrame();
+			}
+			if (aGarages[i].m_pDoor2) {
+				aGarages[i].m_pDoor2->GetPosition().z = aGarages[i].m_fDoor2Z;
+				if (aGarages[i].m_pDoor2->IsObject())
+					((CObject*)aGarages[i].m_pDoor2)->m_objectMatrix.GetPosition().z = aGarages[i].m_fDoor2Z;
+				if (aGarages[i].m_bRotatedDoor)
+					aGarages[i].BuildRotatedDoorMatrix(aGarages[i].m_pDoor2, 0.0f);
+				aGarages[i].m_pDoor2->GetMatrix().UpdateRW();
+				aGarages[i].m_pDoor2->UpdateRwFrame();
+			}
+		}
+	}
+}
+
+void CGarages::Save(uint8 * buf, uint32 * size)
+{
+#ifdef FIX_GARAGE_SIZE
+	*size = (6 * sizeof(uint32) + TOTAL_COLLECTCARS_GARAGES * sizeof(*CarTypesCollected) + sizeof(uint32) + 3 * NUM_GARAGE_STORED_CARS * sizeof(CStoredCar) + NUM_GARAGES * sizeof(CGarage));
+#else
+	* size = 5484;
+#endif
+	CloseHideOutGaragesBeforeSave();
+	WriteSaveBuf(buf, NumGarages);
+	WriteSaveBuf(buf, (uint32)BombsAreFree);
+	WriteSaveBuf(buf, (uint32)RespraysAreFree);
+	WriteSaveBuf(buf, CarsCollected);
+	WriteSaveBuf(buf, BankVansCollected);
+	WriteSaveBuf(buf, PoliceCarsCollected);
+	for (int i = 0; i < TOTAL_COLLECTCARS_GARAGES; i++)
+		WriteSaveBuf(buf, CarTypesCollected[i]);
+	WriteSaveBuf(buf, LastTimeHelpMessage);
+	for (int i = 0; i < NUM_GARAGE_STORED_CARS; i++) {
+		WriteSaveBuf(buf, aCarsInSafeHouse1[i]);
+		WriteSaveBuf(buf, aCarsInSafeHouse2[i]);
+		WriteSaveBuf(buf, aCarsInSafeHouse3[i]);
+	}
+	for (int i = 0; i < NUM_GARAGES; i++)
+		WriteSaveBuf(buf, aGarages[i]);
+}
+
+CStoredCar::CStoredCar(const CStoredCar & other)
+{
+	m_nModelIndex = other.m_nModelIndex;
+	m_vecPos = other.m_vecPos;
+	m_vecAngle = other.m_vecAngle;
+	m_bBulletproof = other.m_bBulletproof;
+	m_bFireproof = other.m_bFireproof;
+	m_bExplosionproof = other.m_bExplosionproof;
+	m_bCollisionproof = other.m_bCollisionproof;
+	m_bMeleeproof = other.m_bMeleeproof;
+	m_nPrimaryColor = other.m_nPrimaryColor;
+	m_nSecondaryColor = other.m_nSecondaryColor;
+	m_nRadioStation = other.m_nRadioStation;
+	m_nVariationA = other.m_nVariationA;
+	m_nVariationB = other.m_nVariationB;
+	m_nCarBombType = other.m_nCarBombType;
+}
+
+void CGarages::Load(uint8* buf, uint32 size)
+{
+#ifdef FIX_GARAGE_SIZE
+	assert(size == (6 * sizeof(uint32) + TOTAL_COLLECTCARS_GARAGES * sizeof(*CarTypesCollected) + sizeof(uint32) + 3 * NUM_GARAGE_STORED_CARS * sizeof(CStoredCar) + NUM_GARAGES * sizeof(CGarage));
+#else
+	assert(size == 5484);
+#endif
+	CloseHideOutGaragesBeforeSave();
+	NumGarages = ReadSaveBuf<uint32>(buf);
+	BombsAreFree = ReadSaveBuf<uint32>(buf);
+	RespraysAreFree = ReadSaveBuf<uint32>(buf);
+	CarsCollected = ReadSaveBuf<int32>(buf);
+	BankVansCollected = ReadSaveBuf<int32>(buf);
+	PoliceCarsCollected = ReadSaveBuf<int32>(buf);
+	for (int i = 0; i < TOTAL_COLLECTCARS_GARAGES; i++)
+		CarTypesCollected[i] = ReadSaveBuf<uint32>(buf);
+	LastTimeHelpMessage = ReadSaveBuf<uint32>(buf);
+	for (int i = 0; i < NUM_GARAGE_STORED_CARS; i++) {
+		aCarsInSafeHouse1[i] = ReadSaveBuf<CStoredCar>(buf);
+		aCarsInSafeHouse2[i] = ReadSaveBuf<CStoredCar>(buf);
+		aCarsInSafeHouse3[i] = ReadSaveBuf<CStoredCar>(buf);
+	}
+	for (int i = 0; i < NUM_GARAGES; i++) {
+		aGarages[i] = ReadSaveBuf<CGarage>(buf);
+		aGarages[i].m_pDoor1 = nil;
+		aGarages[i].m_pDoor2 = nil;
+		aGarages[i].m_pTarget = nil;
+		aGarages[i].field_96 = nil;
+		aGarages[i].m_bRecreateDoorOnNextRefresh = true;
+		aGarages[i].RefreshDoorPointers(true);
+		if (aGarages[i].m_eGarageType == GARAGE_CRUSHER)
+			aGarages[i].UpdateCrusherAngle();
+		else
+			aGarages[i].UpdateDoorsHeight();
+	}
+}
+
+bool
+CGarages::IsModelIndexADoor(uint32 id)
+{
+	return id == MI_GARAGEDOOR1 ||
+		id == MI_GARAGEDOOR2 ||
+		id == MI_GARAGEDOOR3 ||
+		id == MI_GARAGEDOOR4 ||
+		id == MI_GARAGEDOOR5 ||
+		id == MI_GARAGEDOOR6 ||
+		id == MI_GARAGEDOOR7 ||
+		id == MI_GARAGEDOOR9 ||
+		id == MI_GARAGEDOOR10 ||
+		id == MI_GARAGEDOOR11 ||
+		id == MI_GARAGEDOOR12 ||
+		id == MI_GARAGEDOOR13 ||
+		id == MI_GARAGEDOOR14 ||
+		id == MI_GARAGEDOOR15 ||
+		id == MI_GARAGEDOOR16 ||
+		id == MI_GARAGEDOOR17 ||
+		id == MI_GARAGEDOOR18 ||
+		id == MI_GARAGEDOOR19 ||
+		id == MI_GARAGEDOOR20 ||
+		id == MI_GARAGEDOOR21 ||
+		id == MI_GARAGEDOOR22 ||
+		id == MI_GARAGEDOOR23 ||
+		id == MI_GARAGEDOOR24 ||
+		id == MI_GARAGEDOOR25 ||
+		id == MI_GARAGEDOOR26 ||
+		id == MI_GARAGEDOOR27 ||
+		id == MI_GARAGEDOOR28 ||
+		id == MI_GARAGEDOOR29 ||
+		id == MI_GARAGEDOOR30 ||
+		id == MI_GARAGEDOOR31 ||
+		id == MI_GARAGEDOOR32 ||
+		id == MI_CRUSHERBODY ||
+		id == MI_CRUSHERLID;
+}
+
+
+STARTPATCHES
+	InjectHook(0x426B20, CGarages::TriggerMessage, PATCH_JUMP); // CCrane::Update, CCrane::FindCarInSectorList
+	InjectHook(0x427AB0, CGarages::IsPointInAGarageCameraZone, PATCH_JUMP); // CCamera::CamControl
+	InjectHook(0x427BC0, CGarages::CameraShouldBeOutside, PATCH_JUMP); // CCamera::CamControl
+	InjectHook(0x428940, CGarages::Load, PATCH_JUMP); // GenericLoad
+ENDPATCHES
\ No newline at end of file
diff --git a/src/control/Garages.h b/src/control/Garages.h
index 5e106ade..e3864a48 100644
--- a/src/control/Garages.h
+++ b/src/control/Garages.h
@@ -1,9 +1,11 @@
 #pragma once
 #include "Automobile.h"
 #include "audio_enums.h"
+#include "Camera.h"
 #include "config.h"
 
 class CVehicle;
+class CCamera;
 
 enum eGarageState : int8
 {
@@ -44,7 +46,8 @@ enum eGarageType : int8
 
 enum
 {
-	TOTAL_COLLECTCARS_GARAGES = GARAGE_COLLECTCARS_3 - GARAGE_COLLECTCARS_1 + 1
+	TOTAL_COLLECTCARS_GARAGES = GARAGE_COLLECTCARS_3 - GARAGE_COLLECTCARS_1 + 1,
+	TOTAL_COLLECTCARS_CARS = 16
 };
 
 class CStoredCar
@@ -63,34 +66,43 @@ class CStoredCar
 	int8 m_nVariationA;
 	int8 m_nVariationB;
 	int8 m_nCarBombType;
+public:
+	void Init() { m_nModelIndex = 0; }
+	void Clear() { m_nModelIndex = 0; }
+	bool HasCar() { return m_nModelIndex != 0; }
+	CStoredCar(const CStoredCar& other);
+	void StoreCar(CVehicle*);
+	CVehicle* RestoreCar();
 };
 
 static_assert(sizeof(CStoredCar) == 0x28, "CStoredCar");
 
+#define SWITCH_GARAGE_DISTANCE_CLOSE 40.0f
+
 class CGarage
 {
-public:
 	eGarageType m_eGarageType;
 	eGarageState m_eGarageState;
-	char field_2;
-	char m_bClosingWithoutTargetCar;
-	char m_bDeactivated;
-	char m_bResprayHappened;
-	char field_6;
-	char field_7;
+	bool field_2; // unused
+	bool m_bClosingWithoutTargetCar;
+	bool m_bDeactivated;
+	bool m_bResprayHappened;
 	int m_nTargetModelIndex;
 	CEntity *m_pDoor1;
 	CEntity *m_pDoor2;
-	char m_bDoor1PoolIndex;
-	char m_bDoor2PoolIndex;
-	char m_bIsDoor1Object;
-	char m_bIsDoor2Object;
-	char field_24;
-	char m_bRotatedDoor;
-	char m_bCameraFollowsPlayer;
-	char field_27;
-	CVector m_vecInf;
-	CVector m_vecSup;
+	uint8 m_bDoor1PoolIndex;
+	uint8 m_bDoor2PoolIndex;
+	bool m_bDoor1IsDummy;
+	bool m_bDoor2IsDummy;
+	bool m_bRecreateDoorOnNextRefresh;
+	bool m_bRotatedDoor;
+	bool m_bCameraFollowsPlayer;
+	float m_fX1;
+	float m_fX2;
+	float m_fY1;
+	float m_fY2;
+	float m_fZ1;
+	float m_fZ2;
 	float m_fDoorPos;
 	float m_fDoorHeight;
 	float m_fDoor1X;
@@ -99,26 +111,74 @@ public:
 	float m_fDoor2Y;
 	float m_fDoor1Z;
 	float m_fDoor2Z;
-	int m_nDoorOpenTime;
-	char m_bCollectedCarsState;
-	char field_89;
-	char field_90;
-	char field_91;
+	uint32 m_nTimeToStartAction;
+	uint8 m_bCollectedCarsState;
 	CVehicle *m_pTarget;
-	int field_96;
-	CStoredCar m_sStoredCar;
+	void* field_96; // unused
+	CStoredCar m_sStoredCar; // not needed
 
 	void OpenThisGarage();
 	void CloseThisGarage();
 	bool IsOpen() { return m_eGarageState == GS_OPENED || m_eGarageState == GS_OPENEDCONTAINSCAR; }
 	bool IsClosed() { return m_eGarageState == GS_FULLYCLOSED; }
+	bool IsUsed() { return m_eGarageType != GARAGE_NONE; }
+	void Update();
+	float GetGarageCenterX() { return (m_fX1 + m_fX2) / 2; }
+	float GetGarageCenterY() { return (m_fY1 + m_fY2) / 2; }
+	bool IsFar()
+	{ 
+#ifdef FIX_BUGS
+		return Abs(TheCamera.GetPosition().x - GetGarageCenterX()) > SWITCH_GARAGE_DISTANCE_CLOSE ||
+			Abs(TheCamera.GetPosition().y - GetGarageCenterY()) > SWITCH_GARAGE_DISTANCE_CLOSE;
+#else
+		return Abs(TheCamera.GetPosition().x - m_fX1) > SWITCH_GARAGE_DISTANCE_CLOSE || 
+			Abs(TheCamera.GetPosition().y - m_fY1) > SWITCH_GARAGE_DISTANCE_CLOSE;
+#endif
+	}
+	void TidyUpGarageClose();
+	void TidyUpGarage();
+	void RefreshDoorPointers(bool);
+	void UpdateCrusherAngle();
+	void UpdateDoorsHeight();
+	bool IsEntityEntirelyInside3D(CEntity*, float);
+	bool IsEntityEntirelyOutside(CEntity*, float);
+	bool IsEntityEntirelyInside(CEntity*);
+	float CalcDistToGarageRectangleSquared(float, float);
+	float CalcSmallestDistToGarageDoorSquared(float, float);
+	bool IsAnyOtherCarTouchingGarage(CVehicle* pException);
+	bool IsStaticPlayerCarEntirelyInside();
+	bool IsPlayerOutsideGarage();
+	bool IsAnyCarBlockingDoor();
+	void CenterCarInGarage(CVehicle*);
+	bool DoesCraigNeedThisCar(int32);
+	bool MarkThisCarAsCollectedForCraig(int32);
+	bool HasCraigCollectedThisCar(int32);
+	bool IsGarageEmpty();
+	void UpdateCrusherShake(float, float);
+	int32 CountCarsWithCenterPointWithinGarage(CEntity* pException);
+	void RemoveCarsBlockingDoorNotInside();
+	void StoreAndRemoveCarsForThisHideout(CStoredCar*, int32);
+	bool RestoreCarsForThisHideout(CStoredCar*);
+	bool IsEntityTouching3D(CEntity*);
+	bool EntityHasASphereWayOutsideGarage(CEntity*, float);
+	bool IsAnyOtherPedTouchingGarage(CPed* pException);
+	void BuildRotatedDoorMatrix(CEntity*, float);
+	void FindDoorsEntities();
+	void FindDoorsEntitiesSectorList(CPtrList&, bool);
+	void PlayerArrestedOrDied();
+
+	friend class CGarages;
+	friend class cAudioManager;
+	friend class CCamera;
 };
 
 static_assert(sizeof(CGarage) == 140, "CGarage");
 
 class CGarages
 {
-public:
+	enum {
+		MESSAGE_LENGTH = 8
+	};
 	static int32 &BankVansCollected;
 	static bool &BombsAreFree;
 	static bool &RespraysAreFree;
@@ -127,7 +187,7 @@ public:
 	static int32 &CrushedCarId;
 	static uint32 &LastTimeHelpMessage;
 	static int32 &MessageNumberInString;
-	static const char *MessageIDString;
+	static char(&MessageIDString)[MESSAGE_LENGTH];
 	static int32 &MessageNumberInString2;
 	static uint32 &MessageStartTime;
 	static uint32 &MessageEndTime;
@@ -135,36 +195,62 @@ public:
 	static bool &PlayerInGarage;
 	static int32 &PoliceCarsCollected;
 	static uint32 &GarageToBeTidied;
-	static CGarage(&Garages)[NUM_GARAGES];
+	static CGarage(&aGarages)[NUM_GARAGES];
+	static CStoredCar(&aCarsInSafeHouse1)[NUM_GARAGE_STORED_CARS];
+	static CStoredCar(&aCarsInSafeHouse2)[NUM_GARAGE_STORED_CARS];
+	static CStoredCar(&aCarsInSafeHouse3)[NUM_GARAGE_STORED_CARS];
+	static int32 &AudioEntity;
+	static bool &bCamShouldBeOutisde;
 
 public:
-	static bool IsModelIndexADoor(uint32 id);
-	static void TriggerMessage(const char *text, int16, uint16 time, int16);
-	static void PrintMessages(void);
-	static bool HasCarBeenCrushed(int32);
-	static bool IsPointWithinHideOutGarage(CVector&);
-	static bool IsPointWithinAnyGarage(CVector&);
-	static void PlayerArrestedOrDied();
 	static void Init(void);
+#ifndef PS2
+	static void Shutdown(void);
+#endif
 	static void Update(void);
-	static void Load(uint8 *buf, uint32 size);
-	static void Save(uint8 *buf, uint32 *size);
-	static int16 AddOne(float, float, float, float, float, float, uint8, uint32);
+
+	static int16 AddOne(float X1, float Y1, float Z1, float X2, float Y2, float Z2, eGarageType type, int32 targetId);
+	static void ChangeGarageType(int16, eGarageType, int32);
+	static void PrintMessages(void);
+	static void TriggerMessage(const char* text, int16, uint16 time, int16);
 	static void SetTargetCarForMissonGarage(int16, CVehicle*);
 	static bool HasCarBeenDroppedOffYet(int16);
-	static void ActivateGarage(int16);
 	static void DeActivateGarage(int16);
+	static void ActivateGarage(int16);
 	static int32 QueryCarsCollected(int16);
-	static bool HasThisCarBeenCollected(int16, uint8);
-	static void ChangeGarageType(int16, eGarageType, int32);
-	static bool HasResprayHappened(int16);
-	static void GivePlayerDetonator();
+	static bool HasImportExportGarageCollectedThisCar(int16, int8);
 	static bool IsGarageOpen(int16);
 	static bool IsGarageClosed(int16);
+	static bool HasThisCarBeenCollected(int16, uint8);
+	static void OpenGarage(int16 garage) { aGarages[garage].OpenThisGarage(); }
+	static void CloseGarage(int16 garage) { aGarages[garage].CloseThisGarage(); }
+	static bool HasResprayHappened(int16);
 	static void SetGarageDoorToRotate(int16);
-	static bool HasImportExportGarageCollectedThisCar(int16, int8);
 	static void SetLeaveCameraForThisGarage(int16);
 	static bool IsThisCarWithinGarageArea(int16, CEntity*);
+	static bool HasCarBeenCrushed(int32);
+	static bool IsPointInAGarageCameraZone(CVector);
+	static bool CameraShouldBeOutside(void);
+	static void GivePlayerDetonator(void);
+	static void PlayerArrestedOrDied(void);
+	static bool IsPointWithinHideOutGarage(CVector&);
+	static bool IsPointWithinAnyGarage(CVector&);
+	static void SetAllDoorsBackToOriginalHeight(void);
+	static void Save(uint8* buf, uint32* size);
+	static void Load(uint8* buf, uint32 size);
+	static bool IsModelIndexADoor(uint32 id);
+	static void SetFreeBombs(bool bValue) { BombsAreFree = bValue; }
+	static void SetFreeResprays(bool bValue) { RespraysAreFree = bValue; }
+
+private:
+	static bool IsCarSprayable(CVehicle*);
+	static float FindDoorHeightForMI(int32);
+	static void CloseHideOutGaragesBeforeSave(void);
+	static int32 CountCarsInHideoutGarage(eGarageType);
+	static int32 FindMaxNumStoredCarsForGarage(eGarageType);
+	static int32 GetBombTypeForGarageType(eGarageType type) { return type - GARAGE_BOMBSHOP1 + 1; }
+	static int32 GetCarsCollectedIndexForGarageType(eGarageType type) { return type - GARAGE_COLLECTCARS_1; }
 
-	static int GetCarsCollectedIndexForGarageType(eGarageType type) { return type - GARAGE_COLLECTCARS_1; }
+	friend class cAudioManager;
+	friend class CGarage;
 };
diff --git a/src/control/PathFind.cpp b/src/control/PathFind.cpp
index daa27e57..608a209a 100644
--- a/src/control/PathFind.cpp
+++ b/src/control/PathFind.cpp
@@ -11,19 +11,10 @@ CPathFind &ThePaths = *(CPathFind*)0x8F6754;
 
 WRAPPER bool CPedPath::CalcPedRoute(uint8, CVector, CVector, CVector*, int16*, int16) { EAXJMP(0x42E680); }
 
-enum
-{
-	NodeTypeExtern = 1,
-	NodeTypeIntern = 2,
-
-	ObjectFlag1 = 1,
-	ObjectEastWest = 2,
-
-	MAX_DIST = INT16_MAX-1
-};
+#define MAX_DIST INT16_MAX-1
 
 // object flags:
-//	1
+//	1	UseInRoadBlock
 //	2	east/west road(?)
 
 CPathInfoForObject *&InfoForTileCars = *(CPathInfoForObject**)0x8F1A8C;
@@ -218,14 +209,14 @@ CPathFind::PreparePathData(void)
 			if(numIntern == 1 && numExtern == 2){
 				if(numLanes < 4){
 					if((i & 7) == 4){		// WHAT?
-						m_objectFlags[i] |= ObjectFlag1;
+						m_objectFlags[i] |= UseInRoadBlock;
 						if(maxX > maxY)
 							m_objectFlags[i] |= ObjectEastWest;
 						else
 							m_objectFlags[i] &= ~ObjectEastWest;
 					}
 				}else{
-					m_objectFlags[i] |= ObjectFlag1;
+					m_objectFlags[i] |= UseInRoadBlock;
 					if(maxX > maxY)
 						m_objectFlags[i] |= ObjectEastWest;
 					else
diff --git a/src/control/PathFind.h b/src/control/PathFind.h
index d42b8bb3..c51cb7c7 100644
--- a/src/control/PathFind.h
+++ b/src/control/PathFind.h
@@ -11,6 +11,15 @@ public:
 
 enum
 {
+	NodeTypeExtern = 1,
+	NodeTypeIntern = 2,
+
+	UseInRoadBlock = 1,
+	ObjectEastWest = 2,
+};
+
+enum
+{
 	PATH_CAR = 0,
 	PATH_PED = 1,
 };
diff --git a/src/control/Phones.cpp b/src/control/Phones.cpp
index f3b3a8db..276f02b9 100644
--- a/src/control/Phones.cpp
+++ b/src/control/Phones.cpp
@@ -11,6 +11,7 @@
 #include "General.h"
 #include "AudioScriptObject.h"
 #include "RpAnimBlend.h"
+#include "AnimBlendAssociation.h"
 
 CPhoneInfo &gPhoneInfo = *(CPhoneInfo*)0x732A20;
 
diff --git a/src/control/Pickups.cpp b/src/control/Pickups.cpp
index 53da89f4..3e3c2a48 100644
--- a/src/control/Pickups.cpp
+++ b/src/control/Pickups.cpp
@@ -15,8 +15,14 @@
 #include "Pad.h"

 #include "Pickups.h"

 #include "PlayerPed.h"

+#include "Wanted.h"

+#include "DMAudio.h"

+#include "Fire.h"

 #include "PointLights.h"

 #include "Pools.h"

+#ifdef FIX_BUGS

+#include "Replay.h"

+#endif

 #include "Script.h"

 #include "Shadows.h"

 #include "SpecialFX.h"

@@ -639,32 +645,26 @@ CPickups::AddToCollectedPickupsArray(int32 index)
 void

 CPickups::Update()

 {

-#ifndef FIX_BUGS

-	// BUG: this code can only reach 318 out of 320 pickups

+#ifdef FIX_BUGS // RIP speedrunning (solution from SA)

+	if (CReplay::IsPlayingBack())

+		return;

+#endif

 #define PICKUPS_FRAME_SPAN (6)

-#define PICKUPS_PER_FRAME (NUMGENERALPICKUPS/PICKUPS_FRAME_SPAN)

-

-	for (uint32 i = PICKUPS_PER_FRAME * (CTimer::GetFrameCounter() % PICKUPS_FRAME_SPAN); i < PICKUPS_PER_FRAME * (CTimer::GetFrameCounter() % PICKUPS_FRAME_SPAN + 1); i++) {

-		if (aPickUps[i].m_eType != PICKUP_NONE && aPickUps[i].Update(FindPlayerPed(), FindPlayerVehicle(), CWorld::PlayerInFocus)) {

-			AddToCollectedPickupsArray(i);

-		}

-	}

-

-	for (uint32 i = NUMGENERALPICKUPS; i < NUMPICKUPS; i++) {

+#ifdef FIX_BUGS

+	for (uint32 i = NUMGENERALPICKUPS * (CTimer::GetFrameCounter() % PICKUPS_FRAME_SPAN) / PICKUPS_FRAME_SPAN; i < NUMGENERALPICKUPS * (CTimer::GetFrameCounter() % PICKUPS_FRAME_SPAN + 1) / PICKUPS_FRAME_SPAN; i++) {

+#else // BUG: this code can only reach 318 out of 320 pickups

+	for (uint32 i = NUMGENERALPICKUPS / PICKUPS_FRAME_SPAN * (CTimer::GetFrameCounter() % PICKUPS_FRAME_SPAN); i < NUMGENERALPICKUPS / PICKUPS_FRAME_SPAN * (CTimer::GetFrameCounter() % PICKUPS_FRAME_SPAN + 1); i++) {

+#endif

 		if (aPickUps[i].m_eType != PICKUP_NONE && aPickUps[i].Update(FindPlayerPed(), FindPlayerVehicle(), CWorld::PlayerInFocus)) {

 			AddToCollectedPickupsArray(i);

 		}

 	}

-

 #undef PICKUPS_FRAME_SPAN

-#undef PICKUPS_PER_FRAME

-#else

-	for (uint32 i = 0; i < NUMPICKUPS; i++) {

+	for (uint32 i = NUMGENERALPICKUPS; i < NUMPICKUPS; i++) {

 		if (aPickUps[i].m_eType != PICKUP_NONE && aPickUps[i].Update(FindPlayerPed(), FindPlayerVehicle(), CWorld::PlayerInFocus)) {

 			AddToCollectedPickupsArray(i);

 		}

 	}

-#endif

 }

 

 void

diff --git a/src/control/Remote.cpp b/src/control/Remote.cpp
index e3891502..f7d12702 100644
--- a/src/control/Remote.cpp
+++ b/src/control/Remote.cpp
@@ -35,7 +35,7 @@ CRemote::GivePlayerRemoteControlledCar(float x, float y, float z, float rot, uin
 
 	CWorld::Players[CWorld::PlayerInFocus].m_pRemoteVehicle = car;
 	CWorld::Players[CWorld::PlayerInFocus].m_pRemoteVehicle->RegisterReference((CEntity**)&CWorld::Players[CWorld::PlayerInFocus].m_pRemoteVehicle);
-	TheCamera.TakeControl(car, CCam::MODE_BEHINDCAR, INTERPOLATION, CAM_CONTROLLER_1);
+	TheCamera.TakeControl(car, CCam::MODE_BEHINDCAR, INTERPOLATION, CAMCONTROL_SCRIPT);
 }
 
 void
diff --git a/src/control/Replay.cpp b/src/control/Replay.cpp
index a68dd5e7..2e325249 100644
--- a/src/control/Replay.cpp
+++ b/src/control/Replay.cpp
@@ -5,6 +5,7 @@
 #include "SpecialFX.h"
 #include "CarCtrl.h"
 #include "CivilianPed.h"
+#include "Wanted.h"
 #include "Clock.h"
 #include "DMAudio.h"
 #include "Draw.h"
@@ -22,6 +23,8 @@
 #include "Pools.h"
 #include "Population.h"
 #include "Replay.h"
+#include "References.h"
+#include "Pools.h"
 #include "RpAnimBlend.h"
 #include "RwHelper.h"
 #include "CutsceneMgr.h"
@@ -33,6 +36,8 @@
 #include "Zones.h"
 #include "Font.h"
 #include "Text.h"
+#include "Camera.h"
+#include "Radar.h"
 
 uint8 &CReplay::Mode = *(uint8*)0x95CD5B;
 CAddressInReplayBuffer &CReplay::Record = *(CAddressInReplayBuffer*)0x942F7C;
@@ -108,9 +113,6 @@ static void(*CBArray_RE3[])(CAnimBlendAssociation*, void*) =
 	&CPed::PedLandCB, &FinishFuckUCB, &CPed::RestoreHeadingRateCB, &CPed::PedSetQuickDraggedOutCarPositionCB, &CPed::PedSetDraggedOutCarPositionCB
 };
 
-#if 0
-WRAPPER uint8 FindCBFunctionID(void(*f)(CAnimBlendAssociation*, void*)) { EAXJMP(0x584E70); }
-#else
 static uint8 FindCBFunctionID(void(*f)(CAnimBlendAssociation*, void*))
 {
 	for (int i = 0; i < sizeof(CBArray) / sizeof(*CBArray); i++){
@@ -123,16 +125,12 @@ static uint8 FindCBFunctionID(void(*f)(CAnimBlendAssociation*, void*))
 	}
 	return 0;
 }
-#endif
 
 static void(*FindCBFunction(uint8 id))(CAnimBlendAssociation*, void*)
 {
 	return CBArray_RE3[id];
 }
 
-#if 0
-WRAPPER static void ApplyPanelDamageToCar(uint32, CAutomobile*, bool) { EAXJMP(0x584EA0); }
-#else
 static void ApplyPanelDamageToCar(uint32 panels, CAutomobile* vehicle, bool flying)
 {
 	if(vehicle->Damage.GetPanelStatus(VEHPANEL_FRONT_LEFT) != CDamageManager::GetPanelStatus(panels, VEHPANEL_FRONT_LEFT)){
@@ -164,7 +162,6 @@ static void ApplyPanelDamageToCar(uint32 panels, CAutomobile* vehicle, bool flyi
 		vehicle->SetPanelDamage(CAR_BUMP_REAR, VEHBUMPER_REAR, flying);
 	}
 }
-#endif
 
 void PrintElementsInPtrList(void) 
 {
@@ -257,9 +254,6 @@ void CReplay::Update(void)
 	}
 }
 
-#if 0
-WRAPPER void CReplay::RecordThisFrame(void) { EAXJMP(0x5932B0); }
-#else
 void CReplay::RecordThisFrame(void)
 {
 #ifdef FIX_REPLAY_BUGS
@@ -372,11 +366,7 @@ void CReplay::RecordThisFrame(void)
 	MarkEverythingAsNew();
 #endif
 }
-#endif
 
-#if 0
-WRAPPER void CReplay::StorePedUpdate(CPed *ped, int id) { EAXJMP(0x5935B0); }
-#else
 void CReplay::StorePedUpdate(CPed *ped, int id)
 {
 	tPedUpdatePacket* pp = (tPedUpdatePacket*)&Record.m_pBase[Record.m_nOffset];
@@ -394,11 +384,7 @@ void CReplay::StorePedUpdate(CPed *ped, int id)
 	StorePedAnimation(ped, &pp->anim_state);
 	Record.m_nOffset += sizeof(tPedUpdatePacket);
 }
-#endif
 
-#if 0
-WRAPPER void CReplay::StorePedAnimation(CPed *ped, CStoredAnimationState *state) { EAXJMP(0x593670); }
-#else
 void CReplay::StorePedAnimation(CPed *ped, CStoredAnimationState *state)
 {
 	CAnimBlendAssociation* second;
@@ -437,11 +423,7 @@ void CReplay::StorePedAnimation(CPed *ped, CStoredAnimationState *state)
 		state->partBlendAmount = 0;
 	}
 }
-#endif
 
-#if 0
-WRAPPER void CReplay::StoreDetailedPedAnimation(CPed *ped, CStoredDetailedAnimationState *state) { EAXJMP(0x593BB0); }
-#else
 void CReplay::StoreDetailedPedAnimation(CPed *ped, CStoredDetailedAnimationState *state)
 {
 	for (int i = 0; i < NUM_MAIN_ANIMS_IN_REPLAY; i++){
@@ -498,10 +480,7 @@ void CReplay::StoreDetailedPedAnimation(CPed *ped, CStoredDetailedAnimationState
 		}
 	}
 }
-#endif
-#if 0
-WRAPPER void CReplay::ProcessPedUpdate(CPed *ped, float interpolation, CAddressInReplayBuffer *buffer) { EAXJMP(0x594050); }
-#else
+
 void CReplay::ProcessPedUpdate(CPed *ped, float interpolation, CAddressInReplayBuffer *buffer)
 {
 	tPedUpdatePacket *pp = (tPedUpdatePacket*)&buffer->m_pBase[buffer->m_nOffset];
@@ -538,11 +517,7 @@ void CReplay::ProcessPedUpdate(CPed *ped, float interpolation, CAddressInReplayB
 	CWorld::Add(ped);
 	buffer->m_nOffset += sizeof(tPedUpdatePacket);
 }
-#endif
 
-#if 0
-WRAPPER void CReplay::RetrievePedAnimation(CPed *ped, CStoredAnimationState *state) { EAXJMP(0x5942A0); }
-#else
 void CReplay::RetrievePedAnimation(CPed *ped, CStoredAnimationState *state)
 {
 	CAnimBlendAssociation* anim1 = CAnimManager::BlendAnimation(
@@ -580,11 +555,7 @@ void CReplay::RetrievePedAnimation(CPed *ped, CStoredAnimationState *state)
 		}
 	}
 }
-#endif
 
-#if 0
-WRAPPER void CReplay::RetrieveDetailedPedAnimation(CPed *ped, CStoredDetailedAnimationState *state) { EAXJMP(0x5944B0); }
-#else
 void CReplay::RetrieveDetailedPedAnimation(CPed *ped, CStoredDetailedAnimationState *state)
 {
 #ifdef FIX_REPLAY_BUGS
@@ -653,11 +624,7 @@ void CReplay::RetrieveDetailedPedAnimation(CPed *ped, CStoredDetailedAnimationSt
 			anim->SetDeleteCallback(FindCBFunction(callback & 0x7F), ped);
 	}
 }
-#endif
 
-#if 0
-WRAPPER void CReplay::PlaybackThisFrame(void) { EAXJMP(0x5946B0); }
-#else
 void CReplay::PlaybackThisFrame(void)
 {
 	static int FrameSloMo = 0;
@@ -682,7 +649,6 @@ void CReplay::PlaybackThisFrame(void)
 	DMAudio.SetEffectsFadeVol(0);
 	DMAudio.SetMusicFadeVol(0);
 }
-#endif
 
 // next two functions are only found in mobile version
 // most likely they were optimized out for being unused
@@ -707,9 +673,6 @@ bool CReplay::FastForwardToTime(uint32 start)
 	return true;
 }
 
-#if 0
-WRAPPER void CReplay::StoreCarUpdate(CVehicle *vehicle, int id) { EAXJMP(0x5947F0); }
-#else
 void CReplay::StoreCarUpdate(CVehicle *vehicle, int id)
 {
 	tVehicleUpdatePacket* vp = (tVehicleUpdatePacket*)&Record.m_pBase[Record.m_nOffset];
@@ -745,11 +708,7 @@ void CReplay::StoreCarUpdate(CVehicle *vehicle, int id)
 	}
 	Record.m_nOffset += sizeof(tVehicleUpdatePacket);
 }
-#endif
 
-#if 0
-WRAPPER void CReplay::ProcessCarUpdate(CVehicle *vehicle, float interpolation, CAddressInReplayBuffer *buffer) { EAXJMP(0x594D10); }
-#else
 void CReplay::ProcessCarUpdate(CVehicle *vehicle, float interpolation, CAddressInReplayBuffer *buffer)
 {
 	tVehicleUpdatePacket* vp = (tVehicleUpdatePacket*)&buffer->m_pBase[buffer->m_nOffset];
@@ -819,11 +778,7 @@ void CReplay::ProcessCarUpdate(CVehicle *vehicle, float interpolation, CAddressI
 			((CBoat*)vehicle)->m_bIsAnchored = false;
 	}
 }
-#endif
 
-#if 0
-WRAPPER bool CReplay::PlayBackThisFrameInterpolation(CAddressInReplayBuffer *buffer, float interpolation, uint32 *pTimer) { EAXJMP(0x595240); }
-#else
 bool CReplay::PlayBackThisFrameInterpolation(CAddressInReplayBuffer *buffer, float interpolation, uint32 *pTimer){
 	/* Mistake. Not even sure what this is even doing here...
 	 * PlayerWanted is a backup to restore at the end of replay.
@@ -1023,10 +978,7 @@ bool CReplay::PlayBackThisFrameInterpolation(CAddressInReplayBuffer *buffer, flo
 	ProcessReplayCamera();
 	return false;
 }
-#endif
-#if 0
-WRAPPER void CReplay::FinishPlayback(void) { EAXJMP(0x595B20); }
-#else
+
 void CReplay::FinishPlayback(void)
 {
 	if (Mode != MODE_PLAYBACK)
@@ -1048,11 +1000,7 @@ void CReplay::FinishPlayback(void)
 	DMAudio.SetEffectsFadeVol(127);
 	DMAudio.SetMusicFadeVol(127);
 }
-#endif
 
-#if 0
-WRAPPER void CReplay::EmptyReplayBuffer(void) { EAXJMP(0x595BD0); }
-#else
 void CReplay::EmptyReplayBuffer(void)
 {
 	if (Mode == MODE_PLAYBACK)
@@ -1067,11 +1015,7 @@ void CReplay::EmptyReplayBuffer(void)
 	Record.m_pBase[Record.m_nOffset] = 0;
 	MarkEverythingAsNew();
 }
-#endif
 
-#if 0
-WRAPPER void CReplay::ProcessReplayCamera(void) { EAXJMP(0x595C40); }
-#else
 void CReplay::ProcessReplayCamera(void)
 {
 	switch (CameraMode) {
@@ -1115,11 +1059,7 @@ void CReplay::ProcessReplayCamera(void)
 	RwMatrixUpdate(RwFrameGetMatrix(RwCameraGetFrame(TheCamera.m_pRwCamera)));
 	RwFrameUpdateObjects(RwCameraGetFrame(TheCamera.m_pRwCamera));
 }
-#endif
 
-#if 0
-WRAPPER void CReplay::TriggerPlayback(uint8 cam_mode, float cam_x, float cam_y, float cam_z, bool load_scene) { EAXJMP(0x596030); }
-#else
 void CReplay::TriggerPlayback(uint8 cam_mode, float cam_x, float cam_y, float cam_z, bool load_scene)
 {
 	if (Mode != MODE_RECORD)
@@ -1169,11 +1109,7 @@ void CReplay::TriggerPlayback(uint8 cam_mode, float cam_x, float cam_y, float ca
 	if (cam_mode == REPLAYCAMMODE_ASSTORED)
 		TheCamera.CarZoomIndicator = 5.0f;
 }
-#endif
 
-#if 0
-WRAPPER void CReplay::StoreStuffInMem(void) { EAXJMP(0x5961F0); }
-#else
 void CReplay::StoreStuffInMem(void)
 {
 	CPools::GetVehiclePool()->Store(pBuf0, pBuf1);
@@ -1218,11 +1154,7 @@ void CReplay::StoreStuffInMem(void)
 			StoreDetailedPedAnimation(ped, &pPedAnims[i]);
 	}
 }
-#endif
 
-#if 0
-WRAPPER void CReplay::RestoreStuffFromMem(void) { EAXJMP(0x5966E0); }
-#else
 void CReplay::RestoreStuffFromMem(void)
 {
 	CPools::GetVehiclePool()->CopyBack(pBuf0, pBuf1);
@@ -1383,11 +1315,7 @@ void CReplay::RestoreStuffFromMem(void)
 	DMAudio.SetRadioInCar(OldRadioStation);
 	DMAudio.ChangeMusicMode(MUSICMODE_GAME);
 }
-#endif
 
-#if 0
-WRAPPER void CReplay::EmptyPedsAndVehiclePools(void) { EAXJMP(0x5970E0); }
-#else
 void CReplay::EmptyPedsAndVehiclePools(void)
 {
 	int i = CPools::GetVehiclePool()->GetSize();
@@ -1407,11 +1335,7 @@ void CReplay::EmptyPedsAndVehiclePools(void)
 		delete p;
 	}
 }
-#endif
 
-#if 0
-WRAPPER void CReplay::EmptyAllPools(void) { EAXJMP(0x5971B0); }
-#else
 void CReplay::EmptyAllPools(void)
 {
 	EmptyPedsAndVehiclePools();
@@ -1432,11 +1356,7 @@ void CReplay::EmptyAllPools(void)
 		delete d;
 	}
 }
-#endif
 
-#if 0
-WRAPPER void CReplay::MarkEverythingAsNew(void) { EAXJMP(0x597280); }
-#else
 void CReplay::MarkEverythingAsNew(void)
 {
 	int i = CPools::GetVehiclePool()->GetSize();
@@ -1454,11 +1374,7 @@ void CReplay::MarkEverythingAsNew(void)
 		p->bHasAlreadyBeenRecorded = false;
 	}
 }
-#endif
 
-#if 0
-WRAPPER void CReplay::SaveReplayToHD(void) { EAXJMP(0x597330); }
-#else
 void CReplay::SaveReplayToHD(void)
 {
 	CFileMgr::SetDirMyDocuments();
@@ -1489,11 +1405,7 @@ void CReplay::SaveReplayToHD(void)
 	CFileMgr::CloseFile(fw);
 	CFileMgr::SetDir("");
 }
-#endif
 
-#if 0
-WRAPPER void PlayReplayFromHD(void) { EAXJMP(0x597420); }
-#else
 void PlayReplayFromHD(void)
 {
 	CFileMgr::SetDirMyDocuments();
@@ -1525,11 +1437,7 @@ void PlayReplayFromHD(void)
 	CReplay::bAllowLookAroundCam = true;
 	CReplay::StreamAllNecessaryCarsAndPeds();
 }
-#endif
 
-#if 0
-WRAPPER void CReplay::StreamAllNecessaryCarsAndPeds(void) { EAXJMP(0x597560); }
-#else
 void CReplay::StreamAllNecessaryCarsAndPeds(void)
 {
 	for (int slot = 0; slot < NUM_REPLAYBUFFERS; slot++) {
@@ -1550,11 +1458,7 @@ void CReplay::StreamAllNecessaryCarsAndPeds(void)
 	}
 	CStreaming::LoadAllRequestedModels(false);
 }
-#endif
 
-#if 0
-WRAPPER void CReplay::FindFirstFocusCoordinate(CVector *coord) { EAXJMP(0x5975E0); }
-#else
 void CReplay::FindFirstFocusCoordinate(CVector *coord)
 {
 	*coord = CVector(0.0f, 0.0f, 0.0f);
@@ -1569,11 +1473,7 @@ void CReplay::FindFirstFocusCoordinate(CVector *coord)
 		}
 	}
 }
-#endif
 
-#if 0
-WRAPPER bool CReplay::ShouldStandardCameraBeProcessed(void) { EAXJMP(0x597680); }
-#else
 bool CReplay::ShouldStandardCameraBeProcessed(void)
 {
 	if (Mode != MODE_PLAYBACK)
@@ -1582,11 +1482,7 @@ bool CReplay::ShouldStandardCameraBeProcessed(void)
 		return false;
 	return FindPlayerVehicle() != nil;
 }
-#endif
 
-#if 0
-WRAPPER void CReplay::ProcessLookAroundCam(void) { EAXJMP(0x5976C0); }
-#else
 void CReplay::ProcessLookAroundCam(void)
 {
 	if (!bAllowLookAroundCam)
@@ -1642,11 +1538,7 @@ void CReplay::ProcessLookAroundCam(void)
 	RwMatrixUpdate(RwFrameGetMatrix(RwCameraGetFrame(TheCamera.m_pRwCamera)));
 	RwFrameUpdateObjects(RwCameraGetFrame(TheCamera.m_pRwCamera));
 }
-#endif
 
-#if 0
-WRAPPER size_t CReplay::FindSizeOfPacket(uint8 type) { EAXJMP(0x597CC0); }
-#else
 size_t CReplay::FindSizeOfPacket(uint8 type)
 {
 	switch (type) {
@@ -1664,11 +1556,7 @@ size_t CReplay::FindSizeOfPacket(uint8 type)
 	}
 	return 0;
 }
-#endif
 
-#if 0
-WRAPPER void CReplay::Display(void) { EAXJMP(0x595EE0); }
-#else
 void CReplay::Display()
 {
 	static int TimeCount = 0;
@@ -1686,7 +1574,6 @@ void CReplay::Display()
 	if (Mode == MODE_PLAYBACK)
 		CFont::PrintString(SCREEN_SCALE_X(63.5f), SCREEN_SCALE_Y(30.0f), TheText.Get("REPLAY"));
 }
-#endif
 
 STARTPATCHES
 InjectHook(0x592FE0, &CReplay::Init, PATCH_JUMP);
diff --git a/src/control/Replay.h b/src/control/Replay.h
index cc652a11..56de52a3 100644
--- a/src/control/Replay.h
+++ b/src/control/Replay.h
@@ -1,14 +1,7 @@
 #pragma once
 
-#include "Camera.h"
-#include "Ped.h"
 #include "Pools.h"
-#include "Radar.h"
-#include "References.h"
-#include "Vehicle.h"
-#include "Wanted.h"
 #include "World.h"
-#include "common.h"
 
 #ifdef FIX_BUGS
 #ifndef DONT_FIX_REPLAY_BUGS
@@ -16,6 +9,9 @@
 #endif
 #endif
 
+class CVehicle;
+struct CReference;
+
 struct CAddressInReplayBuffer
 {
 	uint32 m_nOffset;
diff --git a/src/control/RoadBlocks.cpp b/src/control/RoadBlocks.cpp
index ed092391..e39fe481 100644
--- a/src/control/RoadBlocks.cpp
+++ b/src/control/RoadBlocks.cpp
@@ -1,7 +1,37 @@
 #include "common.h"
 #include "patcher.h"
 #include "RoadBlocks.h"
+#include "PathFind.h"
+
+int16 &CRoadBlocks::NumRoadBlocks = *(int16*)0x95CC34;
+int16 (&CRoadBlocks::RoadBlockObjects)[NUMROADBLOCKS] = *(int16(*)[NUMROADBLOCKS]) * (uintptr*)0x72B3A8;
+bool (&CRoadBlocks::InOrOut)[NUMROADBLOCKS] = *(bool(*)[NUMROADBLOCKS]) * (uintptr*)0x733810;
 
-WRAPPER void CRoadBlocks::Init(void) { EAXJMP(0x436F50); }
 WRAPPER void CRoadBlocks::GenerateRoadBlockCopsForCar(CVehicle*, int32, int16) { EAXJMP(0x4376A0); }
-WRAPPER void CRoadBlocks::GenerateRoadBlocks(void) { EAXJMP(0x436FA0); }
\ No newline at end of file
+WRAPPER void CRoadBlocks::GenerateRoadBlocks(void) { EAXJMP(0x436FA0); }
+
+void
+CRoadBlocks::Init(void)
+{
+    NumRoadBlocks = 0;
+    for (int objId = 0; objId < ThePaths.m_numMapObjects; objId++) {
+        if (ThePaths.m_objectFlags[objId] & UseInRoadBlock) {
+            if (NumRoadBlocks < 600) {
+                InOrOut[NumRoadBlocks] = true;
+                RoadBlockObjects[NumRoadBlocks] = objId;
+                NumRoadBlocks++;
+            } else {
+#ifndef MASTER
+                printf("Not enough room for the potential roadblocks\n");
+#endif
+                // FIX: Don't iterate loop after NUMROADBLOCKS
+                return;
+            }
+        }
+    }
+
+}
+
+STARTPATCHES
+	InjectHook(0x436F50, &CRoadBlocks::Init, PATCH_JUMP);
+ENDPATCHES
\ No newline at end of file
diff --git a/src/control/RoadBlocks.h b/src/control/RoadBlocks.h
index b1bb3589..3f5868e7 100644
--- a/src/control/RoadBlocks.h
+++ b/src/control/RoadBlocks.h
@@ -6,6 +6,10 @@ class CVehicle;
 class CRoadBlocks
 {
 public:
+	static int16 (&NumRoadBlocks);
+	static int16 (&RoadBlockObjects)[NUMROADBLOCKS];
+	static bool (&InOrOut)[NUMROADBLOCKS];
+
 	static void Init(void);
 	static void GenerateRoadBlockCopsForCar(CVehicle*, int32, int16);
 	static void GenerateRoadBlocks(void);
diff --git a/src/control/SceneEdit.cpp b/src/control/SceneEdit.cpp
index 28b4ea6c..3e55d431 100644
--- a/src/control/SceneEdit.cpp
+++ b/src/control/SceneEdit.cpp
@@ -2,5 +2,11 @@
 #include "patcher.h"
 #include "SceneEdit.h"
 
+bool &CSceneEdit::m_bEditOn = *(bool*)0x95CD77;
+int32 &CSceneEdit::m_bCameraFollowActor = *(int*)0x940590;
+bool &CSceneEdit::m_bRecording = *(bool*)0x95CD1F;
+CVector &CSceneEdit::m_vecCurrentPosition = *(CVector*)0x943064;
+CVector &CSceneEdit::m_vecCamHeading = *(CVector*)0x942F8C;
+
 WRAPPER void CSceneEdit::Update(void) { EAXJMP(0x585570); }
 WRAPPER void CSceneEdit::Init(void) { EAXJMP(0x585170); }
diff --git a/src/control/SceneEdit.h b/src/control/SceneEdit.h
index e9209b90..0de72c19 100644
--- a/src/control/SceneEdit.h
+++ b/src/control/SceneEdit.h
@@ -3,6 +3,12 @@
 class CSceneEdit
 {
 public:
+	static bool &m_bEditOn;
+	static int32 &m_bCameraFollowActor;
+	static bool &m_bRecording;
+	static CVector &m_vecCurrentPosition;
+	static CVector &m_vecCamHeading;
+
 	static void Update(void);
 	static void Init(void);
 };
diff --git a/src/control/Script.cpp b/src/control/Script.cpp
index 4aeacf3f..f96ec060 100644
--- a/src/control/Script.cpp
+++ b/src/control/Script.cpp
@@ -1,3 +1,4 @@
+#define WITHWINDOWS	// for our script loading hack
 #include "common.h"
 #include "patcher.h"
 
@@ -52,6 +53,8 @@
 #include "Restart.h"
 #include "Replay.h"
 #include "RpAnimBlend.h"
+#include "AnimBlendAssociation.h"
+#include "Fire.h"
 #include "Rubbish.h"
 #include "Shadows.h"
 #include "SpecialFX.h"
@@ -64,6 +67,7 @@
 #include "Weather.h"
 #include "World.h"
 #include "Zones.h"
+#include "Radar.h"
 
 #define PICKUP_PLACEMENT_OFFSET 0.5f
 #define PED_FIND_Z_OFFSET 5.0f
@@ -2838,9 +2842,6 @@ int8 CRunningScript::ProcessCommands200To299(int32 command)
 	return -1;
 }
 
-#if 0
-WRAPPER int8 CRunningScript::ProcessCommand300To399(int32 command) { EAXJMP(0x43ED30); }
-#else
 int8 CRunningScript::ProcessCommands300To399(int32 command)
 {
 	switch (command) {
@@ -3072,7 +3073,7 @@ int8 CRunningScript::ProcessCommands300To399(int32 command)
 	{
 		CollectParameters(&m_nIp, 3);
 		// ScriptParams[0] is unused.
-		TheCamera.TakeControl(nil, ScriptParams[1], ScriptParams[2], CAM_CONTROLLER_1);
+		TheCamera.TakeControl(nil, ScriptParams[1], ScriptParams[2], CAMCONTROL_SCRIPT);
 		return 0;
 	}
 	case COMMAND_POINT_CAMERA_AT_CAR:
@@ -3080,7 +3081,7 @@ int8 CRunningScript::ProcessCommands300To399(int32 command)
 		CollectParameters(&m_nIp, 3);
 		CVehicle* pVehicle = CPools::GetVehiclePool()->GetAt(ScriptParams[0]);
 		assert(pVehicle);
-		TheCamera.TakeControl(pVehicle, ScriptParams[1], ScriptParams[2], CAM_CONTROLLER_1);
+		TheCamera.TakeControl(pVehicle, ScriptParams[1], ScriptParams[2], CAMCONTROL_SCRIPT);
 		return 0;
 	}
 	case COMMAND_POINT_CAMERA_AT_CHAR:
@@ -3088,7 +3089,7 @@ int8 CRunningScript::ProcessCommands300To399(int32 command)
 		CollectParameters(&m_nIp, 3);
 		CPed* pPed = CPools::GetPedPool()->GetAt(ScriptParams[0]);
 		assert(pPed);
-		TheCamera.TakeControl(pPed, ScriptParams[1], ScriptParams[2], CAM_CONTROLLER_1);
+		TheCamera.TakeControl(pPed, ScriptParams[1], ScriptParams[2], CAMCONTROL_SCRIPT);
 		return 0;
 	}
 	case COMMAND_RESTORE_CAMERA:
@@ -3139,7 +3140,7 @@ int8 CRunningScript::ProcessCommands300To399(int32 command)
 		CVector pos = *(CVector*)&ScriptParams[0];
 		if (pos.z <= MAP_Z_LOW_LIMIT)
 			pos.z = CWorld::FindGroundZForCoord(pos.x, pos.y);
-		TheCamera.TakeControlNoEntity(pos, ScriptParams[3], CAM_CONTROLLER_1);
+		TheCamera.TakeControlNoEntity(pos, ScriptParams[3], CAMCONTROL_SCRIPT);
 		return 0;
 	}
 	case COMMAND_ADD_BLIP_FOR_CAR_OLD:
@@ -3572,11 +3573,7 @@ int8 CRunningScript::ProcessCommands300To399(int32 command)
 	}
 	return -1;
 }
-#endif
 
-#if 0
-WRAPPER int8 CRunningScript::ProcessCommands400To499(int32 command) { EAXJMP(0x440CB0); }
-#else
 int8 CRunningScript::ProcessCommands400To499(int32 command)
 {
 	switch (command) {
@@ -4366,11 +4363,7 @@ int8 CRunningScript::ProcessCommands400To499(int32 command)
 	}
 	return -1;
 }
-#endif
 
-#if 0
-WRAPPER int8 CRunningScript::ProcessCommands500To599(int32 command) { EAXJMP(0x4429C0); }
-#else
 int8 CRunningScript::ProcessCommands500To599(int32 command)
 {
 	switch (command) {
@@ -4629,7 +4622,7 @@ int8 CRunningScript::ProcessCommands500To599(int32 command)
 			infZ = *(float*)&ScriptParams[5];
 			supZ = *(float*)&ScriptParams[2];
 		}
-		ScriptParams[0] = CGarages::AddOne(infX, infY, infZ, supX, supY, supZ, ScriptParams[6], 0);
+		ScriptParams[0] = CGarages::AddOne(infX, infY, infZ, supX, supY, supZ, (eGarageType)ScriptParams[6], 0);
 		StoreParameters(&m_nIp, 1);
 		return 0;
 	}
@@ -4654,7 +4647,7 @@ int8 CRunningScript::ProcessCommands500To599(int32 command)
 			infZ = *(float*)&ScriptParams[5];
 			supZ = *(float*)&ScriptParams[2];
 		}
-		ScriptParams[0] = CGarages::AddOne(infX, infY, infZ, supX, supY, supZ, ScriptParams[6], ScriptParams[7]);
+		ScriptParams[0] = CGarages::AddOne(infX, infY, infZ, supX, supY, supZ, (eGarageType)ScriptParams[6], ScriptParams[7]);
 		StoreParameters(&m_nIp, 1);
 		return 0;
 	}
@@ -4678,7 +4671,7 @@ int8 CRunningScript::ProcessCommands500To599(int32 command)
 		return 0;
 	case COMMAND_SET_FREE_BOMBS:
 		CollectParameters(&m_nIp, 1);
-		CGarages::BombsAreFree = (ScriptParams[0] != 0);
+		CGarages::SetFreeBombs(ScriptParams[0] != 0);
 		return 0;
 #ifdef GTA_PS2
 	case COMMAND_SET_POWERPOINT:
@@ -5197,11 +5190,7 @@ int8 CRunningScript::ProcessCommands500To599(int32 command)
 	}
 	return -1;
 }
-#endif
 
-#if 0
-WRAPPER int8 CRunningScript::ProcessCommands600To699(int32 command) { EAXJMP(0x444B20); }
-#else
 int8 CRunningScript::ProcessCommands600To699(int32 command)
 {
 	switch (command){
@@ -5555,11 +5544,7 @@ int8 CRunningScript::ProcessCommands600To699(int32 command)
 	}
 	return -1;
 }
-#endif
 
-#if 0
-WRAPPER int8 CRunningScript::ProcessCommands700To799(int32 command) { EAXJMP(0x4458A0); }
-#else
 int8 CRunningScript::ProcessCommands700To799(int32 command)
 {
 	switch (command){
@@ -6425,11 +6410,6 @@ int8 CRunningScript::ProcessCommands700To799(int32 command)
 	}
 	return -1;
 }
-#endif
-
-#if 0
-WRAPPER int8 CRunningScript::ProcessCommands800To899(int32 command) { EAXJMP(0x448240); }
-#else
 int8 CRunningScript::ProcessCommands800To899(int32 command)
 {
 	CMatrix tmp_matrix;
@@ -6682,7 +6662,7 @@ int8 CRunningScript::ProcessCommands800To899(int32 command)
 	}
 	case COMMAND_SET_FREE_RESPRAYS:
 		CollectParameters(&m_nIp, 1);
-		CGarages::RespraysAreFree = (ScriptParams[0] != 0);
+		CGarages::SetFreeResprays(ScriptParams[0] != 0);
 		return 0;
 	case COMMAND_SET_PLAYER_VISIBLE:
 	{
@@ -7130,13 +7110,13 @@ int8 CRunningScript::ProcessCommands800To899(int32 command)
 	case COMMAND_OPEN_GARAGE:
 	{
 		CollectParameters(&m_nIp, 1);
-		CGarages::Garages[ScriptParams[0]].OpenThisGarage();
+		CGarages::OpenGarage(ScriptParams[0]);
 		return 0;
 	}
 	case COMMAND_CLOSE_GARAGE:
 	{
 		CollectParameters(&m_nIp, 1);
-		CGarages::Garages[ScriptParams[0]].CloseThisGarage();
+		CGarages::CloseGarage(ScriptParams[1]);
 		return 0;
 	}
 	case COMMAND_WARP_CHAR_FROM_CAR_TO_COORD:
@@ -7511,11 +7491,7 @@ int8 CRunningScript::ProcessCommands800To899(int32 command)
 	}
 	return -1;
 }
-#endif
 
-#if 0
-WRAPPER int8 CRunningScript::ProcessCommands900To999(int32 command) { EAXJMP(0x44CB80); }
-#else
 int8 CRunningScript::ProcessCommands900To999(int32 command)
 {
 	char str[52];
@@ -8416,7 +8392,6 @@ int8 CRunningScript::ProcessCommands900To999(int32 command)
 	}
 	return -1;
 }
-#endif
 
 int8 CRunningScript::ProcessCommands1000To1099(int32 command)
 {
@@ -9815,7 +9790,7 @@ void CTheScripts::UndoBuildingSwaps()
 	}
 }
 
-void CTheScripts::UndoEntityVisibilitySettings()
+void CTheScripts::UndoEntityInvisibilitySettings()
 {
 	for (int i = 0; i < MAX_NUM_INVISIBILITY_SETTINGS; i++) {
 		if (InvisibilitySettingArray[i]) {
@@ -11653,7 +11628,7 @@ InjectHook(0x439040, &CTheScripts::Process, PATCH_JUMP);
 InjectHook(0x439400, &CTheScripts::StartTestScript, PATCH_JUMP);
 InjectHook(0x439410, &CTheScripts::IsPlayerOnAMission, PATCH_JUMP);
 InjectHook(0x44FD10, &CTheScripts::UndoBuildingSwaps, PATCH_JUMP);
-InjectHook(0x44FD60, &CTheScripts::UndoEntityVisibilitySettings, PATCH_JUMP);
+InjectHook(0x44FD60, &CTheScripts::UndoEntityInvisibilitySettings, PATCH_JUMP);
 InjectHook(0x4534E0, &CTheScripts::ScriptDebugLine3D, PATCH_JUMP);
 InjectHook(0x453550, &CTheScripts::RenderTheScriptDebugLines, PATCH_JUMP);
 InjectHook(0x4535E0, &CTheScripts::SaveAllScripts, PATCH_JUMP);
diff --git a/src/control/Script.h b/src/control/Script.h
index b6844b6c..fbcdce48 100644
--- a/src/control/Script.h
+++ b/src/control/Script.h
@@ -281,7 +281,7 @@ public:
 	static void ClearSpaceForMissionEntity(const CVector&, CEntity*);
 
 	static void UndoBuildingSwaps();
-	static void UndoEntityVisibilitySettings();
+	static void UndoEntityInvisibilitySettings();
 
 	static void ScriptDebugLine3D(float x1, float y1, float z1, float x2, float y2, float z2, uint32 col, uint32 col2);
 	static void RenderTheScriptDebugLines();