6 files changed, 374 insertions, 27 deletions

diff --git a/src/core/PlayerInfo.cpp b/src/core/PlayerInfo.cpp
index 85682ae3..fcdd60da 100644
--- a/src/core/PlayerInfo.cpp
+++ b/src/core/PlayerInfo.cpp
@@ -1,5 +1,6 @@
 #include "common.h"
 #include "patcher.h"
+#include "main.h"
 #include "PlayerPed.h"
 #include "PlayerInfo.h"
 #include "Frontend.h"
@@ -15,13 +16,17 @@
 #include "ProjectileInfo.h"
 #include "Explosion.h"
 #include "Script.h"
-#include "Vehicle.h"
+#include "Automobile.h"
 #include "HandlingMgr.h"
 #include "General.h"
-#include "main.h"
 #include "SpecialFX.h"
-
-WRAPPER void CPlayerInfo::Process(void) { EAXJMP(0x49FD30); }
+#include "Cranes.h"
+#include "Bridge.h"
+#include "WaterLevel.h"
+#include "PathFind.h"
+#include "ZoneCull.h"
+#include "Renderer.h"
+#include "Streaming.h"
 
 void
 CPlayerInfo::SetPlayerSkin(char *skin)
@@ -113,8 +118,8 @@ CPlayerInfo::Clear(void)
 	m_nTrafficMultiplier = 0;

 	m_fRoadDensity = 1.0f;

 	m_bInRemoteMode = false;

-	m_bSwitchTaxi = false;

-	m_nSwitchTaxiTime = 0;

+	m_bUnusedTaxiThing = false;

+	m_nUnusedTaxiTimer = 0;

 	m_nCollectedPackages = 0;

 	m_nTotalPackages = 3;

 	m_nTimeLastHealthLoss = 0;

@@ -306,6 +311,251 @@ INITSAVEBUF
 // VALIDATESAVEBUF(size)

 }
 
+void

+CPlayerInfo::FindClosestCarSectorList(CPtrList& carList, CPed* ped, float unk1, float unk2, float unk3, float unk4, float* lastClosestness, CVehicle** closestCarOutput)

+{

+	for (CPtrNode* node = carList.first; node; node = node->next) {

+		CVehicle *car = (CVehicle*)node->item;

+		if(car->m_scanCode != CWorld::GetCurrentScanCode()) {

+			if (!car->bUsesCollision || !car->IsVehicle())

+				continue;

+

+			car->m_scanCode = CWorld::GetCurrentScanCode();

+			if (car->m_status != STATUS_WRECKED && car->m_status != STATUS_TRAIN_MOVING

+				&& (car->GetUp().z > 0.3f || (car->IsVehicle() && ((CVehicle*)car)->m_vehType == VEHICLE_TYPE_BIKE))) {

+				CVector carCentre = car->GetBoundCentre();

+

+				if (Abs(ped->GetPosition().z - carCentre.z) < 2.0f) {

+					float dist = (ped->GetPosition() - carCentre).Magnitude2D();

+					if (dist <= 10.0f && !CCranes::IsThisCarBeingCarriedByAnyCrane(car)) {

+						EvaluateCarPosition(car, ped, dist, lastClosestness, closestCarOutput);

+					}

+				}

+			}

+		}

+	}

+}
+
+void

+CPlayerInfo::Process(void)

