14 files changed, 2334 insertions, 130 deletions

diff --git a/src/vehicles/Automobile.cpp b/src/vehicles/Automobile.cpp
index 7d3f8ee3..fb42e6e6 100644
--- a/src/vehicles/Automobile.cpp
+++ b/src/vehicles/Automobile.cpp
@@ -1,32 +1,187 @@
 #include "common.h"
+#include "main.h"
 #include "patcher.h"
 #include "General.h"
+#include "RwHelper.h"
+#include "Pad.h"
 #include "ModelIndices.h"
 #include "VisibilityPlugins.h"
 #include "DMAudio.h"
 #include "Camera.h"
 #include "Darkel.h"
+#include "Rubbish.h"
 #include "Fire.h"
 #include "Explosion.h"
+#include "Particle.h"
 #include "World.h"
 #include "SurfaceTable.h"
 #include "HandlingMgr.h"
+#include "Record.h"
+#include "Remote.h"
+#include "Population.h"
 #include "CarCtrl.h"
+#include "CarAI.h"
+#include "Garages.h"
 #include "PathFind.h"
+#include "AnimManager.h"
+#include "RpAnimBlend.h"
 #include "Ped.h"
 #include "PlayerPed.h"
 #include "Object.h"
 #include "Automobile.h"
 
+bool bAllCarCheat;	// unused
+
 RwObject *GetCurrentAtomicObjectCB(RwObject *object, void *data);
 
 bool &CAutomobile::m_sAllTaxiLights = *(bool*)0x95CD21;
 
-WRAPPER CAutomobile* CAutomobile::ctor(int, uint8) { EAXJMP(0x52C6B0); }
-
-CAutomobile::CAutomobile(int mi, uint8 CreatedBy)
+CAutomobile::CAutomobile(int32 id, uint8 CreatedBy)
+ : CVehicle(CreatedBy)
 {
-	ctor(mi, CreatedBy);
+	int i;
+
+	m_vehType = VEHICLE_TYPE_CAR;
+
+	CVehicleModelInfo *mi = (CVehicleModelInfo*)CModelInfo::GetModelInfo(id);
+	m_fFireBlowUpTimer = 0.0f;
+	field_4E0 = 0;
+	bTaxiLight = m_sAllTaxiLights;
+	m_auto_flagA20 = false;
+	m_auto_flagA40 = false;
+	m_auto_flagA80 = false;
+
+	SetModelIndex(id);
+
+	pHandling = mod_HandlingManager.GetHandlingData((eHandlingId)mi->m_handlingId);
+
+	field_49C = 20.0f;
+	field_4D8 = 0;
+
+	mi->ChooseVehicleColour(m_currentColour1, m_currentColour2);
+
+	bIsVan = !!(pHandling->Flags & HANDLING_IS_VAN);
+	bIsBig = !!(pHandling->Flags & HANDLING_IS_BIG);
+	bIsBus = !!(pHandling->Flags & HANDLING_IS_BUS);
+	bLowVehicle = !!(pHandling->Flags & HANDLING_IS_LOW);
+
+	// Doors
+	if(bIsBus){
+		Doors[DOOR_FRONT_LEFT].Init(-HALFPI, 0.0f, 0, 2);
+		Doors[DOOR_FRONT_RIGHT].Init(0.0f, HALFPI, 1, 2);
+	}else{
+		Doors[DOOR_FRONT_LEFT].Init(-PI*0.4f, 0.0f, 0, 2);
+		Doors[DOOR_FRONT_RIGHT].Init(0.0f, PI*0.4f, 1, 2);
+	}
+	if(bIsVan){
+		Doors[DOOR_REAR_LEFT].Init(-HALFPI, 0.0f, 1, 2);
+		Doors[DOOR_REAR_RIGHT].Init(0.0f, HALFPI, 0, 2);
+	}else{
+		Doors[DOOR_REAR_LEFT].Init(-PI*0.4f, 0.0f, 0, 2);
+		Doors[DOOR_REAR_RIGHT].Init(0.0f, PI*0.4f, 1, 2);
+	}
+	if(pHandling->Flags & HANDLING_REV_BONNET)
+		Doors[DOOR_BONNET].Init(-PI*0.3f, 0.0f, 1, 0);
+	else
+		Doors[DOOR_BONNET].Init(0.0f, PI*0.3f, 1, 0);
+	if(pHandling->Flags & HANDLING_HANGING_BOOT)
+		Doors[DOOR_BOOT].Init(PI*0.4f, 0.0f, 0, 0);
+	else if(pHandling->Flags & HANDLING_TAILGATE_BOOT)
+		Doors[DOOR_BOOT].Init(0.0, HALFPI, 1, 0);
+	else
+		Doors[DOOR_BOOT].Init(-PI*0.3f, 0.0f, 1, 0);
+	if(pHandling->Flags & HANDLING_NO_DOORS){
+		Damage.SetDoorStatus(DOOR_FRONT_LEFT, DOOR_STATUS_MISSING);
+		Damage.SetDoorStatus(DOOR_FRONT_RIGHT, DOOR_STATUS_MISSING);
+		Damage.SetDoorStatus(DOOR_REAR_LEFT, DOOR_STATUS_MISSING);
+		Damage.SetDoorStatus(DOOR_REAR_RIGHT, DOOR_STATUS_MISSING);
+	}
+
+	for(i = 0; i < 6; i++)
+		m_randomValues[i] = CGeneral::GetRandomNumberInRange(-0.15f, 0.15f);
+
+	m_fMass = pHandling->fMass;
+	m_fTurnMass = pHandling->fTurnMass;
+	m_vecCentreOfMass = pHandling->CentreOfMass;
+	m_fAirResistance = pHandling->Dimension.x*pHandling->Dimension.z/m_fMass;
+	m_fElasticity = 0.05f;
+	m_fBuoyancy = pHandling->fBuoyancy;
+
+	m_nBusDoorTimerEnd = 0;
+	m_nBusDoorTimerStart = 0;
+
+	m_fSteerAngle = 0.0f;
+	m_fGasPedal = 0.0f;
+	m_fBrakePedal = 0.0f;
+	m_pSetOnFireEntity = nil;
+	field_594 = 0;
+	bNotDamagedUpsideDown = false;
+	bMoreResistantToDamage = false;
+	m_fVelocityChangeForAudio = 0.f;
+	field_4E2 = 0;
+
+	for(i = 0; i < 4; i++){
+		m_aGroundPhysical[i] = nil;
+		m_aGroundOffset[i] = CVector(0.0f, 0.0f, 0.0f);
+		m_aSuspensionSpringRatio[i] = 1.0f;
+		m_aSuspensionSpringRatioPrev[i] = m_aSuspensionSpringRatio[i];
+		m_aWheelTimer[i] = 0.0f;
+		m_aWheelRotation[i] = 0.0f;
+		m_aWheelSpeed[i] = 0.0f;
+		m_aWheelState[i] = WHEEL_STATE_0;
+		m_aWheelSkidmarkMuddy[i] = false;
+		m_aWheelSkidmarkBloody[i] = false;
+	}
+
+	m_nWheelsOnGround = 0;
+	m_nDriveWheelsOnGround = 0;
+	m_nDriveWheelsOnGroundPrev = 0;
+	m_fHeightAboveRoad = 0.0f;
+	m_fTraction = 1.0f;
+
+	CColModel *colModel = mi->GetColModel();
+	if(colModel->lines == nil){
+		colModel->lines = (CColLine*)RwMalloc(4*sizeof(CColLine));
+		colModel->numLines = 4;
+	}
+
+	SetupSuspensionLines();
+
+	m_status = STATUS_SIMPLE;
+	bUseCollisionRecords = true;
+
+	m_nNumPassengers = 0;
+
+	m_bombType = CARBOMB_NONE;
+	bHadDriver = false;
+	m_pBombRigger = nil;
+
+	if(m_nDoorLock == CARLOCK_UNLOCKED &&
+	   (id == MI_POLICE || id == MI_ENFORCER || id == MI_RHINO))
+		m_nDoorLock = CARLOCK_LOCKED_INITIALLY;
+
+	m_fCarGunLR = 0.0f;
+	m_fCarGunUD = 0.05f;
+	m_fWindScreenRotation = 0.0f;
+	m_weaponDoorTimerLeft = 0.0f;
+	m_weaponDoorTimerRight = m_weaponDoorTimerLeft;
+
+	if(GetModelIndex() == MI_DODO){
+		RpAtomicSetFlags(GetFirstObject(m_aCarNodes[CAR_WHEEL_LF]), 0);
+		CMatrix mat1;
+		mat1.Attach(RwFrameGetMatrix(m_aCarNodes[CAR_WHEEL_RF]));
+		CMatrix mat2(RwFrameGetMatrix(m_aCarNodes[CAR_WHEEL_LF]));
+		mat1.GetPosition() += CVector(mat2.GetPosition().x + 0.1f, 0.0f, mat2.GetPosition().z);
+		mat1.UpdateRW();
+	}else if(GetModelIndex() == MI_MIAMI_SPARROW || GetModelIndex() == MI_MIAMI_RCRAIDER){
+		RpAtomicSetFlags(GetFirstObject(m_aCarNodes[CAR_WHEEL_LF]), 0);
+		RpAtomicSetFlags(GetFirstObject(m_aCarNodes[CAR_WHEEL_RF]), 0);
+		RpAtomicSetFlags(GetFirstObject(m_aCarNodes[CAR_WHEEL_LB]), 0);
+		RpAtomicSetFlags(GetFirstObject(m_aCarNodes[CAR_WHEEL_RB]), 0);
+	}else if(GetModelIndex() == MI_RHINO){
+		bExplosionProof = true;
+		bBulletProof = true;
+	}
 }
 
 
@@ -37,7 +192,998 @@ CAutomobile::SetModelIndex(uint32 id)
 	SetupModelNodes();
 }
 
