author: saml1er <danishroar@gmail.com> 2020-04-16 21:01:53 +0200
committer: saml1er <danishroar@gmail.com> 2020-04-16 21:01:53 +0200
commit: e52a02fb9e1dd5602e80d88691f2ee2291d1fa52 (patch)
tree: 333caa1599e2f0c6b91bdae2092cf085eaf8238a /src
parent: Reverse CWorld (diff)
parent: More refs removed (diff)
download: re3-e52a02fb9e1dd5602e80d88691f2ee2291d1fa52.tar
re3-e52a02fb9e1dd5602e80d88691f2ee2291d1fa52.tar.gz
re3-e52a02fb9e1dd5602e80d88691f2ee2291d1fa52.tar.bz2
re3-e52a02fb9e1dd5602e80d88691f2ee2291d1fa52.tar.lz
re3-e52a02fb9e1dd5602e80d88691f2ee2291d1fa52.tar.xz
re3-e52a02fb9e1dd5602e80d88691f2ee2291d1fa52.tar.zst
re3-e52a02fb9e1dd5602e80d88691f2ee2291d1fa52.zip
111 files changed, 6761 insertions, 601 deletions
diff --git a/src/animation/FrameUpdate.cpp b/src/animation/FrameUpdate.cpp
index dcb71944..393d22a8 100644
--- a/src/animation/FrameUpdate.cpp
+++ b/src/animation/FrameUpdate.cpp
@@ -6,7 +6,7 @@
 #include "AnimBlendAssociation.h"
 #include "RpAnimBlend.h"
 
-CAnimBlendClumpData *&gpAnimBlendClump = *(CAnimBlendClumpData**)0x621000;
+CAnimBlendClumpData *gpAnimBlendClump;
 
 void FrameUpdateCallBack(AnimBlendFrameData *frame, void *arg);
 void FrameUpdateCallBackWithVelocityExtraction(AnimBlendFrameData *frame, void *arg);
diff --git a/src/animation/RpAnimBlend.h b/src/animation/RpAnimBlend.h
index 55a4456b..f9e14c42 100644
--- a/src/animation/RpAnimBlend.h
+++ b/src/animation/RpAnimBlend.h
@@ -37,5 +37,5 @@ CAnimBlendAssociation *RpAnimBlendClumpGetFirstAssociation(RpClump *clump);
 void RpAnimBlendClumpUpdateAnimations(RpClump* clump, float timeDelta);
 
 
-extern CAnimBlendClumpData *&gpAnimBlendClump;
+extern CAnimBlendClumpData *gpAnimBlendClump;
 void FrameUpdateCallBack(AnimBlendFrameData *frame, void *arg);
diff --git a/src/audio/AudioManager.cpp b/src/audio/AudioManager.cpp
index 1d2835cf..8a9a81f9 100644
--- a/src/audio/AudioManager.cpp
+++ b/src/audio/AudioManager.cpp
@@ -1,4 +1,4 @@
-#include "common.h"
+#include "common.h"
 #include "patcher.h"
 
 #include "audio_enums.h"
@@ -6269,7 +6269,7 @@ cAudioManager::ProcessPedHeadphones(cPedParams *params)
 				emittingVol = 10;
 				veh = (CAutomobile *)ped->m_pMyVehicle;
 				if(veh && veh->IsCar()) {
-					for(int32 i = 2; i < ARRAYSIZE(veh->Doors); i++) {
+					for(int32 i = 2; i < ARRAY_SIZE(veh->Doors); i++) {
 						if(!veh->IsDoorClosed((eDoors)i) ||
 						   veh->IsDoorMissing((eDoors)i)) {
 							emittingVol = 42;
@@ -9132,6 +9132,9 @@ cAudioManager::ProcessVehicleSirenOrAlarm(cVehicleParams *params)
 		CVehicle *veh = params->m_pVehicle;
 		if(veh->m_bSirenOrAlarm == 0 && veh->m_nAlarmState <= 0) return;
 
+#ifdef FIX_BUGS
+		if (params->m_pVehicle->m_status == STATUS_WRECKED) return;
+#endif
 		CalculateDistance(params->m_bDistanceCalculated, params->m_fDistance);
 		m_sQueueSample.m_bVolume = ComputeVolume(80, 110.f, m_sQueueSample.m_fDistance);
 		if(m_sQueueSample.m_bVolume) {
diff --git a/src/audio/AudioManager.h b/src/audio/AudioManager.h
index 31a07f9b..ad558061 100644
--- a/src/audio/AudioManager.h
+++ b/src/audio/AudioManager.h
@@ -118,7 +118,7 @@ enum eScriptSounds : int16 {
 	SCRIPT_SOUND_BULLET_HIT_GROUND_1 = 106,
 	SCRIPT_SOUND_BULLET_HIT_GROUND_2 = 107,
 	SCRIPT_SOUND_BULLET_HIT_GROUND_3 = 108,
-	SCRIPT_SOUND_109 = 109,
+	SCRIPT_SOUND_BULLET_HIT_WATER = 109, //no sound
 	SCRIPT_SOUND_110 = 110,
 	SCRIPT_SOUND_111 = 111,
 	SCRIPT_SOUND_PAYPHONE_RINGING = 112,
diff --git a/src/audio/MusicManager.cpp b/src/audio/MusicManager.cpp
index d840c57b..d4b60d9b 100644
--- a/src/audio/MusicManager.cpp
+++ b/src/audio/MusicManager.cpp
@@ -15,10 +15,10 @@
 #include "sampman.h"
 #include "patcher.h"
 
-cMusicManager &MusicManager = *(cMusicManager *)0x8F3964;
-int32 &gNumRetunePresses = *(int32 *)0x650B80;
-int32 &gRetuneCounter = *(int32*)0x650B84;
-bool& bHasStarted = *(bool*)0x650B7C;
+cMusicManager MusicManager;
+int32 gNumRetunePresses;
+int32 gRetuneCounter;
+bool bHasStarted;
 
 const int maxVolume = 127;
 
diff --git a/src/audio/MusicManager.h b/src/audio/MusicManager.h
index 5c255069..5d6f41cf 100644
--- a/src/audio/MusicManager.h
+++ b/src/audio/MusicManager.h
@@ -86,4 +86,4 @@ public:
 
 static_assert(sizeof(cMusicManager) == 0x95C, "cMusicManager: error");
 
-extern cMusicManager &MusicManager;
+extern cMusicManager MusicManager;
diff --git a/src/audio/sampman.cpp b/src/audio/sampman.cpp
index 6edb6028..6dd744c3 100644
--- a/src/audio/sampman.cpp
+++ b/src/audio/sampman.cpp
@@ -17,9 +17,8 @@
 
 #pragma comment( lib, "mss32.lib" )
 
-cSampleManager &SampleManager = *(cSampleManager *)0x7341E0;
-extern int32 (&BankStartOffset)[MAX_SAMPLEBANKS] = *(int32 (*)[MAX_SAMPLEBANKS])*(int *)0x6FAB70;
-
+cSampleManager SampleManager;
+int32 BankStartOffset[MAX_SAMPLEBANKS];
 ///////////////////////////////////////////////////////////////
 
 char SampleBankDescFilename[] = "AUDIO\\SFX.SDT";
@@ -116,7 +115,7 @@ typedef struct provider_stuff
 
 static int __cdecl comp(const provider_stuff*s1,const provider_stuff*s2)
 {
-  return(strcasecmp(s1->name, s2->name));
+  return( _stricmp(s1->name,s2->name) );
 }
 
 static void
@@ -435,21 +434,17 @@ _FindMP3s(void)
 				OutputDebugString("Resolving Link");
 				OutputDebugString(filepath);
 				
-				if ( f )
-					fprintf(f, " - shortcut to \"%s\"", filepath);
+				if ( f ) fprintf(f, " - shortcut to \"%s\"", filepath);
 			}
 			else
 			{
-				if ( f )
-					fprintf(f, " - couldn't resolve shortcut");
+				if ( f ) fprintf(f, " - couldn't resolve shortcut");
 			}
 			
 			bShortcut = true;
 		}
 		else
-		{
 			bShortcut = false;
-		}
 	}
 	
 	mp3Stream[0] = AIL_open_stream(DIG, filepath, 0);
@@ -494,8 +489,7 @@ _FindMP3s(void)
 			_pMP3List->pLinkPath = NULL;
 		}
 		
-		if ( f )
-			fprintf(f, " - OK\n");
+		if ( f ) fprintf(f, " - OK\n");
 		
 		bInitFirstEntry = false;
 	}
@@ -505,8 +499,7 @@ _FindMP3s(void)
 		
 		OutputDebugString(filepath);
 
-		if ( f )
-			fprintf(f, " - not an MP3 or supported MP3 type\n");
+		if ( f ) fprintf(f, " - not an MP3 or supported MP3 type\n");
 		
 		bInitFirstEntry = true;
 	}
@@ -514,17 +507,7 @@ _FindMP3s(void)
 	while ( true )
 	{
 		if ( !FindNextFile(hFind, &fd) )
-		{
-			if ( f )
-			{
-				fprintf(f, "\nTOTAL SUPPORTED MP3s: %d\n", nNumMP3s);
-				fclose(f);
-			}
-			
-            FindClose(hFind);
-            
-			return;
-		}
+			break;
 		
 		if ( bInitFirstEntry )
 		{
@@ -533,8 +516,7 @@ _FindMP3s(void)
 			
 			int32 filepathlen = strlen(filepath);
 			
-			if ( f )
-				fprintf(f, "\"%s\"", fd.cFileName);
+			if ( f ) fprintf(f, "\"%s\"", fd.cFileName);
 			
 			if ( filepathlen > 0 )
 			{
@@ -547,13 +529,11 @@ _FindMP3s(void)
 							OutputDebugString("Resolving Link");
 							OutputDebugString(filepath);
 							
-							if ( f )
-								fprintf(f, " - shortcut to \"%s\"", filepath);
+							if ( f ) fprintf(f, " - shortcut to \"%s\"", filepath);
 						}
 						else
 						{
-							if ( f )
-								fprintf(f, " - couldn't resolve shortcut");
+							if ( f ) fprintf(f, " - couldn't resolve shortcut");
 						}
 						
 						bShortcut = true;
@@ -564,8 +544,7 @@ _FindMP3s(void)
 						
 						if ( filepathlen > MAX_PATH )
 						{
-							if ( f )
-								fprintf(f, " - Filename and path too long - %s - IGNORED)\n", filepath);
+							if ( f ) fprintf(f, " - Filename and path too long - %s - IGNORED)\n", filepath);
 							
 							continue;
 						}
@@ -585,15 +564,7 @@ _FindMP3s(void)
 					_pMP3List = new tMP3Entry;
 					
 					if ( _pMP3List  == NULL)
-					{
-						if ( f )
-						{
-							fprintf(f, "\nTOTAL SUPPORTED MP3s: %d\n", nNumMP3s);
-							fclose(f);
-						}
-						FindClose(hFind);
-						return;
-					}
+						break;
 					
 					nNumMP3s = 1;
 					
@@ -614,8 +585,7 @@ _FindMP3s(void)
 					
 					pList = _pMP3List;
 					
-					if ( f )
-						fprintf(f, " - OK\n");
+					if ( f ) fprintf(f, " - OK\n");
 					
 					bInitFirstEntry = false;
 				}
@@ -624,8 +594,7 @@ _FindMP3s(void)
 					strcat(filepath, " - NOT A VALID MP3");
 					OutputDebugString(filepath);
 					
-					if ( f )
-						fprintf(f, " - not an MP3 or supported MP3 type\n");
+					if ( f ) fprintf(f, " - not an MP3 or supported MP3 type\n");
 				}
 			}
 		}
@@ -638,8 +607,7 @@ _FindMP3s(void)
 			
 			if ( filepathlen > 0 )
 			{
-				if ( f )
-					fprintf(f, "\"%s\"", fd.cFileName);
+				if ( f ) fprintf(f, "\"%s\"", fd.cFileName);
 			
 				if ( filepathlen > 4 )
 				{
@@ -650,13 +618,11 @@ _FindMP3s(void)
 							OutputDebugString("Resolving Link");
 							OutputDebugString(filepath);
 							
-							if ( f )
-								fprintf(f, " - shortcut to \"%s\"", filepath);
+							if ( f ) fprintf(f, " - shortcut to \"%s\"", filepath);
 						}
 						else
 						{
-							if ( f )
-								fprintf(f, " - couldn't resolve shortcut");
+							if ( f ) fprintf(f, " - couldn't resolve shortcut");
 						}
 						
 						bShortcut = true;
@@ -679,16 +645,8 @@ _FindMP3s(void)
 					
 					tMP3Entry *e = pList->pNext;
 					
-					if ( e == NULL)
-					{
-						if ( f )
-						{
-							fprintf(f, "\nTOTAL SUPPORTED MP3s: %d\n", nNumMP3s);
-							fclose(f);
-						}
-						FindClose(hFind);
-						return;
-					}
+					if ( e == NULL )
+						break;
 					
 					pList = pList->pNext;
 					
@@ -710,20 +668,26 @@ _FindMP3s(void)
 					
 					OutputDebugString(fd.cFileName);
 					
-					if ( f )
-						fprintf(f, " - OK\n");
+					if ( f ) fprintf(f, " - OK\n");
 				}
 				else
 				{
 					strcat(filepath, " - NOT A VALID MP3");
 					OutputDebugString(filepath);
 					
-					if ( f )
-						fprintf(f, " - not an MP3 or supported MP3 type\n");
+					if ( f ) fprintf(f, " - not an MP3 or supported MP3 type\n");
 				}
 			}
 		}
 	}
+	
+	if ( f )
+	{
+		fprintf(f, "\nTOTAL SUPPORTED MP3s: %d\n", nNumMP3s);
+		fclose(f);
+	}
+	
+	FindClose(hFind);
 }
 
 static void
@@ -2257,7 +2221,7 @@ cSampleManager::InitialiseSampleBanks(void)
 	
 	for ( int32 i = 0; i < TOTAL_AUDIO_SAMPLES; i++ )
 	{
-		if ( BankStartOffset[nBank] == BankStartOffset[0] + i )
+		if ( BankStartOffset[nBank] == BankStartOffset[SAMPLEBANK_MAIN] + i )
 		{
 			nSampleBankDiscStartOffset[nBank] = m_aSamples[i].nOffset;
 			nBank++;
diff --git a/src/audio/sampman.h b/src/audio/sampman.h
index 4b546911..4f3c3eeb 100644
--- a/src/audio/sampman.h
+++ b/src/audio/sampman.h
@@ -135,8 +135,8 @@ public:
 	bool  InitialiseSampleBanks(void);
 };
 
-extern cSampleManager &SampleManager;
-extern int32 (&BankStartOffset)[MAX_SAMPLEBANKS];
+extern cSampleManager SampleManager;
+extern int32 BankStartOffset[MAX_SAMPLEBANKS];
 
 static char StreamedNameTable[][25]=
 {
diff --git a/src/control/AutoPilot.cpp b/src/control/AutoPilot.cpp
index b5bca21d..65e73e5d 100644
--- a/src/control/AutoPilot.cpp
+++ b/src/control/AutoPilot.cpp
@@ -35,7 +35,7 @@ void CAutoPilot::ModifySpeed(float speed)
 	m_nTimeEnteredCurve = CTimer::GetTimeInMilliseconds() -
 		(uint32)(positionBetweenNodes * m_nTimeToSpendOnCurrentCurve);
 #else
-	m_nTimeEnteredCurve = CTimer::GetTimeInMilliseconds() - positionBetweenNodes * m_nSpeedScaleFactor;
+	m_nTimeEnteredCurve = CTimer::GetTimeInMilliseconds() - positionBetweenNodes * m_nTimeToSpendOnCurrentCurve;
 #endif
 }
 
diff --git a/src/control/CarCtrl.cpp b/src/control/CarCtrl.cpp
index 264f1f3f..197fca63 100644
--- a/src/control/CarCtrl.cpp
+++ b/src/control/CarCtrl.cpp
@@ -426,7 +426,7 @@ CCarCtrl::GenerateOneRandomCar()
 		(uint32)((0.5f + positionBetweenNodes) * pCar->AutoPilot.m_nTimeToSpendOnCurrentCurve);
 #else
 	pCar->AutoPilot.m_nTimeEnteredCurve = CTimer::GetTimeInMilliseconds() -
-		(0.5f + positionBetweenNodes) * pCar->AutoPilot.m_nSpeedScaleFactor;
+		(0.5f + positionBetweenNodes) * pCar->AutoPilot.m_nTimeToSpendOnCurrentCurve;
 #endif
 	CVector directionCurrentLink(directionCurrentLinkX, directionCurrentLinkY, 0.0f);
 	CVector directionNextLink(directionNextLinkX, directionNextLinkY, 0.0f);
diff --git a/src/control/Garages.cpp b/src/control/Garages.cpp
index d971d453..d187f666 100644
--- a/src/control/Garages.cpp
+++ b/src/control/Garages.cpp
@@ -307,13 +307,13 @@ void CGarage::Update()
 					CGarages::bCamShouldBeOutisde = true;
 				}
 				if (pVehicle) {
-					if (IsEntityEntirelyOutside(pVehicle, 0.0f))
+					if (!IsEntityEntirelyOutside(pVehicle, 0.0f))
 						TheCamera.pToGarageWeAreInForHackAvoidFirstPerson = this;
 					if (pVehicle->GetModelIndex() == MI_MRWHOOP) {
 						if (pVehicle->IsWithinArea(
 							m_fX1 - DISTANCE_FOR_MRWHOOP_HACK,
-							m_fX2 + DISTANCE_FOR_MRWHOOP_HACK,
-							m_fY1 - DISTANCE_FOR_MRWHOOP_HACK,
+							m_fY1 + DISTANCE_FOR_MRWHOOP_HACK,
+							m_fX2 - DISTANCE_FOR_MRWHOOP_HACK,
 							m_fY2 + DISTANCE_FOR_MRWHOOP_HACK)) {
 							TheCamera.pToGarageWeAreIn = this;
 							CGarages::bCamShouldBeOutisde = true;
@@ -1082,7 +1082,7 @@ void CGarage::Update()
 #ifdef FIX_BUGS
 					bool bCreatedAllCars = false;
 #else
-					bool bCraetedAllCars;
+					bool bCreatedAllCars;
 #endif
 					switch (m_eGarageType) {
 					case GARAGE_HIDEOUT_ONE:   bCreatedAllCars = RestoreCarsForThisHideout(CGarages::aCarsInSafeHouse1); break;
@@ -2313,6 +2313,10 @@ void CGarages::Load(uint8* buf, uint32 size)
 #ifdef FIX_GARAGE_SIZE
 	VALIDATESAVEBUF(size);
 #endif
+
+	MessageEndTime = 0;
+	bCamShouldBeOutisde = false;
+	MessageStartTime = 0;
 }
 
 bool
diff --git a/src/control/PathFind.cpp b/src/control/PathFind.cpp
index 61cd3d4e..9f45c454 100644
--- a/src/control/PathFind.cpp
+++ b/src/control/PathFind.cpp
@@ -14,9 +14,8 @@ bool gbShowCarPathsLinks;
 
 CPathFind &ThePaths = *(CPathFind*)0x8F6754;
 
-WRAPPER bool CPedPath::CalcPedRoute(uint8, CVector, CVector, CVector*, int16*, int16) { EAXJMP(0x42E680); }
-
 #define MAX_DIST INT16_MAX-1
+#define MIN_PED_ROUTE_DISTANCE 23.8f
 
 // object flags:
 //	1	UseInRoadBlock
@@ -28,6 +27,199 @@ CPathInfoForObject *&InfoForTilePeds  = *(CPathInfoForObject**)0x8F1AE4;
 CTempDetachedNode *&DetachedNodesCars = *(CTempDetachedNode**)0x8E2824;
 CTempDetachedNode *&DetachedNodesPeds = *(CTempDetachedNode**)0x8E28A0;
 
+bool 
+CPedPath::CalcPedRoute(int8 pathType, CVector position, CVector destination, CVector *pointPoses, int16 *pointsFound, int16 maxPoints)
+{
+	*pointsFound = 0;
+	CVector vecDistance = destination - position;
+	if (Abs(vecDistance.x) > MIN_PED_ROUTE_DISTANCE || Abs(vecDistance.y) > MIN_PED_ROUTE_DISTANCE || Abs(vecDistance.z) > MIN_PED_ROUTE_DISTANCE)
+		return false;
+	CVector vecPos = (position + destination) * 0.5f;
+	CVector vecSectorStartPos (vecPos.x - 14.0f, vecPos.y - 14.0f, vecPos.z);
+	CVector2D vecSectorEndPos (vecPos.x + 28.0f, vecPos.x + 28.0f);
+	const int16 nodeStartX = (position.x - vecSectorStartPos.x) / 0.7f;
+	const int16 nodeStartY = (position.y - vecSectorStartPos.y) / 0.7f;
+	const int16 nodeEndX = (destination.x - vecSectorStartPos.x) / 0.7f;
+	const int16 nodeEndY = (destination.y - vecSectorStartPos.y) / 0.7f;
+	if (nodeStartX == nodeEndX && nodeStartY == nodeEndY)
+		return false;
+	CPedPathNode pathNodes[40][40]; 
+	CPedPathNode pathNodesList[416];
+	for (int32 x = 0; x < 40; x++) {
+		for (int32 y = 0; y < 40; y++) {
+			pathNodes[x][y].bBlockade = false;
+			pathNodes[x][y].id = INT16_MAX;
+			pathNodes[x][y].nodeIdX = x;
+			pathNodes[x][y].nodeIdY = y;
+		}
+	}
+	CWorld::AdvanceCurrentScanCode();
+	if (pathType != ROUTE_NO_BLOCKADE) {
+		const int32 nStartX = max(CWorld::GetSectorIndexX(vecSectorStartPos.x), 0);
+		const int32 nStartY = max(CWorld::GetSectorIndexY(vecSectorStartPos.y), 0);
+		const int32 nEndX = min(CWorld::GetSectorIndexX(vecSectorEndPos.x), NUMSECTORS_X - 1);
+		const int32 nEndY = min(CWorld::GetSectorIndexY(vecSectorEndPos.y), NUMSECTORS_Y - 1);
+		for (int32 y = nStartY; y <= nEndY; y++) {
+			for (int32 x = nStartX; x <= nEndX; x++) {
+				CSector *pSector = CWorld::GetSector(x, y);
+				AddBlockadeSectorList(pSector->m_lists[ENTITYLIST_VEHICLES], pathNodes, &vecSectorStartPos);
+				AddBlockadeSectorList(pSector->m_lists[ENTITYLIST_VEHICLES_OVERLAP], pathNodes, &vecSectorStartPos);
+				AddBlockadeSectorList(pSector->m_lists[ENTITYLIST_OBJECTS], pathNodes, &vecSectorStartPos);
+				AddBlockadeSectorList(pSector->m_lists[ENTITYLIST_OBJECTS_OVERLAP], pathNodes, &vecSectorStartPos);
+			}
+		}
+	}
+	for (int32 i = 0; i < 416; i++) {
+		pathNodesList[i].prev = nil;
+		pathNodesList[i].next = nil;
+	}
+	CPedPathNode *pStartPathNode = &pathNodes[nodeStartX][nodeStartY];
+	CPedPathNode *pEndPathNode = &pathNodes[nodeEndX][nodeEndY];
+	pEndPathNode->bBlockade = false;
+	pEndPathNode->id = 0;
+	pEndPathNode->prev = nil;
+	pEndPathNode->next = pathNodesList;
+	pathNodesList[0].prev = pEndPathNode;
+	int32 pathNodeIndex = 0;
+	CPedPathNode *pPreviousNode = nil;
+	for (; pathNodeIndex < 414; pathNodeIndex++)
+	{
+		pPreviousNode = pathNodesList[pathNodeIndex].prev;
+		while (pPreviousNode && pPreviousNode != pStartPathNode) {
+			const uint8 nodeIdX = pPreviousNode->nodeIdX;
+			const uint8 nodeIdY = pPreviousNode->nodeIdY;
+			if (nodeIdX > 0) {
+				AddNodeToPathList(&pathNodes[nodeIdX - 1][nodeIdY], pathNodeIndex + 5, pathNodesList);
+				if (nodeIdY > 0)
+					AddNodeToPathList(&pathNodes[nodeIdX - 1][nodeIdY - 1], pathNodeIndex + 7, pathNodesList);
+				if (nodeIdY < 39)
+					AddNodeToPathList(&pathNodes[nodeIdX - 1][nodeIdY + 1], pathNodeIndex + 7, pathNodesList);
+			}
+			if (nodeIdX < 39) {
+				AddNodeToPathList(&pathNodes[nodeIdX + 1][nodeIdY], pathNodeIndex + 5, pathNodesList);
+				if (nodeIdY > 0)
+					AddNodeToPathList(&pathNodes[nodeIdX + 1][nodeIdY - 1], pathNodeIndex + 7, pathNodesList);
+				if (nodeIdY < 39)
+					AddNodeToPathList(&pathNodes[nodeIdX + 1][nodeIdY + 1], pathNodeIndex + 7, pathNodesList);
+			}
+			if (nodeIdY > 0)
+				AddNodeToPathList(&pathNodes[nodeIdX][nodeIdY - 1], pathNodeIndex + 5, pathNodesList);
+			if (nodeIdY < 39)
+				AddNodeToPathList(&pathNodes[nodeIdX][nodeIdY + 1], pathNodeIndex + 5, pathNodesList);
+			pPreviousNode = pPreviousNode->prev;
+			if (!pPreviousNode)
+				break;
+		}
+
+		if (pPreviousNode && pPreviousNode == pStartPathNode)
+			break;
+	}
+	if (pathNodeIndex == 414)
+		return false;
+	CPedPathNode *pPathNode = pStartPathNode;
+	for (*pointsFound = 0; pPathNode != pEndPathNode && *pointsFound < maxPoints; ++ *pointsFound) {
+		const uint8 nodeIdX = pPathNode->nodeIdX;
+		const uint8 nodeIdY = pPathNode->nodeIdY;
+		if (nodeIdX > 0 && pathNodes[nodeIdX - 1][nodeIdY].id + 5 == pPathNode->id) 
+			pPathNode = &pathNodes[nodeIdX - 1][nodeIdY];
+		else if (nodeIdX > 39 && pathNodes[nodeIdX + 1][nodeIdY].id + 5 == pPathNode->id)
+			pPathNode = &pathNodes[nodeIdX + 1][nodeIdY];
+		else if (nodeIdY > 0 && pathNodes[nodeIdX][nodeIdY - 1].id + 5 == pPathNode->id) 
+			pPathNode = &pathNodes[nodeIdX][nodeIdY - 1];
+		else if (nodeIdY > 39 && pathNodes[nodeIdX][nodeIdY + 1].id + 5 == pPathNode->id) 
+			pPathNode = &pathNodes[nodeIdX][nodeIdY + 1];
+		else if (nodeIdX > 0 && nodeIdY > 0 && pathNodes[nodeIdX - 1][nodeIdY - 1].id + 7 == pPathNode->id)
+			pPathNode = &pathNodes[nodeIdX - 1][nodeIdY - 1];
+		else if (nodeIdX > 0 && nodeIdY < 39 && pathNodes[nodeIdX - 1][nodeIdY + 1].id + 7 == pPathNode->id)
+			pPathNode = &pathNodes[nodeIdX - 1][nodeIdY + 1];
+		else if (nodeIdX < 39 && nodeIdY > 0 && pathNodes[nodeIdX + 1][nodeIdY - 1].id + 7 == pPathNode->id)
+			pPathNode = &pathNodes[nodeIdX + 1][nodeIdY - 1];
+		else if (nodeIdX < 39 && nodeIdY < 39 && pathNodes[nodeIdX + 1][nodeIdY + 1].id + 7 == pPathNode->id)
+			pPathNode = &pathNodes[nodeIdX + 1][nodeIdY + 1];
+		pointPoses[*pointsFound] = vecSectorStartPos;
+		pointPoses[*pointsFound].x += pPathNode->nodeIdX * 0.7f;
+		pointPoses[*pointsFound].y += pPathNode->nodeIdY * 0.7f;
+	}
+	return true;
+}
+
+
+void 
+CPedPath::AddNodeToPathList(CPedPathNode *pNodeToAdd, int16 id, CPedPathNode *pNodeList) 
+{
+	if (!pNodeToAdd->bBlockade && id < pNodeToAdd->id) {
+		if (pNodeToAdd->id != INT16_MAX)
+			RemoveNodeFromList(pNodeToAdd);
+		AddNodeToList(pNodeToAdd, id, pNodeList);
+	}
+}
+
+void 
+CPedPath::RemoveNodeFromList(CPedPathNode *pNode)
+{
+	pNode->next->prev = pNode->prev;
+	if (pNode->prev)
+		pNode->prev->next = pNode->next;
+}
+
+void 
+CPedPath::AddNodeToList(CPedPathNode *pNode, int16 index, CPedPathNode *pList)
+{
+	pNode->prev = pList[index].prev;
+	pNode->next = &pList[index];
+	if (pList[index].prev)
+		pList[index].prev->next = pNode;
+	pList[index].prev = pNode;
+	pNode->id = index;
+}
+
+void
+CPedPath::AddBlockadeSectorList(CPtrList& list, CPedPathNode(*pathNodes)[40], CVector *pPosition)
+{
+	CPtrNode* listNode = list.first;
+	while (listNode) {
+		CEntity* pEntity = (CEntity*)listNode->item;
+		if (pEntity->m_scanCode != CWorld::GetCurrentScanCode() && pEntity->bUsesCollision) {
+			pEntity->m_scanCode = CWorld::GetCurrentScanCode();
+			AddBlockade(pEntity, pathNodes, pPosition);
+		}
+		listNode = listNode->next;
+	}
+}
+
+void 
+CPedPath::AddBlockade(CEntity *pEntity, CPedPathNode(*pathNodes)[40], CVector *pPosition)
+{
+	const CColBox& boundingBox = pEntity->GetColModel()->boundingBox;
+	const float fBoundMaxY = boundingBox.max.y + 0.3f;
+	const float fBoundMinY = boundingBox.min.y - 0.3f;
+	const float fBoundMaxX = boundingBox.max.x + 0.3f;
+	const float fDistanceX = pPosition->x - pEntity->m_matrix.GetPosition().x;
+	const float fDistanceY = pPosition->y - pEntity->m_matrix.GetPosition().y;
+	const float fBoundRadius = pEntity->GetBoundRadius();
+	CVector vecBoundCentre;
+	pEntity->GetBoundCentre(vecBoundCentre);
+	if (vecBoundCentre.x + fBoundRadius >= pPosition->x && 
+		vecBoundCentre.y + fBoundRadius >= pPosition->y &&
+		vecBoundCentre.x - fBoundRadius <= pPosition->x + 28.0f &&
+		vecBoundCentre.y - fBoundRadius <= pPosition->y + 28.0f) {
+		for (int16 x = 0; x < 40; x++) {
+			const float pointX = x * 0.7f + fDistanceX;
+			for (int16 y = 0; y < 40; y++) {
+				if (!pathNodes[x][y].bBlockade) {
+					const float pointY = y * 0.7f + fDistanceY;
+					CVector2D point(pointX, pointY);
+					if (fBoundMaxX > Abs(DotProduct2D(point, pEntity->m_matrix.GetRight()))) {
+						float fDotProduct = DotProduct2D(point, pEntity->m_matrix.GetForward());
+						if (fBoundMaxY > fDotProduct && fBoundMinY < fDotProduct)
+							pathNodes[x][y].bBlockade = true;
+					}
+				}
+			}
+		}
+	}
+}
+
 void
 CPathFind::Init(void)
 {
@@ -1576,6 +1768,13 @@ CPathFind::DisplayPathData(void)
 }
 
 STARTPATCHES
+	InjectHook(0x42E680, &CPedPath::CalcPedRoute, PATCH_JUMP);
+	InjectHook(0x42F100, &CPedPath::AddNodeToPathList, PATCH_JUMP);
+	InjectHook(0x42F140, &CPedPath::RemoveNodeFromList, PATCH_JUMP);
+	InjectHook(0x42F160, &CPedPath::AddNodeToList, PATCH_JUMP);
+	InjectHook(0x42F1A0, &CPedPath::AddBlockade, PATCH_JUMP);
+	InjectHook(0x42F420, &CPedPath::AddBlockadeSectorList, PATCH_JUMP);
+
 	InjectHook(0x4294A0, &CPathFind::Init, PATCH_JUMP);
 	InjectHook(0x42D580, &CPathFind::AllocatePathFindInfoMem, PATCH_JUMP);
 	InjectHook(0x429540, &CPathFind::RegisterMapObject, PATCH_JUMP);
diff --git a/src/control/PathFind.h b/src/control/PathFind.h
index 81467cdf..ea88ade6 100644
--- a/src/control/PathFind.h
+++ b/src/control/PathFind.h
@@ -3,11 +3,7 @@
 #include "Treadable.h"
 
 class CVehicle;
-
-class CPedPath {
-public:
-	static bool CalcPedRoute(uint8, CVector, CVector, CVector*, int16*, int16);
-};
+class CPtrList;
 
 enum
 {
@@ -30,6 +26,33 @@ enum
 	SWITCH_ON = 1,
 };
 
+enum 
+{
+	ROUTE_ADD_BLOCKADE = 0,
+	ROUTE_NO_BLOCKADE = 1
+};
+
+struct CPedPathNode
+{
+	bool bBlockade;
+	uint8 nodeIdX;
+	uint8 nodeIdY;
+	int16 id;
+	CPedPathNode* prev;
+	CPedPathNode* next;
+};
+static_assert(sizeof(CPedPathNode) == 0x10, "CPedPathNode: error");
+
+class CPedPath {
+public:
+	static bool CalcPedRoute(int8 pathType, CVector position, CVector destination, CVector *pointPoses, int16 *pointsFound, int16 maxPoints);
+	static void AddNodeToPathList(CPedPathNode *pNodeToAdd, int16 id, CPedPathNode *pNodeList);
+	static void RemoveNodeFromList(CPedPathNode *pNode);
+	static void AddNodeToList(CPedPathNode *pNode, int16 index, CPedPathNode *pList);
+	static void AddBlockade(CEntity *pEntity, CPedPathNode(*pathNodes)[40], CVector *pPosition);
+	static void AddBlockadeSectorList(CPtrList& list, CPedPathNode(*pathNodes)[40], CVector *pPosition);
+};
+
 struct CPathNode
 {
 	CVector pos;
diff --git a/src/control/Replay.cpp b/src/control/Replay.cpp
index 97debfdc..c4a1e686 100644
--- a/src/control/Replay.cpp
+++ b/src/control/Replay.cpp
@@ -1215,7 +1215,7 @@ void CReplay::RestoreStuffFromMem(void)
 		vehicle->SetModelIndex(mi);
 		if (mi == MI_DODO){
 			CAutomobile* dodo = (CAutomobile*)vehicle;
-			RpAtomicSetFlags(GetFirstObject(dodo->m_aCarNodes[CAR_WHEEL_LF]), 0);
+			RpAtomicSetFlags((RpAtomic*)GetFirstObject(dodo->m_aCarNodes[CAR_WHEEL_LF]), 0);
 			CMatrix tmp1;
 			tmp1.Attach(RwFrameGetMatrix(dodo->m_aCarNodes[CAR_WHEEL_RF]), false);
 			CMatrix tmp2(RwFrameGetMatrix(dodo->m_aCarNodes[CAR_WHEEL_LF]), false);
@@ -1243,7 +1243,7 @@ void CReplay::RestoreStuffFromMem(void)
 				vehicle->GetMatrix().Detach();
 				if (vehicle->m_rwObject){
 					if (RwObjectGetType(vehicle->m_rwObject) == rpATOMIC){
-						RwFrame* frame = RpAtomicGetFrame(vehicle->m_rwObject);
+						RwFrame* frame = RpAtomicGetFrame((RpAtomic*)vehicle->m_rwObject);
 						RpAtomicDestroy((RpAtomic*)vehicle->m_rwObject);
 						RwFrameDestroy(frame);
 					}
@@ -1254,7 +1254,7 @@ void CReplay::RestoreStuffFromMem(void)
 				int model_id = info->m_wheelId;
 				if (model_id != -1){
 					if ((vehicle->m_rwObject = CModelInfo::GetModelInfo(model_id)->CreateInstance())){
-						vehicle->GetMatrix().AttachRW(&((RwFrame*)vehicle->m_rwObject->parent)->modelling, false);
+						vehicle->GetMatrix().AttachRW(RwFrameGetMatrix(RpClumpGetFrame((RpClump*)vehicle->m_rwObject)), false);
 					}
 				}
 			}
@@ -1274,7 +1274,7 @@ void CReplay::RestoreStuffFromMem(void)
 		object->SetModelIndex(mi);
 		object->GetMatrix().m_attachment = nil;
 		if (RwObjectGetType(object->m_rwObject) == rpATOMIC)
-			object->GetMatrix().AttachRW(RwFrameGetMatrix(RpAtomicGetFrame(object->m_rwObject)), false);
+			object->GetMatrix().AttachRW(RwFrameGetMatrix(RpAtomicGetFrame((RpAtomic*)object->m_rwObject)), false);
 	}
 	i = CPools::GetDummyPool()->GetSize();
 	while (--i >= 0) {
@@ -1289,7 +1289,7 @@ void CReplay::RestoreStuffFromMem(void)
 		dummy->SetModelIndex(mi);
 		dummy->GetMatrix().m_attachment = nil;
 		if (RwObjectGetType(dummy->m_rwObject) == rpATOMIC)
-			dummy->GetMatrix().AttachRW(RwFrameGetMatrix(RpAtomicGetFrame(dummy->m_rwObject)), false);
+			dummy->GetMatrix().AttachRW(RwFrameGetMatrix(RpAtomicGetFrame((RpAtomic*)dummy->m_rwObject)), false);
 	}
 	CTimer::SetTimeInMilliseconds(Time1);
 	CTimer::SetTimeInMillisecondsNonClipped(Time2);
diff --git a/src/control/SceneEdit.cpp b/src/control/SceneEdit.cpp
index 3e55d431..8d804e4d 100644
--- a/src/control/SceneEdit.cpp
+++ b/src/control/SceneEdit.cpp
@@ -2,11 +2,1096 @@
 #include "patcher.h"
 #include "SceneEdit.h"
 
-bool &CSceneEdit::m_bEditOn = *(bool*)0x95CD77;
-int32 &CSceneEdit::m_bCameraFollowActor = *(int*)0x940590;
-bool &CSceneEdit::m_bRecording = *(bool*)0x95CD1F;
-CVector &CSceneEdit::m_vecCurrentPosition = *(CVector*)0x943064;
-CVector &CSceneEdit::m_vecCamHeading = *(CVector*)0x942F8C;
-
-WRAPPER void CSceneEdit::Update(void) { EAXJMP(0x585570); }
-WRAPPER void CSceneEdit::Init(void) { EAXJMP(0x585170); }
+#include "Automobile.h"
+#include "Camera.h"
+#include "CarCtrl.h"
+#include "CivilianPed.h"
+#include "FileMgr.h"
+#include "Font.h"
+#include "ModelIndices.h"
+#include "ModelInfo.h"
+#include "Pad.h"
+#include "Ped.h"
+#include "Population.h"
+#include "Text.h"
+#include "Timecycle.h"
+#include "Streaming.h"
+#include "Vehicle.h"
+#include "WeaponInfo.h"
+#include "World.h"
+
+bool CSceneEdit::m_bEditOn;
+int32 CSceneEdit::m_bCameraFollowActor;
+bool CSceneEdit::m_bRecording;
+CVector CSceneEdit::m_vecCurrentPosition;
+CVector CSceneEdit::m_vecCamHeading;
+CVector CSceneEdit::m_vecGotoPosition;
+int32 CSceneEdit::m_nVehicle;
+int32 CSceneEdit::m_nVehicle2;
+int32 CSceneEdit::m_nActor;
+int32 CSceneEdit::m_nActor2;
+int32 CSceneEdit::m_nVehiclemodelId;
+int32 CSceneEdit::m_nPedmodelId;
+int16 CSceneEdit::m_nCurrentMovieCommand;
+int16 CSceneEdit::m_nNumActors;
+int16 CSceneEdit::m_nNumMovieCommands;
+int16 CSceneEdit::m_nCurrentCommand;
+int16 CSceneEdit::m_nCurrentVehicle;
+int16 CSceneEdit::m_nCurrentActor;
+int16 CSceneEdit::m_nWeaponType;
+bool CSceneEdit::m_bCommandActive;
+bool CSceneEdit::m_bActorSelected;
+bool CSceneEdit::m_bActor2Selected;
+bool CSceneEdit::m_bVehicleSelected;
+int16 CSceneEdit::m_nNumVehicles;
+CPed* CSceneEdit::pActors[NUM_ACTORS_IN_MOVIE];
+CVehicle* CSceneEdit::pVehicles[NUM_VEHICLES_IN_MOVIE];
+bool CSceneEdit::m_bDrawGotoArrow;
+CMovieCommand CSceneEdit::Movie[NUM_COMMANDS_IN_MOVIE];
+
+#define SHADOW_OFFSET (2.0f)
+#define ACTION_MESSAGE_X_RIGHT (60.0f)
+#define ACTION_MESSAGE_Y (8.0f)
+#define SELECTED_MESSAGE_X_RIGHT (60.0f)
+#define SELECTED_MESSAGE_Y (248.0f)
+#define COMMAND_NAME_X_RIGHT (60.0f)
+#define COMMAND_NAME_Y (38.0f)
+#define COMMAND_NAME_HEIGHT (16.0f)
+
+#define NUM_COMMANDS_TO_DRAW (9)
+
+static const char* pCommandStrings[] = {
+	"do-nothing", "New Actor", "Move Actor", "Select Actor", "Delete Actor",
+	"New Vehicle", "Move Vehicle", "Select Vehicle", "Delete Vehicle", "Give Weapon",
+	"Goto", "Goto (wait)", "Get In Car", "Get Out Car", "Kill",
+	"Flee", "Wait", "Position Camera", "Set Camera Target", "Select Camera Mode",
+	"Save Movie", "Load Movie", "Play Movie", "END"
+};
+
+static_assert(ARRAY_SIZE(pCommandStrings) == CSceneEdit::MOVIE_TOTAL_COMMANDS, "Scene edit: not all commands have names");
+
+static int32 NextValidModelId(int32 mi, int32 step)
+{
+	int32 result = -1;
+	int32 i = mi;
+	while (result == -1) {
+		i += step;
+		if (i < 0 || i > 5500) {
+			step = -step;
+			continue;
+		}
+		CBaseModelInfo* pInfo = CModelInfo::GetModelInfo(i);
+		CVehicleModelInfo* pVehicleInfo = (CVehicleModelInfo*)pInfo;
+		if (!pInfo)
+			continue;
+		if (pInfo->m_type == MITYPE_PED
+#ifdef FIX_BUGS
+			&& !(i >= MI_SPECIAL01 && i <= MI_SPECIAL04)
+#endif
+			||
+			pInfo->m_type == MITYPE_VEHICLE &&
+#ifdef FIX_BUGS
+			(pVehicleInfo->m_vehicleType == VEHICLE_TYPE_CAR || pVehicleInfo->m_vehicleType == VEHICLE_TYPE_BOAT))
+#else // && and || priority failure it seems, also crashes on special models
+			pVehicleInfo->m_vehicleType == VEHICLE_TYPE_CAR || pVehicleInfo->m_vehicleType == VEHICLE_TYPE_BOAT)
+#endif
+			result = i;
+	}
+	return result;
+}
+
+void CSceneEdit::LoadMovie(void)
+{
+	ReInitialise();
+	CFileMgr::SetDir("DATA");
+	int fid = CFileMgr::OpenFile("movie.dat", "r");
+#ifdef FIX_BUGS
+	if (fid >= 0)
+#endif
+	{
+		CFileMgr::Read(fid, (char*)&Movie, sizeof(Movie));
+		CFileMgr::Read(fid, (char*)&m_nNumMovieCommands, sizeof(m_nNumMovieCommands));
+		CFileMgr::CloseFile(fid);
+	}
+	CFileMgr::SetDir("");
+	m_bCommandActive = false;
+}
+
+void CSceneEdit::SaveMovie(void)
+{
+	CFileMgr::SetDir("DATA");
+	int fid = CFileMgr::OpenFileForWriting("movie.dat");
+	if (fid >= 0) {
+		CFileMgr::Write(fid, (char*)&Movie, sizeof(Movie));
+		CFileMgr::Write(fid, (char*)&m_nNumMovieCommands, sizeof(m_nNumMovieCommands));
+		CFileMgr::CloseFile(fid);
+	}
+	CFileMgr::SetDir("");
+	m_bCommandActive = false;
+}
+
+void CSceneEdit::Initialise(void)
+{
+	m_nActor = -1;
+	m_nActor2 = -1;
+	m_nVehicle = -1;
+	m_nVehicle2 = -1;
+	m_nCurrentCommand = MOVIE_NEW_ACTOR;
+	m_nVehiclemodelId = MI_INFERNUS;
+	m_nPedmodelId = MI_MALE01;
+	m_nNumVehicles = 0;
+	m_nNumActors = 0;
+	m_nNumMovieCommands = 0;
+	m_bCommandActive = false;
+	m_bRecording = true;
+	m_bEditOn = false;
+	for (int i = 0; i < NUM_ACTORS_IN_MOVIE; i++)
+		pActors[i] = nil;
+	for (int i = 0; i < NUM_VEHICLES_IN_MOVIE; i++)
+		pVehicles[i] = nil;
+	m_vecCamHeading = TheCamera.Cams[TheCamera.ActiveCam].Front;
+	m_vecGotoPosition = CVector(0.0f, 0.0f, 0.0f);
+	m_bCameraFollowActor = false;
+	TheCamera.Cams[TheCamera.ActiveCam].ResetStatics = true;
+	m_bDrawGotoArrow = false;
+}
+
+void CSceneEdit::InitPlayback(void)
+{
+	m_nVehiclemodelId = MI_INFERNUS;
+	m_nPedmodelId = MI_MALE01;
+	m_bCommandActive = false;
+	m_nNumActors = 0;
+	m_nNumVehicles = 0;
+	m_nActor = -1;
+	m_nActor2 = -1;
+	m_nVehicle = -1;
+	m_nVehicle2 = -1;
+	TheCamera.Cams[TheCamera.ActiveCam].ResetStatics = true;
+	m_vecCamHeading = TheCamera.Cams[TheCamera.ActiveCam].Front;
+	for (int i = 0; i < NUM_ACTORS_IN_MOVIE; i++) {
+		if (pActors[i]) {
+			CPopulation::RemovePed(pActors[i]);
+			pActors[i] = nil;
+		}
+	}
+	m_nCurrentActor = 0;
+	for (int i = 0; i < NUM_VEHICLES_IN_MOVIE; i++) {
+		if (pVehicles[i]) {
+			CWorld::Remove(pVehicles[i]);
+			delete pVehicles[i];
+			pVehicles[i] = nil;
+		}
+	}
+	m_nCurrentVehicle = 0;
+	m_vecGotoPosition = CVector(0.0f, 0.0f, 0.0f);
+	m_nCurrentMovieCommand = MOVIE_DO_NOTHING;
+	m_bDrawGotoArrow = false;
+}
+
+void CSceneEdit::ReInitialise(void)
+{
+	m_nVehiclemodelId = MI_INFERNUS;
+	m_nPedmodelId = MI_MALE01;
+	m_nCurrentCommand = MOVIE_NEW_ACTOR;
+	m_bEditOn = true;
+	m_bRecording = true;
+	m_bCommandActive = false;
+#ifdef FIX_BUGS
+	m_bCameraFollowActor = false;
+	TheCamera.Cams[TheCamera.ActiveCam].ResetStatics = true; // not enough...
+#endif
+	m_nActor = -1;
+	m_nActor2 = -1;
+	m_nVehicle = -1;
+	m_nVehicle2 = -1;
+	m_nNumMovieCommands = 0;
+	m_nCurrentMovieCommand = MOVIE_DO_NOTHING;
+	m_nNumActors = 0;
+	m_nNumVehicles = 0;
+	for (int i = 0; i < NUM_ACTORS_IN_MOVIE; i++) {
+		if (pActors[i]) {
+			CPopulation::RemovePed(pActors[i]);
+			pActors[i] = nil;
+		}
+	}
+	for (int i = 0; i < NUM_VEHICLES_IN_MOVIE; i++) {
+		if (pVehicles[i]) {
+			CWorld::Remove(pVehicles[i]);
+			delete pVehicles[i];
+			pVehicles[i] = nil;
+		}
+	}
+	for (int i = 0; i < NUM_COMMANDS_IN_MOVIE; i++) {
+		Movie[i].m_nCommandId = MOVIE_DO_NOTHING;
+		Movie[i].m_vecPosition = CVector(0.0f, 0.0f, 0.0f);
+		Movie[i].m_vecCamera = CVector(0.0f, 0.0f, 0.0f);
+		Movie[i].m_nActorId = -1;
+		Movie[i].m_nActor2Id = -1;
+		Movie[i].m_nVehicleId = -1;
+		Movie[i].m_nModelIndex = 0;
+	}
+	m_vecGotoPosition = CVector(0.0f, 0.0f, 0.0f);
+	m_bDrawGotoArrow = false;
+}
+
+void CSceneEdit::Update(void)
+{
+	if (!m_bEditOn)
+		return;
+	if (m_bRecording)
+		ProcessCommand();
+	else {
+		if (m_bCameraFollowActor && m_nActor != -1) {
+			if (pActors[m_nActor]->bInVehicle)
+				TheCamera.TakeControl(pActors[m_nActor]->m_pMyVehicle, CCam::MODE_BEHINDCAR, JUMP_CUT, CAMCONTROL_SCRIPT);
+			else
+				TheCamera.TakeControl(pActors[m_nActor], CCam::MODE_FOLLOWPED, JUMP_CUT, CAMCONTROL_SCRIPT);
+		}
+		PlayBack();
+	}
+}
+
+void CSceneEdit::Draw(void)
+{
+	char str[200];
+	wchar wstr[200];
+	if (TheCamera.m_WideScreenOn)
+		return;
+#ifndef FIX_BUGS
+	CFont::SetPropOff();
+#endif
+	CFont::SetBackgroundOff();
+	CFont::SetScale(SCREEN_SCALE_X(0.8f), SCREEN_SCALE_Y(1.35f));
+	CFont::SetCentreOn();
+	CFont::SetRightJustifyOn();
+	CFont::SetRightJustifyWrap(0.0f);
+	CFont::SetBackGroundOnlyTextOff();
+#ifdef FIX_BUGS
+	CFont::SetFontStyle(FONT_BANK);
+	CFont::SetPropOn();
+	CFont::SetDropColor(CRGBA(0, 0, 0, 255));
+	CFont::SetDropShadowPosition(1);
+#else
+	CFont::SetFontStyle(FONT_HEADING);
+	CFont::SetPropOff();
+#endif
+	sprintf(str, "Action");
+	AsciiToUnicode(str, wstr);
+	CFont::SetColor(CRGBA(0, 0, 0, 0));
+	CFont::PrintString(SCREEN_SCALE_FROM_RIGHT(ACTION_MESSAGE_X_RIGHT - SHADOW_OFFSET), SCREEN_SCALE_Y(ACTION_MESSAGE_Y + SHADOW_OFFSET), wstr);
+	CFont::SetColor(CRGBA(193, 164, 120, 255));
+	CFont::PrintString(SCREEN_SCALE_FROM_RIGHT(ACTION_MESSAGE_X_RIGHT), SCREEN_SCALE_Y(ACTION_MESSAGE_Y), wstr);
+	sprintf(str, "Selected");
+	AsciiToUnicode(str, wstr);
+	CFont::SetColor(CRGBA(0, 0, 0, 0));
+	CFont::PrintString(SCREEN_SCALE_FROM_RIGHT(SELECTED_MESSAGE_X_RIGHT - SHADOW_OFFSET), SCREEN_SCALE_Y(SELECTED_MESSAGE_Y + SHADOW_OFFSET), wstr);
+	CFont::SetColor(CRGBA(193, 164, 120, 255));
+	CFont::PrintString(SCREEN_SCALE_FROM_RIGHT(SELECTED_MESSAGE_X_RIGHT), SCREEN_SCALE_Y(SELECTED_MESSAGE_Y), wstr);
+	CFont::SetCentreOff();
+	CFont::SetScale(SCREEN_SCALE_X(0.7f), SCREEN_SCALE_Y(0.7f));
+#ifdef FIX_BUGS
+	CFont::SetFontStyle(FONT_BANK);
+#else
+	CFont::SetFontStyle(FONT_HEADING);
+#endif
+	CFont::SetColor(CRGBA(0, 0, 0, 0));
+	for (int i = 0; i < NUM_COMMANDS_TO_DRAW; i++) {
+		int16 nCommandDrawn = m_nCurrentCommand + i - NUM_COMMANDS_TO_DRAW / 2;
+		if (nCommandDrawn >= MOVIE_TOTAL_COMMANDS)
+			nCommandDrawn -= (MOVIE_TOTAL_COMMANDS - 1);
+		if (nCommandDrawn <= MOVIE_DO_NOTHING)
+			nCommandDrawn += (MOVIE_TOTAL_COMMANDS - 1);
+		sprintf(str, pCommandStrings[nCommandDrawn]);
+		AsciiToUnicode(str, wstr);
+		CFont::SetColor(CRGBA(0, 0, 0, 0));
+		CFont::PrintString(SCREEN_SCALE_FROM_RIGHT(COMMAND_NAME_X_RIGHT - SHADOW_OFFSET), SCREEN_SCALE_Y(COMMAND_NAME_Y + SHADOW_OFFSET + i * COMMAND_NAME_HEIGHT), wstr);
+		if (nCommandDrawn == m_nCurrentCommand)
+			CFont::SetColor(CRGBA(156, 91, 40, 255));
+		else
+			CFont::SetColor(CRGBA(193, 164, 120, 255));
+		CFont::PrintString(SCREEN_SCALE_FROM_RIGHT(COMMAND_NAME_X_RIGHT), SCREEN_SCALE_Y(COMMAND_NAME_Y + i * COMMAND_NAME_HEIGHT), wstr);
+	}
+}
+
+void CSceneEdit::ProcessCommand(void)
+{
+	if (!m_bCommandActive) {
+		ClearForNewCommand();
+		if (CPad::GetPad(1)->GetDPadUpJustDown()) {
+			if (--m_nCurrentCommand == MOVIE_DO_NOTHING)
+				m_nCurrentCommand = MOVIE_END;
+		}
+		if (CPad::GetPad(1)->GetDPadDownJustDown()) {
+			if (++m_nCurrentCommand == MOVIE_TOTAL_COMMANDS)
+				m_nCurrentCommand = MOVIE_NEW_ACTOR;
+		}
+		if (CPad::GetPad(1)->GetTriangleJustDown()) {
+			if (m_nCurrentCommand != MOVIE_DO_NOTHING)
+				m_bCommandActive = true;
+		}
+		return;
+	}
+	switch (m_nCurrentCommand) {
+	case MOVIE_DO_NOTHING:
+		m_bCommandActive = false;
+		break;
+	case MOVIE_NEW_ACTOR:
+		if (m_nActor == -1) {
+			if (m_nNumActors == NUM_ACTORS_IN_MOVIE)
+				break;
+			if (!CStreaming::HasModelLoaded(m_nPedmodelId)) {
+				CStreaming::RequestModel(m_nPedmodelId, 0);
+#ifdef FIX_BUGS
+				CStreaming::LoadAllRequestedModels(false); // otherwise gets stuck :(
+#endif
+				break;
+			}
+			CPed* pPed = new CCivilianPed(PEDTYPE_SPECIAL, m_nPedmodelId);
+			pPed->CharCreatedBy = MISSION_CHAR;
+			pPed->GetPosition() = m_vecCurrentPosition;
+			pPed->SetOrientation(0.0f, 0.0f, 0.0f);
+			CWorld::Add(pPed);
+			pPed->bUsesCollision = false;
+			pPed->bAffectedByGravity = false;
+			for (int i = 0; i < NUM_ACTORS_IN_MOVIE; i++) {
+				if (pActors[i] == nil) {
+					m_nActor = i;
+					pActors[i] = pPed;
+					break;
+				}
+			}
+		}
+		else {
+			pActors[m_nActor]->GetPosition() = m_vecCurrentPosition;
+			pActors[m_nActor]->SetOrientation(0.0f, 0.0f, 0.0f);
+			int32 mi = m_nPedmodelId;
+			if (CPad::GetPad(1)->GetLeftShoulder1JustDown())
+				mi = NextValidModelId(m_nPedmodelId, -1);
+			else if (CPad::GetPad(1)->GetRightShoulder1JustDown())
+				mi = NextValidModelId(m_nPedmodelId, 1);
+			if (mi == m_nPedmodelId) {
+				if (CPad::GetPad(1)->GetTriangleJustDown()) {
+					pActors[m_nActor]->bUsesCollision = true;
+					pActors[m_nActor]->bAffectedByGravity = true;
+					++m_nNumActors;
+					Movie[m_nNumMovieCommands].m_nCommandId = MOVIE_NEW_ACTOR;
+					Movie[m_nNumMovieCommands].m_vecPosition = m_vecCurrentPosition;
+					Movie[m_nNumMovieCommands].m_nModelIndex = m_nPedmodelId;
+					Movie[m_nNumMovieCommands++].m_nActorId = m_nActor;
+					m_nActor = -1;
+					m_bCommandActive = false;
+				}
+				if (CPad::GetPad(1)->GetCircleJustDown()) {
+					CWorld::Remove(pActors[m_nActor]);
+					delete pActors[m_nActor];
+					pActors[m_nActor] = nil;
+					m_nActor = -1;
+					m_bCommandActive = false;
+				}
+			}
+			else {
+				m_nPedmodelId = mi;
+				if (pActors[m_nActor]) {
+					CWorld::Remove(pActors[m_nActor]);
+					delete pActors[m_nActor];
+				}
+				pActors[m_nActor] = nil;
+				m_nActor = -1;
+			}
+		}
+		break;
+	case MOVIE_MOVE_ACTOR:
+		SelectActor();
+		if (m_bCommandActive)
+			break;
+		pActors[m_nActor]->GetPosition() = m_vecCurrentPosition;
+		if (CPad::GetPad(1)->GetTriangleJustDown()) {
+			m_bCommandActive = false;
+#ifndef FIX_BUGS // why? it crashes, also makes no sense
+			pActors[m_nActor] = nil;
+#endif
+			SelectActor();
+		}
+		break;
+	case MOVIE_SELECT_ACTOR:
+		SelectActor();
+		break;
+	case MOVIE_DELETE_ACTOR:
+		SelectActor();
+		if (m_bActorSelected) {
+			CPopulation::RemovePed(pActors[m_nActor]);
+			m_nCurrentActor = 0;
+			--m_nNumActors;
+#ifdef FIX_BUGS
+			pActors[m_nActor] = nil;
+			m_nActor = -1;
+#else
+			m_nActor = -1;
+			pActors[m_nActor] = nil;
+#endif
+			SelectActor();
+			m_bCommandActive = false;
+		}
+		else if (CPad::GetPad(1)->GetCircleJustDown()) {
+			m_nActor = -1;
+			m_bCommandActive = false;
+		}
+		break;
+	case MOVIE_NEW_VEHICLE:
+		if (m_nVehicle == -1) {
+			if (m_nNumVehicles == NUM_VEHICLES_IN_MOVIE)
+				break;
+			if (!CStreaming::HasModelLoaded(m_nVehiclemodelId)) {
+				CStreaming::RequestModel(m_nVehiclemodelId, 0);
+#ifdef FIX_BUGS
+				CStreaming::LoadAllRequestedModels(false); // otherwise gets stuck :(
+#endif
+				break;
+			}
+			CVehicle* pVehicle = new CAutomobile(m_nVehiclemodelId, MISSION_VEHICLE);
+			pVehicle->m_status = STATUS_PHYSICS;
+			pVehicle->GetPosition() = m_vecCurrentPosition;
+			pVehicle->SetOrientation(0.0f, 0.0f, 0.0f);
+			CWorld::Add(pVehicle);
+			pVehicle->bUsesCollision = false;
+			pVehicle->bAffectedByGravity = false;
+			for (int i = 0; i < NUM_VEHICLES_IN_MOVIE; i++) {
+				if (pVehicles[i] == nil) {
+					m_nVehicle = i;
+					pVehicles[i] = pVehicle;
+					break;
+				}
+			}
+		}
+		else {
+			pVehicles[m_nVehicle]->GetPosition() = m_vecCurrentPosition;
+			pVehicles[m_nVehicle]->SetOrientation(0.0f, 0.0f, 0.0f);
+			int32 mi = m_nVehiclemodelId;
+			if (CPad::GetPad(1)->GetLeftShoulder1JustDown())
+				mi = NextValidModelId(m_nVehiclemodelId, -1);
+			else if (CPad::GetPad(1)->GetRightShoulder1JustDown())
+				mi = NextValidModelId(m_nVehiclemodelId, 1);
+			if (mi == m_nVehiclemodelId) {
+				if (CPad::GetPad(1)->GetTriangleJustDown()) {
+					pVehicles[m_nVehicle]->bUsesCollision = true;
+					pVehicles[m_nVehicle]->bAffectedByGravity = true;
+					++m_nNumVehicles;
+					Movie[m_nNumMovieCommands].m_nCommandId = MOVIE_NEW_VEHICLE;
+					Movie[m_nNumMovieCommands].m_vecPosition = m_vecCurrentPosition;
+					Movie[m_nNumMovieCommands].m_nModelIndex = m_nVehiclemodelId;
+					Movie[m_nNumMovieCommands++].m_nVehicleId = m_nVehicle;
+					m_nVehicle = -1;
+					m_bCommandActive = false;
+				}
+				if (CPad::GetPad(1)->GetCircleJustDown()) {
+					CWorld::Remove(pVehicles[m_nVehicle]);
+					delete pVehicles[m_nVehicle];
+					pVehicles[m_nVehicle] = nil;
+					m_nVehicle = -1;
+					m_bCommandActive = false;
+				}
+			}
+			else {
+				m_nVehiclemodelId = mi;
+				if (pVehicles[m_nVehicle]) {
+					CWorld::Remove(pVehicles[m_nVehicle]);
+					delete pVehicles[m_nVehicle];
+				}
+				pVehicles[m_nVehicle] = nil;
+				m_nVehicle = -1;
+			}
+		}
+		break;
+	case MOVIE_MOVE_VEHICLE:
+		SelectVehicle();
+		if (m_bCommandActive)
+			break;
+		pVehicles[m_nVehicle]->GetPosition() = m_vecCurrentPosition;
+		if (CPad::GetPad(1)->GetTriangleJustDown()) {
+			m_bCommandActive = false;
+#ifndef FIX_BUGS // again, why? works wrong
+			pVehicles[m_nVehicle] = nil;
+#endif
+			m_nVehicle = -1;
+		}
+		break;
+	case MOVIE_SELECT_VEHICLE:
+		SelectVehicle();
+		break;
+	case MOVIE_DELETE_VEHICLE:
+		SelectVehicle();
+		if (m_bVehicleSelected) {
+			CWorld::Remove(pVehicles[m_nVehicle]);
+			delete pVehicles[m_nVehicle];
+			m_nCurrentVehicle = 0;
+			--m_nNumVehicles;
+			pVehicles[m_nVehicle] = nil;
+			m_nVehicle = -1;
+			SelectVehicle();
+			m_bCommandActive = false;
+		}
+		else if (CPad::GetPad(1)->GetCircleJustDown()) {
+			pVehicles[m_nVehicle] = nil;
+			m_nVehicle = -1;
+			m_bCommandActive = false;
+		}
+		break;
+	case MOVIE_GIVE_WEAPON:
+		if (m_bActorSelected) {
+			if (SelectWeapon()) {
+				m_bCommandActive = false;
+				Movie[m_nNumMovieCommands].m_nCommandId = MOVIE_GIVE_WEAPON;
+				Movie[m_nNumMovieCommands].m_nActorId = m_nActor;
+				Movie[m_nNumMovieCommands++].m_nModelIndex = m_nWeaponType;
+			}
+		}
+		else {
+			SelectActor();
+			m_bCommandActive = true;
+		}
+		break;
+	case MOVIE_GOTO:
+	case MOVIE_GOTO_WAIT:
+		if (!m_bActorSelected) {
+			m_bDrawGotoArrow = true;
+			SelectActor();
+			if (m_nActor == -1)
+				m_bCommandActive = true;
+		}
+		else {
+			m_vecGotoPosition = m_vecCurrentPosition;
+			if (CPad::GetPad(1)->GetTriangleJustDown()) {
+				if (pActors[m_nActor]->bInVehicle) {
+					if (CCarCtrl::JoinCarWithRoadSystemGotoCoors(pActors[m_nActor]->m_pMyVehicle, m_vecGotoPosition, false))
+						pActors[m_nActor]->m_pMyVehicle->AutoPilot.m_nCarMission = MISSION_GOTOCOORDS_STRAIGHT;
+					else
+						pActors[m_nActor]->m_pMyVehicle->AutoPilot.m_nCarMission = MISSION_GOTOCOORDS;
+					pActors[m_nActor]->m_pMyVehicle->m_status = STATUS_PHYSICS;
+					pActors[m_nActor]->m_pMyVehicle->bEngineOn = true;
+					pActors[m_nActor]->m_pMyVehicle->AutoPilot.m_nCruiseSpeed = max(16, pActors[m_nActor]->m_pMyVehicle->AutoPilot.m_nCruiseSpeed);
+					pActors[m_nActor]->m_pMyVehicle->AutoPilot.m_nAntiReverseTimer = CTimer::GetTimeInMilliseconds();
+					TheCamera.TakeControl(pActors[m_nActor]->m_pMyVehicle, CCam::MODE_BEHINDCAR, JUMP_CUT, CAMCONTROL_SCRIPT);
+				}
+				else {
+					pActors[m_nActor]->SetObjective(OBJECTIVE_GOTO_AREA_ON_FOOT, m_vecGotoPosition);
+					TheCamera.TakeControl(pActors[m_nActor], CCam::MODE_FOLLOWPED, JUMP_CUT, CAMCONTROL_SCRIPT);
+				}
+				m_bDrawGotoArrow = false;
+				Movie[m_nNumMovieCommands].m_nCommandId = MOVIE_GOTO;
+				Movie[m_nNumMovieCommands].m_nActorId = m_nActor;
+				Movie[m_nNumMovieCommands++].m_vecPosition = m_vecGotoPosition;
+			}
+			if (!m_bDrawGotoArrow) {
+				if (pActors[m_nActor]->bInVehicle && pActors[m_nActor]->m_pMyVehicle->AutoPilot.m_nCarMission == MISSION_NONE ||
+					!pActors[m_nActor]->bInVehicle && pActors[m_nActor]->m_objective == OBJECTIVE_NONE) {
+					if (pActors[m_nActor]) // if there is something that requires this check the least, it's this one
+						m_vecCamHeading = TheCamera.Cams[TheCamera.ActiveCam].CamTargetEntity->GetPosition() - TheCamera.Cams[TheCamera.ActiveCam].Source;
+					m_bCommandActive = false;
+					TheCamera.Cams[TheCamera.ActiveCam].Mode = CCam::MODE_FIGHT_CAM_RUNABOUT;
+					m_vecCurrentPosition = pActors[m_nActor]->GetPosition();
+					pActors[m_nActor]->SetObjective(OBJECTIVE_NONE);
+					if (pActors[m_nActor]->bInVehicle)
+						pActors[m_nActor]->m_pMyVehicle->AutoPilot.m_nCarMission = MISSION_NONE;
+				}
+			}
+			if (CPad::GetPad(1)->GetCircleJustDown()) {
+				pActors[m_nActor] = nil;
+				m_nActor = -1;
+				m_bCommandActive = false;
+			}
+		}
+		break;
+	case MOVIE_GET_IN_CAR:
+		if (m_bActorSelected)
+			SelectVehicle();
+		else {
+			SelectActor();
+			if (m_nActor != -1)
+				m_bCommandActive = true;
+		}
+		if (m_bVehicleSelected) {
+			pActors[m_nActor]->SetObjective(OBJECTIVE_ENTER_CAR_AS_DRIVER, pVehicles[m_nVehicle]);
+			Movie[m_nNumMovieCommands].m_nCommandId = MOVIE_GET_IN_CAR;
+			Movie[m_nNumMovieCommands].m_nActorId = m_nActor;
+			Movie[m_nNumMovieCommands++].m_nVehicleId = m_nVehicle;
+			m_nVehicle = -1;
+			m_bCommandActive = false;
+		}
+		if (CPad::GetPad(1)->GetCircleJustDown()) {
+			pVehicles[m_nVehicle] = nil;
+			m_nVehicle = -1;
+			pActors[m_nActor] = nil;
+			m_nActor = -1;
+			m_bCommandActive = false;
+		}
+		break;
+	case MOVIE_GET_OUT_CAR:
+		SelectActor();
+		if (m_bActorSelected) {
+			if (pActors[m_nActor]->bInVehicle) {
+				pActors[m_nActor]->SetObjective(OBJECTIVE_LEAVE_VEHICLE);
+				Movie[m_nNumMovieCommands].m_nCommandId = MOVIE_GET_OUT_CAR;
+				Movie[m_nNumMovieCommands++].m_nActorId = m_nActor;
+			}
+			m_nActor = -1;
+			m_bCommandActive = false;
+		}
+		if (CPad::GetPad(1)->GetCircleJustDown()) {
+			pVehicles[m_nVehicle] = nil;
+			m_nVehicle = -1;
+			pActors[m_nActor] = nil;
+			m_nActor = -1;
+			m_bCommandActive = false;
+		}
+		break;
+	case MOVIE_KILL:
+		if (!m_bActorSelected) {
+			SelectActor();
+			m_bCommandActive = true;
+		}
+		else if (!m_bActor2Selected) {
+			SelectActor2();
+			if (m_bActorSelected && m_bActor2Selected && m_nActor != -1 && m_nActor2 != -1 && m_nActor != m_nActor2) {
+				pActors[m_nActor]->SetObjective(OBJECTIVE_KILL_CHAR_ON_FOOT, pActors[m_nActor2]);
+				Movie[m_nNumMovieCommands].m_nCommandId = MOVIE_KILL;
+				Movie[m_nNumMovieCommands].m_nActorId = m_nActor;
+				Movie[m_nNumMovieCommands++].m_nActor2Id = m_nActor2;
+				m_bCommandActive = false;
+			}
+		}
+		if (CPad::GetPad(1)->GetCircleJustDown()) {
+			pActors[m_nActor] = nil;
+			m_nActor = -1;
+			pActors[m_nActor2] = nil;
+			m_nActor2 = -1;
+			m_bCommandActive = false;
+		}
+		break;
+	case MOVIE_FLEE:
+		if (!m_bActorSelected) {
+			SelectActor();
+			m_bCommandActive = true;
+		}
+		else if (!m_bActor2Selected) {
+			SelectActor2();
+			if (m_bActorSelected && m_bActor2Selected && m_nActor != -1 && m_nActor2 != -1 && m_nActor != m_nActor2) {
+				pActors[m_nActor]->SetObjective(OBJECTIVE_FLEE_CHAR_ON_FOOT_ALWAYS, pActors[m_nActor2]);
+				Movie[m_nNumMovieCommands].m_nCommandId = MOVIE_FLEE;
+				Movie[m_nNumMovieCommands].m_nActorId = m_nActor;
+				Movie[m_nNumMovieCommands++].m_nActor2Id = m_nActor2;
+				m_bCommandActive = false;
+			}
+		}
+		if (CPad::GetPad(1)->GetCircleJustDown()) {
+			pActors[m_nActor] = nil;
+			m_nActor = -1;
+			pActors[m_nActor2] = nil;
+			m_nActor2 = -1;
+			m_bCommandActive = false;
+		}
+		break;
+	case MOVIE_WAIT:
+		SelectActor();
+		if (m_bActorSelected) {
+			pActors[m_nActor]->SetObjective(OBJECTIVE_IDLE);
+			Movie[m_nNumMovieCommands].m_nCommandId = MOVIE_WAIT;
+			Movie[m_nNumMovieCommands++].m_nActorId = m_nActor;
+		}
+		if (CPad::GetPad(1)->GetCircleJustDown()) {
+			pActors[m_nActor] = nil;
+			m_nActor = -1;
+			m_bCommandActive = false;
+		}
+		break;
+	case MOVIE_POSITION_CAMERA:
+		if (CPad::GetPad(1)->GetTriangleJustDown()) {
+			Movie[m_nNumMovieCommands].m_nCommandId = MOVIE_POSITION_CAMERA;
+			Movie[m_nNumMovieCommands].m_vecPosition = TheCamera.Cams[TheCamera.ActiveCam].Source;
+			Movie[m_nNumMovieCommands++].m_vecCamera = m_vecCamHeading;
+			m_bCommandActive = false;
+		}
+		if (CPad::GetPad(1)->GetCircleJustDown()) {
+			m_bCommandActive = false;
+		}
+		break;
+	case MOVIE_SET_CAMERA_TARGET:
+		if (!m_bActorSelected) {
+			SelectActor();
+			m_bCommandActive = true;
+		}
+		else {
+			TheCamera.Cams[TheCamera.ActiveCam].CamTargetEntity = pActors[m_nActor];
+			if (CPad::GetPad(1)->GetTriangleJustDown()) {
+				Movie[m_nNumMovieCommands].m_nCommandId = MOVIE_SET_CAMERA_TARGET;
+				Movie[m_nNumMovieCommands++].m_nActorId = m_nActor;
+				m_bCommandActive = false;
+			}
+		}
+		break;
+	case MOVIE_SELECT_CAMERA_MODE:
+		m_bCommandActive = false;
+		break;
+	case MOVIE_SAVE_MOVIE:
+		SaveMovie();
+		break;
+	case MOVIE_LOAD_MOVIE:
+		LoadMovie();
+		break;
+	case MOVIE_PLAY_MOVIE:
+		InitPlayback();
+		LoadMovie();
+		m_bRecording = false;
+		break;
+	case MOVIE_END:
+		m_bRecording = false;
+		break;
+	default:
+		assert(0);
+	}
+}
+
+void CSceneEdit::PlayBack(void)
+{
+	m_nCurrentCommand = Movie[m_nCurrentMovieCommand].m_nCommandId;
+	if (m_nCurrentMovieCommand >= m_nNumMovieCommands) {
+		if (CPad::GetPad(1)->GetTriangleJustDown()) {
+			m_nCurrentCommand = MOVIE_DO_NOTHING;
+			m_bRecording = true;
+			ReInitialise();
+		}
+		return;
+	}
+	switch (m_nCurrentCommand) {
+	case MOVIE_DO_NOTHING:
+	case MOVIE_MOVE_ACTOR:
+	case MOVIE_SELECT_ACTOR:
+	case MOVIE_DELETE_ACTOR:
+	case MOVIE_MOVE_VEHICLE:
+	case MOVIE_SELECT_VEHICLE:
+	case MOVIE_DELETE_VEHICLE:
+		break;
+	case MOVIE_NEW_ACTOR:
+	{
+		m_nPedmodelId = Movie[m_nCurrentMovieCommand].m_nModelIndex;
+		m_vecCurrentPosition = Movie[m_nCurrentMovieCommand].m_vecPosition;
+		if (!CStreaming::HasModelLoaded(m_nPedmodelId)) {
+			CStreaming::RequestModel(m_nPedmodelId, 0);
+#ifdef FIX_BUGS
+			CStreaming::LoadAllRequestedModels(false); // otherwise gets stuck :(
+#endif
+			break;
+		}
+		CPed* pPed = new CCivilianPed(PEDTYPE_SPECIAL, m_nPedmodelId);
+		pPed->CharCreatedBy = MISSION_CHAR;
+		CWorld::Add(pPed);
+		pPed->GetPosition() = m_vecCurrentPosition;
+		pPed->SetOrientation(0.0f, 0.0f, 0.0f);
+		for (int i = 0; i < NUM_ACTORS_IN_MOVIE; i++) {
+			if (pActors[i] == nil) {
+				m_nActor = i;
+				pActors[i] = pPed;
+				break;
+			}
+		}
+		m_nNumActors++;
+		m_nCurrentMovieCommand++;
+		break;
+	}
+	case MOVIE_NEW_VEHICLE:
+	{
+		m_nVehiclemodelId = Movie[m_nCurrentMovieCommand].m_nModelIndex;
+		m_vecCurrentPosition = Movie[m_nCurrentMovieCommand].m_vecPosition;
+		if (!CStreaming::HasModelLoaded(m_nVehiclemodelId)) {
+			CStreaming::RequestModel(m_nVehiclemodelId, 0);
+#ifdef FIX_BUGS
+			CStreaming::LoadAllRequestedModels(false); // otherwise gets stuck :(
+#endif
+			break;
+		}
+		CVehicle* pVehicle = new CAutomobile(m_nVehiclemodelId, MISSION_VEHICLE);
+		pVehicle->m_status = STATUS_PHYSICS;
+		pVehicle->GetPosition() = m_vecCurrentPosition;
+		pVehicle->SetOrientation(0.0f, 0.0f, 0.0f);
+		CWorld::Add(pVehicle);
+		for (int i = 0; i < NUM_VEHICLES_IN_MOVIE; i++) {
+			if (pVehicles[i] == nil) {
+				m_nVehicle = i;
+				pVehicles[i] = pVehicle;
+				break;
+			}
+		}
+		m_nNumVehicles++;
+		m_nCurrentMovieCommand++;
+		break;
+	}
+	case MOVIE_GIVE_WEAPON:
+		m_nActor = Movie[m_nCurrentMovieCommand].m_nActorId;
+		m_nWeaponType = Movie[m_nCurrentMovieCommand].m_nModelIndex;
+		pActors[m_nActor]->GiveWeapon((eWeaponType)m_nWeaponType, 1000);
+		pActors[m_nActor]->AddWeaponModel(CWeaponInfo::GetWeaponInfo(pActors[m_nActor]->GetWeapon()->m_eWeaponType)->m_nModelId);
+		pActors[m_nActor]->SetCurrentWeapon(m_nWeaponType);
+		m_nCurrentMovieCommand++;
+		break;
+	case MOVIE_GOTO:
+	case MOVIE_GOTO_WAIT:
+		m_nActor = Movie[m_nCurrentMovieCommand].m_nActorId;
+		m_vecGotoPosition = Movie[m_nCurrentMovieCommand].m_vecPosition;
+		if (pActors[m_nActor]->bInVehicle) {
+			if (pActors[m_nActor]->m_pMyVehicle->AutoPilot.m_nCarMission != MISSION_GOTOCOORDS &&
+				pActors[m_nActor]->m_pMyVehicle->AutoPilot.m_nCarMission != MISSION_GOTOCOORDS_STRAIGHT) {
+				if ((pActors[m_nActor]->m_pMyVehicle->GetPosition() - m_vecGotoPosition).Magnitude() < 5.0f) {
+					if (CCarCtrl::JoinCarWithRoadSystemGotoCoors(pActors[m_nActor]->m_pMyVehicle, m_vecGotoPosition, false))
+						pActors[m_nActor]->m_pMyVehicle->AutoPilot.m_nCarMission = MISSION_GOTOCOORDS_STRAIGHT;
+					else
+						pActors[m_nActor]->m_pMyVehicle->AutoPilot.m_nCarMission = MISSION_GOTOCOORDS;
+					pActors[m_nActor]->m_pMyVehicle->m_status = STATUS_PHYSICS;
+					pActors[m_nActor]->m_pMyVehicle->bEngineOn = true;
+					pActors[m_nActor]->m_pMyVehicle->AutoPilot.m_nCruiseSpeed = max(16, pActors[m_nActor]->m_pMyVehicle->AutoPilot.m_nCruiseSpeed);
+					pActors[m_nActor]->m_pMyVehicle->AutoPilot.m_nAntiReverseTimer = CTimer::GetTimeInMilliseconds();
+					if (m_nCurrentCommand != MOVIE_GOTO_WAIT)
+						++m_nCurrentMovieCommand;
+				}
+				else
+					++m_nCurrentMovieCommand;
+			}
+		}
+		else {
+			if (pActors[m_nActor]->m_objective != OBJECTIVE_GOTO_AREA_ON_FOOT) {
+				pActors[m_nActor]->SetObjective(OBJECTIVE_GOTO_AREA_ON_FOOT, m_vecGotoPosition);
+				++m_nCurrentMovieCommand;
+			}
+		}
+		break;
+	case MOVIE_GET_IN_CAR:
+		m_nActor = Movie[m_nCurrentMovieCommand].m_nActorId;
+		if (!pActors[m_nActor]->bInVehicle){
+			m_nVehicle = Movie[m_nCurrentMovieCommand].m_nVehicleId;
+			pActors[m_nActor]->SetObjective(OBJECTIVE_ENTER_CAR_AS_DRIVER, pVehicles[m_nVehicle]);
+		}
+		else
+			++m_nCurrentMovieCommand;
+		break;
+	case MOVIE_GET_OUT_CAR:
+		m_nActor = Movie[m_nCurrentMovieCommand].m_nActorId;
+		if (pActors[m_nActor]->bInVehicle)
+			pActors[m_nActor]->SetObjective(OBJECTIVE_LEAVE_VEHICLE);
+		else
+			++m_nCurrentMovieCommand;
+		break;
+	case MOVIE_KILL:
+		m_nActor = Movie[m_nCurrentMovieCommand].m_nActorId;
+		m_nActor2 = Movie[m_nCurrentMovieCommand].m_nActor2Id;
+		pActors[m_nActor]->SetObjective(OBJECTIVE_KILL_CHAR_ON_FOOT, pActors[m_nActor2]);
+		if (pActors[m_nActor2]->GetPedState() == PED_DEAD)
+			++m_nCurrentMovieCommand;
+		break;
+	case MOVIE_FLEE:
+		m_nActor = Movie[m_nCurrentMovieCommand].m_nActorId;
+		m_nActor2 = Movie[m_nCurrentMovieCommand].m_nActor2Id;
+		pActors[m_nActor]->SetObjective(OBJECTIVE_FLEE_CHAR_ON_FOOT_ALWAYS, pActors[m_nActor2]);
+		++m_nCurrentMovieCommand;
+		break;
+	case MOVIE_WAIT:
+		m_nActor = Movie[m_nCurrentMovieCommand].m_nActorId;
+		pActors[m_nActor]->SetObjective(OBJECTIVE_IDLE);
+		++m_nCurrentMovieCommand;
+		break;
+	case MOVIE_POSITION_CAMERA:
+		TheCamera.Cams[TheCamera.ActiveCam].Source = Movie[m_nCurrentMovieCommand].m_vecPosition;
+		m_vecCamHeading = Movie[m_nCurrentMovieCommand].m_vecCamera;
+		TheCamera.Cams[TheCamera.ActiveCam].Front = m_vecCamHeading;
+		++m_nCurrentMovieCommand;
+		break;
+	case MOVIE_SET_CAMERA_TARGET:
+		m_bCameraFollowActor = true;
+		TheCamera.Cams[TheCamera.ActiveCam].CamTargetEntity = pActors[Movie[m_nNumMovieCommands].m_nActorId];
+		TheCamera.pTargetEntity = pActors[Movie[m_nNumMovieCommands].m_nActorId];
+		TheCamera.m_bLookingAtPlayer = false;
+		++m_nCurrentMovieCommand;
+		break;
+	case MOVIE_SELECT_CAMERA_MODE:
+		m_bCommandActive = false; // this is wrong
+		break;
+	}
+}
+
+void CSceneEdit::ClearForNewCommand(void)
+{
+	m_nActor = -1;
+	m_nActor2 = -1;
+	m_nVehicle = -1;
+	m_bActorSelected = false;
+	m_bActor2Selected = false;
+	m_bVehicleSelected = false;
+	m_bDrawGotoArrow = false;
+}
+void CSceneEdit::SelectActor(void)
+{
+	m_bActorSelected = false;
+	if (m_nActor != -1) {
+		if (CPad::GetPad(1)->GetLeftShoulder1JustDown()) {
+			CPed* pPed;
+			do {
+				if (--m_nActor < 0)
+					m_nActor = NUM_ACTORS_IN_MOVIE - 1;
+				pPed = pActors[m_nActor];
+			} while (pPed == nil);
+			TheCamera.Cams[TheCamera.ActiveCam].Source = pPed->GetPosition() - m_vecCamHeading;
+		}
+		else if (CPad::GetPad(1)->GetRightShoulder1JustDown()) {
+			CPed* pPed;
+			do {
+				if (++m_nActor == NUM_ACTORS_IN_MOVIE)
+					m_nActor = 0;
+				pPed = pActors[m_nActor];
+			} while (pPed == nil);
+			TheCamera.Cams[TheCamera.ActiveCam].Source = pPed->GetPosition() - m_vecCamHeading;
+		}
+		m_vecCurrentPosition = pActors[m_nActor]->GetPosition();
+		if (CPad::GetPad(1)->GetTriangleJustDown()) {
+			m_bActorSelected = true;
+			m_bCommandActive = false;
+		}
+		else if (CPad::GetPad(1)->GetCircleJustDown()) {
+			m_nActor = -1;
+		}
+	}
+	else if (m_nNumActors != 0) {
+		for (int i = 0; i < NUM_ACTORS_IN_MOVIE; i++) {
+			if (pActors[i] != nil) {
+				m_nActor = i;
+				break;
+			}
+		}
+		TheCamera.Cams[TheCamera.ActiveCam].Source = pActors[m_nActor]->GetPosition() - m_vecCamHeading;
+		if (m_nNumActors == 1) {
+			m_bActorSelected = true;
+			m_bCommandActive = false;
+		}
+	}
+	else {
+		m_bCommandActive = false;
+	}
+}
+
+void CSceneEdit::SelectActor2(void)
+{
+	m_bActor2Selected = false;
+	if (m_nNumActors <= 1) {
+		m_bCommandActive = false;
+		return;
+	}
+	if (m_nActor2 != -1) {
+		if (CPad::GetPad(1)->GetLeftShoulder1JustDown()) {
+			CPed* pPed;
+			do {
+				if (--m_nActor2 < 0)
+					m_nActor2 = NUM_ACTORS_IN_MOVIE - 1;
+				pPed = pActors[m_nActor2];
+			} while (pPed == nil || pPed == pActors[m_nActor]);
+			TheCamera.Cams[TheCamera.ActiveCam].Source = pPed->GetPosition() - m_vecCamHeading;
+		}
+		else if (CPad::GetPad(1)->GetRightShoulder1JustDown()) {
+			CPed* pPed;
+			do {
+				if (++m_nActor2 == NUM_ACTORS_IN_MOVIE)
+					m_nActor2 = 0;
+				pPed = pActors[m_nActor2];
+			} while (pPed == nil || pPed == pActors[m_nActor]);
+			TheCamera.Cams[TheCamera.ActiveCam].Source = pPed->GetPosition() - m_vecCamHeading;
+		}
+		m_vecCurrentPosition = pActors[m_nActor2]->GetPosition();
+		if (CPad::GetPad(1)->GetTriangleJustDown()) {
+			m_bActor2Selected = true;
+			m_bCommandActive = false;
+		}
+		else if (CPad::GetPad(1)->GetCircleJustDown()) {
+			m_nActor2 = -1;
+		}
+	}
+	else {
+		for (int i = 0; i < NUM_ACTORS_IN_MOVIE; i++) {
+			if (pActors[i] != nil && pActors[m_nActor] != pActors[i] ) {
+				m_nActor2 = i;
+				break;
+			}
+		}
+		TheCamera.Cams[TheCamera.ActiveCam].Source = pActors[m_nActor2]->GetPosition() - m_vecCamHeading;
+	}
+}
+
+void CSceneEdit::SelectVehicle(void)
+{
+	m_bVehicleSelected = false;
+	if (m_nVehicle != -1) {
+		if (CPad::GetPad(1)->GetLeftShoulder1JustDown()) {
+			CVehicle* pVehicle;
+			do {
+				if (--m_nVehicle < 0)
+					m_nVehicle = NUM_VEHICLES_IN_MOVIE - 1;
+				pVehicle = pVehicles[m_nVehicle];
+			} while (pVehicle == nil);
+		}
+		else if (CPad::GetPad(1)->GetRightShoulder1JustDown()) {
+			CVehicle* pVehicle;
+			do {
+				if (++m_nVehicle == NUM_VEHICLES_IN_MOVIE)
+					m_nVehicle = 0;
+				pVehicle = pVehicles[m_nVehicle];
+			} while (pVehicle == nil);
+		}
+		m_vecCurrentPosition = pVehicles[m_nVehicle]->GetPosition();
+		TheCamera.Cams[TheCamera.ActiveCam].Source = pVehicles[m_nVehicle]->GetPosition() - m_vecCamHeading;
+		if (CPad::GetPad(1)->GetTriangleJustDown()) {
+			m_bVehicleSelected = true;
+			m_bCommandActive = false;
+		}
+		else if (CPad::GetPad(1)->GetCircleJustDown()) {
+			m_nVehicle = -1;
+		}
+	}
+	else if (m_nNumVehicles != 0) {
+		for (int i = 0; i < NUM_ACTORS_IN_MOVIE; i++) {
+			if (pVehicles[i] != nil) {
+				m_nVehicle = i;
+				break;
+			}
+		}
+	}
+}
+
+bool CSceneEdit::SelectWeapon(void)
+{
+	if (m_nWeaponType == WEAPONTYPE_UNARMED) {
+		m_nWeaponType = WEAPONTYPE_COLT45;
+		return false;
+	}
+	if (CPad::GetPad(1)->GetLeftShoulder1JustDown()) {
+		if (++m_nWeaponType >= WEAPONTYPE_DETONATOR)
+			m_nWeaponType = WEAPONTYPE_BASEBALLBAT;
+		pActors[m_nActor]->ClearWeapons();
+		pActors[m_nActor]->GiveWeapon((eWeaponType)m_nWeaponType, 1000);
+		pActors[m_nActor]->AddWeaponModel(CWeaponInfo::GetWeaponInfo(pActors[m_nActor]->GetWeapon()->m_eWeaponType)->m_nModelId);
+		pActors[m_nActor]->SetCurrentWeapon(m_nWeaponType);
+	}
+	else if (CPad::GetPad(1)->GetRightShoulder1JustDown()){
+		if (--m_nWeaponType <= WEAPONTYPE_UNARMED)
+			m_nWeaponType = WEAPONTYPE_GRENADE;
+		pActors[m_nActor]->ClearWeapons();
+		pActors[m_nActor]->GiveWeapon((eWeaponType)m_nWeaponType, 1000);
+		pActors[m_nActor]->AddWeaponModel(CWeaponInfo::GetWeaponInfo(pActors[m_nActor]->GetWeapon()->m_eWeaponType)->m_nModelId);
+		pActors[m_nActor]->SetCurrentWeapon(m_nWeaponType);
+	}
+	if (CPad::GetPad(1)->GetTriangleJustDown()) {
+		m_bCommandActive = false;
+		return true;
+	}
+	if (CPad::GetPad(1)->GetCircleJustDown()) {
+		pActors[m_nActor]->ClearWeapons();
+		m_nWeaponType = WEAPONTYPE_UNARMED;
+		m_bCommandActive = false;
+		return false;
+	}
+	return false;
+}
+\ No newline at end of file
diff --git a/src/control/SceneEdit.h b/src/control/SceneEdit.h
index 0de72c19..6dcefa31 100644
--- a/src/control/SceneEdit.h
+++ b/src/control/SceneEdit.h
@@ -1,14 +1,95 @@
 #pragma once
 
+class CPed;
+class CVehicle;
+
+struct CMovieCommand
+{
+	int32 m_nCommandId;
+	CVector m_vecPosition;
+	CVector m_vecCamera;
+	int16 m_nActorId;
+	int16 m_nActor2Id;
+	int16 m_nVehicleId;
+	int16 m_nModelIndex;
+};
+
 class CSceneEdit
 {
 public:
-	static bool &m_bEditOn;
-	static int32 &m_bCameraFollowActor;
-	static bool &m_bRecording;
-	static CVector &m_vecCurrentPosition;
-	static CVector &m_vecCamHeading;
+	enum {
+		MOVIE_DO_NOTHING = 0,
+		MOVIE_NEW_ACTOR,
+		MOVIE_MOVE_ACTOR,
+		MOVIE_SELECT_ACTOR,
+		MOVIE_DELETE_ACTOR,
+		MOVIE_NEW_VEHICLE,
+		MOVIE_MOVE_VEHICLE,
+		MOVIE_SELECT_VEHICLE,
+		MOVIE_DELETE_VEHICLE,
+		MOVIE_GIVE_WEAPON,
+		MOVIE_GOTO,
+		MOVIE_GOTO_WAIT,
+		MOVIE_GET_IN_CAR,
+		MOVIE_GET_OUT_CAR,
+		MOVIE_KILL,
+		MOVIE_FLEE,
+		MOVIE_WAIT,
+		MOVIE_POSITION_CAMERA,
+		MOVIE_SET_CAMERA_TARGET,
+		MOVIE_SELECT_CAMERA_MODE,
+		MOVIE_SAVE_MOVIE,
+		MOVIE_LOAD_MOVIE,
+		MOVIE_PLAY_MOVIE,
+		MOVIE_END,
+		MOVIE_TOTAL_COMMANDS
+	};
+	enum {
+		NUM_ACTORS_IN_MOVIE = 5,
+		NUM_VEHICLES_IN_MOVIE = 5,
+		NUM_COMMANDS_IN_MOVIE = 20
+	};
+	static int32 m_bCameraFollowActor;
+	static CVector m_vecCurrentPosition;
+	static CVector m_vecCamHeading;
+	static CVector m_vecGotoPosition;
+	static int32 m_nVehicle;
+	static int32 m_nVehicle2;
+	static int32 m_nActor;
+	static int32 m_nActor2;
+	static int32 m_nVehiclemodelId;
+	static int32 m_nPedmodelId;
+	static int16 m_nCurrentMovieCommand;
+	static int16 m_nCurrentCommand;
+	static int16 m_nCurrentVehicle;
+	static int16 m_nCurrentActor;
+	static bool m_bEditOn;
+	static bool m_bRecording;
+	static bool m_bCommandActive;
+	static bool m_bActorSelected;
+	static bool m_bActor2Selected;
+	static bool m_bVehicleSelected;
+	static int16 m_nNumActors;
+	static int16 m_nNumVehicles;
+	static int16 m_nNumMovieCommands;
+	static int16 m_nWeaponType;
+	static CPed* pActors[NUM_ACTORS_IN_MOVIE];
+	static CVehicle* pVehicles[NUM_VEHICLES_IN_MOVIE];
+	static bool m_bDrawGotoArrow;
+	static CMovieCommand Movie[NUM_COMMANDS_IN_MOVIE];
 
+	static void LoadMovie(void);
+	static void SaveMovie(void);
+	static void Initialise(void);
+	static void InitPlayback(void);
+	static void ReInitialise(void);
 	static void Update(void);
-	static void Init(void);
+	static void Draw(void);
+	static void ProcessCommand(void);
+	static void PlayBack(void);
+	static void ClearForNewCommand(void);
+	static void SelectActor(void);
+	static void SelectActor2(void);
+	static void SelectVehicle(void);
+	static bool SelectWeapon(void);
 };
diff --git a/src/control/Script.cpp b/src/control/Script.cpp
index 1f085d32..428ac66a 100644
--- a/src/control/Script.cpp
+++ b/src/control/Script.cpp
@@ -9147,7 +9147,7 @@ int8 CRunningScript::ProcessCommands1100To1199(int32 command)
 	}
 	case COMMAND_SET_JAMES_CAR_ON_PATH_TO_PLAYER:
 	{
-		CollectParameters(&m_nIp, 2);
+		CollectParameters(&m_nIp, 1);
 		CVehicle* pVehicle = CPools::GetVehiclePool()->GetAt(ScriptParams[0]);
 		assert(pVehicle);
 		CCarCtrl::JoinCarWithRoadSystemGotoCoors(pVehicle, FindPlayerCoors(), false);
@@ -10076,8 +10076,8 @@ void CRunningScript::LocatePlayerCarCommand(int32 command, uint32* pIp)
 		case COMMAND_LOCATE_PLAYER_ON_FOOT_CAR_3D:
 			result = !pPlayerInfo->m_pPed->bInVehicle;
 			break;
-		case COMMAND_LOCATE_PLAYER_IN_CAR_CHAR_2D:
-		case COMMAND_LOCATE_PLAYER_IN_CAR_CHAR_3D:
+		case COMMAND_LOCATE_PLAYER_IN_CAR_CAR_2D:
+		case COMMAND_LOCATE_PLAYER_IN_CAR_CAR_3D:
 			result = pPlayerInfo->m_pPed->bInVehicle;
 			break;
 		default:
@@ -11359,7 +11359,7 @@ VALIDATESAVEBUF(size)
 
 void CTheScripts::ClearSpaceForMissionEntity(const CVector& pos, CEntity* pEntity)
 {
-	static CColPoint aTempColPoints[32];
+	static CColPoint aTempColPoints[MAX_COLLISION_POINTS];
 	int16 entities = 0;
 	CEntity* aEntities[16];
 	CWorld::FindObjectsKindaColliding(pos, pEntity->GetBoundRadius(), false, &entities, 16, aEntities, false, true, true, false, false);
diff --git a/src/core/Camera.cpp b/src/core/Camera.cpp
index 91dd6573..c2392d3b 100644
--- a/src/core/Camera.cpp
+++ b/src/core/Camera.cpp
@@ -29,6 +29,7 @@
 #include "SceneEdit.h"
 #include "Pools.h"
 #include "Debug.h"
+#include "GenericGameStorage.h"
 #include "Camera.h"
 
 enum
@@ -2183,13 +2184,21 @@ CCamera::DrawBordersForWideScreen(void)
 		SetMotionBlurAlpha(80);
 
 	CSprite2d::DrawRect(
+#ifdef FIX_BUGS
+		CRect(0.0f, (SCREEN_HEIGHT/2) * m_ScreenReductionPercentage/100.0f - SCREEN_SCALE_Y(8.0f),
+#else
 		CRect(0.0f, (SCREEN_HEIGHT/2) * m_ScreenReductionPercentage/100.0f - 8.0f,
+#endif
 		      SCREEN_WIDTH, 0.0f),
 		CRGBA(0, 0, 0, 255));
 
 	CSprite2d::DrawRect(
 		CRect(0.0f, SCREEN_HEIGHT,
+#ifdef FIX_BUGS
+		      SCREEN_WIDTH, SCREEN_HEIGHT - (SCREEN_HEIGHT/2) * m_ScreenReductionPercentage/100.0f - SCREEN_SCALE_Y(8.0f)),
+#else
 		      SCREEN_WIDTH, SCREEN_HEIGHT - (SCREEN_HEIGHT/2) * m_ScreenReductionPercentage/100.0f - 8.0f),
+#endif
 		CRGBA(0, 0, 0, 255));
 }
 
diff --git a/src/core/Camera.h b/src/core/Camera.h
index eca4518a..09a8d603 100644
--- a/src/core/Camera.h
+++ b/src/core/Camera.h
@@ -415,7 +415,7 @@ uint32    unknown;	// some counter having to do with music
 
 	float CamFrontXNorm;
 	float CamFrontYNorm;
-#if 0  // TODO: FIX_BUGS once GenericLoad is done
+#ifdef FIX_BUGS
 	int32 CarZoomIndicator;
 #else
 	float CarZoomIndicator;
@@ -455,7 +455,7 @@ uint32    unknown;	// some counter having to do with music
 	float m_ScreenReductionSpeed;
 	float m_AlphaForPlayerAnim1rstPerson;
 	float Orientation;
-#if 0  // TODO: FIX_BUGS once GenericLoad is done
+#ifdef FIX_BUGS
 	int32 PedZoomIndicator;
 #else
 	float PedZoomIndicator;
diff --git a/src/core/Collision.cpp b/src/core/Collision.cpp
index c884f751..85145e86 100644
--- a/src/core/Collision.cpp
+++ b/src/core/Collision.cpp
@@ -31,8 +31,8 @@ enum Direction
 	DIR_Z_NEG,
 };
 
-eLevelName &CCollision::ms_collisionInMemory = *(eLevelName*)0x8F6250;
-CLinkList<CColModel*> &CCollision::ms_colModelCache = *(CLinkList<CColModel*>*)0x95CB58;
+eLevelName CCollision::ms_collisionInMemory;
+CLinkList<CColModel*> CCollision::ms_colModelCache;
 
 void
 CCollision::Init(void)
@@ -1355,6 +1355,7 @@ CCollision::ProcessColModels(const CMatrix &matrixA, CColModel &modelA,
 				modelB.triangles[aTriangleIndicesB[j]],
 				modelB.trianglePlanes[aTriangleIndicesB[j]],
 				spherepoints[numCollisions], coldist);
+
 		if(hasCollided)
 			numCollisions++;
 	}
diff --git a/src/core/Collision.h b/src/core/Collision.h
index 1cbd1690..bdf51eb8 100644
--- a/src/core/Collision.h
+++ b/src/core/Collision.h
@@ -3,6 +3,13 @@
 #include "templates.h"
 #include "Game.h"	// for eLevelName
 
+// If you spawn many tanks at once, you will see that collisions of two entity exceeds 32.
+#ifdef FIX_BUGS
+#define MAX_COLLISION_POINTS 64
+#else
+#define MAX_COLLISION_POINTS 32
+#endif
+
 struct CColSphere
 {
 	CVector center;
@@ -110,8 +117,8 @@ struct CColModel
 class CCollision
 {
 public:
-	static eLevelName &ms_collisionInMemory;
-	static CLinkList<CColModel*> &ms_colModelCache;
+	static eLevelName ms_collisionInMemory;
+	static CLinkList<CColModel*> ms_colModelCache;
 
 	static void Init(void);
 	static void Shutdown(void);
diff --git a/src/core/Frontend.cpp b/src/core/Frontend.cpp
index 48683abc..a01689e4 100644
--- a/src/core/Frontend.cpp
+++ b/src/core/Frontend.cpp
@@ -82,34 +82,34 @@ int curBottomBarOption = -1;
 int hoveredBottomBarOption = -1;
 #endif
 
-int32 CMenuManager::OS_Language = LANG_ENGLISH; // *(int32*)0x5F2F78;
-int8 CMenuManager::m_PrefsUseVibration; // = *(int8*)0x95CD92;
-int8 CMenuManager::m_DisplayControllerOnFoot; // = *(int8*)0x95CD8D;
-int8 CMenuManager::m_PrefsVsync = 1; // *(int8*)0x5F2E58;
-int8 CMenuManager::m_PrefsVsyncDisp = 1; // *(int8*)0x5F2E5C;
-int8 CMenuManager::m_PrefsFrameLimiter = 1; // *(int8*)0x5F2E60;
-int8 CMenuManager::m_PrefsShowSubtitles = 1; // *(int8*)0x5F2E54;
-int8 CMenuManager::m_PrefsSpeakers; // = *(int8*)0x95CD7E;
-int32 CMenuManager::m_ControlMethod; // = *(int32*)0x8F5F7C;
-int8 CMenuManager::m_PrefsDMA = 1; // *(int8*)0x5F2F74;
-int32 CMenuManager::m_PrefsLanguage; // = *(int32*)0x941238;
+int32 CMenuManager::OS_Language = LANG_ENGLISH;
+int8 CMenuManager::m_PrefsUseVibration;
+int8 CMenuManager::m_DisplayControllerOnFoot;
+int8 CMenuManager::m_PrefsVsync = 1;
+int8 CMenuManager::m_PrefsVsyncDisp = 1;
+int8 CMenuManager::m_PrefsFrameLimiter = 1;
+int8 CMenuManager::m_PrefsShowSubtitles = 1;
+int8 CMenuManager::m_PrefsSpeakers;
+int32 CMenuManager::m_ControlMethod;
+int8 CMenuManager::m_PrefsDMA = 1;
+int32 CMenuManager::m_PrefsLanguage;
 uint8 CMenuManager::m_PrefsStereoMono; // *(bool*)0x95CDB5; // unused except restore settings
 
-bool CMenuManager::m_PrefsAllowNastyGame = true; // *(bool*)0x5F2E64;
-bool CMenuManager::m_bStartUpFrontEndRequested; // = *(bool*)0x95CCF4;
-bool CMenuManager::m_bShutDownFrontEndRequested; // = *(bool*)0x95CD6A;
+bool CMenuManager::m_PrefsAllowNastyGame = true;
+bool CMenuManager::m_bStartUpFrontEndRequested;
+bool CMenuManager::m_bShutDownFrontEndRequested;
 
-int8 CMenuManager::m_PrefsUseWideScreen; // = *(int8*)0x95CD23;
-int8 CMenuManager::m_PrefsRadioStation; // = *(int8*)0x95CDA4;
-int32 CMenuManager::m_PrefsBrightness = 256; // = *(int32*)0x5F2E50;
-float CMenuManager::m_PrefsLOD; // = *(float*)0x8F42C4;
-int8 CMenuManager::m_bFrontEnd_ReloadObrTxtGxt; // = *(int8*)0x628CFC;
-int32 CMenuManager::m_PrefsMusicVolume = 102; // = *(int32*)0x5F2E4C;
-int32 CMenuManager::m_PrefsSfxVolume = 102; // = *(int32*)0x5F2E48;
+int8 CMenuManager::m_PrefsUseWideScreen;
+int8 CMenuManager::m_PrefsRadioStation;
+int32 CMenuManager::m_PrefsBrightness = 256;
+float CMenuManager::m_PrefsLOD = CRenderer::ms_lodDistScale;
+int8 CMenuManager::m_bFrontEnd_ReloadObrTxtGxt;
+int32 CMenuManager::m_PrefsMusicVolume = 102;
+int32 CMenuManager::m_PrefsSfxVolume = 102;
 
-char CMenuManager::m_PrefsSkinFile[256] = "$$\"\""; // = (char*)0x5F2E74;
+char CMenuManager::m_PrefsSkinFile[256] = "$$\"\"";
 
-int32 CMenuManager::m_KeyPressedCode = -1; // = *(int32*)0x5F2E70;
+int32 CMenuManager::m_KeyPressedCode = -1;
 
 // Originally that was PS2 option color, they forget it here and used in PrintBriefs once(but didn't use the output anyway)
 #ifdef PS2_LIKE_MENU
@@ -119,29 +119,26 @@ const CRGBA TEXT_COLOR = CRGBA(235, 170, 50, 255); // PC briefs text color
 #endif
 
 const float menuXYpadding = MENUACTION_POS_Y; // *(float*)0x5F355C;	// not original name
-float MENU_TEXT_SIZE_X = SMALLTEXT_X_SCALE; //*(float*)0x5F2E40;
-float MENU_TEXT_SIZE_Y = SMALLTEXT_Y_SCALE; //*(float*)0x5F2E44;
+float MENU_TEXT_SIZE_X = SMALLTEXT_X_SCALE;
+float MENU_TEXT_SIZE_Y = SMALLTEXT_Y_SCALE;
 
 bool holdingScrollBar; // *(bool*)0x628D59; // not original name
-int32 CMenuManager::m_SelectedMap; // *(int32*)0x8E2880;
-int32 CMenuManager::m_SelectedGameType; // *(int32*)0x942F88;
+int32 CMenuManager::m_SelectedMap;
+int32 CMenuManager::m_SelectedGameType;
 
 // Used in a hidden menu
 uint8 CMenuManager::m_PrefsPlayerRed = 255;
 uint8 CMenuManager::m_PrefsPlayerGreen = 128;
 uint8 CMenuManager::m_PrefsPlayerBlue; // why??
 
-CMenuManager FrontEndMenuManager; // = *(CMenuManager*)0x8F59D8;
+CMenuManager FrontEndMenuManager;
 
-// Move this somewhere else.
-float CRenderer::ms_lodDistScale = 1.2f; // *(float*)0x5F726C;
-
-uint32 TimeToStopPadShaking; // = *(uint32*)0x628CF8;
-char *pEditString; // = *(char**)0x628D00;
-int32 *pControlEdit; // = *(int32**)0x628D08;
-bool DisplayComboButtonErrMsg; // = *(bool*)0x628D14;
-int32 MouseButtonJustClicked; // = *(int32*)0x628D0C;
-int32 JoyButtonJustClicked; // = *(int32*)0x628D10;
+uint32 TimeToStopPadShaking;
+char *pEditString;
+int32 *pControlEdit;
+bool DisplayComboButtonErrMsg;
+int32 MouseButtonJustClicked;
+int32 JoyButtonJustClicked;
 //int32 *pControlTemp = 0;
 
 #ifndef MASTER
@@ -283,6 +280,12 @@ ScaleAndCenterX(float x)
 	} while(0)
 #endif
 
+#define PREPARE_MENU_HEADER \
+	CFont::SetColor(CRGBA(0, 0, 0, FadeIn(255))); \
+	CFont::SetRightJustifyOn(); \
+	CFont::SetScale(MENU_X(MENUHEADER_WIDTH), MENU_Y(MENUHEADER_HEIGHT)); \
+	CFont::SetFontStyle(FONT_HEADING);
+
 #define ProcessSlider(value, increaseAction, decreaseAction, hoverStartX, hoverEndX) \
 	do { \
 		lastActiveBarX = DisplaySlider(SCREEN_STRETCH_FROM_RIGHT(MENUSLIDER_X + columnWidth), MENU_Y(bitAboveNextItemY), MENU_Y(smallestSliderBar), MENU_Y(usableLineHeight), MENU_X(MENUSLIDER_UNK), value); \
@@ -447,8 +450,8 @@ CMenuManager::CheckCodesForControls(int typeOfControl)
 	if (typeOfControl == KEYBOARD) {
 		if (*pControlEdit == rsESC) {
 			escPressed = true;
-		} else if (*pControlEdit > rsF3 && *pControlEdit != rsF9 && *pControlEdit != rsLWIN &&
-			*pControlEdit != rsRWIN && *pControlEdit != rsRALT) {
+		} else if (*pControlEdit != rsF1 && *pControlEdit != rsF2 && *pControlEdit != rsF3 && *pControlEdit != rsF9 &&
+			*pControlEdit != rsLWIN && *pControlEdit != rsRWIN && *pControlEdit != rsRALT) {
 			typeToSave = KEYBOARD;
 			if (ControlsManager.GetControllerKeyAssociatedWithAction(action, KEYBOARD) != rsNULL &&
 				*pControlEdit != ControlsManager.GetControllerKeyAssociatedWithAction(action, KEYBOARD)) {
@@ -465,7 +468,10 @@ CMenuManager::CheckCodesForControls(int typeOfControl)
 			DisplayComboButtonErrMsg = true;
 	}
 
-	ControlsManager.ClearSettingsAssociatedWithAction(action, typeToSave);
+#ifdef FIX_BUGS
+	if(!escPressed && !invalidKey)
+#endif
+		ControlsManager.ClearSettingsAssociatedWithAction(action, typeToSave);
 	if (!DisplayComboButtonErrMsg && !escPressed && !invalidKey) {
 		if (typeOfControl == KEYBOARD) {
 			ControlsManager.DeleteMatchingActionInitiators(action, *pControlEdit, KEYBOARD);
@@ -670,6 +676,17 @@ CMenuManager::Draw()
 	CFont::SetCentreOff();
 	CFont::SetJustifyOn();
 	CFont::SetBackGroundOnlyTextOn();
+#ifdef GTA3_1_1_PATCH
+	CFont::SetColor(CRGBA(235, 170, 50, FadeIn(255)));
+	CFont::SetRightJustifyOn();
+	CFont::SetFontStyle(FONT_HEADING);
+	CFont::SetScale(MENU_X(0.7f), MENU_Y(0.5f));
+	CFont::SetWrapx(SCREEN_WIDTH);
+	CFont::SetRightJustifyWrap(0.0f);
+	strcpy(gString, "V1.1");
+	AsciiToUnicode(gString, gUString);
+	CFont::PrintString(SCREEN_WIDTH / 10, SCREEN_HEIGHT / 45, gUString);
+#endif
 	CFont::SetWrapx(MENU_X_RIGHT_ALIGNED(MENU_X_MARGIN));
 	CFont::SetRightJustifyWrap(SCREEN_SCALE_X(MENUACTION_WIDTH));
 
@@ -696,17 +713,9 @@ CMenuManager::Draw()
 #endif
 	if (aScreens[m_nCurrScreen].m_ScreenName[0] != '\0') {
 		
-		CFont::SetRightJustifyOn();
-		CFont::SetFontStyle(FONT_HEADING);
-#ifdef PS2_LIKE_MENU
-		CFont::SetColor(CRGBA(0, 0, 0, 255));
-		CFont::SetScale(MENU_X(MENUHEADER_WIDTH), MENU_Y(1.3f));
-		CFont::PrintString(MENU_X_RIGHT_ALIGNED(50.0f), SCREEN_SCALE_FROM_BOTTOM(75.0f), TheText.Get(aScreens[m_nCurrScreen].m_ScreenName));
-#else
-		CFont::SetColor(CRGBA(0, 0, 0, FadeIn(255)));
-		CFont::SetScale(MENU_X(MENUHEADER_WIDTH), MENU_Y(MENUHEADER_HEIGHT));
+		PREPARE_MENU_HEADER
 		CFont::PrintString(SCREEN_SCALE_FROM_RIGHT(MENUHEADER_POS_X), SCREEN_SCALE_FROM_BOTTOM(MENUHEADER_POS_Y), TheText.Get(aScreens[m_nCurrScreen].m_ScreenName));
-#endif
+
 		// Weird place to put that.
 		nextYToUse += 24.0f + 10.0f;
 	}
@@ -1735,11 +1744,8 @@ CMenuManager::DrawControllerSetupScreen()
 	CFont::SetWrapx(MENU_X_RIGHT_ALIGNED(MENU_X_MARGIN));
 	CFont::SetRightJustifyWrap(SCREEN_SCALE_X(MENUACTION_WIDTH));
 
-	// Page header
-	CFont::SetColor(CRGBA(0, 0, 0, FadeIn(255)));
-	CFont::SetRightJustifyOn();
-	CFont::SetScale(MENU_X(MENUHEADER_WIDTH), MENU_Y(MENUHEADER_HEIGHT));
-	CFont::SetFontStyle(FONT_HEADING);
+	PREPARE_MENU_HEADER
+
 	switch (m_ControlMethod) {
 		case CONTROL_STANDARD:
 			CFont::PrintString(SCREEN_SCALE_FROM_RIGHT(MENUHEADER_POS_X), SCREEN_SCALE_FROM_BOTTOM(MENUHEADER_POS_Y),
@@ -2417,10 +2423,8 @@ CMenuManager::DrawPlayerSetupScreen()
 	CFont::SetWrapx(MENU_X_RIGHT_ALIGNED(MENU_X_MARGIN));
 	CFont::SetRightJustifyWrap(SCREEN_SCALE_X(MENUACTION_WIDTH));
 
-	CFont::SetColor(CRGBA(0, 0, 0, FadeIn(255)));
-	CFont::SetScale(MENU_X(MENUHEADER_WIDTH), MENU_Y(MENUHEADER_HEIGHT));
-	CFont::SetRightJustifyOn();
-	CFont::SetFontStyle(FONT_HEADING);
+	PREPARE_MENU_HEADER
+
 	CFont::PrintString(SCREEN_SCALE_FROM_RIGHT(MENUHEADER_POS_X), SCREEN_SCALE_FROM_BOTTOM(MENUHEADER_POS_Y), TheText.Get("FET_PS"));
 
 	// lstrcpy's changed with strcpy
@@ -3314,10 +3318,7 @@ CMenuManager::PrintStats()
 
 	// ::Draw already does that.
 	/*
-	CFont::SetColor(CRGBA(0, 0, 0, FadeIn(255)));
-	CFont::SetRightJustifyOn();
-	CFont::SetFontStyle(FONT_HEADING);
-	CFont::SetScale(MENU_X(MENUHEADER_WIDTH), MENU_Y(MENUHEADER_HEIGHT));
+	PREPARE_MENU_HEADER
 	CFont::PrintString(MENU_X_RIGHT_ALIGNED(MENUHEADER_POS_X), SCREEN_SCALE_FROM_BOTTOM(MENUHEADER_POS_Y), TheText.Get(aScreens[m_nCurrScreen].m_ScreenName));
 	*/
 	CFont::SetScale(MENU_X(MENU_TEXT_SIZE_X), MENU_Y(MENU_TEXT_SIZE_Y));
@@ -5245,6 +5246,7 @@ CMenuManager::PrintController(void)
 void
 CMenuManager::PrintMap(void)
 {
+	CFont::SetJustifyOn();
 	bMenuMapActive = true;
 	CRadar::InitFrontEndMap();
 
diff --git a/src/core/Frontend.h b/src/core/Frontend.h
index 9064cf4e..8fe61a36 100644
--- a/src/core/Frontend.h
+++ b/src/core/Frontend.h
@@ -2,10 +2,16 @@
 
 #include "Sprite2d.h"
 
+#ifdef PS2_LIKE_MENU
+#define MENUHEADER_POS_X 50.0f
+#define MENUHEADER_POS_Y 75.0f
+#define MENUHEADER_HEIGHT 1.3f
+#else
 #define MENUHEADER_POS_X 35.0f
 #define MENUHEADER_POS_Y 93.0f
-#define MENUHEADER_WIDTH 0.84f
 #define MENUHEADER_HEIGHT 1.6f
+#endif
+#define MENUHEADER_WIDTH 0.84f
 
 #define MENU_X_MARGIN 40.0f
 #define MENUACTION_POS_Y 60.0f
diff --git a/src/core/Game.cpp b/src/core/Game.cpp
index daac3ec5..8699ffeb 100644
--- a/src/core/Game.cpp
+++ b/src/core/Game.cpp
@@ -307,6 +307,7 @@ bool CGame::Initialise(const char* datFile)
 	CDraw::SetFOV(120.0f);
 	CDraw::ms_fLODDistance = 500.0f;
 	LoadingScreen("Loading the Game", "Setup streaming", nil);
+#ifdef USE_TXD_CDIMAGE
 	int txdHandle = CFileMgr::OpenFile("MODELS\\TXD.IMG", "r");
 	if (txdHandle)
 		CFileMgr::CloseFile(txdHandle);
@@ -321,6 +322,9 @@ bool CGame::Initialise(const char* datFile)
 			CStreaming::Init();
 		}
 	}
+#else
+	CStreaming::Init();
+#endif
 	CStreaming::LoadInitialVehicles();
 	CStreaming::LoadInitialPeds();
 	CStreaming::RequestBigBuildings(LEVEL_NONE);
@@ -350,7 +354,7 @@ bool CGame::Initialise(const char* datFile)
 	CAntennas::Init();
 	CGlass::Init();
 	gPhoneInfo.Initialise();
-	CSceneEdit::Init();
+	CSceneEdit::Initialise();
 	LoadingScreen("Loading the Game", "Load scripts", nil);
 	CTheScripts::Init();
 	CGangs::Initialise();
diff --git a/src/core/General.h b/src/core/General.h
index f32846eb..77828854 100644
--- a/src/core/General.h
+++ b/src/core/General.h
@@ -90,6 +90,11 @@ public:
 				return -Atan2(x / y, 1.0f);
 		}
 	}
+	
+	static float GetAngleBetweenPoints(float x1, float y1, float x2, float y2)
+	{
+		return RADTODEG(GetRadianAngleBetweenPoints(x1, y1, x2, y2));
+	}
 
 	// should return direction in 0-8 range. fits perfectly to peds' path directions.
 	static int GetNodeHeadingFromVector(float x, float y)
diff --git a/src/core/IniFile.cpp b/src/core/IniFile.cpp
index 08b30876..744f4bd0 100644
--- a/src/core/IniFile.cpp
+++ b/src/core/IniFile.cpp
@@ -7,8 +7,8 @@
 #include "main.h"
 #include "Population.h"
 
-float &CIniFile::PedNumberMultiplier = *(float*)0x6182F4;
-float &CIniFile::CarNumberMultiplier = *(float*)0x6182F8;
+float CIniFile::PedNumberMultiplier = 1.0f;// = *(float*)0x6182F4;
+float CIniFile::CarNumberMultiplier = 1.0f;// = *(float*)0x6182F8;
 
 void CIniFile::LoadIniFile()
 {
diff --git a/src/core/IniFile.h b/src/core/IniFile.h
index 9a98151b..1e30c4de 100644
--- a/src/core/IniFile.h
+++ b/src/core/IniFile.h
@@ -5,6 +5,6 @@ class CIniFile
 public:
 	static void LoadIniFile();
 
-	static float& PedNumberMultiplier;
-	static float& CarNumberMultiplier;
+	static float PedNumberMultiplier;
+	static float CarNumberMultiplier;
 };
diff --git a/src/core/Pad.cpp b/src/core/Pad.cpp
index f83998b8..201dc5b6 100644
--- a/src/core/Pad.cpp
+++ b/src/core/Pad.cpp
@@ -644,6 +644,8 @@ void CPad::AddToCheatString(char c)
 {
 	for ( int32 i = ARRAY_SIZE(CheatString) - 2; i >= 0; i-- )
 		CheatString[i + 1] = CheatString[i];
+	
+	CheatString[0] = c;
 
 #define _CHEATCMP(str)  strncmp(str, CheatString, sizeof(str)-1)
 	// "4414LDRULDRU"	-	R2 R2 L1 R2 LEFT DOWN RIGHT UP LEFT DOWN RIGHT UP
diff --git a/src/core/TempColModels.cpp b/src/core/TempColModels.cpp
index f7cf035e..22ef31bd 100644
--- a/src/core/TempColModels.cpp
+++ b/src/core/TempColModels.cpp
@@ -34,7 +34,7 @@ void
 CTempColModels::Initialise(void)
 {
 #define SET_COLMODEL_SPHERES(colmodel, sphrs)\
-	colmodel.numSpheres = ARRAYSIZE(sphrs);\
+	colmodel.numSpheres = ARRAY_SIZE(sphrs);\
 	colmodel.spheres = sphrs;\
 	colmodel.level = LEVEL_NONE;\
 	colmodel.ownsCollisionVolumes = false;\
@@ -45,7 +45,7 @@ CTempColModels::Initialise(void)
 	ms_colModelBBox.boundingBox.Set(CVector(-2.0f, -2.0f, -2.0f), CVector(2.0f, 2.0f, 2.0f), SURFACE_DEFAULT, 0);
 	ms_colModelBBox.level = LEVEL_NONE;
 
-	for (i = 0; i < ARRAYSIZE(ms_colModelCutObj); i++) {
+	for (i = 0; i < ARRAY_SIZE(ms_colModelCutObj); i++) {
 		ms_colModelCutObj[i].boundingSphere.Set(2.0f, CVector(0.0f, 0.0f, 0.0f), SURFACE_DEFAULT, 0);
 		ms_colModelCutObj[i].boundingBox.Set(CVector(-2.0f, -2.0f, -2.0f), CVector(2.0f, 2.0f, 2.0f), SURFACE_DEFAULT, 0);
 		ms_colModelCutObj[i].level = LEVEL_NONE;
@@ -53,7 +53,7 @@ CTempColModels::Initialise(void)
 
 	// Ped Spheres
 
-	for (i = 0; i < ARRAYSIZE(s_aPedSpheres); i++)
+	for (i = 0; i < ARRAY_SIZE(s_aPedSpheres); i++)
 		s_aPedSpheres[i].radius = 0.35f;
 
 	s_aPedSpheres[0].center = CVector(0.0f, 0.0f, -0.25f);
@@ -61,9 +61,9 @@ CTempColModels::Initialise(void)
 	s_aPedSpheres[2].center = CVector(0.0f, 0.0f, 0.55f);
 
 #ifdef FIX_BUGS
-	for (i = 0; i < ARRAYSIZE(s_aPedSpheres); i++) {
+	for (i = 0; i < ARRAY_SIZE(s_aPedSpheres); i++) {
 #else
-	for (i = 0; i < ARRAYSIZE(s_aPedGSpheres); i++) {
+	for (i = 0; i < ARRAY_SIZE(s_aPedGSpheres); i++) {
 #endif
 		s_aPedSpheres[i].surface = SURFACE_FLESH;
 		s_aPedSpheres[i].piece = 0;
@@ -83,7 +83,7 @@ CTempColModels::Initialise(void)
 	s_aPed2Spheres[1].center = CVector(0.0f, 0.0f, -0.9f);
 	s_aPed2Spheres[2].center = CVector(0.0f, -0.35f, -0.9f);
 
-	for (i = 0; i < ARRAYSIZE(s_aPed2Spheres); i++) {
+	for (i = 0; i < ARRAY_SIZE(s_aPed2Spheres); i++) {
 		s_aPed2Spheres[i].surface = SURFACE_FLESH;
 		s_aPed2Spheres[i].piece = 0;
 	}
@@ -129,7 +129,7 @@ CTempColModels::Initialise(void)
 	s_aDoorSpheres[1].center = CVector(0.0f, -0.95f, -0.35f);
 	s_aDoorSpheres[2].center = CVector(0.0f, -0.6f, 0.25f);
 
-	for (i = 0; i < ARRAYSIZE(s_aDoorSpheres); i++) {
+	for (i = 0; i < ARRAY_SIZE(s_aDoorSpheres); i++) {
 		s_aDoorSpheres[i].surface = SURFACE_BILLBOARD;
 		s_aDoorSpheres[i].piece = 0;
 	}
@@ -141,7 +141,7 @@ CTempColModels::Initialise(void)
 
 	// Bumper Spheres
 
-	for (i = 0; i < ARRAYSIZE(s_aBumperSpheres); i++)
+	for (i = 0; i < ARRAY_SIZE(s_aBumperSpheres); i++)
 		s_aBumperSpheres[i].radius = 0.15f;
 
 	s_aBumperSpheres[0].center = CVector(0.85f, -0.05f, 0.0f);
@@ -149,7 +149,7 @@ CTempColModels::Initialise(void)
 	s_aBumperSpheres[2].center = CVector(-0.4f, 0.05f, 0.0f);
 	s_aBumperSpheres[3].center = CVector(-0.85f, -0.05f, 0.0f);
 
-	for (i = 0; i < ARRAYSIZE(s_aBumperSpheres); i++) {
+	for (i = 0; i < ARRAY_SIZE(s_aBumperSpheres); i++) {
 		s_aBumperSpheres[i].surface = SURFACE_BILLBOARD;
 		s_aBumperSpheres[i].piece = 0;
 	}
@@ -161,7 +161,7 @@ CTempColModels::Initialise(void)
 
 	// Panel Spheres
 
-	for (i = 0; i < ARRAYSIZE(s_aPanelSpheres); i++)
+	for (i = 0; i < ARRAY_SIZE(s_aPanelSpheres); i++)
 		s_aPanelSpheres[i].radius = 0.15f;
 
 	s_aPanelSpheres[0].center = CVector(0.15f, 0.45f, 0.0f);
@@ -169,7 +169,7 @@ CTempColModels::Initialise(void)
 	s_aPanelSpheres[2].center = CVector(-0.15f, -0.45f, 0.0f);
 	s_aPanelSpheres[3].center = CVector(-0.15f, 0.45f, 0.0f);
 
-	for (i = 0; i < ARRAYSIZE(s_aPanelSpheres); i++) {
+	for (i = 0; i < ARRAY_SIZE(s_aPanelSpheres); i++) {
 		s_aPanelSpheres[i].surface = SURFACE_BILLBOARD;
 		s_aPanelSpheres[i].piece = 0;
 	}
@@ -181,7 +181,7 @@ CTempColModels::Initialise(void)
 
 	// Bonnet Spheres
 
-	for (i = 0; i < ARRAYSIZE(s_aBonnetSpheres); i++)
+	for (i = 0; i < ARRAY_SIZE(s_aBonnetSpheres); i++)
 		s_aBonnetSpheres[i].radius = 0.2f;
 
 	s_aBonnetSpheres[0].center = CVector(-0.4f, 0.1f, 0.0f);
@@ -189,7 +189,7 @@ CTempColModels::Initialise(void)
 	s_aBonnetSpheres[2].center = CVector(0.4f, 0.1f, 0.0f);
 	s_aBonnetSpheres[3].center = CVector(0.4f, 0.9f, 0.0f);
 
-	for (i = 0; i < ARRAYSIZE(s_aBonnetSpheres); i++) {
+	for (i = 0; i < ARRAY_SIZE(s_aBonnetSpheres); i++) {
 		s_aBonnetSpheres[i].surface = SURFACE_BILLBOARD;
 		s_aBonnetSpheres[i].piece = 0;
 	}
@@ -201,7 +201,7 @@ CTempColModels::Initialise(void)
 
 	// Boot Spheres
 
-	for (i = 0; i < ARRAYSIZE(s_aBootSpheres); i++)
+	for (i = 0; i < ARRAY_SIZE(s_aBootSpheres); i++)
 		s_aBootSpheres[i].radius = 0.2f;
 
 	s_aBootSpheres[0].center = CVector(-0.4f, -0.1f, 0.0f);
@@ -209,7 +209,7 @@ CTempColModels::Initialise(void)
 	s_aBootSpheres[2].center = CVector(0.4f, -0.1f, 0.0f);
 	s_aBootSpheres[3].center = CVector(0.4f, -0.6f, 0.0f);
 
-	for (i = 0; i < ARRAYSIZE(s_aBootSpheres); i++) {
+	for (i = 0; i < ARRAY_SIZE(s_aBootSpheres); i++) {
 		s_aBootSpheres[i].surface = SURFACE_BILLBOARD;
 		s_aBootSpheres[i].piece = 0;
 	}
@@ -228,9 +228,9 @@ CTempColModels::Initialise(void)
 	s_aWheelSpheres[1].center = CVector(0.3f, 0.0f, 0.0f);
 
 #ifdef FIX_BUGS
-	for (i = 0; i < ARRAYSIZE(s_aWheelSpheres); i++) {
+	for (i = 0; i < ARRAY_SIZE(s_aWheelSpheres); i++) {
 #else
-	for (i = 0; i < ARRAYSIZE(s_aBootSpheres); i++) {
+	for (i = 0; i < ARRAY_SIZE(s_aBootSpheres); i++) {
 #endif
 		s_aWheelSpheres[i].surface = SURFACE_RUBBER29;
 		s_aWheelSpheres[i].piece = 0;
@@ -250,9 +250,9 @@ CTempColModels::Initialise(void)
 	s_aBodyPartSpheres1[1].center = CVector(0.8f, 0.0f, 0.0f);
 
 #ifdef FIX_BUGS
-	for (i = 0; i < ARRAYSIZE(s_aBodyPartSpheres1); i++) {
+	for (i = 0; i < ARRAY_SIZE(s_aBodyPartSpheres1); i++) {
 #else
-	for (i = 0; i < ARRAYSIZE(s_aBootSpheres); i++) {
+	for (i = 0; i < ARRAY_SIZE(s_aBootSpheres); i++) {
 #endif
 		s_aBodyPartSpheres1[i].surface = SURFACE_FLESH;
 		s_aBodyPartSpheres1[i].piece = 0;
@@ -272,9 +272,9 @@ CTempColModels::Initialise(void)
 	s_aBodyPartSpheres2[1].center = CVector(0.5f, 0.0f, 0.0f);
 
 #ifdef FIX_BUGS
-	for (i = 0; i < ARRAYSIZE(s_aBodyPartSpheres2); i++) {
+	for (i = 0; i < ARRAY_SIZE(s_aBodyPartSpheres2); i++) {
 #else
-	for (i = 0; i < ARRAYSIZE(s_aBootSpheres); i++) {
+	for (i = 0; i < ARRAY_SIZE(s_aBootSpheres); i++) {
 #endif
 		s_aBodyPartSpheres2[i].surface = SURFACE_FLESH;
 		s_aBodyPartSpheres2[i].piece = 0;
diff --git a/src/core/World.cpp b/src/core/World.cpp
index 7f18abbf..324be962 100644
--- a/src/core/World.cpp
+++ b/src/core/World.cpp
@@ -29,7 +29,7 @@
 
 #define OBJECT_REPOSITION_OFFSET_Z 0.2f
 
-CColPoint *gaTempSphereColPoints = (CColPoint*)0x6E64C0;	// [32]
+CColPoint gaTempSphereColPoints[MAX_COLLISION_POINTS];
 
 CPtrList *CWorld::ms_bigBuildingsList = (CPtrList*)0x6FAB60;
 CPtrList &CWorld::ms_listMovingEntityPtrs = *(CPtrList*)0x8F433C;
@@ -37,7 +37,7 @@ CSector (*CWorld::ms_aSectors)[NUMSECTORS_X] = (CSector (*)[NUMSECTORS_Y])0x6656
 uint16 &CWorld::ms_nCurrentScanCode = *(uint16*)0x95CC64;
 
 uint8 &CWorld::PlayerInFocus = *(uint8 *)0x95CD61;
-CPlayerInfo (&CWorld::Players)[NUMPLAYERS] = *(CPlayerInfo (*)[NUMPLAYERS])*(uintptr*)0x9412F0;
+CPlayerInfo CWorld::Players[NUMPLAYERS];
 bool &CWorld::bNoMoreCollisionTorque = *(bool*)0x95CDCC;
 CEntity *&CWorld::pIgnoreEntity	= *(CEntity**)0x8F6494;
 bool &CWorld::bIncludeDeadPeds = *(bool*)0x95CD8F;
@@ -66,6 +66,7 @@ bool &CWorld::bIncludeCarTyres = *(bool*)0x95CDAA;
 //WRAPPER void CWorld::CallOffChaseForArea(float, float, float, float) { EAXJMP(0x4B5530); }
 WRAPPER void CWorld::TriggerExplosion(const CVector& position, float fRadius, float fPower, CEntity *pCreator, bool bProcessVehicleBombTimer) { EAXJMP(0x4B1140); }
 //WRAPPER void CWorld::SetPedsOnFire(float, float, float, float, CEntity*) { EAXJMP(0x4B3D30); }
+WRAPPER void CWorld::UseDetonator(CEntity *) { EAXJMP(0x4B4650); }
 
 void
 CWorld::Initialise()
@@ -2035,6 +2036,7 @@ CWorld::Process(void)
 		}
 	}
 }
+
 /*
 void 
 CWorld::TriggerExplosion(const CVector& position, float fRadius, float fPower, CEntity* pCreator, bool bProcessVehicleBombTimer)
@@ -2048,15 +2050,14 @@ CWorld::TriggerExplosion(const CVector& position, float fRadius, float fPower, C
 	for (int32 y = nStartY; y <= nEndY; y++) {
 		for (int32 x = nStartX; x <= nEndX; x++) {
 			CSector* pSector = CWorld::GetSector(x, y);
-			CWorld::TriggerExplosionSectorList(pSector->m_lists[ENTITYLIST_VEHICLES], position, fRadius, fPower, pCreator, bDrecementBombTimer);
-			CWorld::TriggerExplosionSectorList(pSector->m_lists[ENTITYLIST_PEDS], position, fRadius, fPower, pCreator, bDrecementBombTimer);
-			CWorld::TriggerExplosionSectorList(pSector->m_lists[ENTITYLIST_OBJECTS], position, fRadius, fPower, pCreator, bDrecementBombTimer);
+			CWorld::TriggerExplosionSectorList(pSector->m_lists[ENTITYLIST_VEHICLES], position, fRadius, fPower, pCreator, bProcessVehicleBombTimer);
+			CWorld::TriggerExplosionSectorList(pSector->m_lists[ENTITYLIST_PEDS], position, fRadius, fPower, pCreator, bProcessVehicleBombTimer);
+			CWorld::TriggerExplosionSectorList(pSector->m_lists[ENTITYLIST_OBJECTS], position, fRadius, fPower, pCreator, bProcessVehicleBombTimer);
 		}
 	}
 
 }
 */
-
 STARTPATCHES
 	InjectHook(0x4AE930, CWorld::Add, PATCH_JUMP);
 	InjectHook(0x4AE9D0, CWorld::Remove, PATCH_JUMP);
diff --git a/src/core/World.h b/src/core/World.h
index bcb9ca27..fcf7b7cb 100644
--- a/src/core/World.h
+++ b/src/core/World.h
@@ -61,7 +61,7 @@ class CWorld
 
 public:
 	static uint8 &PlayerInFocus;
-	static CPlayerInfo (&Players)[NUMPLAYERS];
+	static CPlayerInfo Players[NUMPLAYERS];
 	static CEntity *&pIgnoreEntity;
 	static bool &bIncludeDeadPeds;
 	static bool &bNoMoreCollisionTorque;
@@ -151,9 +151,10 @@ public:
 	static void Process();
 	static void TriggerExplosion(const CVector& position, float fRadius, float fPower, CEntity* pCreator, bool bProcessVehicleBombTimer);
 	static void TriggerExplosionSectorList(CPtrList& list, const CVector& position, float fRadius, float fPower, CEntity* pCreator, bool bProcessVehicleBombTimer);
+	static void UseDetonator(CEntity *);
 };
 
-extern CColPoint *gaTempSphereColPoints;
+extern CColPoint gaTempSphereColPoints[MAX_COLLISION_POINTS];
 
 class CPlayerPed;
 class CVehicle;
diff --git a/src/core/common.h b/src/core/common.h
index 7688b182..454b848a 100644
--- a/src/core/common.h
+++ b/src/core/common.h
@@ -23,6 +23,15 @@
 #include <rwcore.h>
 #include <rpworld.h>
 
+// gotta put this somewhere
+#ifdef LIBRW
+#define STREAMPOS(str) ((str)->tell())
+#define STREAMFILE(str) (((rw::StreamFile*)(str))->file)
+#else
+#define STREAMPOS(str) ((str)->Type.memory.position)
+#define STREAMFILE(str) ((str)->Type.file.fpFile)
+#endif
+
 #define rwVENDORID_ROCKSTAR 0x0253F2
 
 // Get rid of bullshit windows definitions, we're not running on an 8086
@@ -39,9 +48,6 @@
 #ifndef min
 #define min(a,b) ((a) < (b) ? (a) : (b))
 #endif
-#ifndef ARRAYSIZE
-#define ARRAYSIZE(a) (sizeof(a) / sizeof(*(a)))
-#endif
 
 typedef uint8_t uint8;
 typedef int8_t int8;
@@ -55,7 +61,9 @@ typedef int64_t int64;
 // hardcode ucs-2
 typedef uint16_t wchar;
 
+#ifndef nil
 #define nil nullptr
+#endif
 
 #include "config.h"
 
diff --git a/src/core/config.h b/src/core/config.h
index f7fde579..f9edb74a 100644
--- a/src/core/config.h
+++ b/src/core/config.h
@@ -47,7 +47,8 @@ enum Config {
 	NUM_PATHCONNECTIONS = 10260,
 
 	// Link list lengths
-	// TODO: alpha list
+	NUMALPHALIST = 20,
+	NUMALPHAENTITYLIST = 150,
 	NUMCOLCACHELINKS = 200,
 	NUMREFERENCES = 800,
 
@@ -189,6 +190,8 @@ enum Config {
 #define FIX_BUGS		// fixes bugs that we've came across during reversing, TODO: use this more
 #define TOGGLEABLE_BETA_FEATURES // toggleable from debug menu. not too many things
 #define MORE_LANGUAGES		// Add more translations to the game
+#define DEFAULT_NATIVE_RESOLUTION	// Set default video mode to your native resolution (fixes Windows 10 launch) 
+//#define USE_TXD_CDIMAGE		// generate and load textures from txd.img
 
 // Pad
 #define XINPUT
diff --git a/src/core/main.cpp b/src/core/main.cpp
index f09c2e0a..08463df9 100644
--- a/src/core/main.cpp
+++ b/src/core/main.cpp
@@ -58,6 +58,7 @@
 #include "Console.h"
 #include "timebars.h"
 #include "GenericGameStorage.h"
+#include "SceneEdit.h"
 
 GlobalScene &Scene = *(GlobalScene*)0x726768;
 
@@ -239,8 +240,13 @@ DoFade(void)
 			float y = SCREEN_HEIGHT/2 * TheCamera.m_ScreenReductionPercentage/100.0f;
 			rect.left = 0.0f;
 			rect.right = SCREEN_WIDTH;
+#ifdef FIX_BUGS
+			rect.top = y - SCREEN_SCALE_Y(8.0f);
+			rect.bottom = SCREEN_HEIGHT - y - SCREEN_SCALE_Y(8.0f);
+#else
 			rect.top = y - 8.0f;
 			rect.bottom = SCREEN_HEIGHT - y - 8.0f;
+#endif // FIX_BUGS
 		}else{
 			rect.left = 0.0f;
 			rect.right = SCREEN_WIDTH;
@@ -690,14 +696,14 @@ DisplayGameDebugText()
 	CFont::SetPropOn();
 	CFont::SetBackgroundOff();
 	CFont::SetFontStyle(FONT_BANK);
-	CFont::SetScale(SCREEN_STRETCH_X(0.5f), SCREEN_STRETCH_Y(0.5f));
+	CFont::SetScale(SCREEN_SCALE_X(0.5f), SCREEN_SCALE_Y(0.5f));
 	CFont::SetCentreOff();
 	CFont::SetRightJustifyOff();
 	CFont::SetWrapx(SCREEN_WIDTH);
 	CFont::SetJustifyOff();
 	CFont::SetBackGroundOnlyTextOff();
 	CFont::SetColor(CRGBA(255, 108, 0, 255));
-	CFont::PrintString(10.0f, 10.0f, ver);
+	CFont::PrintString(SCREEN_SCALE_X(10.0f), SCREEN_SCALE_Y(10.0f), ver);
 
 	FrameSamples++;
 	FramesPerSecondCounter += 1000.0f / (CTimer::GetTimeStepNonClippedInSeconds() * 1000.0f);	
@@ -748,6 +754,7 @@ DisplayGameDebugText()
 		
 		AsciiToUnicode(str, ustr);
 		
+		// Let's not scale those numbers, they look better that way :eyes:
 		CFont::SetPropOff();
 		CFont::SetBackgroundOff();
 		CFont::SetScale(0.7f, 1.5f);
@@ -863,11 +870,9 @@ Render2dStuff(void)
 
 	MusicManager.DisplayRadioStationName();
 	TheConsole.Display();
-/*
 	if(CSceneEdit::m_bEditOn)
 		CSceneEdit::Draw();
 	else
-*/
 		CHud::Draw();
 	CUserDisplay::OnscnTimer.ProcessForDisplay();
 	CMessages::Display();
@@ -1560,8 +1565,9 @@ void SystemInit()
 	//
 #endif
 	
-	
+#ifdef GTA_PS2_STUFF
 	CPad::Initialise();
+#endif
 	CPad::GetPad(0)->Mode = 0;
 	
 	CGame::frenchGame = false;
diff --git a/src/core/main.h b/src/core/main.h
index 5e9401b9..5ee758a4 100644
--- a/src/core/main.h
+++ b/src/core/main.h
@@ -16,11 +16,8 @@ extern char *gString;
 extern char *gString2;
 extern wchar *gUString;
 extern wchar *gUString2;
-extern bool &b_FoundRecentSavedGameWantToLoad;
 extern bool gbPrintShite;
 extern bool &gbModelViewer;
-extern bool &StillToFadeOut;
-extern bool &JustLoadedDontFadeInYet;
 
 class CSprite2d;
 
diff --git a/src/core/re3.cpp b/src/core/re3.cpp
index 321ff172..5d76d642 100644
--- a/src/core/re3.cpp
+++ b/src/core/re3.cpp
@@ -22,6 +22,8 @@
 #include "Console.h"
 #include "Debug.h"
 #include "Hud.h"
+#include "SceneEdit.h"
+#include "Pad.h"
 
 #include <list>
 
@@ -332,6 +334,7 @@ DebugMenuPopulate(void)
 		DebugMenuAddCmd("Spawn", "Spawn Predator", [](){ SpawnCar(MI_PREDATOR); });
 
 		DebugMenuAddVarBool8("Debug", "Draw hud", (int8*)&CHud::m_Wants_To_Draw_Hud, nil);
+		DebugMenuAddVarBool8("Debug", "Edit on", (int8*)&CSceneEdit::m_bEditOn, nil);
 		DebugMenuAddVar("Debug", "Engine Status", &engineStatus, nil, 1, 0, 226, nil);
 		DebugMenuAddCmd("Debug", "Set Engine Status", SetEngineStatus);
 		DebugMenuAddCmd("Debug", "Fix Car", FixCar);
diff --git a/src/entities/Physical.cpp b/src/entities/Physical.cpp
index 9fc77a8c..bbdf68f5 100644
--- a/src/entities/Physical.cpp
+++ b/src/entities/Physical.cpp
@@ -612,7 +612,7 @@ CPhysical::ApplyCollision(CPhysical *B, CColPoint &colpoint, float &impulseA, fl
 						if(model == MI_FIRE_HYDRANT && !Bobj->bHasBeenDamaged){
 							CParticleObject::AddObject(POBJECT_FIRE_HYDRANT, B->GetPosition() - CVector(0.0f, 0.0f, 0.5f), true);
 							Bobj->bHasBeenDamaged = true;
-						}else if(B->IsObject() && model != MI_EXPLODINGBARREL && model != MI_PETROLPUMP)
+						}else if(B->IsObject() && !IsExplosiveThingModel(model))
 							Bobj->bHasBeenDamaged = true;
 					}else{
 						if(IsGlass(B->GetModelIndex()))
@@ -1037,7 +1037,7 @@ CPhysical::ProcessShiftSectorList(CPtrList *lists)
 
 	int numCollisions;
 	int mostColliding;
-	CColPoint colpoints[32];
+	CColPoint colpoints[MAX_COLLISION_POINTS];
 	CVector shift = { 0.0f, 0.0f, 0.0f };
 	bool doShift = false;
 	CEntity *boat = nil;
@@ -1187,7 +1187,7 @@ CPhysical::ProcessShiftSectorList(CPtrList *lists)
 bool
 CPhysical::ProcessCollisionSectorList_SimpleCar(CPtrList *lists)
 {
-	static CColPoint aColPoints[32];
+	static CColPoint aColPoints[MAX_COLLISION_POINTS];
 	float radius;
 	CVector center;
 	int listtype;
@@ -1349,7 +1349,7 @@ collision:
 bool
 CPhysical::ProcessCollisionSectorList(CPtrList *lists)
 {
-	static CColPoint aColPoints[32];
+	static CColPoint aColPoints[MAX_COLLISION_POINTS];
 	float radius;
 	CVector center;
 	CPtrList *list;
diff --git a/src/fakerw/fake.cpp b/src/fakerw/fake.cpp
new file mode 100644
index 00000000..557318be
--- /dev/null
+++ b/src/fakerw/fake.cpp
@@ -0,0 +1,814 @@
+#define _CRT_SECURE_NO_WARNINGS
+#define WITH_D3D
+#include <rwcore.h>
+#include <rpworld.h>
+#include <rpmatfx.h>
+#include <rphanim.h>
+#include <assert.h>
+#include <string.h>
+
+// TODO: split image<->raster functions in two
+//       implement raster context
+//	BMP reader
+//	geometry locking
+
+using namespace rw;
+
+RwUInt8 RwObjectGetType(const RwObject *obj) { return obj->type; }
+
+
+void *RwMalloc(size_t size) { return malloc(size); }
+void *RwCalloc(size_t numObj, size_t sizeObj) { return calloc(numObj, sizeObj); }
+void  RwFree(void *mem) { free(mem); }
+
+
+//RwReal RwV3dNormalize(RwV3d * out, const RwV3d * in);
+RwReal RwV3dLength(const RwV3d * in) { return length(*in); }
+//RwReal RwV2dLength(const RwV2d * in);
+//RwReal RwV2dNormalize(RwV2d * out, const RwV2d * in);
+//void RwV2dAssign(RwV2d * out, const RwV2d * ina);
+//void RwV2dAdd(RwV2d * out, const RwV2d * ina, const RwV2d * inb);
+//void RwV2dLineNormal(RwV2d * out, const RwV2d * ina, const RwV2d * inb);
+//void RwV2dSub(RwV2d * out, const RwV2d * ina, const RwV2d * inb);
+//void RwV2dPerp(RwV2d * out, const RwV2d * in);
+//void RwV2dScale(RwV2d * out, const RwV2d * in, RwReal scalar);
+//RwReal RwV2dDotProduct(const RwV2d * ina, const RwV2d * inb);
+//void RwV3dAssign(RwV3d * out, const RwV3d * ina);
+void RwV3dAdd(RwV3d * out, const RwV3d * ina, const RwV3d * inb) { *out = add(*ina, *inb); }
+void RwV3dSub(RwV3d * out, const RwV3d * ina, const RwV3d * inb) { *out = sub(*ina, *inb); }
+//void RwV3dScale(RwV3d * out, const RwV3d * in, RwReal scalar);
+//void RwV3dIncrementScaled(RwV3d * out,  const RwV3d * in, RwReal scalar);
+//void RwV3dNegate(RwV3d * out, const RwV3d * in);
+RwReal RwV3dDotProduct(const RwV3d * ina, const RwV3d * inb) { return dot(*ina, *inb); }
+//void RwV3dCrossProduct(RwV3d * out, const RwV3d * ina, const RwV3d * inb);
+RwV3d *RwV3dTransformPoints(RwV3d * pointsOut, const RwV3d * pointsIn, RwInt32 numPoints, const RwMatrix * matrix)
+	{ V3d::transformPoints(pointsOut, pointsIn, numPoints, matrix); return pointsOut; }
+//RwV3d *RwV3dTransformVectors(RwV3d * vectorsOut, const RwV3d * vectorsIn, RwInt32 numPoints, const RwMatrix * matrix);
+
+
+
+RwBool RwMatrixDestroy(RwMatrix *mpMat) { mpMat->destroy(); return true; }
+RwMatrix *RwMatrixCreate(void) { return Matrix::create(); }
+void RwMatrixCopy(RwMatrix * dstMatrix, const RwMatrix * srcMatrix) { *dstMatrix = *srcMatrix; }
+void RwMatrixSetIdentity(RwMatrix * matrix) { matrix->setIdentity(); }
+RwMatrix *RwMatrixMultiply(RwMatrix * matrixOut, const RwMatrix * MatrixIn1, const RwMatrix * matrixIn2);
+RwMatrix *RwMatrixTransform(RwMatrix * matrix, const RwMatrix * transform, RwOpCombineType combineOp)
+	{ matrix->transform(transform, (rw::CombineOp)combineOp); return matrix; }
+//RwMatrix *RwMatrixOrthoNormalize(RwMatrix * matrixOut, const RwMatrix * matrixIn);
+//RwMatrix *RwMatrixInvert(RwMatrix * matrixOut, const RwMatrix * matrixIn);
+RwMatrix *RwMatrixScale(RwMatrix * matrix, const RwV3d * scale, RwOpCombineType combineOp)
+	{ matrix->scale(scale, (rw::CombineOp)combineOp); return matrix; }
+RwMatrix *RwMatrixTranslate(RwMatrix * matrix, const RwV3d * translation, RwOpCombineType combineOp)
+	{ matrix->translate(translation, (rw::CombineOp)combineOp); return matrix; }
+RwMatrix *RwMatrixRotate(RwMatrix * matrix, const RwV3d * axis, RwReal angle, RwOpCombineType combineOp)
+	{ matrix->rotate(axis, angle, (rw::CombineOp)combineOp); return matrix; }
+//RwMatrix *RwMatrixRotateOneMinusCosineSine(RwMatrix * matrix, const RwV3d * unitAxis, RwReal oneMinusCosine, RwReal sine, RwOpCombineType combineOp);
+//const RwMatrix *RwMatrixQueryRotate(const RwMatrix * matrix, RwV3d * unitAxis, RwReal * angle, RwV3d * center);
+RwV3d *RwMatrixGetRight(RwMatrix * matrix) { return &matrix->right; }
+RwV3d *RwMatrixGetUp(RwMatrix * matrix) { return &matrix->up; }
+RwV3d *RwMatrixGetAt(RwMatrix * matrix) { return &matrix->at; }
+RwV3d *RwMatrixGetPos(RwMatrix * matrix) { return &matrix->pos; }
+RwMatrix *RwMatrixUpdate(RwMatrix * matrix) { matrix->update(); return matrix; }
+//RwMatrix *RwMatrixOptimize(RwMatrix * matrix, const RwMatrixTolerance *tolerance);
+
+
+
+
+RwFrame *RwFrameForAllObjects(RwFrame * frame, RwObjectCallBack callBack, void *data) {
+	FORLIST(lnk, frame->objectList)
+		if(callBack(&ObjectWithFrame::fromFrame(lnk)->object, data) == nil)
+			break;
+	return frame;
+}
+RwFrame *RwFrameTranslate(RwFrame * frame, const RwV3d * v, RwOpCombineType combine) { frame->translate(v, (CombineOp)combine); return frame; }
+RwFrame *RwFrameRotate(RwFrame * frame, const RwV3d * axis, RwReal angle, RwOpCombineType combine) { frame->rotate(axis, angle, (CombineOp)combine); return frame; }
+RwFrame *RwFrameScale(RwFrame * frame, const RwV3d * v, RwOpCombineType combine) { frame->scale(v, (CombineOp)combine); return frame; }
+RwFrame *RwFrameTransform(RwFrame * frame, const RwMatrix * m, RwOpCombineType combine) { frame->transform(m, (CombineOp)combine); return frame; }
+//RwFrame *RwFrameOrthoNormalize(RwFrame * frame);
+RwFrame *RwFrameSetIdentity(RwFrame * frame) { frame->matrix.setIdentity(); frame->updateObjects(); return frame; }
+//RwFrame *RwFrameCloneHierarchy(RwFrame * root);
+//RwBool RwFrameDestroyHierarchy(RwFrame * frame);
+RwFrame *RwFrameForAllChildren(RwFrame * frame, RwFrameCallBack callBack, void *data)
+	{ return frame->forAllChildren(callBack, data); }
+RwFrame *RwFrameRemoveChild(RwFrame * child) { child->removeChild(); return child; }
+RwFrame *RwFrameAddChild(RwFrame * parent, RwFrame * child) { parent->addChild(child); return parent; }
+RwFrame *RwFrameGetParent(const RwFrame * frame) { return frame->getParent(); }
+//RwFrame *RwFrameGetRoot(const RwFrame * frame);
+RwMatrix *RwFrameGetLTM(RwFrame * frame) { return frame->getLTM(); }
+RwMatrix *RwFrameGetMatrix(RwFrame * frame) { return &frame->matrix; }
+RwFrame *RwFrameUpdateObjects(RwFrame * frame) { frame->updateObjects(); return frame; }
+RwFrame *RwFrameCreate(void) { return rw::Frame::create(); }
+//RwBool RwFrameInit(RwFrame *frame);
+//RwBool RwFrameDeInit(RwFrame *frame);
+RwBool RwFrameDestroy(RwFrame * frame) { frame->destroy(); return true; }
+//void _rwFrameInit(RwFrame *frame);
+//void _rwFrameDeInit(RwFrame *frame);
+//RwBool RwFrameDirty(const RwFrame * frame);
+//RwInt32 RwFrameCount(RwFrame * frame);
+//RwBool RwFrameSetStaticPluginsSize(RwInt32 size);
+RwInt32 RwFrameRegisterPlugin(RwInt32 size, RwUInt32 pluginID, RwPluginObjectConstructor constructCB, RwPluginObjectDestructor destructCB, RwPluginObjectCopy copyCB)
+	{ return Frame::registerPlugin(size, pluginID, constructCB, destructCB, (CopyConstructor)copyCB); }
+//RwInt32 RwFrameGetPluginOffset(RwUInt32 pluginID);
+//RwBool RwFrameValidatePlugins(const RwFrame * frame);
+//RwFrame *_rwFrameCloneAndLinkClones(RwFrame * root);
+//RwFrame *_rwFramePurgeClone(RwFrame *root);
+
+RwInt32 RwFrameRegisterPluginStream(RwUInt32 pluginID, RwPluginDataChunkReadCallBack readCB, RwPluginDataChunkWriteCallBack writeCB, RwPluginDataChunkGetSizeCallBack getSizeCB)
+	{ return Frame::registerPluginStream(pluginID, readCB, (StreamWrite)writeCB, (StreamGetSize)getSizeCB); }
+
+
+rwFrameList *rwFrameListDeinitialize(rwFrameList *frameList) {
+	rwFree(frameList->frames);
+	frameList->frames = nil;
+	return frameList;
+}
+rwFrameList *rwFrameListStreamRead(RwStream *stream, rwFrameList *fl) { return fl->streamRead(stream); }
+
+
+
+
+RwCamera    *RwCameraBeginUpdate(RwCamera * camera) { camera->beginUpdate(); return camera; }
+RwCamera    *RwCameraEndUpdate(RwCamera * camera) { camera->endUpdate(); return camera; }
+RwCamera    *RwCameraClear(RwCamera * camera, RwRGBA * colour, RwInt32 clearMode) { camera->clear(colour, clearMode); return camera; }
+// WARNING: ignored arguments
+RwCamera    *RwCameraShowRaster(RwCamera * camera, void *pDev, RwUInt32 flags) { camera->showRaster(); return camera; }
+RwBool       RwCameraDestroy(RwCamera * camera) { camera->destroy(); return true; }
+RwCamera    *RwCameraCreate(void) { return rw::Camera::create(); }
+RwCamera    *RwCameraClone(RwCamera * camera) { return camera->clone(); }
+RwCamera    *RwCameraSetViewOffset(RwCamera *camera, const RwV2d *offset) { camera->setViewOffset(offset); return camera; }
+RwCamera    *RwCameraSetViewWindow(RwCamera *camera, const RwV2d *viewWindow) { camera->setViewWindow(viewWindow); return camera; }
+RwCamera    *RwCameraSetProjection(RwCamera *camera, RwCameraProjection projection);
+RwCamera    *RwCameraSetNearClipPlane(RwCamera *camera, RwReal nearClip) { camera->setNearPlane(nearClip); return camera; }
+RwCamera    *RwCameraSetFarClipPlane(RwCamera *camera, RwReal farClip) { camera->setFarPlane(farClip); return camera; }
+RwInt32      RwCameraRegisterPlugin(RwInt32 size, RwUInt32 pluginID, RwPluginObjectConstructor constructCB, RwPluginObjectDestructor destructCB, RwPluginObjectCopy copyCB);
+RwInt32      RwCameraGetPluginOffset(RwUInt32 pluginID);
+RwBool       RwCameraValidatePlugins(const RwCamera * camera);
+RwFrustumTestResult RwCameraFrustumTestSphere(const RwCamera * camera, const RwSphere * sphere) { return (RwFrustumTestResult)camera->frustumTestSphere(sphere); }
+const RwV2d *RwCameraGetViewOffset(const RwCamera *camera) { return &camera->viewOffset; }
+RwCamera    *RwCameraSetRaster(RwCamera *camera, RwRaster *raster) { camera->frameBuffer = raster; return camera; }
+RwRaster    *RwCameraGetRaster(const RwCamera *camera) { return camera->frameBuffer; }
+RwCamera    *RwCameraSetZRaster(RwCamera *camera, RwRaster *zRaster) { camera->zBuffer = zRaster; return camera; }
+RwRaster    *RwCameraGetZRaster(const RwCamera *camera) { return camera->zBuffer; }
+RwReal       RwCameraGetNearClipPlane(const RwCamera *camera) { return camera->nearPlane; }
+RwReal       RwCameraGetFarClipPlane(const RwCamera *camera) { return camera->farPlane; }
+RwCamera    *RwCameraSetFogDistance(RwCamera *camera, RwReal fogDistance) { camera->fogPlane = fogDistance; return camera; }
+RwReal       RwCameraGetFogDistance(const RwCamera *camera) { return camera->fogPlane; }
+RwCamera    *RwCameraGetCurrentCamera(void);
+RwCameraProjection RwCameraGetProjection(const RwCamera *camera);
+const RwV2d *RwCameraGetViewWindow(const RwCamera *camera) { return &camera->viewWindow; }
+RwMatrix    *RwCameraGetViewMatrix(RwCamera *camera) { return &camera->viewMatrix; }
+RwCamera    *RwCameraSetFrame(RwCamera *camera, RwFrame *frame) { camera->setFrame(frame); return camera; }
+RwFrame     *RwCameraGetFrame(const RwCamera *camera) { return camera->getFrame(); }
+
+
+
+
+
+RwImage     *RwImageCreate(RwInt32 width, RwInt32 height, RwInt32 depth) { return Image::create(width, height, depth); }
+RwBool       RwImageDestroy(RwImage * image) { image->destroy(); return true; }
+RwImage     *RwImageAllocatePixels(RwImage * image);
+RwImage     *RwImageFreePixels(RwImage * image);
+RwImage     *RwImageCopy(RwImage * destImage, const RwImage * sourceImage);
+RwImage     *RwImageResize(RwImage * image, RwInt32 width, RwInt32 height);
+RwImage     *RwImageApplyMask(RwImage * image, const RwImage * mask);
+RwImage     *RwImageMakeMask(RwImage * image);
+RwImage     *RwImageReadMaskedImage(const RwChar * imageName, const RwChar * maskname);
+RwImage     *RwImageRead(const RwChar * imageName);
+RwImage     *RwImageWrite(RwImage * image, const RwChar * imageName);
+RwChar      *RwImageGetPath(void);
+const RwChar *RwImageSetPath(const RwChar * path) { Image::setSearchPath(path); return path; }
+RwImage     *RwImageSetStride(RwImage * image, RwInt32 stride) { image->stride = stride; return image; }
+RwImage     *RwImageSetPixels(RwImage * image, RwUInt8 * pixels) { image->pixels = pixels; return image; }
+RwImage     *RwImageSetPalette(RwImage * image, RwRGBA * palette) { image->palette = (uint8*)palette; return image; }
+RwInt32      RwImageGetWidth(const RwImage * image);
+RwInt32      RwImageGetHeight(const RwImage * image);
+RwInt32      RwImageGetDepth(const RwImage * image);
+RwInt32      RwImageGetStride(const RwImage * image);
+RwUInt8     *RwImageGetPixels(const RwImage * image);
+RwRGBA      *RwImageGetPalette(const RwImage * image);
+RwUInt32     RwRGBAToPixel(RwRGBA * rgbIn, RwInt32 rasterFormat);
+RwRGBA      *RwRGBASetFromPixel(RwRGBA * rgbOut, RwUInt32 pixelValue, RwInt32 rasterFormat);
+RwBool       RwImageSetGamma(RwReal gammaValue);
+RwReal       RwImageGetGamma(void);
+RwImage     *RwImageGammaCorrect(RwImage * image);
+RwRGBA      *RwRGBAGammaCorrect(RwRGBA * rgb);
+RwInt32      RwImageRegisterPlugin(RwInt32 size, RwUInt32 pluginID, RwPluginObjectConstructor constructCB, RwPluginObjectDestructor destructCB, RwPluginObjectCopy copyCB);
+RwInt32      RwImageGetPluginOffset(RwUInt32 pluginID);
+RwBool       RwImageValidatePlugins(const RwImage * image);
+//RwBool       RwImageRegisterImageFormat(const RwChar * extension, RwImageCallBackRead imageRead, RwImageCallBackWrite imageWrite);
+const RwChar *RwImageFindFileType(const RwChar * imageName);
+RwInt32      RwImageStreamGetSize(const RwImage * image);
+RwImage     *RwImageStreamRead(RwStream * stream);
+const RwImage *RwImageStreamWrite(const RwImage * image, RwStream * stream);
+
+// TODO: this is kind hard...
+RwImage *RwImageFindRasterFormat(RwImage *ipImage,RwInt32 nRasterType, RwInt32 *npWidth,RwInt32 *npHeight, RwInt32 *npDepth,RwInt32 *npFormat)
+{
+	// very dumb implementation for now
+	// this is also platform specific
+	if((nRasterType&rwRASTERTYPEMASK) != rwRASTERTYPETEXTURE){
+		*npFormat = 0;
+		return nil;
+	}
+	*npWidth = ipImage->width;
+	*npHeight = ipImage->height;
+	switch(ipImage->depth){
+	case 4:
+	case 8:
+		*npDepth = 8;
+		*npFormat = Raster::C8888 | Raster::PAL8;
+		break;
+	case 16:
+		*npDepth = 16;
+		*npFormat = Raster::C1555;
+		break;
+	case 24:
+		*npDepth = 32;
+		*npFormat = Raster::C888;
+		break;
+	case 32:
+		*npDepth = 32;
+		*npFormat = Raster::C8888;
+		break;
+	default:
+		assert(0 && "invalid depth");
+		return nil;
+	}
+	return ipImage;
+}
+
+
+
+
+RwRaster    *RwRasterCreate(RwInt32 width, RwInt32 height, RwInt32 depth, RwInt32 flags) { return Raster::create(width, height, depth, flags); }
+RwBool       RwRasterDestroy(RwRaster * raster) { raster->destroy(); return true; }
+RwInt32      RwRasterGetWidth(const RwRaster *raster) { return raster->width; }
+RwInt32      RwRasterGetHeight(const RwRaster *raster) { return raster->height; }
+RwInt32      RwRasterGetStride(const RwRaster *raster);
+RwInt32      RwRasterGetDepth(const RwRaster *raster) { return raster->depth; }
+RwInt32      RwRasterGetFormat(const RwRaster *raster);
+RwInt32      RwRasterGetType(const RwRaster *raster);
+RwRaster    *RwRasterGetParent(const RwRaster *raster) { return raster->parent; }
+RwRaster    *RwRasterGetOffset(RwRaster *raster,  RwInt16 *xOffset, RwInt16 *yOffset);
+RwInt32      RwRasterGetNumLevels(RwRaster * raster);
+RwRaster    *RwRasterSubRaster(RwRaster * subRaster, RwRaster * raster, RwRect * rect);
+RwRaster    *RwRasterRenderFast(RwRaster * raster, RwInt32 x, RwInt32 y) { return raster->renderFast(x, y) ? raster : nil; }
+RwRaster    *RwRasterRender(RwRaster * raster, RwInt32 x, RwInt32 y);
+RwRaster    *RwRasterRenderScaled(RwRaster * raster, RwRect * rect);
+RwRaster    *RwRasterPushContext(RwRaster * raster) { return Raster::pushContext(raster); }
+RwRaster    *RwRasterPopContext(void) { return Raster::popContext(); }
+RwRaster    *RwRasterGetCurrentContext(void) { return Raster::getCurrentContext(); }
+RwBool       RwRasterClear(RwInt32 pixelValue);
+RwBool       RwRasterClearRect(RwRect * rpRect, RwInt32 pixelValue);
+RwRaster    *RwRasterShowRaster(RwRaster * raster, void *dev, RwUInt32 flags);
+RwUInt8     *RwRasterLock(RwRaster * raster, RwUInt8 level, RwInt32 lockMode);
+RwRaster    *RwRasterUnlock(RwRaster * raster);
+RwUInt8     *RwRasterLockPalette(RwRaster * raster, RwInt32 lockMode);
+RwRaster    *RwRasterUnlockPalette(RwRaster * raster);
+RwInt32      RwRasterRegisterPlugin(RwInt32 size, RwUInt32 pluginID, RwPluginObjectConstructor constructCB, RwPluginObjectDestructor destructCB, RwPluginObjectCopy copyCB);
+RwInt32      RwRasterGetPluginOffset(RwUInt32 pluginID);
+RwBool       RwRasterValidatePlugins(const RwRaster * raster);
+
+// TODO: let's hope this works
+RwRaster *RwRasterSetFromImage(RwRaster *raster, RwImage *image) {
+	engine->driver[raster->platform]->rasterFromImage(raster, image);
+	return raster;
+}
+
+
+
+
+RwTexture *RwTextureCreate(RwRaster * raster) { return Texture::create(raster); }
+RwBool RwTextureDestroy(RwTexture * texture) { texture->destroy(); return true; }
+RwTexture *RwTextureAddRef(RwTexture *texture) { texture->refCount++; return texture; }
+// TODO
+RwBool RwTextureSetMipmapping(RwBool enable) { return true; }
+RwBool RwTextureGetMipmapping(void);
+// TODO
+RwBool RwTextureSetAutoMipmapping(RwBool enable) { return true; }
+RwBool RwTextureGetAutoMipmapping(void);
+RwBool RwTextureSetMipmapGenerationCallBack(RwTextureCallBackMipmapGeneration callback);
+RwTextureCallBackMipmapGeneration RwTextureGetMipmapGenerationCallBack(void);
+RwBool RwTextureSetMipmapNameCallBack(RwTextureCallBackMipmapName callback);
+RwTextureCallBackMipmapName RwTextureGetMipmapNameCallBack(void);
+RwBool RwTextureGenerateMipmapName(RwChar * name, RwChar * maskName, RwUInt8 mipLevel, RwInt32 format);
+RwBool RwTextureRasterGenerateMipmaps(RwRaster * raster, RwImage * image);
+RwTextureCallBackRead RwTextureGetReadCallBack(void);
+RwBool RwTextureSetReadCallBack(RwTextureCallBackRead fpCallBack);
+RwTexture *RwTextureSetName(RwTexture * texture, const RwChar * name) { strncpy(texture->name, name, 32); return texture; }
+RwTexture *RwTextureSetMaskName(RwTexture * texture, const RwChar * maskName);
+RwChar *RwTextureGetName(RwTexture *texture) { return texture->name; }
+RwChar *RwTextureGetMaskName(RwTexture *texture);
+RwTexture *RwTextureSetRaster(RwTexture * texture, RwRaster * raster) { texture->raster = raster; return texture; }
+RwTexture   *RwTextureRead(const RwChar * name, const RwChar * maskName) { return Texture::read(name, maskName); }
+RwRaster *RwTextureGetRaster(const RwTexture *texture) { return texture->raster; }
+RwInt32 RwTextureRegisterPlugin(RwInt32 size, RwUInt32 pluginID, RwPluginObjectConstructor constructCB, RwPluginObjectDestructor destructCB, RwPluginObjectCopy copyCB);
+RwInt32 RwTextureGetPluginOffset(RwUInt32 pluginID);
+RwBool RwTextureValidatePlugins(const RwTexture * texture);
+
+RwTexDictionary *RwTextureGetDictionary(RwTexture *texture);
+RwTexture *RwTextureSetFilterMode(RwTexture *texture, RwTextureFilterMode filtering) { texture->setFilter((Texture::FilterMode)filtering); return texture; }
+RwTextureFilterMode RwTextureGetFilterMode(const RwTexture *texture);
+RwTexture *RwTextureSetAddressing(RwTexture *texture, RwTextureAddressMode addressing) {
+	texture->setAddressU((Texture::Addressing)addressing);
+	texture->setAddressV((Texture::Addressing)addressing);
+	return texture;
+}
+RwTexture *RwTextureSetAddressingU(RwTexture *texture, RwTextureAddressMode addressing) {
+	texture->setAddressU((Texture::Addressing)addressing);
+	return texture;
+}
+RwTexture *RwTextureSetAddressingV(RwTexture *texture, RwTextureAddressMode addressing) {
+	texture->setAddressV((Texture::Addressing)addressing);
+	return texture;
+}
+RwTextureAddressMode RwTextureGetAddressing(const RwTexture *texture);
+RwTextureAddressMode RwTextureGetAddressingU(const RwTexture *texture);
+RwTextureAddressMode RwTextureGetAddressingV(const RwTexture *texture);
+
+// TODO
+void _rwD3D8TexDictionaryEnableRasterFormatConversion(bool enable) { }
+
+// hack for reading native textures
+RwBool rwNativeTextureHackRead(RwStream *stream, RwTexture **tex, RwInt32 size)
+	{ *tex = Texture::streamReadNative(stream); return *tex != nil; }
+
+
+
+
+
+RwTexDictionary *RwTexDictionaryCreate(void) { return TexDictionary::create(); }
+RwBool RwTexDictionaryDestroy(RwTexDictionary * dict) { dict->destroy(); return true; }
+RwTexture *RwTexDictionaryAddTexture(RwTexDictionary * dict, RwTexture * texture) { dict->addFront(texture); return texture; }
+//RwTexture *RwTexDictionaryRemoveTexture(RwTexture * texture);
+RwTexture *RwTexDictionaryFindNamedTexture(RwTexDictionary * dict, const RwChar * name) { return dict->find(name); }
+RwTexDictionary *RwTexDictionaryGetCurrent(void) { return TexDictionary::getCurrent(); }
+RwTexDictionary *RwTexDictionarySetCurrent(RwTexDictionary * dict) { TexDictionary::setCurrent(dict); return dict; }
+const RwTexDictionary *RwTexDictionaryForAllTextures(const RwTexDictionary * dict, RwTextureCallBack fpCallBack, void *pData) {
+	FORLIST(lnk, ((RwTexDictionary*)dict)->textures)
+		if(fpCallBack(Texture::fromDict(lnk), pData) == nil)
+			break;
+	return dict;
+}
+RwBool RwTexDictionaryForAllTexDictionaries(RwTexDictionaryCallBack fpCallBack, void *pData);
+RwInt32 RwTexDictionaryRegisterPlugin(RwInt32 size, RwUInt32 pluginID, RwPluginObjectConstructor constructCB, RwPluginObjectDestructor destructCB, RwPluginObjectCopy copyCB);
+RwInt32 RwTexDictionaryGetPluginOffset(RwUInt32 pluginID);
+RwBool RwTexDictionaryValidatePlugins(const RwTexDictionary * dict);
+RwUInt32 RwTexDictionaryStreamGetSize(const RwTexDictionary *texDict);
+RwTexDictionary *RwTexDictionaryStreamRead(RwStream *stream);
+const RwTexDictionary *RwTexDictionaryStreamWrite(const RwTexDictionary *texDict, RwStream *stream) {
+	((RwTexDictionary*)texDict)->streamWrite(stream);
+	return texDict;
+}
+
+
+
+
+
+RwStream *RwStreamOpen(RwStreamType type, RwStreamAccessType accessType, const void *pData) {
+	StreamFile *file;
+	StreamMemory *mem;
+	RwMemory *memargs;
+	const char *mode;
+
+	switch(accessType){
+	case rwSTREAMREAD: mode = "rb"; break;
+	case rwSTREAMWRITE: mode = "wb"; break;
+	case rwSTREAMAPPEND: mode = "ab"; break;
+	default: return nil;
+	}
+
+	// oh god this is horrible. librw streams really need fixing
+	switch(type){
+	case rwSTREAMFILENAME:{
+		StreamFile fakefile;
+		file = rwNewT(StreamFile, 1, 0);
+		memcpy(file, &fakefile, sizeof(StreamFile));
+		if(file->open((char*)pData, mode))
+			return file;
+		rwFree(file);
+		return nil;
+	}
+	case rwSTREAMMEMORY:{
+		StreamMemory fakemem;
+		memargs = (RwMemory*)pData;
+		mem = rwNewT(StreamMemory, 1, 0);
+		memcpy(mem, &fakemem, sizeof(StreamMemory));
+		if(mem->open(memargs->start, memargs->length))
+			return mem;
+		rwFree(mem);
+		return nil;
+	}
+	default:
+		assert(0 && "unknown type");
+		return nil;
+	}
+}
+RwBool RwStreamClose(RwStream * stream, void *pData) { stream->close(); rwFree(stream); return true; }
+RwUInt32 RwStreamRead(RwStream * stream, void *buffer, RwUInt32 length) { return stream->read(buffer, length); }
+RwStream *RwStreamWrite(RwStream * stream, const void *buffer, RwUInt32 length) { stream->write(buffer, length); return stream; }
+RwStream *RwStreamSkip(RwStream * stream, RwUInt32 offset) { stream->seek(offset); return stream; }
+
+RwBool RwStreamFindChunk(RwStream *stream, RwUInt32 type, RwUInt32 *lengthOut, RwUInt32 *versionOut)
+	{ return findChunk(stream, type, lengthOut, versionOut); }
+
+
+
+void RwIm2DVertexSetCameraX(RwIm2DVertex *vert, RwReal camx) { }
+void RwIm2DVertexSetCameraY(RwIm2DVertex *vert, RwReal camy) { }
+void RwIm2DVertexSetCameraZ(RwIm2DVertex *vert, RwReal camz) { vert->setCameraZ(camz); }
+void RwIm2DVertexSetRecipCameraZ(RwIm2DVertex *vert, RwReal recipz) { vert->setRecipCameraZ(recipz); }
+void RwIm2DVertexSetScreenX(RwIm2DVertex *vert, RwReal scrnx) { vert->setScreenX(scrnx); }
+void RwIm2DVertexSetScreenY(RwIm2DVertex *vert, RwReal scrny) { vert->setScreenY(scrny); }
+void RwIm2DVertexSetScreenZ(RwIm2DVertex *vert, RwReal scrnz) { vert->setScreenZ(scrnz); }
+void RwIm2DVertexSetU(RwIm2DVertex *vert, RwReal texU, RwReal recipz) { vert->setU(texU, recipz); }
+void RwIm2DVertexSetV(RwIm2DVertex *vert, RwReal texV, RwReal recipz) { vert->setV(texV, recipz); }
+void RwIm2DVertexSetIntRGBA(RwIm2DVertex *vert, RwUInt8 red, RwUInt8 green, RwUInt8 blue, RwUInt8 alpha) { vert->setColor(red, green, blue, alpha); }
+
+RwReal RwIm2DGetNearScreenZ(void) { return im2d::GetNearZ(); }
+RwReal RwIm2DGetFarScreenZ(void) { return im2d::GetFarZ(); }
+RwBool RwIm2DRenderLine(RwIm2DVertex *vertices, RwInt32 numVertices, RwInt32 vert1, RwInt32 vert2)
+	{ im2d::RenderLine(vertices, numVertices, vert1, vert2); return true; }
+RwBool RwIm2DRenderTriangle(RwIm2DVertex *vertices, RwInt32 numVertices, RwInt32 vert1, RwInt32 vert2, RwInt32 vert3 )
+	{ im2d::RenderTriangle(vertices, numVertices, vert1, vert2, vert3); return true; }
+RwBool RwIm2DRenderPrimitive(RwPrimitiveType primType, RwIm2DVertex *vertices, RwInt32 numVertices)
+	{ im2d::RenderPrimitive((PrimitiveType)primType, vertices, numVertices); return true; }
+RwBool RwIm2DRenderIndexedPrimitive(RwPrimitiveType primType, RwIm2DVertex *vertices, RwInt32 numVertices, RwImVertexIndex *indices, RwInt32 numIndices)
+	{ im2d::RenderIndexedPrimitive((PrimitiveType)primType, vertices, numVertices, indices, numIndices); return true; }
+
+
+void RwIm3DVertexSetPos(RwIm3DVertex *vert, RwReal x, RwReal y, RwReal z) { vert->setX(x); vert->setY(y); vert->setZ(z); }
+void RwIm3DVertexSetU(RwIm3DVertex *vert, RwReal u) { vert->setU(u); }
+void RwIm3DVertexSetV(RwIm3DVertex *vert, RwReal v) { vert->setV(v); }
+void RwIm3DVertexSetRGBA(RwIm3DVertex *vert, RwUInt8 r, RwUInt8 g, RwUInt8 b, RwUInt8 a) { vert->setColor(r, g, b, a); }
+
+// WARNING: ignoring flags
+void  *RwIm3DTransform(RwIm3DVertex *pVerts, RwUInt32 numVerts, RwMatrix *ltm, RwUInt32 flags) { im3d::Transform(pVerts, numVerts, ltm); return pVerts; }
+RwBool RwIm3DEnd(void) { im3d::End(); return true; }
+RwBool RwIm3DRenderLine(RwInt32 vert1, RwInt32 vert2) {
+	RwImVertexIndex indices[2];
+	indices[0] = vert1;
+	indices[1] = vert2;
+	im3d::RenderIndexed((PrimitiveType)PRIMTYPELINELIST, indices, 2);
+	return true;
+}
+RwBool RwIm3DRenderTriangle(RwInt32 vert1, RwInt32 vert2, RwInt32 vert3);
+RwBool RwIm3DRenderIndexedPrimitive(RwPrimitiveType primType, RwImVertexIndex *indices, RwInt32 numIndices) { im3d::RenderIndexed((PrimitiveType)primType, indices, numIndices); return true; }
+RwBool RwIm3DRenderPrimitive(RwPrimitiveType primType);
+
+
+
+
+
+RwBool RwRenderStateSet(RwRenderState state, void *value)
+{
+	uint32 uival = (uintptr)value;
+	switch(state){
+	case rwRENDERSTATETEXTURERASTER: SetRenderState(TEXTURERASTER, uival); return true;
+	case rwRENDERSTATETEXTUREADDRESS: SetRenderState(TEXTUREADDRESS, uival); return true;
+	case rwRENDERSTATETEXTUREADDRESSU: SetRenderState(TEXTUREADDRESSU, uival); return true;
+	case rwRENDERSTATETEXTUREADDRESSV: SetRenderState(TEXTUREADDRESSV, uival); return true;
+	case rwRENDERSTATETEXTUREPERSPECTIVE: return true;
+	case rwRENDERSTATEZTESTENABLE: SetRenderState(ZTESTENABLE, uival); return true;
+	case rwRENDERSTATESHADEMODE: return true;
+	case rwRENDERSTATEZWRITEENABLE: SetRenderState(ZWRITEENABLE, uival); return true;
+	case rwRENDERSTATETEXTUREFILTER: SetRenderState(TEXTUREFILTER, uival); return true;
+	case rwRENDERSTATESRCBLEND: SetRenderState(SRCBLEND, uival); return true;
+	case rwRENDERSTATEDESTBLEND: SetRenderState(DESTBLEND, uival); return true;
+	case rwRENDERSTATEVERTEXALPHAENABLE: SetRenderState(VERTEXALPHA, uival); return true;
+	case rwRENDERSTATEBORDERCOLOR: return true;
+	case rwRENDERSTATEFOGENABLE: SetRenderState(FOGENABLE, uival); return true;
+	case rwRENDERSTATEFOGCOLOR: SetRenderState(FOGCOLOR, uival); return true;
+	case rwRENDERSTATEFOGTYPE: return true;
+	case rwRENDERSTATEFOGDENSITY: return true;
+	case rwRENDERSTATEFOGTABLE: return true;
+	case rwRENDERSTATEALPHAPRIMITIVEBUFFER: return true;
+	case rwRENDERSTATECULLMODE: SetRenderState(CULLMODE, uival); return true;
+
+	// all unsupported
+	case rwRENDERSTATESTENCILENABLE:
+	case rwRENDERSTATESTENCILFAIL:
+	case rwRENDERSTATESTENCILZFAIL:
+	case rwRENDERSTATESTENCILPASS:
+	case rwRENDERSTATESTENCILFUNCTION:
+	case rwRENDERSTATESTENCILFUNCTIONREF:
+	case rwRENDERSTATESTENCILFUNCTIONMASK:
+	case rwRENDERSTATESTENCILFUNCTIONWRITEMASK:
+	default:
+		return true;
+	}
+}
+
+
+static EngineOpenParams openParams;
+// WARNING: unused parameters
+RwBool RwEngineInit(RwMemoryFunctions *memFuncs, RwUInt32 initFlags, RwUInt32 resArenaSize) { Engine::init(); return true; }
+// TODO: this is platform dependent
+RwBool RwEngineOpen(RwEngineOpenParams *initParams) {
+	openParams.window = (HWND)initParams->displayID;
+	return Engine::open(&openParams);
+}
+RwBool RwEngineStart(void) {
+	rw::d3d::isP8supported = false;
+	return Engine::start();
+}
+RwBool RwEngineStop(void) { Engine::stop(); return true; }
+RwBool RwEngineClose(void) { Engine::close(); return true; }
+RwBool RwEngineTerm(void) { Engine::term(); return true; }
+RwInt32 RwEngineRegisterPlugin(RwInt32 size, RwUInt32 pluginID, RwPluginObjectConstructor initCB, RwPluginObjectDestructor termCB);
+RwInt32 RwEngineGetPluginOffset(RwUInt32 pluginID);
+RwInt32 RwEngineGetNumSubSystems(void) { return Engine::getNumSubSystems(); }
+RwSubSystemInfo *RwEngineGetSubSystemInfo(RwSubSystemInfo *subSystemInfo, RwInt32 subSystemIndex)
+	{ return Engine::getSubSystemInfo(subSystemInfo, subSystemIndex); }
+RwInt32 RwEngineGetCurrentSubSystem(void) { return Engine::getCurrentSubSystem(); }
+RwBool RwEngineSetSubSystem(RwInt32 subSystemIndex) { return Engine::setSubSystem(subSystemIndex); }
+RwInt32 RwEngineGetNumVideoModes(void) { return Engine::getNumVideoModes(); }
+RwVideoMode *RwEngineGetVideoModeInfo(RwVideoMode *modeinfo, RwInt32 modeIndex)
+	{ return Engine::getVideoModeInfo(modeinfo, modeIndex); }
+RwInt32 RwEngineGetCurrentVideoMode(void) { return Engine::getCurrentVideoMode(); }
+RwBool RwEngineSetVideoMode(RwInt32 modeIndex) { return Engine::setVideoMode(modeIndex); }
+RwInt32 RwEngineGetTextureMemorySize(void);
+RwInt32 RwEngineGetMaxTextureSize(void);
+
+
+
+// TODO
+void RwD3D8EngineSetRefreshRate(RwUInt32 refreshRate) {}
+RwBool RwD3D8DeviceSupportsDXTTexture(void) { return true; }
+
+
+
+RpMaterial *RpMaterialCreate(void) { return Material::create(); }
+RwBool RpMaterialDestroy(RpMaterial *material) { material->destroy(); return true; }
+//RpMaterial *RpMaterialClone(RpMaterial *material);
+RpMaterial *RpMaterialSetTexture(RpMaterial *material, RwTexture *texture) { material->setTexture(texture); return material; }
+//RpMaterial *RpMaterialAddRef(RpMaterial *material);
+RwTexture *RpMaterialGetTexture(const RpMaterial *material) { return material->texture; }
+RpMaterial *RpMaterialSetColor(RpMaterial *material, const RwRGBA *color) { material->color = *color; return material; }
+const RwRGBA *RpMaterialGetColor(const RpMaterial *material) { return &material->color; }
+RpMaterial *RpMaterialSetSurfaceProperties(RpMaterial *material, const RwSurfaceProperties *surfaceProperties);
+const RwSurfaceProperties *RpMaterialGetSurfaceProperties(const RpMaterial *material) { return &material->surfaceProps; }
+//RwInt32 RpMaterialRegisterPlugin(RwInt32 size, RwUInt32 pluginID, RwPluginObjectConstructor constructCB, RwPluginObjectDestructor destructCB, RwPluginObjectCopy copyCB);
+//RwInt32 RpMaterialRegisterPluginStream(RwUInt32 pluginID, RwPluginDataChunkReadCallBack readCB, RwPluginDataChunkWriteCallBack writeCB, RwPluginDataChunkGetSizeCallBack getSizeCB);
+//RwInt32 RpMaterialSetStreamAlwaysCallBack(RwUInt32 pluginID, RwPluginDataChunkAlwaysCallBack alwaysCB);
+//RwInt32 RpMaterialGetPluginOffset(RwUInt32 pluginID);
+//RwBool RpMaterialValidatePlugins(const RpMaterial *material);
+//RwUInt32 RpMaterialStreamGetSize(const RpMaterial *material);
+//RpMaterial *RpMaterialStreamRead(RwStream *stream);
+//const RpMaterial *RpMaterialStreamWrite(const RpMaterial *material, RwStream *stream);
+//RpMaterialChunkInfo *_rpMaterialChunkInfoRead(RwStream *stream,  RpMaterialChunkInfo *materialChunkInfo, RwInt32 *bytesRead);
+
+
+
+
+
+RwReal RpLightGetRadius(const RpLight *light) { return light->radius; }
+//const RwRGBAReal *RpLightGetColor(const RpLight *light);
+RpLight *RpLightSetFrame(RpLight *light, RwFrame *frame) { light->setFrame(frame); return light; }
+RwFrame *RpLightGetFrame(const RpLight *light) { return light->getFrame(); }
+//RpLightType RpLightGetType(const RpLight *light);
+RpLight *RpLightSetFlags(RpLight *light, RwUInt32 flags) { light->setFlags(flags); return light; }
+//RwUInt32 RpLightGetFlags(const RpLight *light);
+RpLight *RpLightCreate(RwInt32 type) { return rw::Light::create(type); }
+RwBool RpLightDestroy(RpLight *light) { light->destroy(); return true; }
+RpLight *RpLightSetRadius(RpLight *light, RwReal radius) { light->radius = radius; return light; }
+RpLight *RpLightSetColor(RpLight *light, const RwRGBAReal *color) { light->setColor(color->red, color->green, color->blue); return light; }
+//RwReal RpLightGetConeAngle(const RpLight *light);
+//RpLight *RpLightSetConeAngle(RpLight * ight, RwReal angle);
+//RwUInt32 RpLightStreamGetSize(const RpLight *light);
+//RpLight *RpLightStreamRead(RwStream *stream);
+//const RpLight *RpLightStreamWrite(const RpLight *light, RwStream *stream);
+//RpLightChunkInfo *_rpLightChunkInfoRead(RwStream *stream, RpLightChunkInfo *lightChunkInfo, RwInt32 *bytesRead);
+//RwInt32 RpLightRegisterPlugin(RwInt32 size, RwUInt32 pluginID, RwPluginObjectConstructor constructCB, RwPluginObjectDestructor destructCB, RwPluginObjectCopy copyCB);
+//RwInt32 RpLightRegisterPluginStream(RwUInt32 pluginID, RwPluginDataChunkReadCallBack readCB, RwPluginDataChunkWriteCallBack writeCB, RwPluginDataChunkGetSizeCallBack getSizeCB);
+//RwInt32 RpLightSetStreamAlwaysCallBack(RwUInt32 pluginID, RwPluginDataChunkAlwaysCallBack alwaysCB);
+//RwInt32 RpLightGetPluginOffset(RwUInt32 pluginID);
+//RwBool RpLightValidatePlugins(const RpLight * light);
+
+
+
+
+
+RpGeometry  *RpGeometryCreate(RwInt32 numVert, RwInt32 numTriangles, RwUInt32 format) { return Geometry::create(numVert, numTriangles, format); }
+RwBool RpGeometryDestroy(RpGeometry *geometry) { geometry->destroy(); return true; }
+RpGeometry *_rpGeometryAddRef(RpGeometry *geometry);
+RpGeometry  *RpGeometryLock(RpGeometry *geometry, RwInt32 lockMode) { geometry->lock(lockMode); return geometry; }
+RpGeometry  *RpGeometryUnlock(RpGeometry *geometry) { geometry->unlock(); return geometry; }
+RpGeometry  *RpGeometryTransform(RpGeometry *geometry, const RwMatrix *matrix);
+RpGeometry  *RpGeometryCreateSpace(RwReal radius);
+RpMorphTarget  *RpMorphTargetSetBoundingSphere(RpMorphTarget *morphTarget, const RwSphere *boundingSphere) { morphTarget->boundingSphere = *boundingSphere; return morphTarget; }
+RwSphere  *RpMorphTargetGetBoundingSphere(RpMorphTarget *morphTarget) { return &morphTarget->boundingSphere; }
+const RpMorphTarget  *RpMorphTargetCalcBoundingSphere(const RpMorphTarget *morphTarget, RwSphere *boundingSphere) { *boundingSphere = morphTarget->calculateBoundingSphere(); return morphTarget; }
+RwInt32 RpGeometryAddMorphTargets(RpGeometry *geometry, RwInt32 mtcount);
+RwInt32 RpGeometryAddMorphTarget(RpGeometry *geometry);
+RpGeometry  *RpGeometryRemoveMorphTarget(RpGeometry *geometry, RwInt32 morphTarget);
+RwInt32 RpGeometryGetNumMorphTargets(const RpGeometry *geometry);
+RpMorphTarget  *RpGeometryGetMorphTarget(const RpGeometry *geometry, RwInt32 morphTarget) { return &geometry->morphTargets[morphTarget]; }
+RwRGBA  *RpGeometryGetPreLightColors(const RpGeometry *geometry) { return geometry->colors; }
+RwTexCoords  *RpGeometryGetVertexTexCoords(const RpGeometry *geometry, RwTextureCoordinateIndex uvIndex) {
+	if(uvIndex == rwNARWTEXTURECOORDINATEINDEX)
+		return nil;
+	return geometry->texCoords[uvIndex-rwTEXTURECOORDINATEINDEX0];
+}
+RwInt32 RpGeometryGetNumTexCoordSets(const RpGeometry *geometry) { return geometry->numTexCoordSets; }
+RwInt32 RpGeometryGetNumVertices (const RpGeometry *geometry) { return geometry->numVertices; }
+RwV3d  *RpMorphTargetGetVertices(const RpMorphTarget *morphTarget) { return morphTarget->vertices; }
+RwV3d  *RpMorphTargetGetVertexNormals(const RpMorphTarget *morphTarget) { return morphTarget->normals; }
+RpTriangle  *RpGeometryGetTriangles(const RpGeometry *geometry) { return geometry->triangles; }
+RwInt32 RpGeometryGetNumTriangles(const RpGeometry *geometry) { return geometry->numTriangles; }
+RpMaterial  *RpGeometryGetMaterial(const RpGeometry *geometry, RwInt32 matNum) { return geometry->matList.materials[matNum]; }
+const RpGeometry  *RpGeometryTriangleSetVertexIndices(const RpGeometry *geometry, RpTriangle *triangle, RwUInt16 vert1, RwUInt16 vert2, RwUInt16 vert3)
+	{ triangle->v[0] = vert1; triangle->v[1] = vert2; triangle->v[2] = vert3; return geometry; }
+RpGeometry  *RpGeometryTriangleSetMaterial(RpGeometry *geometry, RpTriangle *triangle, RpMaterial *material) {
+	int id = geometry->matList.findIndex(material);
+	if(id < 0)
+		id = geometry->matList.appendMaterial(material);
+	if(id < 0)
+		return nil;
+	triangle->matId = id;
+	return geometry;
+}
+const RpGeometry  *RpGeometryTriangleGetVertexIndices(const RpGeometry *geometry, const RpTriangle *triangle, RwUInt16 *vert1, RwUInt16 *vert2, RwUInt16 *vert3);
+RpMaterial   *RpGeometryTriangleGetMaterial(const RpGeometry *geometry, const RpTriangle *triangle);
+RwInt32 RpGeometryGetNumMaterials(const RpGeometry *geometry);
+RpGeometry  *RpGeometryForAllMaterials(RpGeometry *geometry, RpMaterialCallBack fpCallBack, void *pData) {
+	int i;
+	for(i = 0; i < geometry->matList.numMaterials; i++)
+		if(fpCallBack(geometry->matList.materials[i], pData) == nil)
+			break;
+	return geometry;
+}
+//const RpGeometry  *RpGeometryForAllMeshes(const RpGeometry *geometry, RpMeshCallBack fpCallBack, void *pData);
+RwInt32 RpGeometryRegisterPlugin(RwInt32 size, RwUInt32 pluginID, RwPluginObjectConstructor constructCB, RwPluginObjectDestructor destructCB, RwPluginObjectCopy copyCB);
+RwInt32 RpGeometryRegisterPluginStream(RwUInt32 pluginID, RwPluginDataChunkReadCallBack readCB, RwPluginDataChunkWriteCallBack writeCB, RwPluginDataChunkGetSizeCallBack getSizeCB);
+RwInt32 RpGeometrySetStreamAlwaysCallBack(RwUInt32 pluginID, RwPluginDataChunkAlwaysCallBack alwaysCB);
+RwInt32 RpGeometryGetPluginOffset(RwUInt32 pluginID);
+RwBool RpGeometryValidatePlugins(const RpGeometry *geometry);
+RwUInt32 RpGeometryStreamGetSize(const RpGeometry *geometry);
+const RpGeometry  *RpGeometryStreamWrite(const RpGeometry *geometry, RwStream *stream);
+RpGeometry  *RpGeometryStreamRead(RwStream *stream) { return Geometry::streamRead(stream); }
+//RpGeometryChunkInfo *_rpGeometryChunkInfoRead(RwStream *stream, RpGeometryChunkInfo *geometryChunkInfo, RwInt32 *bytesRead);
+RwUInt32 RpGeometryGetFlags(const RpGeometry *geometry) { return geometry->flags; }
+RpGeometry  *RpGeometrySetFlags(RpGeometry *geometry, RwUInt32 flags) { geometry->flags = flags; return geometry; }
+const RwSurfaceProperties *_rpGeometryGetSurfaceProperties(const RpGeometry *geometry);
+RpGeometry *_rpGeometrySetSurfaceProperties(RpGeometry *geometry, const RwSurfaceProperties *surfaceProperties);
+
+
+
+
+
+RwFrame *RpClumpGetFrame(const RpClump * clump) { return clump->getFrame(); }
+RpClump *RpClumpSetFrame(RpClump * clump, RwFrame * frame) { clump->setFrame(frame); return clump; }
+RpClump *RpClumpForAllAtomics(RpClump * clump, RpAtomicCallBack callback, void *pData) {
+	FORLIST(lnk, clump->atomics)
+		if(callback(Atomic::fromClump(lnk), pData) == nil)
+			break;
+	return clump;
+}
+RpClump *RpClumpForAllLights(RpClump * clump, RpLightCallBack callback, void *pData);
+RpClump *RpClumpForAllCameras(RpClump * clump, RwCameraCallBack callback, void *pData);
+//RpClump *RpClumpCreateSpace(const RwV3d * position, RwReal radius);
+RpClump *RpClumpRender(RpClump * clump) { clump->render(); return clump; }
+RpClump *RpClumpRemoveAtomic(RpClump * clump, RpAtomic * atomic) { atomic->removeFromClump(); return clump; }
+RpClump *RpClumpAddAtomic(RpClump * clump, RpAtomic * atomic) { clump->addAtomic(atomic); return clump; }
+//RpClump *RpClumpRemoveLight(RpClump * clump, RpLight * light);
+//RpClump *RpClumpAddLight(RpClump * clump, RpLight * light);
+//RpClump *RpClumpRemoveCamera(RpClump * clump, RwCamera * camera);
+//RpClump *RpClumpAddCamera(RpClump * clump, RwCamera * camera);
+RwBool RpClumpDestroy(RpClump * clump) { clump->destroy(); return true; }
+RpClump *RpClumpCreate(void) { return rw::Clump::create(); }
+RpClump *RpClumpClone(RpClump * clump) { return clump->clone(); }
+//RpClump *RpClumpSetCallBack(RpClump * clump, RpClumpCallBack callback);
+//RpClumpCallBack RpClumpGetCallBack(const RpClump * clump);
+RwInt32 RpClumpGetNumAtomics(RpClump * clump) { return clump->countAtomics(); }
+//RwInt32 RpClumpGetNumLights(RpClump * clump);
+//RwInt32 RpClumpGetNumCameras(RpClump * clump);
+RpClump *RpClumpStreamRead(RwStream * stream) { return rw::Clump::streamRead(stream); }
+//RpClump *RpClumpStreamWrite(RpClump * clump, RwStream * stream);
+RwInt32 RpClumpRegisterPlugin(RwInt32 size, RwUInt32 pluginID, RwPluginObjectConstructor constructCB, RwPluginObjectDestructor destructCB, RwPluginObjectCopy copyCB)
+	{ return Clump::registerPlugin(size, pluginID, constructCB, destructCB, (CopyConstructor)copyCB); }
+RwInt32 RpClumpRegisterPluginStream(RwUInt32 pluginID, RwPluginDataChunkReadCallBack  readCB, RwPluginDataChunkWriteCallBack writeCB, RwPluginDataChunkGetSizeCallBack getSizeCB)
+	{ return Clump::registerPluginStream(pluginID, readCB, (StreamWrite)writeCB, (StreamGetSize)getSizeCB); }
+//RwInt32 RpClumpSetStreamAlwaysCallBack(RwUInt32 pluginID, RwPluginDataChunkAlwaysCallBack alwaysCB);
+//RwInt32 RpClumpGetPluginOffset(RwUInt32 pluginID);
+//RwBool RpClumpValidatePlugins(const RpClump * clump);
+
+
+
+RpAtomic *RpAtomicCreate(void) { return rw::Atomic::create(); }
+RwBool RpAtomicDestroy(RpAtomic * atomic) { atomic->destroy(); return true; }
+RpAtomic *RpAtomicClone(RpAtomic * atomic) { return atomic->clone(); }
+RpAtomic *RpAtomicSetFrame(RpAtomic * atomic, RwFrame * frame) { atomic->setFrame(frame); return atomic; }
+RpAtomic *RpAtomicSetGeometry(RpAtomic * atomic, RpGeometry * geometry, RwUInt32 flags) { atomic->setGeometry(geometry, flags); return atomic; }
+
+RwFrame *RpAtomicGetFrame(const RpAtomic * atomic) { return atomic->getFrame(); }
+RpAtomic *RpAtomicSetFlags(RpAtomic * atomic, RwUInt32 flags) { atomic->setFlags(flags); return atomic; }
+RwUInt32 RpAtomicGetFlags(const RpAtomic * atomic) { return atomic->getFlags(); }
+RwSphere *RpAtomicGetBoundingSphere(RpAtomic * atomic) { return &atomic->boundingSphere; }
+RpAtomic *RpAtomicRender(RpAtomic * atomic) { atomic->render(); return atomic; }
+RpClump *RpAtomicGetClump(const RpAtomic * atomic) { return atomic->clump; }
+//RpInterpolator *RpAtomicGetInterpolator(RpAtomic * atomic);
+RpGeometry *RpAtomicGetGeometry(const RpAtomic * atomic) { return atomic->geometry; }
+// WARNING: illegal cast
+void RpAtomicSetRenderCallBack(RpAtomic * atomic, RpAtomicCallBackRender callback) { atomic->setRenderCB((Atomic::RenderCB)callback); }
+RpAtomicCallBackRender RpAtomicGetRenderCallBack(const RpAtomic * atomic) { return (RpAtomicCallBackRender)atomic->renderCB; }
+//RwBool RpAtomicInstance(RpAtomic *atomic);
+//RwUInt32 RpAtomicStreamGetSize(RpAtomic * atomic);
+//RpAtomic *RpAtomicStreamRead(RwStream * stream);
+//RpAtomic *RpAtomicStreamWrite(RpAtomic * atomic, RwStream * stream);
+RwInt32 RpAtomicRegisterPlugin(RwInt32 size, RwUInt32 pluginID, RwPluginObjectConstructor constructCB, RwPluginObjectDestructor destructCB, RwPluginObjectCopy copyCB)
+	{ return Atomic::registerPlugin(size, pluginID, constructCB, destructCB, (CopyConstructor)copyCB); }
+//RwInt32 RpAtomicRegisterPluginStream(RwUInt32 pluginID, RwPluginDataChunkReadCallBack readCB, RwPluginDataChunkWriteCallBack writeCB, RwPluginDataChunkGetSizeCallBack getSizeCB);
+//RwInt32 RpAtomicSetStreamAlwaysCallBack(RwUInt32 pluginID, RwPluginDataChunkAlwaysCallBack alwaysCB);
+//RwInt32 RpAtomicSetStreamRightsCallBack(RwUInt32 pluginID, RwPluginDataChunkRightsCallBack rightsCB);
+//RwInt32 RpAtomicGetPluginOffset(RwUInt32 pluginID);
+//RwBool RpAtomicValidatePlugins(const RpAtomic * atomic);
+
+RpAtomic *AtomicDefaultRenderCallBack(RpAtomic * atomic) { Atomic::defaultRenderCB(atomic); return atomic; }
+
+
+// TODO: this is extremely simplified
+RpWorld     *RpWorldCreate(RwBBox * boundingBox) { return World::create(); }
+RwBool       RpWorldDestroy(RpWorld * world) { world->destroy(); return true; }
+
+RwBool       RpWorldPluginAttach(void) {
+	registerMeshPlugin();
+	registerNativeDataPlugin();
+	registerAtomicRightsPlugin();
+	registerMaterialRightsPlugin();
+	return true;
+}
+
+RpWorld *RpWorldRemoveCamera(RpWorld *world, RwCamera *camera) { world->removeCamera(camera); return world; }
+RpWorld *RpWorldAddCamera(RpWorld *world, RwCamera *camera) { world->addCamera(camera); return world; }
+RpWorld *RwCameraGetWorld(const RwCamera *camera);
+RpWorld *RpWorldRemoveAtomic(RpWorld *world, RpAtomic *atomic);
+RpWorld *RpWorldAddAtomic(RpWorld *world, RpAtomic *atomic);
+RpWorld *RpAtomicGetWorld(const RpAtomic *atomic);
+RpWorld *RpWorldAddClump(RpWorld *world, RpClump *clump);
+RpWorld *RpWorldRemoveClump(RpWorld *world, RpClump *clump);
+RpWorld *RpClumpGetWorld(const RpClump *clump);
+RpWorld *RpWorldAddLight(RpWorld *world, RpLight *light) { world->addLight(light); return world; }
+RpWorld *RpWorldRemoveLight(RpWorld *world, RpLight *light) { world->removeLight(light); return world; }
+RpWorld *RpLightGetWorld(const RpLight *light);
+RwCamera *RwCameraForAllClumpsInFrustum(RwCamera *camera, void *data);
+RwCamera *RwCameraForAllClumpsNotInFrustum(RwCamera *camera, RwInt32 numClumps, void *data);
+
+
+
+
+RwBool RpMatFXPluginAttach( void ) { registerMatFXPlugin(); return true; }
+RpAtomic *RpMatFXAtomicEnableEffects( RpAtomic *atomic ) { MatFX::enableEffects(atomic); return atomic; }
+RpMaterial *RpMatFXMaterialSetEffects( RpMaterial *material, RpMatFXMaterialFlags flags ) { MatFX::setEffects(material, (uint32)flags); return material; }
+RpMaterial *RpMatFXMaterialSetupEnvMap( RpMaterial *material, RwTexture *texture, RwFrame *frame, RwBool useFrameBufferAlpha, RwReal coef ) {
+	MatFX *mfx = MatFX::get(material);
+	mfx->setEnvTexture(texture);
+	mfx->setEnvFrame(frame);
+	mfx->setEnvCoefficient(coef);
+	return material;
+}
+
+
+
+
+
+RwBool RpHAnimPluginAttach(void) {
+	registerHAnimPlugin();
+	return true;
+}
+
+RwBool RpHAnimFrameSetHierarchy(RwFrame *frame, RpHAnimHierarchy *hierarchy) { HAnimData::get(frame)->hierarchy = hierarchy; return true; }
+RpHAnimHierarchy *RpHAnimFrameGetHierarchy(RwFrame *frame) { return HAnimHierarchy::get(frame); }
+
+RwBool RpHAnimHierarchySetCurrentAnim(RpHAnimHierarchy *hierarchy, RpHAnimAnimation *anim) { hierarchy->currentAnim->setCurrentAnim(anim); return true; }
+RwBool RpHAnimHierarchyAddAnimTime(RpHAnimHierarchy *hierarchy, RwReal time) { hierarchy->currentAnim->addTime(time); return true; }
+
+RwBool RpHAnimHierarchyUpdateMatrices(RpHAnimHierarchy *hierarchy) { hierarchy->updateMatrices(); return true; }
+
+RpHAnimAnimation  *RpHAnimAnimationStreamRead(RwStream *stream) { return Animation::streamRead(stream); }
+
+
+
+
+
+
+RwBool RpSkinPluginAttach(void) {
+	registerSkinPlugin();
+	return true;
+}
+
+RpAtomic *RpSkinAtomicSetHAnimHierarchy( RpAtomic *atomic, RpHAnimHierarchy *hierarchy ) { Skin::setHierarchy(atomic, hierarchy); return atomic; }
+RpHAnimHierarchy *RpSkinAtomicGetHAnimHierarchy( const RpAtomic *atomic ) { return Skin::getHierarchy(atomic); }
+
+
+
+
+
+RwImage *RtBMPImageWrite(RwImage * image, const RwChar * imageName) { rw::writeBMP(image, imageName); return image; }
+RwImage *RtBMPImageRead(const RwChar * imageName) { return rw::readBMP(imageName); }
+
+
+
+
+// fake shit
+RwInt32 _rwD3D8FindCorrectRasterFormat(RwRasterType type, RwInt32 flags) { return 1; }
diff --git a/src/fakerw/rphanim.h b/src/fakerw/rphanim.h
new file mode 100644
index 00000000..665e03f8
--- /dev/null
+++ b/src/fakerw/rphanim.h
@@ -0,0 +1,20 @@
+#pragma once
+
+//struct RpHAnimHierarchy;
+typedef rw::HAnimHierarchy RpHAnimHierarchy;
+//struct RpHAnimAnimation;
+typedef rw::Animation RpHAnimAnimation;
+
+RwBool RpHAnimPluginAttach(void);
+
+RwBool RpHAnimFrameSetHierarchy(RwFrame *frame, RpHAnimHierarchy *hierarchy);
+RpHAnimHierarchy *RpHAnimFrameGetHierarchy(RwFrame *frame);
+
+RwBool RpHAnimHierarchySetCurrentAnim(RpHAnimHierarchy *hierarchy, RpHAnimAnimation *anim);
+RwBool RpHAnimHierarchySetCurrentAnimTime(RpHAnimHierarchy *hierarchy, RwReal time);
+RwBool RpHAnimHierarchySubAnimTime(RpHAnimHierarchy *hierarchy, RwReal time);
+RwBool RpHAnimHierarchyAddAnimTime(RpHAnimHierarchy *hierarchy, RwReal time);
+
+RwBool RpHAnimHierarchyUpdateMatrices(RpHAnimHierarchy *hierarchy);
+
+RpHAnimAnimation  *RpHAnimAnimationStreamRead(RwStream *stream);
diff --git a/src/fakerw/rpmatfx.h b/src/fakerw/rpmatfx.h
new file mode 100644
index 00000000..87c8fb2e
--- /dev/null
+++ b/src/fakerw/rpmatfx.h
@@ -0,0 +1,43 @@
+#pragma once
+
+enum RpMatFXMaterialFlags
+{
+	rpMATFXEFFECTNULL       = rw::MatFX::NOTHING,
+	rpMATFXEFFECTBUMPMAP    = rw::MatFX::BUMPMAP,
+	rpMATFXEFFECTENVMAP     = rw::MatFX::ENVMAP,
+	rpMATFXEFFECTBUMPENVMAP = rw::MatFX::BUMPENVMAP,
+	rpMATFXEFFECTDUAL       = rw::MatFX::DUAL,
+
+	rpMATFXEFFECTMAX,
+	rpMATFXNUMEFFECTS       = rpMATFXEFFECTMAX - 1,
+};
+
+RwBool RpMatFXPluginAttach( void );
+RpAtomic *RpMatFXAtomicEnableEffects( RpAtomic *atomic );
+RwBool RpMatFXAtomicQueryEffects( RpAtomic *atomic );
+//RpWorldSector *RpMatFXWorldSectorEnableEffects( RpWorldSector *worldSector );
+//RwBool RpMatFXWorldSectorQueryEffects( RpWorldSector *worldSector );
+RpMaterial *RpMatFXMaterialSetEffects( RpMaterial *material, RpMatFXMaterialFlags flags );
+RpMaterial *RpMatFXMaterialSetupBumpMap( RpMaterial *material, RwTexture *texture, RwFrame *frame, RwReal coef );
+RpMaterial *RpMatFXMaterialSetupEnvMap( RpMaterial *material, RwTexture *texture, RwFrame *frame, RwBool useFrameBufferAlpha, RwReal coef );
+RpMaterial *RpMatFXMaterialSetupDualTexture( RpMaterial *material, RwTexture *texture, RwBlendFunction srcBlendMode, RwBlendFunction dstBlendMode );
+RpMatFXMaterialFlags RpMatFXMaterialGetEffects( const RpMaterial *material );
+RpMaterial *RpMatFXMaterialSetBumpMapTexture( RpMaterial *material, RwTexture *texture );
+RpMaterial *RpMatFXMaterialSetBumpMapFrame( RpMaterial *material, RwFrame *frame );
+RpMaterial *RpMatFXMaterialSetBumpMapCoefficient( RpMaterial *material, RwReal coef );
+RwTexture *RpMatFXMaterialGetBumpMapTexture( const RpMaterial *material );
+RwTexture *RpMatFXMaterialGetBumpMapBumpedTexture( const RpMaterial *material );
+RwFrame *RpMatFXMaterialGetBumpMapFrame( const RpMaterial *material );
+RwReal RpMatFXMaterialGetBumpMapCoefficient( const RpMaterial *material );
+RpMaterial *RpMatFXMaterialSetEnvMapTexture( RpMaterial *material, RwTexture *texture );
+RpMaterial *RpMatFXMaterialSetEnvMapFrame( RpMaterial *material, RwFrame *frame );
+RpMaterial *RpMatFXMaterialSetEnvMapFrameBufferAlpha( RpMaterial *material, RwBool useFrameBufferAlpha );
+RpMaterial *RpMatFXMaterialSetEnvMapCoefficient( RpMaterial *material, RwReal coef );
+RwTexture *RpMatFXMaterialGetEnvMapTexture( const RpMaterial *material );
+RwFrame *RpMatFXMaterialGetEnvMapFrame( const RpMaterial *material );
+RwBool RpMatFXMaterialGetEnvMapFrameBufferAlpha( const RpMaterial *material );
+RwReal RpMatFXMaterialGetEnvMapCoefficient( const RpMaterial *material );
+RpMaterial *RpMatFXMaterialSetDualTexture( RpMaterial *material, RwTexture *texture );
+RpMaterial *RpMatFXMaterialSetDualBlendModes( RpMaterial *material, RwBlendFunction srcBlendMode, RwBlendFunction dstBlendMode );
+RwTexture *RpMatFXMaterialGetDualTexture( const RpMaterial *material );
+const RpMaterial *RpMatFXMaterialGetDualBlendModes( const RpMaterial *material, RwBlendFunction *srcBlendMode, RwBlendFunction *dstBlendMode );
diff --git a/src/fakerw/rpskin.h b/src/fakerw/rpskin.h
new file mode 100644
index 00000000..dd8551ae
--- /dev/null
+++ b/src/fakerw/rpskin.h
@@ -0,0 +1,8 @@
+#pragma once
+
+#include <rphanim.h>
+
+RwBool RpSkinPluginAttach(void);
+
+RpAtomic *RpSkinAtomicSetHAnimHierarchy( RpAtomic *atomic, RpHAnimHierarchy *hierarchy );
+RpHAnimHierarchy *RpSkinAtomicGetHAnimHierarchy( const RpAtomic *atomic );
diff --git a/src/fakerw/rpworld.h b/src/fakerw/rpworld.h
new file mode 100644
index 00000000..f10a3754
--- /dev/null
+++ b/src/fakerw/rpworld.h
@@ -0,0 +1,336 @@
+#pragma once
+
+#define rpATOMIC rw::Atomic::ID
+#define rpCLUMP rw::Clump::ID
+
+/*
+ ***********************************************
+ *
+ * RpMaterial
+ *
+ ***********************************************
+ */
+
+//struct RpMaterial;
+typedef rw::Material RpMaterial;
+
+typedef RpMaterial *(*RpMaterialCallBack)(RpMaterial *material, void *data);
+
+RpMaterial *RpMaterialCreate(void);
+RwBool RpMaterialDestroy(RpMaterial *material);
+RpMaterial *RpMaterialClone(RpMaterial *material);
+RpMaterial *RpMaterialSetTexture(RpMaterial *material, RwTexture *texture);
+RpMaterial *RpMaterialAddRef(RpMaterial *material);
+RwTexture *RpMaterialGetTexture(const RpMaterial *material);
+RpMaterial *RpMaterialSetColor(RpMaterial *material, const RwRGBA *color);
+const RwRGBA *RpMaterialGetColor(const RpMaterial *material);
+RpMaterial *RpMaterialSetSurfaceProperties(RpMaterial *material, const RwSurfaceProperties *surfaceProperties);
+const RwSurfaceProperties *RpMaterialGetSurfaceProperties(const RpMaterial *material);
+RwInt32 RpMaterialRegisterPlugin(RwInt32 size, RwUInt32 pluginID, RwPluginObjectConstructor constructCB, RwPluginObjectDestructor destructCB, RwPluginObjectCopy copyCB);
+RwInt32 RpMaterialRegisterPluginStream(RwUInt32 pluginID, RwPluginDataChunkReadCallBack readCB, RwPluginDataChunkWriteCallBack writeCB, RwPluginDataChunkGetSizeCallBack getSizeCB);
+RwInt32 RpMaterialSetStreamAlwaysCallBack(RwUInt32 pluginID, RwPluginDataChunkAlwaysCallBack alwaysCB);
+RwInt32 RpMaterialGetPluginOffset(RwUInt32 pluginID);
+RwBool RpMaterialValidatePlugins(const RpMaterial *material);
+RwUInt32 RpMaterialStreamGetSize(const RpMaterial *material);
+RpMaterial *RpMaterialStreamRead(RwStream *stream);
+const RpMaterial *RpMaterialStreamWrite(const RpMaterial *material, RwStream *stream);
+//RpMaterialChunkInfo *_rpMaterialChunkInfoRead(RwStream *stream,  RpMaterialChunkInfo *materialChunkInfo, RwInt32 *bytesRead);
+
+
+/*
+ ***********************************************
+ *
+ * RpLight
+ *
+ ***********************************************
+ */
+
+//struct RpLight;
+typedef rw::Light RpLight;
+
+enum RpLightType
+{
+	rpNALIGHTTYPE = 0,
+	rpLIGHTDIRECTIONAL,
+	rpLIGHTAMBIENT,
+	rpLIGHTPOINT = 0x80,
+	rpLIGHTSPOT,
+	rpLIGHTSPOTSOFT,
+};
+
+enum RpLightFlag
+{
+	rpLIGHTLIGHTATOMICS = 0x01,
+	rpLIGHTLIGHTWORLD = 0x02,
+};
+
+typedef RpLight    *(*RpLightCallBack) (RpLight * light, void *data);
+
+RwReal RpLightGetRadius(const RpLight *light);
+const RwRGBAReal *RpLightGetColor(const RpLight *light);
+RpLight *RpLightSetFrame(RpLight *light, RwFrame *frame);
+RwFrame *RpLightGetFrame(const RpLight *light);
+RpLightType RpLightGetType(const RpLight *light);
+RpLight *RpLightSetFlags(RpLight *light, RwUInt32 flags);
+RwUInt32 RpLightGetFlags(const RpLight *light);
+RpLight *RpLightCreate(RwInt32 type);
+RwBool RpLightDestroy(RpLight *light);
+RpLight *RpLightSetRadius(RpLight *light, RwReal radius);
+RpLight *RpLightSetColor(RpLight *light, const RwRGBAReal *color);
+RwReal RpLightGetConeAngle(const RpLight *light);
+RpLight *RpLightSetConeAngle(RpLight * ight, RwReal angle);
+RwUInt32 RpLightStreamGetSize(const RpLight *light);
+RpLight *RpLightStreamRead(RwStream *stream);
+const RpLight *RpLightStreamWrite(const RpLight *light, RwStream *stream);
+//RpLightChunkInfo *_rpLightChunkInfoRead(RwStream *stream, RpLightChunkInfo *lightChunkInfo, RwInt32 *bytesRead);
+RwInt32 RpLightRegisterPlugin(RwInt32 size, RwUInt32 pluginID, RwPluginObjectConstructor constructCB, RwPluginObjectDestructor destructCB, RwPluginObjectCopy copyCB);
+RwInt32 RpLightRegisterPluginStream(RwUInt32 pluginID, RwPluginDataChunkReadCallBack readCB, RwPluginDataChunkWriteCallBack writeCB, RwPluginDataChunkGetSizeCallBack getSizeCB);
+RwInt32 RpLightSetStreamAlwaysCallBack(RwUInt32 pluginID, RwPluginDataChunkAlwaysCallBack alwaysCB);
+RwInt32 RpLightGetPluginOffset(RwUInt32 pluginID);
+RwBool RpLightValidatePlugins(const RpLight * light);
+
+/*
+ ***********************************************
+ *
+ * RpGeometry
+ *
+ ***********************************************
+ */
+
+typedef rw::Triangle RpTriangle;
+
+//struct RpGeometry;
+typedef rw::Geometry RpGeometry;
+//struct RpMorphTarget;
+typedef rw::MorphTarget RpMorphTarget;
+
+enum RpGeometryFlag
+{
+	rpGEOMETRYTRISTRIP  = rw::Geometry::TRISTRIP,
+	rpGEOMETRYPOSITIONS = rw::Geometry::POSITIONS,
+	rpGEOMETRYTEXTURED  = rw::Geometry::TEXTURED,
+	rpGEOMETRYPRELIT    = rw::Geometry::PRELIT,
+	rpGEOMETRYNORMALS   = rw::Geometry::NORMALS,
+	rpGEOMETRYLIGHT     = rw::Geometry::LIGHT,
+	rpGEOMETRYMODULATEMATERIALCOLOR = rw::Geometry::MODULATE,
+	rpGEOMETRYTEXTURED2 = rw::Geometry::TEXTURED2,
+	rpGEOMETRYNATIVE            = rw::Geometry::NATIVE,
+	rpGEOMETRYNATIVEINSTANCE    = rw::Geometry::NATIVEINSTANCE,
+	rpGEOMETRYFLAGSMASK         = 0x000000FF,
+	rpGEOMETRYNATIVEFLAGSMASK   = 0x0F000000,
+};
+
+enum RpGeometryLockMode
+{
+	rpGEOMETRYLOCKPOLYGONS     = rw::Geometry::LOCKPOLYGONS,
+	rpGEOMETRYLOCKVERTICES     = rw::Geometry::LOCKVERTICES,
+	rpGEOMETRYLOCKNORMALS      = rw::Geometry::LOCKNORMALS,
+	rpGEOMETRYLOCKPRELIGHT     = rw::Geometry::LOCKPRELIGHT,
+	rpGEOMETRYLOCKTEXCOORDS    = rw::Geometry::LOCKTEXCOORDS,
+	rpGEOMETRYLOCKTEXCOORDS1   = rw::Geometry::LOCKTEXCOORDS1,
+	rpGEOMETRYLOCKTEXCOORDS2   = rw::Geometry::LOCKTEXCOORDS2,
+	rpGEOMETRYLOCKTEXCOORDS3   = rw::Geometry::LOCKTEXCOORDS3,
+	rpGEOMETRYLOCKTEXCOORDS4   = rw::Geometry::LOCKTEXCOORDS4,
+	rpGEOMETRYLOCKTEXCOORDS5   = rw::Geometry::LOCKTEXCOORDS5,
+	rpGEOMETRYLOCKTEXCOORDS6   = rw::Geometry::LOCKTEXCOORDS6,
+	rpGEOMETRYLOCKTEXCOORDS7   = rw::Geometry::LOCKTEXCOORDS7,
+	rpGEOMETRYLOCKTEXCOORDS8   = rw::Geometry::LOCKTEXCOORDS8,
+	rpGEOMETRYLOCKTEXCOORDSALL = rw::Geometry::LOCKTEXCOORDSALL,
+	rpGEOMETRYLOCKALL          = rw::Geometry::LOCKALL
+};
+
+RpGeometry  *RpGeometryCreate(RwInt32 numVert, RwInt32 numTriangles, RwUInt32 format);
+RwBool RpGeometryDestroy(RpGeometry *geometry);
+RpGeometry *_rpGeometryAddRef(RpGeometry *geometry);
+RpGeometry  *RpGeometryLock(RpGeometry *geometry, RwInt32 lockMode);
+RpGeometry  *RpGeometryUnlock(RpGeometry *geometry);
+RpGeometry  *RpGeometryTransform(RpGeometry *geometry, const RwMatrix *matrix);
+RpGeometry  *RpGeometryCreateSpace(RwReal radius);
+RpMorphTarget  *RpMorphTargetSetBoundingSphere(RpMorphTarget *morphTarget, const RwSphere *boundingSphere);
+RwSphere  *RpMorphTargetGetBoundingSphere(RpMorphTarget *morphTarget);
+const RpMorphTarget  *RpMorphTargetCalcBoundingSphere(const RpMorphTarget *morphTarget, RwSphere *boundingSphere);
+RwInt32 RpGeometryAddMorphTargets(RpGeometry *geometry, RwInt32 mtcount);
+RwInt32 RpGeometryAddMorphTarget(RpGeometry *geometry);
+RpGeometry  *RpGeometryRemoveMorphTarget(RpGeometry *geometry, RwInt32 morphTarget);
+RwInt32 RpGeometryGetNumMorphTargets(const RpGeometry *geometry);
+RpMorphTarget  *RpGeometryGetMorphTarget(const RpGeometry *geometry, RwInt32 morphTarget);
+RwRGBA  *RpGeometryGetPreLightColors(const RpGeometry *geometry);
+RwTexCoords  *RpGeometryGetVertexTexCoords(const RpGeometry *geometry, RwTextureCoordinateIndex uvIndex);
+RwInt32 RpGeometryGetNumTexCoordSets(const RpGeometry *geometry);
+RwInt32 RpGeometryGetNumVertices (const RpGeometry *geometry);
+RwV3d  *RpMorphTargetGetVertices(const RpMorphTarget *morphTarget);
+RwV3d  *RpMorphTargetGetVertexNormals(const RpMorphTarget *morphTarget);
+RpTriangle  *RpGeometryGetTriangles(const RpGeometry *geometry);
+RwInt32 RpGeometryGetNumTriangles(const RpGeometry *geometry);
+RpMaterial  *RpGeometryGetMaterial(const RpGeometry *geometry, RwInt32 matNum);
+const RpGeometry  *RpGeometryTriangleSetVertexIndices(const RpGeometry *geometry, RpTriangle *triangle, RwUInt16 vert1, RwUInt16 vert2, RwUInt16 vert3);
+RpGeometry  *RpGeometryTriangleSetMaterial(RpGeometry *geometry, RpTriangle *triangle, RpMaterial *material);
+const RpGeometry  *RpGeometryTriangleGetVertexIndices(const RpGeometry *geometry, const RpTriangle *triangle, RwUInt16 *vert1, RwUInt16 *vert2, RwUInt16 *vert3);
+RpMaterial   *RpGeometryTriangleGetMaterial(const RpGeometry *geometry, const RpTriangle *triangle);
+RwInt32 RpGeometryGetNumMaterials(const RpGeometry *geometry);
+RpGeometry  *RpGeometryForAllMaterials(RpGeometry *geometry, RpMaterialCallBack fpCallBack, void *pData);
+//const RpGeometry  *RpGeometryForAllMeshes(const RpGeometry *geometry, RpMeshCallBack fpCallBack, void *pData);
+RwInt32 RpGeometryRegisterPlugin(RwInt32 size, RwUInt32 pluginID, RwPluginObjectConstructor constructCB, RwPluginObjectDestructor destructCB, RwPluginObjectCopy copyCB);
+RwInt32 RpGeometryRegisterPluginStream(RwUInt32 pluginID, RwPluginDataChunkReadCallBack readCB, RwPluginDataChunkWriteCallBack writeCB, RwPluginDataChunkGetSizeCallBack getSizeCB);
+RwInt32 RpGeometrySetStreamAlwaysCallBack(RwUInt32 pluginID, RwPluginDataChunkAlwaysCallBack alwaysCB);
+RwInt32 RpGeometryGetPluginOffset(RwUInt32 pluginID);
+RwBool RpGeometryValidatePlugins(const RpGeometry *geometry);
+RwUInt32 RpGeometryStreamGetSize(const RpGeometry *geometry);
+const RpGeometry  *RpGeometryStreamWrite(const RpGeometry *geometry, RwStream *stream);
+RpGeometry  *RpGeometryStreamRead(RwStream *stream);
+//RpGeometryChunkInfo *_rpGeometryChunkInfoRead(RwStream *stream, RpGeometryChunkInfo *geometryChunkInfo, RwInt32 *bytesRead);
+RwUInt32 RpGeometryGetFlags(const RpGeometry *geometry);
+RpGeometry  *RpGeometrySetFlags(RpGeometry *geometry, RwUInt32 flags);
+const RwSurfaceProperties *_rpGeometryGetSurfaceProperties(const RpGeometry *geometry);
+RpGeometry *_rpGeometrySetSurfaceProperties(RpGeometry *geometry, const RwSurfaceProperties *surfaceProperties);
+
+
+/*
+ ***********************************************
+ *
+ * RpAtomic and RpClump
+ *
+ ***********************************************
+ */
+
+//struct RpAtomic;
+typedef rw::Atomic RpAtomic;
+
+enum RpAtomicFlag
+{
+	rpATOMICCOLLISIONTEST = 0x01,
+	rpATOMICRENDER = 0x04,
+};
+
+enum RpAtomicSetGeomFlag
+{
+	rpATOMICSAMEBOUNDINGSPHERE = 0x01,
+};
+
+typedef RpAtomic   *(*RpAtomicCallBack) (RpAtomic * atomic, void *data);
+typedef RpAtomic   *(*RpAtomicCallBackRender) (RpAtomic * atomic);
+
+
+//struct RpClump;
+typedef rw::Clump RpClump;
+
+struct RpClumpChunkInfo
+{
+	RwInt32             numAtomics;
+	RwInt32             numLights;
+	RwInt32             numCameras;
+};
+
+typedef RpClump    *(*RpClumpCallBack) (RpClump * clump, void *data);
+
+
+RpAtomic *AtomicDefaultRenderCallBack(RpAtomic * atomic);
+//void _rpAtomicResyncInterpolatedSphere(RpAtomic * atomic);
+//const RwSphere *RpAtomicGetWorldBoundingSphere(RpAtomic *  atomic);
+
+RwFrame *RpClumpGetFrame(const RpClump * clump);
+RpClump *RpClumpSetFrame(RpClump * clump, RwFrame * frame);
+RpClump *RpClumpForAllAtomics(RpClump * clump, RpAtomicCallBack callback, void *pData);
+RpClump *RpClumpForAllLights(RpClump * clump, RpLightCallBack callback, void *pData);
+RpClump *RpClumpForAllCameras(RpClump * clump, RwCameraCallBack callback, void *pData);
+RpClump *RpClumpCreateSpace(const RwV3d * position, RwReal radius);
+RpClump *RpClumpRender(RpClump * clump);
+RpClump *RpClumpRemoveAtomic(RpClump * clump, RpAtomic * atomic);
+RpClump *RpClumpAddAtomic(RpClump * clump, RpAtomic * atomic);
+RpClump *RpClumpRemoveLight(RpClump * clump, RpLight * light);
+RpClump *RpClumpAddLight(RpClump * clump, RpLight * light);
+RpClump *RpClumpRemoveCamera(RpClump * clump, RwCamera * camera);
+RpClump *RpClumpAddCamera(RpClump * clump, RwCamera * camera);
+RwBool RpClumpDestroy(RpClump * clump);
+RpClump *RpClumpCreate(void);
+RpClump *RpClumpClone(RpClump * clump);
+RpClump *RpClumpSetCallBack(RpClump * clump, RpClumpCallBack callback);
+RpClumpCallBack RpClumpGetCallBack(const RpClump * clump);
+RwInt32 RpClumpGetNumAtomics(RpClump * clump);
+RwInt32 RpClumpGetNumLights(RpClump * clump);
+RwInt32 RpClumpGetNumCameras(RpClump * clump);
+RwUInt32 RpClumpStreamGetSize(RpClump * clump);
+RpClump *RpClumpStreamRead(RwStream * stream);
+RpClump *RpClumpStreamWrite(RpClump * clump, RwStream * stream);
+RwInt32 RpClumpRegisterPlugin(RwInt32 size, RwUInt32 pluginID, RwPluginObjectConstructor constructCB, RwPluginObjectDestructor destructCB, RwPluginObjectCopy copyCB);
+RwInt32 RpClumpRegisterPluginStream(RwUInt32 pluginID, RwPluginDataChunkReadCallBack  readCB, RwPluginDataChunkWriteCallBack writeCB, RwPluginDataChunkGetSizeCallBack getSizeCB);
+RwInt32 RpClumpSetStreamAlwaysCallBack(RwUInt32 pluginID, RwPluginDataChunkAlwaysCallBack alwaysCB);
+RwInt32 RpClumpGetPluginOffset(RwUInt32 pluginID);
+RwBool RpClumpValidatePlugins(const RpClump * clump);
+
+RpAtomic *RpAtomicCreate(void);
+RwBool RpAtomicDestroy(RpAtomic * atomic);
+RpAtomic *RpAtomicClone(RpAtomic * atomic);
+RpAtomic *RpAtomicSetFrame(RpAtomic * atomic, RwFrame * frame);
+RpAtomic *RpAtomicSetGeometry(RpAtomic * atomic, RpGeometry * geometry, RwUInt32 flags);
+
+RwFrame *RpAtomicGetFrame(const RpAtomic * atomic);
+RpAtomic *RpAtomicSetFlags(RpAtomic * atomic, RwUInt32 flags);
+RwUInt32 RpAtomicGetFlags(const RpAtomic * atomic);
+RwSphere *RpAtomicGetBoundingSphere(RpAtomic * atomic);
+RpAtomic *RpAtomicRender(RpAtomic * atomic);
+RpClump *RpAtomicGetClump(const RpAtomic * atomic);
+//RpInterpolator *RpAtomicGetInterpolator(RpAtomic * atomic);
+RpGeometry *RpAtomicGetGeometry(const RpAtomic * atomic);
+void RpAtomicSetRenderCallBack(RpAtomic * atomic, RpAtomicCallBackRender callback);
+RpAtomicCallBackRender RpAtomicGetRenderCallBack(const RpAtomic * atomic);
+RwBool RpAtomicInstance(RpAtomic *atomic);
+RwUInt32 RpAtomicStreamGetSize(RpAtomic * atomic);
+RpAtomic *RpAtomicStreamRead(RwStream * stream);
+RpAtomic *RpAtomicStreamWrite(RpAtomic * atomic, RwStream * stream);
+RwInt32 RpAtomicRegisterPlugin(RwInt32 size, RwUInt32 pluginID, RwPluginObjectConstructor constructCB, RwPluginObjectDestructor destructCB, RwPluginObjectCopy copyCB);
+RwInt32 RpAtomicRegisterPluginStream(RwUInt32 pluginID, RwPluginDataChunkReadCallBack readCB, RwPluginDataChunkWriteCallBack writeCB, RwPluginDataChunkGetSizeCallBack getSizeCB);
+RwInt32 RpAtomicSetStreamAlwaysCallBack(RwUInt32 pluginID, RwPluginDataChunkAlwaysCallBack alwaysCB);
+RwInt32 RpAtomicSetStreamRightsCallBack(RwUInt32 pluginID, RwPluginDataChunkRightsCallBack rightsCB);
+RwInt32 RpAtomicGetPluginOffset(RwUInt32 pluginID);
+RwBool RpAtomicValidatePlugins(const RpAtomic * atomic);
+
+//RwInt32 RpInterpolatorGetEndMorphTarget(const RpInterpolator * interpolator);
+//RwInt32 RpInterpolatorGetStartMorphTarget(const RpInterpolator * interpolator);
+//RwReal RpInterpolatorGetValue(const RpInterpolator * interpolator);
+//RwReal RpInterpolatorGetScale(const RpInterpolator * interpolator);
+//RpInterpolator *RpInterpolatorSetEndMorphTarget(RpInterpolator * interpolator, RwInt32 morphTarget, RpAtomic * atomic);
+//RpInterpolator *RpInterpolatorSetStartMorphTarget(RpInterpolator * interpolator, RwInt32 morphTarget, RpAtomic * atomic);
+//RpInterpolator *RpInterpolatorSetValue(RpInterpolator *  interpolator, RwReal value, RpAtomic *atomic);
+//RpInterpolator *RpInterpolatorSetScale(RpInterpolator * interpolator, RwReal scale, RpAtomic *atomic);
+
+
+RpClump *RpLightGetClump(const RpLight *light);
+RpClump *RwCameraGetClump(const RwCamera *camera);
+
+/*
+ ***********************************************
+ *
+ * RpWorld
+ *
+ ***********************************************
+ */
+
+//struct RpWorld;
+typedef rw::World RpWorld;
+
+RwBool       RpWorldDestroy(RpWorld * world);
+RpWorld     *RpWorldCreate(RwBBox * boundingBox);
+
+RwBool       RpWorldPluginAttach(void);
+
+RpWorld *RpWorldRemoveCamera(RpWorld *world, RwCamera *camera);
+RpWorld *RpWorldAddCamera(RpWorld *world, RwCamera *camera);
+RpWorld *RwCameraGetWorld(const RwCamera *camera);
+RpWorld *RpWorldRemoveAtomic(RpWorld *world, RpAtomic *atomic);
+RpWorld *RpWorldAddAtomic(RpWorld *world, RpAtomic *atomic);
+RpWorld *RpAtomicGetWorld(const RpAtomic *atomic);
+RpWorld *RpWorldAddClump(RpWorld *world, RpClump *clump);
+RpWorld *RpWorldRemoveClump(RpWorld *world, RpClump *clump);
+RpWorld *RpClumpGetWorld(const RpClump *clump);
+RpWorld *RpWorldAddLight(RpWorld *world, RpLight *light);
+RpWorld *RpWorldRemoveLight(RpWorld *world, RpLight *light);
+RpWorld *RpLightGetWorld(const RpLight *light);
+RwCamera *RwCameraForAllClumpsInFrustum(RwCamera *camera, void *data);
+RwCamera *RwCameraForAllClumpsNotInFrustum(RwCamera *camera, RwInt32 numClumps, void *data);
+//RwCamera *RwCameraForAllSectorsInFrustum(RwCamera *camera, RpWorldSectorCallBack callBack, void *pData);
+//RpLight *RpLightForAllWorldSectors(RpLight *light, RpWorldSectorCallBack callback, void *data);
+//RpAtomic *RpAtomicForAllWorldSectors(RpAtomic *atomic, RpWorldSectorCallBack callback, void *data);
+//RpWorldSector *RpWorldSectorForAllAtomics(RpWorldSector *sector, RpAtomicCallBack callback, void *data);
+//RpWorldSector *RpWorldSectorForAllCollisionAtomics(RpWorldSector *sector, RpAtomicCallBack callback, void *data);
+//RpWorldSector *RpWorldSectorForAllLights(RpWorldSector *sector, RpLightCallBack callback, void *data);
diff --git a/src/fakerw/rtbmp.h b/src/fakerw/rtbmp.h
new file mode 100644
index 00000000..896d276b
--- /dev/null
+++ b/src/fakerw/rtbmp.h
@@ -0,0 +1,4 @@
+#pragma once
+
+RwImage *RtBMPImageWrite(RwImage * image, const RwChar * imageName);
+RwImage *RtBMPImageRead(const RwChar * imageName);
diff --git a/src/fakerw/rwcore.h b/src/fakerw/rwcore.h
new file mode 100644
index 00000000..22e29737
--- /dev/null
+++ b/src/fakerw/rwcore.h
@@ -0,0 +1,413 @@
+#pragma once
+
+#define RWCORE_H	// needed by CVector
+
+#include <rw.h>
+
+#include <rwplcore.h>
+
+/*
+ ***********************************************
+ *
+ * RwIm2D and RwIm3D
+ *
+ ***********************************************
+ */
+
+typedef rw::RWDEVICE::Im2DVertex RwIm2DVertex;
+typedef rw::RWDEVICE::Im3DVertex RwIm3DVertex;
+typedef RwUInt16 RwImVertexIndex;
+
+enum RwIm3DTransformFlags
+{
+	rwIM3D_VERTEXUV      = 1,
+	rwIM3D_ALLOPAQUE     = 2,
+	rwIM3D_NOCLIP        = 4,
+	rwIM3D_VERTEXXYZ     = 8,
+	rwIM3D_VERTEXRGBA    = 16,
+};
+
+void RwIm2DVertexSetCameraX(RwIm2DVertex *vert, RwReal camx);
+void RwIm2DVertexSetCameraY(RwIm2DVertex *vert, RwReal camy);
+void RwIm2DVertexSetCameraZ(RwIm2DVertex *vert, RwReal camz);
+void RwIm2DVertexSetRecipCameraZ(RwIm2DVertex *vert, RwReal recipz);
+void RwIm2DVertexSetScreenX(RwIm2DVertex *vert, RwReal scrnx);
+void RwIm2DVertexSetScreenY(RwIm2DVertex *vert, RwReal scrny);
+void RwIm2DVertexSetScreenZ(RwIm2DVertex *vert, RwReal scrnz);
+void RwIm2DVertexSetU(RwIm2DVertex *vert, RwReal texU, RwReal recipz);
+void RwIm2DVertexSetV(RwIm2DVertex *vert, RwReal texV, RwReal recipz);
+void RwIm2DVertexSetIntRGBA(RwIm2DVertex *vert, RwUInt8 red, RwUInt8 green, RwUInt8 blue, RwUInt8 alpha);
+
+RwReal RwIm2DGetNearScreenZ(void);
+RwReal RwIm2DGetFarScreenZ(void);
+RwBool RwIm2DRenderLine(RwIm2DVertex *vertices, RwInt32 numVertices, RwInt32 vert1, RwInt32 vert2);
+RwBool RwIm2DRenderTriangle(RwIm2DVertex *vertices, RwInt32 numVertices, RwInt32 vert1, RwInt32 vert2, RwInt32 vert3 );
+RwBool RwIm2DRenderPrimitive(RwPrimitiveType primType, RwIm2DVertex *vertices, RwInt32 numVertices);
+RwBool RwIm2DRenderIndexedPrimitive(RwPrimitiveType primType, RwIm2DVertex *vertices, RwInt32 numVertices, RwImVertexIndex *indices, RwInt32 numIndices);
+
+
+void RwIm3DVertexSetPos(RwIm3DVertex *vert, RwReal x, RwReal y, RwReal z);
+void RwIm3DVertexSetU(RwIm3DVertex *vert, RwReal u);
+void RwIm3DVertexSetV(RwIm3DVertex *vert, RwReal v);
+void RwIm3DVertexSetRGBA(RwIm3DVertex *vert, RwUInt8 r, RwUInt8 g, RwUInt8 b, RwUInt8 a);
+
+void  *RwIm3DTransform(RwIm3DVertex *pVerts, RwUInt32 numVerts, RwMatrix *ltm, RwUInt32 flags);
+RwBool RwIm3DEnd(void);
+RwBool RwIm3DRenderLine(RwInt32 vert1, RwInt32 vert2);
+RwBool RwIm3DRenderTriangle(RwInt32 vert1, RwInt32 vert2, RwInt32 vert3);
+RwBool RwIm3DRenderIndexedPrimitive(RwPrimitiveType primType, RwImVertexIndex *indices, RwInt32 numIndices);
+RwBool RwIm3DRenderPrimitive(RwPrimitiveType primType);
+
+
+/*
+ ***********************************************
+ *
+ * RwRaster
+ *
+ ***********************************************
+ */
+
+//struct RwRaster;
+typedef rw::Raster RwRaster;
+
+enum RwRasterType
+{
+	rwRASTERTYPENORMAL = rw::Raster::NORMAL,
+	rwRASTERTYPEZBUFFER = rw::Raster::ZBUFFER,
+	rwRASTERTYPECAMERA = rw::Raster::CAMERA,
+	rwRASTERTYPETEXTURE = rw::Raster::TEXTURE,
+	rwRASTERTYPECAMERATEXTURE = rw::Raster::CAMERATEXTURE,
+	rwRASTERTYPEMASK = 0x07,
+	rwRASTERDONTALLOCATE = rw::Raster::DONTALLOCATE,
+};
+
+enum RwRasterFormat
+{
+	rwRASTERFORMATDEFAULT = rw::Raster::DEFAULT,
+	rwRASTERFORMAT1555 = rw::Raster::C1555,
+	rwRASTERFORMAT565 = rw::Raster::C565,
+	rwRASTERFORMAT4444 = rw::Raster::C4444,
+	rwRASTERFORMATLUM8 = rw::Raster::LUM8,
+	rwRASTERFORMAT8888 = rw::Raster::C8888,
+	rwRASTERFORMAT888 = rw::Raster::C888,
+	rwRASTERFORMAT16 = rw::Raster::D16,
+	rwRASTERFORMAT24 = rw::Raster::D24,
+	rwRASTERFORMAT32 = rw::Raster::D32,
+	rwRASTERFORMAT555 = rw::Raster::C555,
+
+	rwRASTERFORMATAUTOMIPMAP = rw::Raster::AUTOMIPMAP,
+	rwRASTERFORMATPAL8 = rw::Raster::PAL8,
+	rwRASTERFORMATPAL4 = rw::Raster::PAL4,
+	rwRASTERFORMATMIPMAP = rw::Raster::MIPMAP,
+
+	rwRASTERFORMATPIXELFORMATMASK = 0x0f00,
+	rwRASTERFORMATMASK = 0xff00
+};
+
+enum RwRasterFlipMode
+{
+	rwRASTERFLIPDONTWAIT = 0,
+	rwRASTERFLIPWAITVSYNC = 1,
+};
+
+RwRaster    *RwRasterCreate(RwInt32 width, RwInt32 height, RwInt32 depth, RwInt32 flags);
+RwBool       RwRasterDestroy(RwRaster * raster);
+RwInt32      RwRasterGetWidth(const RwRaster *raster);
+RwInt32      RwRasterGetHeight(const RwRaster *raster);
+RwInt32      RwRasterGetStride(const RwRaster *raster);
+RwInt32      RwRasterGetDepth(const RwRaster *raster);
+RwInt32      RwRasterGetFormat(const RwRaster *raster);
+RwInt32      RwRasterGetType(const RwRaster *raster);
+RwRaster    *RwRasterGetParent(const RwRaster *raster);
+RwRaster    *RwRasterGetOffset(RwRaster *raster,  RwInt16 *xOffset, RwInt16 *yOffset);
+RwInt32      RwRasterGetNumLevels(RwRaster * raster);
+RwRaster    *RwRasterSubRaster(RwRaster * subRaster, RwRaster * raster, RwRect * rect);
+RwRaster    *RwRasterRenderFast(RwRaster * raster, RwInt32 x, RwInt32 y);
+RwRaster    *RwRasterRender(RwRaster * raster, RwInt32 x, RwInt32 y);
+RwRaster    *RwRasterRenderScaled(RwRaster * raster, RwRect * rect);
+RwRaster    *RwRasterPushContext(RwRaster * raster);
+RwRaster    *RwRasterPopContext(void);
+RwRaster    *RwRasterGetCurrentContext(void);
+RwBool       RwRasterClear(RwInt32 pixelValue);
+RwBool       RwRasterClearRect(RwRect * rpRect, RwInt32 pixelValue);
+RwRaster    *RwRasterShowRaster(RwRaster * raster, void *dev, RwUInt32 flags);
+RwUInt8     *RwRasterLock(RwRaster * raster, RwUInt8 level, RwInt32 lockMode);
+RwRaster    *RwRasterUnlock(RwRaster * raster);
+RwUInt8     *RwRasterLockPalette(RwRaster * raster, RwInt32 lockMode);
+RwRaster    *RwRasterUnlockPalette(RwRaster * raster);
+RwInt32      RwRasterRegisterPlugin(RwInt32 size, RwUInt32 pluginID, RwPluginObjectConstructor constructCB, RwPluginObjectDestructor destructCB, RwPluginObjectCopy copyCB);
+RwInt32      RwRasterGetPluginOffset(RwUInt32 pluginID);
+RwBool       RwRasterValidatePlugins(const RwRaster * raster);
+
+
+/*
+ ***********************************************
+ *
+ * RwImage
+ *
+ ***********************************************
+ */
+
+//struct RwImage;
+typedef rw::Image RwImage;
+
+RwImage     *RwImageCreate(RwInt32 width, RwInt32 height, RwInt32 depth);
+RwBool       RwImageDestroy(RwImage * image);
+RwImage     *RwImageAllocatePixels(RwImage * image);
+RwImage     *RwImageFreePixels(RwImage * image);
+RwImage     *RwImageCopy(RwImage * destImage, const RwImage * sourceImage);
+RwImage     *RwImageResize(RwImage * image, RwInt32 width, RwInt32 height);
+RwImage     *RwImageApplyMask(RwImage * image, const RwImage * mask);
+RwImage     *RwImageMakeMask(RwImage * image);
+RwImage     *RwImageReadMaskedImage(const RwChar * imageName, const RwChar * maskname);
+RwImage     *RwImageRead(const RwChar * imageName);
+RwImage     *RwImageWrite(RwImage * image, const RwChar * imageName);
+RwChar      *RwImageGetPath(void);
+const RwChar *RwImageSetPath(const RwChar * path);
+RwImage     *RwImageSetStride(RwImage * image, RwInt32 stride);
+RwImage     *RwImageSetPixels(RwImage * image, RwUInt8 * pixels);
+RwImage     *RwImageSetPalette(RwImage * image, RwRGBA * palette);
+RwInt32      RwImageGetWidth(const RwImage * image);
+RwInt32      RwImageGetHeight(const RwImage * image);
+RwInt32      RwImageGetDepth(const RwImage * image);
+RwInt32      RwImageGetStride(const RwImage * image);
+RwUInt8     *RwImageGetPixels(const RwImage * image);
+RwRGBA      *RwImageGetPalette(const RwImage * image);
+RwUInt32     RwRGBAToPixel(RwRGBA * rgbIn, RwInt32 rasterFormat);
+RwRGBA      *RwRGBASetFromPixel(RwRGBA * rgbOut, RwUInt32 pixelValue, RwInt32 rasterFormat);
+RwBool       RwImageSetGamma(RwReal gammaValue);
+RwReal       RwImageGetGamma(void);
+RwImage     *RwImageGammaCorrect(RwImage * image);
+RwRGBA      *RwRGBAGammaCorrect(RwRGBA * rgb);
+RwInt32      RwImageRegisterPlugin(RwInt32 size, RwUInt32 pluginID, RwPluginObjectConstructor constructCB, RwPluginObjectDestructor destructCB, RwPluginObjectCopy copyCB);
+RwInt32      RwImageGetPluginOffset(RwUInt32 pluginID);
+RwBool       RwImageValidatePlugins(const RwImage * image);
+//RwBool       RwImageRegisterImageFormat(const RwChar * extension, RwImageCallBackRead imageRead, RwImageCallBackWrite imageWrite);
+const RwChar *RwImageFindFileType(const RwChar * imageName);
+RwInt32      RwImageStreamGetSize(const RwImage * image);
+RwImage     *RwImageStreamRead(RwStream * stream);
+const RwImage *RwImageStreamWrite(const RwImage * image, RwStream * stream);
+
+
+/*
+ ***********************************************
+ *
+ * RwTexture
+ *
+ ***********************************************
+ */
+
+//struct RwTexture;
+typedef rw::Texture RwTexture;
+//struct RwTexDictionary;
+typedef rw::TexDictionary RwTexDictionary;
+
+typedef RwTexture *(*RwTextureCallBackRead)(const RwChar *name, const RwChar *maskName);
+typedef RwTexture *(*RwTextureCallBack)(RwTexture *texture, void *pData);
+typedef RwTexDictionary *(*RwTexDictionaryCallBack)(RwTexDictionary *dict, void *data);
+typedef RwRaster *(*RwTextureCallBackMipmapGeneration)(RwRaster * raster, RwImage * image);
+typedef RwBool (*RwTextureCallBackMipmapName)(RwChar *name, RwChar *maskName, RwUInt8 mipLevel, RwInt32 format);
+
+RwTexture *RwTextureCreate(RwRaster * raster);
+RwBool RwTextureDestroy(RwTexture * texture);
+RwTexture *RwTextureAddRef(RwTexture *texture);
+RwBool RwTextureSetMipmapping(RwBool enable);
+RwBool RwTextureGetMipmapping(void);
+RwBool RwTextureSetAutoMipmapping(RwBool enable);
+RwBool RwTextureGetAutoMipmapping(void);
+RwBool RwTextureSetMipmapGenerationCallBack(RwTextureCallBackMipmapGeneration callback);
+RwTextureCallBackMipmapGeneration RwTextureGetMipmapGenerationCallBack(void);
+RwBool RwTextureSetMipmapNameCallBack(RwTextureCallBackMipmapName callback);
+RwTextureCallBackMipmapName RwTextureGetMipmapNameCallBack(void);
+RwBool RwTextureGenerateMipmapName(RwChar * name, RwChar * maskName, RwUInt8 mipLevel, RwInt32 format);
+RwBool RwTextureRasterGenerateMipmaps(RwRaster * raster, RwImage * image);
+RwTextureCallBackRead RwTextureGetReadCallBack(void);
+RwBool RwTextureSetReadCallBack(RwTextureCallBackRead fpCallBack);
+RwTexture *RwTextureSetName(RwTexture * texture, const RwChar * name);
+RwTexture *RwTextureSetMaskName(RwTexture * texture, const RwChar * maskName);
+RwChar *RwTextureGetName(RwTexture *texture);
+RwChar *RwTextureGetMaskName(RwTexture *texture);
+RwTexture *RwTextureSetRaster(RwTexture * texture, RwRaster * raster);
+RwTexture   *RwTextureRead(const RwChar * name, const RwChar * maskName);
+RwRaster *RwTextureGetRaster(const RwTexture *texture);
+RwInt32 RwTextureRegisterPlugin(RwInt32 size, RwUInt32 pluginID, RwPluginObjectConstructor constructCB, RwPluginObjectDestructor destructCB, RwPluginObjectCopy copyCB);
+RwInt32 RwTextureGetPluginOffset(RwUInt32 pluginID);
+RwBool RwTextureValidatePlugins(const RwTexture * texture);
+
+RwTexDictionary *RwTextureGetDictionary(RwTexture *texture);
+RwTexture *RwTextureSetFilterMode(RwTexture *texture, RwTextureFilterMode filtering);
+RwTextureFilterMode RwTextureGetFilterMode(const RwTexture *texture);
+RwTexture *RwTextureSetAddressing(RwTexture *texture, RwTextureAddressMode addressing);
+RwTexture *RwTextureSetAddressingU(RwTexture *texture, RwTextureAddressMode addressing);
+RwTexture *RwTextureSetAddressingV(RwTexture *texture, RwTextureAddressMode addressing);
+RwTextureAddressMode RwTextureGetAddressing(const RwTexture *texture);
+RwTextureAddressMode RwTextureGetAddressingU(const RwTexture *texture);
+RwTextureAddressMode RwTextureGetAddressingV(const RwTexture *texture);
+
+void _rwD3D8TexDictionaryEnableRasterFormatConversion(bool enable);
+
+// hack for reading native textures
+RwBool rwNativeTextureHackRead(RwStream *stream, RwTexture **tex, RwInt32 size);
+
+
+RwTexDictionary *RwTexDictionaryCreate(void);
+RwBool RwTexDictionaryDestroy(RwTexDictionary * dict);
+RwTexture *RwTexDictionaryAddTexture(RwTexDictionary * dict, RwTexture * texture);
+RwTexture *RwTexDictionaryRemoveTexture(RwTexture * texture);
+RwTexture *RwTexDictionaryFindNamedTexture(RwTexDictionary * dict, const RwChar * name);
+RwTexDictionary *RwTexDictionaryGetCurrent(void);
+RwTexDictionary *RwTexDictionarySetCurrent(RwTexDictionary * dict);
+const RwTexDictionary *RwTexDictionaryForAllTextures(const RwTexDictionary * dict, RwTextureCallBack fpCallBack, void *pData);
+RwBool RwTexDictionaryForAllTexDictionaries(RwTexDictionaryCallBack fpCallBack, void *pData);
+RwInt32 RwTexDictionaryRegisterPlugin(RwInt32 size, RwUInt32 pluginID, RwPluginObjectConstructor constructCB, RwPluginObjectDestructor destructCB, RwPluginObjectCopy copyCB);
+RwInt32 RwTexDictionaryGetPluginOffset(RwUInt32 pluginID);
+RwBool RwTexDictionaryValidatePlugins(const RwTexDictionary * dict);
+RwUInt32 RwTexDictionaryStreamGetSize(const RwTexDictionary *texDict);
+RwTexDictionary *RwTexDictionaryStreamRead(RwStream *stream);
+const RwTexDictionary *RwTexDictionaryStreamWrite(const RwTexDictionary *texDict, RwStream *stream);
+
+/* RwImage/RwRaster */
+
+RwImage *RwImageSetFromRaster(RwImage *image, RwRaster *raster);
+RwRaster *RwRasterSetFromImage(RwRaster *raster, RwImage *image);
+RwRGBA *RwRGBAGetRasterPixel(RwRGBA *rgbOut, RwRaster *raster, RwInt32 x, RwInt32 y);
+RwRaster *RwRasterRead(const RwChar *filename);
+RwRaster *RwRasterReadMaskedRaster(const RwChar *filename, const RwChar *maskname);
+RwImage *RwImageFindRasterFormat(RwImage *ipImage,RwInt32 nRasterType, RwInt32 *npWidth,RwInt32 *npHeight, RwInt32 *npDepth,RwInt32 *npFormat);
+
+
+/*
+ ***********************************************
+ *
+ * RwFrame
+ *
+ ***********************************************
+ */
+
+//struct RwFrame;
+typedef rw::Frame RwFrame;
+
+typedef RwFrame *(*RwFrameCallBack)(RwFrame *frame, void *data);
+
+
+RwFrame *RwFrameForAllObjects(RwFrame * frame, RwObjectCallBack callBack, void *data);
+RwFrame *RwFrameTranslate(RwFrame * frame, const RwV3d * v, RwOpCombineType combine);
+RwFrame *RwFrameRotate(RwFrame * frame, const RwV3d * axis, RwReal angle, RwOpCombineType combine);
+RwFrame *RwFrameScale(RwFrame * frame, const RwV3d * v, RwOpCombineType combine);
+RwFrame *RwFrameTransform(RwFrame * frame, const RwMatrix * m, RwOpCombineType combine);
+RwFrame *RwFrameOrthoNormalize(RwFrame * frame);
+RwFrame *RwFrameSetIdentity(RwFrame * frame);
+RwFrame *RwFrameCloneHierarchy(RwFrame * root);
+RwBool RwFrameDestroyHierarchy(RwFrame * frame);
+RwFrame *RwFrameForAllChildren(RwFrame * frame, RwFrameCallBack callBack, void *data);
+RwFrame *RwFrameRemoveChild(RwFrame * child);
+RwFrame *RwFrameAddChild(RwFrame * parent, RwFrame * child);
+RwFrame *RwFrameGetParent(const RwFrame * frame);
+RwFrame *RwFrameGetRoot(const RwFrame * frame);
+RwMatrix *RwFrameGetLTM(RwFrame * frame);
+RwMatrix *RwFrameGetMatrix(RwFrame * frame);
+RwFrame *RwFrameUpdateObjects(RwFrame * frame);
+RwFrame *RwFrameCreate(void);
+RwBool RwFrameInit(RwFrame *frame);
+RwBool RwFrameDeInit(RwFrame *frame);
+RwBool RwFrameDestroy(RwFrame * frame);
+void _rwFrameInit(RwFrame *frame);
+void _rwFrameDeInit(RwFrame *frame);
+RwBool RwFrameDirty(const RwFrame * frame);
+RwInt32 RwFrameCount(RwFrame * frame);
+RwBool RwFrameSetStaticPluginsSize(RwInt32 size);
+RwInt32 RwFrameRegisterPlugin(RwInt32 size, RwUInt32 pluginID, RwPluginObjectConstructor constructCB, RwPluginObjectDestructor destructCB, RwPluginObjectCopy copyCB);
+RwInt32 RwFrameGetPluginOffset(RwUInt32 pluginID);
+RwBool RwFrameValidatePlugins(const RwFrame * frame);
+RwFrame *_rwFrameCloneAndLinkClones(RwFrame * root);
+RwFrame *_rwFramePurgeClone(RwFrame *root);
+
+RwInt32 RwFrameRegisterPluginStream(RwUInt32 pluginID, RwPluginDataChunkReadCallBack readCB, RwPluginDataChunkWriteCallBack writeCB, RwPluginDataChunkGetSizeCallBack getSizeCB);
+RwInt32 RwFrameSetStreamAlwaysCallBack(RwUInt32 pluginID, RwPluginDataChunkAlwaysCallBack alwaysCB);
+
+typedef rw::FrameList_ rwFrameList;
+rwFrameList *rwFrameListInitialize(rwFrameList *frameList, RwFrame *frame);
+RwBool  rwFrameListFindFrame(const rwFrameList *frameList, const RwFrame *frame, RwInt32 *npIndex);
+rwFrameList *rwFrameListDeinitialize(rwFrameList *frameList);
+RwUInt32 rwFrameListStreamGetSize(const rwFrameList *frameList);
+rwFrameList *rwFrameListStreamRead(RwStream *stream, rwFrameList *fl);
+const rwFrameList *rwFrameListStreamWrite(const rwFrameList *frameList, RwStream *stream);
+
+
+typedef rw::BBox RwBBox;
+
+/*
+ ***********************************************
+ *
+ * RwCamera
+ *
+ ***********************************************
+ */
+
+//struct RwCamera;
+typedef rw::Camera RwCamera;
+
+typedef RwCamera *(*RwCameraCallBack)(RwCamera *camera, void *data);
+
+enum RwCameraClearMode
+{
+	rwCAMERACLEARIMAGE = 0x1,
+	rwCAMERACLEARZ = 0x2,
+	rwCAMERACLEARSTENCIL = 0x4
+};
+
+enum RwCameraProjection
+{
+	rwNACAMERAPROJECTION = 0,
+	rwPERSPECTIVE = 1,
+	rwPARALLEL = 2
+};
+
+enum RwFrustumTestResult
+{
+	rwSPHEREOUTSIDE = 0,
+	rwSPHEREBOUNDARY = 1,
+	rwSPHEREINSIDE = 2
+};
+
+RwCamera    *RwCameraBeginUpdate(RwCamera * camera);
+RwCamera    *RwCameraEndUpdate(RwCamera * camera);
+RwCamera    *RwCameraClear(RwCamera * camera, RwRGBA * colour, RwInt32 clearMode);
+RwCamera    *RwCameraShowRaster(RwCamera * camera, void *pDev, RwUInt32 flags);
+RwBool       RwCameraDestroy(RwCamera * camera);
+RwCamera    *RwCameraCreate(void);
+RwCamera    *RwCameraClone(RwCamera * camera);
+RwCamera    *RwCameraSetViewOffset(RwCamera *camera, const RwV2d *offset);
+RwCamera    *RwCameraSetViewWindow(RwCamera *camera, const RwV2d *viewWindow);
+RwCamera    *RwCameraSetProjection(RwCamera *camera, RwCameraProjection projection);
+RwCamera    *RwCameraSetNearClipPlane(RwCamera *camera, RwReal nearClip);
+RwCamera    *RwCameraSetFarClipPlane(RwCamera *camera, RwReal farClip);
+RwInt32      RwCameraRegisterPlugin(RwInt32 size, RwUInt32 pluginID, RwPluginObjectConstructor constructCB, RwPluginObjectDestructor destructCB, RwPluginObjectCopy copyCB);
+RwInt32      RwCameraGetPluginOffset(RwUInt32 pluginID);
+RwBool       RwCameraValidatePlugins(const RwCamera * camera);
+RwFrustumTestResult RwCameraFrustumTestSphere(const RwCamera * camera, const RwSphere * sphere);
+const RwV2d *RwCameraGetViewOffset(const RwCamera *camera);
+RwCamera    *RwCameraSetRaster(RwCamera *camera, RwRaster *raster);
+RwRaster    *RwCameraGetRaster(const RwCamera *camera);
+RwCamera    *RwCameraSetZRaster(RwCamera *camera, RwRaster *zRaster);
+RwRaster    *RwCameraGetZRaster(const RwCamera *camera);
+RwReal       RwCameraGetNearClipPlane(const RwCamera *camera);
+RwReal       RwCameraGetFarClipPlane(const RwCamera *camera);
+RwCamera    *RwCameraSetFogDistance(RwCamera *camera, RwReal fogDistance);
+RwReal       RwCameraGetFogDistance(const RwCamera *camera);
+RwCamera    *RwCameraGetCurrentCamera(void);
+RwCameraProjection RwCameraGetProjection(const RwCamera *camera);
+const RwV2d *RwCameraGetViewWindow(const RwCamera *camera);
+RwMatrix    *RwCameraGetViewMatrix(RwCamera *camera);
+RwCamera    *RwCameraSetFrame(RwCamera *camera, RwFrame *frame);
+RwFrame     *RwCameraGetFrame(const RwCamera *camera);
+
+
+/*
+ *
+ * D3D-engine specific stuff
+ *
+ */
+
+void RwD3D8EngineSetRefreshRate(RwUInt32 refreshRate);
+RwBool RwD3D8DeviceSupportsDXTTexture(void);
diff --git a/src/fakerw/rwplcore.h b/src/fakerw/rwplcore.h
new file mode 100644
index 00000000..79c745b6
--- /dev/null
+++ b/src/fakerw/rwplcore.h
@@ -0,0 +1,498 @@
+#pragma once
+
+typedef rw::int8 RwInt8;
+typedef rw::int16 RwInt16;
+typedef rw::int32 RwInt32;
+typedef rw::uint8 RwUInt8;
+typedef rw::uint16 RwUInt16;
+typedef rw::uint32 RwUInt32;
+typedef rw::float32 RwReal;
+
+typedef char RwChar;
+typedef RwInt32 RwBool;
+
+#define __RWUNUSED__
+
+#ifndef FALSE
+#define FALSE 0
+#endif
+
+#ifndef TRUE
+#define TRUE !FALSE
+#endif
+
+// used for unicode
+#define RWSTRING(x) x
+
+typedef rw::V2d RwV2d;
+
+typedef rw::V3d RwV3d;
+
+typedef rw::Rect RwRect;
+
+typedef rw::Sphere RwSphere;
+
+enum RwTextureCoordinateIndex
+{
+	rwNARWTEXTURECOORDINATEINDEX = 0,
+	rwTEXTURECOORDINATEINDEX0,
+	rwTEXTURECOORDINATEINDEX1,
+	rwTEXTURECOORDINATEINDEX2,
+	rwTEXTURECOORDINATEINDEX3,
+	rwTEXTURECOORDINATEINDEX4,
+	rwTEXTURECOORDINATEINDEX5,
+	rwTEXTURECOORDINATEINDEX6,
+	rwTEXTURECOORDINATEINDEX7,
+};
+
+typedef rw::TexCoords RwTexCoords;
+
+typedef rw::SurfaceProperties RwSurfaceProperties;
+
+#define RWRGBALONG(r,g,b,a)                                             \
+    ((RwUInt32) (((a) << 24) | ((r) << 16) | ((g) << 8) | (b)))
+
+
+#define MAKECHUNKID(vendorID, chunkID) (((vendorID & 0xFFFFFF) << 8) | (chunkID & 0xFF))
+
+enum RwCorePluginID
+{
+	rwID_NAOBJECT               = 0x00,
+	rwID_STRUCT                 = 0x01,
+	rwID_STRING                 = 0x02,
+	rwID_EXTENSION              = 0x03,
+	rwID_CAMERA                 = 0x05,
+	rwID_TEXTURE                = 0x06,
+	rwID_MATERIAL               = 0x07,
+	rwID_MATLIST                = 0x08,
+	rwID_ATOMICSECT             = 0x09,
+	rwID_PLANESECT              = 0x0A,
+	rwID_WORLD                  = 0x0B,
+	rwID_SPLINE                 = 0x0C,
+	rwID_MATRIX                 = 0x0D,
+	rwID_FRAMELIST              = 0x0E,
+	rwID_GEOMETRY               = 0x0F,
+	rwID_CLUMP                  = 0x10,
+	rwID_LIGHT                  = 0x12,
+	rwID_UNICODESTRING          = 0x13,
+	rwID_ATOMIC                 = 0x14,
+	rwID_TEXTURENATIVE          = 0x15,
+	rwID_TEXDICTIONARY          = 0x16,
+	rwID_ANIMDATABASE           = 0x17,
+	rwID_IMAGE                  = 0x18,
+	rwID_SKINANIMATION          = 0x19,
+	rwID_GEOMETRYLIST           = 0x1A,
+	rwID_HANIMANIMATION         = 0x1B,
+	rwID_TEAM                   = 0x1C,
+	rwID_CROWD                  = 0x1D,
+	rwID_DMORPHANIMATION        = 0x1E,
+	rwID_RIGHTTORENDER          = 0x1f,
+	rwID_MTEFFECTNATIVE         = 0x20,
+	rwID_MTEFFECTDICT           = 0x21,
+	rwID_TEAMDICTIONARY         = 0x22,
+	rwID_PITEXDICTIONARY        = 0x23,
+	rwID_TOC                    = 0x24,
+	rwID_PRTSTDGLOBALDATA       = 0x25,
+	/* Insert before MAX and increment MAX */
+	rwID_COREPLUGINIDMAX        = 0x26,
+};
+
+
+/*
+ ***********************************************
+ *
+ * RwObject
+ *
+ ***********************************************
+ */
+
+//struct RwObject;
+typedef rw::Object RwObject;
+
+typedef RwObject *(*RwObjectCallBack)(RwObject *object, void *data);
+
+RwUInt8 RwObjectGetType(const RwObject *obj);
+
+
+
+#define rwsprintf   sprintf
+#define rwvsprintf  vsprintf
+#define rwstrcpy    strcpy
+#define rwstrncpy   strncpy
+#define rwstrcat    strcat
+#define rwstrncat   strncat
+#define rwstrrchr   strrchr
+#define rwstrchr    strchr
+#define rwstrstr    strstr
+#define rwstrcmp    strcmp
+#define rwstricmp   stricmp
+#define rwstrlen    strlen
+#define rwstrupr    strupr
+#define rwstrlwr    strlwr
+#define rwstrtok    strtok
+#define rwsscanf    sscanf
+
+
+/*
+ ***********************************************
+ *
+ * Memory
+ *
+ ***********************************************
+ */
+
+struct RwMemoryFunctions;
+/*
+{
+	void *(*rwmalloc)(size_t size);
+	void  (*rwfree)(void *mem);
+	void *(*rwrealloc)(void *mem, size_t newSize);
+	void *(*rwcalloc)(size_t numObj, size_t sizeObj);
+};
+*/
+
+void *RwMalloc(size_t size);
+void  RwFree(void *mem);
+void *RwRealloc(void *mem, size_t newSize);
+void *RwCalloc(size_t numObj, size_t sizeObj);
+
+/*
+ ***********************************************
+ *
+ * RwStream
+ *
+ ***********************************************
+ */
+
+//struct RwStream;
+typedef rw::Stream RwStream;
+
+struct RwMemory
+{
+	RwUInt8     *start;
+	RwUInt32    length;
+};
+
+enum RwStreamType
+{
+	rwNASTREAM = 0,
+	rwSTREAMFILE,
+	rwSTREAMFILENAME,
+	rwSTREAMMEMORY,
+	rwSTREAMCUSTOM
+};
+
+enum RwStreamAccessType
+{
+	rwNASTREAMACCESS = 0,
+	rwSTREAMREAD,
+	rwSTREAMWRITE,
+	rwSTREAMAPPEND
+};
+
+RwStream *RwStreamOpen(RwStreamType type, RwStreamAccessType accessType, const void *pData);
+RwBool RwStreamClose(RwStream * stream, void *pData);
+RwUInt32 RwStreamRead(RwStream * stream, void *buffer, RwUInt32 length);
+RwStream *RwStreamWrite(RwStream * stream, const void *buffer, RwUInt32 length);
+RwStream *RwStreamSkip(RwStream * stream, RwUInt32 offset);
+
+
+/*
+ ***********************************************
+ *
+ * Plugin Registry 
+ *
+ ***********************************************
+ */
+
+#define RWPLUGINOFFSET(_type, _base, _offset)                   \
+   ((_type *)((RwUInt8 *)(_base) + (_offset)))
+
+typedef RwStream *(*RwPluginDataChunkWriteCallBack)(RwStream *stream, RwInt32 binaryLength, const void *object, RwInt32 offsetInObject, RwInt32 sizeInObject);
+typedef RwStream *(*RwPluginDataChunkReadCallBack)(RwStream *stream, RwInt32 binaryLength, void *object, RwInt32 offsetInObject, RwInt32 sizeInObject);
+typedef RwInt32(*RwPluginDataChunkGetSizeCallBack)(const void *object, RwInt32 offsetInObject, RwInt32 sizeInObject);
+typedef RwBool(*RwPluginDataChunkAlwaysCallBack)(void *object, RwInt32 offsetInObject, RwInt32 sizeInObject);
+typedef RwBool(*RwPluginDataChunkRightsCallBack)(void *object, RwInt32 offsetInObject, RwInt32 sizeInObject, RwUInt32 extraData);
+typedef void *(*RwPluginObjectConstructor)(void *object, RwInt32 offsetInObject, RwInt32 sizeInObject);
+typedef void *(*RwPluginObjectCopy)(void *dstObject, const void *srcObject, RwInt32 offsetInObject, RwInt32 sizeInObject);
+typedef void *(*RwPluginObjectDestructor)(void *object, RwInt32 offsetInObject, RwInt32 sizeInObject);
+
+/*
+ ***********************************************
+ *
+ * RwMatrix
+ *
+ ***********************************************
+ */
+
+typedef rw::Matrix RwMatrix;
+
+enum RwOpCombineType
+{
+	rwCOMBINEREPLACE = rw::COMBINEREPLACE,
+	rwCOMBINEPRECONCAT = rw::COMBINEPRECONCAT,
+	rwCOMBINEPOSTCONCAT = rw::COMBINEPOSTCONCAT
+};
+
+enum RwMatrixType
+{
+	rwMATRIXTYPENORMAL = rw::Matrix::TYPENORMAL,
+	rwMATRIXTYPEORTHOGANAL = rw::Matrix::TYPEORTHOGONAL,
+	rwMATRIXTYPEORTHONORMAL = rw::Matrix::TYPEORTHONORMAL,
+	rwMATRIXTYPEMASK = 0x00000003,
+};
+
+typedef rw::Matrix::Tolerance RwMatrixTolerance;
+
+RwBool RwMatrixDestroy(RwMatrix *mpMat);
+RwMatrix *RwMatrixCreate(void);
+void RwMatrixCopy(RwMatrix * dstMatrix, const RwMatrix * srcMatrix);
+void RwMatrixSetIdentity(RwMatrix * matrix);
+RwMatrix *RwMatrixMultiply(RwMatrix * matrixOut, const RwMatrix * MatrixIn1, const RwMatrix * matrixIn2);
+RwMatrix *RwMatrixTransform(RwMatrix * matrix, const RwMatrix * transform, RwOpCombineType combineOp);
+RwMatrix *RwMatrixOrthoNormalize(RwMatrix * matrixOut, const RwMatrix * matrixIn);
+RwMatrix *RwMatrixInvert(RwMatrix * matrixOut, const RwMatrix * matrixIn);
+RwMatrix *RwMatrixScale(RwMatrix * matrix, const RwV3d * scale, RwOpCombineType combineOp);
+RwMatrix *RwMatrixTranslate(RwMatrix * matrix, const RwV3d * translation, RwOpCombineType combineOp);
+RwMatrix *RwMatrixRotate(RwMatrix * matrix, const RwV3d * axis, RwReal angle, RwOpCombineType combineOp);
+RwMatrix *RwMatrixRotateOneMinusCosineSine(RwMatrix * matrix, const RwV3d * unitAxis, RwReal oneMinusCosine, RwReal sine, RwOpCombineType combineOp);
+const RwMatrix *RwMatrixQueryRotate(const RwMatrix * matrix, RwV3d * unitAxis, RwReal * angle, RwV3d * center);
+RwV3d *RwMatrixGetRight(RwMatrix * matrix);
+RwV3d *RwMatrixGetUp(RwMatrix * matrix);
+RwV3d *RwMatrixGetAt(RwMatrix * matrix);
+RwV3d *RwMatrixGetPos(RwMatrix * matrix);
+RwMatrix *RwMatrixUpdate(RwMatrix * matrix);
+RwMatrix *RwMatrixOptimize(RwMatrix * matrix, const RwMatrixTolerance *tolerance);
+
+/*
+ ***********************************************
+ *
+ * RwRGBA
+ *
+ ***********************************************
+ */
+
+typedef rw::RGBA RwRGBA;
+typedef rw::RGBAf RwRGBAReal;
+
+
+inline void RwRGBAAssign(RwRGBA *target, const RwRGBA *source) { *target = *source; }
+
+
+RwReal RwV3dNormalize(RwV3d * out, const RwV3d * in);
+RwReal RwV3dLength(const RwV3d * in);
+RwReal RwV2dLength(const RwV2d * in);
+RwReal RwV2dNormalize(RwV2d * out, const RwV2d * in);
+void RwV2dAssign(RwV2d * out, const RwV2d * ina);
+void RwV2dAdd(RwV2d * out, const RwV2d * ina, const RwV2d * inb);
+void RwV2dLineNormal(RwV2d * out, const RwV2d * ina, const RwV2d * inb);
+void RwV2dSub(RwV2d * out, const RwV2d * ina, const RwV2d * inb);
+void RwV2dPerp(RwV2d * out, const RwV2d * in);
+void RwV2dScale(RwV2d * out, const RwV2d * in, RwReal scalar);
+RwReal RwV2dDotProduct(const RwV2d * ina, const RwV2d * inb);
+void RwV3dAssign(RwV3d * out, const RwV3d * ina);
+void RwV3dAdd(RwV3d * out, const RwV3d * ina, const RwV3d * inb);
+void RwV3dSub(RwV3d * out, const RwV3d * ina, const RwV3d * inb);
+void RwV3dScale(RwV3d * out, const RwV3d * in, RwReal scalar);
+void RwV3dIncrementScaled(RwV3d * out,  const RwV3d * in, RwReal scalar);
+void RwV3dNegate(RwV3d * out, const RwV3d * in);
+RwReal RwV3dDotProduct(const RwV3d * ina, const RwV3d * inb);
+void RwV3dCrossProduct(RwV3d * out, const RwV3d * ina, const RwV3d * inb);
+RwV3d *RwV3dTransformPoints(RwV3d * pointsOut, const RwV3d * pointsIn, RwInt32 numPoints, const RwMatrix * matrix);
+RwV3d *RwV3dTransformVectors(RwV3d * vectorsOut, const RwV3d * vectorsIn, RwInt32 numPoints, const RwMatrix * matrix);
+
+
+/*
+ ***********************************************
+ *
+ * Render States
+ *
+ ***********************************************
+ */
+
+// not librw because we don't support all of them (yet?) - mapping in wrapper functions
+enum RwRenderState
+{
+	rwRENDERSTATENARENDERSTATE = 0,
+	rwRENDERSTATETEXTURERASTER,
+	rwRENDERSTATETEXTUREADDRESS,
+	rwRENDERSTATETEXTUREADDRESSU,
+	rwRENDERSTATETEXTUREADDRESSV,
+	rwRENDERSTATETEXTUREPERSPECTIVE,
+	rwRENDERSTATEZTESTENABLE,
+	rwRENDERSTATESHADEMODE,
+	rwRENDERSTATEZWRITEENABLE,
+	rwRENDERSTATETEXTUREFILTER,
+	rwRENDERSTATESRCBLEND,
+	rwRENDERSTATEDESTBLEND,
+	rwRENDERSTATEVERTEXALPHAENABLE,
+	rwRENDERSTATEBORDERCOLOR,
+	rwRENDERSTATEFOGENABLE,
+	rwRENDERSTATEFOGCOLOR,
+	rwRENDERSTATEFOGTYPE,
+	rwRENDERSTATEFOGDENSITY,
+	rwRENDERSTATEFOGTABLE,
+	rwRENDERSTATEALPHAPRIMITIVEBUFFER,
+	rwRENDERSTATECULLMODE,
+	rwRENDERSTATESTENCILENABLE,
+	rwRENDERSTATESTENCILFAIL,
+	rwRENDERSTATESTENCILZFAIL,
+	rwRENDERSTATESTENCILPASS,
+	rwRENDERSTATESTENCILFUNCTION,
+	rwRENDERSTATESTENCILFUNCTIONREF,
+	rwRENDERSTATESTENCILFUNCTIONMASK,
+	rwRENDERSTATESTENCILFUNCTIONWRITEMASK
+};
+
+// not supported - we only do gouraud
+enum RwShadeMode
+{
+	rwSHADEMODENASHADEMODE = 0,
+	rwSHADEMODEFLAT,
+	rwSHADEMODEGOURAUD
+};
+
+enum RwBlendFunction
+{
+	rwBLENDNABLEND = 0,
+	rwBLENDZERO = rw::BLENDZERO,
+	rwBLENDONE = rw::BLENDONE,
+	rwBLENDSRCCOLOR = rw::BLENDSRCCOLOR,
+	rwBLENDINVSRCCOLOR = rw::BLENDINVSRCCOLOR,
+	rwBLENDSRCALPHA = rw::BLENDSRCALPHA,
+	rwBLENDINVSRCALPHA = rw::BLENDINVSRCALPHA,
+	rwBLENDDESTALPHA = rw::BLENDDESTALPHA,
+	rwBLENDINVDESTALPHA = rw::BLENDINVDESTALPHA,
+	rwBLENDDESTCOLOR = rw::BLENDDESTCOLOR,
+	rwBLENDINVDESTCOLOR = rw::BLENDINVDESTCOLOR,
+	rwBLENDSRCALPHASAT = rw::BLENDSRCALPHASAT
+};
+
+// unsupported - we only need linear
+enum RwFogType
+{
+	rwFOGTYPENAFOGTYPE = 0,
+	rwFOGTYPELINEAR,
+	rwFOGTYPEEXPONENTIAL,
+	rwFOGTYPEEXPONENTIAL2
+};
+
+enum RwTextureFilterMode
+{
+	rwFILTERNAFILTERMODE = 0,
+	rwFILTERNEAREST = rw::Texture::NEAREST,
+	rwFILTERLINEAR = rw::Texture::LINEAR,
+	rwFILTERMIPNEAREST = rw::Texture::MIPNEAREST,
+	rwFILTERMIPLINEAR = rw::Texture::MIPLINEAR,
+	rwFILTERLINEARMIPNEAREST = rw::Texture::LINEARMIPNEAREST,
+	rwFILTERLINEARMIPLINEAR = rw::Texture::LINEARMIPLINEAR
+};
+
+enum RwTextureAddressMode
+{
+	rwTEXTUREADDRESSNATEXTUREADDRESS = 0,
+	rwTEXTUREADDRESSWRAP = rw::Texture::WRAP,
+	rwTEXTUREADDRESSMIRROR = rw::Texture::MIRROR,
+	rwTEXTUREADDRESSCLAMP = rw::Texture::CLAMP,
+	rwTEXTUREADDRESSBORDER = rw::Texture::BORDER
+};
+
+enum RwCullMode
+{
+	rwCULLMODENACULLMODE = 0,
+	rwCULLMODECULLNONE = rw::CULLNONE,
+	rwCULLMODECULLBACK = rw::CULLBACK,
+	rwCULLMODECULLFRONT = rw::CULLFRONT
+};
+
+enum RwPrimitiveType
+{
+	rwPRIMTYPENAPRIMTYPE = rw::PRIMTYPENONE,
+	rwPRIMTYPELINELIST = rw::PRIMTYPELINELIST,
+	rwPRIMTYPEPOLYLINE = rw::PRIMTYPEPOLYLINE,
+	rwPRIMTYPETRILIST = rw::PRIMTYPETRILIST,
+	rwPRIMTYPETRISTRIP = rw::PRIMTYPETRISTRIP,
+	rwPRIMTYPETRIFAN = rw::PRIMTYPETRIFAN,
+	rwPRIMTYPEPOINTLIST = rw::PRIMTYPEPOINTLIST
+};
+
+
+RwBool RwRenderStateGet(RwRenderState state, void *value);
+RwBool RwRenderStateSet(RwRenderState state, void *value);
+
+
+/*
+ ***********************************************
+ *
+ * Engine
+ *
+ ***********************************************
+ */
+
+struct RwEngineOpenParams
+{
+	void    *displayID;
+};
+
+typedef rw::SubSystemInfo RwSubSystemInfo;
+
+enum RwVideoModeFlag
+{
+	rwVIDEOMODEEXCLUSIVE  = rw::VIDEOMODEEXCLUSIVE,
+/*
+	rwVIDEOMODEINTERLACE  = 0x2,
+	rwVIDEOMODEFFINTERLACE  = 0x4,
+	rwVIDEOMODEFSAA0 = 0x8,
+	rwVIDEOMODEFSAA1 = 0x10
+*/
+};
+
+typedef rw::VideoMode RwVideoMode;
+
+#if 0
+struct RwFileFunctions
+{
+	rwFnFexist  rwfexist; /**< Pointer to fexist function */
+	rwFnFopen   rwfopen;  /**< Pointer to fopen function */
+	rwFnFclose  rwfclose; /**< Pointer to fclose function */
+	rwFnFread   rwfread;  /**< Pointer to fread function */
+	rwFnFwrite  rwfwrite; /**< Pointer to fwrite function */
+	rwFnFgets   rwfgets;  /**< Pointer to fgets function */
+	rwFnFputs   rwfputs;  /**< Pointer to puts function */
+	rwFnFeof    rwfeof;   /**< Pointer to feof function */
+	rwFnFseek   rwfseek;  /**< Pointer to fseek function */
+	rwFnFflush  rwfflush; /**< Pointer to fflush function */
+	rwFnFtell   rwftell;  /**< Pointer to ftell function */  
+};
+RwFileFunctions *RwOsGetFileInterface(void);
+#endif
+
+RwBool RwEngineInit(RwMemoryFunctions *memFuncs, RwUInt32 initFlags, RwUInt32 resArenaSize);
+RwInt32 RwEngineRegisterPlugin(RwInt32 size, RwUInt32 pluginID, RwPluginObjectConstructor initCB, RwPluginObjectDestructor termCB);
+RwInt32 RwEngineGetPluginOffset(RwUInt32 pluginID);
+RwBool RwEngineOpen(RwEngineOpenParams *initParams);
+RwBool RwEngineStart(void);
+RwBool RwEngineStop(void);
+RwBool RwEngineClose(void);
+RwBool RwEngineTerm(void);
+RwInt32 RwEngineGetNumSubSystems(void);
+RwSubSystemInfo *RwEngineGetSubSystemInfo(RwSubSystemInfo *subSystemInfo, RwInt32 subSystemIndex);
+RwInt32 RwEngineGetCurrentSubSystem(void);
+RwBool RwEngineSetSubSystem(RwInt32 subSystemIndex);
+RwInt32 RwEngineGetNumVideoModes(void);
+RwVideoMode *RwEngineGetVideoModeInfo(RwVideoMode *modeinfo, RwInt32 modeIndex);
+RwInt32 RwEngineGetCurrentVideoMode(void);
+RwBool RwEngineSetVideoMode(RwInt32 modeIndex);
+RwInt32 RwEngineGetTextureMemorySize(void);
+RwInt32 RwEngineGetMaxTextureSize(void);
+
+
+/*
+ ***********************************************
+ *
+ * Binary stream
+ *
+ ***********************************************
+ */
+
+RwBool RwStreamFindChunk(RwStream *stream, RwUInt32 type, RwUInt32 *lengthOut, RwUInt32 *versionOut);
diff --git a/src/math/Vector.h b/src/math/Vector.h
index 1274a4b2..269ffc88 100644
--- a/src/math/Vector.h
+++ b/src/math/Vector.h
@@ -46,6 +46,13 @@ public:
 		y *= invsqrt;
 		z *= invsqrt;
 	}
+	
+	void Normalise2D(void) {
+		float sq = MagnitudeSqr2D();
+		float invsqrt = RecipSqrt(sq);
+		x *= invsqrt;
+		y *= invsqrt;
+	}
 
 	const CVector &operator+=(CVector const &right) {
 		x += right.x;
diff --git a/src/math/Vector2D.h b/src/math/Vector2D.h
index 1e4d698f..705ad763 100644
--- a/src/math/Vector2D.h
+++ b/src/math/Vector2D.h
@@ -13,13 +13,14 @@ public:
 
 	void Normalise(void){
 		float sq = MagnitudeSqr();
-		if(sq > 0.0f){
+		//if(sq > 0.0f){
 			float invsqrt = RecipSqrt(sq);
 			x *= invsqrt;
 			y *= invsqrt;
-		}else
-			x = 1.0f;
+		//}else
+		//	x = 1.0f;
 	}
+	
 	const CVector2D &operator+=(CVector2D const &right) {
 		x += right.x;
 		y += right.y;
diff --git a/src/modelinfo/ModelIndices.h b/src/modelinfo/ModelIndices.h
index 20d1b7f3..309fa1bb 100644
--- a/src/modelinfo/ModelIndices.h
+++ b/src/modelinfo/ModelIndices.h
@@ -490,3 +490,10 @@ IsPoliceVehicleModel(int16 id)
 		id == MI_POLICE ||
 		id == MI_ENFORCER;
 }
+
+inline bool
+IsExplosiveThingModel(int16 id)
+{
+	return id == MI_EXPLODINGBARREL ||
+		id == MI_PETROLPUMP;
+}
+\ No newline at end of file
diff --git a/src/peds/Ped.cpp b/src/peds/Ped.cpp
index cee2b323..412b1f04 100644
--- a/src/peds/Ped.cpp
+++ b/src/peds/Ped.cpp
@@ -62,7 +62,7 @@
 CPed *gapTempPedList[50];
 uint16 gnNumTempPedList;
 
-CColPoint &aTempPedColPts = *(CColPoint*)0x62DB14;
+CColPoint aTempPedColPts[MAX_COLLISION_POINTS];
 
 // Corresponds to ped sounds (from SOUND_PED_DEATH to SOUND_PED_TAXI_CALL)
 PedAudioData CommentWaitTime[39] = {
@@ -106,8 +106,6 @@ PedAudioData CommentWaitTime[39] = {
 	{1000, 1000, 1000, 1000},
 	{1000, 1000, 5000, 5000},
 };
-// *(CPedAudioData(*)[39]) * (uintptr*)0x5F94C4;
-
 uint16 nPlayerInComboMove;
 
 RpClump *flyingClumpTemp;
@@ -139,10 +137,9 @@ FightMove tFightMoves[NUM_FIGHTMOVES] = {
 	{ANIM_HIT_BEHIND, 0.0f, 0.0f, 0.0f, 0.0f, HITLEVEL_NULL, 0, 0},
 	{ANIM_FIGHT2_IDLE, 0.0f, 0.0f, 0.0f, 0.0f, HITLEVEL_NULL, 0, 0},
 };
-// *(FightMove(*)[NUM_FIGHTMOVES])* (uintptr*)0x5F9844;
 
-uint16 &CPed::nThreatReactionRangeMultiplier = *(uint16*)0x5F8C98;
-uint16 &CPed::nEnterCarRangeMultiplier = *(uint16*)0x5F8C94;
+uint16 CPed::nThreatReactionRangeMultiplier = 1;
+uint16 CPed::nEnterCarRangeMultiplier = 1;
 
 CVector vecPedCarDoorAnimOffset;
 CVector vecPedCarDoorLoAnimOffset;
@@ -151,9 +148,9 @@ CVector vecPedQuickDraggedOutCarAnimOffset;
 CVector vecPedDraggedOutCarAnimOffset;
 CVector vecPedTrainDoorAnimOffset;
 
-bool &CPed::bNastyLimbsCheat = *(bool*)0x95CD44;
-bool &CPed::bPedCheat2 = *(bool*)0x95CD5A;
-bool &CPed::bPedCheat3 = *(bool*)0x95CD59;
+bool CPed::bNastyLimbsCheat;
+bool CPed::bPedCheat2;
+bool CPed::bPedCheat3;
 CVector2D CPed::ms_vec2DFleePosition;
 
 void *CPed::operator new(size_t sz) { return CPools::GetPedPool()->New();  }
@@ -1231,7 +1228,7 @@ CPed::Attack(void)
 						weaponAnimAssoc->SetCurrentTime(0.0f);
 
 					if (IsPlayer()) {
-						((CPlayerPed*)this)->field_1376 = 0.0f;
+						((CPlayerPed*)this)->m_fAttackButtonCounter = 0.0f;
 						((CPlayerPed*)this)->m_bHaveTargetSelected = false;
 					}
 				}
@@ -2244,7 +2241,7 @@ CPed::BuildPedLists(void)
 						if (nThreatReactionRangeMultiplier * 30.0f > dist) {
 							gapTempPedList[gnNumTempPedList] = ped;
 							gnNumTempPedList++;
-							assert(gnNumTempPedList < ARRAYSIZE(gapTempPedList));
+							assert(gnNumTempPedList < ARRAY_SIZE(gapTempPedList));
 						}
 					}
 				}
@@ -4143,7 +4140,7 @@ CPed::SetGetUp(void)
 			&& ((CTimer::GetFrameCounter() + m_randomSeed % 256 + 5) % 8
 				|| CCollision::ProcessColModels(GetMatrix(), *CModelInfo::GetModelInfo(m_modelIndex)->GetColModel(),
 					collidingVeh->GetMatrix(), *CModelInfo::GetModelInfo(collidingVeh->m_modelIndex)->GetColModel(),
-					&aTempPedColPts, nil, nil) > 0)) {
+					aTempPedColPts, nil, nil) > 0)) {
 
 			bGetUpAnimStarted = false;
 			if (IsPlayer())
diff --git a/src/peds/Ped.h b/src/peds/Ped.h
index 2edd5d68..9f660693 100644
--- a/src/peds/Ped.h
+++ b/src/peds/Ped.h
@@ -796,7 +796,12 @@ public:
 
 	PedState GetPedState(void) { return m_nPedState; }
 	void SetPedState(PedState state) { m_nPedState = state; }
+	bool Dead(void) { return m_nPedState == PED_DEAD; }
+	bool Dying(void) { return m_nPedState == PED_DIE; }
 	bool DyingOrDead(void) { return m_nPedState == PED_DIE || m_nPedState == PED_DEAD; }
+	bool OnGround(void) { return m_nPedState == PED_FALL || m_nPedState == PED_DIE || m_nPedState == PED_DEAD; }
+	
+	bool Driving(void) { return m_nPedState == PED_DRIVING; }
 	bool InVehicle(void) { return bInVehicle && m_pMyVehicle; } // True when ped is sitting/standing in vehicle, not in enter/exit state.
 	bool EnteringCar(void) { return m_nPedState == PED_ENTER_CAR || m_nPedState == PED_CARJACK; }
 
@@ -823,14 +828,14 @@ public:
 	}
 
 	// set by 0482:set_threat_reaction_range_multiplier opcode
-	static uint16 &nThreatReactionRangeMultiplier;
+	static uint16 nThreatReactionRangeMultiplier;
 
 	// set by 0481:set_enter_car_range_multiplier opcode
-	static uint16 &nEnterCarRangeMultiplier;
+	static uint16 nEnterCarRangeMultiplier;
 
-	static bool &bNastyLimbsCheat;
-	static bool &bPedCheat2;
-	static bool &bPedCheat3;
+	static bool bNastyLimbsCheat;
+	static bool bPedCheat2;
+	static bool bPedCheat3;
 	static CVector2D ms_vec2DFleePosition;
 
 #ifdef TOGGLEABLE_BETA_FEATURES
diff --git a/src/peds/PlayerPed.cpp b/src/peds/PlayerPed.cpp
index ccc0a43a..dcd9486f 100644
--- a/src/peds/PlayerPed.cpp
+++ b/src/peds/PlayerPed.cpp
@@ -43,8 +43,8 @@ CPlayerPed::CPlayerPed(void) : CPed(PEDTYPE_PLAYER1)
 	m_fStaminaProgress = 0.0f;
 	m_nEvadeAmount = 0;
 	field_1367 = 0;
-	m_nShotDelay = 0;
-	field_1376 = 0.0f;
+	m_nHitAnimDelayTimer = 0;
+	m_fAttackButtonCounter = 0.0f;
 	m_bHaveTargetSelected = false;
 	m_bHasLockOnTarget = false;
 	m_bCanBeDamaged = true;
@@ -1024,10 +1024,10 @@ CPlayerPed::ProcessPlayerWeapon(CPad *padUsed)
 					if (padUsed->WeaponJustDown()) {
 						m_bHaveTargetSelected = true;
 					} else if (!m_bHaveTargetSelected) {
-						field_1376 += CTimer::GetTimeStepNonClipped();
+						m_fAttackButtonCounter += CTimer::GetTimeStepNonClipped();
 					}
 				} else {
-					field_1376 = 0.0f;
+					m_fAttackButtonCounter = 0.0f;
 					m_bHaveTargetSelected = false;
 				}
 				SetAttack(nil);
diff --git a/src/peds/PlayerPed.h b/src/peds/PlayerPed.h
index c139bbbc..f96d8e6a 100644
--- a/src/peds/PlayerPed.h
+++ b/src/peds/PlayerPed.h
@@ -20,8 +20,8 @@ public:
 	uint8 m_nEvadeAmount;
 	int8 field_1367;
 	uint32 m_nSpeedTimer;
-	int32 m_nShotDelay;
-	float field_1376;	// m_fAttackButtonCounter?
+	uint32 m_nHitAnimDelayTimer;
+	float m_fAttackButtonCounter;
 	bool m_bHaveTargetSelected;	// may have better name
 	int8 field_1381;
 	int8 field_1382;
diff --git a/src/peds/Population.cpp b/src/peds/Population.cpp
index 6959487f..d3a67a57 100644
--- a/src/peds/Population.cpp
+++ b/src/peds/Population.cpp
@@ -35,48 +35,48 @@ const RegenerationPoint aSafeZones[] = {
 		CVector(790.0f, -917.0f, 39.0f), CVector(775.0f, -921.0f, 39.0f), CVector(424.0f, -942.0f, 38.0f), CVector(439.0f, -938.0f, 38.0f) },
 	{ LEVEL_INDUSTRIAL, LEVEL_COMMERCIAL, 555.0f, 711.0f, 118.0f, 186.0f, -30.0f, -10.0f,
 		CVector(698.0f,  182.0f, -20.0f), CVector(681.0f,  178.0f, -20.0f), CVector(586.0f,  144.0f, -20.0f), CVector(577.0f,  135.0f, -20.0f) },
-	{ LEVEL_INDUSTRIAL, LEVEL_COMMERCIAL, 26.0f, 44.0f, 124.0f, 87.0f, 20.0f, 6.0f,
+	{ LEVEL_INDUSTRIAL, LEVEL_COMMERCIAL, 626.0f, 744.0f, -124.0f, -87.0f, -20.0f, -6.0f,
 		CVector(736.0f, -117.0f, -13.0f), CVector(730.0f, -115.0f, -13.0f), CVector(635.0f, -93.0f, -12.5f), CVector(650.0f, -89.0f, -12.5f) },
-	{ LEVEL_INDUSTRIAL, LEVEL_COMMERCIAL, 45.0f, 34.0f, 780.0f, 750.0f, 25.0f, 6.0f,
+	{ LEVEL_INDUSTRIAL, LEVEL_COMMERCIAL, 645.0f, 734.0f, -780.0f, -750.0f, -25.0f, -6.0f,
 		CVector(729.0f, -764.0f, -18.0f), CVector(720.0f, -769.0f, -17.0f), CVector(652.0f, -774.0f, -10.5f), CVector(659.0f, -770.0f, -10.5f) },
-	{ LEVEL_COMMERCIAL, LEVEL_SUBURBAN, 532.0f, 136.0f, 668.0f, 599.0f, 4.0f, 0.0f,
+	{ LEVEL_COMMERCIAL, LEVEL_SUBURBAN, -532.0f, -136.0f, -668.0f, -599.0f, 34.0f, 60.0f,
 		CVector(-172.0f, -619.0f,  44.0f), CVector(-183.0f, -623.0f,  44.0f), CVector(-511.0f, -645.0f,  41.0f), CVector(-493.0f, -639.0f,  41.5f) },
-	{ LEVEL_COMMERCIAL, LEVEL_SUBURBAN, 325.0f, 175.0f, 7.0f, 5.0f, 30.0f, 10.0f,
+	{ LEVEL_COMMERCIAL, LEVEL_SUBURBAN, -325.0f, -175.0f, 27.0f, 75.0f, -30.0f, -10.0f,
 		CVector(-185.0f,  40.8f, -20.5f), CVector(-202.0f,  37.0f, -20.5f), CVector(-315.0f,  65.5f, -20.5f), CVector(-306.0f,  62.4f, -20.5f) },
-	{ LEVEL_COMMERCIAL, LEVEL_SUBURBAN, 410.0f, 310.0f, 1055.0f, 1030.0f, 20.0f, 6.0f,
+	{ LEVEL_COMMERCIAL, LEVEL_SUBURBAN, -410.0f, -310.0f, -1055.0f, -1030.0f, -20.0f, -6.0f,
 		CVector(-321.0f, -1043.0f, -13.2f), CVector(-328.0f, -1045.0f, -13.2f), CVector(-398.0f, -1044.0f, -13.5f), CVector(-390.0f, -1040.5f, -13.5f) },
-	{ LEVEL_COMMERCIAL, LEVEL_SUBURBAN, 425.0f, 280.0f, 471.0f, 447.0f, 20.0f, 5.0f,
+	{ LEVEL_COMMERCIAL, LEVEL_SUBURBAN, -425.0f, -280.0f, -471.0f, -447.0f, -20.0f, -5.0f,
 		CVector(-292.0f, -457.0f, -11.6f), CVector(-310.0f, -461.0f, -11.6f), CVector(-413.0f, -461.0f, -11.5f), CVector(-399.0f, -457.0f, -11.3f) }
-}; // *(RegenerationPoint(*)[8]) * (uintptr*)0x5FA578;
-
-PedGroup CPopulation::ms_pPedGroups[NUMPEDGROUPS]; // = *(PedGroup(*)[NUMPEDGROUPS]) * (uintptr*)0x6E9248;
-bool CPopulation::ms_bGivePedsWeapons; // = *(bool*)0x95CCF6;
-int32 CPopulation::m_AllRandomPedsThisType = -1; // = *(int32*)0x5FA570;
-float CPopulation::PedDensityMultiplier = 1.0f; // = *(float*)0x5FA56C;
-uint32 CPopulation::ms_nTotalMissionPeds; // = *(uint32*)0x8F5F70;
-int32 CPopulation::MaxNumberOfPedsInUse = 25; // *(int32*)0x5FA574;
-uint32 CPopulation::ms_nNumCivMale; // = *(uint32*)0x8F2548;
-uint32 CPopulation::ms_nNumCivFemale; // = *(uint32*)0x8F5F44;
-uint32 CPopulation::ms_nNumCop; // = *(uint32*)0x885AFC;
-bool CPopulation::bZoneChangeHasHappened; // = *(bool*)0x95CD79;
-uint32 CPopulation::ms_nNumEmergency; // = *(uint32*)0x94071C;
-int8 CPopulation::m_CountDownToPedsAtStart; // = *(int8*)0x95CD4F;
-uint32 CPopulation::ms_nNumGang1; // = *(uint32*)0x8F1B1C;
-uint32 CPopulation::ms_nNumGang2; // = *(uint32*)0x8F1B14;
-uint32 CPopulation::ms_nTotalPeds; // = *(uint32*)0x95CB50;
-uint32 CPopulation::ms_nNumGang3; // = *(uint32*)0x8F2548;
-uint32 CPopulation::ms_nTotalGangPeds; // = *(uint32*)0x885AF0;
-uint32 CPopulation::ms_nNumGang4; // = *(uint32*)0x8F1B2C;
-uint32 CPopulation::ms_nTotalCivPeds; // = *(uint32*)0x8F2C3C;
-uint32 CPopulation::ms_nNumGang5; // = *(uint32*)0x8F1B30;
-uint32 CPopulation::ms_nNumDummy; // = *(uint32*)0x8F1A98;
-uint32 CPopulation::ms_nNumGang6; // = *(uint32*)0x8F1B20;
-uint32 CPopulation::ms_nNumGang9; // = *(uint32*)0x8F1B10;
-uint32 CPopulation::ms_nNumGang7; // = *(uint32*)0x8F1B28;
-uint32 CPopulation::ms_nNumGang8; // = *(uint32*)0x8F1B0C;
-CVector CPopulation::RegenerationPoint_a; // = *(CVector*)0x8E2AA4;
-CVector CPopulation::RegenerationPoint_b; // = *(CVector*)0x8E2A98;
-CVector CPopulation::RegenerationForward; // = *(CVector*)0x8F1AD4;
+};
+
+PedGroup CPopulation::ms_pPedGroups[NUMPEDGROUPS];
+bool CPopulation::ms_bGivePedsWeapons;
+int32 CPopulation::m_AllRandomPedsThisType = -1;
+float CPopulation::PedDensityMultiplier = 1.0f;
+uint32 CPopulation::ms_nTotalMissionPeds;
+int32 CPopulation::MaxNumberOfPedsInUse = 25;
+uint32 CPopulation::ms_nNumCivMale;
+uint32 CPopulation::ms_nNumCivFemale;
+uint32 CPopulation::ms_nNumCop;
+bool CPopulation::bZoneChangeHasHappened;
+uint32 CPopulation::ms_nNumEmergency;
+int8 CPopulation::m_CountDownToPedsAtStart;
+uint32 CPopulation::ms_nNumGang1;
+uint32 CPopulation::ms_nNumGang2;
+uint32 CPopulation::ms_nTotalPeds;
+uint32 CPopulation::ms_nNumGang3;
+uint32 CPopulation::ms_nTotalGangPeds;
+uint32 CPopulation::ms_nNumGang4;
+uint32 CPopulation::ms_nTotalCivPeds;
+uint32 CPopulation::ms_nNumGang5;
+uint32 CPopulation::ms_nNumDummy;
+uint32 CPopulation::ms_nNumGang6;
+uint32 CPopulation::ms_nNumGang9;
+uint32 CPopulation::ms_nNumGang7;
+uint32 CPopulation::ms_nNumGang8;
+CVector CPopulation::RegenerationPoint_a;
+CVector CPopulation::RegenerationPoint_b;
+CVector CPopulation::RegenerationForward;
 
 void
 CPopulation::Initialise()
diff --git a/src/render/Clouds.cpp b/src/render/Clouds.cpp
index 39866294..7debe3d3 100644
--- a/src/render/Clouds.cpp
+++ b/src/render/Clouds.cpp
@@ -233,7 +233,7 @@ CClouds::Render(void)
 					szx*55.0f, szy*55.0f,
 					tr, tg, tb, br, bg, bb, 0.0f, -1.0f,
 					1.0f/screenpos.z,
-					IndividualRotation/65336.0f * 2*3.14f + ms_cameraRoll,
+					(uint16)IndividualRotation/65336.0f * 6.28f + ms_cameraRoll,
 					fluffyalpha);
 				bCloudOnScreen[i] = true;
 			}else
diff --git a/src/render/Console.cpp b/src/render/Console.cpp
index d4940955..545122b0 100644
--- a/src/render/Console.cpp
+++ b/src/render/Console.cpp
@@ -1,4 +1,5 @@
 #include "common.h"
+#include <stdarg.h>
 #include "patcher.h"
 #include "Console.h"
 #include "Font.h"
diff --git a/src/render/Glass.cpp b/src/render/Glass.cpp
index 41d31985..ac6c1728 100644
--- a/src/render/Glass.cpp
+++ b/src/render/Glass.cpp
@@ -404,6 +404,7 @@ CGlass::AskForObjectToBeRenderedInGlass(CEntity *entity)
 void
 CGlass::RenderEntityInGlass(CEntity *entity)
 {
+	ASSERT(entity!=nil);
 	CObject *object = (CObject *)entity;
 
 	if ( object->bGlassBroken )
@@ -419,7 +420,7 @@ CGlass::RenderEntityInGlass(CEntity *entity)
 	uint8 alpha = CalcAlphaWithNormal(&fwdNorm);
 
 	CColModel *col = object->GetColModel();
-
+	ASSERT(col!=nil);
 	if ( col->numTriangles >= 2 )
 	{
 		CVector a = object->GetMatrix() * col->vertices[0];
@@ -523,6 +524,8 @@ CGlass::RenderEntityInGlass(CEntity *entity)
 int32
 CGlass::CalcAlphaWithNormal(CVector *normal)
 {
+	ASSERT(normal!=nil);
+	
 	float fwdDir = 2.0f * DotProduct(*normal, TheCamera.GetForward());
 	float fwdDot = DotProduct(TheCamera.GetForward()-fwdDir*(*normal), CVector(0.57f, 0.57f, -0.57f));
 	return int32(lerp(fwdDot*fwdDot*fwdDot*fwdDot*fwdDot*fwdDot, 20.0f, 255.0f));
@@ -597,6 +600,8 @@ CGlass::RenderReflectionPolys(void)
 void
 CGlass::WindowRespondsToCollision(CEntity *entity, float amount, CVector speed, CVector point, bool explosion)
 {
+	ASSERT(entity!=nil);
+	
 	CObject *object = (CObject *)entity;
 
 	if ( object->bGlassBroken )
@@ -605,7 +610,8 @@ CGlass::WindowRespondsToCollision(CEntity *entity, float amount, CVector speed,
 	object->bGlassCracked = true;
 
 	CColModel *col = object->GetColModel();
-
+	ASSERT(col!=nil);
+	
 	CVector a = object->GetMatrix() * col->vertices[0];
 	CVector b = object->GetMatrix() * col->vertices[1];
 	CVector c = object->GetMatrix() * col->vertices[2];
@@ -647,6 +653,8 @@ CGlass::WindowRespondsToCollision(CEntity *entity, float amount, CVector speed,
 void
 CGlass::WindowRespondsToSoftCollision(CEntity *entity, float amount)
 {
+	ASSERT(entity!=nil);
+	
 	CObject *object = (CObject *)entity;
 
 	if ( amount > 50.0f && !object->bGlassCracked )
@@ -659,6 +667,8 @@ CGlass::WindowRespondsToSoftCollision(CEntity *entity, float amount)
 void
 CGlass::WasGlassHitByBullet(CEntity *entity, CVector point)
 {
+	ASSERT(entity!=nil);
+	
 	CObject *object = (CObject *)entity;
 
 	if ( IsGlass(object->GetModelIndex()) )
@@ -679,6 +689,8 @@ CGlass::WasGlassHitByBullet(CEntity *entity, CVector point)
 void
 CGlass::WindowRespondsToExplosion(CEntity *entity, CVector point)
 {
+	ASSERT(entity!=nil);
+	
 	CObject *object = (CObject *)entity;
 
 	CVector distToGlass = object->GetPosition() - point;
diff --git a/src/render/Hud.cpp b/src/render/Hud.cpp
index f8b86bd2..9529c4c1 100644
--- a/src/render/Hud.cpp
+++ b/src/render/Hud.cpp
@@ -144,12 +144,10 @@ void CHud::Draw()
 			float fMultBright = SpriteBrightness * 0.03f * (0.25f * fStep + 0.75f);
 			CRect rect;
 			if (DrawCrossHairPC && TheCamera.Cams[TheCamera.ActiveCam].Using3rdPersonMouseCam()) {
-#ifndef ASPECT_RATIO_SCALE
 				float f3rdX = SCREEN_WIDTH * TheCamera.m_f3rdPersonCHairMultX;
 				float f3rdY = SCREEN_HEIGHT * TheCamera.m_f3rdPersonCHairMultY;
-#else
-				float f3rdX = (((TheCamera.m_f3rdPersonCHairMultX - 0.5f) / ((CDraw::GetAspectRatio()) / (DEFAULT_ASPECT_RATIO))) + 0.5f) * SCREEN_WIDTH;
-				float f3rdY = SCREEN_HEIGHT * TheCamera.m_f3rdPersonCHairMultY + SCREEN_SCALE_Y(-2.0f);
+#ifdef ASPECT_RATIO_SCALE
+				f3rdY -= SCREEN_SCALE_Y(2.0f);
 #endif
 				if (FindPlayerPed() && WeaponType == WEAPONTYPE_M16) {
 					rect.left = f3rdX - SCREEN_SCALE_X(32.0f * 0.6f);
diff --git a/src/core/Instance.cpp b/src/render/Instance.cpp
index 775341be..775341be 100644
--- a/src/core/Instance.cpp
+++ b/src/render/Instance.cpp
diff --git a/src/core/Instance.h b/src/render/Instance.h
index 01dfb6a2..01dfb6a2 100644
--- a/src/core/Instance.h
+++ b/src/render/Instance.h
diff --git a/src/render/Renderer.cpp b/src/render/Renderer.cpp
index d7834065..7b2f90e8 100644
--- a/src/render/Renderer.cpp
+++ b/src/render/Renderer.cpp
@@ -39,16 +39,17 @@ struct EntityInfo
 	float sort;
 };
 
-CLinkList<EntityInfo> &gSortedVehiclesAndPeds = *(CLinkList<EntityInfo>*)0x629AC0;
+CLinkList<EntityInfo> gSortedVehiclesAndPeds;
 
-int32 &CRenderer::ms_nNoOfVisibleEntities = *(int32*)0x940730;
-CEntity *(&CRenderer::ms_aVisibleEntityPtrs)[NUMVISIBLEENTITIES] = *(CEntity * (*)[NUMVISIBLEENTITIES]) * (uintptr*)0x6E9920;
-CEntity *(&CRenderer::ms_aInVisibleEntityPtrs)[NUMINVISIBLEENTITIES] = *(CEntity * (*)[NUMINVISIBLEENTITIES]) * (uintptr*)0x880B50;
-int32 &CRenderer::ms_nNoOfInVisibleEntities = *(int32*)0x8F1B78;
+int32 CRenderer::ms_nNoOfVisibleEntities;
+CEntity *CRenderer::ms_aVisibleEntityPtrs[NUMVISIBLEENTITIES];
+CEntity *CRenderer::ms_aInVisibleEntityPtrs[NUMINVISIBLEENTITIES];
+int32 CRenderer::ms_nNoOfInVisibleEntities;
 
-CVector &CRenderer::ms_vecCameraPosition = *(CVector*)0x8E2C3C;
-CVehicle *&CRenderer::m_pFirstPersonVehicle = *(CVehicle**)0x885B80;
-bool &CRenderer::m_loadingPriority = *(bool*)0x95CD86;
+CVector CRenderer::ms_vecCameraPosition;
+CVehicle *CRenderer::m_pFirstPersonVehicle;
+bool CRenderer::m_loadingPriority;
+float CRenderer::ms_lodDistScale = 1.2f;
 
 void
 CRenderer::Init(void)
diff --git a/src/render/Renderer.h b/src/render/Renderer.h
index 42c154ec..362741e3 100644
--- a/src/render/Renderer.h
+++ b/src/render/Renderer.h
@@ -20,17 +20,17 @@ class CPtrList;
 
 class CRenderer
 {
-	static int32 &ms_nNoOfVisibleEntities;
-	static CEntity *(&ms_aVisibleEntityPtrs)[NUMVISIBLEENTITIES];
-	static int32 &ms_nNoOfInVisibleEntities;
-	static CEntity *(&ms_aInVisibleEntityPtrs)[NUMINVISIBLEENTITIES];
+	static int32 ms_nNoOfVisibleEntities;
+	static CEntity *ms_aVisibleEntityPtrs[NUMVISIBLEENTITIES];
+	static int32 ms_nNoOfInVisibleEntities;
+	static CEntity *ms_aInVisibleEntityPtrs[NUMINVISIBLEENTITIES];
 
-	static CVector &ms_vecCameraPosition;
-	static CVehicle *&m_pFirstPersonVehicle;
+	static CVector ms_vecCameraPosition;
+	static CVehicle *m_pFirstPersonVehicle;
 
 public:
-	static float ms_lodDistScale;	// defined in Frontend.cpp
-	static bool &m_loadingPriority;
+	static float ms_lodDistScale;
+	static bool m_loadingPriority;
 
 	static void Init(void);
 	static void Shutdown(void);
diff --git a/src/render/Shadows.h b/src/render/Shadows.h
index fb41ebbc..ced9f11b 100644
--- a/src/render/Shadows.h
+++ b/src/render/Shadows.h
@@ -6,7 +6,6 @@
 #define MAX_PERMAMENTSHADOWS 48
 
 
-struct RwTexture;
 class CEntity;
 
 enum eShadowType
diff --git a/src/render/Sprite.cpp b/src/render/Sprite.cpp
index 8ac2315f..82754121 100644
--- a/src/render/Sprite.cpp
+++ b/src/render/Sprite.cpp
@@ -137,8 +137,8 @@ CSprite::RenderOneXLUSprite(float x, float y, float z, float w, float h, uint8 r
 void
 CSprite::RenderOneXLUSprite_Rotate_Aspect(float x, float y, float z, float w, float h, uint8 r, uint8 g, uint8 b, int16 intens, float recipz, float rotation, uint8 a)
 {
-	float c = Cos(DEGTORAD(rotation));
-	float s = Sin(DEGTORAD(rotation));
+	float c = Cos(rotation);
+	float s = Sin(rotation);
 
 	float xs[4];
 	float ys[4];
@@ -315,8 +315,8 @@ void
 CSprite::RenderBufferedOneXLUSprite_Rotate_Aspect(float x, float y, float z, float w, float h, uint8 r, uint8 g, uint8 b, int16 intens, float recipz, float rotation, uint8 a)
 {
 	m_bFlushSpriteBufferSwitchZTest = 0;
-	float c = Cos(DEGTORAD(rotation));
-	float s = Sin(DEGTORAD(rotation));
+	float c = Cos(rotation);
+	float s = Sin(rotation);
 
 	float xs[4];
 	float ys[4];
@@ -367,8 +367,8 @@ void
 CSprite::RenderBufferedOneXLUSprite_Rotate_2Colours(float x, float y, float z, float w, float h, uint8 r1, uint8 g1, uint8 b1, uint8 r2, uint8 g2, uint8 b2, float cx, float cy, float recipz, float rotation, uint8 a)
 {
 	m_bFlushSpriteBufferSwitchZTest = 0;
-	float c = Cos(DEGTORAD(rotation));
-	float s = Sin(DEGTORAD(rotation));
+	float c = Cos(rotation);
+	float s = Sin(rotation);
 
 	float xs[4];
 	float ys[4];
@@ -398,11 +398,11 @@ CSprite::RenderBufferedOneXLUSprite_Rotate_2Colours(float x, float y, float z, f
 	// Colour factors, cx/y is the direction in which colours change from rgb1 to rgb2
 	cf[0] = (cx*(-c-s) + cy*(-c+s))*0.5f + 0.5f;
 	cf[0] = clamp(cf[0], 0.0f, 1.0f);
-	cf[1] = (cx*(-c-s) + cy*(-c+s))*0.5f + 0.5f;
+	cf[1] = (cx*(-c+s) + cy*( c+s))*0.5f + 0.5f;
 	cf[1] = clamp(cf[1], 0.0f, 1.0f);
-	cf[2] = (cx*(-c-s) + cy*(-c+s))*0.5f + 0.5f;
+	cf[2] = (cx*( c+s) + cy*( c-s))*0.5f + 0.5f;
 	cf[2] = clamp(cf[2], 0.0f, 1.0f);
-	cf[3] = (cx*(-c-s) + cy*(-c+s))*0.5f + 0.5f;
+	cf[3] = (cx*( c-s) + cy*(-c-s))*0.5f + 0.5f;
 	cf[3] = clamp(cf[3], 0.0f, 1.0f);
 
 	float screenz = m_f2DNearScreenZ +
diff --git a/src/render/Sprite2d.cpp b/src/render/Sprite2d.cpp
index 3f21516a..1fe70121 100644
--- a/src/render/Sprite2d.cpp
+++ b/src/render/Sprite2d.cpp
@@ -5,13 +5,13 @@
 #include "Camera.h"
 #include "Sprite2d.h"
 
-RwIm2DVertex *CSprite2d::maVertices = (RwIm2DVertex*)0x6E9168;
-float &CSprite2d::RecipNearClip = *(float*)0x880DB4;
-int32 &CSprite2d::mCurrentBank = *(int32*)0x8F1AF4;
-RwTexture **CSprite2d::mpBankTextures = (RwTexture**)0x774DC0;
-int32 *CSprite2d::mCurrentSprite = (int32*)0x6F4500;
-int32 *CSprite2d::mBankStart = (int32*)0x774BE8;
-RwIm2DVertex *CSprite2d::maBankVertices = (RwIm2DVertex*)0x8429F8;
+RwIm2DVertex CSprite2d::maVertices[4];
+float CSprite2d::RecipNearClip;
+int32 CSprite2d::mCurrentBank;
+RwTexture *CSprite2d::mpBankTextures[10];
+int32 CSprite2d::mCurrentSprite[10];
+int32 CSprite2d::mBankStart[10];
+RwIm2DVertex CSprite2d::maBankVertices[500];
 
 void
 CSprite2d::SetRecipNearClip(void)
diff --git a/src/render/Sprite2d.h b/src/render/Sprite2d.h
index 268c7d2b..0b073557 100644
--- a/src/render/Sprite2d.h
+++ b/src/render/Sprite2d.h
@@ -2,13 +2,13 @@
 
 class CSprite2d
 {
-	static float &RecipNearClip;
-	static int32 &mCurrentBank;
-	static RwTexture **mpBankTextures;	//[10];
-	static int32 *mCurrentSprite;	//[10];
-	static int32 *mBankStart;	//[10];
-	static RwIm2DVertex *maBankVertices;	//[500];
-	static RwIm2DVertex *maVertices;	//[4];
+	static float RecipNearClip;
+	static int32 mCurrentBank;
+	static RwTexture *mpBankTextures[10];
+	static int32 mCurrentSprite[10];
+	static int32 mBankStart[10];
+	static RwIm2DVertex maBankVertices[500];
+	static RwIm2DVertex maVertices[4];
 public:
 	RwTexture *m_pTexture;
 
diff --git a/src/render/Weather.cpp b/src/render/Weather.cpp
index b440e77c..7aa2778f 100644
--- a/src/render/Weather.cpp
+++ b/src/render/Weather.cpp
@@ -126,7 +126,7 @@ void CWeather::Update(void)
 		if (ForcedWeatherType >= 0)
 			NewWeatherType = ForcedWeatherType;
 		else {
-			WeatherTypeInList = (WeatherTypeInList + 1) % ARRAYSIZE(WeatherTypesList);
+			WeatherTypeInList = (WeatherTypeInList + 1) % ARRAY_SIZE(WeatherTypesList);
 			NewWeatherType = WeatherTypesList[WeatherTypeInList];
 #ifdef FIX_BUGS
 		}
diff --git a/src/rw/ClumpRead.cpp b/src/rw/ClumpRead.cpp
index c9f027e7..0bf62f32 100644
--- a/src/rw/ClumpRead.cpp
+++ b/src/rw/ClumpRead.cpp
@@ -153,7 +153,7 @@ RpClumpGtaStreamRead1(RwStream *stream)
 
 	if(!RwStreamFindChunk(stream, rwID_FRAMELIST, nil, &version))
 		return false;
-	if(_rwFrameListStreamRead(stream, &gFrameList) == nil)
+	if(rwFrameListStreamRead(stream, &gFrameList) == nil)
 		return false;
 
 	if(!RwStreamFindChunk(stream, rwID_GEOMETRYLIST, nil, &version)){
@@ -164,7 +164,7 @@ RpClumpGtaStreamRead1(RwStream *stream)
 		rwFrameListDeinitialize(&gFrameList);
 		return false;
 	}
-	streamPosition = stream->Type.memory.position;
+	streamPosition = STREAMPOS(stream);
 	return true;
 }
 
@@ -180,7 +180,7 @@ RpClumpGtaStreamRead2(RwStream *stream)
 	if(clump == nil)
 		return nil;
 
-	RwStreamSkip(stream, streamPosition - stream->Type.memory.position);
+	RwStreamSkip(stream, streamPosition - STREAMPOS(stream));
 
 	if(GeometryListStreamRead2(stream, &gGeomList) == nil){
 		GeometryListDeinitialize(&gGeomList);
diff --git a/src/rw/Lights.cpp b/src/rw/Lights.cpp
index cd83a898..9218a055 100644
--- a/src/rw/Lights.cpp
+++ b/src/rw/Lights.cpp
@@ -9,18 +9,18 @@
 #include "ZoneCull.h"
 #include "Frontend.h"
 
-RpLight *&pAmbient = *(RpLight**)0x885B6C;
-RpLight *&pDirect = *(RpLight**)0x880F7C;
-RpLight **pExtraDirectionals = (RpLight**)0x60009C;
-int *LightStrengths = (int*)0x87BEF0;
-int &NumExtraDirLightsInWorld = *(int*)0x64C608;
-
-RwRGBAReal &AmbientLightColourForFrame = *(RwRGBAReal*)0x6F46F8;
-RwRGBAReal &AmbientLightColourForFrame_PedsCarsAndObjects = *(RwRGBAReal*)0x6F1D10;
-RwRGBAReal &DirectionalLightColourForFrame = *(RwRGBAReal*)0x87C6B8;
-
-RwRGBAReal &AmbientLightColour = *(RwRGBAReal*)0x86B0F8;
-RwRGBAReal &DirectionalLightColour = *(RwRGBAReal*)0x72E308;
+RpLight *pAmbient;// = *(RpLight**)0x885B6C;
+RpLight *pDirect;// = *(RpLight**)0x880F7C;
+RpLight *pExtraDirectionals[] = { nil, nil, nil, nil };// = (RpLight**)0x60009C;
+int LightStrengths[4];// = (int*)0x87BEF0;
+int NumExtraDirLightsInWorld;// = *(int*)0x64C608;
+
+RwRGBAReal AmbientLightColourForFrame;// = *(RwRGBAReal*)0x6F46F8;
+RwRGBAReal AmbientLightColourForFrame_PedsCarsAndObjects;// = *(RwRGBAReal*)0x6F1D10;
+RwRGBAReal DirectionalLightColourForFrame;// = *(RwRGBAReal*)0x87C6B8;
+
+RwRGBAReal AmbientLightColour;// = *(RwRGBAReal*)0x86B0F8;
+RwRGBAReal DirectionalLightColour;// = *(RwRGBAReal*)0x72E308;
 
 void
 SetLightsWithTimeOfDayColour(RpWorld *)
diff --git a/src/rw/NodeName.cpp b/src/rw/NodeName.cpp
index 2aea3c83..7422a323 100644
--- a/src/rw/NodeName.cpp
+++ b/src/rw/NodeName.cpp
@@ -2,7 +2,7 @@
 #include "patcher.h"
 #include "NodeName.h"
 
-static int32 &gPluginOffset = *(int32*)0x64C610;
+static int32 gPluginOffset;// = *(int32*)0x64C610;
 
 enum
 {
diff --git a/src/rw/RwHelper.cpp b/src/rw/RwHelper.cpp
index 44ca3a0a..cf1a6f2b 100644
--- a/src/rw/RwHelper.cpp
+++ b/src/rw/RwHelper.cpp
@@ -90,9 +90,13 @@ DefinedState(void)
 	RwRenderStateSet(rwRENDERSTATEFOGTYPE, (void*)rwFOGTYPELINEAR);
 	RwRenderStateSet(rwRENDERSTATECULLMODE, (void*)rwCULLMODECULLNONE);
 
+#ifdef LIBRW
+	#pragma message ("	TODO: alphatest func")
+#else
 	// D3D stuff
 	RwD3D8SetRenderState(D3DRS_ALPHAFUNC, D3DCMP_GREATER);
 	RwD3D8SetRenderState(D3DRS_ALPHAREF, 2);
+#endif
 }
 
 RwFrame*
diff --git a/src/rw/RwMatFX.cpp b/src/rw/RwMatFX.cpp
index 3af6fabe..c4fe0b0b 100644
--- a/src/rw/RwMatFX.cpp
+++ b/src/rw/RwMatFX.cpp
@@ -1,3 +1,5 @@
+#ifndef LIBRW
+
 #define WITHD3D
 #include "common.h"
 #include "patcher.h"
@@ -224,3 +226,5 @@ STARTPATCHES
 ENDPATCHES
 
 #endif
+
+#endif
diff --git a/src/rw/TexRead.cpp b/src/rw/TexRead.cpp
index 50b99d47..1ac5a75e 100644
--- a/src/rw/TexRead.cpp
+++ b/src/rw/TexRead.cpp
@@ -22,8 +22,14 @@
 #include "RwHelper.h"
 #endif //GTA_PC
 
-float &texLoadTime = *(float*)0x8F1B50;
-int32 &texNumLoaded = *(int32*)0x8F252C;
+float texLoadTime;// = *(float*)0x8F1B50;
+int32 texNumLoaded;// = *(int32*)0x8F252C;
+
+#ifdef LIBRW
+#define READNATIVE(stream, tex, size) rwNativeTextureHackRead(stream, tex, size)
+#else
+#define READNATIVE(stream, tex, size) RWSRCGLOBAL(stdFunc[rwSTANDARDNATIVETEXTUREREAD](stream, tex, size))
+#endif
 
 RwTexture*
 RwTextureGtaStreamRead(RwStream *stream)
@@ -36,7 +42,7 @@ RwTextureGtaStreamRead(RwStream *stream)
 
 	float preloadTime = (float)CTimer::GetCurrentTimeInCycles() / (float)CTimer::GetCyclesPerMillisecond();
 
-	if(!RWSRCGLOBAL(stdFunc[rwSTANDARDNATIVETEXTUREREAD](stream, &tex, size)))
+	if(!READNATIVE(stream, &tex, size))
 		return nil;
 
 	if (gGameState == GS_INIT_PLAYING_GAME) {
@@ -64,7 +70,9 @@ RwTexDictionaryGtaStreamRead(RwStream *stream)
 	if(!RwStreamFindChunk(stream, rwID_STRUCT, &size, &version))
 		return nil;
 	assert(size == 4);
-	if(RwStreamRead(stream, &numTextures, size) != size)
+int foo = RwStreamRead(stream, &numTextures, size);
+if(foo != size)
+//	if(RwStreamRead(stream, &numTextures, size) != size)
 		return nil;
 
 	texDict = RwTexDictionaryCreate();
@@ -121,7 +129,7 @@ RwTexDictionaryGtaStreamRead1(RwStream *stream)
 	}
 
 	numberTextures = numTextures;
-	streamPosition = stream->Type.memory.position;
+	streamPosition = STREAMPOS(stream);
 
 	return texDict;
 }
@@ -131,7 +139,7 @@ RwTexDictionaryGtaStreamRead2(RwStream *stream, RwTexDictionary *texDict)
 {
 	RwTexture *tex;
 
-	RwStreamSkip(stream, streamPosition - stream->Type.memory.position);
+	RwStreamSkip(stream, streamPosition - STREAMPOS(stream));
 
 	while(numberTextures--){
 		tex = RwTextureGtaStreamRead(stream);
@@ -150,9 +158,8 @@ RwTexDictionaryGtaStreamRead2(RwStream *stream, RwTexDictionary *texDict)
 #ifdef RWLIBS
 extern "C" RwInt32 _rwD3D8FindCorrectRasterFormat(RwRasterType type, RwInt32 flags);
 #else
-WRAPPER RwInt32 _rwD3D8FindCorrectRasterFormat(RwRasterType type, RwInt32 flags) { EAXJMP(0x59A350); }
+RwInt32 _rwD3D8FindCorrectRasterFormat(RwRasterType type, RwInt32 flags);
 #endif
-
 void
 ReadVideoCardCapsFile(uint32 &cap32, uint32 &cap24, uint32 &cap16, uint32 &cap8)
 {
@@ -251,6 +258,12 @@ DealWithTxdWriteError(uint32 num, uint32 count, const char *text)
 	RsGlobal.quit = true;
 }
 
+#ifdef LIBRW
+#define STREAMTELL(str)	str->tell()
+#else
+#define STREAMTELL(str) filesys->rwftell((str)->Type.file.fpFile)
+#endif
+
 bool
 CreateTxdImageForVideoCard()
 {
@@ -260,7 +273,9 @@ CreateTxdImageForVideoCard()
 
 	CStreaming::FlushRequestList();
 
+#ifndef LIBRW
 	RwFileFunctions *filesys = RwOsGetFileInterface();
+#endif
 
 	RwStream *img = RwStreamOpen(rwSTREAMFILENAME, rwSTREAMWRITE, "models\\txd.img");
 	if (img == nil) {
@@ -287,7 +302,8 @@ CreateTxdImageForVideoCard()
 			sprintf(filename, "%s.txd", CTxdStore::GetTxdName(i));
 
 			if (CTxdStore::GetSlot(i)->texDict) {
-				int32 pos = filesys->rwftell(img->Type.file.fpFile);
+
+				int32 pos = STREAMTELL(img);
 
 				if (RwTexDictionaryStreamWrite(CTxdStore::GetSlot(i)->texDict, img) == nil) {
 					DealWithTxdWriteError(i, TXDSTORESIZE, "CVT_ERR");
@@ -298,7 +314,7 @@ CreateTxdImageForVideoCard()
 					return false;
 				}
 
-				int32 size = filesys->rwftell(img->Type.file.fpFile) - pos;
+				int32 size = STREAMTELL(img) - pos;
 				int32 num = size % CDSTREAM_SECTOR_SIZE;
 
 				size /= CDSTREAM_SECTOR_SIZE;
diff --git a/src/rw/TxdStore.cpp b/src/rw/TxdStore.cpp
index c751147d..a32755a4 100644
--- a/src/rw/TxdStore.cpp
+++ b/src/rw/TxdStore.cpp
@@ -6,8 +6,8 @@
 #include "RwHelper.h"
 #include "TxdStore.h"
 
-CPool<TxdDef,TxdDef> *&CTxdStore::ms_pTxdPool = *(CPool<TxdDef,TxdDef>**)0x8F5FB8;
-RwTexDictionary *&CTxdStore::ms_pStoredTxd = *(RwTexDictionary**)0x9405BC;
+CPool<TxdDef,TxdDef> *CTxdStore::ms_pTxdPool;// = *(CPool<TxdDef,TxdDef>**)0x8F5FB8;
+RwTexDictionary *CTxdStore::ms_pStoredTxd;// = *(RwTexDictionary**)0x9405BC;
 
 void
 CTxdStore::Initialise(void)
diff --git a/src/rw/TxdStore.h b/src/rw/TxdStore.h
index 12ac708f..937fd1b7 100644
--- a/src/rw/TxdStore.h
+++ b/src/rw/TxdStore.h
@@ -10,8 +10,8 @@ struct TxdDef {
 
 class CTxdStore
 {
-	static CPool<TxdDef,TxdDef> *&ms_pTxdPool;
-	static RwTexDictionary *&ms_pStoredTxd;
+	static CPool<TxdDef,TxdDef> *ms_pTxdPool;
+	static RwTexDictionary *ms_pStoredTxd;
 public:
 	static void Initialise(void);
 	static void Shutdown(void);
diff --git a/src/rw/VisibilityPlugins.cpp b/src/rw/VisibilityPlugins.cpp
index f8b1f6b2..5438ed0f 100644
--- a/src/rw/VisibilityPlugins.cpp
+++ b/src/rw/VisibilityPlugins.cpp
@@ -11,40 +11,37 @@
 
 #define FADE_DISTANCE 20.0f
 
-/*
-CLinkList<CVisibilityPlugins::AlphaObjectInfo> CVisibilityPlugins::m_alphaList;
-CLinkList<CVisibilityPlugins::AlphaObjectInfo> CVisibilityPlugins::m_alphaEntityList;
-
-int32 CVisibilityPlugins::ms_atomicPluginOffset = -1;
-int32 CVisibilityPlugins::ms_framePluginOffset = -1;
-int32 CVisibilityPlugins::ms_clumpPluginOffset = -1;
-*/
-CLinkList<CVisibilityPlugins::AlphaObjectInfo> &CVisibilityPlugins::m_alphaList = *(CLinkList<CVisibilityPlugins::AlphaObjectInfo>*)0x8F42E4;
-CLinkList<CVisibilityPlugins::AlphaObjectInfo> &CVisibilityPlugins::m_alphaEntityList = *(CLinkList<CVisibilityPlugins::AlphaObjectInfo>*)0x943084;
-
-int32 &CVisibilityPlugins::ms_atomicPluginOffset = *(int32*)0x600124;
-int32 &CVisibilityPlugins::ms_framePluginOffset = *(int32*)0x600128;
-int32 &CVisibilityPlugins::ms_clumpPluginOffset = *(int32*)0x60012C;
-
-RwCamera *&CVisibilityPlugins::ms_pCamera = *(RwCamera**)0x8F2514;
-RwV3d *&CVisibilityPlugins::ms_pCameraPosn = *(RwV3d**)0x8F6270;
-float &CVisibilityPlugins::ms_cullCompsDist = *(float*)0x8F2BC4;
-float &CVisibilityPlugins::ms_vehicleLod0Dist = *(float*)0x885B28;
-float &CVisibilityPlugins::ms_vehicleLod1Dist = *(float*)0x885B30;
-float &CVisibilityPlugins::ms_vehicleFadeDist = *(float*)0x8E28B4;
-float &CVisibilityPlugins::ms_bigVehicleLod0Dist = *(float*)0x8E2A84;
-float &CVisibilityPlugins::ms_bigVehicleLod1Dist = *(float*)0x8E2A8C;
-float &CVisibilityPlugins::ms_pedLod0Dist = *(float*)0x8F2BD4;
-float &CVisibilityPlugins::ms_pedLod1Dist = *(float*)0x8F2BD8;
-float &CVisibilityPlugins::ms_pedFadeDist = *(float*)0x8E2C34;
+CLinkList<CVisibilityPlugins::AlphaObjectInfo> CVisibilityPlugins::m_alphaList;// = *(CLinkList<CVisibilityPlugins::AlphaObjectInfo>*)0x8F42E4;
+CLinkList<CVisibilityPlugins::AlphaObjectInfo> CVisibilityPlugins::m_alphaEntityList;// = *(CLinkList<CVisibilityPlugins::AlphaObjectInfo>*)0x943084;
+
+int32 CVisibilityPlugins::ms_atomicPluginOffset = -1;// = *(int32*)0x600124;
+int32 CVisibilityPlugins::ms_framePluginOffset = -1;// = *(int32*)0x600128;
+int32 CVisibilityPlugins::ms_clumpPluginOffset = -1;// = *(int32*)0x60012C;
+
+RwCamera *CVisibilityPlugins::ms_pCamera;// = *(RwCamera**)0x8F2514;
+RwV3d *CVisibilityPlugins::ms_pCameraPosn;// = *(RwV3d**)0x8F6270;
+float CVisibilityPlugins::ms_cullCompsDist;// = *(float*)0x8F2BC4;
+float CVisibilityPlugins::ms_vehicleLod0Dist;// = *(float*)0x885B28;
+float CVisibilityPlugins::ms_vehicleLod1Dist;// = *(float*)0x885B30;
+float CVisibilityPlugins::ms_vehicleFadeDist;// = *(float*)0x8E28B4;
+float CVisibilityPlugins::ms_bigVehicleLod0Dist;// = *(float*)0x8E2A84;
+float CVisibilityPlugins::ms_bigVehicleLod1Dist;// = *(float*)0x8E2A8C;
+float CVisibilityPlugins::ms_pedLod0Dist;// = *(float*)0x8F2BD4;
+float CVisibilityPlugins::ms_pedLod1Dist;// = *(float*)0x8F2BD8;
+float CVisibilityPlugins::ms_pedFadeDist;// = *(float*)0x8E2C34;
 
 void
 CVisibilityPlugins::Initialise(void)
 {
-	m_alphaList.Init(20);
+	m_alphaList.Init(NUMALPHALIST);
 	m_alphaList.head.item.sort = 0.0f;
 	m_alphaList.tail.item.sort = 100000000.0f;
-	m_alphaEntityList.Init(150);
+#ifdef ASPECT_RATIO_SCALE
+	// default 150 if not enough for bigger FOVs
+	m_alphaEntityList.Init(NUMALPHAENTITYLIST * 3);
+#else
+	m_alphaEntityList.Init(NUMALPHAENTITYLIST);
+#endif // ASPECT_RATIO_SCALE
 	m_alphaEntityList.head.item.sort = 0.0f;
 	m_alphaEntityList.tail.item.sort = 100000000.0f;
 }
@@ -603,6 +600,16 @@ CVisibilityPlugins::DefaultVisibilityCB(RpClump *clump)
 }
 
 bool
+CVisibilityPlugins::MloVisibilityCB(RpClump *clump)
+{
+	RwFrame *frame = RpClumpGetFrame(clump);
+	CMloModelInfo *modelInfo = (CMloModelInfo*)GetFrameHierarchyId(frame);
+	if (sq(modelInfo->field_34) < GetDistanceSquaredFromCamera(frame))
+		return false;
+	return CVisibilityPlugins::FrustumSphereCB(clump);
+}
+
+bool
 CVisibilityPlugins::FrustumSphereCB(RpClump *clump)
 {
 	RwSphere sphere;
diff --git a/src/rw/VisibilityPlugins.h b/src/rw/VisibilityPlugins.h
index 65d2675a..63bc95e4 100644
--- a/src/rw/VisibilityPlugins.h
+++ b/src/rw/VisibilityPlugins.h
@@ -20,19 +20,19 @@ public:
 		float sort;
 	};
 
-	static CLinkList<AlphaObjectInfo> &m_alphaList;
-	static CLinkList<AlphaObjectInfo> &m_alphaEntityList;
-	static RwCamera *&ms_pCamera;
-	static RwV3d *&ms_pCameraPosn;
-	static float &ms_cullCompsDist;
-	static float &ms_vehicleLod0Dist;
-	static float &ms_vehicleLod1Dist;
-	static float &ms_vehicleFadeDist;
-	static float &ms_bigVehicleLod0Dist;
-	static float &ms_bigVehicleLod1Dist;
-	static float &ms_pedLod0Dist;
-	static float &ms_pedLod1Dist;
-	static float &ms_pedFadeDist;
+	static CLinkList<AlphaObjectInfo> m_alphaList;
+	static CLinkList<AlphaObjectInfo> m_alphaEntityList;
+	static RwCamera *ms_pCamera;
+	static RwV3d *ms_pCameraPosn;
+	static float ms_cullCompsDist;
+	static float ms_vehicleLod0Dist;
+	static float ms_vehicleLod1Dist;
+	static float ms_vehicleFadeDist;
+	static float ms_bigVehicleLod0Dist;
+	static float ms_bigVehicleLod1Dist;
+	static float ms_pedLod0Dist;
+	static float ms_pedLod1Dist;
+	static float ms_pedFadeDist;
 
 	static void Initialise(void);
 	static void Shutdown(void);
@@ -70,7 +70,7 @@ public:
 	// All actually unused
 	static bool DefaultVisibilityCB(RpClump *clump);
 	static bool FrustumSphereCB(RpClump *clump);
-//	static bool MloVisibilityCB(RpClump *clump);
+	static bool MloVisibilityCB(RpClump *clump);
 	static bool VehicleVisibilityCB(RpClump *clump);
 	static bool VehicleVisibilityCB_BigVehicle(RpClump *clump);
 
@@ -97,7 +97,7 @@ public:
 	static void *AtomicDestructor(void *object, int32 offset, int32 len);
 	static void *AtomicCopyConstructor(void *dst, const void *src,
 	                                   int32 offset, int32 len);
-	static int32 &ms_atomicPluginOffset;
+	static int32 ms_atomicPluginOffset;
 
 	struct FrameExt
 	{
@@ -111,7 +111,7 @@ public:
 	static void *FrameDestructor(void *object, int32 offset, int32 len);
 	static void *FrameCopyConstructor(void *dst, const void *src,
 	                                  int32 offset, int32 len);
-	static int32 &ms_framePluginOffset;
+	static int32 ms_framePluginOffset;
 
 	// Not actually used
 	struct ClumpExt
@@ -127,7 +127,7 @@ public:
 	static void *ClumpDestructor(void *object, int32 offset, int32 len);
 	static void *ClumpCopyConstructor(void *dst, const void *src,
 	                                  int32 offset, int32 len);
-	static int32 &ms_clumpPluginOffset;
+	static int32 ms_clumpPluginOffset;
 
 	static bool PluginAttach(void);
 };
diff --git a/src/rw/rw.cpp b/src/rw/rw.cpp
index 3875f2a1..c525f49f 100644
--- a/src/rw/rw.cpp
+++ b/src/rw/rw.cpp
@@ -1,3 +1,4 @@
+#ifndef LIBRW
 #include "common.h"
 #include "patcher.h"
 #include "rwcore.h"
@@ -414,6 +415,9 @@ WRAPPER RxNodeDefinition* RxNodeDefinitionGetMaterialScatter() { EAXJMP(0x5DDAA0
 WRAPPER RxNodeDefinition* RxNodeDefinitionGetLight() { EAXJMP(0x5DF040); }
 WRAPPER RxNodeDefinition* RxNodeDefinitionGetPostLight() { EAXJMP(0x5DF560); }
 WRAPPER void RxD3D8AllInOneSetRenderCallBack(RxPipelineNode* node, RxD3D8AllInOneRenderCallBack callback) { EAXJMP(0x5DFC60); }
+
+WRAPPER RwInt32 _rwD3D8FindCorrectRasterFormat(RwRasterType type, RwInt32 flags) { EAXJMP(0x59A350); }
+
 #else
 
 extern "C"
@@ -432,6 +436,8 @@ extern "C"
     void* _rwVectorOpen(void* instance, RwInt32 offset, RwInt32 size);
     RwBool _rwPluginRegistryOpen();
     RwBool _rwPluginRegistryClose();
+
+    RwInt32 _rwD3D8FindCorrectRasterFormat(RwRasterType type, RwInt32 flags);
 }
 
 STARTPATCHES
@@ -836,4 +842,5 @@ InjectHook(0x5DF040, &RxNodeDefinitionGetLight, PATCH_JUMP);
 InjectHook(0x5DF560, &RxNodeDefinitionGetPostLight, PATCH_JUMP);
 InjectHook(0x5DFC60, &RxD3D8AllInOneSetRenderCallBack, PATCH_JUMP);
 ENDPATCHES
+#endif
 #endif
 \ No newline at end of file
diff --git a/src/save/GenericGameStorage.cpp b/src/save/GenericGameStorage.cpp
index 0ec0b117..0bae979b 100644
--- a/src/save/GenericGameStorage.cpp
+++ b/src/save/GenericGameStorage.cpp
@@ -40,22 +40,22 @@
 
 const uint32 SIZE_OF_ONE_GAME_IN_BYTES = 201729;
 
-char (&DefaultPCSaveFileName)[260] = *(char(*)[260])*(uintptr*)0x8E28C0;
-char (&ValidSaveName)[260] = *(char(*)[260])*(uintptr*)0x8E2CBC;
-char (&LoadFileName)[256] = *(char(*)[256])*(uintptr*)0x9403C4;
-wchar (&SlotFileName)[SLOT_COUNT][260] = *(wchar(*)[SLOT_COUNT][260])*(uintptr*)0x6F07C8;
-wchar (&SlotSaveDate)[SLOT_COUNT][70] = *(wchar(*)[SLOT_COUNT][70])*(uintptr*)0x72B858;
-int &CheckSum = *(int*)0x8E2BE0;
-eLevelName &m_LevelToLoad = *(eLevelName*)0x8E29CC;
+char DefaultPCSaveFileName[260];// = *(char(*)[260]) * (uintptr*)0x8E28C0;
+char ValidSaveName[260];// = *(char(*)[260])*(uintptr*)0x8E2CBC;
+char LoadFileName[256];// = *(char(*)[256])*(uintptr*)0x9403C4;
+wchar SlotFileName[SLOT_COUNT][260];// = *(wchar(*)[SLOT_COUNT][260])*(uintptr*)0x6F07C8;
+wchar SlotSaveDate[SLOT_COUNT][70];// = *(wchar(*)[SLOT_COUNT][70])*(uintptr*)0x72B858;
+int CheckSum;// = *(int*)0x8E2BE0;
+eLevelName m_LevelToLoad;// = *(eLevelName*)0x8E29CC;
 char SaveFileNameJustSaved[260];
-int (&Slots)[SLOT_COUNT+1] = *(int(*)[SLOT_COUNT+1])*(uintptr*)0x72803C;
-CDate &CompileDateAndTime = *(CDate*)0x72BCB8;
+int Slots[SLOT_COUNT+1];// = *(int(*)[SLOT_COUNT+1])*(uintptr*)0x72803C;
+CDate CompileDateAndTime;// = *(CDate*)0x72BCB8;
 
-bool &b_FoundRecentSavedGameWantToLoad = *(bool*)0x95CDA8;
-bool &JustLoadedDontFadeInYet = *(bool*)0x95CDB4;
-bool &StillToFadeOut = *(bool*)0x95CD99;
-uint32 &TimeStartedCountingForFade = *(uint32*)0x9430EC;
-uint32 &TimeToStayFadedBeforeFadeOut = *(uint32*)0x611564;
+bool b_FoundRecentSavedGameWantToLoad;// = *(bool*)0x95CDA8;
+bool JustLoadedDontFadeInYet;// = *(bool*)0x95CDB4;
+bool StillToFadeOut;// = *(bool*)0x95CD99;
+uint32 TimeStartedCountingForFade;// = *(uint32*)0x9430EC;
+uint32 TimeToStayFadedBeforeFadeOut = 1750;// = *(uint32*)0x611564;
 
 #define ReadDataFromBufferPointer(buf, to) memcpy(&to, buf, sizeof(to)); buf += align4bytes(sizeof(to));
 #define WriteDataToBufferPointer(buf, from) memcpy(buf, &from, sizeof(from)); buf += align4bytes(sizeof(from));
@@ -154,8 +154,17 @@ GenericSave(int file)
 	WriteDataToBufferPointer(buf, CompileDateAndTime.m_nMonth);
 	WriteDataToBufferPointer(buf, CompileDateAndTime.m_nYear);
 	WriteDataToBufferPointer(buf, CWeather::WeatherTypeInList);
+#ifdef FIX_BUGS
+	// converted to float for compatibility with original format
+	// TODO: maybe remove this? not really gonna break anything vital
+	float f = TheCamera.CarZoomIndicator;
+	WriteDataToBufferPointer(buf, f);
+	f = TheCamera.PedZoomIndicator;
+	WriteDataToBufferPointer(buf, f);
+#else
 	WriteDataToBufferPointer(buf, TheCamera.CarZoomIndicator);
 	WriteDataToBufferPointer(buf, TheCamera.PedZoomIndicator);
+#endif
 	assert(buf - work_buff == SIZE_OF_SIMPLEVARS);
 
 	// Save scripts, block is nested within the same block as simple vars for some reason
@@ -264,8 +273,18 @@ GenericLoad()
 	ReadDataFromBufferPointer(buf, CompileDateAndTime.m_nMonth);
 	ReadDataFromBufferPointer(buf, CompileDateAndTime.m_nYear);
 	ReadDataFromBufferPointer(buf, CWeather::WeatherTypeInList);
+#ifdef FIX_BUGS
+	// converted to float for compatibility with original format
+	// TODO: maybe remove this? not really gonna break anything vital
+	float f;
+	ReadDataFromBufferPointer(buf, f);
+	TheCamera.CarZoomIndicator = f;
+	ReadDataFromBufferPointer(buf, f);
+	TheCamera.PedZoomIndicator = f;
+#else
 	ReadDataFromBufferPointer(buf, TheCamera.CarZoomIndicator);
 	ReadDataFromBufferPointer(buf, TheCamera.PedZoomIndicator);
+#endif
 	assert(buf - work_buff == SIZE_OF_SIMPLEVARS);
 	ReadDataFromBlock("Loading Scripts \n", CTheScripts::LoadAllScripts);
 
diff --git a/src/save/GenericGameStorage.h b/src/save/GenericGameStorage.h
index e6fd2e2d..b913c305 100644
--- a/src/save/GenericGameStorage.h
+++ b/src/save/GenericGameStorage.h
@@ -21,22 +21,22 @@ bool CheckDataNotCorrupt(int32 slot, char *name);
 bool RestoreForStartLoad();
 int align4bytes(int32 size);
 
-extern class CDate& CompileDateAndTime;
-
-extern char (&DefaultPCSaveFileName)[260];
-extern char (&ValidSaveName)[260];
-extern char (&LoadFileName)[256];
-extern wchar (&SlotFileName)[SLOT_COUNT][260];
-extern wchar (&SlotSaveDate)[SLOT_COUNT][70];
-extern int &CheckSum;
-extern enum eLevelName &m_LevelToLoad;
-extern int (&Slots)[SLOT_COUNT+1];
-
-extern bool &b_FoundRecentSavedGameWantToLoad;
-extern bool &JustLoadedDontFadeInYet;
-extern bool &StillToFadeOut;
-extern uint32 &TimeStartedCountingForFade;
-extern uint32 &TimeToStayFadedBeforeFadeOut;
+extern class CDate CompileDateAndTime;
+
+extern char DefaultPCSaveFileName[260];
+extern char ValidSaveName[260];
+extern char LoadFileName[256];
+extern wchar SlotFileName[SLOT_COUNT][260];
+extern wchar SlotSaveDate[SLOT_COUNT][70];
+extern int CheckSum;
+extern enum eLevelName m_LevelToLoad;
+extern int Slots[SLOT_COUNT+1];
+
+extern bool b_FoundRecentSavedGameWantToLoad;
+extern bool JustLoadedDontFadeInYet;
+extern bool StillToFadeOut;
+extern uint32 TimeStartedCountingForFade;
+extern uint32 TimeToStayFadedBeforeFadeOut;
 
 extern char SaveFileNameJustSaved[260]; // 8F2570
 
diff --git a/src/save/PCSave.cpp b/src/save/PCSave.cpp
index 744f5e0d..4afcb645 100644
--- a/src/save/PCSave.cpp
+++ b/src/save/PCSave.cpp
@@ -9,7 +9,7 @@
 
 const char* _psGetUserFilesFolder();
 
-C_PcSave &PcSaveHelper = *(C_PcSave*)0x8E2C60;
+C_PcSave PcSaveHelper;// = *(C_PcSave*)0x8E2C60;
 
 void
 C_PcSave::SetSaveDirectory(const char *path)
diff --git a/src/save/PCSave.h b/src/save/PCSave.h
index c58a5c9e..4a2d9a66 100644
--- a/src/save/PCSave.h
+++ b/src/save/PCSave.h
@@ -37,4 +37,4 @@ public:
 	static void SetSaveDirectory(const char *path);
 };
 
-extern C_PcSave &PcSaveHelper;
+extern C_PcSave PcSaveHelper;
diff --git a/src/skel/win/win.cpp b/src/skel/win/win.cpp
index ec84e968..acc9650c 100644
--- a/src/skel/win/win.cpp
+++ b/src/skel/win/win.cpp
@@ -679,11 +679,17 @@ psInitialise(void)
 	_dwMemAvailVirtual = memstats.dwAvailVirtual;
 	
 	_GetVideoMemInfo(&_dwMemTotalVideo, &_dwMemAvailVideo);
-	
+#ifdef FIX_BUGS
+	debug("Physical memory size %u\n", _dwMemTotalPhys);
+	debug("Available physical memory %u\n", _dwMemAvailPhys);
+	debug("Video memory size %u\n", _dwMemTotalVideo);
+	debug("Available video memory %u\n", _dwMemAvailVideo);
+#else
 	debug("Physical memory size %d\n", _dwMemTotalPhys);
 	debug("Available physical memory %d\n", _dwMemAvailPhys);
 	debug("Video memory size %d\n", _dwMemTotalVideo);
 	debug("Available video memory %d\n", _dwMemAvailVideo);
+#endif
 	
 	if ( _dwMemAvailVideo < (12 * 1024 * 1024) /*12 MB*/ )
 	{
@@ -1321,12 +1327,23 @@ psSelectDevice()
 		}
 		else
 		{
+#ifdef DEFAULT_NATIVE_RESOLUTION
+			// get the native video mode
+			HDC hDevice = GetDC(NULL);
+			int w = GetDeviceCaps(hDevice, HORZRES);
+			int h = GetDeviceCaps(hDevice, VERTRES);
+			int d = GetDeviceCaps(hDevice, BITSPIXEL);
+#else
+			const int w = 640;
+			const int h = 480;
+			const int d = 16;
+#endif
 			while ( !modeFound && GcurSelVM < RwEngineGetNumVideoModes() )
 			{
 				RwEngineGetVideoModeInfo(&vm, GcurSelVM);
-				if ( defaultFullscreenRes	&& vm.width	 != 640 
-											|| vm.height != 480
-											|| vm.depth	 != 16
+				if ( defaultFullscreenRes	&& vm.width	 != w 
+											|| vm.height != h
+											|| vm.depth	 != d
 											|| !(vm.flags & rwVIDEOMODEEXCLUSIVE) )
 					++GcurSelVM;
 				else
@@ -1335,8 +1352,12 @@ psSelectDevice()
 			
 			if ( !modeFound )
 			{
+#ifdef DEFAULT_NATIVE_RESOLUTION
+				GcurSelVM = 1;
+#else
 				MessageBox(nil, "Cannot find 640x480 video mode", "GTA3", MB_OK);
 				return FALSE;
+#endif
 			}
 		}
 	}
diff --git a/src/text/Messages.cpp b/src/text/Messages.cpp
index 9896a8e0..4b181d67 100644
--- a/src/text/Messages.cpp
+++ b/src/text/Messages.cpp
@@ -12,9 +12,9 @@
 
 #include "ControllerConfig.h"
 
-tMessage(&CMessages::BriefMessages)[NUMBRIEFMESSAGES] = *(tMessage(*)[NUMBRIEFMESSAGES])*(uintptr*)0x8786E0;
-tPreviousBrief(&CMessages::PreviousBriefs)[NUMPREVIOUSBRIEFS] = *(tPreviousBrief(*)[NUMPREVIOUSBRIEFS])*(uintptr*)0x713C08;
-tBigMessage(&CMessages::BIGMessages)[NUMBIGMESSAGES] = *(tBigMessage(*)[NUMBIGMESSAGES])*(uintptr*)0x773628;
+tMessage CMessages::BriefMessages[NUMBRIEFMESSAGES];// = *(tMessage(*)[NUMBRIEFMESSAGES]) * (uintptr*)0x8786E0;
+tPreviousBrief CMessages::PreviousBriefs[NUMPREVIOUSBRIEFS];// = *(tPreviousBrief(*)[NUMPREVIOUSBRIEFS]) * (uintptr*)0x713C08;
+tBigMessage CMessages::BIGMessages[NUMBIGMESSAGES];// = *(tBigMessage(*)[NUMBIGMESSAGES]) * (uintptr*)0x773628;
 char CMessages::PreviousMissionTitle[16]; // unused
 
 void
diff --git a/src/text/Messages.h b/src/text/Messages.h
index 8044c626..e8ba1bf7 100644
--- a/src/text/Messages.h
+++ b/src/text/Messages.h
@@ -29,9 +29,9 @@ struct tPreviousBrief
 class CMessages 
 {
 public:
-	static tMessage(&BriefMessages)[NUMBRIEFMESSAGES];
-	static tBigMessage(&BIGMessages)[NUMBIGMESSAGES];
-	static tPreviousBrief(&PreviousBriefs)[NUMPREVIOUSBRIEFS];
+	static tMessage BriefMessages[NUMBRIEFMESSAGES];
+	static tBigMessage BIGMessages[NUMBIGMESSAGES];
+	static tPreviousBrief PreviousBriefs[NUMPREVIOUSBRIEFS];
 	static char PreviousMissionTitle[16]; // unused
 public:
 	static void Init(void);
diff --git a/src/text/Text.cpp b/src/text/Text.cpp
index 5fc19f12..b3da27e8 100644
--- a/src/text/Text.cpp
+++ b/src/text/Text.cpp
@@ -7,7 +7,7 @@
 
 static wchar WideErrorString[25];
 
-CText &TheText = *(CText*)0x941520;
+CText TheText;// = *(CText*)0x941520;
 
 CText::CText(void)
 {
diff --git a/src/text/Text.h b/src/text/Text.h
index 6f39ba49..00d1c5e6 100644
--- a/src/text/Text.h
+++ b/src/text/Text.h
@@ -56,4 +56,4 @@ public:
 	void UpperCase(wchar *s);
 };
 
-extern CText &TheText;
+extern CText TheText;
diff --git a/src/vehicles/Automobile.cpp b/src/vehicles/Automobile.cpp
index 257c8d33..12d4f589 100644
--- a/src/vehicles/Automobile.cpp
+++ b/src/vehicles/Automobile.cpp
@@ -49,7 +49,7 @@ bool bAllCarCheat;	// unused
 
 RwObject *GetCurrentAtomicObjectCB(RwObject *object, void *data);
 
-bool &CAutomobile::m_sAllTaxiLights = *(bool*)0x95CD21;
+bool CAutomobile::m_sAllTaxiLights;// = *(bool*)0x95CD21;
 
 CAutomobile::CAutomobile(int32 id, uint8 CreatedBy)
  : CVehicle(CreatedBy)
@@ -356,7 +356,7 @@ CAutomobile::ProcessControl(void)
 
 			PruneReferences();
 
-			if(m_status == STATUS_PLAYER && CRecordDataForChase::IsRecording())
+			if(m_status == STATUS_PLAYER && !CRecordDataForChase::IsRecording())
 				DoDriveByShootings();
 		}
 		break;
@@ -4206,8 +4206,7 @@ GetCurrentAtomicObjectCB(RwObject *object, void *data)
 	return object;
 }
 
-CColPoint aTempPedColPts[32];	// this name doesn't make any sense
-								// they probably copied it from Ped (both serves same purpose) and didn't change the name
+CColPoint spherepoints[MAX_COLLISION_POINTS];
 
 CObject*
 CAutomobile::SpawnFlyingComponent(int32 component, uint32 type)
@@ -4327,7 +4326,7 @@ CAutomobile::SpawnFlyingComponent(int32 component, uint32 type)
 
 	if(CCollision::ProcessColModels(obj->GetMatrix(), *obj->GetColModel(),
 			this->GetMatrix(), *this->GetColModel(),
-			aTempPedColPts, nil, nil) > 0)
+			spherepoints, nil, nil) > 0)
 		obj->m_pCollidingEntity = this;
 
 	if(bRenderScorched)
diff --git a/src/vehicles/Automobile.h b/src/vehicles/Automobile.h
index 561ab566..66774612 100644
--- a/src/vehicles/Automobile.h
+++ b/src/vehicles/Automobile.h
@@ -120,7 +120,7 @@ public:
 	float m_fGasPedalAudio;
 	tWheelState m_aWheelState[4];
 
-	static bool &m_sAllTaxiLights;
+	static bool m_sAllTaxiLights;
 
 	CAutomobile(int32 id, uint8 CreatedBy);
 
diff --git a/src/vehicles/Boat.cpp b/src/vehicles/Boat.cpp
index 0159d168..d694d8b0 100644
--- a/src/vehicles/Boat.cpp
+++ b/src/vehicles/Boat.cpp
@@ -21,16 +21,16 @@
 
 #define INVALID_ORIENTATION (-9999.99f)
 
-float &fShapeLength = *(float*)0x600E78;
-float &fShapeTime   = *(float*)0x600E7C;
-float &fRangeMult   = *(float*)0x600E80; //0.6f; // 0.75f gta 3
-float &fTimeMult = *(float*)0x943008;
+float fShapeLength = 0.4f;// *(float*)0x600E78;
+float fShapeTime = 0.05f;// *(float*)0x600E7C;
+float fRangeMult = 0.75f; // = *(float*)0x600E80; //0.6f; // 0.75f gta 3
+float fTimeMult;// = *(float*)0x943008;
 
 float MAX_WAKE_LENGTH = 50.0f;
 float MIN_WAKE_INTERVAL = 1.0f;
 float WAKE_LIFETIME = 400.0f;
 
-CBoat * (&CBoat::apFrameWakeGeneratingBoats)[4] = *(CBoat * (*)[4])*(uintptr*)0x8620E0;
+CBoat *CBoat::apFrameWakeGeneratingBoats[4];// = *(CBoat * (*)[4]) * (uintptr*)0x8620E0;
 
 CBoat::CBoat(int mi, uint8 owner) : CVehicle(owner)
 {
diff --git a/src/vehicles/Boat.h b/src/vehicles/Boat.h
index f4c6a747..ba56e355 100644
--- a/src/vehicles/Boat.h
+++ b/src/vehicles/Boat.h
@@ -58,7 +58,7 @@ public:
 	void PruneWakeTrail(void);
 	void AddWakePoint(CVector point);
 
-	static CBoat *(&apFrameWakeGeneratingBoats)[4];
+	static CBoat *apFrameWakeGeneratingBoats[4];
 	
 	static bool IsSectorAffectedByWake(CVector2D sector, float fSize, CBoat **apBoats);
 	static float IsVertexAffectedByWake(CVector vecVertex, CBoat *pBoat);
diff --git a/src/vehicles/Floater.cpp b/src/vehicles/Floater.cpp
index 62d55925..ee4a1191 100644
--- a/src/vehicles/Floater.cpp
+++ b/src/vehicles/Floater.cpp
@@ -7,10 +7,9 @@
 #include "Vehicle.h"
 #include "Floater.h"
 
-cBuoyancy &mod_Buoyancy = *(cBuoyancy*)0x8F2674;
+cBuoyancy mod_Buoyancy;// = *(cBuoyancy*)0x8F2674;
 
-//static float fVolMultiplier = 1.0f;
-static float &fVolMultiplier = *(float*)0x601394;
+static float fVolMultiplier = 1.0f; // 0x601394;
 // amount of boat volume in bounding box
 // 1.0-volume is the empty space in the bbox
 static float fBoatVolumeDistribution[9] = {
diff --git a/src/vehicles/Floater.h b/src/vehicles/Floater.h
index 4754a235..1cfb46fb 100644
--- a/src/vehicles/Floater.h
+++ b/src/vehicles/Floater.h
@@ -42,4 +42,4 @@ public:
 	void FindWaterLevel(const CVector &zpos, CVector *waterLevel, tWaterLevel *waterPosition);
 	bool CalcBuoyancyForce(CPhysical *phys, CVector *impulse, CVector *point);
 };
-extern cBuoyancy &mod_Buoyancy;
+extern cBuoyancy mod_Buoyancy;
diff --git a/src/vehicles/HandlingMgr.cpp b/src/vehicles/HandlingMgr.cpp
index 0f16401e..40715887 100644
--- a/src/vehicles/HandlingMgr.cpp
+++ b/src/vehicles/HandlingMgr.cpp
@@ -4,7 +4,7 @@
 #include "FileMgr.h"
 #include "HandlingMgr.h"
 
-cHandlingDataMgr &mod_HandlingManager = *(cHandlingDataMgr*)0x728060;
+cHandlingDataMgr mod_HandlingManager;// = *(cHandlingDataMgr*)0x728060;
 
 const char *HandlingFilename = "HANDLING.CFG";
 
diff --git a/src/vehicles/HandlingMgr.h b/src/vehicles/HandlingMgr.h
index 70f1c005..137925f3 100644
--- a/src/vehicles/HandlingMgr.h
+++ b/src/vehicles/HandlingMgr.h
@@ -140,4 +140,4 @@ public:
 	bool HasFrontWheelDrive(eHandlingId id) { return HandlingData[id].Transmission.nDriveType == 'F'; }
 };
 VALIDATE_SIZE(cHandlingDataMgr, 0x3030);
-extern cHandlingDataMgr &mod_HandlingManager;
+extern cHandlingDataMgr mod_HandlingManager;
diff --git a/src/vehicles/Heli.cpp b/src/vehicles/Heli.cpp
index 3dc1deeb..61714133 100644
--- a/src/vehicles/Heli.cpp
+++ b/src/vehicles/Heli.cpp
@@ -34,13 +34,13 @@ enum
 	HELI_STATUS_HOVER2,
 };
 
-CHeli **CHeli::pHelis = (CHeli**)0x72CF50;
-int16 &CHeli::NumRandomHelis = *(int16*)0x95CCAA;
-uint32 &CHeli::TestForNewRandomHelisTimer = *(uint32*)0x8F1A7C;
+CHeli *CHeli::pHelis[NUM_HELIS];// = (CHeli**)0x72CF50;
+int16 CHeli::NumRandomHelis;// = *(int16*)0x95CCAA;
+uint32 CHeli::TestForNewRandomHelisTimer;// = *(uint32*)0x8F1A7C;
 int16 CHeli::NumScriptHelis;	// unused
-bool &CHeli::CatalinaHeliOn = *(bool*)0x95CD85;
-bool &CHeli::CatalinaHasBeenShotDown = *(bool*)0x95CD56;
-bool &CHeli::ScriptHeliOn = *(bool*)0x95CD43;
+bool CHeli::CatalinaHeliOn;// = *(bool*)0x95CD85;
+bool CHeli::CatalinaHasBeenShotDown;// = *(bool*)0x95CD56;
+bool CHeli::ScriptHeliOn;// = *(bool*)0x95CD43;
 
 CHeli::CHeli(int32 id, uint8 CreatedBy)
  : CVehicle(CreatedBy)
@@ -78,6 +78,9 @@ CHeli::CHeli(int32 id, uint8 CreatedBy)
 	m_bTestRight = true;
 	m_fTargetOffset = 0.0f;
 	m_fSearchLightX = m_fSearchLightY = 0.0f;
+
+	// BUG: not in game but gets initialized to CDCDCDCD in debug
+	m_nLastShotTime = 0;
 }
 
 void
@@ -590,7 +593,12 @@ CHeli::PreRender(void)
 			break;
 		}
 		RwRGBA col = { r, g, b, 32 };
+#ifdef FIX_BUGS
+		pos.z = m_fHeliDustZ[frm];
+#else
+		// What the hell is the point of this?
 		pos.z = m_fHeliDustZ[(i - (i&3))/4];	// advance every 4 iterations, why not just /4?
+#endif
 		if(pos.z > -200.0f && GetPosition().z - pos.z < 20.0f)
 			CParticle::AddParticle(PARTICLE_HELI_DUST, pos, dir, nil, 0.0f, col);
 		i++;
diff --git a/src/vehicles/Heli.h b/src/vehicles/Heli.h
index bb10345d..15dff7b1 100644
--- a/src/vehicles/Heli.h
+++ b/src/vehicles/Heli.h
@@ -61,13 +61,13 @@ public:
 	float m_fTargetOffset;
 	bool m_bTestRight;
 
-	static CHeli **pHelis;	//[NUM_HELIS]
-	static int16 &NumRandomHelis;
-	static uint32 &TestForNewRandomHelisTimer;
+	static CHeli *pHelis[NUM_HELIS];
+	static int16 NumRandomHelis;
+	static uint32 TestForNewRandomHelisTimer;
 	static int16 NumScriptHelis;	// unused
-	static bool &CatalinaHeliOn;
-	static bool &CatalinaHasBeenShotDown;
-	static bool &ScriptHeliOn;
+	static bool CatalinaHeliOn;
+	static bool CatalinaHasBeenShotDown;
+	static bool ScriptHeliOn;
 
 	CHeli(int32 id, uint8 CreatedBy);
 	CHeli* ctor(int, uint8);
diff --git a/src/vehicles/Plane.cpp b/src/vehicles/Plane.cpp
index c2b9e493..49f5d69d 100644
--- a/src/vehicles/Plane.cpp
+++ b/src/vehicles/Plane.cpp
@@ -16,35 +16,35 @@
 #include "HandlingMgr.h"
 #include "Plane.h"
 
-CPlaneNode *&pPathNodes = *(CPlaneNode**)0x8F1B68;
-CPlaneNode *&pPath2Nodes = *(CPlaneNode**)0x885B8C;
-CPlaneNode *&pPath3Nodes = *(CPlaneNode**)0x885B78;
-CPlaneNode *&pPath4Nodes = *(CPlaneNode**)0x885AD8;
-int32 &NumPathNodes = *(int32*)0x8F2BE4;
-int32 &NumPath2Nodes = *(int32*)0x941498;
-int32 &NumPath3Nodes = *(int32*)0x9414D8;
-int32 &NumPath4Nodes = *(int32*)0x9412C8;
-float &TotalLengthOfFlightPath = *(float*)0x8F2C6C;
-float &TotalLengthOfFlightPath2 = *(float*)0x64CFBC;
-float &TotalLengthOfFlightPath3 = *(float*)0x64CFD0;
-float &TotalLengthOfFlightPath4 = *(float*)0x64CFDC;
-float &TotalDurationOfFlightPath = *(float*)0x64CFB8;
-float &TotalDurationOfFlightPath2 = *(float*)0x64CFC0;
-float &TotalDurationOfFlightPath3 = *(float*)0x64CFD4;
-float &TotalDurationOfFlightPath4 = *(float*)0x64CFE0;
-float &LandingPoint = *(float*)0x8F2C7C;
-float &TakeOffPoint = *(float*)0x8E28A4;
-CPlaneInterpolationLine *aPlaneLineBits = (CPlaneInterpolationLine*)0x734168;	//[6]
-
-float *PlanePathPosition = (float*)0x8F5FC8;	//[3]
-float *OldPlanePathPosition = (float*)0x8F5FBC;	//[3]
-float *PlanePathSpeed = (float*)0x941538;	//[3]
-float *PlanePath2Position = (float*)0x64CFC4;	//[3]
-float &PlanePath3Position = *(float*)0x64CFD8;
-float &PlanePath4Position = *(float*)0x64CFE4;
-float *PlanePath2Speed = (float*)0x8F1A54;	//[3]
-float &PlanePath3Speed = *(float*)0x8F1A94;
-float &PlanePath4Speed = *(float*)0x8F1AFC;
+CPlaneNode *pPathNodes;// = *(CPlaneNode**)0x8F1B68;
+CPlaneNode *pPath2Nodes;// = *(CPlaneNode**)0x885B8C;
+CPlaneNode *pPath3Nodes;// = *(CPlaneNode**)0x885B78;
+CPlaneNode *pPath4Nodes;// = *(CPlaneNode**)0x885AD8;
+int32 NumPathNodes;// = *(int32*)0x8F2BE4;
+int32 NumPath2Nodes;// = *(int32*)0x941498;
+int32 NumPath3Nodes;// = *(int32*)0x9414D8;
+int32 NumPath4Nodes;// = *(int32*)0x9412C8;
+float TotalLengthOfFlightPath;// = *(float*)0x8F2C6C;
+float TotalLengthOfFlightPath2;// = *(float*)0x64CFBC;
+float TotalLengthOfFlightPath3;// = *(float*)0x64CFD0;
+float TotalLengthOfFlightPath4;// = *(float*)0x64CFDC;
+float TotalDurationOfFlightPath;// = *(float*)0x64CFB8;
+float TotalDurationOfFlightPath2;// = *(float*)0x64CFC0;
+float TotalDurationOfFlightPath3;// = *(float*)0x64CFD4;
+float TotalDurationOfFlightPath4;// = *(float*)0x64CFE0;
+float LandingPoint;// = *(float*)0x8F2C7C;
+float TakeOffPoint;// = *(float*)0x8E28A4;
+CPlaneInterpolationLine aPlaneLineBits[6]; // = (CPlaneInterpolationLine*)0x734168;
+
+float PlanePathPosition[3];// = (float*)0x8F5FC8;	//[3]
+float OldPlanePathPosition[3];// = (float*)0x8F5FBC;	//[3]
+float PlanePathSpeed[3];// = (float*)0x941538;	//[3]
+float PlanePath2Position[3];// = (float*)0x64CFC4;	//[3]
+float PlanePath3Position;// = *(float*)0x64CFD8;
+float PlanePath4Position;// = *(float*)0x64CFE4;
+float PlanePath2Speed[3];// = (float*)0x8F1A54;	//[3]
+float PlanePath3Speed;// = *(float*)0x8F1A94;
+float PlanePath4Speed;// = *(float*)0x8F1AFC;
 
 
 enum
diff --git a/src/vehicles/Plane.h b/src/vehicles/Plane.h
index edca92ec..4c8e70aa 100644
--- a/src/vehicles/Plane.h
+++ b/src/vehicles/Plane.h
@@ -67,6 +67,6 @@ public:
 };
 static_assert(sizeof(CPlane) == 0x29C, "CPlane: error");
 
-extern float &LandingPoint;
-extern float &TakeOffPoint;
-extern float *PlanePathPosition;	//[3]
+extern float LandingPoint;
+extern float TakeOffPoint;
+extern float PlanePathPosition[3];
diff --git a/src/vehicles/Train.cpp b/src/vehicles/Train.cpp
index 7d81fd57..25be193c 100644
--- a/src/vehicles/Train.cpp
+++ b/src/vehicles/Train.cpp
@@ -14,23 +14,23 @@
 #include "HandlingMgr.h"
 #include "Train.h"
 
-static CTrainNode *&pTrackNodes = *(CTrainNode**)0x8F4338;
-static int16 &NumTrackNodes = *(int16*)0x95CC5C;
+static CTrainNode* pTrackNodes;
+static int16 NumTrackNodes;
 static float StationDist[3] = { 873.0f, 1522.0f, 2481.0f };
-static float &TotalLengthOfTrack = *(float*)0x64D000;
-static float &TotalDurationOfTrack = *(float*)0x64D004;
-static CTrainInterpolationLine *aLineBits = (CTrainInterpolationLine*)0x70D838;	// [17]
-static float *EngineTrackPosition = (float*)0x64D008;	//[2]
-static float *EngineTrackSpeed = (float*)0x880848;	//[2]
-
-static CTrainNode *&pTrackNodes_S = *(CTrainNode**)0x8F2560;
-static int16 &NumTrackNodes_S = *(int16*)0x95CC6A;
+static float TotalLengthOfTrack;
+static float TotalDurationOfTrack;
+static CTrainInterpolationLine aLineBits[17];
+static float EngineTrackPosition[2];
+static float EngineTrackSpeed[2];
+
+static CTrainNode* pTrackNodes_S;
+static int16 NumTrackNodes_S;
 static float StationDist_S[4] = { 55.0f, 1388.0f, 2337.0f, 3989.0f };
-static float &TotalLengthOfTrack_S = *(float*)0x64D010;
-static float &TotalDurationOfTrack_S = *(float*)0x64D014;
-static CTrainInterpolationLine *aLineBits_S = (CTrainInterpolationLine*)0x726600;	// [18]
-static float *EngineTrackPosition_S = (float*)0x64D018;	//[4]
-static float *EngineTrackSpeed_S = (float*)0x87C7C8;	//[4]
+static float TotalLengthOfTrack_S;
+static float TotalDurationOfTrack_S;
+static CTrainInterpolationLine aLineBits_S[18];
+static float EngineTrackPosition_S[4];
+static float EngineTrackSpeed_S[4];
 
 CVector CTrain::aStationCoors[3];
 CVector CTrain::aStationCoors_S[4];
diff --git a/src/vehicles/Vehicle.cpp b/src/vehicles/Vehicle.cpp
index f47fd131..ed8f4221 100644
--- a/src/vehicles/Vehicle.cpp
+++ b/src/vehicles/Vehicle.cpp
@@ -19,12 +19,12 @@
 #include "Fire.h"
 #include "Darkel.h"
 
-bool &CVehicle::bWheelsOnlyCheat = *(bool *)0x95CD78;
-bool &CVehicle::bAllDodosCheat = *(bool *)0x95CD75;
-bool &CVehicle::bCheat3 = *(bool *)0x95CD66;
-bool &CVehicle::bCheat4 = *(bool *)0x95CD65;
-bool &CVehicle::bCheat5 = *(bool *)0x95CD64;
-bool &CVehicle::m_bDisableMouseSteering = *(bool *)0x60252C;
+bool CVehicle::bWheelsOnlyCheat;
+bool CVehicle::bAllDodosCheat;
+bool CVehicle::bCheat3;
+bool CVehicle::bCheat4;
+bool CVehicle::bCheat5;
+bool CVehicle::m_bDisableMouseSteering;
 
 void *CVehicle::operator new(size_t sz) { return CPools::GetVehiclePool()->New();  }
 void *CVehicle::operator new(size_t sz, int handle) { return CPools::GetVehiclePool()->New(handle); }
diff --git a/src/vehicles/Vehicle.h b/src/vehicles/Vehicle.h
index f9becda0..bfc6d95d 100644
--- a/src/vehicles/Vehicle.h
+++ b/src/vehicles/Vehicle.h
@@ -277,12 +277,12 @@ public:
 	bool IsTaxi(void) { return GetModelIndex() == MI_TAXI || GetModelIndex() == MI_CABBIE || GetModelIndex() == MI_BORGNINE; }
 	AnimationId GetDriverAnim(void) { return IsCar() && bLowVehicle ? ANIM_CAR_LSIT : (IsBoat() && GetModelIndex() != MI_SPEEDER ? ANIM_DRIVE_BOAT : ANIM_CAR_SIT); }
 
-	static bool &bWheelsOnlyCheat;
-	static bool &bAllDodosCheat;
-	static bool &bCheat3;
-	static bool &bCheat4;
-	static bool &bCheat5;
-	static bool &m_bDisableMouseSteering;
+	static bool bWheelsOnlyCheat;
+	static bool bAllDodosCheat;
+	static bool bCheat3;
+	static bool bCheat4;
+	static bool bCheat5;
+	static bool m_bDisableMouseSteering;
 };
 
 static_assert(sizeof(CVehicle) == 0x288, "CVehicle: error");
diff --git a/src/weapons/BulletInfo.cpp b/src/weapons/BulletInfo.cpp
index 54fa6844..9e83a4ec 100644
--- a/src/weapons/BulletInfo.cpp
+++ b/src/weapons/BulletInfo.cpp
@@ -2,4 +2,268 @@
 #include "patcher.h"
 #include "BulletInfo.h"
 
-WRAPPER bool CBulletInfo::TestForSniperBullet(float x1, float x2, float y1, float y2, float z1, float z2) { EAXJMP(0x558D40); }
+#include "AnimBlendAssociation.h"
+#include "AudioManager.h"
+#include "AudioScriptObject.h"
+#ifdef FIX_BUGS
+#include "Collision.h"
+#endif
+#include "RpAnimBlend.h"
+#include "Entity.h"
+#include "EventList.h"
+#include "Fire.h"
+#include "Glass.h"
+#include "Particle.h"
+#include "Ped.h"
+#include "Object.h"
+#include "Stats.h"
+#include "Timer.h"
+#include "Vehicle.h"
+#include "Weapon.h"
+#include "WeaponInfo.h"
+#include "World.h"
+
+#define BULLET_LIFETIME (1000)
+#define NUM_PED_BLOOD_PARTICLES (8)
+#define BLOOD_PARTICLE_OFFSET (CVector(0.0f, 0.0f, 0.0f))
+#define NUM_VEHICLE_SPARKS (16)
+#define NUM_OTHER_SPARKS (8)
+#define BULLET_HIT_FORCE (7.5f)
+#define MAP_BORDER (1960.0f)
+
+CBulletInfo gaBulletInfo[CBulletInfo::NUM_BULLETS];
+bool bPlayerSniperBullet;
+CVector PlayerSniperBulletStart;
+CVector PlayerSniperBulletEnd;
+
+void CBulletInfo::Initialise(void)
+{
+	debug("Initialising CBulletInfo...\n");
+	for (int i = 0; i < NUM_BULLETS; i++) {
+		gaBulletInfo[i].m_bInUse = false;
+		gaBulletInfo[i].m_eWeaponType = WEAPONTYPE_COLT45;
+		gaBulletInfo[i].m_fTimer = 0.0f;
+		gaBulletInfo[i].m_pSource = nil;
+	}
+	debug("CBulletInfo ready\n");
+}
+
+void CBulletInfo::Shutdown(void)
+{
+	debug("Shutting down CBulletInfo...\n");
+	debug("CBulletInfo shut down\n");
+}
+
+bool CBulletInfo::AddBullet(CEntity* pSource, eWeaponType type, CVector vecPosition, CVector vecSpeed)
+{
+	int i;
+	for (i = 0; i < NUM_BULLETS; i++) {
+		if (!gaBulletInfo[i].m_bInUse)
+			break;
+	}
+	if (i == NUM_BULLETS)
+		return false;
+	gaBulletInfo[i].m_pSource = pSource;
+	gaBulletInfo[i].m_eWeaponType = type;
+	gaBulletInfo[i].m_nDamage = CWeaponInfo::GetWeaponInfo(type)->m_nDamage;
+	gaBulletInfo[i].m_vecPosition = vecPosition;
+	gaBulletInfo[i].m_vecSpeed = vecSpeed;
+	gaBulletInfo[i].m_fTimer = CTimer::GetTimeInMilliseconds() + BULLET_LIFETIME;
+	gaBulletInfo[i].m_bInUse = true;
+	return true;
+}
+
+void CBulletInfo::Update(void)
+{
+	bool bAddSound = true;
+	bPlayerSniperBullet = false;
+	for (int i = 0; i < NUM_BULLETS; i++) {
+		CBulletInfo* pBullet = &gaBulletInfo[i];
+		if (pBullet->m_pSource && pBullet->m_pSource->IsPed() && !((CPed*)pBullet->m_pSource)->IsPointerValid())
+			pBullet->m_pSource = nil;
+		if (!pBullet->m_bInUse)
+			continue;
+		if (CTimer::GetTimeInMilliseconds() > pBullet->m_fTimer)
+			pBullet->m_bInUse = false;
+		CVector vecOldPos = pBullet->m_vecPosition;
+		CVector vecNewPos = pBullet->m_vecPosition + pBullet->m_vecSpeed * CTimer::GetTimeStep() * 0.5f;
+		CWorld::bIncludeCarTyres = true;
+		CWorld::bIncludeDeadPeds = true;
+		CWorld::pIgnoreEntity = pBullet->m_pSource;
+		CColPoint point;
+		CEntity* pHitEntity;
+		if (CWorld::ProcessLineOfSight(vecOldPos, vecNewPos, point, pHitEntity, true, true, true, true, true, true)) {
+			if (pBullet->m_pSource && (pHitEntity->IsPed() || pHitEntity->IsVehicle()))
+				CStats::InstantHitsHitByPlayer++;
+			if (pHitEntity->IsPed()) {
+				CPed* pPed = (CPed*)pHitEntity;
+				if (!pPed->DyingOrDead() && pPed != pBullet->m_pSource) {
+					if (pPed->DoesLOSBulletHitPed(point)) {
+						if (pPed->IsPedInControl() && !pPed->bIsDucking) {
+							pPed->ClearAttackByRemovingAnim();
+							CAnimBlendAssociation* pAnim = CAnimManager::AddAnimation(pPed->GetClump(), ASSOCGRP_STD, ANIM_SHOT_FRONT_PARTIAL);
+							pAnim->SetBlend(0.0f, 8.0f);
+						}
+						pPed->InflictDamage(pBullet->m_pSource, pBullet->m_eWeaponType, pBullet->m_nDamage, (ePedPieceTypes)point.pieceB, pPed->GetLocalDirection(pPed->GetPosition() - point.point));
+						CEventList::RegisterEvent(pPed->m_nPedType == PEDTYPE_COP ? EVENT_SHOOT_COP : EVENT_SHOOT_PED, EVENT_ENTITY_PED, pPed, (CPed*)pBullet->m_pSource, 1000);
+						pBullet->m_bInUse = false;
+						vecNewPos = point.point;
+					}
+					else {
+						bAddSound = false;
+					}
+				}
+				if (CGame::nastyGame) {
+					CVector vecParticleDirection = (point.point - pPed->GetPosition()) * 0.01f;
+					vecParticleDirection.z = 0.01f;
+					if (pPed->GetIsOnScreen()) {
+						for (int j = 0; j < NUM_PED_BLOOD_PARTICLES; j++)
+							CParticle::AddParticle(PARTICLE_BLOOD_SMALL, point.point + BLOOD_PARTICLE_OFFSET, vecParticleDirection);
+					}
+					if (pPed->GetPedState() == PED_DEAD) {
+						CAnimBlendAssociation* pAnim;
+						if (RpAnimBlendClumpGetFirstAssociation(pPed->GetClump(), ASSOC_FLAG800))
+							pAnim = CAnimManager::BlendAnimation(pPed->GetClump(), ASSOCGRP_STD, ANIM_FLOOR_HIT_F, 8.0f);
+						else
+							pAnim = CAnimManager::BlendAnimation(pPed->GetClump(), ASSOCGRP_STD, ANIM_FLOOR_HIT, 8.0f);
+						if (pAnim) {
+							pAnim->SetCurrentTime(0.0f);
+							pAnim->flags |= ASSOC_RUNNING;
+							pAnim->flags &= ~ASSOC_FADEOUTWHENDONE;
+						}
+					}
+					pBullet->m_bInUse = false;
+					vecNewPos = point.point;
+				}
+			}
+			else if (pHitEntity->IsVehicle()) {
+				CVehicle* pVehicle = (CVehicle*)pHitEntity;
+				pVehicle->InflictDamage(pBullet->m_pSource, pBullet->m_eWeaponType, pBullet->m_nDamage);
+				if (pBullet->m_eWeaponType == WEAPONTYPE_FLAMETHROWER) // huh?
+					gFireManager.StartFire(pVehicle, pBullet->m_pSource, 0.8f, true);
+				else {
+					for (int j = 0; j < NUM_VEHICLE_SPARKS; j++)
+						CParticle::AddParticle(PARTICLE_SPARK, point.point, point.normal / 20);
+				}
+#ifdef FIX_BUGS
+				pBullet->m_bInUse = false;
+				vecNewPos = point.point;
+#endif
+			}
+			else {
+				for (int j = 0; j < NUM_OTHER_SPARKS; j++)
+					CParticle::AddParticle(PARTICLE_SPARK, point.point, point.normal / 20);
+				if (pHitEntity->IsObject()) {
+					CObject* pObject = (CObject*)pHitEntity;
+					if (!pObject->bInfiniteMass) {
+						if (pObject->bIsStatic && pObject->m_fUprootLimit <= 0.0f) {
+							pObject->bIsStatic = false;
+							pObject->AddToMovingList();
+						}
+						if (!pObject->bIsStatic)
+							pObject->ApplyMoveForce(-BULLET_HIT_FORCE * point.normal);
+					}
+				}
+#ifdef FIX_BUGS
+				pBullet->m_bInUse = false;
+				vecNewPos = point.point;
+#endif
+			}
+			if (pBullet->m_eWeaponType == WEAPONTYPE_SNIPERRIFLE && bAddSound) {
+				cAudioScriptObject* pAudio;
+				switch (pHitEntity->m_type) {
+				case ENTITY_TYPE_BUILDING:
+					pAudio = new cAudioScriptObject();
+					pAudio->Posn = pHitEntity->GetPosition();
+					pAudio->AudioId = SCRIPT_SOUND_BULLET_HIT_GROUND_1;
+					pAudio->AudioEntity = AEHANDLE_NONE;
+					DMAudio.CreateOneShotScriptObject(pAudio);
+					break;
+				case ENTITY_TYPE_OBJECT:
+					pAudio = new cAudioScriptObject();
+					pAudio->Posn = pHitEntity->GetPosition();
+					pAudio->AudioId = SCRIPT_SOUND_BULLET_HIT_GROUND_2;
+					pAudio->AudioEntity = AEHANDLE_NONE;
+					DMAudio.CreateOneShotScriptObject(pAudio);
+					break;
+				case ENTITY_TYPE_DUMMY:
+					pAudio = new cAudioScriptObject();
+					pAudio->Posn = pHitEntity->GetPosition();
+					pAudio->AudioId = SCRIPT_SOUND_BULLET_HIT_GROUND_3;
+					pAudio->AudioEntity = AEHANDLE_NONE;
+					DMAudio.CreateOneShotScriptObject(pAudio);
+					break;
+				case ENTITY_TYPE_PED:
+					DMAudio.PlayOneShot(((CPed*)pHitEntity)->m_audioEntityId, SOUND_WEAPON_HIT_PED, 1.0f);
+					((CPed*)pHitEntity)->Say(SOUND_PED_BULLET_HIT);
+					break;
+				case ENTITY_TYPE_VEHICLE:
+					DMAudio.PlayOneShot(((CVehicle*)pHitEntity)->m_audioEntityId, SOUND_WEAPON_HIT_VEHICLE, 1.0f);
+					break;
+				}
+			}
+			CGlass::WasGlassHitByBullet(pHitEntity, point.point);
+			CWeapon::BlowUpExplosiveThings(pHitEntity);
+		}
+		CWorld::pIgnoreEntity = nil;
+		CWorld::bIncludeDeadPeds = false;
+		CWorld::bIncludeCarTyres = false;
+		if (pBullet->m_eWeaponType == WEAPONTYPE_SNIPERRIFLE) {
+			bPlayerSniperBullet = true;
+			PlayerSniperBulletStart = pBullet->m_vecPosition;
+			PlayerSniperBulletEnd = vecNewPos;
+		}
+		pBullet->m_vecPosition = vecNewPos;
+		if (pBullet->m_vecPosition.x < -MAP_BORDER || pBullet->m_vecPosition.x > MAP_BORDER ||
+			pBullet->m_vecPosition.y < -MAP_BORDER || pBullet->m_vecPosition.y > MAP_BORDER)
+			pBullet->m_bInUse = false;
+	}
+}
+
+bool CBulletInfo::TestForSniperBullet(float x1, float x2, float y1, float y2, float z1, float z2)
+{
+	if (!bPlayerSniperBullet)
+		return false;
+#ifdef FIX_BUGS // original code is not going work anyway...
+	CColLine line(PlayerSniperBulletStart, PlayerSniperBulletEnd);
+	CColBox box;
+	box.Set(CVector(x1, y1, z1), CVector(x2, y2, z2), 0, 0);
+	return CCollision::TestLineBox(line, box);
+#else
+	float minP = 0.0f;
+	float maxP = 1.0f;
+	float minX = min(PlayerSniperBulletStart.x, PlayerSniperBulletEnd.x);
+	float maxX = max(PlayerSniperBulletStart.x, PlayerSniperBulletEnd.x);
+	if (minX < x2 || maxX > x1) {
+		if (minX < x1)
+			minP = min(minP, (x1 - minX) / (maxX - minX));
+		if (maxX > x2)
+			maxP = max(maxP, (maxX - x2) / (maxX - minX));
+	}
+	else
+		return false;
+	float minY = min(PlayerSniperBulletStart.y, PlayerSniperBulletEnd.y);
+	float maxY = max(PlayerSniperBulletStart.y, PlayerSniperBulletEnd.y);
+	if (minY < y2 || maxY > y1) {
+		if (minY < y1)
+			minP = min(minP, (y1 - minY) / (maxY - minY));
+		if (maxY > y2)
+			maxP = max(maxP, (maxY - y2) / (maxY - minY));
+	}
+#ifdef FIX_BUGS
+	else
+		return false;
+#endif
+	float minZ = min(PlayerSniperBulletStart.z, PlayerSniperBulletEnd.z);
+	float maxZ = max(PlayerSniperBulletStart.z, PlayerSniperBulletEnd.z);
+	if (minZ < z2 || maxZ > z1) {
+		if (minZ < z1)
+			minP = min(minP, (z1 - minZ) / (maxZ - minZ));
+		if (maxZ > z2)
+			maxP = max(maxP, (maxZ - z2) / (maxZ - minZ));
+	}
+	else
+		return false;
+	return minP <= maxP;
+#endif
+}
diff --git a/src/weapons/BulletInfo.h b/src/weapons/BulletInfo.h
index 3905b56d..c7d740b2 100644
--- a/src/weapons/BulletInfo.h
+++ b/src/weapons/BulletInfo.h
@@ -1,7 +1,24 @@
 #pragma once
 
+class CEntity;
+enum eWeaponType;
+
 class CBulletInfo
 {
+	eWeaponType m_eWeaponType;
+	CEntity* m_pSource;
+	float m_fTimer; // big mistake
+	bool m_bInUse;
+	CVector m_vecPosition;
+	CVector m_vecSpeed;
+	int16 m_nDamage;
 public:
+	enum {
+		NUM_BULLETS = 100
+	};
+	static void Initialise(void);
+	static void Shutdown(void);
+	static bool AddBullet(CEntity* pSource, eWeaponType type, CVector vecPosition, CVector vecSpeed);
+	static void Update(void);
 	static bool TestForSniperBullet(float x1, float x2, float y1, float y2, float z1, float z2);
 };
 \ No newline at end of file
diff --git a/src/weapons/Explosion.cpp b/src/weapons/Explosion.cpp
index 3d00052a..02243702 100644
--- a/src/weapons/Explosion.cpp
+++ b/src/weapons/Explosion.cpp
@@ -19,7 +19,7 @@
 #include "WaterLevel.h"
 #include "World.h"
 
-CExplosion(&gaExplosion)[NUM_EXPLOSIONS] = *(CExplosion(*)[NUM_EXPLOSIONS])*(uintptr*)0x64E208;
+CExplosion gaExplosion[NUM_EXPLOSIONS];
 
 // these two were not initialised in original code, I'm really not sure what were they meant to be
 RwRGBA colMedExpl = { 0, 0, 0, 0 };
diff --git a/src/weapons/Explosion.h b/src/weapons/Explosion.h
index 45e2d5bb..bf54328c 100644
--- a/src/weapons/Explosion.h
+++ b/src/weapons/Explosion.h
@@ -46,4 +46,4 @@ public:
 	static void RemoveAllExplosionsInArea(CVector pos, float radius);
 };
 
-extern CExplosion (&gaExplosion)[NUM_EXPLOSIONS];
-\ No newline at end of file
+extern CExplosion gaExplosion[NUM_EXPLOSIONS];
+\ No newline at end of file
diff --git a/src/weapons/ProjectileInfo.cpp b/src/weapons/ProjectileInfo.cpp
index b33d2d62..8f04278c 100644
--- a/src/weapons/ProjectileInfo.cpp
+++ b/src/weapons/ProjectileInfo.cpp
@@ -13,8 +13,8 @@
 #include "Weapon.h"
 #include "World.h"
 
-CProjectileInfo (&gaProjectileInfo)[NUM_PROJECTILES] = *(CProjectileInfo(*)[NUM_PROJECTILES])*(uintptr*)0x64ED50;
-CProjectile* (&CProjectileInfo::ms_apProjectile)[NUM_PROJECTILES] = *(CProjectile*(*)[NUM_PROJECTILES])*(uintptr*)0x87C748;
+CProjectileInfo gaProjectileInfo[NUM_PROJECTILES];
+CProjectile *CProjectileInfo::ms_apProjectile[NUM_PROJECTILES];
 
 void
 CProjectileInfo::Initialise()
diff --git a/src/weapons/ProjectileInfo.h b/src/weapons/ProjectileInfo.h
index a4ea369a..b88322f9 100644
--- a/src/weapons/ProjectileInfo.h
+++ b/src/weapons/ProjectileInfo.h
@@ -9,14 +9,14 @@ class CProjectileInfo
 {
 public:
 	eWeaponType m_eWeaponType;
-	CEntity* m_pSource;
+	CEntity *m_pSource;
 	uint32 m_nExplosionTime;
 	bool m_bInUse;
 	CVector m_vecPos;
 
 public:
-	static CProjectileInfo* GetProjectileInfo(int32 id);
-	static CProjectile* (&ms_apProjectile)[NUM_PROJECTILES];
+	static CProjectileInfo *GetProjectileInfo(int32 id);
+	static CProjectile *ms_apProjectile[NUM_PROJECTILES];
 
 	static void Initialise();
 	static void Shutdown();
@@ -29,4 +29,4 @@ public:
 	static bool IsProjectileInRange(float x1, float x2, float y1, float y2, float z1, float z2, bool remove);
 };
 
-extern CProjectileInfo (&gaProjectileInfo)[NUM_PROJECTILES];
-\ No newline at end of file
+extern CProjectileInfo gaProjectileInfo[NUM_PROJECTILES];
+\ No newline at end of file
diff --git a/src/weapons/Weapon.cpp b/src/weapons/Weapon.cpp
index 0f41264f..98154e93 100644
--- a/src/weapons/Weapon.cpp
+++ b/src/weapons/Weapon.cpp
@@ -1,23 +1,92 @@
 #include "common.h"
 #include "patcher.h"
 #include "Weapon.h"
+#include "AnimBlendAssociation.h"
+#include "AudioManager.h"
+#include "BulletInfo.h"
+#include "Camera.h"
+#include "Coronas.h"
+#include "DMAudio.h"
+#include "Explosion.h"
+#include "General.h"
+#include "Glass.h"
+#include "Heli.h"
+#include "ModelIndices.h"
+#include "Object.h"
+#include "Pad.h"
+#include "Particle.h"
+#include "Ped.h"
+#include "PointLights.h"
+#include "Pools.h"
+#include "ProjectileInfo.h"
+#include "RpAnimBlend.h"
+#include "ShotInfo.h"
+#include "SpecialFX.h"
+#include "Stats.h"
+#include "TempColModels.h"
 #include "Timer.h"
+#include "Vehicle.h"
+#include "WaterLevel.h"
 #include "WeaponInfo.h"
-#include "Ped.h"
 #include "World.h"
 
-WRAPPER void CWeapon::ShutdownWeapons(void) { EAXJMP(0x55C2F0); }
-WRAPPER void CWeapon::UpdateWeapons(void) { EAXJMP(0x55C310); }
-WRAPPER bool CWeapon::Fire(CEntity*, CVector*) { EAXJMP(0x55C380); }
-WRAPPER void CWeapon::FireFromCar(CAutomobile *car, bool left) { EAXJMP(0x55C940); }
-WRAPPER void CWeapon::AddGunshell(CEntity*, CVector const&, CVector2D const&, float) { EAXJMP(0x55F770); }
-WRAPPER void CWeapon::Update(int32 audioEntity) { EAXJMP(0x563A10); }
-WRAPPER void CWeapon::DoTankDoomAiming(CEntity *playerVehicle, CEntity *playerPed, CVector *start, CVector *end) { EAXJMP(0x563200); }
-WRAPPER void CWeapon::InitialiseWeapons(void) { EAXJMP(0x55C2D0); }
-WRAPPER void FireOneInstantHitRound(CVector* shotSource, CVector* shotTarget, int32 damage) { EAXJMP(0x563B00); }
+uint16 gReloadSampleTime[WEAPONTYPE_LAST_WEAPONTYPE] =
+{
+	0,			// UNARMED
+	0,			// BASEBALLBAT
+	250,		// COLT45
+	400,		// UZI
+	650,		// SHOTGUN
+	300,		// AK47
+	300,		// M16
+	423,		// SNIPERRIFLE
+	400,		// ROCKETLAUNCHER
+	0,			// FLAMETHROWER
+	0,			// MOLOTOV
+	0,			// GRENADE
+	0,			// DETONATOR
+	0			// HELICANNON
+};
+
+CWeaponInfo *
+CWeapon::GetInfo()
+{
+	CWeaponInfo *info = CWeaponInfo::GetWeaponInfo(m_eWeaponType);
+	ASSERT(info!=nil);
+	return info;
+}
+
+void
+CWeapon::InitialiseWeapons(void)
+{
+	CWeaponInfo::Initialise();
+	CShotInfo::Initialise();
+	CExplosion::Initialise();
+	CProjectileInfo::Initialise();
+	CBulletInfo::Initialise();
+}
+
+void
+CWeapon::ShutdownWeapons(void)
+{
+	CWeaponInfo::Shutdown();
+	CShotInfo::Shutdown();
+	CExplosion::Shutdown();
+	CProjectileInfo::Shutdown();
+	CBulletInfo::Shutdown();
+}
 
 void
-CWeapon::Initialise(eWeaponType type, int ammo)
+CWeapon::UpdateWeapons(void)
+{
+	CShotInfo::Update();
+	CExplosion::Update();
+	CProjectileInfo::Update();
+	CBulletInfo::Update();
+}
+
+void
+CWeapon::Initialise(eWeaponType type, int32 ammo)
 {
 	m_eWeaponType = type;
 	m_eWeaponState = WEAPONSTATE_READY;
@@ -30,13 +99,1871 @@ CWeapon::Initialise(eWeaponType type, int ammo)
 	m_nTimer = 0;
 }
 
+bool
+CWeapon::Fire(CEntity *shooter, CVector *fireSource)
+{
+	ASSERT(shooter!=nil);
+
+	CVector fireOffset(0.0f, 0.0f, 0.6f);
+	CVector *source = fireSource;
+
+	if ( !fireSource )
+		source = &(shooter->GetMatrix() * fireOffset);
+
+	if ( m_bAddRotOffset )
+	{
+		float heading = RADTODEG(shooter->GetForward().Heading());
+		float angle   = DEGTORAD(heading);
+		(*source).x += -Sin(angle) * 0.15f;
+		(*source).y +=  Cos(angle) * 0.15f;
+	}
+
+	if ( m_eWeaponState != WEAPONSTATE_READY && m_eWeaponState != WEAPONSTATE_FIRING )
+		return false;
+
+	bool fired;
+
+	if ( GetInfo()->m_eWeaponFire != WEAPON_FIRE_MELEE )
+	{
+		if ( m_nAmmoInClip <= 0 )
+			return false;
+
+		switch ( m_eWeaponType )
+		{
+			case WEAPONTYPE_SHOTGUN:
+			{
+				fired = FireShotgun(shooter, source);
+
+				break;
+			}
+
+			case WEAPONTYPE_COLT45:
+			case WEAPONTYPE_UZI:
+			case WEAPONTYPE_AK47:
+			{
+				fired = FireInstantHit(shooter, source);
+
+				break;
+			}
+
+			case WEAPONTYPE_SNIPERRIFLE:
+			{
+				fired = FireSniper(shooter);
+
+				break;
+			}
+
+			case WEAPONTYPE_M16:
+			{
+				if ( TheCamera.PlayerWeaponMode.Mode == CCam::MODE_M16_1STPERSON && shooter == FindPlayerPed() )
+					fired = FireM16_1stPerson(shooter);
+				else
+					fired = FireInstantHit(shooter, source);
+
+				break;
+			}
+
+			case WEAPONTYPE_ROCKETLAUNCHER:
+			{
+				if ( shooter->IsPed() && ((CPed*)shooter)->m_pSeekTarget != nil )
+				{
+					float distToTarget = (shooter->GetPosition() - ((CPed*)shooter)->m_pSeekTarget->GetPosition()).Magnitude();
+
+					if ( distToTarget > 8.0f || ((CPed*)shooter)->IsPlayer() )
+						fired = FireProjectile(shooter, source, 0.0f);
+					else
+						fired = false;
+				}
+				else
+					fired = FireProjectile(shooter, source, 0.0f);
+
+				break;
+			}
+
+			case WEAPONTYPE_MOLOTOV:
+			case WEAPONTYPE_GRENADE:
+			{
+				if ( shooter == FindPlayerPed() )
+				{
+					fired = FireProjectile(shooter, source, ((CPlayerPed*)shooter)->m_fAttackButtonCounter*0.0375f);
+					if ( m_eWeaponType == WEAPONTYPE_GRENADE )
+						CStats::KgsOfExplosivesUsed++;
+				}
+				else if ( shooter->IsPed() && ((CPed*)shooter)->m_pSeekTarget != nil )
+				{
+					float distToTarget = (shooter->GetPosition() - ((CPed*)shooter)->m_pSeekTarget->GetPosition()).Magnitude();
+					float power = clamp((distToTarget-10.0f)*0.02f, 0.2f, 1.0f);
+
+					fired = FireProjectile(shooter, source, power);
+				}
+				else
+					fired = FireProjectile(shooter, source, 0.3f);
+
+				break;
+			}
+
+			case WEAPONTYPE_FLAMETHROWER:
+			{
+				fired = FireAreaEffect(shooter, source);
+
+				break;
+			}
+
+			case WEAPONTYPE_DETONATOR:
+			{
+				CWorld::UseDetonator(shooter);
+				m_nAmmoTotal  = 1;
+				m_nAmmoInClip = m_nAmmoTotal;
+				fired = true;
+
+				break;
+			}
+
+			case WEAPONTYPE_HELICANNON:
+			{
+				if ( (TheCamera.PlayerWeaponMode.Mode == CCam::MODE_HELICANNON_1STPERSON || TheCamera.PlayerWeaponMode.Mode == CCam::MODE_M16_1STPERSON )
+						&& shooter == FindPlayerPed() )
+				{
+					fired = FireM16_1stPerson(shooter);
+				}
+				else
+					fired = FireInstantHit(shooter, source);
+
+				break;
+			}
+
+			default:
+			{
+				debug("Unknown weapon type, Weapon.cpp");
+				break;
+			}
+		}
+
+		if ( fired )
+		{
+			bool isPlayer = false;
+
+			if ( shooter->IsPed() )
+			{
+				CPed *shooterPed = (CPed*)shooter;
+
+				shooterPed->bIsShooting = true;
+
+				if ( shooterPed->IsPlayer() )
+					isPlayer = true;
+
+				DMAudio.PlayOneShot(shooterPed->m_audioEntityId, SOUND_WEAPON_SHOT_FIRED, 0.0f);
+			}
+
+			if ( m_nAmmoInClip > 0 ) m_nAmmoInClip--;
+			if ( m_nAmmoTotal > 0 && (m_nAmmoTotal < 25000 || isPlayer) ) m_nAmmoTotal--;
+
+			if ( m_eWeaponState == WEAPONSTATE_READY && m_eWeaponType == WEAPONTYPE_FLAMETHROWER )
+				DMAudio.PlayOneShot(((CPhysical*)shooter)->m_audioEntityId, SOUND_WEAPON_FLAMETHROWER_FIRE, 0.0f);
+
+			m_eWeaponState = WEAPONSTATE_FIRING;
+		}
+
+		if ( m_nAmmoInClip == 0 )
+		{
+			if ( m_nAmmoTotal == 0 )
+				return true;
+
+			m_eWeaponState = WEAPONSTATE_RELOADING;
+			m_nTimer = CTimer::GetTimeInMilliseconds() + GetInfo()->m_nReload;
+
+			if ( shooter == FindPlayerPed() )
+			{
+				if ( CWorld::Players[CWorld::PlayerInFocus].m_bFastReload )
+					m_nTimer = CTimer::GetTimeInMilliseconds() + GetInfo()->m_nReload / 4;
+			}
+
+			return true;
+		}
+
+		m_nTimer = CTimer::GetTimeInMilliseconds() + 1000;
+		if ( shooter == FindPlayerPed() )
+			CStats::RoundsFiredByPlayer++;
+	}
+	else
+	{
+		if ( m_eWeaponState != WEAPONSTATE_FIRING )
+		{
+			m_nTimer = CTimer::GetTimeInMilliseconds() + GetInfo()->m_nReload;
+			m_eWeaponState = WEAPONSTATE_FIRING;
+		}
+
+		FireMelee(shooter, *source);
+	}
+
+	if ( m_eWeaponType == WEAPONTYPE_UNARMED || m_eWeaponType == WEAPONTYPE_BASEBALLBAT )
+		return true;
+	else
+		return fired;
+}
+
+bool
+CWeapon::FireFromCar(CAutomobile *shooter, bool left)
+{
+	ASSERT(shooter!=nil);
+
+	if ( m_eWeaponState != WEAPONSTATE_READY && m_eWeaponState != WEAPONSTATE_FIRING )
+		return false;
+
+	if ( m_nAmmoInClip <= 0 )
+		return false;
+
+	if ( FireInstantHitFromCar(shooter, left) )
+	{
+		DMAudio.PlayOneShot(shooter->m_audioEntityId, SOUND_WEAPON_SHOT_FIRED, 0.0f);
+
+		if ( m_nAmmoInClip > 0 ) m_nAmmoInClip--;
+		if ( m_nAmmoTotal < 25000 && m_nAmmoTotal > 0 ) m_nAmmoTotal--;
+
+		m_eWeaponState = WEAPONSTATE_FIRING;
+
+		if ( m_nAmmoInClip == 0 )
+		{
+			if ( m_nAmmoTotal == 0 )
+				return true;
+
+			m_eWeaponState = WEAPONSTATE_RELOADING;
+			m_nTimer = CTimer::GetTimeInMilliseconds() + GetInfo()->m_nReload;
+
+			return true;
+		}
+
+		m_nTimer = CTimer::GetTimeInMilliseconds() + 1000;
+		if ( shooter == FindPlayerVehicle() )
+			CStats::RoundsFiredByPlayer++;
+	}
+
+	return true;
+}
+
+bool
+CWeapon::FireMelee(CEntity *shooter, CVector &fireSource)
+{
+	ASSERT(shooter!=nil);
+
+	CWeaponInfo *info = GetInfo();
+
+	bool anim2Playing = false;
+	if ( RpAnimBlendClumpGetAssociation(shooter->GetClump(), info->m_Anim2ToPlay) )
+		anim2Playing = true;
+
+	ASSERT(shooter->IsPed());
+
+	CPed *shooterPed = (CPed*)shooter;
+
+	for ( int32 i = 0; i < shooterPed->m_numNearPeds; i++ )
+	{
+		CPed *victimPed = shooterPed->m_nearPeds[i];
+		ASSERT(victimPed!=nil);
+
+		if ( (victimPed->m_nPedType != shooterPed->m_nPedType || victimPed == shooterPed->m_pSeekTarget)
+				&& victimPed != shooterPed->m_leader || !(CGeneral::GetRandomNumber() & 31) )
+		{
+			bool collided = false;
+
+			CColModel *victimPedCol = &CTempColModels::ms_colModelPed1;
+			if ( victimPed->OnGround() || !victimPed->IsPedHeadAbovePos(-0.3f) )
+				victimPedCol = &CTempColModels::ms_colModelPedGroundHit;
+
+
+			float victimPedRadius = victimPed->GetBoundRadius() + info->m_fRadius;
+			if ( victimPed->bUsesCollision || victimPed->Dead() || victimPed->Driving() )
+			{
+				CVector victimPedPos = victimPed->GetPosition();
+				if ( SQR(victimPedRadius) > (victimPedPos-(*fireSource)).MagnitudeSqr() )
+				{
+					CVector collisionDist;
+
+					int32 s = 0;
+					while ( s < victimPedCol->numSpheres )
+					{
+						CColSphere *sphere = &victimPedCol->spheres[s];
+						collisionDist = victimPedPos+sphere->center-(*fireSource);
+
+						if ( SQR(sphere->radius + info->m_fRadius) > collisionDist.MagnitudeSqr() )
+						{
+							collided = true;
+							break;
+						}
+						s++;
+					}
+
+					if ( !(victimPed->IsPlayer() && victimPed->GetPedState() == PED_GETUP) )
+					{
+						if ( collided )
+						{
+							float victimPedHealth = victimPed->m_fHealth;
+							CVector bloodPos = fireSource + (collisionDist*0.7f);
+
+							CVector2D posOffset(shooterPed->GetPosition().x-victimPedPos.x, shooterPed->GetPosition().y-victimPedPos.y);
+
+							int32 localDir = victimPed->GetLocalDirection(posOffset);
+
+							bool isBat = m_eWeaponType == WEAPONTYPE_BASEBALLBAT;
+
+							if ( !victimPed->DyingOrDead() )
+								victimPed->ReactToAttack(shooterPed);
+
+							uint8 hitLevel = HITLEVEL_HIGH;
+							if ( isBat && victimPed->OnGround() )
+								hitLevel = HITLEVEL_GROUND;
+
+							victimPed->StartFightDefend(localDir, hitLevel, 10);
+
+							if ( !victimPed->DyingOrDead() )
+							{
+								if ( shooterPed->IsPlayer() && isBat && anim2Playing )
+									victimPed->InflictDamage(shooterPed, m_eWeaponType, 100.0f, PEDPIECE_TORSO, localDir);
+								else if ( shooterPed->IsPlayer() && ((CPlayerPed*)shooterPed)->m_bAdrenalineActive )
+									victimPed->InflictDamage(shooterPed, m_eWeaponType, 3.5f*info->m_nDamage, PEDPIECE_TORSO, localDir);
+								else
+								{
+									if ( victimPed->IsPlayer() && isBat ) // wtf, it's not fair
+										victimPed->InflictDamage(shooterPed, m_eWeaponType, 2.0f*info->m_nDamage, PEDPIECE_TORSO, localDir);
+									else
+										victimPed->InflictDamage(shooterPed, m_eWeaponType,      info->m_nDamage, PEDPIECE_TORSO, localDir);
+								}
+							}
+
+							if ( CGame::nastyGame )
+							{
+								if ( victimPed->GetIsOnScreen() )
+								{
+									CVector dir = collisionDist * RecipSqrt(1.0f, 10.0f*collisionDist.MagnitudeSqr());
+
+									CParticle::AddParticle(PARTICLE_BLOOD, bloodPos, dir);
+									CParticle::AddParticle(PARTICLE_BLOOD, bloodPos, dir);
+									CParticle::AddParticle(PARTICLE_BLOOD, bloodPos, dir);
+
+									if ( isBat )
+									{
+										dir.x += CGeneral::GetRandomNumberInRange(-0.05f, 0.05f);
+										dir.y += CGeneral::GetRandomNumberInRange(-0.05f, 0.05f);
+										CParticle::AddParticle(PARTICLE_BLOOD, bloodPos, dir);
+
+										dir.x += CGeneral::GetRandomNumberInRange(-0.05f, 0.05f);
+										dir.y += CGeneral::GetRandomNumberInRange(-0.05f, 0.05f);
+										CParticle::AddParticle(PARTICLE_BLOOD, bloodPos, dir);
+									}
+								}
+							}
+
+							if ( !victimPed->OnGround() )
+							{
+								if ( victimPed->m_fHealth > 0.0f
+									&& (victimPed->m_fHealth < 20.0f && victimPedHealth > 20.0f || isBat && !victimPed->IsPlayer()) )
+								{
+									posOffset.Normalise();
+									victimPed->bIsStanding = false;
+									victimPed->ApplyMoveForce(posOffset.x*-5.0f, posOffset.y*-5.0f, 3.0f);
+
+									if ( isBat && victimPed->IsPlayer() )
+										victimPed->SetFall(3000, AnimationId(ANIM_KO_SKID_FRONT + localDir), false);
+									else
+										victimPed->SetFall(1500, AnimationId(ANIM_KO_SKID_FRONT + localDir), false);
+
+									shooterPed->m_pSeekTarget = victimPed;
+									shooterPed->m_pSeekTarget->RegisterReference(&shooterPed->m_pSeekTarget);
+								}
+							}
+							else if (victimPed->Dying() && !anim2Playing)
+							{
+								posOffset.Normalise();
+								victimPed->bIsStanding = false;
+								victimPed->ApplyMoveForce(posOffset.x*-5.0f, posOffset.y*-5.0f, 3.0f);
+							}
+
+							m_eWeaponState = WEAPONSTATE_MELEE_MADECONTACT;
+
+							if ( victimPed->m_nPedType == PEDTYPE_COP )
+								CEventList::RegisterEvent(EVENT_ASSAULT_POLICE, EVENT_ENTITY_PED, victimPed, shooterPed, 2000);
+							else
+								CEventList::RegisterEvent(EVENT_ASSAULT,        EVENT_ENTITY_PED, victimPed, shooterPed, 2000);
+						}
+					}
+				}
+			}
+		}
+	}
+
+	return true;
+}
+
+bool
+CWeapon::FireInstantHit(CEntity *shooter, CVector *fireSource)
+{
+	ASSERT(shooter!=nil);
+	ASSERT(fireSource!=nil);
+
+	CWeaponInfo *info = GetInfo();
+
+	CVector source, target;
+	CColPoint point;
+	CEntity *victim = nil;
+
+	float heading = RADTODEG(shooter->GetForward().Heading());
+	float angle   = DEGTORAD(heading);
+
+	CVector2D ahead(-Sin(angle), Cos(angle));
+	ahead.Normalise();
+
+	CVector vel = ((CPed *)shooter)->m_vecMoveSpeed;
+	int32 shooterMoving = false;
+	if ( Abs(vel.x) > 0.0f && Abs(vel.y) > 0.0f )
+		shooterMoving = true;
+
+	if ( shooter == FindPlayerPed() )
+	{
+		static float prev_heading = 0.0f;
+		prev_heading = ((CPed*)shooter)->m_fRotationCur;
+	}
+
+	if ( shooter->IsPed() && ((CPed *)shooter)->m_pPointGunAt )
+	{
+		CPed *shooterPed = (CPed *)shooter;
+		if ( shooterPed->m_pedIK.m_flags & CPedIK::GUN_POINTED_SUCCESSFULLY )
+		{
+			int32 accuracy   = shooterPed->m_wepAccuracy;
+			int32 inaccuracy = 100-accuracy;
+
+			if ( accuracy != 100 )
+				FindPlayerPed();	//what ?
+
+			CPed *threatAttack = (CPed*)shooterPed->m_pPointGunAt;
+			if ( threatAttack->IsPed() )
+			{
+				threatAttack->m_pedIK.GetComponentPosition(target, PED_MID);
+				threatAttack->ReactToPointGun(shooter);
+			}
+			else
+				target = threatAttack->GetPosition();
+
+			target -= *fireSource;
+			target *= info->m_fRange / target.Magnitude();
+			target += *fireSource;
+
+			if ( inaccuracy != 0 )
+			{
+				target.x += CGeneral::GetRandomNumberInRange(-0.2f, 0.2f) * inaccuracy;
+				target.y += CGeneral::GetRandomNumberInRange(-0.2f, 0.2f) * inaccuracy;
+				target.z += CGeneral::GetRandomNumberInRange(-0.1f, 0.1f) * inaccuracy;
+			}
+
+			CWorld::bIncludeDeadPeds = true;
+			ProcessLineOfSight(*fireSource, target, point, victim, m_eWeaponType, shooter, true, true, true, true, true, true, false);
+			CWorld::bIncludeDeadPeds = false;
+		}
+		else
+		{
+			target.x = info->m_fRange;
+			target.y = 0.0f;
+			target.z = 0.0f;
+
+			for (RwFrame *i = shooterPed->GetNodeFrame(PED_HANDR); i; i = RwFrameGetParent(i))
+				RwV3dTransformPoints(target, target, 1, RwFrameGetMatrix(i));
+
+			ProcessLineOfSight(*fireSource, target, point, victim, m_eWeaponType, shooter, true, true, true, true, true, true, false);
+		}
+	}
+	else if ( shooter == FindPlayerPed() && TheCamera.Cams[0].Using3rdPersonMouseCam()  )
+	{
+		CVector src, trgt;
+		TheCamera.Find3rdPersonCamTargetVector(info->m_fRange, *fireSource, src, trgt);
+
+		CWorld::bIncludeDeadPeds = true;
+		ProcessLineOfSight(src, trgt,point, victim, m_eWeaponType, shooter, true, true, true, true, true, true, false);
+		CWorld::bIncludeDeadPeds = false;
+
+		int32 rotSpeed = 1;
+		if ( m_eWeaponType == WEAPONTYPE_M16  )
+			rotSpeed = 4;
+
+		CVector bulletPos;
+		if ( CHeli::TestBulletCollision(&src, &trgt, &bulletPos, 4) )
+		{
+			for ( int32 i = 0; i < 16; i++ )
+				CParticle::AddParticle(PARTICLE_SPARK, bulletPos, CVector(0.0f, 0.0f, 0.0f), nil, 0.0f, rotSpeed);
+		}
+	}
+	else
+	{
+		float shooterHeading = RADTODEG(shooter->GetForward().Heading());
+		float shooterAngle   = DEGTORAD(shooterHeading);
+
+		CVector2D rotOffset(-Sin(shooterAngle), Cos(shooterAngle));
+		rotOffset.Normalise();
+
+		target   = *fireSource;
+		target.x = rotOffset.x * info->m_fRange;
+		target.y = rotOffset.y * info->m_fRange;
+
+		if ( shooter->IsPed() )
+			DoDoomAiming(shooter, fireSource, &target);
+
+		ProcessLineOfSight(*fireSource, target, point, victim, m_eWeaponType, shooter, true, true, true, true, true, true, false);
+
+		int32 rotSpeed = 1;
+		if ( m_eWeaponType == WEAPONTYPE_M16  )
+			rotSpeed = 4;
+
+		CVector bulletPos;
+		if ( CHeli::TestBulletCollision(fireSource, &target, &bulletPos, 4) )
+		{
+			for ( int32 i = 0; i < 16; i++ )
+				CParticle::AddParticle(PARTICLE_SPARK, bulletPos, CVector(0.0f, 0.0f, 0.0f), nil, 0.0f, rotSpeed);
+		}
+	}
+
+	if ( victim && shooter->IsPed() && victim == ((CPed*)shooter)->m_leader )
+		return false;
+
+	CEventList::RegisterEvent(EVENT_GUNSHOT, EVENT_ENTITY_PED, shooter, (CPed *)shooter, 1000);
+
+	if ( shooter == FindPlayerPed() )
+	{
+		CStats::InstantHitsFiredByPlayer++;
+		if ( !(CTimer::GetFrameCounter() & 3) )
+			MakePedsJumpAtShot((CPhysical*)shooter, fireSource, &target);
+	}
+
+	switch ( m_eWeaponType )
+	{
+		case WEAPONTYPE_AK47:
+		{
+			static uint8 counter = 0;
+
+			if ( !(++counter & 1) )
+			{
+				CPointLights::AddLight(CPointLights::LIGHT_POINT,
+					*fireSource, CVector(0.0f, 0.0f, 0.0f), 5.0f,
+					1.0f, 0.8f, 0.0f, CPointLights::FOG_NONE, false);
+
+				CVector gunflashPos = *fireSource;
+				gunflashPos += CVector(0.06f*ahead.x, 0.06f*ahead.y, 0.0f);
+				CParticle::AddParticle(PARTICLE_GUNFLASH_NOANIM, gunflashPos, CVector(0.0f, 0.0f, 0.0f), nil, 0.10f);
+				gunflashPos += CVector(0.06f*ahead.x, 0.06f*ahead.y, 0.0f);
+				CParticle::AddParticle(PARTICLE_GUNFLASH_NOANIM, gunflashPos, CVector(0.0f, 0.0f, 0.0f), nil, 0.08f);
+				gunflashPos += CVector(0.05f*ahead.x, 0.05f*ahead.y, 0.0f);
+				CParticle::AddParticle(PARTICLE_GUNFLASH_NOANIM, gunflashPos, CVector(0.0f, 0.0f, 0.0f), nil, 0.06f);
+				gunflashPos += CVector(0.04f*ahead.x, 0.04f*ahead.y, 0.0f);
+				CParticle::AddParticle(PARTICLE_GUNFLASH_NOANIM, gunflashPos, CVector(0.0f, 0.0f, 0.0f), nil, 0.04f);
+
+				CVector gunsmokePos = *fireSource;
+				float rnd = CGeneral::GetRandomNumberInRange(0.05f, 0.25f);
+				CParticle::AddParticle(PARTICLE_GUNSMOKE2, gunsmokePos, CVector(ahead.x*rnd, ahead.y*rnd, 0.0f));
+
+				CVector gunshellPos = *fireSource;
+				gunshellPos -= CVector(0.5f*ahead.x, 0.5f*ahead.y, 0.0f);
+				CVector dir = CrossProduct(CVector(ahead.x, ahead.y, 0.0f), CVector(0.0f, 0.0f, 5.0f));
+				dir.Normalise2D();
+				AddGunshell(shooter, gunshellPos, CVector2D(dir.x, dir.y), 0.018f);
+			}
+
+			break;
+		}
+
+		case WEAPONTYPE_M16:
+		{
+			static uint8 counter = 0;
+
+			if ( !(++counter & 1) )
+			{
+				CPointLights::AddLight(CPointLights::LIGHT_POINT,
+					*fireSource, CVector(0.0f, 0.0f, 0.0f), 5.0f,
+					1.0f, 0.8f, 0.0f, CPointLights::FOG_NONE, false);
+
+				CVector gunflashPos = *fireSource;
+				CParticle::AddParticle(PARTICLE_GUNFLASH_NOANIM, gunflashPos, CVector(0.0f, 0.0f, 0.0f), nil, 0.08f);
+				gunflashPos += CVector(0.06f*ahead.x, 0.06f*ahead.y, 0.0f);
+				CParticle::AddParticle(PARTICLE_GUNFLASH_NOANIM, gunflashPos, CVector(0.0f, 0.0f, 0.0f), nil, 0.06f);
+				gunflashPos += CVector(0.06f*ahead.x, 0.06f*ahead.y, 0.0f);
+				CParticle::AddParticle(PARTICLE_GUNFLASH_NOANIM, gunflashPos, CVector(0.0f, 0.0f, 0.0f), nil, 0.06f);
+
+				gunflashPos = *fireSource;
+				gunflashPos += CVector(-0.1f*ahead.x, -0.1f*ahead.y, 0.0f);
+				gunflashPos.z += 0.04f;
+				CParticle::AddParticle(PARTICLE_GUNFLASH_NOANIM, gunflashPos, CVector(0.0f, 0.0f, 0.0f), nil, 0.04f);
+				gunflashPos.z += 0.04f;
+				CParticle::AddParticle(PARTICLE_GUNFLASH_NOANIM, gunflashPos, CVector(0.0f, 0.0f, 0.0f), nil, 0.02f);
+				gunflashPos.z += 0.03f;
+				CParticle::AddParticle(PARTICLE_GUNFLASH_NOANIM, gunflashPos, CVector(0.0f, 0.0f, 0.0f), nil, 0.02f);
+
+				gunflashPos = *fireSource;
+				gunflashPos += CVector(-0.1f*ahead.x, -0.1f*ahead.y, 0.0f);
+				gunflashPos.z -= 0.04f;
+				CParticle::AddParticle(PARTICLE_GUNFLASH_NOANIM, gunflashPos, CVector(0.0f, 0.0f, 0.0f), nil, 0.04f);
+				gunflashPos.z -= 0.04f;
+				CParticle::AddParticle(PARTICLE_GUNFLASH_NOANIM, gunflashPos, CVector(0.0f, 0.0f, 0.0f), nil, 0.02f);
+				gunflashPos.z -= 0.03f;
+				CParticle::AddParticle(PARTICLE_GUNFLASH_NOANIM, gunflashPos, CVector(0.0f, 0.0f, 0.0f), nil, 0.02f);
+
+				CVector offset = CrossProduct(CVector(ahead.x, ahead.y, 0.0f), CVector(0.0f, 0.0f, 5.0f));
+				offset.Normalise2D();
+
+				gunflashPos = *fireSource;
+				gunflashPos += CVector(-0.1f*ahead.x, -0.1f*ahead.y, 0.0f);
+				gunflashPos += CVector(0.06f*offset.x, 0.06f*offset.y, 0.0f);
+				CParticle::AddParticle(PARTICLE_GUNFLASH_NOANIM, gunflashPos, CVector(0.0f, 0.0f, 0.0f), nil, 0.04f);
+				gunflashPos += CVector(0.04f*offset.x, 0.04f*offset.y, 0.0f);
+				CParticle::AddParticle(PARTICLE_GUNFLASH_NOANIM, gunflashPos, CVector(0.0f, 0.0f, 0.0f), nil, 0.03f);
+				gunflashPos += CVector(0.03f*offset.x, 0.03f*offset.y, 0.0f);
+				CParticle::AddParticle(PARTICLE_GUNFLASH_NOANIM, gunflashPos, CVector(0.0f, 0.0f, 0.0f), nil, 0.02f);
+
+				gunflashPos = *fireSource;
+				gunflashPos += CVector(-0.1f*ahead.x, -0.1f*ahead.y, 0.0f);
+				gunflashPos -= CVector(0.06f*offset.x, 0.06f*offset.y, 0.0f);
+				CParticle::AddParticle(PARTICLE_GUNFLASH_NOANIM, gunflashPos, CVector(0.0f, 0.0f, 0.0f), nil, 0.04f);
+				gunflashPos -= CVector(0.04f*offset.x, 0.04f*offset.y, 0.0f);
+				CParticle::AddParticle(PARTICLE_GUNFLASH_NOANIM, gunflashPos, CVector(0.0f, 0.0f, 0.0f), nil, 0.03f);
+				gunflashPos -= CVector(0.03f*offset.x, 0.03f*offset.y, 0.0f);
+				CParticle::AddParticle(PARTICLE_GUNFLASH_NOANIM, gunflashPos, CVector(0.0f, 0.0f, 0.0f), nil, 0.02f);
+
+				CVector gunsmokePos = *fireSource;
+				float rnd = CGeneral::GetRandomNumberInRange(0.05f, 0.25f);
+				CParticle::AddParticle(PARTICLE_GUNSMOKE2, gunsmokePos, CVector(ahead.x*rnd, ahead.y*rnd, 0.0f));
+
+				CVector gunshellPos = *fireSource;
+				gunshellPos -= CVector(0.65f*ahead.x, 0.65f*ahead.y, 0.0f);
+				CVector dir = CrossProduct(CVector(ahead.x, ahead.y, 0.0f), CVector(0.0f, 0.0f, 5.0f));
+				dir.Normalise2D();
+				AddGunshell(shooter, gunshellPos, CVector2D(dir.x, dir.y), 0.02f);
+			}
+
+			break;
+		}
+
+		case WEAPONTYPE_UZI:
+		{
+			CPointLights::AddLight(CPointLights::LIGHT_POINT,
+					*fireSource, CVector(0.0f, 0.0f, 0.0f), 5.0f,
+					1.0f, 0.8f, 0.0f, CPointLights::FOG_NONE, false);
+
+			CVector gunflashPos = *fireSource;
+
+			if ( shooterMoving )
+				gunflashPos += CVector(1.5f*vel.x, 1.5f*vel.y, 0.0f);
+
+			CParticle::AddParticle(PARTICLE_GUNFLASH_NOANIM, gunflashPos, CVector(0.0f, 0.0f, 0.0f), nil, 0.07f);
+			gunflashPos += CVector(0.06f*ahead.x, 0.06f*ahead.y, 0.0f);
+			CParticle::AddParticle(PARTICLE_GUNFLASH_NOANIM, gunflashPos, CVector(0.0f, 0.0f, 0.0f), nil, 0.05f);
+			gunflashPos += CVector(0.04f*ahead.x, 0.04f*ahead.y, 0.0f);
+			CParticle::AddParticle(PARTICLE_GUNFLASH_NOANIM, gunflashPos, CVector(0.0f, 0.0f, 0.0f), nil, 0.04f);
+			gunflashPos += CVector(0.04f*ahead.x, 0.04f*ahead.y, 0.0f);
+			CParticle::AddParticle(PARTICLE_GUNFLASH_NOANIM, gunflashPos, CVector(0.0f, 0.0f, 0.0f), nil, 0.03f);
+			gunflashPos += CVector(0.03f*ahead.x, 0.03f*ahead.y, 0.0f);
+			CParticle::AddParticle(PARTICLE_GUNFLASH_NOANIM, gunflashPos, CVector(0.0f, 0.0f, 0.0f), nil, 0.03f);
+			gunflashPos += CVector(0.03f*ahead.x, 0.03f*ahead.y, 0.0f);
+			CParticle::AddParticle(PARTICLE_GUNFLASH_NOANIM, gunflashPos, CVector(0.0f, 0.0f, 0.0f), nil, 0.02f);
+			gunflashPos += CVector(0.02f*ahead.x, 0.02f*ahead.y, 0.0f);
+			CParticle::AddParticle(PARTICLE_GUNFLASH_NOANIM, gunflashPos, CVector(0.0f, 0.0f, 0.0f), nil, 0.01f);
+
+			CVector gunsmokePos = *fireSource;
+			float rnd = CGeneral::GetRandomNumberInRange(0.05f, 0.25f);
+			CParticle::AddParticle(PARTICLE_GUNSMOKE2, gunsmokePos, CVector(ahead.x*rnd, ahead.y*rnd, 0.0f));
+
+			CVector gunshellPos = *fireSource;
+			gunshellPos -= CVector(0.2f*ahead.x, 0.2f*ahead.y, 0.0f);
+			CVector dir = CrossProduct(CVector(ahead.x, ahead.y, 0.0f), CVector(0.0f, 0.0f, 5.0f));
+			dir.Normalise2D();
+			AddGunshell(shooter, gunshellPos, CVector2D(dir.x, dir.y), 0.015f);
+
+			break;
+		}
+
+		case WEAPONTYPE_COLT45:
+		{
+			CPointLights::AddLight(CPointLights::LIGHT_POINT,
+					*fireSource, CVector(0.0f, 0.0f, 0.0f), 5.0f,
+					1.0f, 0.8f, 0.0f, CPointLights::FOG_NONE, false);
+
+			CVector gunflashPos = *fireSource;
+
+			if ( shooterMoving )
+				gunflashPos += CVector(1.5f*vel.x, 1.5f*vel.y, 0.0f);
+
+			CParticle::AddParticle(PARTICLE_GUNFLASH_NOANIM, gunflashPos, CVector(0.0f, 0.0f, 0.0f), nil, 0.06f);
+			gunflashPos += CVector(0.06f*ahead.x, 0.06f*ahead.y, 0.0f);
+			CParticle::AddParticle(PARTICLE_GUNFLASH_NOANIM, gunflashPos, CVector(0.0f, 0.0f, 0.0f), nil, 0.04f);
+			gunflashPos += CVector(0.04f*ahead.x, 0.04f*ahead.y, 0.0f);
+			CParticle::AddParticle(PARTICLE_GUNFLASH_NOANIM, gunflashPos, CVector(0.0f, 0.0f, 0.0f), nil, 0.02f);
+
+			CVector gunsmokePos = *fireSource;
+			CParticle::AddParticle(PARTICLE_GUNSMOKE2, gunsmokePos, CVector(ahead.x*0.10f, ahead.y*0.10f, 0.0f), nil, 0.005f);
+			CParticle::AddParticle(PARTICLE_GUNSMOKE2, gunsmokePos, CVector(ahead.x*0.15f, ahead.y*0.15f, 0.0f), nil, 0.015f);
+			CParticle::AddParticle(PARTICLE_GUNSMOKE2, gunsmokePos, CVector(ahead.x*0.20f, ahead.y*0.20f, 0.0f), nil, 0.025f);
+
+			CVector gunshellPos = *fireSource;
+			gunshellPos -= CVector(0.2f*ahead.x, 0.2f*ahead.y, 0.0f);
+			CVector dir = CrossProduct(CVector(ahead.x, ahead.y, 0.0f), CVector(0.0f, 0.0f, 5.0f));
+			dir.Normalise2D();
+			AddGunshell(shooter, gunshellPos, CVector2D(dir.x, dir.y), 0.015f);
+
+			break;
+		}
+	}
+
+	DoBulletImpact(shooter, victim, fireSource, &target, &point, ahead);
+
+	return true;
+}
+
+void
+CWeapon::AddGunshell(CEntity *shooter, CVector const &source, CVector2D const &direction, float size)
+{
+	ASSERT(shooter!=nil);
+
+	if ( shooter == nil)
+		return;
+
+	CVector dir(direction.x*0.05f, direction.y*0.05f, CGeneral::GetRandomNumberInRange(0.02f, 0.08f));
+
+	static CVector prevEntityPosition(0.0f, 0.0f, 0.0f);
+	CVector entityPosition = shooter->GetPosition();
+
+	CVector diff = entityPosition - prevEntityPosition;
+
+	if ( Abs(diff.x)+Abs(diff.y)+Abs(diff.z) > 1.5f )
+	{
+		prevEntityPosition = entityPosition;
+
+		CParticle::AddParticle(PARTICLE_GUNSHELL_FIRST,
+			source, dir, nil, size, CGeneral::GetRandomNumberInRange(-20.0f, 20.0f));
+	}
+	else
+	{
+		CParticle::AddParticle(PARTICLE_GUNSHELL,
+			source, dir, nil, size, CGeneral::GetRandomNumberInRange(-20.0f, 20.0f));
+	}
+}
+
+void
+CWeapon::DoBulletImpact(CEntity *shooter, CEntity *victim,
+		CVector *source, CVector *target, CColPoint *point, CVector2D ahead)
+{
+	ASSERT(shooter!=nil);
+	ASSERT(source!=nil);
+	ASSERT(target!=nil);
+	ASSERT(point!=nil);
+
+	CWeaponInfo *info = GetInfo();
+
+	if ( victim )
+	{
+		CGlass::WasGlassHitByBullet(victim, point->point);
+
+		CVector traceTarget = point->point;
+		CBulletTraces::AddTrace(source, &traceTarget);
+
+		if ( shooter != nil )
+		{
+			if ( shooter == FindPlayerPed() )
+			{
+				if ( victim->IsPed() || victim->IsVehicle() )
+					CStats::InstantHitsHitByPlayer++;
+			}
+		}
+
+		if ( victim->IsPed() && ((CPed*)shooter)->m_nPedType != ((CPed*)victim)->m_nPedType || ((CPed*)shooter)->m_nPedType == PEDTYPE_PLAYER2 )
+		{
+			CPed *victimPed = (CPed *)victim;
+			if ( !victimPed->OnGround() && victim != shooter )
+			{
+				if ( victimPed->DoesLOSBulletHitPed(*point) )
+				{
+					CVector pos = victimPed->GetPosition();
+
+					CVector2D posOffset(source->x-pos.x, source->y-pos.y);
+					int32 localDir = victimPed->GetLocalDirection(posOffset);
+
+					victimPed->ReactToAttack(shooter);
+
+					if ( !victimPed->IsPedInControl() || victimPed->bIsDucking )
+					{
+						victimPed->InflictDamage(shooter, m_eWeaponType, info->m_nDamage, (ePedPieceTypes)point->pieceB, localDir);
+					}
+					else
+					{
+						if ( m_eWeaponType == WEAPONTYPE_SHOTGUN || m_eWeaponType == WEAPONTYPE_HELICANNON )
+						{
+							posOffset.Normalise();
+							victimPed->bIsStanding = false;
+
+							victimPed->ApplyMoveForce(posOffset.x*-5.0f, posOffset.y*-5.0f, 5.0f);
+							victimPed->SetFall(1500, AnimationId(ANIM_KO_SKID_FRONT + localDir), false);
+
+							victimPed->InflictDamage(shooter, m_eWeaponType, info->m_nDamage, (ePedPieceTypes)point->pieceB, localDir);
+						}
+						else
+						{
+							if ( victimPed->IsPlayer() )
+							{
+								CPlayerPed *victimPlayer = (CPlayerPed *)victimPed;
+								if ( victimPlayer->m_nHitAnimDelayTimer < CTimer::GetTimeInMilliseconds() )
+								{
+									victimPed->ClearAttackByRemovingAnim();
+
+									CAnimBlendAssociation *asoc = CAnimManager::AddAnimation(victimPed->GetClump(), ASSOCGRP_STD, AnimationId(ANIM_SHOT_FRONT_PARTIAL + localDir));
+									ASSERT(asoc!=nil);
+
+									asoc->blendAmount = 0.0f;
+									asoc->blendDelta  = 8.0f;
+
+									if ( m_eWeaponType == WEAPONTYPE_AK47 || m_eWeaponType == WEAPONTYPE_M16 )
+										victimPlayer->m_nHitAnimDelayTimer = CTimer::GetTimeInMilliseconds() + 2500;
+									else
+										victimPlayer->m_nHitAnimDelayTimer = CTimer::GetTimeInMilliseconds() + 1000;
+								}
+							}
+							else
+							{
+								victimPed->ClearAttackByRemovingAnim();
+
+								CAnimBlendAssociation *asoc = CAnimManager::AddAnimation(victimPed->GetClump(), ASSOCGRP_STD, AnimationId(ANIM_SHOT_FRONT_PARTIAL + localDir));
+								ASSERT(asoc!=nil);
+
+								asoc->blendAmount = 0.0f;
+								asoc->blendDelta  = 8.0f;
+							}
+
+							victimPed->InflictDamage(shooter, m_eWeaponType, info->m_nDamage, (ePedPieceTypes)point->pieceB, localDir);
+						}
+					}
+
+					if ( victimPed->m_nPedType == PEDTYPE_COP )
+						CEventList::RegisterEvent(EVENT_SHOOT_COP, EVENT_ENTITY_PED, victim, (CPed*)shooter, 10000);
+					else
+						CEventList::RegisterEvent(EVENT_SHOOT_PED, EVENT_ENTITY_PED, victim, (CPed*)shooter, 10000);
+
+					if ( CGame::nastyGame )
+					{
+						uint8 bloodAmount = 8;
+						if ( m_eWeaponType == WEAPONTYPE_SHOTGUN || m_eWeaponType == WEAPONTYPE_HELICANNON )
+							bloodAmount = 32;
+
+						CVector dir = (point->point - victim->GetPosition()) * 0.01f;
+						dir.z = 0.01f;
+
+						if ( victimPed->GetIsOnScreen() )
+						{
+							for ( uint8 i = 0; i < bloodAmount; i++ )
+								CParticle::AddParticle(PARTICLE_BLOOD_SMALL, point->point, dir);
+						}
+					}
+				}
+			}
+			else
+			{
+				if ( CGame::nastyGame )
+				{
+					CVector dir = (point->point - victim->GetPosition()) * 0.01f;
+					dir.z = 0.01f;
+
+					if ( victim->GetIsOnScreen() )
+					{
+						for ( int32 i = 0; i < 8; i++ )
+							CParticle::AddParticle(PARTICLE_BLOOD_SMALL, point->point + CVector(0.0f, 0.0f, 0.15f), dir);
+					}
+
+					if ( victimPed->Dead() )
+					{
+						CAnimBlendAssociation *asoc;
+						if ( RpAnimBlendClumpGetFirstAssociation(victimPed->GetClump(), ASSOC_FLAG800) )
+							asoc = CAnimManager::BlendAnimation(victimPed->GetClump(), ASSOCGRP_STD, ANIM_FLOOR_HIT_F, 8.0f);
+						else
+							asoc = CAnimManager::BlendAnimation(victimPed->GetClump(), ASSOCGRP_STD, ANIM_FLOOR_HIT,   8.0f);
+
+						if ( asoc )
+						{
+							asoc->SetCurrentTime(0.0f);
+							asoc->flags |= ASSOC_RUNNING;
+							asoc->flags &= ~ASSOC_FADEOUTWHENDONE;
+						}
+					}
+				}
+			}
+		}
+		else
+		{
+			switch ( victim->m_type )
+			{
+				case ENTITY_TYPE_BUILDING:
+				{
+					for ( int32 i = 0; i < 16; i++ )
+						CParticle::AddParticle(PARTICLE_SPARK, point->point, point->normal*0.05f);
+
+					CVector dist = point->point - (*source);
+					CVector offset = dist - max(0.2f*dist.Magnitude(), 2.0f) * CVector(ahead.x, ahead.y, 0.0f);
+					CVector smokePos = *source + offset;
+
+					smokePos.x += CGeneral::GetRandomNumberInRange(-0.2f, 0.2f);
+					smokePos.y += CGeneral::GetRandomNumberInRange(-0.2f, 0.2f);
+					smokePos.z += CGeneral::GetRandomNumberInRange(-0.2f, 0.2f);
+
+					CParticle::AddParticle(PARTICLE_BULLETHIT_SMOKE, smokePos, CVector(0.0f, 0.0f, 0.0f));
+
+					break;
+				}
+				case ENTITY_TYPE_VEHICLE:
+				{
+					((CVehicle *)victim)->InflictDamage(shooter, m_eWeaponType, info->m_nDamage);
+
+					for ( int32 i = 0; i < 16; i++ )
+						CParticle::AddParticle(PARTICLE_SPARK, point->point, point->normal*0.05f);
+
+					CVector dist = point->point - (*source);
+					CVector offset = dist - max(0.2f*dist.Magnitude(), 0.5f) * CVector(ahead.x, ahead.y, 0.0f);
+					CVector smokePos = *source + offset;
+
+					CParticle::AddParticle(PARTICLE_BULLETHIT_SMOKE, smokePos, CVector(0.0f, 0.0f, 0.0f));
+
+					if ( shooter->IsPed() )
+					{
+						CPed *shooterPed = (CPed *)shooter;
+
+						if ( shooterPed->bNotAllowedToDuck )
+						{
+							if ( shooterPed->bKindaStayInSamePlace && victim != shooterPed->m_pPointGunAt )
+							{
+								shooterPed->bKindaStayInSamePlace = false;
+								shooterPed->m_duckAndCoverTimer   = CTimer::GetTimeInMilliseconds() + 15000;
+							}
+						}
+					}
+
+					break;
+				}
+				case ENTITY_TYPE_OBJECT:
+				{
+					for ( int32 i = 0; i < 8; i++ )
+						CParticle::AddParticle(PARTICLE_SPARK, point->point, point->normal*0.05f);
+
+					CObject *victimObject = (CObject *)victim;
+
+					if ( !victimObject->bInfiniteMass )
+					{
+						if ( victimObject->bIsStatic && victimObject->m_fUprootLimit <= 0.0f )
+						{
+							victimObject->bIsStatic = false;
+							victimObject->AddToMovingList();
+						}
+
+						if ( !victimObject->bIsStatic )
+						{
+							CVector moveForce = point->normal*-4.0f;
+							victimObject->ApplyMoveForce(moveForce.x, moveForce.y, moveForce.z);
+						}
+					}
+
+					break;
+				}
+			}
+		}
+
+		switch ( victim->m_type )
+		{
+			case ENTITY_TYPE_BUILDING:
+			{
+				PlayOneShotScriptObject(SCRIPT_SOUND_BULLET_HIT_GROUND_1, point->point);
+				break;
+			}
+			case ENTITY_TYPE_VEHICLE:
+			{
+				DMAudio.PlayOneShot(((CPhysical*)victim)->m_audioEntityId, SOUND_WEAPON_HIT_VEHICLE, 1.0f);
+				break;
+			}
+			case ENTITY_TYPE_PED:
+			{
+				DMAudio.PlayOneShot(((CPhysical*)victim)->m_audioEntityId, SOUND_WEAPON_HIT_PED, 1.0f);
+				((CPed*)victim)->Say(SOUND_PED_BULLET_HIT);
+				break;
+			}
+			case ENTITY_TYPE_OBJECT:
+			{
+				PlayOneShotScriptObject(SCRIPT_SOUND_BULLET_HIT_GROUND_2, point->point);
+				break;
+			}
+			case ENTITY_TYPE_DUMMY:
+			{
+				PlayOneShotScriptObject(SCRIPT_SOUND_BULLET_HIT_GROUND_3, point->point);
+				break;
+			}
+		}
+	}
+	else
+		CBulletTraces::AddTrace(source, target);
+
+	if ( shooter == FindPlayerPed() )
+		CPad::GetPad(0)->StartShake_Distance(240, 128, FindPlayerPed()->GetPosition().x, FindPlayerPed()->GetPosition().y, FindPlayerPed()->GetPosition().z);
+
+	BlowUpExplosiveThings(victim);
+}
+
+bool
+CWeapon::FireShotgun(CEntity *shooter, CVector *fireSource)
+{
+	ASSERT(shooter!=nil);
+	ASSERT(fireSource!=nil);
+
+	CWeaponInfo *info = GetInfo();
+
+	float heading = RADTODEG(shooter->GetForward().Heading());
+	float angle   = DEGTORAD(heading);
+
+	CVector2D rotOffset(-Sin(angle), Cos(angle));
+	rotOffset.Normalise();
+
+	CVector gunflashPos = *fireSource;
+	gunflashPos += CVector(rotOffset.x*0.1f, rotOffset.y*0.1f, 0.0f);
+	CParticle::AddParticle(PARTICLE_GUNFLASH, gunflashPos, CVector(0.0f, 0.0f, 0.0f), nil, 0.0f);
+	gunflashPos += CVector(rotOffset.x*0.1f, rotOffset.y*0.1f, 0.0f);
+	CParticle::AddParticle(PARTICLE_GUNFLASH, gunflashPos, CVector(0.0f, 0.0f, 0.0f), nil, 0.15f);
+	gunflashPos += CVector(rotOffset.x*0.1f, rotOffset.y*0.1f, 0.0f);
+	CParticle::AddParticle(PARTICLE_GUNFLASH, gunflashPos, CVector(0.0f, 0.0f, 0.0f), nil, 0.2f);
+	CParticle::AddParticle(PARTICLE_GUNFLASH, *fireSource, CVector(0.0f, 0.0f, 0.0f), nil, 0.0f);
+
+	CVector gunsmokePos = *fireSource;
+	CParticle::AddParticle(PARTICLE_GUNSMOKE2, gunsmokePos, CVector(rotOffset.x*0.10f, rotOffset.y*0.10f, 0.0f), nil, 0.1f);
+	CParticle::AddParticle(PARTICLE_GUNSMOKE2, gunsmokePos, CVector(rotOffset.x*0.15f, rotOffset.y*0.15f, 0.0f), nil, 0.1f);
+	CParticle::AddParticle(PARTICLE_GUNSMOKE2, gunsmokePos, CVector(rotOffset.x*0.20f, rotOffset.y*0.20f, 0.0f), nil, 0.1f);
+	CParticle::AddParticle(PARTICLE_GUNSMOKE2, gunsmokePos, CVector(rotOffset.x*0.25f, rotOffset.y*0.25f, 0.0f), nil, 0.1f);
+
+	CEventList::RegisterEvent(EVENT_GUNSHOT, EVENT_ENTITY_PED, shooter, (CPed*)shooter, 1000);
+
+	CPointLights::AddLight(CPointLights::LIGHT_POINT, *fireSource, CVector(0.0, 0.0, 0.0), 5.0f,
+							1.0f, 0.8f, 0.0f, CPointLights::FOG_NONE, false);
+
+	float shooterAngle;
+
+	if ( shooter->IsPed() && ((CPed*)shooter)->m_pPointGunAt != nil )
+	{
+		CEntity *threatAttack = ((CPed*)shooter)->m_pPointGunAt;
+		shooterAngle = CGeneral::GetAngleBetweenPoints(threatAttack->GetPosition().x, threatAttack->GetPosition().y,
+														(*fireSource).x, (*fireSource).y);
+	}
+	else
+		shooterAngle = RADTODEG(shooter->GetForward().Heading());
+
+
+	for ( int32 i = 0; i < 5; i++ ) // five shoots at once
+	{
+		float shootAngle = DEGTORAD(7.5f*i + shooterAngle - 15.0f);
+		CVector2D shootRot(-Sin(shootAngle), Cos(shootAngle));
+
+		CVector source, target;
+		CColPoint point;
+		CEntity *victim;
+
+		if ( shooter == FindPlayerPed() && TheCamera.Cams[0].Using3rdPersonMouseCam() )
+		{
+			TheCamera.Find3rdPersonCamTargetVector(1.0f, *fireSource, source, target);
+			CVector Left = CrossProduct(TheCamera.Cams[TheCamera.ActiveCam].Front, TheCamera.Cams[TheCamera.ActiveCam].Up);
+
+			float f = float(i - 2) * (DEGTORAD(7.5f) / 2);
+			target  = f * Left + target - source;
+			target *= info->m_fRange;
+			target += source;
+
+			ProcessLineOfSight(source, target, point, victim, m_eWeaponType, shooter, true, true, true, true, true, true, false);
+		}
+		else
+		{
+			target = *fireSource;
+			target.x += shootRot.x * info->m_fRange;
+			target.y += shootRot.y * info->m_fRange;
+
+			if ( shooter->IsPed() )
+			{
+				CPed *shooterPed = (CPed *)shooter;
+
+				if ( shooterPed->m_pPointGunAt == nil )
+					DoDoomAiming(shooter, fireSource, &target);
+				else
+				{
+					float distToTarget = (shooterPed->m_pPointGunAt->GetPosition() - (*fireSource)).Magnitude2D();
+					target.z += info->m_fRange / distToTarget * (shooterPed->m_pPointGunAt->GetPosition().z - target.z);
+				}
+			}
+
+			ProcessLineOfSight(*fireSource, target, point, victim, m_eWeaponType, shooter, true, true, true, true, true, true, false);
+		}
+
+		if ( victim )
+		{
+			CGlass::WasGlassHitByBullet(victim, point.point);
+
+			CBulletTraces::AddTrace(fireSource, &point.point);
+
+			if ( victim->IsPed() )
+			{
+				CPed *victimPed = (CPed *)victim;
+				if ( !victimPed->OnGround() && victim != shooter && victimPed->DoesLOSBulletHitPed(point) )
+				{
+					bool cantStandup = true;
+
+					CVector pos = victimPed->GetPosition();
+
+					CVector2D posOffset((*fireSource).x-pos.x, (*fireSource).y-pos.y);
+					int32 localDir = victimPed->GetLocalDirection(posOffset);
+
+					victimPed->ReactToAttack(FindPlayerPed());
+
+					posOffset.Normalise();
+
+					if ( victimPed->m_getUpTimer > (CTimer::GetTimeInMilliseconds() - 3000) )
+						cantStandup = false;
+
+					if ( victimPed->bIsStanding && cantStandup )
+					{
+						victimPed->bIsStanding = false;
+
+						victimPed->ApplyMoveForce(posOffset.x*-6.0f, posOffset.y*-6.0f, 5.0f);
+					}
+					else
+						victimPed->ApplyMoveForce(posOffset.x*-2.0f, posOffset.y*-2.0f, 0.0f);
+
+					if ( cantStandup )
+						victimPed->SetFall(1500, AnimationId(ANIM_KO_SKID_FRONT + localDir), false);
+
+					victimPed->InflictDamage(nil, m_eWeaponType, info->m_nDamage, (ePedPieceTypes)point.pieceB, localDir);
+
+					if ( victimPed->m_nPedType == PEDTYPE_COP )
+						CEventList::RegisterEvent(EVENT_SHOOT_COP, EVENT_ENTITY_PED, victim, (CPed*)shooter, 10000);
+					else
+						CEventList::RegisterEvent(EVENT_SHOOT_PED, EVENT_ENTITY_PED, victim, (CPed*)shooter, 10000);
+
+					if ( CGame::nastyGame )
+					{
+						uint8 bloodAmount = 8;
+						if ( m_eWeaponType == WEAPONTYPE_SHOTGUN )
+							bloodAmount = 32;
+
+						CVector dir = (point.point - victim->GetPosition()) * 0.01f;
+						dir.z = 0.01f;
+
+						if ( victimPed->GetIsOnScreen() )
+						{
+							for ( uint8 i = 0; i < bloodAmount; i++ )
+								CParticle::AddParticle(PARTICLE_BLOOD_SMALL, point.point, dir);
+						}
+					}
+				}
+			}
+			else
+			{
+				switch ( victim->m_type )
+				{
+					case ENTITY_TYPE_VEHICLE:
+					{
+						((CVehicle *)victim)->InflictDamage(shooter, m_eWeaponType, info->m_nDamage);
+
+						for ( int32 i = 0; i < 16; i++ )
+							CParticle::AddParticle(PARTICLE_SPARK, point.point, point.normal*0.05f);
+
+						CVector dist = point.point - (*fireSource);
+						CVector offset = dist - max(0.2f*dist.Magnitude(), 2.0f) * CVector(shootRot.x, shootRot.y, 0.0f);
+						CVector smokePos = *fireSource + offset;
+
+						CParticle::AddParticle(PARTICLE_BULLETHIT_SMOKE, smokePos, CVector(0.0f, 0.0f, 0.0f));
+
+						break;
+					}
+
+					case ENTITY_TYPE_BUILDING:
+					case ENTITY_TYPE_OBJECT:
+					{
+						for ( int32 i = 0; i < 16; i++ )
+							CParticle::AddParticle(PARTICLE_SPARK, point.point, point.normal*0.05f);
+
+						CVector dist = point.point - (*fireSource);
+						CVector offset = dist - max(0.2f*dist.Magnitude(), 2.0f) * CVector(shootRot.x, shootRot.y, 0.0f);
+						CVector smokePos = *fireSource + offset;
+
+						smokePos.x += CGeneral::GetRandomNumberInRange(-0.2f, 0.2f);
+						smokePos.y += CGeneral::GetRandomNumberInRange(-0.2f, 0.2f);
+						smokePos.z += CGeneral::GetRandomNumberInRange(-0.2f, 0.2f);
+
+						CParticle::AddParticle(PARTICLE_BULLETHIT_SMOKE, smokePos, CVector(0.0f, 0.0f, 0.0f));
+
+						if ( victim->IsObject() )
+						{
+							CObject *victimObject = (CObject *)victim;
+
+							if ( !victimObject->bInfiniteMass )
+							{
+								if ( victimObject->bIsStatic && victimObject->m_fUprootLimit <= 0.0f )
+								{
+									victimObject->bIsStatic = false;
+									victimObject->AddToMovingList();
+								}
+
+								if ( !victimObject->bIsStatic )
+								{
+									CVector moveForce = point.normal*-5.0f;
+									victimObject->ApplyMoveForce(moveForce.x, moveForce.y, moveForce.z);
+								}
+							}
+						}
+
+						break;
+					}
+				}
+			}
+
+			switch ( victim->m_type )
+			{
+				case ENTITY_TYPE_BUILDING:
+				{
+					PlayOneShotScriptObject(SCRIPT_SOUND_BULLET_HIT_GROUND_1, point.point);
+					break;
+				}
+				case ENTITY_TYPE_VEHICLE:
+				{
+					DMAudio.PlayOneShot(((CPhysical*)victim)->m_audioEntityId, SOUND_WEAPON_HIT_VEHICLE, 1.0f);
+					break;
+				}
+				case ENTITY_TYPE_PED:
+				{
+					DMAudio.PlayOneShot(((CPhysical*)victim)->m_audioEntityId, SOUND_WEAPON_HIT_PED, 1.0f);
+					((CPed*)victim)->Say(SOUND_PED_BULLET_HIT);
+					break;
+				}
+				case ENTITY_TYPE_OBJECT:
+				{
+					PlayOneShotScriptObject(SCRIPT_SOUND_BULLET_HIT_GROUND_2, point.point);
+					break;
+				}
+				case ENTITY_TYPE_DUMMY:
+				{
+					PlayOneShotScriptObject(SCRIPT_SOUND_BULLET_HIT_GROUND_3, point.point);
+					break;
+				}
+			}
+		}
+		else
+		{
+			CVector traceTarget = *fireSource;
+			traceTarget += (target - (*fireSource)) * min(info->m_fRange, 30.0f) / info->m_fRange;
+			CBulletTraces::AddTrace(fireSource, &traceTarget);
+		}
+	}
+
+	if ( shooter == FindPlayerPed() )
+		CPad::GetPad(0)->StartShake_Distance(240, 128, FindPlayerPed()->GetPosition().x, FindPlayerPed()->GetPosition().y, FindPlayerPed()->GetPosition().z);
+
+	return true;
+}
+
+bool
+CWeapon::FireProjectile(CEntity *shooter, CVector *fireSource, float power)
+{
+	ASSERT(shooter!=nil);
+	ASSERT(fireSource!=nil);
+
+	CVector source, target;
+
+	if ( m_eWeaponType == WEAPONTYPE_ROCKETLAUNCHER )
+	{
+		source = *fireSource;
+
+		if ( shooter->IsPed() && ((CPed*)shooter)->IsPlayer() )
+		{
+			int16 mode = TheCamera.Cams[TheCamera.ActiveCam].Mode;
+			if (!( mode == CCam::MODE_M16_1STPERSON
+				|| mode == CCam::MODE_SNIPER
+				|| mode == CCam::MODE_ROCKETLAUNCHER
+				|| mode == CCam::MODE_M16_1STPERSON_RUNABOUT
+				|| mode == CCam::MODE_SNIPER_RUNABOUT
+				|| mode == CCam::MODE_ROCKETLAUNCHER_RUNABOUT) )
+			{
+				return false;
+			}
+
+			*fireSource += TheCamera.Cams[TheCamera.ActiveCam].Front;
+		}
+		else
+			*fireSource += shooter->GetForward();
+
+		target = *fireSource;
+	}
+	else
+	{
+		float dot = DotProduct(*fireSource-shooter->GetPosition(), shooter->GetForward());
+
+		if ( dot < 0.3f )
+			*fireSource += (0.3f-dot) * shooter->GetForward();
+
+		target = *fireSource;
+
+		if ( target.z - shooter->GetPosition().z > 0.0f )
+			target += 0.6f*shooter->GetForward();
+
+		source = *fireSource - shooter->GetPosition();
+
+		source = *fireSource - DotProduct(source, shooter->GetForward()) * shooter->GetForward();
+	}
+
+	if ( !CWorld::GetIsLineOfSightClear(source, target, true, true, false, true, false, false, false) )
+	{
+		if ( m_eWeaponType != WEAPONTYPE_GRENADE )
+			CProjectileInfo::RemoveNotAdd(shooter, m_eWeaponType, *fireSource);
+		else
+		{
+			if ( shooter->IsPed() )
+			{
+				source    = shooter->GetPosition() - shooter->GetForward();
+				source.z -= 0.4f;
+
+				if ( !CWorld::TestSphereAgainstWorld(source, 0.5f, nil, false, false, true, false, false, false) )
+					CProjectileInfo::AddProjectile(shooter, m_eWeaponType, source, 0.0f);
+				else
+					CProjectileInfo::RemoveNotAdd(shooter, m_eWeaponType, *fireSource);
+			}
+		}
+	}
+	else
+		CProjectileInfo::AddProjectile(shooter, m_eWeaponType, *fireSource, power);
+
+	return true;
+}
+
+void
+CWeapon::GenerateFlameThrowerParticles(CVector pos, CVector dir)
+{
+	dir *= 0.7f;
+	CParticle::AddParticle(PARTICLE_FIREBALL, pos, dir);
+
+	dir *= 0.7f;
+	CParticle::AddParticle(PARTICLE_FIREBALL, pos, dir);
+
+	dir *= 0.7f;
+	CParticle::AddParticle(PARTICLE_FIREBALL, pos, dir);
+
+	dir *= 0.7f;
+	CParticle::AddParticle(PARTICLE_FIREBALL, pos, dir);
+
+	dir *= 0.7f;
+	CParticle::AddParticle(PARTICLE_FIREBALL, pos, dir);
+}
+
+bool
+CWeapon::FireAreaEffect(CEntity *shooter, CVector *fireSource)
+{
+	ASSERT(shooter!=nil);
+	ASSERT(fireSource!=nil);
+
+	CWeaponInfo *info = GetInfo();
+
+	float heading = RADTODEG(shooter->GetForward().Heading());
+
+	CVector source;
+	CVector target;
+	CVector dir;
+
+	if ( shooter == FindPlayerPed() && TheCamera.Cams[0].Using3rdPersonMouseCam() )
+	{
+		TheCamera.Find3rdPersonCamTargetVector(info->m_fRange, *fireSource, source, target);
+		float norm = (1.0f / info->m_fRange);
+		dir = (target - source) * norm;
+	}
+	else
+	{
+		float angle = DEGTORAD(heading);
+		dir         = CVector(-Sin(angle)*0.5f, Cos(angle)*0.5f, 0.0f);
+		target      = *fireSource + dir;
+	}
+
+	CShotInfo::AddShot(shooter, m_eWeaponType, *fireSource, target);
+	CWeapon::GenerateFlameThrowerParticles(*fireSource, dir);
+
+	return true;
+}
+
+bool
+CWeapon::FireSniper(CEntity *shooter)
+{
+	ASSERT(shooter!=nil);
+
+	int16 mode = TheCamera.Cams[TheCamera.ActiveCam].Mode;
+	if (!( mode == CCam::MODE_M16_1STPERSON
+		|| mode == CCam::MODE_SNIPER
+		|| mode == CCam::MODE_ROCKETLAUNCHER
+		|| mode == CCam::MODE_M16_1STPERSON_RUNABOUT
+		|| mode == CCam::MODE_SNIPER_RUNABOUT
+		|| mode == CCam::MODE_ROCKETLAUNCHER_RUNABOUT) )
+	{
+		return false;
+	}
+
+#ifndef FIX_BUGS
+	CWeaponInfo *info = GetInfo(); //unused
+#endif
+
+	CCam *cam = &TheCamera.Cams[TheCamera.ActiveCam];
+	ASSERT(cam!=nil);
+
+	CVector source = cam->Source;
+	CVector dir    = cam->Front;
+
+	if ( DotProduct(dir, CVector(0.0f, -0.9894f, 0.145f)) > 0.997f )
+		CCoronas::bSmallMoon = !CCoronas::bSmallMoon;
+
+	dir.Normalise();
+	dir *= 16.0f;
+
+	CBulletInfo::AddBullet(shooter, m_eWeaponType, source, dir);
+
+	if ( shooter == FindPlayerPed() )
+		CStats::InstantHitsFiredByPlayer++;
+
+	if ( shooter == FindPlayerPed() )
+	{
+		CPad::GetPad(0)->StartShake_Distance(240, 128,
+			FindPlayerPed()->GetPosition().x,
+			FindPlayerPed()->GetPosition().y,
+			FindPlayerPed()->GetPosition().z);
+
+		CamShakeNoPos(&TheCamera, 0.2f);
+	}
+
+	return true;
+}
+
+bool
+CWeapon::FireM16_1stPerson(CEntity *shooter)
+{
+	ASSERT(shooter!=nil);
+
+	int16 mode = TheCamera.Cams[TheCamera.ActiveCam].Mode;
+
+	if (!( mode == CCam::MODE_M16_1STPERSON
+		|| mode == CCam::MODE_SNIPER
+		|| mode == CCam::MODE_ROCKETLAUNCHER
+		|| mode == CCam::MODE_M16_1STPERSON_RUNABOUT
+		|| mode == CCam::MODE_SNIPER_RUNABOUT
+		|| mode == CCam::MODE_ROCKETLAUNCHER_RUNABOUT
+		|| mode == CCam::MODE_HELICANNON_1STPERSON) )
+	{
+		return false;
+	}
+
+	CWeaponInfo *info = GetInfo();
+
+	CColPoint point;
+	CEntity *victim;
+
+	CWorld::bIncludeCarTyres = true;
+	CWorld::pIgnoreEntity = shooter;
+	CWorld::bIncludeDeadPeds = true;
+
+	CCam *cam = &TheCamera.Cams[TheCamera.ActiveCam];
+	ASSERT(cam!=nil);
+
+	CVector source = cam->Source;
+	CVector target = cam->Front*info->m_fRange + source;
+
+	ProcessLineOfSight(source, target, point, victim, m_eWeaponType, shooter, true, true, true, true, true, true, false);
+	CWorld::bIncludeDeadPeds = false;
+	CWorld::pIgnoreEntity = nil;
+	CWorld::bIncludeCarTyres = false;
+
+	CVector2D front(cam->Front.x, cam->Front.y);
+	front.Normalise();
+
+	DoBulletImpact(shooter, victim, &source, &target, &point, front);
+
+	CVector bulletPos;
+	if ( CHeli::TestBulletCollision(&source, &target, &bulletPos, 4) )
+	{
+		for ( int32 i = 0; i < 16; i++ )
+			CParticle::AddParticle(PARTICLE_SPARK, bulletPos, CVector(0.0f, 0.0f, 0.0f));
+	}
+
+	if ( shooter == FindPlayerPed() )
+	{
+		CPad::GetPad(0)->StartShake_Distance(240, 128, FindPlayerPed()->GetPosition().x, FindPlayerPed()->GetPosition().y, FindPlayerPed()->GetPosition().z);
+
+		if ( m_eWeaponType == WEAPONTYPE_M16 )
+		{
+			TheCamera.Cams[TheCamera.ActiveCam].Beta  += float((CGeneral::GetRandomNumber() & 127) - 64) * 0.0003f;
+			TheCamera.Cams[TheCamera.ActiveCam].Alpha += float((CGeneral::GetRandomNumber() & 127) - 64) * 0.0003f;
+		}
+		else if ( m_eWeaponType == WEAPONTYPE_HELICANNON )
+		{
+			TheCamera.Cams[TheCamera.ActiveCam].Beta  += float((CGeneral::GetRandomNumber() & 127) - 64) * 0.0001f;
+			TheCamera.Cams[TheCamera.ActiveCam].Alpha += float((CGeneral::GetRandomNumber() & 127) - 64) * 0.0001f;
+		}
+	}
+
+	return true;
+}
+
+bool
+CWeapon::FireInstantHitFromCar(CAutomobile *shooter, bool left)
+{
+	CWeaponInfo *info = GetInfo();
+
+	CVehicleModelInfo *modelInfo = shooter->GetModelInfo();
+
+	#define FRONTSEATPOS() (&(shooter->IsBoat() ? modelInfo->m_positions[BOAT_POS_FRONTSEAT] : modelInfo->m_positions[CAR_POS_FRONTSEAT]))
+
+	CVector source, target;
+	if ( left )
+	{
+		source = shooter->GetMatrix() * CVector(-shooter->GetColModel()->boundingBox.max.x + -0.2f,
+												float(CGeneral::GetRandomNumber() & 255) * 0.001f + FRONTSEATPOS()->y,
+												FRONTSEATPOS()->z + 0.5f);
+		source += CTimer::GetTimeStep() * shooter->m_vecMoveSpeed;
+
+
+		target = shooter->GetMatrix() * CVector(-info->m_fRange,
+													FRONTSEATPOS()->y,
+													FRONTSEATPOS()->z + 0.5f);
+	}
+	else
+	{
+		source = shooter->GetMatrix() * CVector(shooter->GetColModel()->boundingBox.max.x + 0.2f,
+												float(CGeneral::GetRandomNumber() & 255) * 0.001f + FRONTSEATPOS()->y,
+												FRONTSEATPOS()->z + 0.5f);
+		source += CTimer::GetTimeStep() * shooter->m_vecMoveSpeed;
+
+		target = shooter->GetMatrix() * CVector(info->m_fRange,
+													FRONTSEATPOS()->y,
+													FRONTSEATPOS()->z + 0.5f);
+	}
+	#undef FRONTSEATPOS
+
+	if ( TheCamera.GetLookingLRBFirstPerson() && !left )
+	{
+		source -= 0.3f * shooter->GetForward();
+		target -= 0.3f * shooter->GetForward();
+	}
+
+	target += CVector(float(CGeneral::GetRandomNumber()&255)*0.01f-1.28f,
+						float(CGeneral::GetRandomNumber()&255)*0.01f-1.28f,
+						float(CGeneral::GetRandomNumber()&255)*0.01f-1.28f);
+
+	DoDriveByAutoAiming(FindPlayerPed(), &source, &target);
+
+	CEventList::RegisterEvent(EVENT_GUNSHOT, EVENT_ENTITY_PED, FindPlayerPed(), FindPlayerPed(), 1000);
+
+	if ( !TheCamera.GetLookingLRBFirstPerson() )
+		CParticle::AddParticle(PARTICLE_GUNFLASH, source, CVector(0.0f, 0.0f, 0.0f));
+	else
+		CamShakeNoPos(&TheCamera, 0.01f);
+
+	CEventList::RegisterEvent(EVENT_GUNSHOT, EVENT_ENTITY_VEHICLE, shooter, FindPlayerPed(), 1000);
+
+	CPointLights::AddLight(CPointLights::LIGHT_POINT, source, CVector(0.0f, 0.0f, 0.0f), 5.0f,
+		1.0f, 0.8f, 0.0f, CPointLights::FOG_NONE, false);
+
+	CColPoint point;
+	CEntity *victim;
+	ProcessLineOfSight(source, target, point, victim, m_eWeaponType, shooter, true, true, true, true, true, true, false);
+
+	if ( !(CTimer::GetFrameCounter() & 3) )
+		MakePedsJumpAtShot(shooter, &source, &target);
+
+	if ( victim )
+	{
+		CVector traceTarget = point.point;
+		CBulletTraces::AddTrace(&source, &traceTarget);
+
+		if ( victim->IsPed() )
+		{
+			CPed *victimPed = (CPed*)victim;
+
+			if ( !victimPed->DyingOrDead() && victim != (CEntity *)shooter )
+			{
+				CVector pos = victimPed->GetPosition();
+
+				CVector2D posOffset(source.x-pos.x, source.y-pos.y);
+				int32 localDir = victimPed->GetLocalDirection(posOffset);
+
+				victimPed->ReactToAttack(FindPlayerPed());
+				victimPed->ClearAttackByRemovingAnim();
+
+				CAnimBlendAssociation *asoc = CAnimManager::AddAnimation(victimPed->GetClump(), ASSOCGRP_STD, AnimationId(ANIM_SHOT_FRONT_PARTIAL + localDir));
+				ASSERT(asoc!=nil);
+				asoc->blendAmount = 0.0f;
+				asoc->blendDelta  = 8.0f;
+
+				victimPed->InflictDamage(shooter, WEAPONTYPE_UZI_DRIVEBY, 3*info->m_nDamage, (ePedPieceTypes)point.pieceB, localDir);
+
+				pos.z += 0.8f;
+
+				if ( victimPed->GetIsOnScreen() )
+				{
+					if ( CGame::nastyGame )
+					{
+						for ( int32 i = 0; i < 4; i++ )
+						{
+							CVector dir;
+							dir.x = CGeneral::GetRandomNumberInRange(-0.1f, 0.1f);
+							dir.y = CGeneral::GetRandomNumberInRange(-0.1f, 0.1f);
+							dir.z = CGeneral::GetRandomNumberInRange(-0.1f, 0.1f);
+
+							CParticle::AddParticle(PARTICLE_BLOOD, pos, dir);
+						}
+					}
+				}
+
+				if ( victimPed->m_nPedType == PEDTYPE_COP )
+					CEventList::RegisterEvent(EVENT_SHOOT_COP, EVENT_ENTITY_PED, victimPed, FindPlayerPed(), 10000);
+				else
+					CEventList::RegisterEvent(EVENT_SHOOT_PED, EVENT_ENTITY_PED, victimPed, FindPlayerPed(), 10000);
+			}
+		}
+		else if ( victim->IsVehicle() )
+			((CVehicle *)victim)->InflictDamage(FindPlayerPed(), WEAPONTYPE_UZI_DRIVEBY, info->m_nDamage);
+		else
+			CGlass::WasGlassHitByBullet(victim, point.point);
+
+		switch ( victim->m_type )
+		{
+			case ENTITY_TYPE_BUILDING:
+			{
+				PlayOneShotScriptObject(SCRIPT_SOUND_BULLET_HIT_GROUND_1, point.point);
+				break;
+			}
+			case ENTITY_TYPE_VEHICLE:
+			{
+				DMAudio.PlayOneShot(((CPhysical*)victim)->m_audioEntityId, SOUND_WEAPON_HIT_VEHICLE, 1.0f);
+				break;
+			}
+			case ENTITY_TYPE_PED:
+			{
+				DMAudio.PlayOneShot(((CPhysical*)victim)->m_audioEntityId, SOUND_WEAPON_HIT_PED, 1.0f);
+				((CPed*)victim)->Say(SOUND_PED_BULLET_HIT);
+				break;
+			}
+			case ENTITY_TYPE_OBJECT:
+			{
+				PlayOneShotScriptObject(SCRIPT_SOUND_BULLET_HIT_GROUND_2, point.point);
+				break;
+			}
+			case ENTITY_TYPE_DUMMY:
+			{
+				PlayOneShotScriptObject(SCRIPT_SOUND_BULLET_HIT_GROUND_3, point.point);
+				break;
+			}
+		}
+	}
+	else
+	{
+		float norm = 30.0f/info->m_fRange;
+		CVector traceTarget = (target-source)*norm + source;
+		CBulletTraces::AddTrace(&source, &traceTarget);
+	}
+
+	if ( shooter == FindPlayerVehicle() )
+		CPad::GetPad(0)->StartShake_Distance(240, 128, FindPlayerVehicle()->GetPosition().x, FindPlayerVehicle()->GetPosition().y, FindPlayerVehicle()->GetPosition().z);
+
+	return true;
+}
+
+void
+CWeapon::DoDoomAiming(CEntity *shooter, CVector *source, CVector *target)
+{
+	ASSERT(shooter!=nil);
+	ASSERT(source!=nil);
+	ASSERT(target !=nil);
+
+#ifndef FIX_BUGS
+	CEntity entity; // unused
+#endif
+
+	CPed *shooterPed = (CPed*)shooter;
+	if ( shooterPed->IsPed() && shooterPed->bCrouchWhenShooting )
+		return;
+
+	int16 lastEntity;
+	CEntity *entities[16];
+	CWorld::FindObjectsInRange(*source, (*target-*source).Magnitude(), true, &lastEntity, 15, entities, false, true, true, false, false);
+
+	float closestEntityDist = 10000.0f;
+	int16 closestEntity;
+
+	for ( int32 i = 0; i < lastEntity; i++ )
+	{
+		CEntity *victim = entities[i];
+		ASSERT(victim!=nil);
+
+		if ( (CEntity*)shooterPed != victim && shooterPed->CanSeeEntity(victim, DEGTORAD(22.5f)) )
+		{
+			if ( !(victim->m_status == STATUS_TRAIN_MOVING
+				|| victim->m_status == STATUS_TRAIN_NOT_MOVING
+				|| victim->m_status == STATUS_HELI
+				|| victim->m_status == STATUS_PLANE) )
+			{
+				float distToVictim   = (shooterPed->GetPosition()-victim->GetPosition()).Magnitude2D();
+				float distToVictimZ  = Abs(shooterPed->GetPosition().z-victim->GetPosition().z);
+
+				if ( 1.5f*distToVictimZ < distToVictim )
+				{
+					float entityDist = Sqrt(SQR(distToVictim) + SQR(distToVictimZ));
+
+					if ( entityDist < closestEntityDist )
+					{
+						closestEntityDist = entityDist;
+						closestEntity = i;
+					}
+				}
+			}
+		}
+	}
+
+	if ( closestEntityDist < DOOMAUTOAIMING_MAXDIST )
+	{
+		CEntity *victim = entities[closestEntity];
+		ASSERT(victim !=nil);
+
+		float distToTarget = (*target - *source).Magnitude2D();
+		float distToSource = (victim->GetPosition() - *source).Magnitude2D();
+
+		float victimZ = victim->GetPosition().z + 0.3f;
+		if ( victim->IsPed() )
+		{
+			if ( ((CPed*)victim)->bIsDucking )
+				victimZ -= 0.8f;
+		}
+
+		(*target).z = (distToTarget / distToSource) * (victimZ - (*source).z) + (*source).z;
+	}
+}
+
+void
+CWeapon::DoTankDoomAiming(CEntity *shooter, CEntity *driver, CVector *source, CVector *target)
+{
+	ASSERT(shooter!=nil);
+	ASSERT(driver!=nil);
+	ASSERT(source!=nil);
+	ASSERT(target!=nil);
+
+#ifndef FIX_BUGS
+	CEntity entity; // unused
+#endif
+
+	int16 lastEntity;
+	CEntity *entities[16];
+	CWorld::FindObjectsInRange(*source, (*target-*source).Magnitude(), true, &lastEntity, 15, entities, false, true, false, false, false);
+
+	float closestEntityDist = 10000.0f;
+	int16 closestEntity;
+
+	float normZ = (target->z - source->z) / (*target-*source).Magnitude();
+
+	for ( int32 i = 0; i < lastEntity; i++ )
+	{
+		CEntity *victim = entities[i];
+
+		ASSERT(victim!=nil);
+
+		if ( shooter != victim && driver != victim )
+		{
+			if ( !(victim->m_status == STATUS_TRAIN_MOVING
+				|| victim->m_status == STATUS_TRAIN_NOT_MOVING
+				|| victim->m_status == STATUS_HELI
+				|| victim->m_status == STATUS_PLANE) )
+			{
+				if ( !(victim->IsVehicle() && victim->bRenderScorched) )
+				{
+					float distToVictim  = (shooter->GetPosition()-victim->GetPosition()).Magnitude2D();
+					float distToVictimZ = Abs(shooter->GetPosition().z - (distToVictim*normZ + victim->GetPosition().z));
+
+					if ( 3.0f*distToVictimZ < distToVictim )
+					{
+						if ( CCollision::DistToLine(source, target,
+								&CVector(victim->GetPosition().x, victim->GetPosition().y, 0.0f)) < victim->GetBoundRadius()*3.0f )
+						{
+							float vehicleDist = Sqrt(SQR(distToVictim) + SQR(distToVictimZ));
+							if ( vehicleDist < closestEntityDist )
+							{
+								closestEntityDist = vehicleDist;
+								closestEntity = i;
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
+	if ( closestEntityDist < DOOMAUTOAIMING_MAXDIST )
+	{
+		CEntity *victim = entities[closestEntity];
+		ASSERT(victim!=nil);
+
+		float distToTarget = (*target - *source).Magnitude2D();
+		float distToSource = (victim->GetPosition() - *source).Magnitude2D();
+
+		(*target).z = (distToTarget / distToSource) * (0.3f + victim->GetPosition().z - (*source).z) + (*source).z;
+	}
+}
+
+void
+CWeapon::DoDriveByAutoAiming(CEntity *shooter, CVector *source, CVector *target)
+{
+	ASSERT(shooter!=nil);
+	ASSERT(source!=nil);
+	ASSERT(target!=nil);
+
+#ifndef FIX_BUGS
+	CEntity entity; // unused
+#endif
+
+	CPed *shooterPed = (CPed*)shooter;
+	if ( shooterPed->IsPed() && shooterPed->bCrouchWhenShooting )
+		return;
+
+	int16 lastEntity;
+	CEntity *entities[16];
+	CWorld::FindObjectsInRange(*source, (*target-*source).Magnitude(), true, &lastEntity, 15, entities, false, false, true, false, false);
+
+	float closestEntityDist = 10000.0f;
+	int16 closestEntity;
+
+	for ( int32 i = 0; i < lastEntity; i++ )
+	{
+		CEntity *victim = entities[i];
+		ASSERT(victim!=nil);
+
+		if ( shooter != victim )
+		{
+			float lineDist = CCollision::DistToLine(source, target, &victim->GetPosition());
+			float distToVictim  = (victim->GetPosition() - shooter->GetPosition()).Magnitude();
+			float pedDist = 0.15f*distToVictim + lineDist;
+
+			if ( DotProduct((*target-*source), victim->GetPosition()-*source) > 0.0f && pedDist < closestEntityDist)
+			{
+				closestEntity = i;
+				closestEntityDist = pedDist;
+			}
+		}
+	}
+
+	if ( closestEntityDist < DRIVEBYAUTOAIMING_MAXDIST )
+	{
+		CEntity *victim = entities[closestEntity];
+		ASSERT(victim!=nil);
+
+		float distToTarget = (*source - *target).Magnitude();
+		float distToSource      = (*source - victim->GetPosition()).Magnitude();
+		*target = (distToTarget / distToSource) * (victim->GetPosition() - *source) + *source;
+	}
+}
+
 void
 CWeapon::Reload(void)
 {
 	if (m_nAmmoTotal == 0)
 		return;
 
-	CWeaponInfo *info = CWeaponInfo::GetWeaponInfo(m_eWeaponType);
+	CWeaponInfo *info = GetInfo();
 
 	if (m_nAmmoTotal >= info->m_nAmountofAmmunition)
 		m_nAmmoInClip = info->m_nAmountofAmmunition;
@@ -44,10 +1971,159 @@ CWeapon::Reload(void)
 		m_nAmmoInClip = m_nAmmoTotal;
 }
 
-bool
-CWeapon::IsType2Handed(void)
+void
+CWeapon::Update(int32 audioEntity)
 {
-	return m_eWeaponType >= WEAPONTYPE_SHOTGUN && m_eWeaponType <= WEAPONTYPE_FLAMETHROWER && m_eWeaponType != WEAPONTYPE_ROCKETLAUNCHER;
+	switch ( m_eWeaponState )
+	{
+		case WEAPONSTATE_MELEE_MADECONTACT:
+		{
+			m_eWeaponState = WEAPONSTATE_READY;
+			break;
+		}
+
+		case WEAPONSTATE_FIRING:
+		{
+			if ( m_eWeaponType == WEAPONTYPE_SHOTGUN && AEHANDLE_IS_OK(audioEntity) )
+			{
+				uint32 timePassed = m_nTimer - gReloadSampleTime[WEAPONTYPE_SHOTGUN];
+				if ( CTimer::GetPreviousTimeInMilliseconds() < timePassed && CTimer::GetTimeInMilliseconds() >= timePassed )
+					DMAudio.PlayOneShot(audioEntity, SOUND_WEAPON_RELOAD, 0.0f);
+			}
+
+			if ( CTimer::GetTimeInMilliseconds() > m_nTimer )
+			{
+				if ( GetInfo()->m_eWeaponFire != WEAPON_FIRE_MELEE && m_nAmmoTotal == 0 )
+					m_eWeaponState = WEAPONSTATE_OUT_OF_AMMO;
+				else
+					m_eWeaponState = WEAPONSTATE_READY;
+			}
+
+			break;
+		}
+
+		case WEAPONSTATE_RELOADING:
+		{
+			if  ( AEHANDLE_IS_OK(audioEntity) && m_eWeaponType < WEAPONTYPE_LAST_WEAPONTYPE )
+			{
+				uint32 timePassed = m_nTimer - gReloadSampleTime[m_eWeaponType];
+				if ( CTimer::GetPreviousTimeInMilliseconds() < timePassed && CTimer::GetTimeInMilliseconds() >= timePassed )
+					DMAudio.PlayOneShot(audioEntity, SOUND_WEAPON_RELOAD, 0.0f);
+			}
+
+			if ( CTimer::GetTimeInMilliseconds() > m_nTimer )
+			{
+				Reload();
+				m_eWeaponState = WEAPONSTATE_READY;
+			}
+
+			break;
+		}
+	}
+}
+
+void
+FireOneInstantHitRound(CVector *source, CVector *target, int32 damage)
+{
+	ASSERT(source!=nil);
+	ASSERT(target!=nil);
+
+	CParticle::AddParticle(PARTICLE_GUNFLASH, *source, CVector(0.0f, 0.0f, 0.0f));
+
+	CPointLights::AddLight(CPointLights::LIGHT_POINT,
+		*source, CVector(0.0f, 0.0f, 0.0f), 5.0f,
+		1.0f, 0.8f, 0.0f, CPointLights::FOG_NONE, false);
+
+	CColPoint point;
+	CEntity *victim;
+	CWorld::ProcessLineOfSight(*source, *target, point, victim, true, true, true, true, true, true, false);
+
+	CParticle::AddParticle(PARTICLE_HELI_ATTACK, *source, ((*target) - (*source)) * 0.15f);
+
+	if ( victim )
+	{
+		if ( victim->IsPed() )
+		{
+			CPed *victimPed = (CPed *)victim;
+			if ( !victimPed->DyingOrDead() )
+			{
+				CVector pos = victimPed->GetPosition();
+
+				CVector2D posOffset((*source).x-pos.x, (*source).y-pos.y);
+				int32 localDir = victimPed->GetLocalDirection(posOffset);
+
+				victimPed->ClearAttackByRemovingAnim();
+
+				CAnimBlendAssociation *asoc = CAnimManager::AddAnimation(victimPed->GetClump(), ASSOCGRP_STD, AnimationId(ANIM_SHOT_FRONT_PARTIAL + localDir));
+				ASSERT(asoc!=nil);
+				asoc->blendAmount = 0.0f;
+				asoc->blendDelta  = 8.0f;
+
+				victimPed->InflictDamage(nil, WEAPONTYPE_UZI, damage, (ePedPieceTypes)point.pieceB, localDir);
+
+				pos.z += 0.8f;
+
+				if ( victimPed->GetIsOnScreen() )
+				{
+					if ( CGame::nastyGame )
+					{
+						for ( int32 i = 0; i < 4; i++ )
+						{
+							CVector dir;
+							dir.x = CGeneral::GetRandomNumberInRange(-0.1f, 0.1f);
+							dir.y = CGeneral::GetRandomNumberInRange(-0.1f, 0.1f);
+							dir.z = CGeneral::GetRandomNumberInRange(-0.1f, 0.1f);
+
+							CParticle::AddParticle(PARTICLE_BLOOD, pos, dir);
+						}
+					}
+				}
+			}
+		}
+		else if ( victim->IsVehicle() )
+			((CVehicle *)victim)->InflictDamage(nil, WEAPONTYPE_UZI, damage);
+		//BUG ? no CGlass::WasGlassHitByBullet
+
+		switch ( victim->m_type )
+		{
+			case ENTITY_TYPE_BUILDING:
+			{
+				PlayOneShotScriptObject(SCRIPT_SOUND_BULLET_HIT_GROUND_1, point.point);
+				CParticle::AddParticle(PARTICLE_SMOKE, point.point, CVector(0.0f, 0.0f, 0.01f));
+				break;
+			}
+			case ENTITY_TYPE_VEHICLE:
+			{
+				DMAudio.PlayOneShot(((CPhysical*)victim)->m_audioEntityId, SOUND_WEAPON_HIT_VEHICLE, 1.0f);
+				break;
+			}
+			case ENTITY_TYPE_PED:
+			{
+				DMAudio.PlayOneShot(((CPhysical*)victim)->m_audioEntityId, SOUND_WEAPON_HIT_PED, 1.0f);
+				((CPed*)victim)->Say(SOUND_PED_BULLET_HIT);
+				break;
+			}
+			case ENTITY_TYPE_OBJECT:
+			{
+				PlayOneShotScriptObject(SCRIPT_SOUND_BULLET_HIT_GROUND_2, point.point);
+				break;
+			}
+			case ENTITY_TYPE_DUMMY:
+			{
+				PlayOneShotScriptObject(SCRIPT_SOUND_BULLET_HIT_GROUND_3, point.point);
+				break;
+			}
+		}
+	}
+	else
+	{
+		float waterLevel;
+		if ( CWaterLevel::GetWaterLevel((*target).x, (*target).y, (*target).z + 10.0f, &waterLevel, false) )
+		{
+			CParticle::AddParticle(PARTICLE_BOAT_SPLASH, CVector((*target).x, (*target).y, waterLevel), CVector(0.0f, 0.0f, 0.01f));
+			PlayOneShotScriptObject(SCRIPT_SOUND_BULLET_HIT_WATER, point.point); // no sound(empty)
+		}
+	}
 }
 
 bool
@@ -57,32 +2133,75 @@ CWeapon::IsTypeMelee(void)
 }
 
 bool
-CWeapon::HitsGround(CEntity *holder, CVector *firePos, CEntity *aimingTo)
+CWeapon::IsType2Handed(void)
 {
+	return m_eWeaponType >= WEAPONTYPE_SHOTGUN && m_eWeaponType <= WEAPONTYPE_FLAMETHROWER && m_eWeaponType != WEAPONTYPE_ROCKETLAUNCHER;
+}
+
+void
+CWeapon::MakePedsJumpAtShot(CPhysical *shooter, CVector *source, CVector *target)
+{
+	ASSERT(shooter!=nil);
+	ASSERT(source!=nil);
+	ASSERT(target!=nil);
+
+	float minx = min(source->x, target->x) - 2.0f;
+	float maxx = max(source->x, target->x) + 2.0f;
+	float miny = min(source->y, target->y) - 2.0f;
+	float maxy = max(source->y, target->y) + 2.0f;
+	float minz = min(source->z, target->z) - 2.0f;
+	float maxz = max(source->z, target->z) + 2.0f;
+
+	for ( int32 i = CPools::GetPedPool()->GetSize() - 1; i >= 0; i--)
+	{
+		CPed *ped = CPools::GetPedPool()->GetSlot(i);
+
+		if ( ped )
+		{
+			if (   ped->GetPosition().x > minx && ped->GetPosition().x < maxx
+				&& ped->GetPosition().y > miny && ped->GetPosition().y < maxy
+				&& ped->GetPosition().z > minz && ped->GetPosition().z < maxz )
+			{
+				if ( ped != FindPlayerPed() && !((uint8)(ped->m_randomSeed ^ CGeneral::GetRandomNumber()) & 31) )
+					ped->SetEvasiveDive(shooter, 1);
+			}
+		}
+	}
+}
+
+bool
+CWeapon::HitsGround(CEntity *holder, CVector *fireSource, CEntity *aimingTo)
+{
+	ASSERT(holder!=nil);
+	ASSERT(aimingTo!=nil);
+
 	if (!holder->IsPed() || !((CPed*)holder)->m_pSeekTarget)
 		return false;
 
-	CWeaponInfo *ourType = CWeaponInfo::GetWeaponInfo(m_eWeaponType);
-	CVector adjustedOffset = ourType->m_vecFireOffset;
+	CWeaponInfo *info = GetInfo();
+
+	CVector adjustedOffset = info->m_vecFireOffset;
 	adjustedOffset.z += 0.6f;
 
-	CVector point1, point2;
+	CVector source, target;
 	CEntity *foundEnt = nil;
 	CColPoint foundCol;
 
-	if (firePos)
-		point1 = *firePos;
+	if (fireSource)
+		source = *fireSource;
 	else
-		point1 = holder->GetMatrix() * adjustedOffset;
+		source = holder->GetMatrix() * adjustedOffset;
 
 	CEntity *aimEntity = aimingTo ? aimingTo : ((CPed*)holder)->m_pSeekTarget;
-	point2 = aimEntity->GetPosition();
-	point2.z += 0.6f;
+	ASSERT(aimEntity!=nil);
+
+	target = aimEntity->GetPosition();
+	target.z += 0.6f;
 
-	CWorld::ProcessLineOfSight(point1, point2, foundCol, foundEnt, true, false, false, false, false, false, false);
+	CWorld::ProcessLineOfSight(source, target, foundCol, foundEnt, true, false, false, false, false, false, false);
 	if (foundEnt && foundEnt->IsBuilding()) {
 		// That was supposed to be Magnitude, according to leftover code in assembly
-		float diff = (foundCol.point.z - point1.z);
+		float diff = (foundCol.point.z - source.z);
 		if (diff < 0.0f && diff > -3.0f)
 			return true;
 	}
@@ -90,6 +2209,36 @@ CWeapon::HitsGround(CEntity *holder, CVector *firePos, CEntity *aimingTo)
 	return false;
 }
 
+void
+CWeapon::BlowUpExplosiveThings(CEntity *thing)
+{
+	if ( thing )
+	{
+		CObject *object = (CObject*)thing;
+		int32 mi = object->GetModelIndex();
+		if ( IsExplosiveThingModel(mi) && !object->bHasBeenDamaged )
+		{
+			object->bHasBeenDamaged = true;
+
+			CExplosion::AddExplosion(object, FindPlayerPed(), EXPLOSION_BARREL, object->GetPosition()+CVector(0.0f,0.0f,0.5f), 100);
+
+			if ( MI_EXPLODINGBARREL == mi )
+				object->m_vecMoveSpeed.z += 0.75f;
+			else
+				object->m_vecMoveSpeed.z += 0.45f;
+
+			object->m_vecMoveSpeed.x += float((CGeneral::GetRandomNumber()&255) - 128) * 0.0002f;
+			object->m_vecMoveSpeed.y += float((CGeneral::GetRandomNumber()&255) - 128) * 0.0002f;
+
+			if ( object->bIsStatic )
+			{
+				object->bIsStatic = false;
+				object->AddToMovingList();
+			}
+		}
+	}
+}
+
 bool
 CWeapon::HasWeaponAmmoToBeUsed(void)
 {
@@ -102,8 +2251,42 @@ CWeapon::HasWeaponAmmoToBeUsed(void)
 	}
 }
 
+bool
+CWeapon::ProcessLineOfSight(CVector const &point1, CVector const &point2, CColPoint &point, CEntity *&entity, eWeaponType type, CEntity *shooter, bool checkBuildings, bool checkVehicles, bool checkPeds, bool checkObjects, bool checkDummies, bool ignoreSeeThrough, bool ignoreSomeObjects)
+{
+	return CWorld::ProcessLineOfSight(point1, point2, point, entity, checkBuildings, checkVehicles, checkPeds, checkObjects, checkDummies, ignoreSeeThrough, ignoreSomeObjects);
+}
+
 STARTPATCHES
+
+	InjectHook(0x55C2D0, CWeapon::InitialiseWeapons, PATCH_JUMP);
+	InjectHook(0x55C2F0, CWeapon::ShutdownWeapons, PATCH_JUMP);
+	InjectHook(0x55C310, CWeapon::UpdateWeapons, PATCH_JUMP);
 	InjectHook(0x55C330, &CWeapon::Initialise, PATCH_JUMP);
+	InjectHook(0x55C380, &CWeapon::Fire, PATCH_JUMP);
+	InjectHook(0x55C940, &CWeapon::FireFromCar, PATCH_JUMP);
+	InjectHook(0x55CA20, &CWeapon::FireMelee, PATCH_JUMP);
+	InjectHook(0x55D2E0, &CWeapon::FireInstantHit, PATCH_JUMP);
+	InjectHook(0x55F770, &CWeapon::AddGunshell, PATCH_JUMP);
+	InjectHook(0x55F950, &CWeapon::DoBulletImpact, PATCH_JUMP);
+	InjectHook(0x560620, &CWeapon::FireShotgun, PATCH_JUMP);
+	InjectHook(0x561900, &CWeapon::FireProjectile, PATCH_JUMP);
+	InjectHook(0x561C70, CWeapon::GenerateFlameThrowerParticles, PATCH_JUMP);
+	InjectHook(0x561E00, &CWeapon::FireAreaEffect, PATCH_JUMP);
+	InjectHook(0x561FE0, &CWeapon::FireSniper, PATCH_JUMP);
+	InjectHook(0x562180, &CWeapon::FireM16_1stPerson, PATCH_JUMP);
+	InjectHook(0x5624D0, &CWeapon::FireInstantHitFromCar, PATCH_JUMP);
+	InjectHook(0x562EB0, CWeapon::DoDoomAiming, PATCH_JUMP);
+	InjectHook(0x563200, CWeapon::DoTankDoomAiming, PATCH_JUMP);
+	InjectHook(0x563660, CWeapon::DoDriveByAutoAiming, PATCH_JUMP);
 	InjectHook(0x5639D0, &CWeapon::Reload, PATCH_JUMP);
+	InjectHook(0x563A10, &CWeapon::Update, PATCH_JUMP);
+	InjectHook(0x563FB0, &CWeapon::IsTypeMelee, PATCH_JUMP);
+	InjectHook(0x563FD0, &CWeapon::IsType2Handed, PATCH_JUMP);
+	InjectHook(0x564680, CWeapon::MakePedsJumpAtShot, PATCH_JUMP);
 	InjectHook(0x564890, &CWeapon::HitsGround, PATCH_JUMP);
+	InjectHook(0x564A60, CWeapon::BlowUpExplosiveThings, PATCH_JUMP);
+	InjectHook(0x564B80, &CWeapon::HasWeaponAmmoToBeUsed, PATCH_JUMP);
+	InjectHook(0x564C00, CWeapon::ProcessLineOfSight, PATCH_JUMP);
+
 ENDPATCHES
diff --git a/src/weapons/Weapon.h b/src/weapons/Weapon.h
index 84760550..265ffddb 100644
--- a/src/weapons/Weapon.h
+++ b/src/weapons/Weapon.h
@@ -1,5 +1,8 @@
 #pragma once
 
+#define DRIVEBYAUTOAIMING_MAXDIST (2.5f)
+#define DOOMAUTOAIMING_MAXDIST    (9000.0f)
+
 enum eWeaponType
 {
 	WEAPONTYPE_UNARMED,
@@ -49,7 +52,10 @@ enum eWeaponState
 };
 
 class CEntity;
+class CPhysical;
 class CAutomobile;
+struct CColPoint;
+class CWeaponInfo;
 
 class CWeapon
 {
@@ -64,22 +70,50 @@ public:
 	CWeapon() {
 		m_bAddRotOffset = false;
 	}
+	
+	CWeaponInfo *GetInfo();
 
-	static void ShutdownWeapons(void);
-	void Initialise(eWeaponType type, int ammo);
-	void Update(int32 audioEntity);
+	static void InitialiseWeapons(void);
+	static void ShutdownWeapons  (void);
+	static void UpdateWeapons    (void);
+	
+	void Initialise(eWeaponType type, int32 ammo);
+	
+	bool Fire          (CEntity *shooter, CVector *fireSource);
+	bool FireFromCar   (CAutomobile *shooter, bool left);
+	bool FireMelee     (CEntity *shooter, CVector &fireSource);
+	bool FireInstantHit(CEntity *shooter, CVector *fireSource);
+	
+	void AddGunshell   (CEntity *shooter, CVector const &source, CVector2D const &direction, float size);
+	void DoBulletImpact(CEntity *shooter, CEntity *victim, CVector *source, CVector *target, CColPoint *point, CVector2D ahead);
+	
+	bool FireShotgun   (CEntity *shooter, CVector *fireSource);
+	bool FireProjectile(CEntity *shooter, CVector *fireSource, float power);
+	
+	static void GenerateFlameThrowerParticles(CVector pos, CVector dir);
+	
+	bool FireAreaEffect       (CEntity *shooter, CVector *fireSource);
+	bool FireSniper           (CEntity *shooter);
+	bool FireM16_1stPerson    (CEntity *shooter);
+	bool FireInstantHitFromCar(CAutomobile *shooter, bool left);
+	
+	static void DoDoomAiming       (CEntity *shooter, CVector *source, CVector *target);
+	static void DoTankDoomAiming   (CEntity *shooter, CEntity *driver, CVector *source, CVector *target);
+	static void DoDriveByAutoAiming(CEntity *shooter, CVector *source, CVector *target);
+	
 	void Reload(void);
-	bool Fire(CEntity*, CVector*);
-	void FireFromCar(CAutomobile *car, bool left);
-	void AddGunshell(CEntity*, CVector const&, CVector2D const&, float);
-	bool IsTypeMelee(void);
+	void Update(int32 audioEntity);
+	bool IsTypeMelee  (void);
 	bool IsType2Handed(void);
-	static void DoTankDoomAiming(CEntity *playerVehicle, CEntity *playerPed, CVector *start, CVector *end);
-	bool HitsGround(CEntity* holder, CVector* firePos, CEntity* aimingTo);
+	
+	static void MakePedsJumpAtShot(CPhysical *shooter, CVector *source, CVector *target);
+	
+	bool HitsGround(CEntity *holder, CVector *fireSource, CEntity *aimingTo);
+	static void BlowUpExplosiveThings(CEntity *thing);
 	bool HasWeaponAmmoToBeUsed(void);
-	static void InitialiseWeapons(void);
-	static void UpdateWeapons(void);
+	
+	static bool ProcessLineOfSight(CVector const &point1, CVector const &point2, CColPoint &point, CEntity *&entity, eWeaponType type, CEntity *shooter, bool checkBuildings, bool checkVehicles, bool checkPeds, bool checkObjects, bool checkDummies, bool ignoreSeeThrough, bool ignoreSomeObjects);
 };
-static_assert(sizeof(CWeapon) == 0x18, "CWeapon: error");
+VALIDATE_SIZE(CWeapon, 0x18);
 
-void FireOneInstantHitRound(CVector* shotSource, CVector* shotTarget, int32 damage);
-\ No newline at end of file
+void FireOneInstantHitRound(CVector *source, CVector *target, int32 damage);
+\ No newline at end of file
diff --git a/src/render/WeaponEffects.cpp b/src/weapons/WeaponEffects.cpp
index 2ed9e662..2ed9e662 100644
--- a/src/render/WeaponEffects.cpp
+++ b/src/weapons/WeaponEffects.cpp
diff --git a/src/render/WeaponEffects.h b/src/weapons/WeaponEffects.h
index 31c5a309..31c5a309 100644
--- a/src/render/WeaponEffects.h
+++ b/src/weapons/WeaponEffects.h
author	saml1er <danishroar@gmail.com>	2020-04-16 21:01:53 +0200
committer	saml1er <danishroar@gmail.com>	2020-04-16 21:01:53 +0200
commit	e52a02fb9e1dd5602e80d88691f2ee2291d1fa52 (patch)
tree	333caa1599e2f0c6b91bdae2092cf085eaf8238a /src
parent	Reverse CWorld (diff)
parent	More refs removed (diff)
download	re3-e52a02fb9e1dd5602e80d88691f2ee2291d1fa52.tar re3-e52a02fb9e1dd5602e80d88691f2ee2291d1fa52.tar.gz re3-e52a02fb9e1dd5602e80d88691f2ee2291d1fa52.tar.bz2 re3-e52a02fb9e1dd5602e80d88691f2ee2291d1fa52.tar.lz re3-e52a02fb9e1dd5602e80d88691f2ee2291d1fa52.tar.xz re3-e52a02fb9e1dd5602e80d88691f2ee2291d1fa52.tar.zst re3-e52a02fb9e1dd5602e80d88691f2ee2291d1fa52.zip