+{

+	// Unused taxi feature. Gives you a dollar for every second with a passenger. Can be toggled via 0x29A opcode.

+	bool startTaxiTimer = true;

+	if (m_bUnusedTaxiThing && m_pPed->bInVehicle) {

+		CVehicle *veh = m_pPed->m_pMyVehicle;

+		if ((veh->m_modelIndex == MI_TAXI || veh->m_modelIndex == MI_CABBIE || veh->m_modelIndex == MI_BORGNINE)

+			&& veh->pDriver == m_pPed && veh->m_nNumPassengers != 0) {

+			for (uint32 timePassed = CTimer::GetTimeInMilliseconds() - m_nUnusedTaxiTimer; timePassed >= 1000; m_nUnusedTaxiTimer += 1000) {

+				timePassed -= 1000;

+				++m_nMoney;

+			}

+			startTaxiTimer = false;

+		}

+	}

+	if (startTaxiTimer)

+		m_nUnusedTaxiTimer = CTimer::GetTimeInMilliseconds();

+

+	// The effect that makes money counter does while earning/losing money

+	if (m_nVisibleMoney != m_nMoney) {

+		int diff = m_nMoney - m_nVisibleMoney;

+		int diffAbs = Abs(diff);

+		int changeBy;

+

+		if (diffAbs > 100000)

+			changeBy = 12345;

+		else if (diffAbs > 10000)

+			changeBy = 1234;

+		else if (diffAbs > 1000)

+			changeBy = 123;

+		else if (diffAbs > 50)

+			changeBy = 42;

+		else

+			changeBy = 1;

+

+		if (diff < 0)

+			m_nVisibleMoney -= changeBy;

+		else

+			m_nVisibleMoney += changeBy;

+	}

+

+	if (!(CTimer::GetFrameCounter() & 15)) {

+		CVector2D playerPos = m_pPed->bInVehicle ? m_pPed->m_pMyVehicle->GetPosition() : m_pPed->GetPosition();

+		m_fRoadDensity = ThePaths.CalcRoadDensity(playerPos.x, playerPos.y);

+	}

+

+	m_fRoadDensity = clamp(m_fRoadDensity, 0.4f, 1.45f);

+

+	// Because vehicle enter/exit use same key binding.

+	bool enterOrExitVeh;

+	if (m_pPed->m_ped_flagI4 && m_pPed->bInVehicle)

+		enterOrExitVeh = CPad::GetPad(0)->ExitVehicleJustDown();

+	else

+		enterOrExitVeh = CPad::GetPad(0)->GetExitVehicle();

+

+	if (enterOrExitVeh && m_pPed->m_nPedState != PED_SNIPER_MODE && m_pPed->m_nPedState != PED_ROCKET_ODE) {

+		if (m_pPed->bInVehicle) {

+			if (!m_pRemoteVehicle) {

+				CEntity *surfaceBelowVeh = m_pPed->m_pMyVehicle->m_pCurGroundEntity;

+				if (!surfaceBelowVeh || !CBridge::ThisIsABridgeObjectMovingUp(surfaceBelowVeh->m_modelIndex)) {

+					CVehicle *veh = m_pPed->m_pMyVehicle;

+					if (!veh->IsBoat() || veh->m_nDoorLock == CARLOCK_LOCKED_PLAYER_INSIDE) {

+

+						// This condition will always return true, else block was probably WIP Miami code.

+						if (veh->m_vehType != VEHICLE_TYPE_BIKE || veh->m_nDoorLock == CARLOCK_LOCKED_PLAYER_INSIDE) {

+							if (veh->m_status != STATUS_WRECKED && veh->m_status != STATUS_TRAIN_MOVING && veh->m_nDoorLock != CARLOCK_LOCKED_PLAYER_INSIDE) {

+								if (veh->m_vecMoveSpeed.Magnitude() < 0.17f && CTimer::GetTimeScale() >= 0.5f && !veh->bIsInWater) {

+									m_pPed->SetObjective(OBJECTIVE_LEAVE_VEHICLE, veh);

+								}

+							}

+						} else {

+							CVector sth = 0.7f * veh->GetRight() + veh->GetPosition();

+							bool found = false;

+							float groundZ = CWorld::FindGroundZFor3DCoord(sth.x, sth.y, 2.0f + sth.z, &found);

+

+							if (found)

+								sth.z = 1.0f + groundZ;

+							m_pPed->m_nPedState = PED_IDLE;

+							m_pPed->SetMoveState(PEDMOVE_STILL);

+							CPed::PedSetOutCarCB(0, m_pPed);

+							CAnimManager::BlendAnimation(m_pPed->GetClump(), m_pPed->m_animGroup, ANIM_IDLE_STANCE, 100.0f);

+							CAnimManager::BlendAnimation(m_pPed->GetClump(), ASSOCGRP_STD, ANIM_FALL_LAND, 100.0f);

+							m_pPed->GetPosition() = sth;

+							m_pPed->SetMoveState(PEDMOVE_STILL);

+							m_pPed->m_vecMoveSpeed = veh->m_vecMoveSpeed;

+						}

+					} else {

+						// The code in here was under CPed::SetExitBoat in VC, did the same for here.

+						m_pPed->SetExitBoat(veh);

+						m_pPed->bTryingToReachDryLand = true;

+					}

+				}

+			}

+		} else {

+			// Enter vehicle

+			if (CPad::GetPad(0)->ExitVehicleJustDown()) {

+				bool weAreOnBoat = false;

+				float lastClosestness = 0.0f;

+				CVehicle *carBelow;

+				CEntity *surfaceBelow = m_pPed->m_pCurrentPhysSurface;

+				if (surfaceBelow && surfaceBelow->IsVehicle()) {

+					carBelow = (CVehicle*)surfaceBelow;

+					if (carBelow->IsBoat()) {

+						weAreOnBoat = true;

+						m_pPed->bOnBoat = true;

+#ifdef VC_PED_PORTS

+						if (carBelow->m_status != STATUS_WRECKED && carBelow->GetUp().z > 0.3f)

+#else

+						if (carBelow->m_status != STATUS_WRECKED)

+#endif

+							m_pPed->SetSeekBoatPosition(carBelow);

+					}

+				}

+				// Find closest car

+				if (!weAreOnBoat) {

+					float minX = m_pPed->GetPosition().x - 10.0f;

+					float maxX = 10.0f + m_pPed->GetPosition().x;

+					float minY = m_pPed->GetPosition().y - 10.0f;

+					float maxY = 10.0f + m_pPed->GetPosition().y;

+

+					int minXSector = CWorld::GetSectorIndexX(minX);

+					if (minXSector < 0) minXSector = 0;

+					int minYSector = CWorld::GetSectorIndexY(minY);

+					if (minYSector < 0) minYSector = 0;

+					int maxXSector = CWorld::GetSectorIndexX(maxX);

+					if (maxXSector > NUMSECTORS_X - 1) maxXSector = NUMSECTORS_X - 1;

+					int maxYSector = CWorld::GetSectorIndexY(maxY);

+					if (maxYSector > NUMSECTORS_Y - 1) maxYSector = NUMSECTORS_Y - 1;

+

+					CWorld::AdvanceCurrentScanCode();

+

+					for (int curY = minYSector; curY <= maxYSector; curY++) {

+						for (int curX = minXSector; curX <= maxXSector; curX++) {

+							CSector *sector = CWorld::GetSector(curX, curY);

+							FindClosestCarSectorList(sector->m_lists[ENTITYLIST_VEHICLES], m_pPed,

+								minX, minY, maxX, maxY, &lastClosestness, &carBelow);

+							FindClosestCarSectorList(sector->m_lists[ENTITYLIST_VEHICLES_OVERLAP], m_pPed,

+								minX, minY, maxX, maxY, &lastClosestness, &carBelow);

+						}

+					}

+				}

+				// carBelow is now closest vehicle

+				if (carBelow && !weAreOnBoat) {

+					if (carBelow->m_status == STATUS_TRAIN_NOT_MOVING) {

+						m_pPed->SetObjective(OBJECTIVE_ENTER_CAR_AS_PASSENGER, carBelow);

+					} else if (carBelow->IsBoat()) {

+						if (!carBelow->pDriver) {

+							m_pPed->m_vehEnterType = 0;

+							m_pPed->SetEnterCar(carBelow, m_pPed->m_vehEnterType);

+						}

+					} else {

+						m_pPed->SetObjective(OBJECTIVE_ENTER_CAR_AS_DRIVER, carBelow);

+					}

+				}

+			}

+		}

+	}

+	if (m_bInRemoteMode) {

+		uint32 timeWithoutRemoteCar = CTimer::GetTimeInMilliseconds() - m_nTimeLostRemoteCar;

+		if (CTimer::GetPreviousTimeInMilliseconds() - m_nTimeLostRemoteCar < 1000 && timeWithoutRemoteCar >= 1000 && m_WBState == WBSTATE_PLAYING) {

+			TheCamera.SetFadeColour(0, 0, 0);

+			TheCamera.Fade(1.0f, 0);

+		}

+		if (timeWithoutRemoteCar > 2000) {

+			if (m_WBState == WBSTATE_PLAYING) {

+				TheCamera.RestoreWithJumpCut();

+				TheCamera.SetFadeColour(0, 0, 0);

+				TheCamera.Fade(1.0f, 1);

+				TheCamera.Process();

+				CTimer::Stop();

+				CCullZones::ForceCullZoneCoors(TheCamera.GetPosition());

+				CRenderer::RequestObjectsInFrustum();

+				CStreaming::LoadAllRequestedModels(false);

+				CTimer::Update();

+			}

+			m_bInRemoteMode = false;

+			CWorld::Players[CWorld::PlayerInFocus].m_pRemoteVehicle = nil;

+			if (FindPlayerVehicle()) {

+				FindPlayerVehicle()->m_status = STATUS_PLAYER;

+			}

+		}

+	}

+	if (!(CTimer::GetFrameCounter() & 31)) {

+		CVehicle *veh = FindPlayerVehicle();

+		if (veh && m_pPed->bInVehicle && veh->GetUp().z < 0.0f

+			&& veh->m_vecMoveSpeed.Magnitude() < 0.05f && veh->IsCar() && !veh->bIsInWater) {

+

+			if (veh->GetUp().z < -0.5f) {

+				m_nUpsideDownCounter += 2;

+			

+			} else {

+				m_nUpsideDownCounter++;

+			}

+		} else {

+			m_nUpsideDownCounter = 0;

+		}

+

+		if (m_nUpsideDownCounter > 6 && veh->bCanBeDamaged) {

+			veh->m_fHealth = 249.0f < veh->m_fHealth ? 249.0f : veh->m_fHealth;

+			if (veh->IsCar()) {

+				CAutomobile* car = (CAutomobile*)veh;

+				car->Damage.SetEngineStatus(225);

+				car->m_pSetOnFireEntity = nil;

+			}

+		}

+	}

+	if (FindPlayerVehicle()) {

+		CVehicle *veh = FindPlayerVehicle();

+		veh->m_nZoneLevel = -1;

+		for (int i = 0; i < ARRAY_SIZE(veh->pPassengers); i++) {

+			if (veh->pPassengers[i])

+				veh->pPassengers[i]->m_nZoneLevel = 0;

+		}

+		CStats::DistanceTravelledInVehicle += veh->m_fDistanceTravelled;

+	} else {

+		CStats::DistanceTravelledOnFoot += FindPlayerPed()->m_fDistanceTravelled;

+	}

+}
+
 STARTPATCHES
 	InjectHook(0x4B5DC0, &CPlayerInfo::dtor, PATCH_JUMP);
 	InjectHook(0x4A1700, &CPlayerInfo::LoadPlayerSkin, PATCH_JUMP);