-WRAPPER void CAutomobile::ProcessControl(void) { EAXJMP(0x531470); }
+CVector vecDAMAGE_ENGINE_POS_SMALL(-0.1f, -0.1f, 0.0f);
+CVector vecDAMAGE_ENGINE_POS_BIG(-0.5f, -0.3f, 0.0f);
+
+void
+CAutomobile::ProcessControl(void)
+{
+	int i;
+	CColModel *colModel;
+
+	if(m_veh_flagC80)
+		colModel = &CWorld::Players[CWorld::PlayerInFocus].m_ColModel;
+	else
+		colModel = GetColModel();
+	bWarnedPeds = false;
+
+	// skip if the collision isn't for the current level
+	if(colModel->level > LEVEL_NONE && colModel->level != CCollision::ms_collisionInMemory)
+		return;
+
+	// Improve grip of vehicles in certain cases
+	bool strongGrip1 = false;
+	bool strongGrip2 = false;
+	if(FindPlayerVehicle() && this != FindPlayerVehicle()){
+		switch(AutoPilot.m_nCarMission){
+		case MISSION_RAMPLAYER_FARAWAY:
+		case MISSION_RAMPLAYER_CLOSE:
+		case MISSION_BLOCKPLAYER_FARAWAY:
+		case MISSION_BLOCKPLAYER_CLOSE:
+			if(FindPlayerSpeed().Magnitude() > 0.3f){
+				strongGrip1 = true;
+				if(FindPlayerSpeed().Magnitude() > 0.4f){
+					if(m_vecMoveSpeed.Magnitude() < 0.3f)
+						strongGrip2 = true;
+				}else{
+					if((GetPosition() - FindPlayerCoors()).Magnitude() > 50.0f)
+						strongGrip2 = true;
+				}
+			}
+		}
+	}
+
+	if(bIsBus)
+		ProcessAutoBusDoors();
+
+	ProcessCarAlarm();
+
+	// Scan if this car is committing a crime that the police can see
+	if(m_status != STATUS_ABANDONED && m_status != STATUS_WRECKED &&
+	   m_status != STATUS_PLAYER && m_status != STATUS_PLAYER_REMOTE && m_status != STATUS_PLAYER_DISABLED){
+		switch(GetModelIndex())
+		case MI_FBICAR:
+		case MI_POLICE:
+		case MI_ENFORCER:
+		case MI_SECURICA:
+		case MI_RHINO:
+		case MI_BARRACKS:
+			ScanForCrimes();
+	}
+
+	// Process driver
+	if(pDriver){
+		if(!bHadDriver && m_bombType == CARBOMB_ONIGNITIONACTIVE){
+			// If someone enters the car and there is a bomb, detonate
+			m_nBombTimer = 1000;
+			m_pBlowUpEntity = m_pBombRigger;
+			if(m_pBlowUpEntity)
+				m_pBlowUpEntity->RegisterReference((CEntity**)&m_pBlowUpEntity);
+			DMAudio.PlayOneShot(m_audioEntityId, SOUND_BOMB_TICK, 1.0f);
+		}
+		bHadDriver = true;
+
+		if(IsUpsideDown() && CanPedEnterCar()){
+			if(!pDriver->IsPlayer() &&
+			   !(pDriver->m_leader && pDriver->m_leader->bInVehicle) &&
+			   pDriver->CharCreatedBy != MISSION_CHAR)
+				pDriver->SetObjective(OBJECTIVE_LEAVE_VEHICLE, this);
+		}
+	}else
+		bHadDriver = false;
+
+	// Process passengers
+	if(m_nNumPassengers != 0 && IsUpsideDown() && CanPedEnterCar()){
+		for(i = 0; i < m_nNumMaxPassengers; i++)
+			if(pPassengers[i])
+				if(!pPassengers[i]->IsPlayer() &&
+				   !(pPassengers[i]->m_leader && pPassengers[i]->m_leader->bInVehicle) &&
+				   pPassengers[i]->CharCreatedBy != MISSION_CHAR)
+					pPassengers[i]->SetObjective(OBJECTIVE_LEAVE_VEHICLE, this);
+	}
+
+	CRubbish::StirUp(this);
+
+	// blend in clump
+	int clumpAlpha = CVisibilityPlugins::GetClumpAlpha((RpClump*)m_rwObject);
+	if(bFadeOut){
+		clumpAlpha -= 8;
+		if(clumpAlpha < 0)
+			clumpAlpha = 0;
+	}else if(clumpAlpha < 255){
+		clumpAlpha += 16;
+		if(clumpAlpha > 255)
+			clumpAlpha = 255;
+	}
+	CVisibilityPlugins::SetClumpAlpha((RpClump*)m_rwObject, clumpAlpha);
+
+	AutoPilot.m_flag1 = false;
+	AutoPilot.m_flag2 = false;
+
+	// Set Center of Mass to make car more stable
+	if(strongGrip1 || bCheat3)
+		m_vecCentreOfMass.z = 0.3f*m_aSuspensionSpringLength[0] + -1.0*m_fHeightAboveRoad;
+	else if(pHandling->Flags & HANDLING_NONPLAYER_STABILISER && m_status == STATUS_PHYSICS)
+		m_vecCentreOfMass.z = pHandling->CentreOfMass.z - 0.2f*pHandling->Dimension.z;
+	else
+		m_vecCentreOfMass.z = pHandling->CentreOfMass.z;
+
+	// Process depending on status
+
+	bool playerRemote = false;
+	switch(m_status){
+	case STATUS_PLAYER_REMOTE:
+		if(CPad::GetPad(0)->WeaponJustDown()){
+			BlowUpCar(FindPlayerPed());
+			CRemote::TakeRemoteControlledCarFromPlayer();
+		}
+
+		if(GetModelIndex() == MI_RCBANDIT){
+			CVector pos = GetPosition();
+			// FindPlayerCoors unused
+			if(RcbanditCheckHitWheels() || bIsInWater || CPopulation::IsPointInSafeZone(&pos)){
+				if(CPopulation::IsPointInSafeZone(&pos))
+					CGarages::TriggerMessage("HM2_5", -1, 5000, -1);
+				CRemote::TakeRemoteControlledCarFromPlayer();
+				BlowUpCar(FindPlayerPed());
+			}
+		}
+
+		if(CWorld::Players[CWorld::PlayerInFocus].m_pRemoteVehicle == this)
+			playerRemote = true;
+		// fall through
+	case STATUS_PLAYER:
+		if(playerRemote ||
+		   pDriver && pDriver->GetPedState() != PED_EXIT_CAR && pDriver->GetPedState() != PED_DRAG_FROM_CAR){
+			// process control input if controlled by player
+			if(playerRemote || pDriver->m_nPedType == PEDTYPE_PLAYER1)
+				ProcessControlInputs(0);
+
+			PruneReferences();
+
+			if(m_status == STATUS_PLAYER && CRecordDataForChase::Status != RECORDSTATE_1)
+				DoDriveByShootings();
+		}
+		break;
+
+	case STATUS_SIMPLE:
+		CCarAI::UpdateCarAI(this);
+		CPhysical::ProcessControl();
+		CCarCtrl::UpdateCarOnRails(this);
+
+		m_nWheelsOnGround = 4;
+		m_nDriveWheelsOnGroundPrev = m_nDriveWheelsOnGround;
+		m_nDriveWheelsOnGround = 4;
+
+		pHandling->Transmission.CalculateGearForSimpleCar(AutoPilot.m_fMaxTrafficSpeed/50.0f, m_nCurrentGear);
+
+		{
+		float wheelRot = ProcessWheelRotation(WHEEL_STATE_0, GetForward(), m_vecMoveSpeed, 0.35f);
+		for(i = 0; i < 4; i++)
+			m_aWheelRotation[i] += wheelRot;
+		}
+
+		PlayHornIfNecessary();
+		ReduceHornCounter();
+		bVehicleColProcessed = false;
+		// that's all we do for simple vehicles
+		return;
+
+	case STATUS_PHYSICS:
+		CCarAI::UpdateCarAI(this);
+		CCarCtrl::SteerAICarWithPhysics(this);
+		PlayHornIfNecessary();
+		break;
+
+	case STATUS_ABANDONED:
+		m_fBrakePedal = 0.2f;
+		bIsHandbrakeOn = false;
+
+		m_fSteerAngle = 0.0f;
+		m_fGasPedal = 0.0f;
+		m_nCarHornTimer = 0;
+		break;
+
+	case STATUS_WRECKED:
+		m_fBrakePedal = 0.05f;
+		bIsHandbrakeOn = true;
+
+		m_fSteerAngle = 0.0f;
+		m_fGasPedal = 0.0f;
+		m_nCarHornTimer = 0;
+		break;
+
+	case STATUS_PLAYER_DISABLED:
+		m_fBrakePedal = 1.0f;
+		bIsHandbrakeOn = true;
+
+		m_fSteerAngle = 0.0f;
+		m_fGasPedal = 0.0f;
+		m_nCarHornTimer = 0;
+		break;
+	}
+
+	// what's going on here?
+	if(GetPosition().z < -0.6f &&
+	   Abs(m_vecMoveSpeed.x) < 0.05f &&
+	   Abs(m_vecMoveSpeed.y) < 0.05f)
+		m_vecTurnSpeed *= Pow(0.95f, CTimer::GetTimeStep());
+
+	// Skip physics if object is found to have been static recently
+	bool skipPhysics = false;
+	if(!bIsStuck && (m_status == STATUS_ABANDONED || m_status == STATUS_WRECKED)){
+		bool makeStatic = false;
+		float moveSpeedLimit, turnSpeedLimit, distanceLimit;
+
+		if(!bVehicleColProcessed &&
+		   m_vecMoveSpeed.IsZero() &&
+		// BUG? m_aSuspensionSpringRatioPrev[3] is checked twice in the game. also, why 3?
+		   m_aSuspensionSpringRatioPrev[3] != 1.0f)
+			makeStatic = true;
+
+		if(m_status == STATUS_WRECKED){
+			moveSpeedLimit = 0.006f;
+			turnSpeedLimit = 0.0015f;
+			distanceLimit = 0.015f;
+		}else{
+			moveSpeedLimit = 0.003f;
+			turnSpeedLimit = 0.0009f;
+			distanceLimit = 0.005f;
+		}
+
+		m_vecMoveSpeedAvg = (m_vecMoveSpeedAvg + m_vecMoveSpeed)/2.0f;
+		m_vecTurnSpeedAvg = (m_vecTurnSpeedAvg + m_vecTurnSpeed)/2.0f;
+
+		if(m_vecMoveSpeedAvg.MagnitudeSqr() <= sq(moveSpeedLimit*CTimer::GetTimeStep()) &&
+		   m_vecTurnSpeedAvg.MagnitudeSqr() <= sq(turnSpeedLimit*CTimer::GetTimeStep()) &&
+		   m_fDistanceTravelled < distanceLimit ||
+		   makeStatic){
+			m_nStaticFrames++;
+
+			if(m_nStaticFrames > 10 || makeStatic)
+				if(!CCarCtrl::MapCouldMoveInThisArea(GetPosition().x, GetPosition().y)){
+					if(!makeStatic || m_nStaticFrames > 10)
+						m_nStaticFrames = 10;
+
+					skipPhysics = true;
+
+					m_vecMoveSpeed = CVector(0.0f, 0.0f, 0.0f);
+					m_vecTurnSpeed = CVector(0.0f, 0.0f, 0.0f);
+				}
+		}else
+			m_nStaticFrames = 0;
+	}
+
+	// Postpone
+	for(i = 0; i < 4; i++)
+		if(m_aGroundPhysical[i] && !CWorld::bForceProcessControl && m_aGroundPhysical[i]->bIsInSafePosition){
+			bWasPostponed = true;
+			return;
+		}
+
+	VehicleDamage(0.0f, 0);
+
+	// special control
+	switch(GetModelIndex()){
+	case MI_FIRETRUCK:
+		FireTruckControl();
+		break;
+	case MI_RHINO:
+		TankControl();
+		BlowUpCarsInPath();
+		break;
+	case MI_YARDIE:
+	// beta also had esperanto here it seems
+		HydraulicControl();
+		break;
+	default:
+		if(CVehicle::bCheat3){
+			// Make vehicle jump when horn is sounded
+			if(m_status == STATUS_PLAYER && m_vecMoveSpeed.MagnitudeSqr() > sq(0.2f) &&
+			// BUG: game checks [0] four times, instead of all wheels
+			   m_aSuspensionSpringRatio[0] < 1.0f &&
+			   CPad::GetPad(0)->HornJustDown()){
+
+				DMAudio.PlayOneShot(m_audioEntityId, SOUND_CAR_HYDRALIC_1, 0.0f);
+				DMAudio.PlayOneShot(m_audioEntityId, SOUND_CAR_JUMP, 1.0f);
+
+				CParticle::AddParticle(PARTICLE_ENGINE_STEAM,
+					m_aWheelColPoints[0].point + 0.5f*GetUp(),
+					1.3f*m_vecMoveSpeed, nil, 2.5f);
+				CParticle::AddParticle(PARTICLE_ENGINE_SMOKE,
+					m_aWheelColPoints[0].point + 0.5f*GetUp(),
+					1.2f*m_vecMoveSpeed, nil, 2.0f);
+
+				CParticle::AddParticle(PARTICLE_ENGINE_STEAM,
+					m_aWheelColPoints[2].point + 0.5f*GetUp(),
+					1.3f*m_vecMoveSpeed, nil, 2.5f);
+				CParticle::AddParticle(PARTICLE_ENGINE_SMOKE,
+					m_aWheelColPoints[2].point + 0.5f*GetUp(),
+					1.2f*m_vecMoveSpeed, nil, 2.0f);
+
+				CParticle::AddParticle(PARTICLE_ENGINE_STEAM,
+					m_aWheelColPoints[0].point + 0.5f*GetUp() - GetForward(),
+					1.3f*m_vecMoveSpeed, nil, 2.5f);
+				CParticle::AddParticle(PARTICLE_ENGINE_SMOKE,
+					m_aWheelColPoints[0].point + 0.5f*GetUp() - GetForward(),
+					1.2f*m_vecMoveSpeed, nil, 2.0f);
+
+				CParticle::AddParticle(PARTICLE_ENGINE_STEAM,
+					m_aWheelColPoints[2].point + 0.5f*GetUp() - GetForward(),
+					1.3f*m_vecMoveSpeed, nil, 2.5f);
+				CParticle::AddParticle(PARTICLE_ENGINE_SMOKE,
+					m_aWheelColPoints[2].point + 0.5f*GetUp() - GetForward(),
+					1.2f*m_vecMoveSpeed, nil, 2.0f);
+
+				ApplyMoveForce(CVector(0.0f, 0.0f, 1.0f)*m_fMass*0.4f);
+				ApplyTurnForce(GetUp()*m_fMass*0.035f, GetForward()*1.0f);
+			}
+		}
+		break;
+	}
+
+	float brake;
+	if(skipPhysics){
+		bHasContacted = false;
+		bIsInSafePosition = false;
+		bWasPostponed = false;
+		bHasHitWall = false;
+		m_nCollisionRecords = 0;
+		bHasCollided = false;
+		bVehicleColProcessed = false;
+		m_nDamagePieceType = 0;
+		m_fDamageImpulse = 0.0f;
+		m_pDamageEntity = nil;
+		m_vecTurnFriction = CVector(0.0f, 0.0f, 0.0f);
+		m_vecMoveFriction = CVector(0.0f, 0.0f, 0.0f);
+	}else{
+
+		// This has to be done if ProcessEntityCollision wasn't called
+		if(!bVehicleColProcessed){
+			CMatrix mat(GetMatrix());
+			bIsStuck = false;
+			bHasContacted = false;
+			bIsInSafePosition = false;
+			bWasPostponed = false;
+			bHasHitWall = false;
+			m_fDistanceTravelled = 0.0f;
+			field_EF = false;
+			m_phy_flagA80 = false;
+			ApplyMoveSpeed();
+			ApplyTurnSpeed();
+			for(i = 0; CheckCollision() && i < 5; i++){
+				GetMatrix() = mat;
+				ApplyMoveSpeed();
+				ApplyTurnSpeed();
+			}
+			bIsInSafePosition = true;
+			bIsStuck = false;			
+		}
+
+		CPhysical::ProcessControl();
+
+		ProcessBuoyancy();
+
+		// Rescale spring ratios, i.e. subtract wheel radius
+		for(i = 0; i < 4; i++){
+			// wheel radius in relation to suspension line
+			float wheelRadius = 1.0f - m_aSuspensionSpringLength[i]/m_aSuspensionLineLength[i];
+			// rescale such that 0.0 is fully compressed and 1.0 is fully extended
+			m_aSuspensionSpringRatio[i] = (m_aSuspensionSpringRatio[i]-wheelRadius)/(1.0f-wheelRadius);
+		}
+
+		float fwdSpeed = DotProduct(m_vecMoveSpeed, GetForward());
+		CVector contactPoints[4];	// relative to model
+		CVector contactSpeeds[4];	// speed at contact points
+		CVector springDirections[4];	// normalized, in model space
+
+		for(i = 0; i < 4; i++){
+			// Set spring under certain circumstances
+			if(Damage.GetWheelStatus(i) == WHEEL_STATUS_MISSING)
+				m_aSuspensionSpringRatio[i] = 1.0f;
+			else if(Damage.GetWheelStatus(i) == WHEEL_STATUS_BURST){
+				// wheel more bumpy the faster we are
+				if(CGeneral::GetRandomNumberInRange(0, (uint16)(40*fwdSpeed) + 98) < 100){
+					m_aSuspensionSpringRatio[i] += 0.3f*(m_aSuspensionLineLength[i]-m_aSuspensionSpringLength[i])/m_aSuspensionSpringLength[i];
+					if(m_aSuspensionSpringRatio[i] > 1.0f)
+						m_aSuspensionSpringRatio[i] = 1.0f;
+				}
+			}
+
+			// get points and directions if spring is compressed
+			if(m_aSuspensionSpringRatio[i] < 1.0f){
+				contactPoints[i] = m_aWheelColPoints[i].point - GetPosition();
+				springDirections[i] = Multiply3x3(GetMatrix(), colModel->lines[i].p1 - colModel->lines[i].p0);
+				springDirections[i].Normalise();
+			}
+		}
+
+		// Make springs push up vehicle
+		for(i = 0; i < 4; i++){
+			if(m_aSuspensionSpringRatio[i] < 1.0f){
+				float bias = pHandling->fSuspensionBias;
+				if(i == 1 || i == 3)	// rear
+					bias = 1.0f - bias;
+
+				ApplySpringCollision(pHandling->fSuspensionForceLevel,
+					springDirections[i], contactPoints[i],
+					m_aSuspensionSpringRatio[i], bias);
+				m_aWheelSkidmarkMuddy[i] =
+					m_aWheelColPoints[i].surfaceB == SURFACE_GRASS ||
+					m_aWheelColPoints[i].surfaceB == SURFACE_DIRTTRACK ||
+					m_aWheelColPoints[i].surfaceB == SURFACE_SAND;
+			}else{
+				contactPoints[i] = Multiply3x3(GetMatrix(), colModel->lines[i].p1);
+			}
+		}
+
+		// Get speed at contact points
+		for(i = 0; i < 4; i++){
+			contactSpeeds[i] = GetSpeed(contactPoints[i]);
+			if(m_aGroundPhysical[i]){
+				// subtract movement of physical we're standing on
+				contactSpeeds[i] -= m_aGroundPhysical[i]->GetSpeed(m_aGroundOffset[i]);
+#ifndef FIX_BUGS
+				// this shouldn't be reset because we still need it below
+				m_aGroundPhysical[i] = nil;
+#endif
+			}
+		}
+
+		// dampen springs
+		for(i = 0; i < 4; i++)
+			if(m_aSuspensionSpringRatio[i] < 1.0f)
+				ApplySpringDampening(pHandling->fSuspensionDampingLevel,
+					springDirections[i], contactPoints[i], contactSpeeds[i]);
+
+		// Get speed at contact points again
+		for(i = 0; i < 4; i++){
+			contactSpeeds[i] = GetSpeed(contactPoints[i]);
+			if(m_aGroundPhysical[i]){
+				// subtract movement of physical we're standing on
+				contactSpeeds[i] -= m_aGroundPhysical[i]->GetSpeed(m_aGroundOffset[i]);
+				m_aGroundPhysical[i] = nil;
+			}
+		}
+
+
+		bool gripCheat = true;
+		fwdSpeed = DotProduct(m_vecMoveSpeed, GetForward());
+		if(!strongGrip1 && !CVehicle::bCheat3)
+			gripCheat = false;
+		float acceleration = pHandling->Transmission.CalculateDriveAcceleration(m_fGasPedal, m_nCurrentGear, m_fChangeGearTime, fwdSpeed, gripCheat);
+		acceleration /= fForceMultiplier;
+
+		// unused
+		if(GetModelIndex() == MI_MIAMI_RCBARON ||
+		   GetModelIndex() == MI_MIAMI_RCRAIDER ||
+		   GetModelIndex() == MI_MIAMI_SPARROW)
+			acceleration = 0.0f;
+
+		brake = m_fBrakePedal * pHandling->fBrakeDeceleration * CTimer::GetTimeStep();
+		bool neutralHandling = !!(pHandling->Flags & HANDLING_NEUTRALHANDLING);
+		float brakeBiasFront = neutralHandling ? 1.0f : 2.0f*pHandling->fBrakeBias;
+		float brakeBiasRear  = neutralHandling ? 1.0f : 2.0f*(1.0f-pHandling->fBrakeBias);
+		float tractionBiasFront = neutralHandling ? 1.0f : 2.0f*pHandling->fTractionBias;
+		float tractionBiasRear  = neutralHandling ? 1.0f : 2.0f*(1.0f-pHandling->fTractionBias);
+
+		// Count how many wheels are touching the ground
+
+		m_nWheelsOnGround = 0;
+		m_nDriveWheelsOnGroundPrev = m_nDriveWheelsOnGround;
+		m_nDriveWheelsOnGround = 0;
+
+		for(i = 0; i < 4; i++){
+			if(m_aSuspensionSpringRatio[i] < 1.0f)
+				m_aWheelTimer[i] = 4.0f;
+			else
+				m_aWheelTimer[i] = max(m_aWheelTimer[i]-CTimer::GetTimeStep(), 0.0f);
+
+			if(m_aWheelTimer[i] > 0.0f){
+				m_nWheelsOnGround++;
+				switch(pHandling->Transmission.nDriveType){
+				case '4':
+					m_nDriveWheelsOnGround++;
+					break;
+				case 'F':
+					if(i == CARWHEEL_FRONT_LEFT || i == CARWHEEL_FRONT_RIGHT)
+						m_nDriveWheelsOnGround++;
+					break;
+				case 'R':
+					if(i == CARWHEEL_REAR_LEFT || i == CARWHEEL_REAR_RIGHT)
+						m_nDriveWheelsOnGround++;
+					break;
+				}
+			}
+		}
+
+		float traction;
+		if(m_status == STATUS_PHYSICS)
+			traction = 0.004f * m_fTraction;
+		else
+			traction = 0.004f;
+		traction *= pHandling->fTractionMultiplier / 4.0f;
+		traction /= fForceMultiplier;
+		if(CVehicle::bCheat3)
+			traction *= 4.0f;
+
+		if(FindPlayerVehicle() && FindPlayerVehicle() == this){
+			if(CPad::GetPad(0)->WeaponJustDown()){
+				if(m_bombType == CARBOMB_TIMED){
+					m_bombType = CARBOMB_TIMEDACTIVE;
+					m_nBombTimer = 7000;
+					m_pBlowUpEntity = FindPlayerPed();
+					CGarages::TriggerMessage("GA_12", -1, 3000, -1);
+					DMAudio.PlayOneShot(m_audioEntityId, SOUND_BOMB_TIMED_ACTIVATED, 1.0f);
+				}else if(m_bombType == CARBOMB_ONIGNITION){
+					m_bombType = CARBOMB_ONIGNITIONACTIVE;
+					CGarages::TriggerMessage("GA_12", -1, 3000, -1);
+					DMAudio.PlayOneShot(m_audioEntityId, SOUND_BOMB_ONIGNITION_ACTIVATED, 1.0f);
+				}
+			}
+		}else if(strongGrip1 || CVehicle::bCheat3){
+			traction *= 1.2f;
+			acceleration *= 1.4f;
+			if(strongGrip2 || CVehicle::bCheat3){
+				traction *= 1.3f;
+				acceleration *= 1.4f;
+			}
+		}
+
+		static float fThrust;
+		static tWheelState WheelState[4];
+
+		// Process front wheels on ground
+
+		if(m_aWheelTimer[CARWHEEL_FRONT_LEFT] > 0.0f || m_aWheelTimer[CARWHEEL_FRONT_RIGHT] > 0.0f){
+			float s = Sin(m_fSteerAngle);
+			float c = Cos(m_fSteerAngle);
+			CVector wheelFwd = Multiply3x3(GetMatrix(), CVector(-s, c, 0.0f));
+			CVector wheelRight = Multiply3x3(GetMatrix(), CVector(c, s, 0.0f));
+
+			if(m_aWheelTimer[CARWHEEL_FRONT_LEFT] > 0.0f){
+				if(mod_HandlingManager.HasRearWheelDrive(pHandling->nIdentifier))
+					fThrust = 0.0f;
+				else
+					fThrust = acceleration;
+
+				m_aWheelColPoints[CARWHEEL_FRONT_LEFT].surfaceA = SURFACE_RUBBER29;
+				float adhesion = CSurfaceTable::GetAdhesiveLimit(m_aWheelColPoints[CARWHEEL_FRONT_LEFT])*traction;
+				if(m_status == STATUS_PLAYER)
+					adhesion *= CSurfaceTable::GetWetMultiplier(m_aWheelColPoints[CARWHEEL_FRONT_LEFT].surfaceB);
+				WheelState[CARWHEEL_FRONT_LEFT] = m_aWheelState[CARWHEEL_FRONT_LEFT];
+
+				if(Damage.GetWheelStatus(VEHWHEEL_FRONT_LEFT) == WHEEL_STATUS_BURST)
+					ProcessWheel(wheelFwd, wheelRight,
+						contactSpeeds[CARWHEEL_FRONT_LEFT], contactPoints[CARWHEEL_FRONT_LEFT],
+						m_nWheelsOnGround, fThrust,
+						brake*brakeBiasFront,
+						adhesion*tractionBiasFront*Damage.m_fWheelDamageEffect,
+						CARWHEEL_FRONT_LEFT,
+						&m_aWheelSpeed[CARWHEEL_FRONT_LEFT],
+						&WheelState[CARWHEEL_FRONT_LEFT],
+						WHEEL_STATUS_BURST);
+				else
+					ProcessWheel(wheelFwd, wheelRight,
+						contactSpeeds[CARWHEEL_FRONT_LEFT], contactPoints[CARWHEEL_FRONT_LEFT],
+						m_nWheelsOnGround, fThrust,
+						brake*brakeBiasFront,
+						adhesion*tractionBiasFront,
+						CARWHEEL_FRONT_LEFT,
+						&m_aWheelSpeed[CARWHEEL_FRONT_LEFT],
+						&WheelState[CARWHEEL_FRONT_LEFT],
+						WHEEL_STATUS_OK);
+			}
+
+			if(m_aWheelTimer[CARWHEEL_FRONT_RIGHT] > 0.0f){
+				if(mod_HandlingManager.HasRearWheelDrive(pHandling->nIdentifier))
+					fThrust = 0.0f;
+				else
+					fThrust = acceleration;
+
+				m_aWheelColPoints[CARWHEEL_FRONT_RIGHT].surfaceA = SURFACE_RUBBER29;
+				float adhesion = CSurfaceTable::GetAdhesiveLimit(m_aWheelColPoints[CARWHEEL_FRONT_RIGHT])*traction;
+				if(m_status == STATUS_PLAYER)
+					adhesion *= CSurfaceTable::GetWetMultiplier(m_aWheelColPoints[CARWHEEL_FRONT_RIGHT].surfaceB);
+				WheelState[CARWHEEL_FRONT_RIGHT] = m_aWheelState[CARWHEEL_FRONT_RIGHT];
+
+				if(Damage.GetWheelStatus(VEHWHEEL_FRONT_RIGHT) == WHEEL_STATUS_BURST)
+					ProcessWheel(wheelFwd, wheelRight,
+						contactSpeeds[CARWHEEL_FRONT_RIGHT], contactPoints[CARWHEEL_FRONT_RIGHT],
+						m_nWheelsOnGround, fThrust,
+						brake*brakeBiasFront,
+						adhesion*tractionBiasFront*Damage.m_fWheelDamageEffect,
+						CARWHEEL_FRONT_RIGHT,
+						&m_aWheelSpeed[CARWHEEL_FRONT_RIGHT],
+						&WheelState[CARWHEEL_FRONT_RIGHT],
+						WHEEL_STATUS_BURST);
+				else
+					ProcessWheel(wheelFwd, wheelRight,
+						contactSpeeds[CARWHEEL_FRONT_RIGHT], contactPoints[CARWHEEL_FRONT_RIGHT],
+						m_nWheelsOnGround, fThrust,
+						brake*brakeBiasFront,
+						adhesion*tractionBiasFront,
+						CARWHEEL_FRONT_RIGHT,
+						&m_aWheelSpeed[CARWHEEL_FRONT_RIGHT],
+						&WheelState[CARWHEEL_FRONT_RIGHT],
+						WHEEL_STATUS_OK);
+			}
+		}
+
+		// Process front wheels off ground
+
+		if(m_aWheelTimer[CARWHEEL_FRONT_LEFT] <= 0.0f){
+			if(mod_HandlingManager.HasRearWheelDrive(pHandling->nIdentifier) || acceleration == 0.0f)
+				m_aWheelSpeed[CARWHEEL_FRONT_LEFT] *= 0.95f;
+			else{
+				if(acceleration > 0.0f){
+					if(m_aWheelSpeed[CARWHEEL_FRONT_LEFT] < 2.0f)
+						m_aWheelSpeed[CARWHEEL_FRONT_LEFT] -= 0.2f;
+				}else{
+					if(m_aWheelSpeed[CARWHEEL_FRONT_LEFT] > -2.0f)
+						m_aWheelSpeed[CARWHEEL_FRONT_LEFT] += 0.1f;
+				}
+			}
+			m_aWheelRotation[CARWHEEL_FRONT_LEFT] += m_aWheelSpeed[CARWHEEL_FRONT_LEFT];
+		}
+		if(m_aWheelTimer[CARWHEEL_FRONT_RIGHT] <= 0.0f){
+			if(mod_HandlingManager.HasRearWheelDrive(pHandling->nIdentifier) || acceleration == 0.0f)
+				m_aWheelSpeed[CARWHEEL_FRONT_RIGHT] *= 0.95f;
+			else{
+				if(acceleration > 0.0f){
+					if(m_aWheelSpeed[CARWHEEL_FRONT_RIGHT] < 2.0f)
+						m_aWheelSpeed[CARWHEEL_FRONT_RIGHT] -= 0.2f;
+				}else{
+					if(m_aWheelSpeed[CARWHEEL_FRONT_RIGHT] > -2.0f)
+						m_aWheelSpeed[CARWHEEL_FRONT_RIGHT] += 0.1f;
+				}
+			}
+			m_aWheelRotation[CARWHEEL_FRONT_RIGHT] += m_aWheelSpeed[CARWHEEL_FRONT_RIGHT];
+		}
+
+		// Process rear wheels
+
+		if(m_aWheelTimer[CARWHEEL_REAR_LEFT] > 0.0f || m_aWheelTimer[CARWHEEL_REAR_RIGHT] > 0.0f){
+			CVector wheelFwd = GetForward();
+			CVector wheelRight = GetRight();
+
+			if(bIsHandbrakeOn)
+				brake = 20000.0f;
+
+			if(m_aWheelTimer[CARWHEEL_REAR_LEFT] > 0.0f){
+				if(mod_HandlingManager.HasFrontWheelDrive(pHandling->nIdentifier))
+					fThrust = 0.0f;
+				else
+					fThrust = acceleration;
+
+				m_aWheelColPoints[CARWHEEL_REAR_LEFT].surfaceA = SURFACE_RUBBER29;
+				float adhesion = CSurfaceTable::GetAdhesiveLimit(m_aWheelColPoints[CARWHEEL_REAR_LEFT])*traction;
+				if(m_status == STATUS_PLAYER)
+					adhesion *= CSurfaceTable::GetWetMultiplier(m_aWheelColPoints[CARWHEEL_REAR_LEFT].surfaceB);
+				WheelState[CARWHEEL_REAR_LEFT] = m_aWheelState[CARWHEEL_REAR_LEFT];
+
+				if(Damage.GetWheelStatus(VEHWHEEL_REAR_LEFT) == WHEEL_STATUS_BURST)
+					ProcessWheel(wheelFwd, wheelRight,
+						contactSpeeds[CARWHEEL_REAR_LEFT], contactPoints[CARWHEEL_REAR_LEFT],
+						m_nWheelsOnGround, fThrust,
+						brake*brakeBiasRear,
+						adhesion*tractionBiasRear*Damage.m_fWheelDamageEffect,
+						CARWHEEL_REAR_LEFT,
+						&m_aWheelSpeed[CARWHEEL_REAR_LEFT],
+						&WheelState[CARWHEEL_REAR_LEFT],
+						WHEEL_STATUS_BURST);
+				else
+					ProcessWheel(wheelFwd, wheelRight,
+						contactSpeeds[CARWHEEL_REAR_LEFT], contactPoints[CARWHEEL_REAR_LEFT],
+						m_nWheelsOnGround, fThrust,
+						brake*brakeBiasRear,
+						adhesion*tractionBiasRear,
+						CARWHEEL_REAR_LEFT,
+						&m_aWheelSpeed[CARWHEEL_REAR_LEFT],
+						&WheelState[CARWHEEL_REAR_LEFT],
+						WHEEL_STATUS_OK);
+			}
+
+			if(m_aWheelTimer[CARWHEEL_REAR_RIGHT] > 0.0f){
+				if(mod_HandlingManager.HasFrontWheelDrive(pHandling->nIdentifier))
+					fThrust = 0.0f;
+				else
+					fThrust = acceleration;
+
+				m_aWheelColPoints[CARWHEEL_REAR_RIGHT].surfaceA = SURFACE_RUBBER29;
+				float adhesion = CSurfaceTable::GetAdhesiveLimit(m_aWheelColPoints[CARWHEEL_REAR_RIGHT])*traction;
+				if(m_status == STATUS_PLAYER)
+					adhesion *= CSurfaceTable::GetWetMultiplier(m_aWheelColPoints[CARWHEEL_REAR_RIGHT].surfaceB);
+				WheelState[CARWHEEL_REAR_RIGHT] = m_aWheelState[CARWHEEL_REAR_RIGHT];
+
+				if(Damage.GetWheelStatus(VEHWHEEL_REAR_RIGHT) == WHEEL_STATUS_BURST)
+					ProcessWheel(wheelFwd, wheelRight,
+						contactSpeeds[CARWHEEL_REAR_RIGHT], contactPoints[CARWHEEL_REAR_RIGHT],
+						m_nWheelsOnGround, fThrust,
+						brake*brakeBiasRear,
+						adhesion*tractionBiasRear*Damage.m_fWheelDamageEffect,
+						CARWHEEL_REAR_RIGHT,
+						&m_aWheelSpeed[CARWHEEL_REAR_RIGHT],
+						&WheelState[CARWHEEL_REAR_RIGHT],
+						WHEEL_STATUS_BURST);
+				else
+					ProcessWheel(wheelFwd, wheelRight,
+						contactSpeeds[CARWHEEL_REAR_RIGHT], contactPoints[CARWHEEL_REAR_RIGHT],
+						m_nWheelsOnGround, fThrust,
+						brake*brakeBiasRear,
+						adhesion*tractionBiasRear,
+						CARWHEEL_REAR_RIGHT,
+						&m_aWheelSpeed[CARWHEEL_REAR_RIGHT],
+						&WheelState[CARWHEEL_REAR_RIGHT],
+						WHEEL_STATUS_OK);
+			}
+		}
+
+		// Process rear wheels off ground
+
+		if(m_aWheelTimer[CARWHEEL_REAR_LEFT] <= 0.0f){
+			if(mod_HandlingManager.HasFrontWheelDrive(pHandling->nIdentifier) || acceleration == 0.0f)
+				m_aWheelSpeed[CARWHEEL_REAR_LEFT] *= 0.95f;
+			else{
+				if(acceleration > 0.0f){
+					if(m_aWheelSpeed[CARWHEEL_REAR_LEFT] < 2.0f)
+						m_aWheelSpeed[CARWHEEL_REAR_LEFT] -= 0.2f;
+				}else{
+					if(m_aWheelSpeed[CARWHEEL_REAR_LEFT] > -2.0f)
+						m_aWheelSpeed[CARWHEEL_REAR_LEFT] += 0.1f;
+				}
+			}
+			m_aWheelRotation[CARWHEEL_REAR_LEFT] += m_aWheelSpeed[CARWHEEL_REAR_LEFT];
+		}
+		if(m_aWheelTimer[CARWHEEL_REAR_RIGHT] <= 0.0f){
+			if(mod_HandlingManager.HasFrontWheelDrive(pHandling->nIdentifier) || acceleration == 0.0f)
+				m_aWheelSpeed[CARWHEEL_REAR_RIGHT] *= 0.95f;
+			else{
+				if(acceleration > 0.0f){
+					if(m_aWheelSpeed[CARWHEEL_REAR_RIGHT] < 2.0f)
+						m_aWheelSpeed[CARWHEEL_REAR_RIGHT] -= 0.2f;
+				}else{
+					if(m_aWheelSpeed[CARWHEEL_REAR_RIGHT] > -2.0f)
+						m_aWheelSpeed[CARWHEEL_REAR_RIGHT] += 0.1f;
+				}
+			}
+			m_aWheelRotation[CARWHEEL_REAR_RIGHT] += m_aWheelSpeed[CARWHEEL_REAR_RIGHT];
+		}
+
+		for(i = 0; i < 4; i++){
+			float wheelPos = colModel->lines[i].p0.z;
+			if(m_aSuspensionSpringRatio[i] > 0.0f)
+				wheelPos -= m_aSuspensionSpringRatio[i]*m_aSuspensionSpringLength[i];
+			m_aWheelPosition[i] += (wheelPos - m_aWheelPosition[i])*0.75f;
+		}
+		for(i = 0; i < 4; i++)
+			m_aWheelState[i] = WheelState[i];
+
+		// Process horn
+
+		if(m_status != STATUS_PLAYER){
+			ReduceHornCounter();
+		}else{
+			if(GetModelIndex() == MI_MRWHOOP){
+				if(Pads[0].bHornHistory[Pads[0].iCurrHornHistory] &&
+				   !Pads[0].bHornHistory[(Pads[0].iCurrHornHistory+4) % 5]){
+					m_bSirenOrAlarm = !m_bSirenOrAlarm;
+					printf("m_bSirenOrAlarm toggled to %d\n", m_bSirenOrAlarm);
+				}
+			}else if(UsesSiren(GetModelIndex())){
+				if(Pads[0].bHornHistory[Pads[0].iCurrHornHistory]){
+					if(Pads[0].bHornHistory[(Pads[0].iCurrHornHistory+4) % 5] &&
+					   Pads[0].bHornHistory[(Pads[0].iCurrHornHistory+3) % 5])
+						m_nCarHornTimer = 1;
+					else
+						m_nCarHornTimer = 0;
+				}else if(Pads[0].bHornHistory[(Pads[0].iCurrHornHistory+4) % 5] &&
+				         !Pads[0].bHornHistory[(Pads[0].iCurrHornHistory+1) % 5]){
+					m_nCarHornTimer = 0;
+					m_bSirenOrAlarm = !m_bSirenOrAlarm;
+				}else
+					m_nCarHornTimer = 0;
+			}else if(GetModelIndex() != MI_YARDIE && !CVehicle::bCheat3){
+				if(Pads[0].GetHorn())
+					m_nCarHornTimer = 1;
+				else
+					m_nCarHornTimer = 0;
+			}
+		}
+
+		// Flying
+
+		if(m_status != STATUS_PLAYER && m_status != STATUS_PLAYER_REMOTE && m_status != STATUS_PHYSICS){
+			if(GetModelIndex() == MI_MIAMI_RCRAIDER || GetModelIndex() == MI_MIAMI_SPARROW)
+				m_aWheelSpeed[0] = max(m_aWheelSpeed[0]-0.0005f, 0.0f);
+		}else if((GetModelIndex() == MI_DODO || CVehicle::bAllDodosCheat) &&
+		         m_vecMoveSpeed.Magnitude() > 0.0f && CTimer::GetTimeStep() > 0.0f){
+			FlyingControl(FLIGHT_MODEL_DODO);
+		}else if(GetModelIndex() == MI_MIAMI_RCBARON){
+			FlyingControl(FLIGHT_MODEL_HELI);
+		}else if(GetModelIndex() == MI_MIAMI_RCRAIDER || GetModelIndex() == MI_MIAMI_SPARROW || bAllCarCheat){
+			if(CPad::GetPad(0)->GetCircleJustDown())
+				m_aWheelSpeed[0] = max(m_aWheelSpeed[0]-0.03f, 0.0f);
+			if(m_aWheelSpeed[0] < 0.22f)
+				m_aWheelSpeed[0] += 0.0001f;
+			if(m_aWheelSpeed[0] > 0.15f)
+				FlyingControl(FLIGHT_MODEL_HELI);
+		}
+	}
+
+
+
+	// Process car on fire
+	// A similar calculation of damagePos is done elsewhere for smoke
+
+	uint8 engineStatus = Damage.GetEngineStatus();
+	CVector damagePos = ((CVehicleModelInfo*)CModelInfo::GetModelInfo(GetModelIndex()))->m_positions[CAR_POS_HEADLIGHTS];
+
+	switch(Damage.GetDoorStatus(DOOR_BONNET)){
+	case DOOR_STATUS_OK:
+	case DOOR_STATUS_SMASHED:
+		// Bonnet is still there, smoke comes out at the edge
+		damagePos += vecDAMAGE_ENGINE_POS_SMALL;
+		break;
+	case DOOR_STATUS_SWINGING:
+	case DOOR_STATUS_MISSING:
+		// Bonnet is gone, smoke comes out at the engine
+		damagePos += vecDAMAGE_ENGINE_POS_BIG;
+		break;
+	}
+
+	// move fire forward if in first person
+	if(this == FindPlayerVehicle() && TheCamera.GetLookingForwardFirstPerson())
+		if(m_fHealth < 250.0f && m_status != STATUS_WRECKED){
+			if(GetModelIndex() == MI_FIRETRUCK)
+				damagePos += CVector(0.0f, 3.0f, -0.2f);
+			else
+				damagePos += CVector(0.0f, 1.2f, -0.8f);
+		}
+
+	damagePos = GetMatrix()*damagePos;
+	damagePos.z += 0.15f;
+
+	if(m_fHealth < 250.0f && m_status != STATUS_WRECKED){
+		// Car is on fire
+
+		CParticle::AddParticle(PARTICLE_CARFLAME, damagePos,
+			CVector(0.0f, 0.0f, CGeneral::GetRandomNumberInRange(0.01125f, 0.09f)),
+			nil, 0.9f);
+
+		CVector coors = damagePos;
+		coors.x += CGeneral::GetRandomNumberInRange(-0.5625f, 0.5625f),
+		coors.y += CGeneral::GetRandomNumberInRange(-0.5625f, 0.5625f),
+		coors.z += CGeneral::GetRandomNumberInRange(0.5625f, 2.25f);
+		CParticle::AddParticle(PARTICLE_CARFLAME_SMOKE, coors, CVector(0.0f, 0.0f, 0.0f));
+
+		CParticle::AddParticle(PARTICLE_ENGINE_SMOKE2, damagePos, CVector(0.0f, 0.0f, 0.0f), nil, 0.5f);
+
+		// Blow up car after 5 seconds
+		m_fFireBlowUpTimer += CTimer::GetTimeStepInMilliseconds();
+		if(m_fFireBlowUpTimer > 5000.0f){
+			CWorld::Players[CWorld::PlayerInFocus].AwardMoneyForExplosion(this);
+			BlowUpCar(m_pSetOnFireEntity);
+		}
+	}else
+		m_fFireBlowUpTimer = 0.0f;
+
+	// Decrease car health if engine is damaged badly
+	if(engineStatus > ENGINE_STATUS_ON_FIRE && m_fHealth > 250.0f)
+		m_fHealth -= 2.0f;
+
+	ProcessDelayedExplosion();
+
+
+	if(m_bSirenOrAlarm && (CTimer::GetFrameCounter()&7) == 5 &&
+	   UsesSiren(GetModelIndex()) && GetModelIndex() != MI_RCBANDIT)
+		CCarAI::MakeWayForCarWithSiren(this);
+
+
+	// Find out how much to shake the pad depending on suspension and ground surface
+
+	float suspShake = 0.0f;
+	float surfShake = 0.0f;
+	for(i = 0; i < 4; i++){
+		float suspChange = m_aSuspensionSpringRatioPrev[i] - m_aSuspensionSpringRatio[i];
+		if(suspChange > 0.3f){
+			DMAudio.PlayOneShot(m_audioEntityId, SOUND_CAR_JUMP, suspChange);
+			if(suspChange > suspShake)
+				suspShake = suspChange;
+		}
+
+		uint8 surf = m_aWheelColPoints[i].surfaceB;
+		if(surf == SURFACE_DIRT || surf == SURFACE_PUDDLE || surf == SURFACE_HEDGE){
+			if(surfShake < 0.2f)
+				surfShake = 0.3f;
+		}else if(surf == SURFACE_DIRTTRACK || surf == SURFACE_SAND){
+			if(surfShake < 0.1f)
+				surfShake = 0.2f;
+		}else if(surf == SURFACE_GRASS){
+			if(surfShake < 0.05f)
+				surfShake = 0.1f;
+		}
+
+		m_aSuspensionSpringRatioPrev[i] = m_aSuspensionSpringRatio[i];
+		m_aSuspensionSpringRatio[i] = 1.0f;
+	}
+
+	// Shake pad
+
+	if((suspShake > 0.0f || surfShake > 0.0f) && m_status == STATUS_PLAYER){
+		float speed = m_vecMoveSpeed.MagnitudeSqr();
+		if(speed > sq(0.1f)){
+			speed = Sqrt(speed);
+			if(suspShake > 0.0f){
+				uint8 freq = min(200.0f*suspShake*speed*2000.0f/m_fMass + 100.0f, 250.0f);
+				CPad::GetPad(0)->StartShake(20000.0f*CTimer::GetTimeStep()/freq, freq);
+			}else{
+				uint8 freq = min(200.0f*surfShake*speed*2000.0f/m_fMass + 40.0f, 145.0f);
+				CPad::GetPad(0)->StartShake(5000.0f*CTimer::GetTimeStep()/freq, freq);
+			}
+		}
+	}
+
+	bVehicleColProcessed = false;
+
+	if(!bWarnedPeds)
+		CCarCtrl::ScanForPedDanger(this);
+
+
+	// Turn around at the edge of the world
+	// TODO: make the numbers defines
+
+	float heading;
+	if(GetPosition().x > 1900.0f){
+		if(m_vecMoveSpeed.x > 0.0f)
+			m_vecMoveSpeed.x *= -1.0f;
+		heading = GetForward().Heading();
+		if(heading > 0.0f)	// going west
+			SetHeading(-heading);
+	}else if(GetPosition().x < -1900.0f){
+		if(m_vecMoveSpeed.x < 0.0f)
+			m_vecMoveSpeed.x *= -1.0f;
+		heading = GetForward().Heading();
+		if(heading < 0.0f)	// going east
+			SetHeading(-heading);
+	}
+	if(GetPosition().y > 1900.0f){
+		if(m_vecMoveSpeed.y > 0.0f)
+			m_vecMoveSpeed.y *= -1.0f;
+		heading = GetForward().Heading();
+		if(heading < HALFPI && heading > 0.0f)
+			SetHeading(PI-heading);
+		else if(heading > -HALFPI && heading < 0.0f)
+			SetHeading(-PI-heading);
+	}else if(GetPosition().y < -1900.0f){
+		if(m_vecMoveSpeed.y < 0.0f)
+			m_vecMoveSpeed.y *= -1.0f;
+		heading = GetForward().Heading();
+		if(heading > HALFPI)
+			SetHeading(PI-heading);
+		else if(heading < -HALFPI)
+			SetHeading(-PI-heading);
+	}
+
+	if(bInfiniteMass){
+		m_vecMoveSpeed = CVector(0.0f, 0.0f, 0.0f);
+		m_vecTurnSpeed = CVector(0.0f, 0.0f, 0.0f);
+		m_vecMoveFriction = CVector(0.0f, 0.0f, 0.0f);
+		m_vecTurnFriction = CVector(0.0f, 0.0f, 0.0f);
+	}else if(!skipPhysics &&
+	         (m_fGasPedal == 0.0f && brake == 0.0f || m_status == STATUS_WRECKED)){
+		if(Abs(m_vecMoveSpeed.x) < 0.005f &&
+		   Abs(m_vecMoveSpeed.y) < 0.005f &&
+		   Abs(m_vecMoveSpeed.z) < 0.005f){
+			m_vecMoveSpeed = CVector(0.0f, 0.0f, 0.0f);
+			m_vecTurnSpeed.z = 0.0f;
+		}
+	}
+
+// TEMP
+if(pDriver)
+	pDriver->m_fHealth = 100.0f;
+}
 
 void
 CAutomobile::Teleport(CVector pos)
@@ -86,7 +1232,7 @@ CAutomobile::ProcessEntityCollision(CEntity *ent, CColPoint *colpoints)
 	// In ProcessControl these will be re-normalized to ignore the tyre radius.
 
 	if(field_EF || m_phy_flagA80 ||
-	   GetModelIndex() == MI_DODO && (ent->m_status == STATUS_PHYSICS || ent->m_status == STATUS_SIMPLE)){
+	   GetModelIndex() == MI_DODO && (ent->IsPed() || ent->IsVehicle())){
 		// don't do line collision
 		for(i = 0; i < 4; i++)
 			m_aSuspensionSpringRatio[i] = prevRatios[i];
@@ -141,8 +1287,613 @@ CAutomobile::ProcessEntityCollision(CEntity *ent, CColPoint *colpoints)
 	return numCollisions;
 }
 
+static int16 nLastControlInput;
+static float fMouseCentreRange = 0.35f;
+static float fMouseSteerSens = -0.0035f;
+static float fMouseCentreMult = 0.975f;
+
+void
+CAutomobile::ProcessControlInputs(uint8 pad)
+{
+	float speed = DotProduct(m_vecMoveSpeed, GetForward());
+
+	if(CPad::GetPad(pad)->GetExitVehicle())
+		bIsHandbrakeOn = true;
+	else
+		bIsHandbrakeOn = !!CPad::GetPad(pad)->GetHandBrake();
+
+	// Steer left/right
+	if(CCamera::m_bUseMouse3rdPerson && !CVehicle::m_bDisableMouseSteering){
+		if(CPad::GetPad(pad)->GetMouseX() != 0.0f){
+			m_fSteerRatio += fMouseSteerSens*CPad::GetPad(pad)->GetMouseX();
+			nLastControlInput = 2;
+			if(Abs(m_fSteerRatio) < fMouseCentreRange)
+				m_fSteerRatio *= Pow(fMouseCentreMult, CTimer::GetTimeStep());
+		}else if(CPad::GetPad(pad)->GetSteeringLeftRight() || nLastControlInput != 2){
+			// mouse hasn't move, steer with pad like below
+			m_fSteerRatio += (-CPad::GetPad(pad)->GetSteeringLeftRight()/128.0f - m_fSteerRatio)*
+				0.2f*CTimer::GetTimeStep();
+			nLastControlInput = 0;
+		}
+	}else{
+		m_fSteerRatio += (-CPad::GetPad(pad)->GetSteeringLeftRight()/128.0f - m_fSteerRatio)*
+			0.2f*CTimer::GetTimeStep();
+		nLastControlInput = 0;
+	}
+	m_fSteerRatio = clamp(m_fSteerRatio, -1.0f, 1.0f);
+
+	// Accelerate/Brake
+	float acceleration = (CPad::GetPad(pad)->GetAccelerate() - CPad::GetPad(pad)->GetBrake())/255.0f;
+	if(GetModelIndex() == MI_DODO && acceleration < 0.0f)
+		acceleration *= 0.3f;
+	if(Abs(speed) < 0.01f){
+		// standing still, go into direction we want
+		m_fGasPedal = acceleration;
+		m_fBrakePedal = 0.0f;
+	}else{
+#if 1
+		// simpler than the code below
+		if(speed * acceleration < 0.0f){
+			// if opposite directions, have to brake first
+			m_fGasPedal = 0.0f;
+			m_fBrakePedal = Abs(acceleration);
+		}else{
+			// accelerating in same direction we were already going
+			m_fGasPedal = acceleration;
+			m_fBrakePedal = 0.0f;
+		}
+#else
+		if(speed < 0.0f){
+			// moving backwards currently
+			if(acceleration < 0.0f){
+				// still go backwards
+				m_fGasPedal = acceleration;
+				m_fBrakePedal = 0.0f;
+			}else{
+				// want to go forwards, so brake
+				m_fGasPedal = 0.0f;
+				m_fBrakePedal = acceleration;
+			}
+		}else{
+			// moving forwards currently
+			if(acceleration < 0.0f){
+				// want to go backwards, so brake
+				m_fGasPedal = 0.0f;
+				m_fBrakePedal = -acceleration;
+			}else{
+				// still go forwards
+				m_fGasPedal = acceleration;
+				m_fBrakePedal = 0.0f;
+			}
+		}
+#endif
+	}
+
+	// Actually turn wheels
+	static float fValue;	// why static?
+	if(m_fSteerRatio < 0.0f)
+		fValue = -sq(m_fSteerRatio);
+	else
+		fValue = sq(m_fSteerRatio);
+	m_fSteerAngle = DEGTORAD(pHandling->fSteeringLock) * fValue;
+
+	if(bComedyControls){
+		int rnd = CGeneral::GetRandomNumber() % 10;
+		switch(m_comedyControlState){
+		case 0:
+			if(rnd < 2)
+				m_comedyControlState = 1;
+			else if(rnd < 4)
+				m_comedyControlState = 2;
+			break;
+		case 1:
+			m_fSteerAngle += 0.05f;
+			if(rnd < 2)
+				m_comedyControlState = 0;
+			break;
+		case 2:
+			m_fSteerAngle -= 0.05f;
+			if(rnd < 2)
+				m_comedyControlState = 0;
+			break;
+		}
+	}else
+		m_comedyControlState = 0;
+
+	// Brake if player isn't in control
+	// BUG: game always uses pad 0 here
+	if(CPad::GetPad(pad)->DisablePlayerControls){
+		m_fBrakePedal = 1.0f;
+		bIsHandbrakeOn = true;
+		m_fGasPedal = 0.0f;
+
+		FindPlayerPed()->KeepAreaAroundPlayerClear();
+
+		// slow down car immediately
+		speed = m_vecMoveSpeed.Magnitude();
+		if(speed > 0.28f)
+			m_vecMoveSpeed *= 0.28f/speed;
+	}
+}
+
+WRAPPER void
+CAutomobile::FireTruckControl(void)
+{ EAXJMP(0x522590);
+}
 