@@ -320,4 +570,5 @@ STARTPATCHES
 	InjectHook(0x4A15F0, &CPlayerInfo::AwardMoneyForExplosion, PATCH_JUMP);
 	InjectHook(0x4A0B20, &CPlayerInfo::LoadPlayerInfo, PATCH_JUMP);
 	InjectHook(0x4A0960, &CPlayerInfo::SavePlayerInfo, PATCH_JUMP);
+	InjectHook(0x49FD30, &CPlayerInfo::Process, PATCH_JUMP);
 ENDPATCHES
diff --git a/src/core/PlayerInfo.h b/src/core/PlayerInfo.h
index 28881796..19c5ce23 100644
--- a/src/core/PlayerInfo.h
+++ b/src/core/PlayerInfo.h
@@ -29,8 +29,8 @@ public:
 	int32 m_nCollectedPackages;
 	int32 m_nTotalPackages;
 	uint32 m_nLastBumpPlayerCarTimer;
-	uint32 m_nSwitchTaxiTime;
-	bool m_bSwitchTaxi;
+	uint32 m_nUnusedTaxiTimer;
+	bool m_bUnusedTaxiThing;
 	int8 field_197;
 	int8 field_198;
 	int8 field_199;
@@ -87,6 +87,7 @@ public:
 	void EvaluateCarPosition(CEntity*, CPed*, float, float*, CVehicle**);
 	void LoadPlayerInfo(uint8 *buf, uint32 size);
 	void SavePlayerInfo(uint8 *buf, uint32* size);