-WRAPPER void CAutomobile::ProcessControlInputs(uint8) { EAXJMP(0x53B660); }
+WRAPPER void
+CAutomobile::TankControl(void)
+{ EAXJMP(0x53D530);
+}
+
+WRAPPER void
+CAutomobile::HydraulicControl(void)
+{ EAXJMP(0x52D4E0);
+}
+
+WRAPPER void
+CAutomobile::ProcessBuoyancy(void)
+{ EAXJMP(0x5308D0);
+}
+
+void
+CAutomobile::DoDriveByShootings(void)
+{
+	CAnimBlendAssociation *anim;
+	CWeapon *weapon = pDriver->GetWeapon();
+	if(weapon->m_eWeaponType != WEAPONTYPE_UZI)
+		return;
+
+	weapon->Update(pDriver->m_audioEntityId);
+
+	bool lookingLeft = false;
+	bool lookingRight = false;
+	if(TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_TOPDOWN1){
+		if(CPad::GetPad(0)->GetLookLeft())
+			lookingLeft = true;
+		if(CPad::GetPad(0)->GetLookRight())
+			lookingRight = true;
+	}else{
+		if(TheCamera.Cams[TheCamera.ActiveCam].LookingLeft)
+			lookingLeft = true;
+		if(TheCamera.Cams[TheCamera.ActiveCam].LookingRight)
+			lookingRight = true;
+	}
+
+	if(lookingLeft || lookingRight){
+		if(lookingLeft){
+			anim = RpAnimBlendClumpGetAssociation(pDriver->GetClump(), ANIM_DRIVEBY_R);
+			if(anim)
+				anim->blendDelta = -1000.0f;
+			anim = RpAnimBlendClumpGetAssociation(pDriver->GetClump(), ANIM_DRIVEBY_L);
+			if(anim == nil || anim->blendDelta < 0.0f)
+				CAnimManager::AddAnimation(pDriver->GetClump(), ASSOCGRP_STD, ANIM_DRIVEBY_L);
+			else
+				anim->SetRun();
+		}else if(pDriver->m_pMyVehicle->pPassengers[0] == nil || TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_FIRSTPERSON){
+			anim = RpAnimBlendClumpGetAssociation(pDriver->GetClump(), ANIM_DRIVEBY_L);
+			if(anim)
+				anim->blendDelta = -1000.0f;
+			anim = RpAnimBlendClumpGetAssociation(pDriver->GetClump(), ANIM_DRIVEBY_R);
+			if(anim == nil || anim->blendDelta < 0.0f)
+				CAnimManager::AddAnimation(pDriver->GetClump(), ASSOCGRP_STD, ANIM_DRIVEBY_R);
+			else
+				anim->SetRun();
+		}
+
+		if(CPad::GetPad(0)->GetCarGunFired() && CTimer::GetTimeInMilliseconds() > weapon->m_nTimer){
+			weapon->FireFromCar(this, lookingLeft);
+			weapon->m_nTimer = CTimer::GetTimeInMilliseconds() + 70;
+		}
+	}else{
+		weapon->Reload();
+		anim = RpAnimBlendClumpGetAssociation(pDriver->GetClump(), ANIM_DRIVEBY_L);
+		if(anim)
+			anim->blendDelta = -1000.0f;
+		anim = RpAnimBlendClumpGetAssociation(pDriver->GetClump(), ANIM_DRIVEBY_R);
+		if(anim)
+			anim->blendDelta = -1000.0f;
+	}
+
+	// TODO: what is this?
+	if(!lookingLeft && m_weaponDoorTimerLeft > 0.0f){
+		m_weaponDoorTimerLeft = max(m_weaponDoorTimerLeft - CTimer::GetTimeStep()*0.1f, 0.0f);
+		ProcessOpenDoor(CAR_DOOR_LF, NUM_ANIMS, m_weaponDoorTimerLeft);
+	}
+	if(!lookingRight && m_weaponDoorTimerRight > 0.0f){
+		m_weaponDoorTimerRight = max(m_weaponDoorTimerRight - CTimer::GetTimeStep()*0.1f, 0.0f);
+		ProcessOpenDoor(CAR_DOOR_RF, NUM_ANIMS, m_weaponDoorTimerRight);
+	}
+}
+
+int32
+CAutomobile::RcbanditCheckHitWheels(void)
+{
+	int x, xmin, xmax;
+	int y, ymin, ymax;
+
+	xmin = CWorld::GetSectorIndexX(GetPosition().x - 2.0f);
+	if(xmin < 0) xmin = 0;
+	xmax = CWorld::GetSectorIndexX(GetPosition().x + 2.0f);
+	if(xmax > NUMSECTORS_X-1) xmax = NUMSECTORS_X-1;
+	ymin = CWorld::GetSectorIndexX(GetPosition().y - 2.0f);
+	if(ymin < 0) ymin = 0;
+	ymax = CWorld::GetSectorIndexX(GetPosition().y + 2.0f);
+	if(ymax > NUMSECTORS_Y-1) ymax = NUMSECTORS_X-1;
+
+	CWorld::AdvanceCurrentScanCode();
+
+	for(y = ymin; y <= ymax; y++)
+		for(x = xmin; x <= xmax; x++){
+			CSector *s = CWorld::GetSector(x, y);
+			if(RcbanditCheck1CarWheels(s->m_lists[ENTITYLIST_VEHICLES]) ||
+			   RcbanditCheck1CarWheels(s->m_lists[ENTITYLIST_VEHICLES_OVERLAP]))
+				return 1;
+		}
+	return 0;
+}
+
+int32
+CAutomobile::RcbanditCheck1CarWheels(CPtrList &list)
+{
+	static CMatrix matW2B;
+	int i;
+	CPtrNode *node;
+	CAutomobile *car;
+	CColModel *colModel = GetColModel();
+	CVehicleModelInfo *mi;
+
+	for(node = list.first; node; node = node->next){
+		car = (CAutomobile*)node->item;
+		if(this != car && car->IsCar() && car->m_scanCode != CWorld::GetCurrentScanCode()){
+			car->m_scanCode = CWorld::GetCurrentScanCode();
+
+			if(Abs(this->GetPosition().x - car->GetPosition().x) < 10.0f &&
+			   Abs(this->GetPosition().y - car->GetPosition().y) < 10.0f){
+				mi = (CVehicleModelInfo*)CModelInfo::GetModelInfo(car->GetModelIndex());
+
+				for(i = 0; i < 4; i++){
+					if(car->m_aSuspensionSpringRatioPrev[i] < 1.0f || car->m_status == STATUS_SIMPLE){
+						CVector wheelPos;
+						CColSphere sph;
+						mi->GetWheelPosn(i, wheelPos);
+						matW2B = Invert(GetMatrix());
+						sph.center = matW2B * (car->GetMatrix() * wheelPos);
+						sph.radius = mi->m_wheelScale*0.25f;
+						if(CCollision::TestSphereBox(sph, colModel->boundingBox))
+							return 1;
+					}
+				}
+			}
+		}
+	}
+	return 0;
+}
+
+void
+CAutomobile::PlaceOnRoadProperly(void)
+{
+	CColPoint point;
+	CEntity *entity;
+	CColModel *colModel = GetColModel();
+	float lenFwd, lenBack;
+	float frontZ, rearZ;
+
+	lenFwd = colModel->boundingBox.max.y;
+	lenBack = -colModel->boundingBox.min.y;
+
+	CVector front(GetPosition().x + GetForward().x*lenFwd,
+	              GetPosition().y + GetForward().y*lenFwd,
+	              GetPosition().z + 5.0f);
+	if(CWorld::ProcessVerticalLine(front, GetPosition().z - 5.0f, point, entity,
+			true, false, false, false, false, false, nil)){
+		frontZ = point.point.z;
+		m_pCurGroundEntity = entity;
+	}else{
+		frontZ = field_21C;
+	}
+
+	CVector rear(GetPosition().x - GetForward().x*lenBack,
+	             GetPosition().y - GetForward().y*lenBack,
+	             GetPosition().z + 5.0f);
+	if(CWorld::ProcessVerticalLine(rear, GetPosition().z - 5.0f, point, entity,
+			true, false, false, false, false, false, nil)){
+		rearZ = point.point.z;
+		m_pCurGroundEntity = entity;
+	}else{
+		rearZ = field_220;
+	}
+
+	float len = lenFwd + lenBack;
+	float angle = Atan((frontZ - rearZ)/len);
+	float c = Cos(angle);
+	float s = Sin(angle);
+
+	GetRight() = CVector((front.y - rear.y)/len, -(front.x - rear.x)/len, 0.0f);
+	GetForward() = CVector(-c*GetRight().y, c*GetRight().x, s);
+	GetUp() = CrossProduct(GetRight(), GetForward());
+	GetPosition() = CVector((front.x + rear.x)/2.0f, (front.y + rear.y)/2.0f, (frontZ + rearZ)/2.0f + GetHeightAboveRoad());
+}
+
+void
+CAutomobile::VehicleDamage(float impulse, uint16 damagedPiece)
+{
+	int i;
+	float damageMultiplier = 0.2f;
+	bool doubleMoney = false;
+
+	if(impulse == 0.0f){
+		impulse = m_fDamageImpulse;
+		damagedPiece = m_nDamagePieceType;
+		damageMultiplier = 1.0f;
+	}
+
+	CVector pos(0.0f, 0.0f, 0.0f);
+
+	if(!bCanBeDamaged)
+		return;
+
+	// damage flipped over car
+	if(GetUp().z < 0.0f && this != FindPlayerVehicle()){
+		if(bNotDamagedUpsideDown || m_status == STATUS_PLAYER_REMOTE || bIsInWater)
+			return;
+		m_fHealth -= 4.0f*CTimer::GetTimeStep();
+	}
+
+	if(impulse > 25.0f && m_status != STATUS_WRECKED){
+		if(bIsLawEnforcer &&
+		   FindPlayerVehicle() && FindPlayerVehicle() == m_pDamageEntity &&
+		   m_status != STATUS_ABANDONED &&
+		   FindPlayerVehicle()->m_vecMoveSpeed.Magnitude() >= m_vecMoveSpeed.Magnitude() &&
+		   FindPlayerVehicle()->m_vecMoveSpeed.Magnitude() > 0.1f)
+			FindPlayerPed()->SetWantedLevelNoDrop(1);
+
+		if(m_status == STATUS_PLAYER && impulse > 50.0f){
+			uint8 freq = min(0.4f*impulse*2000.0f/m_fMass + 100.0f, 250.0f);
+			CPad::GetPad(0)->StartShake(40000/freq, freq);
+		}
+
+		if(bOnlyDamagedByPlayer){
+			if(m_pDamageEntity != FindPlayerPed() &&
+			   m_pDamageEntity != FindPlayerVehicle())
+				return;
+		}
+
+		if(bCollisionProof)
+			return;
+
+		if(m_pDamageEntity){
+			if(m_pDamageEntity->IsBuilding() &&
+			   DotProduct(m_vecDamageNormal, GetUp()) > 0.6f)
+				return;
+		}
+
+		int oldLightStatus[4];
+		for(i = 0; i < 4; i++)
+			oldLightStatus[i] = Damage.GetLightStatus((eLights)i);
+
+		if(GetUp().z > 0.0f || m_vecMoveSpeed.MagnitudeSqr() > 0.1f){
+			float impulseMult = bMoreResistantToDamage ? 0.5f : 4.0f;
+
+			switch(damagedPiece){
+			case CAR_PIECE_BUMP_FRONT:
+				GetComponentWorldPosition(CAR_BUMP_FRONT, pos);
+				dmgDrawCarCollidingParticles(pos, impulse);
+				if(Damage.ApplyDamage(COMPONENT_BUMPER_FRONT, impulse*impulseMult, pHandling->fCollisionDamageMultiplier)){
+					SetBumperDamage(CAR_BUMP_FRONT, VEHBUMPER_FRONT);
+					doubleMoney = true;
+				}
+				if(m_aCarNodes[CAR_BONNET] && Damage.GetPanelStatus(VEHBUMPER_FRONT) == PANEL_STATUS_MISSING){
+			case CAR_PIECE_BONNET:
+					GetComponentWorldPosition(CAR_BONNET, pos);
+					dmgDrawCarCollidingParticles(pos, impulse);
+					if(Damage.ApplyDamage(COMPONENT_DOOR_BONNET, impulse*impulseMult, pHandling->fCollisionDamageMultiplier)){
+						SetDoorDamage(CAR_BONNET, DOOR_BONNET);
+						doubleMoney = true;
+					}
+				}
+				break;
+
+			case CAR_PIECE_BUMP_REAR:
+				GetComponentWorldPosition(CAR_BUMP_REAR, pos);
+				dmgDrawCarCollidingParticles(pos, impulse);
+				if(Damage.ApplyDamage(COMPONENT_BUMPER_FRONT, impulse*impulseMult, pHandling->fCollisionDamageMultiplier)){
+					SetBumperDamage(CAR_BUMP_REAR, VEHBUMPER_REAR);
+					doubleMoney = true;
+				}
+				if(m_aCarNodes[CAR_BOOT] && Damage.GetPanelStatus(VEHBUMPER_REAR) == PANEL_STATUS_MISSING){
+			case CAR_PIECE_BOOT:
+					GetComponentWorldPosition(CAR_BOOT, pos);
+					dmgDrawCarCollidingParticles(pos, impulse);
+					if(Damage.ApplyDamage(COMPONENT_DOOR_BOOT, impulse*impulseMult, pHandling->fCollisionDamageMultiplier)){
+						SetDoorDamage(CAR_BOOT, DOOR_BOOT);
+						doubleMoney = true;
+					}
+				}
+				break;
+
+			case CAR_PIECE_DOOR_LF:
+				GetComponentWorldPosition(CAR_DOOR_LF, pos);
+				dmgDrawCarCollidingParticles(pos, impulse);
+				if((m_nDoorLock == CARLOCK_NOT_USED || m_nDoorLock == CARLOCK_UNLOCKED) &&
+				   Damage.ApplyDamage(COMPONENT_DOOR_FRONT_LEFT, impulse*impulseMult, pHandling->fCollisionDamageMultiplier)){
+					SetDoorDamage(CAR_DOOR_LF, DOOR_FRONT_LEFT);
+					doubleMoney = true;
+				}
+				break;
+			case CAR_PIECE_DOOR_RF:
+				GetComponentWorldPosition(CAR_DOOR_RF, pos);
+				dmgDrawCarCollidingParticles(pos, impulse);
+				if((m_nDoorLock == CARLOCK_NOT_USED || m_nDoorLock == CARLOCK_UNLOCKED) &&
+				   Damage.ApplyDamage(COMPONENT_DOOR_FRONT_RIGHT, impulse*impulseMult, pHandling->fCollisionDamageMultiplier)){
+					SetDoorDamage(CAR_DOOR_RF, DOOR_FRONT_RIGHT);
+					doubleMoney = true;
+				}
+				break;
+			case CAR_PIECE_DOOR_LR:
+				GetComponentWorldPosition(CAR_DOOR_LR, pos);
+				dmgDrawCarCollidingParticles(pos, impulse);
+				if((m_nDoorLock == CARLOCK_NOT_USED || m_nDoorLock == CARLOCK_UNLOCKED) &&
+				   Damage.ApplyDamage(COMPONENT_DOOR_REAR_LEFT, impulse*impulseMult, pHandling->fCollisionDamageMultiplier)){
+					SetDoorDamage(CAR_DOOR_LR, DOOR_REAR_LEFT);
+					doubleMoney = true;
+				}
+				break;
+			case CAR_PIECE_DOOR_RR:
+				GetComponentWorldPosition(CAR_DOOR_RR, pos);
+				dmgDrawCarCollidingParticles(pos, impulse);
+				if((m_nDoorLock == CARLOCK_NOT_USED || m_nDoorLock == CARLOCK_UNLOCKED) &&
+				   Damage.ApplyDamage(COMPONENT_DOOR_REAR_RIGHT, impulse*impulseMult, pHandling->fCollisionDamageMultiplier)){
+					SetDoorDamage(CAR_DOOR_RR, DOOR_REAR_RIGHT);
+					doubleMoney = true;
+				}
+				break;
+
+			case CAR_PIECE_WING_LF:
+				GetComponentWorldPosition(CAR_WING_LF, pos);
+				dmgDrawCarCollidingParticles(pos, impulse);
+				if(Damage.ApplyDamage(COMPONENT_PANEL_FRONT_LEFT, impulse*impulseMult, pHandling->fCollisionDamageMultiplier)){
+					SetPanelDamage(CAR_WING_LF, VEHPANEL_FRONT_LEFT);
+					doubleMoney = true;
+				}
+				break;
+			case CAR_PIECE_WING_RF:
+				GetComponentWorldPosition(CAR_WING_RF, pos);
+				dmgDrawCarCollidingParticles(pos, impulse);
+				if(Damage.ApplyDamage(COMPONENT_PANEL_FRONT_RIGHT, impulse*impulseMult, pHandling->fCollisionDamageMultiplier)){
+					SetPanelDamage(CAR_WING_RF, VEHPANEL_FRONT_RIGHT);
+					doubleMoney = true;
+				}
+				break;
+			case CAR_PIECE_WING_LR:
+				GetComponentWorldPosition(CAR_WING_LR, pos);
+				dmgDrawCarCollidingParticles(pos, impulse);
+				if(Damage.ApplyDamage(COMPONENT_PANEL_REAR_LEFT, impulse*impulseMult, pHandling->fCollisionDamageMultiplier)){
+					SetPanelDamage(CAR_WING_LR, VEHPANEL_REAR_LEFT);
+					doubleMoney = true;
+				}
+				break;
+			case CAR_PIECE_WING_RR:
+				GetComponentWorldPosition(CAR_WING_RR, pos);
+				dmgDrawCarCollidingParticles(pos, impulse);
+				if(Damage.ApplyDamage(COMPONENT_PANEL_REAR_RIGHT, impulse*impulseMult, pHandling->fCollisionDamageMultiplier)){
+					SetPanelDamage(CAR_WING_RR, VEHPANEL_REAR_RIGHT);
+					doubleMoney = true;
+				}
+				break;
+
+			case CAR_PIECE_WHEEL_LF:
+			case CAR_PIECE_WHEEL_LR:
+			case CAR_PIECE_WHEEL_RF:
+			case CAR_PIECE_WHEEL_RR:
+				break;
+
+			case CAR_PIECE_WINDSCREEN:
+				if(Damage.ApplyDamage(COMPONENT_PANEL_WINDSCREEN, impulse*impulseMult, pHandling->fCollisionDamageMultiplier)){
+					uint8 oldStatus = Damage.GetPanelStatus(VEHPANEL_WINDSCREEN);
+					SetPanelDamage(CAR_WINDSCREEN, VEHPANEL_WINDSCREEN);
+					if(oldStatus != Damage.GetPanelStatus(VEHPANEL_WINDSCREEN)){
+						DMAudio.PlayOneShot(m_audioEntityId, SOUND_CAR_WINDSHIELD_CRACK, 0.0f);
+						doubleMoney = true;
+					}
+				}
+				break;
+			}
+
+			if(m_pDamageEntity && m_pDamageEntity == FindPlayerVehicle() && impulse > 10.0f){
+				int money = (doubleMoney ? 2 : 1) * impulse*pHandling->nMonetaryValue/1000000.0f;
+				money = min(money, 40);
+				if(money > 2){
+					sprintf(gString, "$%d", money);
+					CWorld::Players[CWorld::PlayerInFocus].m_nMoney += money;
+				}
+			}
+		}
+
+		float damage = (impulse-25.0f)*pHandling->fCollisionDamageMultiplier*0.6f*damageMultiplier;
+
+		if(GetModelIndex() == MI_SECURICA && m_pDamageEntity && m_pDamageEntity->m_status == STATUS_PLAYER)
+			damage *= 7.0f;
+
+		if(damage > 0.0f){
+			int oldHealth = m_fHealth;
+			if(this == FindPlayerVehicle()){
+				m_fHealth -= bTakeLessDamage ? damage/6.0f : damage/2.0f;
+			}else{
+				if(damage > 35.0f && pDriver)
+					pDriver->Say(SOUND_PED_CAR_COLLISION);
+				m_fHealth -= bTakeLessDamage ? damage/12.0f : damage/4.0f;
+			}
+			if(m_fHealth <= 0.0f && oldHealth > 0)
+				m_fHealth = 1.0f;
+		}
+
+		// play sound if a light broke
+		for(i = 0; i < 4; i++)
+			if(oldLightStatus[i] != 1 && Damage.GetLightStatus((eLights)i) == 1){
+				DMAudio.PlayOneShot(m_audioEntityId, SOUND_CAR_LIGHT_BREAK, i);	// BUG? i?
+				break;
+			}
+	}
+
+	if(m_fHealth < 250.0f){
+		// Car is on fire
+		if(Damage.GetEngineStatus() < ENGINE_STATUS_ON_FIRE){
+			// Set engine on fire and remember who did this
+			Damage.SetEngineStatus(ENGINE_STATUS_ON_FIRE);
+			m_fFireBlowUpTimer = 0.0f;
+			m_pSetOnFireEntity = m_pDamageEntity;
+			if(m_pSetOnFireEntity)
+				m_pSetOnFireEntity->RegisterReference(&m_pSetOnFireEntity);
+		}
+	}else{
+		if(GetModelIndex() == MI_BFINJECT){
+			if(m_fHealth < 400.0f)
+				Damage.SetEngineStatus(200);
+			else if(m_fHealth < 600.0f)
+				Damage.SetEngineStatus(100);
+		}
+	}
+}
+
+void
+CAutomobile::dmgDrawCarCollidingParticles(const CVector &pos, float amount)
+{
+	int i, n;
+
+	if(!GetIsOnScreen())
+		return;
+
+	// FindPlayerSpeed() unused
+
+	n = (int)amount/20;
+
+	for(i = 0; i < ((n+4)&0x1F); i++)
+		CParticle::AddParticle(PARTICLE_SPARK_SMALL, pos,
+			CVector(CGeneral::GetRandomNumberInRange(-0.1f, 0.1f),
+			        CGeneral::GetRandomNumberInRange(-0.1f, 0.1f),
+			        0.006f));
+
+	for(i = 0; i < n+2; i++)
+		CParticle::AddParticle(PARTICLE_CARCOLLISION_DUST,
+			CVector(CGeneral::GetRandomNumberInRange(-1.2f, 1.2f) + pos.x,
+			        CGeneral::GetRandomNumberInRange(-1.2f, 1.2f) + pos.y,
+			        pos.z),
+			CVector(0.0f, 0.0f, 0.0f), nil, 0.5f);
+
+	n = (int)amount/50 + 1;
+	for(i = 0; i < n; i++)
+		CParticle::AddParticle(PARTICLE_CAR_DEBRIS, pos,
+			CVector(CGeneral::GetRandomNumberInRange(-0.25f, 0.25f),
+			        CGeneral::GetRandomNumberInRange(-0.25f, 0.25f),
+			        CGeneral::GetRandomNumberInRange(0.1f, 0.25f)),
+			nil,
+			CGeneral::GetRandomNumberInRange(0.02f, 0.08f),
+			CVehicleModelInfo::ms_vehicleColourTable[m_currentColour1],
+			CGeneral::GetRandomNumberInRange(-40.0f, 40.0f),
+			0,
+			CGeneral::GetRandomNumberInRange(0.0f, 4.0f));
+}
 
 void
 CAutomobile::GetComponentWorldPosition(int32 component, CVector &pos)
@@ -390,6 +2141,7 @@ CAutomobile::BlowUpCar(CEntity *culprit)
 		SetDoorDamage(CAR_DOOR_LR, DOOR_REAR_LEFT);
 		SetDoorDamage(CAR_DOOR_RR, DOOR_REAR_RIGHT);
 		SpawnFlyingComponent(CAR_WHEEL_LF, COMPGROUP_WHEEL);
+		atomic = nil;
 		RwFrameForAllObjects(m_aCarNodes[CAR_WHEEL_LF], GetCurrentAtomicObjectCB, &atomic);
 		if(atomic)
 			RpAtomicSetFlags(atomic, 0);
@@ -397,7 +2149,7 @@ CAutomobile::BlowUpCar(CEntity *culprit)
 
 	m_fHealth = 0.0f;
 	m_nBombTimer = 0;
-	m_auto_flagA7 = 0;
+	m_bombType = CARBOMB_NONE;
 
 	TheCamera.CamShake(0.7f, GetPosition().x, GetPosition().y, GetPosition().z);
 
@@ -533,8 +2285,8 @@ CAutomobile::PlayCarHorn(void)
 void
 CAutomobile::PlayHornIfNecessary(void)
 {
-	if(m_autoPilot.m_flag2 ||
-	   m_autoPilot.m_flag1)
+	if(AutoPilot.m_flag2 ||
+	   AutoPilot.m_flag1)
 		if(!HasCarStoppedBecauseOfLight())
 			PlayCarHorn();
 }
@@ -546,9 +2298,9 @@ CAutomobile::ResetSuspension(void)
 	int i;
 	for(i = 0; i < 4; i++){
 		m_aSuspensionSpringRatio[i] = 1.0f;
-		m_aWheelSkidThing[i] = 0.0f;
+		m_aWheelTimer[i] = 0.0f;
 		m_aWheelRotation[i] = 0.0f;
-		m_aWheelState[i] = 0;	// TODO: enum?
+		m_aWheelState[i] = WHEEL_STATE_0;
 	}
 }
 
@@ -567,23 +2319,23 @@ CAutomobile::SetupSuspensionLines(void)
 		m_aWheelPosition[i] = posn.z;
 
 		// uppermost wheel position
-		posn.z += m_handling->fSuspensionUpperLimit;
+		posn.z += pHandling->fSuspensionUpperLimit;
 		colModel->lines[i].p0 = posn;
 
 		// lowermost wheel position
-		posn.z += m_handling->fSuspensionLowerLimit - m_handling->fSuspensionUpperLimit;
+		posn.z += pHandling->fSuspensionLowerLimit - pHandling->fSuspensionUpperLimit;
 		// lowest point on tyre
 		posn.z -= mi->m_wheelScale*0.5f;
 		colModel->lines[i].p1 = posn;
 
 		// this is length of the spring at rest