+	void FindClosestCarSectorList(CPtrList&, CPed*, float, float, float, float, float*, CVehicle**);
 
 	~CPlayerInfo() { };
 	void dtor(void) { this->CPlayerInfo::~CPlayerInfo(); }
diff --git a/src/core/Stats.cpp b/src/core/Stats.cpp
index 9641e8f0..aa3f21a9 100644
--- a/src/core/Stats.cpp
+++ b/src/core/Stats.cpp
@@ -12,6 +12,8 @@ int32 *CStats::PedsKilledOfThisType = (int32*)0x880DBC;
 int32 &CStats::TimesDied = *(int32*)0x8E2BDC;
 int32 &CStats::TimesArrested = *(int32*)0x8E2BEC;
 int32 &CStats::KillsSinceLastCheckpoint = *(int32*)0x8F2C8C;
+int32& CStats::DistanceTravelledInVehicle = *(int32*)0x940574;
+int32& CStats::DistanceTravelledOnFoot = *(int32*)0x941518;
 
 void CStats::AnotherKillFrenzyPassed()
 {
diff --git a/src/core/Stats.h b/src/core/Stats.h
index 7bae8c51..13f97218 100644
--- a/src/core/Stats.h
+++ b/src/core/Stats.h
@@ -14,6 +14,8 @@ public:
 	static int32 &TimesDied;
 	static int32 &TimesArrested;
 	static int32 &KillsSinceLastCheckpoint;
+	static int32 &DistanceTravelledInVehicle;
+	static int32 &DistanceTravelledOnFoot;
 
 public:
 	static void AnotherKillFrenzyPassed();
diff --git a/src/peds/Ped.cpp b/src/peds/Ped.cpp
index ee4a5f7c..68372ee8 100644
--- a/src/peds/Ped.cpp
+++ b/src/peds/Ped.cpp
@@ -540,7 +540,7 @@ CPed::CPed(uint32 pedType) : m_pedIK(this)
 	bHitSteepSlope = false;
 	m_ped_flagH4 = false;
 	bClearObjective = false;
-	m_ped_flagH10 = false;
+	bTryingToReachDryLand = false;
 	bCollidedWithMyVehicle = false;
 	bRichFromMugging = false;
 	m_ped_flagH80 = false;
@@ -1926,7 +1926,7 @@ CPed::LineUpPedWithCar(PedLineUpPhase phase)
 	if (!stillGettingInOut) {
 		m_fRotationCur = m_fRotationDest;
 	} else {
-		float limitedAngle = CGeneral::LimitRadianAngle(m_fRotationDest);
+		float limitedDest = CGeneral::LimitRadianAngle(m_fRotationDest);
 		float timeUntilStateChange = (m_nPedStateTimer - CTimer::GetTimeInMilliseconds())/600.0f;
 
 		m_vecOffsetSeek.z = 0.0f;
@@ -1937,12 +1937,12 @@ CPed::LineUpPedWithCar(PedLineUpPhase phase)
 			neededPos -= timeUntilStateChange * m_vecOffsetSeek;
 		}
 
-		if (PI + m_fRotationCur < limitedAngle) {
-			limitedAngle -= 2 * PI;
-		} else if (m_fRotationCur - PI > limitedAngle) {
-			limitedAngle += 2 * PI;
+		if (PI + m_fRotationCur < limitedDest) {
+			limitedDest -= 2 * PI;
+		} else if (m_fRotationCur - PI > limitedDest) {
+			limitedDest += 2 * PI;
 		}
-		m_fRotationCur -= (m_fRotationCur - limitedAngle) * (1.0f - timeUntilStateChange);
+		m_fRotationCur -= (m_fRotationCur - limitedDest) * (1.0f - timeUntilStateChange);
 	}
 
 	if (seatPosMult > 0.2f || vehIsUpsideDown) {
@@ -10902,6 +10902,12 @@ CPed::RemoveInCarAnims(void)
 			animAssoc->blendDelta = -1000.0f;
 	}
 
+#ifdef VC_PED_PORTS
+	animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_DRIVE_BOAT);
+	if (animAssoc)
+		animAssoc->blendDelta = -1000.0f;
+#endif
+
 	animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_CAR_LB);
 	if (animAssoc)
 		animAssoc->blendDelta = -1000.0f;