-		m_aSuspensionSpringLength[i] = m_handling->fSuspensionUpperLimit - m_handling->fSuspensionLowerLimit;
+		m_aSuspensionSpringLength[i] = pHandling->fSuspensionUpperLimit - pHandling->fSuspensionLowerLimit;
 		m_aSuspensionLineLength[i] = colModel->lines[i].p0.z - colModel->lines[i].p1.z;
 	}
 
 	// Compress spring somewhat to get normal height on road
 	m_fHeightAboveRoad = -(colModel->lines[0].p0.z + (colModel->lines[0].p1.z - colModel->lines[0].p0.z)*
-	                                                  (1.0f - 1.0f/(8.0f*m_handling->fSuspensionForceLevel)));
+	                                                  (1.0f - 1.0f/(8.0f*pHandling->fSuspensionForceLevel)));
 	for(i = 0; i < 4; i++)
 		m_aWheelPosition[i] = mi->m_wheelScale*0.5f - m_fHeightAboveRoad;
 
@@ -606,7 +2358,7 @@ void
 CAutomobile::ScanForCrimes(void)
 {
 	if(FindPlayerVehicle() && FindPlayerVehicle()->IsCar())
-		if(FindPlayerVehicle()->m_nAlarmState != -1)
+		if(FindPlayerVehicle()->IsAlarmOn())
 			// if player's alarm is on, increase wanted level
 			if((FindPlayerVehicle()->GetPosition() - GetPosition()).MagnitudeSqr() < sq(20.0f))
 				CWorld::Players[CWorld::PlayerInFocus].m_pPed->SetWantedLevelNoDrop(1);
@@ -634,20 +2386,20 @@ CAutomobile::HasCarStoppedBecauseOfLight(void)
 	if(m_status != STATUS_SIMPLE && m_status != STATUS_PHYSICS)
 		return false;
 
-	if(m_autoPilot.m_nCurrentRouteNode && m_autoPilot.m_nNextRouteNode){
-		CPathNode *curnode = &ThePaths.m_pathNodes[m_autoPilot.m_nCurrentRouteNode];
+	if(AutoPilot.m_nCurrentRouteNode && AutoPilot.m_nNextRouteNode){
+		CPathNode *curnode = &ThePaths.m_pathNodes[AutoPilot.m_nCurrentRouteNode];
 		for(i = 0; i < curnode->numLinks; i++)
-			if(ThePaths.m_connections[curnode->firstLink + i] == m_autoPilot.m_nNextRouteNode)
+			if(ThePaths.m_connections[curnode->firstLink + i] == AutoPilot.m_nNextRouteNode)
 				break;
 		if(i < curnode->numLinks &&
 		   ThePaths.m_carPathLinks[ThePaths.m_carPathConnections[curnode->firstLink + i]].trafficLightType & 3)	// TODO
 			return true;
 	}
 
-	if(m_autoPilot.m_nCurrentRouteNode && m_autoPilot.m_nPrevRouteNode){
-		CPathNode *curnode = &ThePaths.m_pathNodes[m_autoPilot.m_nCurrentRouteNode];
+	if(AutoPilot.m_nCurrentRouteNode && AutoPilot.m_nPrevRouteNode){
+		CPathNode *curnode = &ThePaths.m_pathNodes[AutoPilot.m_nCurrentRouteNode];
 		for(i = 0; i < curnode->numLinks; i++)
-			if(ThePaths.m_connections[curnode->firstLink + i] == m_autoPilot.m_nPrevRouteNode)
+			if(ThePaths.m_connections[curnode->firstLink + i] == AutoPilot.m_nPrevRouteNode)
 				break;
 		if(i < curnode->numLinks &&
 		   ThePaths.m_carPathLinks[ThePaths.m_carPathConnections[curnode->firstLink + i]].trafficLightType & 3)	// TODO
@@ -734,7 +2486,7 @@ CAutomobile::Fix(void)
 
 	Damage.ResetDamageStatus();
 
-	if(m_handling->Flags & HANDLING_NO_DOORS){
+	if(pHandling->Flags & HANDLING_NO_DOORS){
 		Damage.SetDoorStatus(DOOR_FRONT_LEFT, DOOR_STATUS_MISSING);
 		Damage.SetDoorStatus(DOOR_FRONT_RIGHT, DOOR_STATUS_MISSING);
 		Damage.SetDoorStatus(DOOR_REAR_LEFT, DOOR_STATUS_MISSING);
@@ -860,7 +2612,7 @@ CAutomobile::SpawnFlyingComponent(int32 component, uint32 type)
 	obj->m_fElasticity = 0.1f;
 	obj->m_fBuoyancy = obj->m_fMass*GRAVITY/0.75f;
 	obj->ObjectCreatedBy = TEMP_OBJECT;
-	obj->bIsStatic = true;
+	obj->bIsStatic = false;
 	obj->bIsPickup = false;
 	obj->bUseVehicleColours = true;
 	obj->m_colour1 = m_currentColour1;
@@ -987,7 +2739,7 @@ CAutomobile::SetDoorDamage(int32 component, eDoors door, bool noFlyingComponents
 		return;
 	}
 
-	if(door == DOOR_BOOT && status == DOOR_STATUS_SWINGING && m_handling->Flags & HANDLING_NOSWING_BOOT){
+	if(door == DOOR_BOOT && status == DOOR_STATUS_SWINGING && pHandling->Flags & HANDLING_NOSWING_BOOT){
 		Damage.SetDoorStatus(DOOR_BOOT, DOOR_STATUS_MISSING);
 		status = DOOR_STATUS_MISSING;
 	}
@@ -1051,7 +2803,7 @@ CAutomobile::SetTaxiLight(bool light)
 bool
 CAutomobile::GetAllWheelsOffGround(void)
 {
-	return m_nWheelsOnGround == 0;
+	return m_nDriveWheelsOnGround == 0;
 }
 
 void
@@ -1091,7 +2843,7 @@ public:
 
 	int32 ProcessEntityCollision_(CEntity *ent, CColPoint *colpoints){ return CAutomobile::ProcessEntityCollision(ent, colpoints); }
 
-	void ProcessControlInputs_(uint8 x) { CAutomobile::ProcessControlInputs(x); }
+	void ProcessControlInputs_(uint8 pad) { CAutomobile::ProcessControlInputs(pad); }
 	void GetComponentWorldPosition_(int32 component, CVector &pos) { CAutomobile::GetComponentWorldPosition(component, pos); }
 	bool IsComponentPresent_(int32 component) { return CAutomobile::IsComponentPresent(component); }
 	void SetComponentRotation_(int32 component, CVector rotation) { CAutomobile::SetComponentRotation(component, rotation); }
@@ -1113,8 +2865,10 @@ public:
 STARTPATCHES
 	InjectHook(0x52D170, &CAutomobile_::dtor, PATCH_JUMP);
 	InjectHook(0x52D190, &CAutomobile_::SetModelIndex_, PATCH_JUMP);
+	InjectHook(0x531470, &CAutomobile_::ProcessControl_, PATCH_JUMP);
 	InjectHook(0x535180, &CAutomobile_::Teleport_, PATCH_JUMP);
 	InjectHook(0x53B270, &CAutomobile_::ProcessEntityCollision_, PATCH_JUMP);
+	InjectHook(0x53B660, &CAutomobile_::ProcessControlInputs_, PATCH_JUMP);
 	InjectHook(0x52E5F0, &CAutomobile_::GetComponentWorldPosition_, PATCH_JUMP);
 	InjectHook(0x52E660, &CAutomobile_::IsComponentPresent_, PATCH_JUMP);
 	InjectHook(0x52E680, &CAutomobile_::SetComponentRotation_, PATCH_JUMP);
@@ -1129,6 +2883,8 @@ STARTPATCHES
 	InjectHook(0x53C0E0, &CAutomobile_::BurstTyre_, PATCH_JUMP);
 	InjectHook(0x437690, &CAutomobile_::GetHeightAboveRoad_, PATCH_JUMP);
 	InjectHook(0x53C450, &CAutomobile_::PlayCarHorn_, PATCH_JUMP);
+	InjectHook(0x53E090, &CAutomobile::PlaceOnRoadProperly, PATCH_JUMP);
+	InjectHook(0x52F030, &CAutomobile::dmgDrawCarCollidingParticles, PATCH_JUMP);
 	InjectHook(0x5353A0, &CAutomobile::ResetSuspension, PATCH_JUMP);
 	InjectHook(0x52D210, &CAutomobile::SetupSuspensionLines, PATCH_JUMP);
 	InjectHook(0x53E000, &CAutomobile::BlowUpCarsInPath, PATCH_JUMP);
diff --git a/src/vehicles/Automobile.h b/src/vehicles/Automobile.h
index 60e08d0a..1a103777 100644
--- a/src/vehicles/Automobile.h
+++ b/src/vehicles/Automobile.h
@@ -6,6 +6,25 @@
 
 class CObject;
 
+// These are used for all the wheel arrays
+// DON'T confuse with VEHWHEEL, which are vehicle components
+enum {
+	CARWHEEL_FRONT_LEFT,
+	CARWHEEL_REAR_LEFT,
+	CARWHEEL_FRONT_RIGHT,
+	CARWHEEL_REAR_RIGHT
+};
+
+enum eBombType
+{
+	CARBOMB_NONE,
+	CARBOMB_TIMED,
+	CARBOMB_ONIGNITION,
+	CARBOMB_REMOTE,
+	CARBOMB_TIMEDACTIVE,
+	CARBOMB_ONIGNITIONACTIVE,
+};
+
 class CAutomobile : public CVehicle
 {
 public:
@@ -16,7 +35,7 @@ public:
 	CColPoint m_aWheelColPoints[4];
 	float m_aSuspensionSpringRatio[4];
 	float m_aSuspensionSpringRatioPrev[4];
-	float m_aWheelSkidThing[4];
+	float m_aWheelTimer[4];		// set to 4.0 when wheel is touching ground, then decremented
 	float field_49C;
 	bool m_aWheelSkidmarkMuddy[4];
 	bool m_aWheelSkidmarkBloody[4];
@@ -24,39 +43,45 @@ public:
 	float m_aWheelPosition[4];
 	float m_aWheelSpeed[4];
 	uint8 field_4D8;
-	uint8 m_auto_flagA7 : 1;
+	uint8 m_bombType : 3;
 	uint8 bTaxiLight : 1;
-	uint8 m_auto_flagA10 : 1;
+	uint8 bHadDriver : 1;		// for bombs
 	uint8 m_auto_flagA20 : 1;
 	uint8 m_auto_flagA40 : 1;
 	uint8 m_auto_flagA80 : 1;
-	uint8 field_4DA[10];
+	uint8 bNotDamagedUpsideDown : 1;
+	uint8 bMoreResistantToDamage : 1;
+	uint8 field_4DB;
+	CEntity *m_pBombRigger;
+	int16 field_4E0;
+	int16 field_4E2;
 	uint32 m_nBusDoorTimerEnd;
 	uint32 m_nBusDoorTimerStart;
 	float m_aSuspensionSpringLength[4];
 	float m_aSuspensionLineLength[4];
 	float m_fHeightAboveRoad;
-	float m_fImprovedHandling;
-	uint8 stuff6[28];
-	float field_530;
+	float m_fTraction;
+	float m_fVelocityChangeForAudio;
+	float m_randomValues[6];	// used for what?
+	float m_fFireBlowUpTimer;
 	CPhysical *m_aGroundPhysical[4];	// physicals touching wheels
 	CVector m_aGroundOffset[4];		// from ground object to colpoint
-	CEntity *m_pBlowUpEntity;
-	float m_weaponThingA;	// TODO
-	float m_weaponThingB;	// TODO
+	CEntity *m_pSetOnFireEntity;
+	float m_weaponDoorTimerLeft;	// still don't know what exactly this is
+	float m_weaponDoorTimerRight;
 	float m_fCarGunLR;
 	float m_fCarGunUD;
 	float m_fWindScreenRotation;
 	uint8 stuff4[4];
-	uint8 m_nWheelsOnGround_2;
 	uint8 m_nWheelsOnGround;
-	uint8 m_nWheelsOnGroundPrev;
-	uint8 stuff5[5];
-	int32 m_aWheelState[4];
+	uint8 m_nDriveWheelsOnGround;
+	uint8 m_nDriveWheelsOnGroundPrev;
+	int32 field_594;
+	tWheelState m_aWheelState[4];
 
 	static bool &m_sAllTaxiLights;
 
-	CAutomobile(int, uint8);
+	CAutomobile(int32, uint8);
 
 	// from CEntity
 	void SetModelIndex(uint32 id);
@@ -87,6 +112,16 @@ public:
 	float GetHeightAboveRoad(void);
 	void PlayCarHorn(void);
 
+	void FireTruckControl(void);
+	void TankControl(void);
+	void HydraulicControl(void);
+	void VehicleDamage(float impulse, uint16 damagedPiece);
+	void ProcessBuoyancy(void);
+	void DoDriveByShootings(void);
+	int32 RcbanditCheckHitWheels(void);
+	int32 RcbanditCheck1CarWheels(CPtrList &list);
+	void PlaceOnRoadProperly(void);
+	void dmgDrawCarCollidingParticles(const CVector &pos, float amount);
 	void PlayHornIfNecessary(void);
 	void ResetSuspension(void);
 	void SetupSuspensionLines(void);
@@ -113,7 +148,5 @@ public:
 	void ReduceHornCounter(void);
 
 	static void SetAllTaxiLights(bool set);
-
-	CAutomobile* ctor(int, uint8);
 };
 static_assert(sizeof(CAutomobile) == 0x5A8, "CAutomobile: error");
diff --git a/src/vehicles/DamageManager.cpp b/src/vehicles/DamageManager.cpp
index 380537f2..3a7bd9e9 100644
--- a/src/vehicles/DamageManager.cpp
+++ b/src/vehicles/DamageManager.cpp
@@ -7,6 +7,13 @@
 
 float G_aComponentDamage[] = { 2.5f, 1.25f, 3.2f, 1.4f, 2.5f, 2.8f, 0.5f };
 
+CDamageManager::CDamageManager(void)
+{
+	ResetDamageStatus();
+	m_fWheelDamageEffect = 0.75f;
+	field_24 = 1;
+}
+
 void
 CDamageManager::ResetDamageStatus(void)
 {
@@ -18,15 +25,15 @@ CDamageManager::FuckCarCompletely(void)
 {
 	int i;
 
-	m_wheelStatus[0] = 2;
+	m_wheelStatus[0] = WHEEL_STATUS_MISSING;
 	// wheels 1-3 not reset?
 
-	m_doorStatus[0] = 3;
-	m_doorStatus[1] = 3;
-	m_doorStatus[2] = 3;
-	m_doorStatus[3] = 3;
-	m_doorStatus[4] = 3;
-	m_doorStatus[5] = 3;
+	m_doorStatus[0] = DOOR_STATUS_MISSING;
+	m_doorStatus[1] = DOOR_STATUS_MISSING;
+	m_doorStatus[2] = DOOR_STATUS_MISSING;
+	m_doorStatus[3] = DOOR_STATUS_MISSING;
+	m_doorStatus[4] = DOOR_STATUS_MISSING;
+	m_doorStatus[5] = DOOR_STATUS_MISSING;
 
 	for(i = 0; i < 3; i++){
 #ifdef FIX_BUGS
@@ -216,8 +223,8 @@ CDamageManager::ProgressEngineDamage(void)
 {
 	int status = GetEngineStatus();
 	int newstatus = status + 32 + (CGeneral::GetRandomNumber() & 0x1F);
-	if(status < 225 && newstatus > 224)
-		newstatus = 224;
+	if(status < ENGINE_STATUS_ON_FIRE && newstatus > ENGINE_STATUS_ON_FIRE-1)
+		newstatus = ENGINE_STATUS_ON_FIRE-1;
 	SetEngineStatus(newstatus);
 	return true;
 }
diff --git a/src/vehicles/DamageManager.h b/src/vehicles/DamageManager.h
index b815f724..adcd7430 100644
--- a/src/vehicles/DamageManager.h
+++ b/src/vehicles/DamageManager.h
@@ -4,6 +4,11 @@
 
 // TODO: move some of this into Vehicle.h
 
+enum eEngineStatus
+{
+	ENGINE_STATUS_ON_FIRE = 225
+};
+
 enum eDoorStatus
 {
 	DOOR_STATUS_OK,
@@ -23,7 +28,8 @@ enum ePanelStatus
 enum eWheelStatus
 {
 	WHEEL_STATUS_OK,
-	WHEEL_STATUS_BURST
+	WHEEL_STATUS_BURST,
+	WHEEL_STATUS_MISSING
 };
 
 enum tComponent
@@ -65,7 +71,7 @@ class CDamageManager
 {
 public:
 
-	float field_0;
+	float m_fWheelDamageEffect;
 	uint8 m_engineStatus;
 	uint8 m_wheelStatus[4];
 	uint8 m_doorStatus[6];
@@ -73,6 +79,8 @@ public:
 	uint32 m_panelStatus;
 	uint32 field_24;
 
+	CDamageManager(void);
+
 	void ResetDamageStatus(void);
 	void FuckCarCompletely(void);
 	bool ApplyDamage(tComponent component, float damage, float unused);
diff --git a/src/vehicles/Door.h b/src/vehicles/Door.h
index fc771a40..7bb7bba3 100644
--- a/src/vehicles/Door.h
+++ b/src/vehicles/Door.h
@@ -26,6 +26,12 @@ struct CDoor
 	CVector m_vecSpeed;
 
 	CDoor(void);
+	void Init(float minAngle, float maxAngle, int8 dir, int8 axis) {
+		m_fMinAngle = minAngle;
+		m_fMaxAngle = maxAngle;
+		m_nDirn = dir;
+		m_nAxis = axis;
+	}
 	void Open(float ratio);
 	void Process(CVehicle *veh);
 	float RetAngleWhenClosed(void);
diff --git a/src/vehicles/Floater.cpp b/src/vehicles/Floater.cpp
new file mode 100644
index 00000000..cabe00c3
--- /dev/null
+++ b/src/vehicles/Floater.cpp
@@ -0,0 +1,195 @@
+#include "common.h"
+#include "patcher.h"
+#include "Timer.h"
+#include "WaterLevel.h"
+#include "ModelIndices.h"
+#include "Physical.h"
+#include "Vehicle.h"
+#include "Floater.h"
+
+cBuoyancy &mod_Buoyancy = *(cBuoyancy*)0x8F2674;
+
+//static float fVolMultiplier = 1.0f;
+static float &fVolMultiplier = *(float*)0x601394;
+// amount of boat volume in bounding box
+// 1.0-volume is the empty space in the bbox
+static float fBoatVolumeDistribution[9] = {
+	// rear
+	0.75f, 0.9f, 0.75f,
+	0.95f, 1.0f, 0.95f,
+	0.3f, 0.7f, 0.3f
+	// bow
+};
+
+bool
+cBuoyancy::ProcessBuoyancy(CPhysical *phys, float buoyancy, CVector *impulse, CVector *point)
+{
+	m_numSteps = 2.0f;
+
+	if(!CWaterLevel::GetWaterLevel(phys->GetPosition(), &m_waterlevel, phys->m_flagD8))
+		return false;
+	m_matrix = phys->GetMatrix();
+
+	PreCalcSetup(phys, buoyancy);
+	SimpleCalcBuoyancy();
+	float f = CalcBuoyancyForce(phys, impulse, point);
+	if(m_isBoat)
+		return true;
+	return f != 0.0f;
+}
+
+void
+cBuoyancy::PreCalcSetup(CPhysical *phys, float buoyancy)
+{
+	CColModel *colModel;
+
+	m_isBoat = phys->IsVehicle() && ((CVehicle*)phys)->IsBoat();
+	colModel = phys->GetColModel();
+	m_dimMin = colModel->boundingBox.min;
+	m_dimMax = colModel->boundingBox.max;
+
+	if(m_isBoat){
+		if(phys->GetModelIndex() == MI_PREDATOR){
+			m_dimMax.y *= 0.9f;
+			m_dimMin.y *= 0.9f;
+		}else if(phys->GetModelIndex() == MI_SPEEDER){
+			m_dimMax.y *= 1.1f;
+			m_dimMin.y *= 0.9f;
+		}else if(phys->GetModelIndex() == MI_REEFER){
+			m_dimMin.y *= 0.9f;
+		}else{
+			m_dimMax.y *= 0.9f;
+			m_dimMin.y *= 0.9f;
+		}
+	}
+
+	m_step = (m_dimMax - m_dimMin)/m_numSteps;
+
+	if(m_step.z > m_step.x && m_step.z > m_step.y){
+		m_stepRatio.x = m_step.x/m_step.z;
+		m_stepRatio.y = m_step.y/m_step.z;
+		m_stepRatio.z = 1.0f;
+	}else if(m_step.y > m_step.x && m_step.y > m_step.z){
+		m_stepRatio.x = m_step.x/m_step.y;
+		m_stepRatio.y = 1.0f;
+		m_stepRatio.z = m_step.z/m_step.y;
+	}else{
+		m_stepRatio.x = 1.0f;
+		m_stepRatio.y = m_step.y/m_step.x;
+		m_stepRatio.z = m_step.z/m_step.x;
+	}
+
+	m_haveVolume = false;
+	m_numPartialVolumes = 1.0f;
+	m_volumeUnderWater = 0.0f;
+	m_impulse = CVector(0.0f, 0.0f, 0.0f);
+	m_position = phys->GetPosition();
+	m_positionZ = CVector(0.0f, 0.0f, m_position.z);
+	m_buoyancy = buoyancy;
+	m_waterlevel += m_waterLevelInc;
+}
+
+void
+cBuoyancy::SimpleCalcBuoyancy(void)
+{
+	float x, y;
+	int ix, i;
+	tWaterLevel waterPosition;
+
+	// Floater is divided into 3x3 parts. Process and sum each of them
+	ix = 0;
+	for(x = m_dimMin.x; x <= m_dimMax.x; x += m_step.x){
+		i = ix;
+		for(y = m_dimMin.y; y <= m_dimMax.y; y += m_step.y){
+			CVector waterLevel(x, y, 0.0f);
+			FindWaterLevel(m_positionZ, &waterLevel, &waterPosition);
+			fVolMultiplier = m_isBoat ? fBoatVolumeDistribution[i] : 1.0f;
+			if(waterPosition != FLOATER_ABOVE_WATER)
+				SimpleSumBuoyancyData(waterLevel, waterPosition);
+			i += 3;
+		}
+		ix++;
+	}
+
+	m_volumeUnderWater /= (m_dimMax.z - m_dimMin.z)*sq(m_numSteps+1.0f);
+}
+
+float
+cBuoyancy::SimpleSumBuoyancyData(CVector &waterLevel, tWaterLevel waterPosition)
+{
+	static float fThisVolume;
+	static CVector AverageOfWaterLevel;
+	static float fFraction;
+	static float fRemainingSlice;
+
+	float submerged = Abs(waterLevel.z - m_dimMin.z);
+	// subtract empty space from submerged volume
+	fThisVolume = submerged - (1.0f - fVolMultiplier);
+	if(fThisVolume < 0.0f)
+		return 0.0f;
+
+	if(m_isBoat){
+		fThisVolume *= fVolMultiplier;
+		if(fThisVolume < 0.5f)
+			fThisVolume = 2.0f*sq(fThisVolume);
+		if(fThisVolume < 1.0f)
+			fThisVolume = sq(fThisVolume);
+		fThisVolume = sq(fThisVolume);
+	}
+
+	m_volumeUnderWater += fThisVolume;
+
+	AverageOfWaterLevel.x = waterLevel.x * m_stepRatio.x;
+	AverageOfWaterLevel.y = waterLevel.y * m_stepRatio.y;
+	AverageOfWaterLevel.z = (waterLevel.z+m_dimMin.z)/2.0f * m_stepRatio.z;
+
+	if(m_flipAverage)
+		AverageOfWaterLevel = -AverageOfWaterLevel;
+
+	fFraction = 1.0f/m_numPartialVolumes;
+	fRemainingSlice = 1.0f - fFraction;
+	m_impulse = m_impulse*fRemainingSlice + AverageOfWaterLevel*fThisVolume*fFraction;
+	m_numPartialVolumes += 1.0f;
+	m_haveVolume = true;
+	return fThisVolume;
+}
+
+void
+cBuoyancy::FindWaterLevel(const CVector &zpos, CVector *waterLevel, tWaterLevel *waterPosition)
+{
+	*waterPosition = FLOATER_IN_WATER;
+	// waterLevel is a local x,y point
+	// m_position is the global position of our floater
+	// zpos is the global z coordinate of our floater
+	CVector xWaterLevel = Multiply3x3(m_matrix, *waterLevel);
+	CWaterLevel::GetWaterLevel(xWaterLevel.x + m_position.x, xWaterLevel.y + m_position.y, m_position.z,
+		&waterLevel->z, true);
+	waterLevel->z -= xWaterLevel.z + zpos.z;	// make local
+	if(waterLevel->z > m_dimMax.z){
+		waterLevel->z = m_dimMax.z;
+		*waterPosition = FLOATER_UNDER_WATER;
+	}else if(waterLevel->z < m_dimMin.z){
+		waterLevel->z = m_dimMin.z;
+		*waterPosition = FLOATER_ABOVE_WATER;
+	}
+}
+
+bool
+cBuoyancy::CalcBuoyancyForce(CPhysical *phys, CVector *impulse, CVector *point)
+{
+	if(!m_haveVolume)
+		return false;
+
+	*impulse = Multiply3x3(m_matrix, m_impulse);
+	*point = CVector(0.0f, 0.0f, m_volumeUnderWater*m_buoyancy*CTimer::GetTimeStep());
+	return true;
+}
+
+STARTPATCHES
+	InjectHook(0x546270, &cBuoyancy::ProcessBuoyancy, PATCH_JUMP);
+	InjectHook(0x546360, &cBuoyancy::PreCalcSetup, PATCH_JUMP);
+	InjectHook(0x5466F0, &cBuoyancy::SimpleCalcBuoyancy, PATCH_JUMP);
+	InjectHook(0x546820, &cBuoyancy::SimpleSumBuoyancyData, PATCH_JUMP);
+	InjectHook(0x546620, &cBuoyancy::FindWaterLevel, PATCH_JUMP);
+	InjectHook(0x5465A0, &cBuoyancy::CalcBuoyancyForce, PATCH_JUMP);
+ENDPATCHES
diff --git a/src/vehicles/Floater.h b/src/vehicles/Floater.h
new file mode 100644
index 00000000..ede2b9d0
--- /dev/null
+++ b/src/vehicles/Floater.h
@@ -0,0 +1,45 @@
+#pragma once
+
+class Physical;
+
+enum tWaterLevel
+{
+	FLOATER_ABOVE_WATER,
+	FLOATER_IN_WATER,
+	FLOATER_UNDER_WATER,
+};
+
+class cBuoyancy
+{
+public:
+	CVector m_position;
+	CMatrix m_matrix;
+	int m_field_54;
+	CVector m_positionZ;
+	float m_waterlevel;
+	float m_waterLevelInc;
+	float m_buoyancy;
+	CVector m_dimMax;
+	CVector m_dimMin;
+	float m_numPartialVolumes;
+	int m_field_8C;
+	int m_field_90;
+	int m_field_94;
+	bool m_haveVolume;
+	CVector m_step;
+	CVector m_stepRatio;
+	float m_numSteps;
+	bool m_flipAverage;
+	char m_field_B9;
+	bool m_isBoat;
+	float m_volumeUnderWater;
+	CVector m_impulse;
+
+	bool ProcessBuoyancy(CPhysical *phys, float buoyancy, CVector *impulse, CVector *point);
+	void PreCalcSetup(CPhysical *phys, float buoyancy);
+	void SimpleCalcBuoyancy(void);
+	float SimpleSumBuoyancyData(CVector &waterLevel, tWaterLevel waterPosition);
+	void FindWaterLevel(const CVector &zpos, CVector *waterLevel, tWaterLevel *waterPosition);
+	bool CalcBuoyancyForce(CPhysical *phys, CVector *impulse, CVector *point);
+};
+extern cBuoyancy &mod_Buoyancy;
diff --git a/src/vehicles/HandlingMgr.cpp b/src/vehicles/HandlingMgr.cpp
index 47d0564c..be96ab08 100644
--- a/src/vehicles/HandlingMgr.cpp
+++ b/src/vehicles/HandlingMgr.cpp
@@ -70,7 +70,7 @@ char VehicleNames[NUMHANDLINGS][14] = {
 
 cHandlingDataMgr::cHandlingDataMgr(void)
 {
-	memset(this, 0, sizeof(this));
+	memset(this, 0, sizeof(*this));
 }
 
 void
@@ -127,7 +127,7 @@ cHandlingDataMgr::LoadHandlingData(void)
 					handlingId = FindExactWord(word, (const char*)VehicleNames, 14, NUMHANDLINGS);
 					assert(handlingId >= 0 && handlingId < NUMHANDLINGS);
 					handling = &HandlingData[handlingId];
-					handling->nIdentifier = handlingId;
+					handling->nIdentifier = (eHandlingId)handlingId;
 					break;
 				case  1: handling->fMass = strtod(word, nil); break;
 				case  2: handling->Dimension.x = strtod(word, nil); break;
@@ -140,11 +140,11 @@ cHandlingDataMgr::LoadHandlingData(void)
 				case  9: handling->fTractionMultiplier = strtod(word, nil); break;
 				case 10: handling->fTractionLoss = strtod(word, nil); break;
 				case 11: handling->fTractionBias = strtod(word, nil); break;
-				case 12: handling->TransmissionData.nNumberOfGears = atoi(word); break;
-				case 13: handling->TransmissionData.fMaxVelocity = strtod(word, nil); break;
-				case 14: handling->TransmissionData.fEngineAcceleration = strtod(word, nil) * 0.4f; break;
-				case 15: handling->TransmissionData.nDriveType = word[0]; break;
-				case 16: handling->TransmissionData.nEngineType = word[0]; break;
+				case 12: handling->Transmission.nNumberOfGears = atoi(word); break;
+				case 13: handling->Transmission.fMaxVelocity = strtod(word, nil); break;
+				case 14: handling->Transmission.fEngineAcceleration = strtod(word, nil) * 0.4f; break;
+				case 15: handling->Transmission.nDriveType = word[0]; break;
+				case 16: handling->Transmission.nEngineType = word[0]; break;
 				case 17: handling->fBrakeDeceleration = strtod(word, nil); break;
 				case 18: handling->fBrakeBias = strtod(word, nil); break;
 				case 19: handling->bABS = !!atoi(word); break;
@@ -159,7 +159,7 @@ cHandlingDataMgr::LoadHandlingData(void)
 				case 28: handling->fSuspensionBias = strtod(word, nil); break;
 				case 29:
 					sscanf(word, "%x", &handling->Flags);
-					handling->TransmissionData.Flags = handling->Flags;
+					handling->Transmission.Flags = handling->Flags;
 					break;
 				case 30: handling->FrontLights = atoi(word); break;
 				case 31: handling->RearLights = atoi(word); break;
@@ -192,8 +192,8 @@ cHandlingDataMgr::ConvertDataToGameUnits(tHandlingData *handling)
 	// TODO: figure out what exactly is being converted here
 	float velocity, a, b, specificVolume;
 
-	handling->TransmissionData.fEngineAcceleration /= 2500.0f;
-	handling->TransmissionData.fMaxVelocity /= 180.0f;
+	handling->Transmission.fEngineAcceleration /= 2500.0f;
+	handling->Transmission.fMaxVelocity /= 180.0f;
 	handling->fBrakeDeceleration /= 2500.0f;
 	handling->fTurnMass = (sq(handling->Dimension.x) + sq(handling->Dimension.y)) * handling->fMass / 12.0f;
 	if(handling->fTurnMass < 10.0f)
@@ -205,27 +205,27 @@ cHandlingDataMgr::ConvertDataToGameUnits(tHandlingData *handling)
 	specificVolume = handling->Dimension.x*handling->Dimension.z*0.5f / handling->fMass;	// ?
 	a = 0.0f;
 	b = 100.0f;
-	velocity = handling->TransmissionData.fMaxVelocity;
+	velocity = handling->Transmission.fMaxVelocity;
 	while(a < b && velocity > 0.0f){
 		velocity -= 0.01;
-		a = handling->TransmissionData.fEngineAcceleration/6.0f;
+		a = handling->Transmission.fEngineAcceleration/6.0f;
 		b = -velocity * (1.0f/(specificVolume * sq(velocity) + 1.0f) - 1.0f);
 	}
 
 	if(handling->nIdentifier == HANDLING_RCBANDIT){
-		handling->TransmissionData.fUnkMaxVelocity = handling->TransmissionData.fMaxVelocity;
+		handling->Transmission.fUnkMaxVelocity = handling->Transmission.fMaxVelocity;
 	}else{
-		handling->TransmissionData.fUnkMaxVelocity = velocity;
-		handling->TransmissionData.fMaxVelocity = velocity * 1.2f;
+		handling->Transmission.fUnkMaxVelocity = velocity;
+		handling->Transmission.fMaxVelocity = velocity * 1.2f;
 	}
-	handling->TransmissionData.fMaxReverseVelocity = -0.2f;
+	handling->Transmission.fMaxReverseVelocity = -0.2f;
 
-	if(handling->TransmissionData.nDriveType == '4')
-		handling->TransmissionData.fEngineAcceleration /= 4.0f;
+	if(handling->Transmission.nDriveType == '4')
+		handling->Transmission.fEngineAcceleration /= 4.0f;
 	else
-		handling->TransmissionData.fEngineAcceleration /= 2.0f;
+		handling->Transmission.fEngineAcceleration /= 2.0f;
 
-	handling->TransmissionData.InitGearRatios();
+	handling->Transmission.InitGearRatios();
 }
 
 int32
diff --git a/src/vehicles/HandlingMgr.h b/src/vehicles/HandlingMgr.h
index 2627fbae..70f1c005 100644
--- a/src/vehicles/HandlingMgr.h
+++ b/src/vehicles/HandlingMgr.h
@@ -85,7 +85,7 @@ enum
 
 struct tHandlingData
 {
-	int32 nIdentifier;
+	eHandlingId nIdentifier;
 	float fMass;
 	float fInvMass;
 	float fTurnMass;
@@ -94,7 +94,7 @@ struct tHandlingData
 	int8 nPercentSubmerged;
 	float fBuoyancy;
 	float fTractionMultiplier;
-	cTransmission TransmissionData;
+	cTransmission Transmission;
 	float fBrakeDeceleration;
 	float fBrakeBias;
 	int8 bABS;
@@ -136,6 +136,8 @@ public:
 	void ConvertDataToGameUnits(tHandlingData *handling);
 	int32 GetHandlingId(const char *name);
 	tHandlingData *GetHandlingData(eHandlingId id) { return &HandlingData[id]; }
+	bool HasRearWheelDrive(eHandlingId id) { return HandlingData[id].Transmission.nDriveType == 'R'; }
+	bool HasFrontWheelDrive(eHandlingId id) { return HandlingData[id].Transmission.nDriveType == 'F'; }
 };
 VALIDATE_SIZE(cHandlingDataMgr, 0x3030);
 extern cHandlingDataMgr &mod_HandlingManager;
diff --git a/src/vehicles/Plane.h b/src/vehicles/Plane.h
index 1f54e529..e263766e 100644
--- a/src/vehicles/Plane.h
+++ b/src/vehicles/Plane.h
@@ -7,7 +7,17 @@ class CPlane : public CVehicle
 {
 public:
 	// 0x288
-	uint8 stuff[20];
+	int16 m_wIndex;
+	int16 field_650;
+	int16 m_wNextPathNode;
+	char field_654;
+	char field_655;
+	float field_656;
+	int m_nFrameWhenHit;
+	char m_bHasBeenHit;
+	char m_bIsIncomingCesna;
+	char m_bIsDropoffCesna;
+	char field_667;
 
 	CPlane(int, uint8);
 	~CPlane(void);
diff --git a/src/vehicles/Transmission.cpp b/src/vehicles/Transmission.cpp
index 2be25cbb..d500d004 100644
--- a/src/vehicles/Transmission.cpp
+++ b/src/vehicles/Transmission.cpp
@@ -1,5 +1,7 @@
 #include "common.h"
 #include "patcher.h"
+#include "Timer.h"
+#include "HandlingMgr.h"
 #include "Transmission.h"
 
 void
@@ -35,3 +37,107 @@ cTransmission::InitGearRatios(void)
 
 	Gears[1].fShiftDownVelocity = -0.01f;
 }
+
+void
+cTransmission::CalculateGearForSimpleCar(float speed, uint8 &gear)
+{
+	static tGear *pGearRatio;
+
+	pGearRatio = &Gears[gear];
+	fCurVelocity = speed;
+	if(speed > pGearRatio->fShiftUpVelocity)
+		gear++;
+	else if(speed < pGearRatio->fShiftDownVelocity){
+		if(gear - 1 < 0)
+			gear = 0;
+		else
+			gear--;
+	}
+}
+
+float
+cTransmission::CalculateDriveAcceleration(const float &gasPedal, uint8 &gear, float &time, const float &velocity, bool cheat)
+{
+	static float fAcceleration = 0.0f;
+	static float fVelocity;
+	static float fCheat;
+	static tGear *pGearRatio;
+
+	fVelocity = velocity;
+	if(fVelocity < fMaxReverseVelocity){
+		fVelocity = fMaxReverseVelocity;
+		return 0.0f;
+	}
+	if(fVelocity > fMaxVelocity){
+		fVelocity = fMaxVelocity;
+		return 0.0f;
+	}
+	fCurVelocity = fVelocity;
+
+	assert(gear <= nNumberOfGears);
+
+	pGearRatio = &Gears[gear];
+	if(fVelocity > pGearRatio->fShiftUpVelocity){
+		if(gear != 0 || gasPedal > 0.0f){
+			gear++;
+			time = 0.0f;
+			return CalculateDriveAcceleration(gasPedal, gear, time, fVelocity, false);
+		}
+	}else if(fVelocity < pGearRatio->fShiftDownVelocity && gear != 0){
+		if(gear != 1 || gasPedal < 0.0f){
+			gear--;
+			time = 0.0f;
+			return CalculateDriveAcceleration(gasPedal, gear, time, fVelocity, false);
+		}
+	}
+
+	if(time > 0.0f){
+		// changing gears currently, can't accelerate
+		fAcceleration = 0.0f;
+		time -= CTimer::GetTimeStepInSeconds();
+	}else{
+		float speedMul, accelMul;
+
+		if(gear < 1){
+			// going reverse
+			accelMul = (Flags & HANDLING_2G_BOOST) ? 2.0f : 1.0f;
+			speedMul = -1.0f;
+		}else if(nNumberOfGears == 1){
+			accelMul = 1.0f;
+			speedMul = 1.0f;
+		}else{
+			// BUG or not? this is 1.0 normally but 0.0 in the highest gear
+			float f = 1.0f - (gear-1)/(nNumberOfGears-1);
+			speedMul = 3.0f*sq(f) + 1.0f;
+			// This is pretty ugly, could be written more clearly
+			if(Flags & HANDLING_2G_BOOST){
+				if(gear == 1)
+					accelMul = (Flags & HANDLING_1G_BOOST) ? 3.0f : 2.0f;
+				else if(gear == 2)
+					accelMul = 1.3f;
+				else
+					accelMul = 1.0f;
+			}else if(Flags & HANDLING_1G_BOOST && gear == 1){
+				accelMul = 3.0f;
+			}else
+				accelMul = 1.0f;
+		}
+
+		if(cheat)
+			fCheat = 1.2f;
+		else
+			fCheat = 1.0f;
+		float targetVelocity = Gears[gear].fMaxVelocity*speedMul*fCheat;
+		float accel = fEngineAcceleration*accelMul * (targetVelocity - fVelocity)/Abs(targetVelocity);
+		if(Abs(fVelocity) < Abs(Gears[gear].fMaxVelocity*fCheat))
+			fAcceleration = gasPedal * accel * CTimer::GetTimeStep();
+		else
+			fAcceleration = 0.0f;
+	}
+	return fAcceleration;
+}
+
+STARTPATCHES
+	InjectHook(0x550A00, &cTransmission::CalculateGearForSimpleCar, PATCH_JUMP);
+	InjectHook(0x5506B0, &cTransmission::CalculateDriveAcceleration, PATCH_JUMP);
+ENDPATCHES
diff --git a/src/vehicles/Transmission.h b/src/vehicles/Transmission.h
index 686e0aca..8eeef1e8 100644
--- a/src/vehicles/Transmission.h
+++ b/src/vehicles/Transmission.h
@@ -20,7 +20,9 @@ public:
 	float fMaxVelocity;
 	float fUnkMaxVelocity;
 	float fMaxReverseVelocity;
-	float field_5C;
+	float fCurVelocity;
 
 	void InitGearRatios(void);
+	void CalculateGearForSimpleCar(float speed, uint8 &gear);
+	float CalculateDriveAcceleration(const float &gasPedal, uint8 &gear, float &time, const float &velocity, bool cheat);
 };
diff --git a/src/vehicles/Vehicle.cpp b/src/vehicles/Vehicle.cpp
index d8ed1a15..cc98bbe9 100644
--- a/src/vehicles/Vehicle.cpp
+++ b/src/vehicles/Vehicle.cpp
@@ -35,7 +35,7 @@ CVehicle::CVehicle(uint8 CreatedBy)
 	int i;
 
 	m_nCurrentGear = 0;
-	field_208 = 0;
+	m_fChangeGearTime = 0;
 	m_fSteerRatio = 0.0f;
 	m_type = ENTITY_TYPE_VEHICLE;
 	VehicleCreatedBy = CreatedBy;
@@ -56,16 +56,18 @@ CVehicle::CVehicle(uint8 CreatedBy)
 	for(i = 0; i < m_nNumMaxPassengers; i++)
 		pPassengers[i] = nil;
 	m_nBombTimer = 0;
-	m_pWhoSetMeOnFire = nil;
+	m_pBlowUpEntity = nil;
 	field_1FB = 0;
-	m_veh_flagB10 = false;
+	bComedyControls = false;
 	m_veh_flagB40 = false;
 	m_veh_flagB80 = false;
-	m_veh_flagC1 = false;
+	bTakeLessDamage = false;
 	bIsDamaged = false;
-	m_veh_flagC8 = false;
+	bFadeOut = false;
 	m_veh_flagC10 = false;
-	m_veh_flagC4 = false;
+	m_nTimeOfDeath = 0;
+	m_pCarFire = nil;
+	bHasBeenOwnedByPlayer = false;
 	m_veh_flagC20 = false;
 	bCanBeDamaged = true;
 	m_veh_flagC80 = false;
@@ -93,14 +95,14 @@ CVehicle::CVehicle(uint8 CreatedBy)
 	m_pCurGroundEntity = nil;
 	field_22A = 0;
 	field_22B = 0;
-	field_22F = 0;
+	m_comedyControlState = 0;
 	m_aCollPolys[0].valid = false;
 	m_aCollPolys[1].valid = false;
-	m_autoPilot.m_nCarMission = MISSION_NONE;
-	m_autoPilot.m_nAnimationId = TEMPACT_NONE;
-	m_autoPilot.m_nTimeToStartMission = CTimer::GetTimeInMilliseconds();
-	m_autoPilot.m_flag4 = false;
-	m_autoPilot.m_flag10 = false;
+	AutoPilot.m_nCarMission = MISSION_NONE;
+	AutoPilot.m_nAnimationId = TEMPACT_NONE;
+	AutoPilot.m_nTimeToStartMission = CTimer::GetTimeInMilliseconds();
+	AutoPilot.m_flag4 = false;
+	AutoPilot.m_flag10 = false;
 }
 
 CVehicle::~CVehicle()
@@ -259,7 +261,7 @@ CVehicle::ProcessWheel(CVector &wheelFwd, CVector &wheelRight, CVector &wheelCon
 
 	adhesion *= CTimer::GetTimeStep();
 	if(bAlreadySkidding)
-		adhesion *= m_handling->fTractionLoss;
+		adhesion *= pHandling->fTractionLoss;
 
 	// moving sideways
 	if(contactSpeedRight != 0.0f){
@@ -318,7 +320,7 @@ CVehicle::ProcessWheel(CVector &wheelFwd, CVector &wheelRight, CVector &wheelCon
 		}
 
 		float l = Sqrt(sq(right) + sq(fwd));
-		float tractionLoss = bAlreadySkidding ? 1.0f : m_handling->fTractionLoss;
+		float tractionLoss = bAlreadySkidding ? 1.0f : pHandling->fTractionLoss;
 		right *= adhesion * tractionLoss / l;
 		fwd *= adhesion * tractionLoss / l;
 	}
@@ -362,9 +364,9 @@ CVehicle::ExtinguishCarFire(void)
 		m_pCarFire->Extinguish();
 	if(IsCar()){
 		CAutomobile *car = (CAutomobile*)this;
-		if(car->Damage.GetEngineStatus() >= 225)
-			car->Damage.SetEngineStatus(215);
-		car->field_530 = 0.0f;
+		if(car->Damage.GetEngineStatus() >= ENGINE_STATUS_ON_FIRE)
+			car->Damage.SetEngineStatus(ENGINE_STATUS_ON_FIRE-10);
+		car->m_fFireBlowUpTimer = 0.0f;
 	}
 }
 
@@ -374,20 +376,21 @@ CVehicle::ProcessDelayedExplosion(void)
 	if(m_nBombTimer == 0)
 		return;
 
-	if(m_nBombTimer == 0){
-		int tick = CTimer::GetTimeStep()/60.0f*1000.0f;
-		if(tick > m_nBombTimer)
-			m_nBombTimer = 0;
-		else
-			m_nBombTimer -= tick;
+	int tick = CTimer::GetTimeStep()/60.0f*1000.0f;
+	if(tick > m_nBombTimer)
+		m_nBombTimer = 0;
+	else
+		m_nBombTimer -= tick;
 
-		if(IsCar() && ((CAutomobile*)this)->m_auto_flagA7 == 4 && (m_nBombTimer & 0xFE00) != 0xFE00)
-			DMAudio.PlayOneShot(m_audioEntityId, SOUND_CAR_BOMB_TICK, 0.0f);
+	if(IsCar() && ((CAutomobile*)this)->m_bombType == CARBOMB_TIMEDACTIVE && (m_nBombTimer & 0xFE00) != 0xFE00)
+		DMAudio.PlayOneShot(m_audioEntityId, SOUND_CAR_BOMB_TICK, 0.0f);
 
-		if(FindPlayerVehicle() != this && m_pWhoSetMeOnFire == FindPlayerPed())
-			CWorld::Players[CWorld::PlayerInFocus].AwardMoneyForExplosion(this);
-		BlowUpCar(m_pWhoSetMeOnFire);
-	}
+	if (m_nBombTimer != 0)
+		return;
+
+	if(FindPlayerVehicle() != this && m_pBlowUpEntity == FindPlayerPed())
+		CWorld::Players[CWorld::PlayerInFocus].AwardMoneyForExplosion(this);
+	BlowUpCar(m_pBlowUpEntity);
 }
 
 bool
@@ -449,7 +452,7 @@ CVehicle::IsVehicleNormal(void)
 bool
 CVehicle::CarHasRoof(void)
 {
-	if((m_handling->Flags & HANDLING_HAS_NO_ROOF) == 0)
+	if((pHandling->Flags & HANDLING_HAS_NO_ROOF) == 0)
 		return true;
 	if(m_aExtras[0] && m_aExtras[1])
 		return false;
@@ -519,7 +522,7 @@ bool
 CVehicle::CanPedOpenLocks(CPed *ped)
 {
 	if(m_nDoorLock == CARLOCK_LOCKED ||
-	   m_nDoorLock == CARLOCK_COP_CAR ||
+	   m_nDoorLock == CARLOCK_LOCKED_INITIALLY ||
 	   m_nDoorLock == CARLOCK_LOCKED_PLAYER_INSIDE)
 		return false;
 	if(ped->IsPlayer() && m_nDoorLock == CARLOCK_LOCKOUT_PLAYER_ONLY)
@@ -602,7 +605,7 @@ CVehicle::SetUpDriver(void)
 	pDriver->bInVehicle = true;
 	pDriver->SetPedState(PED_DRIVING);
 	if(bIsBus)
-		pDriver->m_ped_flagC4 = false;
+		pDriver->bRenderPedInCar = false;
 	return pDriver;
 }
 
@@ -618,7 +621,7 @@ CVehicle::SetupPassenger(int n)
 	pPassengers[n]->bInVehicle = true;
 	pPassengers[n]->SetPedState(PED_DRIVING);
 	if(bIsBus)
-		pPassengers[n]->m_ped_flagC4 = false;
+		pPassengers[n]->bRenderPedInCar = false;
 	return pPassengers[n];
 }
 
diff --git a/src/vehicles/Vehicle.h b/src/vehicles/Vehicle.h
index c293b8a6..38d411cd 100644
--- a/src/vehicles/Vehicle.h
+++ b/src/vehicles/Vehicle.h
@@ -20,7 +20,7 @@ enum eCarLock {
 	CARLOCK_LOCKED,
 	CARLOCK_LOCKOUT_PLAYER_ONLY,
 	CARLOCK_LOCKED_PLAYER_INSIDE,
-	CARLOCK_COP_CAR,
+	CARLOCK_LOCKED_INITIALLY,
 	CARLOCK_FORCE_SHUT_DOORS,
 	CARLOCK_SKIP_SHUT_DOORS
 };
@@ -98,10 +98,23 @@ enum eWheels
 
 enum
 {
-	CAR_PIECE_WHEEL_LF = 13,
+	CAR_PIECE_BONNET = 1,
+	CAR_PIECE_BOOT,
+	CAR_PIECE_BUMP_FRONT,
+	CAR_PIECE_BUMP_REAR,
+	CAR_PIECE_DOOR_LF,
+	CAR_PIECE_DOOR_RF,
+	CAR_PIECE_DOOR_LR,
+	CAR_PIECE_DOOR_RR,
+	CAR_PIECE_WING_LF,
+	CAR_PIECE_WING_RF,
+	CAR_PIECE_WING_LR,
+	CAR_PIECE_WING_RR,
+	CAR_PIECE_WHEEL_LF,
 	CAR_PIECE_WHEEL_LR,
 	CAR_PIECE_WHEEL_RF,
 	CAR_PIECE_WHEEL_RR,
+	CAR_PIECE_WINDSCREEN,
 };
 
 enum tWheelState
@@ -125,12 +138,12 @@ class CVehicle : public CPhysical
 {
 public:
 	// 0x128
-	tHandlingData *m_handling;
-	CAutoPilot m_autoPilot;
+	tHandlingData *pHandling;
+	CAutoPilot AutoPilot;
 	uint8 m_currentColour1;
 	uint8 m_currentColour2;
 	uint8 m_aExtras[2];
-	int16 m_nAlarmState; // m_nWantedStarsOnEnter on DK22
+	int16 m_nAlarmState;
 	int16 m_nMissionValue;
 	CPed *pDriver;
 	CPed *pPassengers[8];
@@ -144,7 +157,7 @@ public:
 	CFire *m_pCarFire;
 	float m_fSteerAngle;
 	float m_fGasPedal;
-	float m_fBreakPedal;
+	float m_fBrakePedal;
 	uint8 VehicleCreatedBy;
 
 	// cf. https://github.com/DK22Pac/plugin-sdk/blob/master/plugin_sa/game_sa/CVehicle.h from R*
@@ -161,15 +174,15 @@ public:
 	uint8 bIsBus: 1; // Is this vehicle a bus
 	uint8 bIsBig: 1; // Is this vehicle a bus
 	uint8 bLowVehicle: 1; // Need this for sporty type cars to use low getting-in/out anims
-	uint8 m_veh_flagB10 : 1;
-	uint8 m_veh_flagB20 : 1;
+	uint8 bComedyControls : 1; // Will make the car hard to control (hopefully in a funny way)
+	uint8 bWarnedPeds : 1; // Has scan and warn peds of danger been processed?
 	uint8 m_veh_flagB40 : 1;
 	uint8 m_veh_flagB80 : 1;
 
-	uint8 m_veh_flagC1 : 1;
+	uint8 bTakeLessDamage : 1; // This vehicle is stronger (takes about 1/4 of damage)
 	uint8 bIsDamaged : 1; // This vehicle has been damaged and is displaying all its components
-	uint8 m_veh_flagC4 : 1;
-	uint8 m_veh_flagC8 : 1;
+	uint8 bHasBeenOwnedByPlayer : 1;// To work out whether stealing it is a crime
+	uint8 bFadeOut : 1; // Fade vehicle out
 	uint8 m_veh_flagC10 : 1;
 	uint8 m_veh_flagC20 : 1;
 	uint8 bCanBeDamaged : 1; // Set to FALSE during cut scenes to avoid explosions
@@ -188,17 +201,17 @@ public:
 	uint8 m_nAmmoInClip;    // Used to make the guns on boat do a reload (20 by default)
 	int8 field_1FB;
 	int8 field_1FC[4];
-	float m_fHealth;           // 1000.0f = full health. 0 -> explode
+	float m_fHealth;           // 1000.0f = full health. 250.0f = fire. 0 -> explode
 	uint8 m_nCurrentGear;
 	int8 field_205[3];
-	int field_208;
+	float m_fChangeGearTime;
 	uint32 m_nGunFiringTime;    // last time when gun on vehicle was fired (used on boats)
 	uint32 m_nTimeOfDeath;
 	int16 field_214;
 	int16 m_nBombTimer;        // goes down with each frame
-	CPed *m_pWhoSetMeOnFire;
-	float field_21C;
-	float field_220;
+	CEntity *m_pBlowUpEntity;
+	float field_21C;	// front Z?
+	float field_220;	// rear Z?
 	eCarLock m_nDoorLock;
 	int8 m_nLastWeaponDamage; // see eWeaponType, -1 if no damage
 	int8 m_nRadioStation;
@@ -207,7 +220,7 @@ public:
 	uint8 m_nCarHornTimer;
 	int8 field_22D;
 	bool m_bSirenOrAlarm;
-	int8 field_22F;
+	int8 m_comedyControlState;
 	CStoredCollPoly m_aCollPolys[2];     // poly which is under front/rear part of car
 	float m_fSteerRatio;
 	eVehicleType m_vehType;
@@ -277,6 +290,8 @@ public:
 	void RemoveDriver(void);
 	void ProcessCarAlarm(void);
 	bool IsSphereTouchingVehicle(float sx, float sy, float sz, float radius);
+
+	bool IsAlarmOn(void) { return m_nAlarmState != 0 && m_nAlarmState != -1; }
 	
 	static bool &bWheelsOnlyCheat;
 	static bool &bAllDodosCheat;
@@ -305,3 +320,19 @@ inline uint8 GetVehDoorFlag(int32 carnode) {
 		return 0;
 	}
 }
+
+class cTransmission;
+
+class cVehicleParams
+{
+public:
+	char m_bDistanceCalculated;
+	char gap_1[3];
+	float m_fDistance;
+	CVehicle *m_pVehicle;
+	cTransmission *m_pTransmission;
+	int m_nIndex;
+	float m_fVelocityChange;
+};
+
+static_assert(sizeof(cVehicleParams) == 0x18, "CVehicle: error");