@@ -13581,6 +13587,10 @@ CPed::ProcessObjective(void)
 								|| m_pMyVehicle->m_vecMoveSpeed.MagnitudeSqr2D() < 0.000025f)) {
 							if (m_pMyVehicle->IsTrain())
 								SetExitTrain(m_pMyVehicle);
+#ifdef VC_PED_PORTS
+							else if (m_pMyVehicle->IsBoat())
+								SetExitBoat(m_pMyVehicle);
+#endif
 							else
 								SetExitCar(m_pMyVehicle, 0);
 						}
@@ -13594,13 +13604,10 @@ CPed::ProcessObjective(void)
 			{
 				if (CTimer::GetTimeInMilliseconds() > m_leaveCarTimer) {
 					if (InVehicle()) {
-						if (m_nPedState != PED_EXIT_CAR && m_nPedState != PED_DRAG_FROM_CAR
-							&& m_nPedState != PED_EXIT_TRAIN) {
-							// VC calls SetExitBoat for boats, which is not seperate func. in III but housed in CPlayerInfo::Process.
-							// This obj. will probably break/crash game if ped was in boat.
-							if (m_pMyVehicle->IsTrain())
-								SetExitTrain(m_pMyVehicle);
-							else if (m_pMyVehicle->bIsBus || m_pMyVehicle->IsBoat())
+						if (m_nPedState != PED_EXIT_CAR && m_nPedState != PED_DRAG_FROM_CAR && m_nPedState != PED_EXIT_TRAIN) {
+							if (m_pMyVehicle->IsBoat())
+								SetExitBoat(m_pMyVehicle);
+							else if (m_pMyVehicle->bIsBus)
 								SetExitCar(m_pMyVehicle, 0);
 							else {
 								eCarNodes doorNode = CAR_DOOR_LF;
@@ -14413,7 +14420,7 @@ CPed::ProcessEntityCollision(CEntity *collidingEnt, CColPoint *collidingPoints)
 							if (!collidingEnt->IsVehicle() && !collidingEnt->IsObject()) {
 								m_pCurSurface = collidingEnt;
 								collidingEnt->RegisterReference((CEntity**)&m_pCurSurface);
-								m_ped_flagH10 = false;
+								bTryingToReachDryLand = false;
 								bOnBoat = false;
 							} else {
 								m_pCurrentPhysSurface = (CPhysical*)collidingEnt;
@@ -14912,9 +14919,9 @@ CPed::ProcessBuoyancy(void)
 		bIsInWater = true;
 		ApplyMoveForce(buoyancyImpulse);
 		if (!DyingOrDead()) {
-			if (m_ped_flagH10) {
+			if (bTryingToReachDryLand) {
 				if (buoyancyImpulse.z / m_fMass > 0.0032f * CTimer::GetTimeStep()) {
-					m_ped_flagH10 = false;
+					bTryingToReachDryLand = false;
 					CVector pos = GetPosition();
 					if (PlacePedOnDryLand()) {
 						if (m_fHealth > 20.0f)
@@ -16873,8 +16880,8 @@ CPed::SetEnterCar_AllClear(CVehicle *car, uint32 doorNode, uint32 doorFlag)
 	if (car->IsBoat()) {
 		m_pVehicleAnim = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_DRIVE_BOAT, 100.0f);
 #ifdef VC_PED_PORTS
-		m_ped_flagI4 = true;
 		PedSetInCarCB(nil, this);
+		m_ped_flagI4 = true;
 #else
 		m_pVehicleAnim->SetFinishCallback(PedSetInCarCB, this);
 #endif
@@ -17236,6 +17243,89 @@ CPed::Solicit(void)
 	}
 }
 
+// Seperate function in VC, more logical. Not sure is it inlined in III.
+void
+CPed::SetExitBoat(CVehicle *boat)
+{
+#ifndef VC_PED_PORTS
+	m_nPedState = PED_IDLE;
+	CVector firstPos = GetPosition();
+	CAnimManager::BlendAnimation(GetClump(), m_animGroup, ANIM_IDLE_STANCE, 100.0f);
+	if (boat->m_modelIndex == MI_SPEEDER && boat->IsUpsideDown()) {
+		m_pVehicleAnim = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_CAR_CRAWLOUT_RHS, 8.0f);
+		m_pVehicleAnim->SetFinishCallback(CPed::PedSetOutCarCB, this);
+		m_vehEnterType = CAR_DOOR_RF;
+		m_nPedState = PED_EXIT_CAR;
+	} else {
+		m_vehEnterType = CAR_DOOR_RF;
+		CPed::PedSetOutCarCB(nil, this);
+		bIsStanding = true;
+		m_pCurSurface = boat;
+		m_pCurSurface->RegisterReference((CEntity**)&m_pCurSurface);
+	}
+	GetPosition() = firstPos;
+	SetMoveState(PEDMOVE_STILL);
+	m_vecMoveSpeed = boat->m_vecMoveSpeed;
+	bTryingToReachDryLand = true;
+#else
+	m_nPedState = PED_IDLE;
+	CVector newPos = GetPosition();
+	RemoveInCarAnims();
+	CColModel* boatCol = boat->GetColModel();
+	if (boat->IsUpsideDown()) {
+		newPos = { 0.0f, 0.0f, boatCol->boundingBox.min.z };
+		newPos = boat->GetMatrix() * newPos;
+		newPos.z += 1.0f;
+		m_vehEnterType = CAR_DOOR_RF;
+		PedSetOutCarCB(nil, this);
+		bIsStanding = true;
+		m_pCurSurface = boat;
+		m_pCurSurface->RegisterReference((CEntity**)&m_pCurSurface);
+		m_pCurrentPhysSurface = boat;
+	} else {
+/*		if (boat->m_modelIndex != MI_SKIMMER || boat->bIsInWater) {
+			if (boat->m_modelIndex == MI_SKIMMER)
+				newPos.z += 2.0f
+*/
+			m_vehEnterType = CAR_DOOR_RF;
+			PedSetOutCarCB(nil, this);
+			bIsStanding = true;
+			m_pCurSurface = boat;
+			m_pCurSurface->RegisterReference((CEntity**)&m_pCurSurface);
+			m_pCurrentPhysSurface = boat;
+			CColPoint foundCol;
+			CEntity *foundEnt = nil;
+			if (CWorld::ProcessVerticalLine(newPos, newPos.z - 1.4f, foundCol, foundEnt, false, true, false, false, false, false, nil))
+				newPos.z = FEET_OFFSET + foundCol.point.z;
+/*		// VC specific
+		} else {
+			m_vehEnterType = CAR_DOOR_RF;
+			PedSetOutCarCB(nil, this);
+			bIsStanding = true;
+			SetMoveState(PEDMOVE_STILL);
+			bTryingToReachDryLand = true;
+			float upMult = 1.04f + boatCol->boundingBox.min.z;
+			float rightMult = 0.6f * boatCol->boundingBox.max.x;
+			newPos = upMult * boat->GetUp() + rightMult * boat->GetRight() + boat->GetPosition();
+			GetPosition() = newPos;
+			if (m_pMyVehicle) {
+				PositionPedOutOfCollision();
+			} else {
+				m_pMyVehicle = boat;
+				PositionPedOutOfCollision();
+				m_pMyVehicle = nil;
+			}
+			return;
+		}
+*/	}
+	GetPosition() = newPos;
+	SetMoveState(PEDMOVE_STILL);
+	m_vecMoveSpeed = boat->m_vecMoveSpeed;
+#endif
+	// Not there in VC.
+	CWaterLevel::FreeBoatWakeArray();
+}
+
 class CPed_ : public CPed
 {
 public:
diff --git a/src/peds/Ped.h b/src/peds/Ped.h
index f4647831..00b73bae 100644
--- a/src/peds/Ped.h
+++ b/src/peds/Ped.h
@@ -360,7 +360,7 @@ public:
 	uint8 bHitSteepSlope : 1; // has ped collided/is standing on a steep slope (surface type)
 	uint8 m_ped_flagH4 : 1;
 	uint8 bClearObjective : 1;
-	uint8 m_ped_flagH10 : 1; // bTryingToReachDryLand? reset when we landed on something not vehicle and object
+	uint8 bTryingToReachDryLand : 1;
 	uint8 bCollidedWithMyVehicle : 1;
 	uint8 bRichFromMugging : 1; // ped has lots of cash from mugging people - will drop money if someone points gun to him
 	uint8 m_ped_flagH80 : 1;
@@ -696,6 +696,7 @@ public:
 	void SetCarJack(CVehicle*);
 	bool WarpPedToNearLeaderOffScreen(void);
 	void Solicit(void);
+	void SetExitBoat(CVehicle*);
 
 	// Static methods
 	static CVector GetLocalPositionToOpenCarDoor(CVehicle *veh, uint32 component, float offset);