18 files changed, 2874 insertions, 328 deletions

diff --git a/src/core/Camera.cpp b/src/core/Camera.cpp
index 20c2ebd0..3ab7d742 100644
--- a/src/core/Camera.cpp
+++ b/src/core/Camera.cpp
@@ -102,8 +102,8 @@ CCamera::IsBoxVisible(RwV3d *box, const CMatrix *mat)
 int
 CCamera::GetLookDirection(void)
 {
-	if(Cams[ActiveCam].Mode == CCam::MODE_CAMONASTRING ||
-	   Cams[ActiveCam].Mode == CCam::MODE_FIRSTPERSON ||
+	if(Cams[ActiveCam].Mode == CCam::MODE_CAM_ON_A_STRING ||
+	   Cams[ActiveCam].Mode == CCam::MODE_1STPERSON ||
 	   Cams[ActiveCam].Mode == CCam::MODE_BEHINDBOAT ||
 	   Cams[ActiveCam].Mode == CCam::MODE_FOLLOWPED)
 		return Cams[ActiveCam].DirectionWasLooking;
@@ -113,7 +113,7 @@ CCamera::GetLookDirection(void)
 bool
 CCamera::GetLookingForwardFirstPerson()
 {
-	return Cams[ActiveCam].Mode == CCam::MODE_FIRSTPERSON &&
+	return Cams[ActiveCam].Mode == CCam::MODE_1STPERSON &&
 		Cams[ActiveCam].DirectionWasLooking == LOOKING_FORWARD;
 }
 
@@ -1145,7 +1145,7 @@ CCam::FixCamIfObscured(CVector &TargetCoors, float TargetHeight, float TargetOri
 
 	if(Mode == MODE_BEHINDCAR)
 		Target.z += TargetHeight/2.0f;
-	if(Mode == MODE_CAMONASTRING){
+	if(Mode == MODE_CAM_ON_A_STRING){
 		UseEntityPos = true;
 		Target.z += TargetHeight/2.0f;
 		EntityPos = CamTargetEntity->GetPosition();
@@ -1306,7 +1306,7 @@ CCam::Using3rdPersonMouseCam()
 		(Mode == MODE_FOLLOWPED ||
 			TheCamera.m_bPlayerIsInGarage &&
 			FindPlayerPed() && FindPlayerPed()->m_nPedState != PED_DRIVING &&
-			Mode != MODE_TOPDOWN1 && this->CamTargetEntity == FindPlayerPed());
+			Mode != MODE_TOPDOWN && this->CamTargetEntity == FindPlayerPed());
 }
 
 bool
diff --git a/src/core/Camera.h b/src/core/Camera.h
index e2717934..46c25436 100644
--- a/src/core/Camera.h
+++ b/src/core/Camera.h
@@ -11,14 +11,15 @@ struct CCam
 {
 	enum
 	{
-		MODE_TOPDOWN1 = 1,
-		MODE_TOPDOWN2,
+		MODE_NONE = 0,
+		MODE_TOPDOWN,
+		MODE_GTACLASSIC,
 		MODE_BEHINDCAR,
 		MODE_FOLLOWPED,
 		MODE_AIMING,
 		MODE_DEBUG,
 		MODE_SNIPER,
-		MODE_ROCKET,
+		MODE_ROCKETLAUNCHER,
 		MODE_MODELVIEW,
 		MODE_BILL,
 		MODE_SYPHON,
@@ -26,35 +27,35 @@ struct CCam
 		MODE_CHEESYZOOM,
 		MODE_WHEELCAM,
 		MODE_FIXED,
-		MODE_FIRSTPERSON,
+		MODE_1STPERSON,
 		MODE_FLYBY,
-		MODE_CAMONASTRING,
-		MODE_REACTIONCAM,
-		MODE_FOLLOWPEDWITHBINDING,
-		MODE_CHRISWITHBINDINGPLUSROTATION,
+		MODE_CAM_ON_A_STRING,
+		MODE_REACTION,
+		MODE_FOLLOW_PED_WITH_BIND,
+		MODE_CHRIS,
 		MODE_BEHINDBOAT,
-		MODE_PLAYERFALLENWATER,
-		MODE_CAMONTRAINROOF,
-		MODE_CAMRUNNINGSIDETRAIN,
-		MODE_BLOODONTHETRACKS,
-		MODE_IMTHEPASSENGERWOOWOO,
-		MODE_SYPHONCRIMINFRONT,
-		MODE_PEDSDEADBABY,
-		MODE_CUSHYPILLOWSARSE,
-		MODE_LOOKATCARS,
-		MODE_ARRESTCAMONE,
-		MODE_ARRESTCAMTWO,
-		MODE_M16FIRSTPERSON_34,
-		MODE_SPECIALFIXEDFORSYPHON,
-		MODE_FIGHT,
-		MODE_TOPDOWNPED,
-		MODE_SNIPER_RUN_AROUND,
-		MODE_ROCKET_RUN_AROUND,
-		MODE_FIRSTPERSONPEDONPC_40,
-		MODE_FIRSTPERSONPEDONPC_41,
-		MODE_FIRSTPERSONPEDONPC_42,
+		MODE_PLAYER_FALLEN_WATER,
+		MODE_CAM_ON_TRAIN_ROOF,
+		MODE_CAM_RUNNING_SIDE_TRAIN,
+		MODE_BLOOD_ON_THE_TRACKS,
+		MODE_IM_THE_PASSENGER_WOOWOO,
+		MODE_SYPHON_CRIM_IN_FRONT,
+		MODE_PED_DEAD_BABY,
+		MODE_PILLOWS_PAPS,
+		MODE_LOOK_AT_CARS,
+		MODE_ARRESTCAM_ONE,
+		MODE_ARRESTCAM_TWO,
+		MODE_M16_1STPERSON,
+		MODE_SPECIAL_FIXED_FOR_SYPHON,
+		MODE_FIGHT_CAM,
+		MODE_TOP_DOWN_PED,
+		MODE_SNIPER_RUNABOUT,
+		MODE_ROCKETLAUNCHER_RUNABOUT,
+		MODE_1STPERSON_RUNABOUT,
+		MODE_M16_1STPERSON_RUNABOUT,
+		MODE_FIGHT_CAM_RUNABOUT,
 		MODE_EDITOR,
-		MODE_M16FIRSTPERSON_44
+		MODE_HELICANNON_1STPERSON, // vice city leftover
 	};
 
 	bool    bBelowMinDist; //used for follow ped mode
diff --git a/src/core/ControllerConfig.cpp b/src/core/ControllerConfig.cpp
index 6eef4d3d..d32b8283 100644
--- a/src/core/ControllerConfig.cpp
+++ b/src/core/ControllerConfig.cpp
@@ -1,51 +1,93 @@
-	#define DIRECTINPUT_VERSION 0x0800
-	#include <dinput.h>
+#define DIRECTINPUT_VERSION 0x0800
+#include <dinput.h>
 #include "common.h"
 #include "patcher.h"
 #include "ControllerConfig.h"
 #include "Pad.h"
 #include "FileMgr.h"
+#include "Text.h"
+#include "Font.h"
+#include "Messages.h"
+#include "Frontend.h"
+#include "Ped.h"
+#include "PlayerPed.h"
+#include "Vehicle.h"
+#include "World.h"
+#include "ModelIndices.h"
+#include "Camera.h"
+#include "win.h"
 
 CControllerConfigManager &ControlsManager = *(CControllerConfigManager*)0x8F43A4;
 
-WRAPPER void CControllerConfigManager::UpdateJoyButtonState(int padnumber) { EAXJMP(0x58F5B0); }
-WRAPPER void CControllerConfigManager::UpdateJoyInConfigMenus_ButtonDown(int button, int padnumber) { EAXJMP(0x58C5E0); }
-WRAPPER void CControllerConfigManager::AffectControllerStateOn_ButtonDown(int button, eControllerType type) { EAXJMP(0x58C730); }
-WRAPPER void CControllerConfigManager::UpdateJoyInConfigMenus_ButtonUp(int button, int padnumber) { EAXJMP(0x58CE80); }
-WRAPPER void CControllerConfigManager::AffectControllerStateOn_ButtonUp(int button, int padnumber) { EAXJMP(0x58CFD0); }
-WRAPPER void CControllerConfigManager::MakeControllerActionsBlank() { EAXJMP(0x58B7A0); }
-WRAPPER void CControllerConfigManager::InitDefaultControlConfiguration() { EAXJMP(0x58B930); }
-WRAPPER void CControllerConfigManager::InitDefaultControlConfigMouse(CMouseControllerState const &mousestate) { EAXJMP(0x58BD00); }
-WRAPPER int32 CControllerConfigManager::GetJoyButtonJustDown() { EAXJMP(0x58B7D0); }
-WRAPPER void CControllerConfigManager::InitDefaultControlConfigJoyPad(unsigned int buttons) { EAXJMP(0x58BD90); }
-WRAPPER void CControllerConfigManager::ClearSimButtonPressCheckers() { EAXJMP(0x58D220); }
-WRAPPER void CControllerConfigManager::AffectPadFromKeyBoard() { EAXJMP(0x58D0C0); }
-WRAPPER void CControllerConfigManager::AffectPadFromMouse() { EAXJMP(0x58D1A0); }
-WRAPPER void CControllerConfigManager::ClearSettingsAssociatedWithAction(int, int) { EAXJMP(0x58EB40); }
-WRAPPER void CControllerConfigManager::GetWideStringOfCommandKeys(uint16, wchar*, uint16) { EAXJMP(0x58F460); }
+CControllerConfigManager::CControllerConfigManager()
+{
+	m_bFirstCapture    = false;
+	m_bMouseAssociated = false;
+
+	MakeControllerActionsBlank();
+	InitDefaultControlConfiguration();
+	InitialiseControllerActionNameArray();
+}
+
+void CControllerConfigManager::MakeControllerActionsBlank()
+{
+	for (int32 i = 0; i < MAX_CONTROLLERTYPES; i++)
+	{
+		for (int32 j = 0; j < MAX_CONTROLLERACTIONS; j++)
+		{
+			ClearSettingsAssociatedWithAction((e_ControllerAction)j, (eControllerType)i);
+		}
+	}
+}
+
+int32 CControllerConfigManager::GetJoyButtonJustDown()
+{
+#ifdef __DINPUT_INCLUDED__
+	for (int32 i = 0; i < JOY_BUTTONS; i++)
+	{
+		if (m_NewState.rgbButtons[i] & 0x80 && !(m_OldState.rgbButtons[i] & 0x80))
+			return i + 1;
+	}
+#endif
+	return 0;
+}
+
+void CControllerConfigManager::SaveSettings(int32 file)
+{
+	if (file)
+	{
+		for (int32 i = 0; i < MAX_CONTROLLERTYPES; i++)
+		{
+			for (int32 j = 0; j < MAX_CONTROLLERACTIONS; j++)
+			{
+				CFileMgr::Write(file, (char *)&ControlsManager.m_aSettings[j][i], sizeof(tControllerConfigBind));
+			}
+		}
+	}
+}
 
 void CControllerConfigManager::LoadSettings(int32 file)
 {
 	bool bValid = true;
-	
-	if ( file )
+
+	if (file)
 	{
 		char buff[29];
 		CFileMgr::Read(file, buff, sizeof(buff));
-		
-		if ( !strncmp(buff, "THIS FILE IS NOT VALID YET", sizeof(buff) - 3) )
+
+		if (!strcmp(buff, "THIS FILE IS NOT VALID YET"))
 			bValid = false;
 		else
 			CFileMgr::Seek(file, 0, 0);
 	}
-	
-	if ( bValid )
+
+	if (bValid)
 	{
 		ControlsManager.MakeControllerActionsBlank();
-		
-		for ( int i = 0; i < 4; i++ )
+
+		for (int32 i = 0; i < MAX_CONTROLLERTYPES; i++)
 		{
-			for ( int j = 0; j < 41; j++ )
+			for (int32 j = 0; j < MAX_CONTROLLERACTIONS; j++)
 			{
 				CFileMgr::Read(file, (char *)&ControlsManager.m_aSettings[j][i], sizeof(tControllerConfigBind));
 			}
@@ -53,7 +95,2387 @@ void CControllerConfigManager::LoadSettings(int32 file)
 	}
 }
 
-WRAPPER void CControllerConfigManager::SaveSettings(int32 file)
+void CControllerConfigManager::InitDefaultControlConfiguration()
+{
+	SetControllerKeyAssociatedWithAction    (VEHICLE_LOOKLEFT,                    rsPADEND,   KEYBOARD);
+	SetControllerKeyAssociatedWithAction    (VEHICLE_LOOKLEFT,                    'Q',        OPTIONAL_EXTRA);
+										    						              
+	SetControllerKeyAssociatedWithAction    (VEHICLE_LOOKRIGHT,                   rsPADDOWN,  KEYBOARD);
+	SetControllerKeyAssociatedWithAction    (VEHICLE_LOOKRIGHT,                   'E',        OPTIONAL_EXTRA);
+																	              
+	if ( _dwOperatingSystemVersion != OS_WIN98 )						              
+	{																              
+		SetControllerKeyAssociatedWithAction(VEHICLE_HORN,                        rsLSHIFT,   OPTIONAL_EXTRA);
+		SetControllerKeyAssociatedWithAction(VEHICLE_HORN,                        rsRSHIFT,   KEYBOARD);
+	}																              
+	else															              
+		SetControllerKeyAssociatedWithAction(VEHICLE_HORN,                        rsSHIFT,    OPTIONAL_EXTRA);
+																	              
+	SetControllerKeyAssociatedWithAction    (VEHICLE_HANDBRAKE,                   rsRCTRL,    KEYBOARD);
+	SetControllerKeyAssociatedWithAction    (VEHICLE_HANDBRAKE,                   ' ',        OPTIONAL_EXTRA);
+															                      
+	SetControllerKeyAssociatedWithAction    (VEHICLE_ENTER_EXIT,                  rsENTER,    KEYBOARD);
+	SetControllerKeyAssociatedWithAction    (VEHICLE_ENTER_EXIT,                  'F',        OPTIONAL_EXTRA);
+										    					                  
+	SetControllerKeyAssociatedWithAction    (VEHICLE_ACCELERATE,                  rsUP,       KEYBOARD);
+	SetControllerKeyAssociatedWithAction    (VEHICLE_ACCELERATE,                  'W',        OPTIONAL_EXTRA);
+																		          
+	SetControllerKeyAssociatedWithAction    (VEHICLE_CHANGE_RADIO_STATION,        rsINS,      KEYBOARD);
+	SetControllerKeyAssociatedWithAction    (VEHICLE_CHANGE_RADIO_STATION,        'R',        OPTIONAL_EXTRA);
+																		          
+	SetControllerKeyAssociatedWithAction    (VEHICLE_BRAKE,                       rsDOWN,     KEYBOARD);
+	SetControllerKeyAssociatedWithAction    (VEHICLE_BRAKE,                       'S',        OPTIONAL_EXTRA);
+																		          
+	SetControllerKeyAssociatedWithAction    (TOGGLE_SUBMISSIONS,                  rsPLUS,     KEYBOARD);
+	SetControllerKeyAssociatedWithAction    (TOGGLE_SUBMISSIONS,                  rsCAPSLK,   OPTIONAL_EXTRA);
+																		          
+	SetControllerKeyAssociatedWithAction    (GO_LEFT,                             rsLEFT,     KEYBOARD);
+	SetControllerKeyAssociatedWithAction    (GO_LEFT,                             'A',        OPTIONAL_EXTRA);
+																		          
+	SetControllerKeyAssociatedWithAction    (GO_RIGHT,                            rsRIGHT,    KEYBOARD);
+	SetControllerKeyAssociatedWithAction    (GO_RIGHT,                            'D',        OPTIONAL_EXTRA);
+																		          
+	SetControllerKeyAssociatedWithAction    (GO_FORWARD,                          rsUP,       KEYBOARD);
+	SetControllerKeyAssociatedWithAction    (GO_FORWARD,                          'W',        OPTIONAL_EXTRA);
+																		          
+	SetControllerKeyAssociatedWithAction    (GO_BACK,                             rsDOWN,     KEYBOARD);
+	SetControllerKeyAssociatedWithAction    (GO_BACK,                             'S',        OPTIONAL_EXTRA);
+																		          
+	SetControllerKeyAssociatedWithAction    (PED_LOOKBEHIND,                      rsPADEND,   KEYBOARD);
+	SetControllerKeyAssociatedWithAction    (PED_LOOKBEHIND,                      rsCAPSLK,   OPTIONAL_EXTRA);
+																		          
+	SetControllerKeyAssociatedWithAction    (PED_FIREWEAPON,                      rsPADINS,   KEYBOARD);
+	SetControllerKeyAssociatedWithAction    (PED_FIREWEAPON,                      rsLCTRL,    OPTIONAL_EXTRA);
+																		          
+	SetControllerKeyAssociatedWithAction    (PED_CYCLE_WEAPON_LEFT,               rsPADDEL,   KEYBOARD);
+
+	SetControllerKeyAssociatedWithAction    (PED_CYCLE_WEAPON_RIGHT,              rsPADENTER, OPTIONAL_EXTRA); // BUG: must be KEYBOARD ?
+																		          
+	SetControllerKeyAssociatedWithAction    (PED_LOCK_TARGET,                     rsDEL,      KEYBOARD);
+																		          
+	SetControllerKeyAssociatedWithAction    (PED_JUMPING,                         rsRCTRL,    KEYBOARD);
+	SetControllerKeyAssociatedWithAction    (PED_JUMPING,                         ' ',        OPTIONAL_EXTRA);
+																		          
+	if ( _dwOperatingSystemVersion != OS_WIN98 )							          
+	{																	          
+		SetControllerKeyAssociatedWithAction(PED_SPRINT,                          rsLSHIFT,   OPTIONAL_EXTRA);
+#ifndef FIX_BUGS
+		SetControllerKeyAssociatedWithAction(PED_SPRINT,                          rsRSHIFT,   OPTIONAL_EXTRA); // BUG: must be KEYBOARD
+#else
+		SetControllerKeyAssociatedWithAction(PED_SPRINT,                          rsRSHIFT,   KEYBOARD); // BUG: must be KEYBOARD ?
+#endif
+	}																	          
+	else																          
+		SetControllerKeyAssociatedWithAction(PED_SPRINT,                          rsSHIFT,    OPTIONAL_EXTRA);
+																		          
+	SetControllerKeyAssociatedWithAction    (PED_CYCLE_TARGET_LEFT,               '[',        KEYBOARD);
+
+	SetControllerKeyAssociatedWithAction    (PED_CYCLE_TARGET_RIGHT,              ']',        OPTIONAL_EXTRA); // BUG: must be KEYBOARD ?
+																			      
+	SetControllerKeyAssociatedWithAction    (PED_CENTER_CAMERA_BEHIND_PLAYER,     '#',        KEYBOARD);
+	
+	SetControllerKeyAssociatedWithAction    (PED_SNIPER_ZOOM_IN,                  rsPGUP,     KEYBOARD);
+	SetControllerKeyAssociatedWithAction    (PED_SNIPER_ZOOM_IN,                  'Z',        OPTIONAL_EXTRA);
+										    
+	SetControllerKeyAssociatedWithAction    (PED_SNIPER_ZOOM_OUT,                 rsPGDN,     KEYBOARD);
+	SetControllerKeyAssociatedWithAction    (PED_SNIPER_ZOOM_OUT,                 'X',        OPTIONAL_EXTRA);
+										    
+	SetControllerKeyAssociatedWithAction    (PED_1RST_PERSON_LOOK_LEFT,           rsPADLEFT,  KEYBOARD);
+
+	SetControllerKeyAssociatedWithAction    (PED_1RST_PERSON_LOOK_RIGHT,          rsPADRIGHT, KEYBOARD);
+										    
+	SetControllerKeyAssociatedWithAction    (PED_1RST_PERSON_LOOK_UP,             rsPADUP,    KEYBOARD);
+
+	SetControllerKeyAssociatedWithAction    (PED_1RST_PERSON_LOOK_DOWN,           rsPAD5,     KEYBOARD);
+										    
+	SetControllerKeyAssociatedWithAction    (VEHICLE_TURRETLEFT,                  rsPADLEFT,  KEYBOARD);
+
+	SetControllerKeyAssociatedWithAction    (VEHICLE_TURRETRIGHT,                 rsPAD5,     KEYBOARD);
+										    
+	SetControllerKeyAssociatedWithAction    (VEHICLE_TURRETUP,                    rsPADPGUP,  KEYBOARD);
+
+	SetControllerKeyAssociatedWithAction    (VEHICLE_TURRETDOWN,                  rsPADRIGHT, KEYBOARD);
+										    
+	SetControllerKeyAssociatedWithAction    (CAMERA_CHANGE_VIEW_ALL_SITUATIONS,   rsHOME,     KEYBOARD);
+	SetControllerKeyAssociatedWithAction    (CAMERA_CHANGE_VIEW_ALL_SITUATIONS,   'C',        OPTIONAL_EXTRA);
+
+	for (int32 i = 0; i < MAX_SIMS; i++)
+	{
+		m_aSimCheckers[i][KEYBOARD]       = false;
+		m_aSimCheckers[i][OPTIONAL_EXTRA] = false;
+		m_aSimCheckers[i][MOUSE]          = false;
+		m_aSimCheckers[i][JOYSTICK]       = false;
+	}
+}
+
+void CControllerConfigManager::InitDefaultControlConfigMouse(CMouseControllerState const &availableButtons)
 {
-	EAXJMP(0x58B800);
+	if (availableButtons.LMB)
+	{
+		m_bMouseAssociated = true;
+		SetMouseButtonAssociatedWithAction(PED_FIREWEAPON,               1);
+	}
+
+	if (availableButtons.RMB)
+	{
+		SetMouseButtonAssociatedWithAction(PED_LOCK_TARGET,              3);
+
+		SetMouseButtonAssociatedWithAction(VEHICLE_HANDBRAKE,            3);
+	}
+
+	if (availableButtons.MMB)
+	{
+		SetMouseButtonAssociatedWithAction(VEHICLE_LOOKBEHIND,           2);
+
+		SetMouseButtonAssociatedWithAction(PED_LOOKBEHIND,               2);
+	}
+
+	if (availableButtons.WHEELUP || availableButtons.WHEELDN)
+	{
+		SetMouseButtonAssociatedWithAction(PED_CYCLE_WEAPON_LEFT,        4);
+
+		SetMouseButtonAssociatedWithAction(PED_CYCLE_WEAPON_RIGHT,       5);
+
+		SetMouseButtonAssociatedWithAction(VEHICLE_CHANGE_RADIO_STATION, 4);
+	}
 }
+
+void CControllerConfigManager::InitDefaultControlConfigJoyPad(uint32 buttons)
+{
+	m_bFirstCapture = true;
+
+	uint32 btn = buttons;
+	if (buttons > 16)
+		btn = 16;
+
+	if (   AllValidWinJoys.m_aJoys[JOYSTICK1].m_nVendorID == 0x3427
+		&& AllValidWinJoys.m_aJoys[JOYSTICK1].m_nProductID == 0x1190)
+	{
+		//GIC USB Joystick, PS2 Gamepad ?
+
+		switch (btn)
+		{
+		case 16:
+			SetControllerKeyAssociatedWithAction(GO_LEFT,                           16, JOYSTICK);
+		case 15:											                        
+			SetControllerKeyAssociatedWithAction(GO_BACK,                           15, JOYSTICK);
+		case 14:											                        
+			SetControllerKeyAssociatedWithAction(GO_RIGHT,                          14, JOYSTICK);
+		case 13:											                        
+			SetControllerKeyAssociatedWithAction(GO_FORWARD,                        13, JOYSTICK);
+		case 12:													                
+		case 11:													                
+			SetControllerKeyAssociatedWithAction(PED_LOOKBEHIND,                    11, JOYSTICK);
+			SetControllerKeyAssociatedWithAction(TOGGLE_SUBMISSIONS,                11, JOYSTICK);
+		case 10:
+			SetControllerKeyAssociatedWithAction(VEHICLE_HORN,                      10, JOYSTICK);
+		case 9:
+			SetControllerKeyAssociatedWithAction(CAMERA_CHANGE_VIEW_ALL_SITUATIONS,  9, JOYSTICK);
+		case 8:
+			SetControllerKeyAssociatedWithAction(VEHICLE_HANDBRAKE,                  8, JOYSTICK);
+			SetControllerKeyAssociatedWithAction(PED_LOCK_TARGET,                    8, JOYSTICK);
+		case 7:
+			SetControllerKeyAssociatedWithAction(PED_CENTER_CAMERA_BEHIND_PLAYER,    7, JOYSTICK);
+			SetControllerKeyAssociatedWithAction(VEHICLE_CHANGE_RADIO_STATION,       7, JOYSTICK);
+		case 6:
+			SetControllerKeyAssociatedWithAction(PED_CYCLE_WEAPON_RIGHT,             6, JOYSTICK);
+			SetControllerKeyAssociatedWithAction(VEHICLE_LOOKRIGHT,                  6, JOYSTICK);
+		case 5:
+			SetControllerKeyAssociatedWithAction(PED_CYCLE_WEAPON_LEFT,              5, JOYSTICK);
+			SetControllerKeyAssociatedWithAction(VEHICLE_LOOKLEFT,                   5, JOYSTICK);
+		/*******************************************************************************************/
+		case 4:
+			SetControllerKeyAssociatedWithAction(VEHICLE_BRAKE,                      4, JOYSTICK);
+			SetControllerKeyAssociatedWithAction(PED_JUMPING,                        4, JOYSTICK);
+			SetControllerKeyAssociatedWithAction(PED_SNIPER_ZOOM_IN,                 4, JOYSTICK);
+		case 3:
+			SetControllerKeyAssociatedWithAction(VEHICLE_ACCELERATE,                 3, JOYSTICK);
+			SetControllerKeyAssociatedWithAction(PED_SPRINT,                         3, JOYSTICK);
+			SetControllerKeyAssociatedWithAction(PED_SNIPER_ZOOM_OUT,                3, JOYSTICK);
+		case 2:
+			SetControllerKeyAssociatedWithAction(PED_FIREWEAPON,                     2, JOYSTICK);
+		case 1:
+			SetControllerKeyAssociatedWithAction(VEHICLE_ENTER_EXIT,                 1, JOYSTICK);
+		/*******************************************************************************************/
+		}
+	}
+	else
+	{
+		switch (btn)
+		{
+		case 16:
+			SetControllerKeyAssociatedWithAction(GO_LEFT,                           16, JOYSTICK);
+		case 15:
+			SetControllerKeyAssociatedWithAction(GO_BACK,                           15, JOYSTICK);
+		case 14:
+			SetControllerKeyAssociatedWithAction(GO_RIGHT,                          14, JOYSTICK);
+		case 13:
+			SetControllerKeyAssociatedWithAction(GO_FORWARD,                        13, JOYSTICK);
+		case 12:
+		case 11:
+			SetControllerKeyAssociatedWithAction(PED_LOOKBEHIND,                    11, JOYSTICK);
+			SetControllerKeyAssociatedWithAction(TOGGLE_SUBMISSIONS,                11, JOYSTICK);
+		case 10:
+			SetControllerKeyAssociatedWithAction(VEHICLE_HORN,                      10, JOYSTICK);
+		case 9:
+			SetControllerKeyAssociatedWithAction(CAMERA_CHANGE_VIEW_ALL_SITUATIONS,  9, JOYSTICK);
+		case 8:
+			SetControllerKeyAssociatedWithAction(VEHICLE_HANDBRAKE,                  8, JOYSTICK);
+			SetControllerKeyAssociatedWithAction(PED_LOCK_TARGET,                    8, JOYSTICK);
+		case 7:
+			SetControllerKeyAssociatedWithAction(PED_CENTER_CAMERA_BEHIND_PLAYER,    7, JOYSTICK);
+			SetControllerKeyAssociatedWithAction(VEHICLE_CHANGE_RADIO_STATION,       7, JOYSTICK);
+		case 6:
+			SetControllerKeyAssociatedWithAction(PED_CYCLE_WEAPON_RIGHT,             6, JOYSTICK);
+			SetControllerKeyAssociatedWithAction(VEHICLE_LOOKRIGHT,                  6, JOYSTICK);
+		case 5:
+			SetControllerKeyAssociatedWithAction(PED_CYCLE_WEAPON_LEFT,              5, JOYSTICK);
+			SetControllerKeyAssociatedWithAction(VEHICLE_LOOKLEFT,                   5, JOYSTICK);
+		/*******************************************************************************************/
+		case 4:
+			SetControllerKeyAssociatedWithAction(VEHICLE_ENTER_EXIT,                 4, JOYSTICK);
+		case 3:
+			SetControllerKeyAssociatedWithAction(VEHICLE_BRAKE,                      3, JOYSTICK);
+			SetControllerKeyAssociatedWithAction(PED_JUMPING,                        3, JOYSTICK);
+			SetControllerKeyAssociatedWithAction(PED_SNIPER_ZOOM_IN,                 3, JOYSTICK);
+		case 2:
+			SetControllerKeyAssociatedWithAction(VEHICLE_ACCELERATE,                 2, JOYSTICK);
+			SetControllerKeyAssociatedWithAction(PED_SPRINT,                         2, JOYSTICK);
+			SetControllerKeyAssociatedWithAction(PED_SNIPER_ZOOM_OUT,                2, JOYSTICK);
+		case 1:
+			SetControllerKeyAssociatedWithAction(PED_FIREWEAPON,                     1, JOYSTICK);
+		/*******************************************************************************************/
+		}
+	}
+}
+
+void CControllerConfigManager::InitialiseControllerActionNameArray()
+{
+	wchar buff[40+2];
+
+	AsciiToUnicode("PED_LOOKBEHIND",                    buff);
+	CMessages::WideStringCopy(m_aActionNames[PED_LOOKBEHIND],                    buff, sizeof(m_aActionNames[PED_LOOKBEHIND]));
+																	             
+	AsciiToUnicode("PED_CYCLE_WEAPON_LEFT",             buff);					             
+	CMessages::WideStringCopy(m_aActionNames[PED_CYCLE_WEAPON_LEFT],             buff, sizeof(m_aActionNames[PED_CYCLE_WEAPON_LEFT]));
+																	             
+	AsciiToUnicode("PED_CYCLE_WEAPON_RIGHT",            buff);					             
+	CMessages::WideStringCopy(m_aActionNames[PED_CYCLE_WEAPON_RIGHT],            buff, sizeof(m_aActionNames[PED_CYCLE_WEAPON_RIGHT]));
+																	             
+	AsciiToUnicode("PED_LOCK_TARGET",                   buff);						             
+	CMessages::WideStringCopy(m_aActionNames[PED_LOCK_TARGET],                   buff, sizeof(m_aActionNames[PED_LOCK_TARGET]));
+																	             
+	AsciiToUnicode("PED_JUMPING",                       buff);							             
+	CMessages::WideStringCopy(m_aActionNames[PED_JUMPING],                       buff, sizeof(m_aActionNames[PED_JUMPING]));
+																	             
+	AsciiToUnicode("PED_SPRINT",                        buff);								             
+	CMessages::WideStringCopy(m_aActionNames[PED_SPRINT],                        buff, sizeof(m_aActionNames[PED_SPRINT]));
+																	             
+	AsciiToUnicode("PED_CYCLE_TARGET_LEFT",             buff);					             
+	CMessages::WideStringCopy(m_aActionNames[PED_CYCLE_TARGET_LEFT],             buff, sizeof(m_aActionNames[PED_CYCLE_TARGET_LEFT]));
+																	             
+	AsciiToUnicode("PED_CYCLE_TARGET_RIGHT",            buff);					             
+	CMessages::WideStringCopy(m_aActionNames[PED_CYCLE_TARGET_RIGHT],            buff, sizeof(m_aActionNames[PED_CYCLE_TARGET_RIGHT]));
+																			     
+	AsciiToUnicode("PED_CENTER_CAMERA_BEHIND_PLAYER",   buff);				     
+	CMessages::WideStringCopy(m_aActionNames[PED_CENTER_CAMERA_BEHIND_PLAYER],   buff, sizeof(m_aActionNames[PED_CENTER_CAMERA_BEHIND_PLAYER]));
+																			     
+	AsciiToUnicode("VEHICLE_LOOKBEHIND",                buff);								     
+	CMessages::WideStringCopy(m_aActionNames[VEHICLE_LOOKBEHIND],                buff, sizeof(m_aActionNames[VEHICLE_LOOKBEHIND]));
+																			     
+	AsciiToUnicode("VEHICLE_LOOKLEFT",                  buff);								     
+	CMessages::WideStringCopy(m_aActionNames[VEHICLE_LOOKLEFT],                  buff, sizeof(m_aActionNames[VEHICLE_LOOKLEFT]));
+																			     
+	AsciiToUnicode("VEHICLE_LOOKRIGHT",                 buff);								     
+	CMessages::WideStringCopy(m_aActionNames[VEHICLE_LOOKRIGHT],                 buff, sizeof(m_aActionNames[VEHICLE_LOOKRIGHT]));
+																			     
+	AsciiToUnicode("VEHICLE_HORN",                      buff);									     
+	CMessages::WideStringCopy(m_aActionNames[VEHICLE_HORN],                      buff, sizeof(m_aActionNames[VEHICLE_HORN]));
+																			     
+	AsciiToUnicode("VEHICLE_HANDBRAKE",                 buff);								     
+	CMessages::WideStringCopy(m_aActionNames[VEHICLE_HANDBRAKE],                 buff, sizeof(m_aActionNames[VEHICLE_HANDBRAKE]));
+																			     
+	AsciiToUnicode("VEHICLE_ACCELERATE",                buff);								     
+	CMessages::WideStringCopy(m_aActionNames[VEHICLE_ACCELERATE],                buff, sizeof(m_aActionNames[VEHICLE_ACCELERATE]));
+																			     
+	AsciiToUnicode("VEHICLE_BRAKE",                     buff);									     
+	CMessages::WideStringCopy(m_aActionNames[VEHICLE_BRAKE],                     buff, sizeof(m_aActionNames[VEHICLE_BRAKE]));
+																			     
+	AsciiToUnicode("VEHICLE_CHANGE_RADIO_STATION",      buff);					     
+	CMessages::WideStringCopy(m_aActionNames[VEHICLE_CHANGE_RADIO_STATION],      buff, sizeof(m_aActionNames[VEHICLE_CHANGE_RADIO_STATION]));
+																			     
+	AsciiToUnicode("TOGGLE_SUBMISSIONS",                buff);								     
+	CMessages::WideStringCopy(m_aActionNames[TOGGLE_SUBMISSIONS],                buff, sizeof(m_aActionNames[TOGGLE_SUBMISSIONS]));
+																			     
+	AsciiToUnicode("PED_SNIPER_ZOOM_IN",                buff);								     
+	CMessages::WideStringCopy(m_aActionNames[PED_SNIPER_ZOOM_IN],                buff, sizeof(m_aActionNames[PED_SNIPER_ZOOM_IN]));
+																			     
+	AsciiToUnicode("PED_SNIPER_ZOOM_OUT",               buff);							     
+	CMessages::WideStringCopy(m_aActionNames[PED_SNIPER_ZOOM_OUT],               buff, sizeof(m_aActionNames[PED_SNIPER_ZOOM_OUT]));
+																			     
+	AsciiToUnicode("PED_1RST_PERSON_LOOK_LEFT",         buff);						     
+	CMessages::WideStringCopy(m_aActionNames[PED_1RST_PERSON_LOOK_LEFT],         buff, sizeof(m_aActionNames[PED_1RST_PERSON_LOOK_LEFT]));
+																			     
+	AsciiToUnicode("PED_1RST_PERSON_LOOK_RIGHT",        buff);						     
+	CMessages::WideStringCopy(m_aActionNames[PED_1RST_PERSON_LOOK_RIGHT],        buff, sizeof(m_aActionNames[PED_1RST_PERSON_LOOK_RIGHT]));
+																			     
+	AsciiToUnicode("PED_1RST_PERSON_LOOK_UP",           buff);						     
+	CMessages::WideStringCopy(m_aActionNames[PED_1RST_PERSON_LOOK_UP],           buff, sizeof(m_aActionNames[PED_1RST_PERSON_LOOK_UP]));
+																			     
+	AsciiToUnicode("PED_1RST_PERSON_LOOK_DOWN",         buff);						     
+	CMessages::WideStringCopy(m_aActionNames[PED_1RST_PERSON_LOOK_DOWN],         buff, sizeof(m_aActionNames[PED_1RST_PERSON_LOOK_DOWN]));
+																			     
+	AsciiToUnicode("SHOW_MOUSE_POINTER_TOGGLE",         buff);						     
+	CMessages::WideStringCopy(m_aActionNames[SHOW_MOUSE_POINTER_TOGGLE],         buff, sizeof(m_aActionNames[SHOW_MOUSE_POINTER_TOGGLE]));
+
+	AsciiToUnicode("CAMERA_CHANGE_VIEW_ALL_SITUATIONS", buff);
+	CMessages::WideStringCopy(m_aActionNames[CAMERA_CHANGE_VIEW_ALL_SITUATIONS], buff, sizeof(m_aActionNames[CAMERA_CHANGE_VIEW_ALL_SITUATIONS]));
+
+	AsciiToUnicode("PED_FIREWEAPON",                    buff);
+	CMessages::WideStringCopy(m_aActionNames[PED_FIREWEAPON],                    buff, sizeof(m_aActionNames[PED_FIREWEAPON]));
+
+	AsciiToUnicode("VEHICLE_ENTER_EXIT",                buff);
+	CMessages::WideStringCopy(m_aActionNames[VEHICLE_ENTER_EXIT],                buff, sizeof(m_aActionNames[VEHICLE_ENTER_EXIT]));
+
+	AsciiToUnicode("GO_LEFT",                           buff);
+	CMessages::WideStringCopy(m_aActionNames[GO_LEFT],                           buff, sizeof(m_aActionNames[GO_LEFT]));
+
+	AsciiToUnicode("GO_RIGHT",                          buff);
+	CMessages::WideStringCopy(m_aActionNames[GO_RIGHT],                          buff, sizeof(m_aActionNames[GO_RIGHT]));
+
+	AsciiToUnicode("GO_FORWARD",                        buff);
+	CMessages::WideStringCopy(m_aActionNames[GO_FORWARD],                        buff, sizeof(m_aActionNames[GO_FORWARD]));
+
+	AsciiToUnicode("GO_BACK",                           buff);
+	CMessages::WideStringCopy(m_aActionNames[GO_BACK],                           buff, sizeof(m_aActionNames[GO_BACK]));
+
+	AsciiToUnicode("NETWORK_TALK",                      buff);
+	CMessages::WideStringCopy(m_aActionNames[NETWORK_TALK],                      buff, sizeof(m_aActionNames[NETWORK_TALK]));
+
+	AsciiToUnicode("TOGGLE_DPAD",                       buff);
+	CMessages::WideStringCopy(m_aActionNames[TOGGLE_DPAD],                       buff, sizeof(m_aActionNames[TOGGLE_DPAD]));
+
+	AsciiToUnicode("SWITCH_DEBUG_CAM_ON",               buff);
+	CMessages::WideStringCopy(m_aActionNames[SWITCH_DEBUG_CAM_ON],               buff, sizeof(m_aActionNames[SWITCH_DEBUG_CAM_ON]));
+
+	AsciiToUnicode("TAKE_SCREEN_SHOT",                  buff);
+	CMessages::WideStringCopy(m_aActionNames[TAKE_SCREEN_SHOT],                  buff, sizeof(m_aActionNames[TAKE_SCREEN_SHOT]));
+}
+
+void CControllerConfigManager::UpdateJoyInConfigMenus_ButtonDown(int32 button, int32 padnumber)
+{
+	if (button != 0)
+	{
+		CPad *pad = CPad::GetPad(padnumber);
+		if (pad != NULL)
+		{
+			switch (button)
+			{
+			case 16:
+				pad->PCTempJoyState.DPadLeft = 255;
+				break;
+			case 15:
+				pad->PCTempJoyState.DPadDown = 255;
+				break;
+			case 14:
+				pad->PCTempJoyState.DPadRight = 255;
+				break;
+			case 13:
+				pad->PCTempJoyState.DPadUp = 255;
+				break;
+			case 11:
+				pad->PCTempJoyState.RightShock = 255;
+				break;
+			case 10:
+				pad->PCTempJoyState.LeftShock = 255;
+				break;
+			case 9:
+				pad->PCTempJoyState.Select = 255;
+				break;
+			case 8:
+				pad->PCTempJoyState.RightShoulder1 = 255;
+				break;
+			case 7:
+				pad->PCTempJoyState.LeftShoulder1 = 255;
+				break;
+			case 6:
+				pad->PCTempJoyState.RightShoulder2 = 255;
+				break;
+			case 5:
+				pad->PCTempJoyState.LeftShoulder2 = 255;
+				break;
+			}
+
+			if (   AllValidWinJoys.m_aJoys[JOYSTICK1].m_nVendorID  == 0x3427
+				&& AllValidWinJoys.m_aJoys[JOYSTICK1].m_nProductID == 0x1190)
+			{
+				//GIC USB Joystick, PS2 Gamepad ?
+
+				switch (button)
+				{
+				case 4:
+					pad->PCTempJoyState.Square = 255;
+					break;
+				case 3:
+					pad->PCTempJoyState.Cross = 255;
+					break;
+				case 2:
+					pad->PCTempJoyState.Circle = 255;
+					break;
+				case 1:
+					pad->PCTempJoyState.Triangle = 255;
+					break;
+				}
+			}
+			else
+			{
+				switch (button)
+				{
+				case 4:
+					pad->PCTempJoyState.Triangle = 255;
+					break;
+				case 3:
+					pad->PCTempJoyState.Square = 255;
+					break;
+				case 2:
+					pad->PCTempJoyState.Cross = 255;
+					break;
+				case 1:
+					pad->PCTempJoyState.Circle = 255;
+					break;
+				}
+			}
+		}
+	}
+}
+
+void CControllerConfigManager::AffectControllerStateOn_ButtonDown(int32 button, eControllerType type)
+{
+	bool process = true;
+	
+	if ((type == KEYBOARD || type == OPTIONAL_EXTRA) && button == rsNULL)
+		process = false;
+	if (type == JOYSTICK && button == 0)
+		process = false;
+	if (type == MOUSE && button == 0)
+		process = false;
+
+	if (process)
+	{
+		CPad *pad = CPad::GetPad(PAD1);
+
+		bool firstPerson = false;
+		bool playerDriving = false;
+
+		if (FindPlayerVehicle() != NULL)
+		{
+			CPlayerPed *plr = FindPlayerPed();
+			if (plr != NULL)
+			{
+				if (plr->m_nPedState == PED_DRIVING)
+					playerDriving = true;
+			}
+		}
+
+		int16 mode = TheCamera.Cams[TheCamera.ActiveCam].Mode;
+		if (   mode == CCam::MODE_1STPERSON
+			|| mode == CCam::MODE_SNIPER
+			|| mode == CCam::MODE_ROCKETLAUNCHER
+			|| mode == CCam::MODE_M16_1STPERSON)
+		{
+			firstPerson = true;
+		}
+
+		CControllerState *state;
+		
+		switch (type)
+		{
+		case KEYBOARD:
+		case OPTIONAL_EXTRA:
+			state = &CPad::GetPad(PAD1)->PCTempKeyState;
+			break;
+		case JOYSTICK:
+			state = &CPad::GetPad(PAD1)->PCTempJoyState;
+			break;
+		case MOUSE:
+			state = &CPad::GetPad(PAD1)->PCTempMouseState;
+			break;
+		}
+
+		if (pad != NULL)
+		{
+			if (playerDriving)
+			{
+				AffectControllerStateOn_ButtonDown_Driving(button, type, *state);
+				AffectControllerStateOn_ButtonDown_VehicleAndThirdPersonOnly(button, type, *state);
+			}
+			else
+			{
+				AffectControllerStateOn_ButtonDown_FirstAndThirdPersonOnly(button, type, *state);
+				if (firstPerson)
+					AffectControllerStateOn_ButtonDown_FirstPersonOnly(button, type, *state);
+				else
+				{
+					AffectControllerStateOn_ButtonDown_ThirdPersonOnly(button, type, *state);
+					AffectControllerStateOn_ButtonDown_VehicleAndThirdPersonOnly(button, type, *state);
+				}
+			}
+
+			AffectControllerStateOn_ButtonDown_AllStates(button, type, *state);
+		}
+	}
+}
+
+void CControllerConfigManager::AffectControllerStateOn_ButtonDown_Driving(int32 button, eControllerType type, CControllerState &state)
+{
+	if (button == GetControllerKeyAssociatedWithAction(VEHICLE_LOOKBEHIND, type))
+	{
+		state.LeftShoulder2 = 255;
+		state.RightShoulder2 = 255;
+	}
+
+	if (button == GetControllerKeyAssociatedWithAction(VEHICLE_LOOKLEFT, type))
+		state.LeftShoulder2 = 255;
+	if (button == GetControllerKeyAssociatedWithAction(VEHICLE_LOOKRIGHT, type))
+		state.RightShoulder2 = 255;
+	if (button == GetControllerKeyAssociatedWithAction(VEHICLE_HORN, type))
+		state.LeftShock = 255;
+	if (button == GetControllerKeyAssociatedWithAction(VEHICLE_HANDBRAKE, type))
+		state.RightShoulder1 = 255;
+	if (button == GetControllerKeyAssociatedWithAction(VEHICLE_ACCELERATE, type))
+		state.Cross = 255;
+	if (button == GetControllerKeyAssociatedWithAction(VEHICLE_CHANGE_RADIO_STATION, type))
+		state.LeftShoulder1 = 255;
+	if (button == GetControllerKeyAssociatedWithAction(VEHICLE_BRAKE, type))
+		state.Square = 255;
+	if (button == GetControllerKeyAssociatedWithAction(TOGGLE_SUBMISSIONS, type))
+		state.RightShock = 255;
+	
+	if (button == GetControllerKeyAssociatedWithAction(VEHICLE_TURRETLEFT, type))
+	{
+		if (state.RightStickX == 128 || m_aSimCheckers[SIM_X2][type])
+		{
+			state.RightStickX = 0;
+			m_aSimCheckers[SIM_X2][type] = true;
+		}
+		else
+		{
+			state.RightStickX = -128;
+		}
+	}
+
+	if (button == GetControllerKeyAssociatedWithAction(VEHICLE_TURRETRIGHT, type))
+	{
+		if (state.RightStickX == -128 || m_aSimCheckers[SIM_X2][type])
+		{
+			state.RightStickX = 0;
+			m_aSimCheckers[SIM_X2][type] = true;
+		}
+		else
+			state.RightStickX = 128;
+	}
+	
+	bool isDodo = false;
+	if (FindPlayerVehicle() && (FindPlayerVehicle()->IsVehicle() && FindPlayerVehicle()->GetModelIndex() == MI_DODO))
+	{
+		isDodo = true;
+	}
+
+	
+	if (button == GetControllerKeyAssociatedWithAction(VEHICLE_TURRETUP, type))
+	{
+		if (isDodo == true)
+		{
+			if (state.LeftStickY == -128 || m_aSimCheckers[SIM_Y1][type]) // BUG: should be SIM_Y2. SIM_Y1 it's DPAD
+			{
+				state.LeftStickY = 0;
+				m_aSimCheckers[SIM_Y2][type] = true;
+			}
+			else
+				state.LeftStickY = 128;
+		}
+
+		else if (state.RightStickY == -128 || m_aSimCheckers[SIM_Y2][type])
+		{
+			state.RightStickY = 0;
+			m_aSimCheckers[SIM_Y2][type] = true;
+		}
+		else
+		{
+			state.RightStickY = 128;
+		}
+	}
+	
+	if (button == GetControllerKeyAssociatedWithAction(VEHICLE_TURRETDOWN, type))
+	{
+		if (isDodo == true)
+		{
+			if (state.LeftStickY == 128 || m_aSimCheckers[SIM_Y1][type]) // BUG: should be SIM_Y2. SIM_Y1 it's DPAD
+			{
+				state.LeftStickY = 0;
+				m_aSimCheckers[SIM_Y2][type] = true;
+			}
+			else
+				state.LeftStickY = -128;
+		}
+
+		else if (state.RightStickY == 128 || m_aSimCheckers[SIM_Y2][type])
+		{
+			state.RightStickY = 0;
+			m_aSimCheckers[SIM_Y2][type] = true;
+		}
+		else
+			state.RightStickY = -128;
+	}
+}
+
+void CControllerConfigManager::AffectControllerStateOn_ButtonDown_FirstPersonOnly(int32 button, eControllerType type, CControllerState &state)
+{
+	if (button == GetControllerKeyAssociatedWithAction(PED_SNIPER_ZOOM_IN, type))
+		state.Square = 255;
+	if (button == GetControllerKeyAssociatedWithAction(PED_SNIPER_ZOOM_OUT, type))
+		state.Cross = 255;
+}
+
+void CControllerConfigManager::AffectControllerStateOn_ButtonDown_ThirdPersonOnly(int32 button, eControllerType type, CControllerState &state)
+{
+	if (button == GetControllerKeyAssociatedWithAction(PED_LOOKBEHIND, type))
+		state.RightShock = 255;
+	if (button == GetControllerKeyAssociatedWithAction(PED_JUMPING, type))
+		state.Square = 255;
+	if (button == GetControllerKeyAssociatedWithAction(PED_CYCLE_WEAPON_LEFT, type))
+		state.LeftShoulder2 = 255;
+	if (button == GetControllerKeyAssociatedWithAction(PED_CYCLE_WEAPON_RIGHT, type))
+		state.RightShoulder2 = 255;
+	if (button == GetControllerKeyAssociatedWithAction(PED_SPRINT, type))
+		state.Cross = 255;
+	
+	if (CMenuManager::m_ControlMethod == CONTROL_CLASSIC)
+	{
+		if (button == GetControllerKeyAssociatedWithAction(PED_CYCLE_TARGET_LEFT, type))
+			state.LeftShoulder2 = 255;
+		if (button == GetControllerKeyAssociatedWithAction(PED_CYCLE_TARGET_RIGHT, type))
+			state.RightShoulder2 = 255;
+		if (button == GetControllerKeyAssociatedWithAction(PED_CENTER_CAMERA_BEHIND_PLAYER, type))
+			state.LeftShoulder1 = 255;
+	}
+}
+
+void CControllerConfigManager::AffectControllerStateOn_ButtonDown_FirstAndThirdPersonOnly(int32 button, eControllerType type, CControllerState &state)
+{
+	CPad *pad = CPad::GetPad(PAD1);
+	
+	if (button == GetControllerKeyAssociatedWithAction(PED_LOCK_TARGET, type))
+		state.RightShoulder1 = 255;
+
+	if (button == GetControllerKeyAssociatedWithAction(GO_FORWARD, type))
+	{
+		if (state.DPadDown || m_aSimCheckers[SIM_Y1][type])
+		{
+			m_aSimCheckers[SIM_Y1][type] = true;
+			state.DPadDown = 0;
+			state.DPadUp = 0;
+		}
+		else
+			state.DPadUp = 255;
+	}
+
+	if (button == GetControllerKeyAssociatedWithAction(GO_BACK, type))
+	{
+		if (state.DPadUp || m_aSimCheckers[SIM_Y1][type])
+		{
+			m_aSimCheckers[SIM_Y1][type] = true;
+			state.DPadDown = 0;
+			state.DPadUp = 0;
+		}
+		else
+			state.DPadDown = 255;
+	}
+
+	if (button == GetControllerKeyAssociatedWithAction(PED_1RST_PERSON_LOOK_LEFT, type))
+	{
+		if (state.RightStickX == 128 || m_aSimCheckers[SIM_X2][type])
+		{
+			state.RightStickX = 0;
+			m_aSimCheckers[SIM_X2][type] = true;
+		}
+		else
+		{
+			state.RightStickX = -128;
+		}
+	}
+
+	if (button == GetControllerKeyAssociatedWithAction(PED_1RST_PERSON_LOOK_RIGHT, type))
+	{
+		if (state.RightStickX == -128 || m_aSimCheckers[SIM_X2][type])
+		{
+			state.RightStickX = 0;
+			m_aSimCheckers[SIM_X2][type] = true;
+		}
+		else
+			state.RightStickX = 128;
+	}
+
+	if (CMenuManager::m_ControlMethod == CONTROL_CLASSIC)
+	{
+		if (button == GetControllerKeyAssociatedWithAction(PED_1RST_PERSON_LOOK_UP, type))
+		{
+			if (state.RightStickY == -128 || m_aSimCheckers[SIM_Y2][type])
+			{
+				state.RightStickY = 0;
+				m_aSimCheckers[SIM_Y2][type] = true;
+			}
+			else
+				state.RightStickY = 128;
+		}
+
+		if (button == GetControllerKeyAssociatedWithAction(PED_1RST_PERSON_LOOK_DOWN, type))
+		{
+			if (state.RightStickY == 128 || m_aSimCheckers[SIM_Y2][type])
+			{
+				state.RightStickY = 0;
+				m_aSimCheckers[SIM_Y2][type] = true;
+			}
+			else
+				state.RightStickY = -128;
+		}
+	}
+}
+
+void CControllerConfigManager::AffectControllerStateOn_ButtonDown_AllStates(int32 button, eControllerType type, CControllerState &state)
+{
+	if (button == GetControllerKeyAssociatedWithAction(CAMERA_CHANGE_VIEW_ALL_SITUATIONS, type))
+		state.Select = 255;
+	if (button == GetControllerKeyAssociatedWithAction(PED_FIREWEAPON, type))
+		state.Circle = 255;
+
+	if (button == GetControllerKeyAssociatedWithAction(GO_LEFT, type))
+	{
+		if (state.DPadRight || m_aSimCheckers[SIM_X1][type])
+		{
+			m_aSimCheckers[SIM_X1][type] = true;
+			state.DPadLeft = 0;
+			state.DPadRight = 0;
+		}
+		else
+			state.DPadLeft = 255;
+	}
+
+	if (button == GetControllerKeyAssociatedWithAction(GO_RIGHT, type))
+	{
+		if (state.DPadLeft || m_aSimCheckers[SIM_X1][type])
+		{
+			m_aSimCheckers[SIM_X1][type] = true;
+			state.DPadLeft = 0;
+			state.DPadRight = 0;
+		}
+		else
+			state.DPadRight = 255;
+	}
+
+	if (button == GetControllerKeyAssociatedWithAction(NETWORK_TALK, type))
+		state.NetworkTalk = 255;
+}
+
+void CControllerConfigManager::AffectControllerStateOn_ButtonDown_VehicleAndThirdPersonOnly(int32 button, eControllerType type, CControllerState &state)
+{
+	if (button == GetControllerKeyAssociatedWithAction(VEHICLE_ENTER_EXIT, type))
+		state.Triangle = 255;
+}
+
+void CControllerConfigManager::UpdateJoyInConfigMenus_ButtonUp(int32 button, int32 padnumber)
+{
+	if (button!=0)
+	{
+		CPad *pad = CPad::GetPad(padnumber);
+
+		if (pad != NULL)
+		{
+			switch (button)
+			{
+			case 16:
+				pad->PCTempJoyState.DPadLeft = 0;
+				break;
+			case 15:
+				pad->PCTempJoyState.DPadDown = 0;
+				break;
+			case 14:
+				pad->PCTempJoyState.DPadRight = 0;
+				break;
+			case 13:
+				pad->PCTempJoyState.DPadUp = 0;
+				break;
+			case 11:
+				pad->PCTempJoyState.RightShock = 0;
+				break;
+			case 10:
+				pad->PCTempJoyState.LeftShock = 0;
+				break;
+			case 9:
+				pad->PCTempJoyState.Select = 0;
+				break;
+			case 8:
+				pad->PCTempJoyState.RightShoulder1 = 0;
+				break;
+			case 7:
+				pad->PCTempJoyState.LeftShoulder1 = 0;
+				break;
+			case 6:
+				pad->PCTempJoyState.RightShoulder2 = 0;
+				break;
+			case 5:
+				pad->PCTempJoyState.LeftShoulder2 = 0;
+				break;
+			}
+
+			if (   AllValidWinJoys.m_aJoys[JOYSTICK1].m_nVendorID  == 0x3427
+				&& AllValidWinJoys.m_aJoys[JOYSTICK1].m_nProductID == 0x1190)
+			{
+				//GIC USB Joystick, PS2 Gamepad ?
+
+				switch (button)
+				{
+				case 4:
+					pad->PCTempJoyState.Square = 0;
+					break;
+				case 3:
+					pad->PCTempJoyState.Cross = 0;
+					break;
+				case 2:
+					pad->PCTempJoyState.Circle = 0;
+					break;
+				case 1:
+					pad->PCTempJoyState.Triangle = 0;
+					break;
+				}
+			}
+			else
+			{
+				switch (button)
+				{
+				case 4:
+					pad->PCTempJoyState.Triangle = 0;
+					break;
+				case 3:
+					pad->PCTempJoyState.Square = 0;
+					break;
+				case 2:
+					pad->PCTempJoyState.Cross = 0;
+					break;
+				case 1:
+					pad->PCTempJoyState.Circle = 0;
+					break;
+				}
+			}
+		}
+	}
+}
+
+void CControllerConfigManager::AffectControllerStateOn_ButtonUp(int32 button, eControllerType type)
+{
+	bool process = true;
+
+	if ((type == KEYBOARD || type == OPTIONAL_EXTRA) && button == rsNULL)
+		process = false;
+	if (type == JOYSTICK && button == 0)
+		process = false;
+	if (type == MOUSE && button == 0)
+		process = false;
+
+	CControllerState *state;
+
+	switch (type)
+	{
+	case KEYBOARD:
+	case OPTIONAL_EXTRA:
+		state = &CPad::GetPad(PAD1)->PCTempKeyState;
+		break;
+	case MOUSE:
+		state = &CPad::GetPad(PAD1)->PCTempMouseState;
+		break;
+	case JOYSTICK:
+		state = &CPad::GetPad(PAD1)->PCTempJoyState;
+		break;
+	
+	}
+
+	if (process)
+	{
+		CPad *pad = CPad::GetPad(PAD1);
+		
+		if (pad != NULL)
+		{
+			if (FrontEndMenuManager.GetIsMenuActive())
+				AffectControllerStateOn_ButtonUp_All_Player_States(button, type, *state);
+		}
+	}
+}
+
+void CControllerConfigManager::AffectControllerStateOn_ButtonUp_All_Player_States(int32 button, eControllerType type, CControllerState &state)
+{
+	if (button == GetControllerKeyAssociatedWithAction(NETWORK_TALK, type))
+		state.NetworkTalk = 0;
+}
+
+void CControllerConfigManager::AffectPadFromKeyBoard()
+{
+	RsKeyCodes kc;
+	_InputTranslateShiftKeyUpDown(&kc);
+
+	bool processdown = false;
+	if (!CPad::m_bMapPadOneToPadTwo && !FrontEndMenuManager.GetIsMenuActive())
+		processdown = true;
+	
+	for (int32 i = 0; i < MAX_CONTROLLERACTIONS; i++)
+	{
+		int32 key = GetControllerKeyAssociatedWithAction((e_ControllerAction)i, KEYBOARD);
+		if (GetIsKeyboardKeyDown((RsKeyCodes)key) && processdown)
+			AffectControllerStateOn_ButtonDown(key, KEYBOARD);
+
+		int32 extrakey = GetControllerKeyAssociatedWithAction((e_ControllerAction)i, OPTIONAL_EXTRA);
+		if (GetIsKeyboardKeyDown((RsKeyCodes)extrakey) && processdown)
+			AffectControllerStateOn_ButtonDown(extrakey, OPTIONAL_EXTRA);
+
+		if (!GetIsKeyboardKeyDown((RsKeyCodes)key))
+			AffectControllerStateOn_ButtonUp(key, KEYBOARD);
+		else if ( !GetIsKeyboardKeyDown((RsKeyCodes)extrakey))
+			AffectControllerStateOn_ButtonUp(key, OPTIONAL_EXTRA);
+	}
+}
+
+void CControllerConfigManager::AffectPadFromMouse()
+{
+	bool processdown = false;
+	if (!CPad::m_bMapPadOneToPadTwo && !FrontEndMenuManager.GetIsMenuActive())
+		processdown = true;
+	
+	for (int32 i = 0; i < MAX_CONTROLLERACTIONS; i++)
+	{
+		int32 button = GetControllerKeyAssociatedWithAction((e_ControllerAction)i, MOUSE);
+		if (GetIsMouseButtonDown((RsKeyCodes)button) && processdown)
+			AffectControllerStateOn_ButtonDown(button, MOUSE);
+		if (GetIsMouseButtonUp((RsKeyCodes)button))
+			AffectControllerStateOn_ButtonUp(button, MOUSE);
+	}
+}
+
+void CControllerConfigManager::ClearSimButtonPressCheckers()
+{
+	for (int32 i = 0; i < MAX_SIMS; i++)
+	{
+		m_aSimCheckers[i][KEYBOARD]       = false;
+		m_aSimCheckers[i][OPTIONAL_EXTRA] = false;
+		m_aSimCheckers[i][MOUSE]          = false;
+		m_aSimCheckers[i][JOYSTICK]       = false;
+	}
+}
+
+bool CControllerConfigManager::GetIsKeyboardKeyDown(RsKeyCodes keycode)
+{
+	if (keycode < 255)
+	{
+		if (CPad::GetPad(PAD1)->GetChar(keycode))
+			return true;
+	}
+
+	for (int32 i = 0; i < 12; i++)
+	{
+		if (i + rsF1 == keycode)
+		{
+			if (CPad::GetPad(PAD1)->GetF(i))
+				return true;
+		}
+	}
+
+	switch (keycode)
+	{
+	case rsESC:
+		if (CPad::GetPad(PAD1)->GetEscape())
+			return true;
+		break;
+	case rsINS:
+		if (CPad::GetPad(PAD1)->GetInsert())
+			return true;
+		break;
+	case rsDEL:
+		if (CPad::GetPad(PAD1)->GetDelete())
+			return true;
+		break;
+	case rsHOME:
+		if (CPad::GetPad(PAD1)->GetHome())
+			return true;
+		break;
+	case rsEND:
+		if (CPad::GetPad(PAD1)->GetEnd())
+			return true;
+		break;
+	case rsPGUP:
+		if (CPad::GetPad(PAD1)->GetPageUp())
+			return true;
+		break;
+	case rsPGDN:
+		if (CPad::GetPad(PAD1)->GetPageDown())
+			return true;
+		break;
+	case rsUP:
+		if (CPad::GetPad(PAD1)->GetUp())
+			return true;
+		break;
+	case rsDOWN:
+		if (CPad::GetPad(PAD1)->GetDown())
+			return true;
+		break;
+	case rsLEFT:
+		if (CPad::GetPad(PAD1)->GetLeft())
+			return true;
+		break;
+	case rsRIGHT:
+		if (CPad::GetPad(PAD1)->GetRight())
+			return true;
+		break;
+	case rsSCROLL:
+		if (CPad::GetPad(PAD1)->GetScrollLock())
+			return true;
+		break;
+	case rsPAUSE:
+		if (CPad::GetPad(PAD1)->GetPause())
+			return true;
+		break;
+	case rsNUMLOCK:
+		if (CPad::GetPad(PAD1)->GetNumLock())
+			return true;
+		break;
+	case rsDIVIDE:
+		if (CPad::GetPad(PAD1)->GetDivide())
+			return true;
+		break;
+	case rsTIMES:
+		if (CPad::GetPad(PAD1)->GetTimes())
+			return true;
+		break;
+	case rsMINUS:
+		if (CPad::GetPad(PAD1)->GetMinus())
+			return true;
+		break;
+	case rsPLUS:
+		if (CPad::GetPad(PAD1)->GetPlus())
+			return true;
+		break;
+	case rsPADENTER:
+		if (CPad::GetPad(PAD1)->GetPadEnter())
+			return true;
+		break;
+	case rsPADDEL:
+		if (CPad::GetPad(PAD1)->GetPadDel())
+			return true;
+		break;
+	case rsPADEND:
+		if (CPad::GetPad(PAD1)->GetPad1())
+			return true;
+		break;
+	case rsPADDOWN:
+		if (CPad::GetPad(PAD1)->GetPad2())
+			return true;
+		break;
+	case rsPADPGDN:
+		if (CPad::GetPad(PAD1)->GetPad3())
+			return true;
+		break;
+	case rsPADLEFT:
+		if (CPad::GetPad(PAD1)->GetPad4())
+			return true;
+		break;
+	case rsPAD5:
+		if (CPad::GetPad(PAD1)->GetPad5())
+			return true;
+		break;
+	case rsPADRIGHT:
+		if (CPad::GetPad(PAD1)->GetPad6())
+			return true;
+		break;
+	case rsPADHOME:
+		if (CPad::GetPad(PAD1)->GetPad7())
+			return true;
+		break;
+	case rsPADUP:
+		if (CPad::GetPad(PAD1)->GetPad8())
+			return true;
+		break;
+	case rsPADPGUP:
+		if (CPad::GetPad(PAD1)->GetPad9())
+			return true;
+		break;
+	case rsPADINS:
+		if (CPad::GetPad(PAD1)->GetPad0())
+			return true;
+		break;
+	case rsBACKSP:
+		if (CPad::GetPad(PAD1)->GetBackspace())
+			return true;
+		break;
+	case rsTAB:
+		if (CPad::GetPad(PAD1)->GetTab())
+			return true;
+		break;
+	case rsCAPSLK:
+		if (CPad::GetPad(PAD1)->GetCapsLock())
+			return true;
+		break;
+	case rsENTER:
+		if (CPad::GetPad(PAD1)->GetEnter())
+			return true;
+		break;
+	case rsLSHIFT:
+		if (CPad::GetPad(PAD1)->GetLeftShift())
+			return true;
+		break;
+	case rsSHIFT:
+		if (CPad::GetPad(PAD1)->GetShift())
+			return true;
+		break;
+	case rsRSHIFT:
+		if (CPad::GetPad(PAD1)->GetRightShift())
+			return true;
+		break;
+	case rsLCTRL:
+		if (CPad::GetPad(PAD1)->GetLeftCtrl())
+			return true;
+		break;
+	case rsRCTRL:
+		if (CPad::GetPad(PAD1)->GetRightCtrl())
+			return true;
+		break;
+	case rsLALT:
+		if (CPad::GetPad(PAD1)->GetLeftAlt())
+			return true;
+		break;
+	case rsRALT:
+		if (CPad::GetPad(PAD1)->GetRightAlt())
+			return true;
+		break;
+	case rsLWIN:
+		if (CPad::GetPad(PAD1)->GetLeftWin())
+			return true;
+		break;
+	case rsRWIN:
+		if (CPad::GetPad(PAD1)->GetRightWin())
+			return true;
+		break;
+	case rsAPPS:
+		if (CPad::GetPad(PAD1)->GetApps())
+			return true;
+		break;
+	}
+
+	return false;
+}
+
+bool CControllerConfigManager::GetIsKeyboardKeyJustDown(RsKeyCodes keycode)
+{
+	if (keycode < 255)
+	{
+		if (CPad::GetPad(PAD1)->GetCharJustDown(keycode))
+			return true;
+	}
+
+	for (int32 i = 0; i < 12; i++)
+	{
+		if (i + rsF1 == keycode)
+		{
+			if (CPad::GetPad(PAD1)->GetFJustDown(i))
+				return true;
+		}
+	}
+
+	switch (keycode)
+	{
+	case rsESC:
+		if (CPad::GetPad(PAD1)->GetEscapeJustDown())
+			return true;
+		break;
+	case rsINS:
+		if (CPad::GetPad(PAD1)->GetInsertJustDown())
+			return true;
+		break;
+	case rsDEL:
+		if (CPad::GetPad(PAD1)->GetDeleteJustDown())
+			return true;
+		break;
+	case rsHOME:
+		if (CPad::GetPad(PAD1)->GetHomeJustDown())
+			return true;
+		break;
+	case rsEND:
+		if (CPad::GetPad(PAD1)->GetEndJustDown())
+			return true;
+		break;
+	case rsPGUP:
+		if (CPad::GetPad(PAD1)->GetPageUpJustDown())
+			return true;
+		break;
+	case rsPGDN:
+		if (CPad::GetPad(PAD1)->GetPageDownJustDown())
+			return true;
+		break;
+	case rsUP:
+		if (CPad::GetPad(PAD1)->GetUpJustDown())
+			return true;
+		break;
+	case rsDOWN:
+		if (CPad::GetPad(PAD1)->GetDownJustDown())
+			return true;
+		break;
+	case rsLEFT:
+		if (CPad::GetPad(PAD1)->GetLeftJustDown())
+			return true;
+		break;
+	case rsRIGHT:
+		if (CPad::GetPad(PAD1)->GetRightJustDown())
+			return true;
+		break;
+	case rsSCROLL:
+		if (CPad::GetPad(PAD1)->GetScrollLockJustDown())
+			return true;
+		break;
+	case rsPAUSE:
+		if (CPad::GetPad(PAD1)->GetPauseJustDown())
+			return true;
+		break;
+	case rsNUMLOCK:
+		if (CPad::GetPad(PAD1)->GetNumLockJustDown())
+			return true;
+		break;
+	case rsDIVIDE:
+		if (CPad::GetPad(PAD1)->GetDivideJustDown())
+			return true;
+		break;
+	case rsTIMES:
+		if (CPad::GetPad(PAD1)->GetTimesJustDown())
+			return true;
+		break;
+	case rsMINUS:
+		if (CPad::GetPad(PAD1)->GetMinusJustDown())
+			return true;
+		break;
+	case rsPLUS:
+		if (CPad::GetPad(PAD1)->GetPlusJustDown())
+			return true;
+		break;
+	case rsPADENTER:
+		if (CPad::GetPad(PAD1)->GetPadEnterJustDown())
+			return true;
+		break;
+	case rsPADDEL:
+		if (CPad::GetPad(PAD1)->GetPadDelJustDown())
+			return true;
+		break;
+	case rsPADEND:
+		if (CPad::GetPad(PAD1)->GetPad1JustDown())
+			return true;
+		break;
+	case rsPADDOWN:
+		if (CPad::GetPad(PAD1)->GetPad2JustDown())
+			return true;
+		break;
+	case rsPADPGDN:
+		if (CPad::GetPad(PAD1)->GetPad3JustDown())
+			return true;
+		break;
+	case rsPADLEFT:
+		if (CPad::GetPad(PAD1)->GetPad4JustDown())
+			return true;
+		break;
+	case rsPAD5:
+		if (CPad::GetPad(PAD1)->GetPad5JustDown())
+			return true;
+		break;
+	case rsPADRIGHT:
+		if (CPad::GetPad(PAD1)->GetPad6JustDown())
+			return true;
+		break;
+	case rsPADHOME:
+		if (CPad::GetPad(PAD1)->GetPad7JustDown())
+			return true;
+		break;
+	case rsPADUP:
+		if (CPad::GetPad(PAD1)->GetPad8JustDown())
+			return true;
+		break;
+	case rsPADPGUP:
+		if (CPad::GetPad(PAD1)->GetPad9JustDown())
+			return true;
+		break;
+	case rsPADINS:
+		if (CPad::GetPad(PAD1)->GetPad0JustDown())
+			return true;
+		break;
+	case rsBACKSP:
+		if (CPad::GetPad(PAD1)->GetBackspaceJustDown())
+			return true;
+		break;
+	case rsTAB:
+		if (CPad::GetPad(PAD1)->GetTabJustDown())
+			return true;
+		break;
+	case rsCAPSLK:
+		if (CPad::GetPad(PAD1)->GetCapsLockJustDown())
+			return true;
+		break;
+	case rsENTER:
+		if (CPad::GetPad(PAD1)->GetEnterJustDown())
+			return true;
+		break;
+	case rsLSHIFT:
+		if (CPad::GetPad(PAD1)->GetLeftShiftJustDown())
+			return true;
+		break;
+	case rsSHIFT:
+		if (CPad::GetPad(PAD1)->GetShiftJustDown())
+			return true;
+		break;
+	case rsRSHIFT:
+		if (CPad::GetPad(PAD1)->GetRightShiftJustDown())
+			return true;
+		break;
+	case rsLCTRL:
+		if (CPad::GetPad(PAD1)->GetLeftCtrlJustDown())
+			return true;
+		break;
+	case rsRCTRL:
+		if (CPad::GetPad(PAD1)->GetRightCtrlJustDown())
+			return true;
+		break;
+	case rsLALT:
+		if (CPad::GetPad(PAD1)->GetLeftAltJustDown())
+			return true;
+		break;
+	case rsRALT:
+		if (CPad::GetPad(PAD1)->GetRightAltJustDown())
+			return true;
+		break;
+	case rsLWIN:
+		if (CPad::GetPad(PAD1)->GetLeftWinJustDown())
+			return true;
+		break;
+	case rsRWIN:
+		if (CPad::GetPad(PAD1)->GetRightWinJustDown())
+			return true;
+		break;
+	case rsAPPS:
+		if (CPad::GetPad(PAD1)->GetAppsJustDown())
+			return true;
+		break;
+	}
+
+	return false;
+}
+
+bool CControllerConfigManager::GetIsMouseButtonDown(RsKeyCodes keycode)
+{
+	switch (keycode)
+	{
+	case rsMOUSELEFTBUTTON:
+		if (CPad::GetPad(PAD1)->GetLeftMouse())
+			return true;
+		break;
+	case rsMOUSMIDDLEBUTTON:
+		if (CPad::GetPad(PAD1)->GetMiddleMouse())
+			return true;
+		break;
+	case rsMOUSERIGHTBUTTON:
+		if (CPad::GetPad(PAD1)->GetRightMouse())
+			return true;
+		break;
+	case rsMOUSEWHEELUPBUTTON:
+		if (CPad::GetPad(PAD1)->GetMouseWheelUp())
+			return true;
+		break;
+	case rsMOUSEWHEELDOWNBUTTON:
+		if (CPad::GetPad(PAD1)->GetMouseWheelDown())
+			return true;
+		break;
+	case rsMOUSEX1BUTTON:
+		if (CPad::GetPad(PAD1)->GetMouseX1())
+			return true;
+		break;
+	case rsMOUSEX2BUTTON:
+		if (CPad::GetPad(PAD1)->GetMouseX2())
+			return true;
+		break;
+	}
+
+	return false;
+}
+
+bool CControllerConfigManager::GetIsMouseButtonUp(RsKeyCodes keycode)
+{
+	if (keycode > rsMOUSEX2BUTTON)
+	{
+		switch (keycode)
+		{
+		case rsMOUSELEFTBUTTON:
+			if (CPad::GetPad(PAD1)->GetLeftMouseUp())
+				return true;
+			break;
+		case rsMOUSMIDDLEBUTTON:
+			if (CPad::GetPad(PAD1)->GetMiddleMouseUp())
+				return true;
+			break;
+		case rsMOUSERIGHTBUTTON:
+			if (CPad::GetPad(PAD1)->GetRightMouseUp())
+				return true;
+			break;
+		case rsMOUSEWHEELUPBUTTON:
+			if (CPad::GetPad(PAD1)->GetMouseWheelUpUp())
+				return true;
+			break;
+		case rsMOUSEWHEELDOWNBUTTON:
+			if (CPad::GetPad(PAD1)->GetMouseWheelDownUp())
+				return true;
+			break;
+		case rsMOUSEX1BUTTON:
+			if (CPad::GetPad(PAD1)->GetMouseX1Up())
+				return true;
+			break;
+		case rsMOUSEX2BUTTON:
+			if (CPad::GetPad(PAD1)->GetMouseX2Up())
+				return true;
+			break;
+		}
+	}
+
+	return false;
+}
+
+void CControllerConfigManager::DeleteMatchingCommonControls(e_ControllerAction action, int32 key, eControllerType type)
+{
+	if (!GetIsKeyBlank(key, type))
+	{
+		if (key == GetControllerKeyAssociatedWithAction(CAMERA_CHANGE_VIEW_ALL_SITUATIONS,type))
+			ClearSettingsAssociatedWithAction(CAMERA_CHANGE_VIEW_ALL_SITUATIONS, type);
+		if (key == GetControllerKeyAssociatedWithAction(PED_FIREWEAPON, type))
+			ClearSettingsAssociatedWithAction(PED_FIREWEAPON, type);
+		if (key == GetControllerKeyAssociatedWithAction(GO_LEFT, type))
+			ClearSettingsAssociatedWithAction(GO_LEFT, type);
+		if (key == GetControllerKeyAssociatedWithAction(GO_RIGHT, type))
+			ClearSettingsAssociatedWithAction(GO_RIGHT, type);
+		if (key == GetControllerKeyAssociatedWithAction(NETWORK_TALK, type))
+			ClearSettingsAssociatedWithAction(NETWORK_TALK, type);
+		if (key == GetControllerKeyAssociatedWithAction(SWITCH_DEBUG_CAM_ON, type))
+			ClearSettingsAssociatedWithAction(SWITCH_DEBUG_CAM_ON, type);
+		if (key == GetControllerKeyAssociatedWithAction(TOGGLE_DPAD, type))
+			ClearSettingsAssociatedWithAction(TOGGLE_DPAD, type);
+		if (key == GetControllerKeyAssociatedWithAction(TAKE_SCREEN_SHOT, type))
+			ClearSettingsAssociatedWithAction(TAKE_SCREEN_SHOT, type);
+		if (key == GetControllerKeyAssociatedWithAction(SHOW_MOUSE_POINTER_TOGGLE, type))
+			ClearSettingsAssociatedWithAction(SHOW_MOUSE_POINTER_TOGGLE, type);
+	}
+}
+
+void CControllerConfigManager::DeleteMatching3rdPersonControls(e_ControllerAction action, int32 key, eControllerType type)
+{
+	if (!GetIsKeyBlank(key, type))
+	{
+		if (key == GetControllerKeyAssociatedWithAction(PED_LOOKBEHIND, type))
+			ClearSettingsAssociatedWithAction(PED_LOOKBEHIND, type);
+		if (key == GetControllerKeyAssociatedWithAction(PED_CYCLE_WEAPON_LEFT, type))
+			ClearSettingsAssociatedWithAction(PED_CYCLE_WEAPON_LEFT, type);
+		if (key == GetControllerKeyAssociatedWithAction(PED_CYCLE_WEAPON_RIGHT, type))
+			ClearSettingsAssociatedWithAction(PED_CYCLE_WEAPON_RIGHT, type);
+		if (key == GetControllerKeyAssociatedWithAction(PED_JUMPING, type))
+			ClearSettingsAssociatedWithAction(PED_JUMPING, type);
+		if (key == GetControllerKeyAssociatedWithAction(PED_SPRINT, type))
+			ClearSettingsAssociatedWithAction(PED_SPRINT, type);
+
+		if (CMenuManager::m_ControlMethod == CONTROL_CLASSIC)
+		{
+			if (key == GetControllerKeyAssociatedWithAction(PED_CYCLE_TARGET_LEFT, type))
+				ClearSettingsAssociatedWithAction(PED_CYCLE_TARGET_LEFT, type);
+			if (key == GetControllerKeyAssociatedWithAction(PED_CYCLE_TARGET_RIGHT, type))
+				ClearSettingsAssociatedWithAction(PED_CYCLE_TARGET_RIGHT, type);
+			if (key == GetControllerKeyAssociatedWithAction(PED_CENTER_CAMERA_BEHIND_PLAYER, type))
+				ClearSettingsAssociatedWithAction(PED_CENTER_CAMERA_BEHIND_PLAYER, type);
+		}
+	}
+}
+
+void CControllerConfigManager::DeleteMatching1rst3rdPersonControls(e_ControllerAction action, int32 key, eControllerType type)
+{
+	if (!GetIsKeyBlank(key, type))
+	{
+		if (key == GetControllerKeyAssociatedWithAction(PED_LOCK_TARGET, type))
+			ClearSettingsAssociatedWithAction(PED_LOCK_TARGET, type);
+		if (key == GetControllerKeyAssociatedWithAction(GO_FORWARD, type))
+			ClearSettingsAssociatedWithAction(GO_FORWARD, type);
+		if (key == GetControllerKeyAssociatedWithAction(GO_BACK, type))
+			ClearSettingsAssociatedWithAction(GO_BACK, type);
+
+		if (CMenuManager::m_ControlMethod == CONTROL_CLASSIC)
+		{
+			if (key == GetControllerKeyAssociatedWithAction(PED_1RST_PERSON_LOOK_LEFT, type))
+				ClearSettingsAssociatedWithAction(PED_1RST_PERSON_LOOK_LEFT, type);
+			if (key == GetControllerKeyAssociatedWithAction(PED_1RST_PERSON_LOOK_RIGHT, type))
+				ClearSettingsAssociatedWithAction(PED_1RST_PERSON_LOOK_RIGHT, type);
+			if (key == GetControllerKeyAssociatedWithAction(PED_1RST_PERSON_LOOK_DOWN, type))
+				ClearSettingsAssociatedWithAction(PED_1RST_PERSON_LOOK_DOWN, type);
+			if (key == GetControllerKeyAssociatedWithAction(PED_1RST_PERSON_LOOK_UP, type))
+				ClearSettingsAssociatedWithAction(PED_1RST_PERSON_LOOK_UP, type);
+		}
+	}
+}
+
+void CControllerConfigManager::DeleteMatchingVehicleControls(e_ControllerAction action, int32 key, eControllerType type)
+{
+	if (!GetIsKeyBlank(key, type))
+	{
+		if (key == GetControllerKeyAssociatedWithAction(VEHICLE_LOOKBEHIND, type))
+			ClearSettingsAssociatedWithAction(VEHICLE_LOOKBEHIND, type);
+		if (key == GetControllerKeyAssociatedWithAction(VEHICLE_LOOKLEFT, type))
+			ClearSettingsAssociatedWithAction(VEHICLE_LOOKLEFT, type);
+		if (key == GetControllerKeyAssociatedWithAction(VEHICLE_LOOKRIGHT, type))
+			ClearSettingsAssociatedWithAction(VEHICLE_LOOKRIGHT, type);
+		if (key == GetControllerKeyAssociatedWithAction(VEHICLE_LOOKBEHIND, type)) // note: dublicate
+			ClearSettingsAssociatedWithAction(VEHICLE_LOOKBEHIND, type);
+		if (key == GetControllerKeyAssociatedWithAction(VEHICLE_HORN, type))
+			ClearSettingsAssociatedWithAction(VEHICLE_HORN, type);
+		if (key == GetControllerKeyAssociatedWithAction(VEHICLE_HANDBRAKE, type))
+			ClearSettingsAssociatedWithAction(VEHICLE_HANDBRAKE, type);
+		if (key == GetControllerKeyAssociatedWithAction(VEHICLE_ACCELERATE, type))
+			ClearSettingsAssociatedWithAction(VEHICLE_ACCELERATE, type);
+		if (key == GetControllerKeyAssociatedWithAction(VEHICLE_BRAKE, type))
+			ClearSettingsAssociatedWithAction(VEHICLE_BRAKE, type);
+		if (key == GetControllerKeyAssociatedWithAction(VEHICLE_CHANGE_RADIO_STATION, type))
+			ClearSettingsAssociatedWithAction(VEHICLE_CHANGE_RADIO_STATION, type);
+		if (key == GetControllerKeyAssociatedWithAction(TOGGLE_SUBMISSIONS, type))
+			ClearSettingsAssociatedWithAction(TOGGLE_SUBMISSIONS, type);
+		if (key == GetControllerKeyAssociatedWithAction(VEHICLE_TURRETLEFT, type))
+			ClearSettingsAssociatedWithAction(VEHICLE_TURRETLEFT, type);
+		if (key == GetControllerKeyAssociatedWithAction(VEHICLE_TURRETRIGHT, type))
+			ClearSettingsAssociatedWithAction(VEHICLE_TURRETRIGHT, type);
+		if (key == GetControllerKeyAssociatedWithAction(VEHICLE_TURRETUP, type))
+			ClearSettingsAssociatedWithAction(VEHICLE_TURRETUP, type);
+		if (key == GetControllerKeyAssociatedWithAction(VEHICLE_TURRETDOWN, type))
+			ClearSettingsAssociatedWithAction(VEHICLE_TURRETDOWN, type);
+	}
+}
+
+void CControllerConfigManager::DeleteMatchingVehicle_3rdPersonControls(e_ControllerAction action, int32 key, eControllerType type)
+{
+	if (!GetIsKeyBlank(key, type))
+	{
+		if (key == GetControllerKeyAssociatedWithAction(VEHICLE_ENTER_EXIT, type))
+			ClearSettingsAssociatedWithAction(VEHICLE_ENTER_EXIT, type);
+	}
+}
+
+void CControllerConfigManager::DeleteMatching1rstPersonControls(e_ControllerAction action, int32 key, eControllerType type)
+{
+	if (!GetIsKeyBlank(key, type))
+	{
+		if (key == GetControllerKeyAssociatedWithAction(PED_SNIPER_ZOOM_IN, type))
+			ClearSettingsAssociatedWithAction(PED_SNIPER_ZOOM_IN, type);
+		if (key == GetControllerKeyAssociatedWithAction(PED_SNIPER_ZOOM_OUT, type))
+			ClearSettingsAssociatedWithAction(PED_SNIPER_ZOOM_OUT, type);
+	}
+}
+
+void CControllerConfigManager::DeleteMatchingActionInitiators(e_ControllerAction action, int32 key, eControllerType type)
+{
+	if (!GetIsKeyBlank(key, type))
+	{
+		switch (GetActionType(action))
+		{
+		case ACTIONTYPE_1RSTPERSON:
+			DeleteMatchingCommonControls           (action, key, type);
+			DeleteMatching1rstPersonControls       (action, key, type);
+			DeleteMatching1rst3rdPersonControls    (action, key, type);
+			break;
+		case ACTIONTYPE_3RDPERSON:
+			DeleteMatching3rdPersonControls        (action, key, type);
+			DeleteMatchingCommonControls           (action, key, type);
+			DeleteMatchingVehicle_3rdPersonControls(action, key, type);
+			DeleteMatching1rst3rdPersonControls    (action, key, type);
+			break;
+		case ACTIONTYPE_VEHICLE:
+			DeleteMatchingVehicleControls          (action, key, type);
+			DeleteMatchingCommonControls           (action, key, type);
+			DeleteMatchingVehicle_3rdPersonControls(action, key, type);
+			break;
+		case ACTIONTYPE_VEHICLE_3RDPERSON:
+			DeleteMatching3rdPersonControls        (action, key, type);
+			DeleteMatchingVehicleControls          (action, key, type);
+			DeleteMatchingCommonControls           (action, key, type);
+			DeleteMatching1rst3rdPersonControls    (action, key, type);
+			break;
+		case ACTIONTYPE_1RST3RDPERSON:
+			DeleteMatching1rstPersonControls       (action, key, type);
+			DeleteMatching3rdPersonControls        (action, key, type);
+			DeleteMatchingCommonControls           (action, key, type);
+			DeleteMatchingVehicle_3rdPersonControls(action, key, type);
+			DeleteMatching1rst3rdPersonControls    (action, key, type);
+			break;
+		case ACTIONTYPE_COMMON:
+			DeleteMatching1rstPersonControls       (action, key, type);
+			DeleteMatching3rdPersonControls        (action, key, type);
+			DeleteMatchingVehicleControls          (action, key, type);
+			DeleteMatchingVehicle_3rdPersonControls(action, key, type);
+			DeleteMatchingCommonControls           (action, key, type);
+			DeleteMatching1rst3rdPersonControls    (action, key, type);
+			break;
+		}
+	}
+}
+
+bool CControllerConfigManager::GetIsKeyBlank(int32 key, eControllerType type)
+{
+	if (type > JOYSTICK)
+		return true;
+
+	switch (type)
+	{
+	case KEYBOARD:
+	case OPTIONAL_EXTRA:
+		if (key != rsNULL)
+			return false;
+		break;
+
+	case JOYSTICK:
+		if (key != 0)
+			return false;
+		break;
+
+	case MOUSE:
+		if (key != 0)
+			return false;
+		break;
+	}
+
+	return true;
+}
+
+e_ControllerActionType CControllerConfigManager::GetActionType(e_ControllerAction action)
+{
+	switch (action)
+	{
+	case CAMERA_CHANGE_VIEW_ALL_SITUATIONS:
+	case PED_FIREWEAPON:
+	case GO_LEFT:
+	case GO_RIGHT:
+	case NETWORK_TALK:
+	case SWITCH_DEBUG_CAM_ON:
+	case TOGGLE_DPAD:
+	case TAKE_SCREEN_SHOT:
+	case SHOW_MOUSE_POINTER_TOGGLE:
+		return ACTIONTYPE_COMMON;
+		break;
+
+	case PED_LOOKBEHIND:
+	case PED_CYCLE_WEAPON_LEFT:
+	case PED_CYCLE_WEAPON_RIGHT:
+	case PED_JUMPING:
+	case PED_SPRINT:
+	case PED_CYCLE_TARGET_LEFT:
+	case PED_CYCLE_TARGET_RIGHT:
+	case PED_CENTER_CAMERA_BEHIND_PLAYER:
+		return ACTIONTYPE_3RDPERSON;
+		break;
+
+	case VEHICLE_LOOKBEHIND:
+	case VEHICLE_LOOKLEFT:
+	case VEHICLE_LOOKRIGHT:
+	case VEHICLE_HORN:
+	case VEHICLE_HANDBRAKE:
+	case VEHICLE_ACCELERATE:
+	case VEHICLE_BRAKE:
+	case VEHICLE_CHANGE_RADIO_STATION:
+	case TOGGLE_SUBMISSIONS:
+	case VEHICLE_TURRETLEFT:
+	case VEHICLE_TURRETRIGHT:
+	case VEHICLE_TURRETUP:
+	case VEHICLE_TURRETDOWN:
+		return ACTIONTYPE_VEHICLE;
+		break;
+
+	case VEHICLE_ENTER_EXIT:
+		return ACTIONTYPE_VEHICLE_3RDPERSON;
+		break;
+
+	case PED_LOCK_TARGET:
+	case GO_FORWARD:
+	case GO_BACK:
+	case PED_1RST_PERSON_LOOK_LEFT:
+	case PED_1RST_PERSON_LOOK_RIGHT:
+	case PED_1RST_PERSON_LOOK_DOWN:
+	case PED_1RST_PERSON_LOOK_UP:
+		return ACTIONTYPE_1RST3RDPERSON;
+		break;
+
+	case PED_SNIPER_ZOOM_IN:
+	case PED_SNIPER_ZOOM_OUT:
+		return ACTIONTYPE_1RSTPERSON;
+		break;
+	}
+
+	return ACTIONTYPE_NONE;
+}
+
+void CControllerConfigManager::ClearSettingsAssociatedWithAction(e_ControllerAction action, eControllerType type)
+{
+	if (type <= JOYSTICK)
+	{
+		switch (type)
+		{
+		case KEYBOARD:
+			m_aSettings[action][type].m_Key = rsNULL;
+			m_aSettings[action][type].m_ContSetOrder = SETORDER_NONE;
+			break;
+		case OPTIONAL_EXTRA:
+			m_aSettings[action][type].m_Key = rsNULL;
+			m_aSettings[action][type].m_ContSetOrder = SETORDER_NONE;
+			break;
+		case MOUSE:
+			m_aSettings[action][type].m_Key = 0;
+			m_aSettings[action][type].m_ContSetOrder = SETORDER_NONE;
+			break;
+		case JOYSTICK:
+			m_aSettings[action][type].m_Key = 0;
+			m_aSettings[action][type].m_ContSetOrder = SETORDER_NONE;
+			break;
+		}
+	}
+
+	ResetSettingOrder(action);
+}
+
+wchar *CControllerConfigManager::GetControllerSettingTextWithOrderNumber(e_ControllerAction action, eContSetOrder setorder)
+{
+	for (int i = 0; i < MAX_CONTROLLERTYPES; i++)
+	{
+		if (m_aSettings[action][i].m_ContSetOrder == setorder)
+		{
+			switch (i)
+			{
+			case KEYBOARD:
+			case OPTIONAL_EXTRA:
+				return GetControllerSettingTextKeyBoard(action, (eControllerType)i);
+			case MOUSE:
+				return GetControllerSettingTextMouse   (action);
+			case JOYSTICK:
+				return GetControllerSettingTextJoystick(action);
+			}
+		}
+	}
+	
+	return NULL;
+}
+
+wchar *CControllerConfigManager::GetControllerSettingTextKeyBoard(e_ControllerAction action, eControllerType type)
+{
+	static wchar ActionText[50];
+	static wchar NewStringWithNumber[30];
+
+	for (int32 i = 0; i < ARRAYSIZE(ActionText); i++)
+		ActionText[i] = '\0';
+
+	if (GetControllerKeyAssociatedWithAction(action, type) != rsNULL)
+	{
+		if (   GetControllerKeyAssociatedWithAction(action, type) >= 0
+			&& GetControllerKeyAssociatedWithAction(action, type) <= 255)
+		{
+			char c = GetControllerKeyAssociatedWithAction(action, type);
+			if (c == ' ')
+				return TheText.Get("FEC_SPC"); // "SPC"
+			else
+			{
+				ActionText[0] = CFont::character_code(c);
+				if (ActionText[0] == '\0')
+					ActionText[0] = CFont::character_code('#');
+				ActionText[1] = '\0';
+				return ActionText;
+			}
+		}
+		else
+		{
+			switch (GetControllerKeyAssociatedWithAction(action, type))
+			{
+				case rsF1:
+				case rsF2:
+				case rsF3:
+				case rsF4:
+				case rsF5:
+				case rsF6:
+				case rsF7:
+				case rsF8:
+				case rsF9:
+				case rsF10:
+				case rsF11:
+				case rsF12:
+				{
+					CMessages::InsertNumberInString(TheText.Get("FEC_FNC"), // "F~1~"
+						GetControllerKeyAssociatedWithAction(action, type) - rsESC,
+						-1, -1, -1, -1, -1,
+						NewStringWithNumber);
+					return NewStringWithNumber;
+					break;
+				}
+
+				case rsINS:
+				{
+					return TheText.Get("FEC_IRT"); // "INS"
+					break;
+				}
+
+				case rsDEL:
+				{
+					return TheText.Get("FEC_DLL"); // "DEL"
+					break;
+				}
+
+				case rsHOME:
+				{
+					return TheText.Get("FEC_HME"); // "HOME"
+					break;
+				}
+
+				case rsEND:
+				{
+					return TheText.Get("FEC_END"); // "END"
+					break;
+				}
+
+				case rsPGUP:
+				{
+					return TheText.Get("FEC_PGU"); // "PGUP"
+					break;
+				}
+
+				case rsPGDN:
+				{
+					return TheText.Get("FEC_PGD"); // "PGDN"
+					break;
+				}
+
+				case rsUP:
+				{
+					return TheText.Get("FEC_UPA"); // "UP"
+					break;
+				}
+
+				case rsDOWN:
+				{
+					return TheText.Get("FEC_DWA"); // "DOWN"
+					break;
+				}
+
+				case rsLEFT:
+				{
+					return TheText.Get("FEC_LFA"); // "LEFT"
+					break;
+				}
+
+				case rsRIGHT:
+				{
+					return TheText.Get("FEC_RFA"); // "RIGHT"
+					break;
+				}
+
+				case rsDIVIDE:
+				{
+					return TheText.Get("FEC_FWS"); // "NUM /"
+					break;
+				}
+
+				case rsTIMES:
+				{
+					return TheText.Get("FEC_STR"); // "NUM STAR"
+					break;
+				}
+
+				case rsPLUS:
+				{
+					return TheText.Get("FEC_PLS"); // "NUM +"
+					break;
+				}
+
+				case rsMINUS:
+				{
+					return TheText.Get("FEC_MIN"); // "NUM -"
+					break;
+				}
+
+				case rsPADDEL:
+				{
+					return TheText.Get("FEC_DOT"); // "NUM ."
+					break;
+				}
+
+				case rsPADEND:
+				{
+					CMessages::InsertNumberInString(TheText.Get("FEC_NMN"), // "NUM~1~"
+						1, -1, -1, -1, -1, -1, NewStringWithNumber);
+					return NewStringWithNumber;
+					break;
+				}
+
+				case rsPADDOWN:
+				{
+					CMessages::InsertNumberInString(TheText.Get("FEC_NMN"), // "NUM~1~"
+						2, -1, -1, -1, -1, -1,
+						NewStringWithNumber);
+					return NewStringWithNumber;
+					break;
+				}
+
+				case rsPADPGDN:
+				{
+					CMessages::InsertNumberInString(TheText.Get("FEC_NMN"), // "NUM~1~"
+						3, -1, -1, -1, -1, -1,
+						NewStringWithNumber);
+					return NewStringWithNumber;
+					break;
+				}
+
+				case rsPADLEFT:
+				{
+					CMessages::InsertNumberInString(TheText.Get("FEC_NMN"), // "NUM~1~"
+						4, -1, -1, -1, -1, -1,
+						NewStringWithNumber);
+					return NewStringWithNumber;
+					break;
+				}
+
+				case rsPAD5:
+				{
+					CMessages::InsertNumberInString(TheText.Get("FEC_NMN"), // "NUM~1~"
+						5, -1, -1, -1, -1, -1,
+						NewStringWithNumber);
+					return NewStringWithNumber;
+					break;
+				}
+
+				case rsNUMLOCK:
+				{
+					return TheText.Get("FEC_NLK"); // "NUMLOCK"
+					break;
+				}
+
+				case rsPADRIGHT:
+				{
+					CMessages::InsertNumberInString(TheText.Get("FEC_NMN"), // "NUM~1~"
+						6, -1, -1, -1, -1, -1,
+						NewStringWithNumber);
+					return NewStringWithNumber;
+					break;
+				}
+
+				case rsPADHOME:
+				{
+					CMessages::InsertNumberInString(TheText.Get("FEC_NMN"), // "NUM~1~"
+						7, -1, -1, -1, -1, -1,
+						NewStringWithNumber);
+					return NewStringWithNumber;
+					break;
+				}
+
+				case rsPADUP:
+				{
+					CMessages::InsertNumberInString(TheText.Get("FEC_NMN"), // "NUM~1~"
+						8, -1, -1, -1, -1, -1,
+						NewStringWithNumber);
+					return NewStringWithNumber;
+					break;
+				}
+
+				case rsPADPGUP:
+				{
+					CMessages::InsertNumberInString(TheText.Get("FEC_NMN"), // "NUM~1~"
+						9, -1, -1, -1, -1, -1,
+						NewStringWithNumber);
+					return NewStringWithNumber;
+					break;
+				}
+
+				case rsPADINS:
+				{
+					CMessages::InsertNumberInString(TheText.Get("FEC_NMN"), // "NUM~1~"
+						0, -1, -1, -1, -1, -1,
+						NewStringWithNumber);
+					return NewStringWithNumber;
+					break;
+				}
+
+				case rsPADENTER:
+				{
+					return TheText.Get("FEC_ETR"); // "ENT"
+					break;
+				}
+
+				case rsSCROLL:
+				{
+					return TheText.Get("FEC_SLK"); // "SCROLL LOCK"
+					break;
+				}
+
+				case rsPAUSE:
+				{
+					return TheText.Get("FEC_PSB"); // "BREAK"
+					break;
+				}
+
+				case rsBACKSP:
+				{
+					return TheText.Get("FEC_BSP"); // "BSPACE"
+					break;
+				}
+
+				case rsTAB:
+				{
+					return TheText.Get("FEC_TAB"); // "TAB"
+					break;
+				}
+
+				case rsCAPSLK:
+				{
+					return TheText.Get("FEC_CLK"); // "CAPSLOCK"
+					break;
+				}
+
+				case rsENTER:
+				{
+					return TheText.Get("FEC_RTN"); // "RET"
+					break;
+				}
+
+				case rsLSHIFT:
+				{
+					return TheText.Get("FEC_LSF"); // "LSHIFT"
+					break;
+				}
+
+				case rsRSHIFT:
+				{
+					return TheText.Get("FEC_RSF"); // "RSHIFT"
+					break;
+				}
+
+				case rsLCTRL:
+				{
+					return TheText.Get("FEC_LCT"); // "LCTRL"
+					break;
+				}
+
+				case rsRCTRL:
+				{
+					return TheText.Get("FEC_RCT"); // "RCTRL"
+					break;
+				}
+
+				case rsLALT:
+				{
+					return TheText.Get("FEC_LAL"); // "LALT"
+					break;
+				}
+
+				case rsRALT:
+				{
+					return TheText.Get("FEC_RAL"); // "RALT"
+					break;
+				}
+
+				case rsLWIN:
+				{
+					return TheText.Get("FEC_LWD"); // "LWIN"
+					break;
+				}
+
+				case rsRWIN:
+				{
+					return TheText.Get("FEC_RWD"); // "RWIN"
+					break;
+				}
+
+				case rsAPPS:
+				{
+					return TheText.Get("FEC_WRC"); // "WINCLICK"
+					break;
+				}
+
+				case rsSHIFT:
+				{
+					return TheText.Get("FEC_SFT"); // "SHIFT"
+					break;
+				}
+			}
+		}
+	}
+
+	return NULL;
+}
+
+wchar *CControllerConfigManager::GetControllerSettingTextMouse(e_ControllerAction action)
+{
+	switch (m_aSettings[action][MOUSE].m_Key)
+	{
+	case 1:
+		return TheText.Get("FEC_MSL");	// LMB
+		break;
+	case 2:
+		return TheText.Get("FEC_MSM");	// MMB
+		break;
+	case 3:
+		return TheText.Get("FEC_MSR");	// RMB
+		break;
+	case 4:
+		return TheText.Get("FEC_MWF");	// WHEEL UP
+		break;
+	case 5:
+		return TheText.Get("FEC_MWB");	// WHEEL DN
+		break;
+	case 6:
+		return TheText.Get("FEC_MXO");	// MXB1
+		break;
+	case 7:
+		return TheText.Get("FEC_MXT");	// MXB2
+		break;
+	}
+
+	return NULL;
+}
+
+wchar *CControllerConfigManager::GetControllerSettingTextJoystick(e_ControllerAction action)
+{
+	if (m_aSettings[action][JOYSTICK].m_Key == 0) 
+		return NULL;
+
+	static wchar NewStringWithNumber[30];
+
+	CMessages::InsertNumberInString(TheText.Get("FEC_JBO"),		// JOY ~1~
+		m_aSettings[action][JOYSTICK].m_Key, -1, -1, -1, -1, -1,
+		NewStringWithNumber);
+
+	return NewStringWithNumber;
+}
+
+int32 CControllerConfigManager::GetNumOfSettingsForAction(e_ControllerAction action)
+{
+	int32 num = 0;
+
+	if (m_aSettings[action][KEYBOARD].m_Key       != rsNULL) num++;
+	if (m_aSettings[action][OPTIONAL_EXTRA].m_Key != rsNULL) num++;
+	if (m_aSettings[action][MOUSE].m_Key          != 0)      num++;
+	if (m_aSettings[action][JOYSTICK].m_Key       != 0)      num++;
+
+	return num;
+}
+
+void CControllerConfigManager::GetWideStringOfCommandKeys(uint16 action, wchar *text, uint16 leight)
+{
+	int32 nums = GetNumOfSettingsForAction((e_ControllerAction)action);
+
+	int32 sets = 0;
+
+	for (int32 i = SETORDER_1; i < MAX_SETORDERS; i++)
+	{
+		wchar *textorder = ControlsManager.GetControllerSettingTextWithOrderNumber((e_ControllerAction)action, (eContSetOrder)i);
+		if (textorder != NULL)
+		{
+			uint16 len = CMessages::GetWideStringLength(text);
+			CMessages::WideStringCopy(&text[len], textorder, leight - len);
+
+			if (++sets < nums)
+			{
+				if (sets == nums - 1)
+				{
+					// if last - text += ' or ';
+					uint16 pos1 = CMessages::GetWideStringLength(text);
+					text[pos1] = ' ';
+
+					CMessages::WideStringCopy(&text[pos1 + 1],
+						TheText.Get("FEC_ORR"),	// "or"
+						leight - (pos1 + 1));
+					
+					uint16 pos2 = CMessages::GetWideStringLength(text);
+					text[pos2 + 0] = ' ';
+					text[pos2 + 1] = '\0';
+				}
+				else
+				{
+					// text += ', ';
+					uint16 pos1 = CMessages::GetWideStringLength(text);
+					text[pos1 + 0] = ',';
+					text[pos1 + 1] = ' ';
+					text[pos1 + 2] = '\0';
+
+					uint16 pos2 = CMessages::GetWideStringLength(text);
+				}
+			}
+		}
+	}
+}
+
+int32 CControllerConfigManager::GetControllerKeyAssociatedWithAction(e_ControllerAction action, eControllerType type)
+{
+	return m_aSettings[action][type].m_Key;
+}
+
+void CControllerConfigManager::UpdateJoyButtonState(int32 padnumber)
+{
+	for (int32 i = 0; i < MAX_BUTTONS; i++)
+		m_aButtonStates[i] = false;
+
+	for (int32 i = 0; i < MAX_BUTTONS; i++)
+	{
+		if (m_NewState.rgbButtons[i] & 0x80)
+			m_aButtonStates[i] = true;
+		else
+			m_aButtonStates[i] = false;
+	}
+}
+
+bool CControllerConfigManager::GetIsActionAButtonCombo(e_ControllerAction action)
+{
+	switch (action)
+	{
+	case VEHICLE_LOOKBEHIND:
+	case PED_CYCLE_TARGET_LEFT:
+	case PED_CYCLE_TARGET_RIGHT:
+		return true;
+		break;
+	}
+
+	return false;
+}
+
+wchar *CControllerConfigManager::GetButtonComboText(e_ControllerAction action)
+{
+	switch (action)
+	{
+	case PED_CYCLE_TARGET_LEFT:
+		return TheText.Get("FEC_PTL");	// Use LockTarget with Weapon Switch Left.
+		break;
+	
+	case PED_CYCLE_TARGET_RIGHT:
+		return TheText.Get("FEC_PTR");	// Use LockTarget with Weapon Switch Right.
+		break;
+	
+	case VEHICLE_LOOKBEHIND:
+		return TheText.Get("FEC_LBC");	// Use Look Left With Look Right. 
+		break;
+	}
+
+	return NULL;
+}
+
+void CControllerConfigManager::SetControllerKeyAssociatedWithAction(e_ControllerAction action, int32 key, eControllerType type)
+{
+	ResetSettingOrder(action);
+	
+	m_aSettings[action][type].m_Key = key;
+	m_aSettings[action][type].m_ContSetOrder = GetNumOfSettingsForAction(action) + 1;
+}
+
+int32 CControllerConfigManager::GetMouseButtonAssociatedWithAction(e_ControllerAction action)
+{
+	return m_aSettings[action][MOUSE].m_Key;
+}
+
+void CControllerConfigManager::SetMouseButtonAssociatedWithAction(e_ControllerAction action, int32 button)
+{
+	m_aSettings[action][MOUSE].m_Key = button;
+	m_aSettings[action][MOUSE].m_ContSetOrder = GetNumOfSettingsForAction(action) + 1;
+}
+
+void CControllerConfigManager::ResetSettingOrder(e_ControllerAction action)
+{
+	int32 conttype = KEYBOARD;
+
+	for (int32 i = SETORDER_1; i < MAX_SETORDERS; i++)
+	{
+		bool isexist = false;
+		for (int32 j = 0; j < MAX_CONTROLLERTYPES; j++)
+		{
+			if (m_aSettings[action][j].m_ContSetOrder == i)
+				isexist = true;
+		}
+
+		bool init = false;
+
+		if (isexist)
+		{
+			for (int32 k = 0; k < MAX_CONTROLLERTYPES; k++)
+			{
+				int32 setorder = m_aSettings[action][k].m_ContSetOrder;
+				if (setorder > i && setorder != KEYBOARD)
+				{
+					if (init)
+					{
+						if (setorder < m_aSettings[action][conttype].m_ContSetOrder)
+							conttype = k;
+					}
+					else
+					{
+						init = true;
+						conttype = k;
+					}
+				}
+			}
+
+			if (init)
+				m_aSettings[action][conttype].m_ContSetOrder = i;
+		}
+	}
+}
+
+
+STARTPATCHES
+	InjectHook(0x58B7A0, &CControllerConfigManager::MakeControllerActionsBlank, PATCH_JUMP);
+	InjectHook(0x58B7D0, &CControllerConfigManager::GetJoyButtonJustDown, PATCH_JUMP);
+	InjectHook(0x58B800, &CControllerConfigManager::SaveSettings, PATCH_JUMP);
+	InjectHook(0x58B870, &CControllerConfigManager::LoadSettings, PATCH_JUMP);
+	InjectHook(0x58B930, &CControllerConfigManager::InitDefaultControlConfiguration, PATCH_JUMP);
+	InjectHook(0x58BD00, &CControllerConfigManager::InitDefaultControlConfigMouse, PATCH_JUMP);
+	InjectHook(0x58BD90, &CControllerConfigManager::InitDefaultControlConfigJoyPad, PATCH_JUMP);
+	InjectHook(0x58C060, &CControllerConfigManager::InitialiseControllerActionNameArray, PATCH_JUMP);
+	InjectHook(0x58C5E0, &CControllerConfigManager::UpdateJoyInConfigMenus_ButtonDown, PATCH_JUMP);
+	InjectHook(0x58C730, &CControllerConfigManager::AffectControllerStateOn_ButtonDown, PATCH_JUMP);
+	InjectHook(0x58C880, &CControllerConfigManager::AffectControllerStateOn_ButtonDown_Driving, PATCH_JUMP);
+	InjectHook(0x58CAD0, &CControllerConfigManager::AffectControllerStateOn_ButtonDown_FirstPersonOnly, PATCH_JUMP);
+	InjectHook(0x58CB10, &CControllerConfigManager::AffectControllerStateOn_ButtonDown_ThirdPersonOnly, PATCH_JUMP);
+	InjectHook(0x58CBD0, &CControllerConfigManager::AffectControllerStateOn_ButtonDown_FirstAndThirdPersonOnly, PATCH_JUMP);
+	InjectHook(0x58CD70, &CControllerConfigManager::AffectControllerStateOn_ButtonDown_AllStates, PATCH_JUMP);
+	InjectHook(0x58CE50, &CControllerConfigManager::AffectControllerStateOn_ButtonDown_VehicleAndThirdPersonOnly, PATCH_JUMP);
+	InjectHook(0x58CE80, &CControllerConfigManager::UpdateJoyInConfigMenus_ButtonUp, PATCH_JUMP);
+	InjectHook(0x58CFD0, &CControllerConfigManager::AffectControllerStateOn_ButtonUp, PATCH_JUMP);
+	InjectHook(0x58D090, &CControllerConfigManager::AffectControllerStateOn_ButtonUp_All_Player_States, PATCH_JUMP);
+	InjectHook(0x58D0C0, &CControllerConfigManager::AffectPadFromKeyBoard, PATCH_JUMP);
+	InjectHook(0x58D1A0, &CControllerConfigManager::AffectPadFromMouse, PATCH_JUMP);
+	InjectHook(0x58D220, &CControllerConfigManager::ClearSimButtonPressCheckers, PATCH_JUMP);
+	InjectHook(0x58D2A0, &CControllerConfigManager::GetIsKeyboardKeyDown, PATCH_JUMP);
+	InjectHook(0x58D8A0, &CControllerConfigManager::GetIsKeyboardKeyJustDown, PATCH_JUMP);
+	InjectHook(0x58E280, &CControllerConfigManager::GetIsMouseButtonDown, PATCH_JUMP);
+	InjectHook(0x58E360, &CControllerConfigManager::GetIsMouseButtonUp, PATCH_JUMP);
+	InjectHook(0x58E440, &CControllerConfigManager::DeleteMatchingCommonControls, PATCH_JUMP);
+	InjectHook(0x58E540, &CControllerConfigManager::DeleteMatching3rdPersonControls, PATCH_JUMP);
+	InjectHook(0x58E630, &CControllerConfigManager::DeleteMatching1rst3rdPersonControls, PATCH_JUMP);
+	InjectHook(0x58E710, &CControllerConfigManager::DeleteMatchingVehicleControls, PATCH_JUMP);
+	InjectHook(0x58E890, &CControllerConfigManager::DeleteMatchingVehicle_3rdPersonControls, PATCH_JUMP);
+	InjectHook(0x58E8D0, &CControllerConfigManager::DeleteMatching1rstPersonControls, PATCH_JUMP);
+	InjectHook(0x58E920, &CControllerConfigManager::DeleteMatchingActionInitiators, PATCH_JUMP);
+	InjectHook(0x58EA70, &CControllerConfigManager::GetIsKeyBlank, PATCH_JUMP);
+	InjectHook(0x58EAD0, &CControllerConfigManager::GetActionType, PATCH_JUMP);
+	InjectHook(0x58EB40, &CControllerConfigManager::ClearSettingsAssociatedWithAction, PATCH_JUMP);
+	InjectHook(0x58EBF0, &CControllerConfigManager::GetControllerSettingTextWithOrderNumber, PATCH_JUMP);
+	InjectHook(0x58EC50, &CControllerConfigManager::GetControllerSettingTextKeyBoard, PATCH_JUMP);
+	InjectHook(0x58F320, &CControllerConfigManager::GetControllerSettingTextMouse, PATCH_JUMP);
+	InjectHook(0x58F3D0, &CControllerConfigManager::GetControllerSettingTextJoystick, PATCH_JUMP);
+	InjectHook(0x58F420, &CControllerConfigManager::GetNumOfSettingsForAction, PATCH_JUMP);
+	InjectHook(0x58F460, &CControllerConfigManager::GetWideStringOfCommandKeys, PATCH_JUMP);
+	InjectHook(0x58F590, &CControllerConfigManager::GetControllerKeyAssociatedWithAction, PATCH_JUMP);
+	InjectHook(0x58F5B0, &CControllerConfigManager::UpdateJoyButtonState, PATCH_JUMP);
+	InjectHook(0x58F660, &CControllerConfigManager::GetIsActionAButtonCombo, PATCH_JUMP);
+	InjectHook(0x58F690, &CControllerConfigManager::GetButtonComboText, PATCH_JUMP);
+	InjectHook(0x58F700, &CControllerConfigManager::SetControllerKeyAssociatedWithAction, PATCH_JUMP);
+	InjectHook(0x58F740, &CControllerConfigManager::GetMouseButtonAssociatedWithAction, PATCH_JUMP);
+	InjectHook(0x58F760, &CControllerConfigManager::SetMouseButtonAssociatedWithAction, PATCH_JUMP);
+	InjectHook(0x58F790, &CControllerConfigManager::ResetSettingOrder, PATCH_JUMP);
+ENDPATCHES
\ No newline at end of file
diff --git a/src/core/ControllerConfig.h b/src/core/ControllerConfig.h
index ab17577b..e7abb21d 100644
--- a/src/core/ControllerConfig.h
+++ b/src/core/ControllerConfig.h
@@ -5,65 +5,94 @@
 
 enum eControllerType
 {
-	KEYBOARD,
+	KEYBOARD = 0,
 	OPTIONAL_EXTRA,
 	MOUSE,
 	JOYSTICK,
-	TOTAL_CONTROLLER_TYPES
+	MAX_CONTROLLERTYPES,
 };
 
-enum e_ControllerAction

-{

-	PED_FIREWEAPON = 0,

-	PED_CYCLE_WEAPON_RIGHT,

-	PED_CYCLE_WEAPON_LEFT,

-	GO_FORWARD,

-	GO_BACK,

-	GO_LEFT,

-	GO_RIGHT,

-	PED_SNIPER_ZOOM_IN,

-	PED_SNIPER_ZOOM_OUT,

-	VEHICLE_ENTER_EXIT,

-	CAMERA_CHANGE_VIEW_ALL_SITUATIONS,

-	PED_JUMPING,

-	PED_SPRINT,

-	PED_LOOKBEHIND,

-	//PED_DUCK,				// VC

-	//PED_ANSWER_PHONE,		// VC

-	VEHICLE_ACCELERATE,

-	VEHICLE_BRAKE,

-	VEHICLE_CHANGE_RADIO_STATION,

-	VEHICLE_HORN,

-	TOGGLE_SUBMISSIONS,

-	VEHICLE_HANDBRAKE,

-	PED_1RST_PERSON_LOOK_LEFT,

-	PED_1RST_PERSON_LOOK_RIGHT,

-	VEHICLE_LOOKLEFT,

-	VEHICLE_LOOKRIGHT,

-	VEHICLE_LOOKBEHIND,

-	VEHICLE_TURRETLEFT,

-	VEHICLE_TURRETRIGHT,

-	VEHICLE_TURRETUP,

-	VEHICLE_TURRETDOWN,

-	PED_CYCLE_TARGET_LEFT,

-	PED_CYCLE_TARGET_RIGHT,

-	PED_CENTER_CAMERA_BEHIND_PLAYER,

-	PED_LOCK_TARGET,

-	NETWORK_TALK,

-	PED_1RST_PERSON_LOOK_UP,

-	PED_1RST_PERSON_LOOK_DOWN,

-

-	CONTROLLERACTION_36, // unk, unused?

-

-	TOGGLE_DPAD,

-	SWITCH_DEBUG_CAM_ON,

-	TAKE_SCREEN_SHOT,

-	SHOW_MOUSE_POINTER_TOGGLE,

-

-	TOTAL_CONTROL_ACTIONS

+enum e_ControllerAction
+{
+	PED_FIREWEAPON = 0,
+	PED_CYCLE_WEAPON_RIGHT,
+	PED_CYCLE_WEAPON_LEFT,
+	GO_FORWARD,
+	GO_BACK,
+	GO_LEFT,
+	GO_RIGHT,
+	PED_SNIPER_ZOOM_IN,
+	PED_SNIPER_ZOOM_OUT,
+	VEHICLE_ENTER_EXIT,
+	CAMERA_CHANGE_VIEW_ALL_SITUATIONS,
+	PED_JUMPING,
+	PED_SPRINT,
+	PED_LOOKBEHIND,
+	VEHICLE_ACCELERATE,
+	VEHICLE_BRAKE,
+	VEHICLE_CHANGE_RADIO_STATION,
+	VEHICLE_HORN,
+	TOGGLE_SUBMISSIONS,
+	VEHICLE_HANDBRAKE,
+	PED_1RST_PERSON_LOOK_LEFT,
+	PED_1RST_PERSON_LOOK_RIGHT,
+	VEHICLE_LOOKLEFT,
+	VEHICLE_LOOKRIGHT,
+	VEHICLE_LOOKBEHIND,
+	VEHICLE_TURRETLEFT,
+	VEHICLE_TURRETRIGHT,
+	VEHICLE_TURRETUP,
+	VEHICLE_TURRETDOWN,
+	PED_CYCLE_TARGET_LEFT,
+	PED_CYCLE_TARGET_RIGHT,
+	PED_CENTER_CAMERA_BEHIND_PLAYER,
+	PED_LOCK_TARGET,
+	NETWORK_TALK,
+	PED_1RST_PERSON_LOOK_UP,
+	PED_1RST_PERSON_LOOK_DOWN,
+	_CONTROLLERACTION_36,					// Unused
+	TOGGLE_DPAD,
+	SWITCH_DEBUG_CAM_ON,
+	TAKE_SCREEN_SHOT,
+	SHOW_MOUSE_POINTER_TOGGLE,
+	MAX_CONTROLLERACTIONS,
+};
+
+enum e_ControllerActionType
+{
+	ACTIONTYPE_1RSTPERSON = 0,
+	ACTIONTYPE_3RDPERSON,
+	ACTIONTYPE_VEHICLE,
+	ACTIONTYPE_VEHICLE_3RDPERSON,
+	ACTIONTYPE_COMMON,
+	ACTIONTYPE_1RST3RDPERSON,
+	ACTIONTYPE_NONE,
+};
+
+enum eContSetOrder
+{
+	SETORDER_NONE = 0,
+	SETORDER_1,
+	SETORDER_2,
+	SETORDER_3,
+	SETORDER_4,
+	MAX_SETORDERS,
+};
+
+enum eSimCheckers
+{
+	SIM_X1 = 0, SIM_Y1,	// DPad
+	SIM_X2, SIM_Y2,	    // LeftStick
+
+	MAX_SIMS
 };
 
 class CMouseControllerState;
+class CControllerState;
+
+
+#define JOY_BUTTONS 16
+#define MAX_BUTTONS (JOY_BUTTONS+1)
 
 #define ACTIONNAME_LENGTH 40
 
@@ -72,38 +101,97 @@ class CControllerConfigManager
 public:
 	struct tControllerConfigBind
 	{
-		RsKeyCodes m_Key;
-		int32 m_ContSetOrder;
+		int32      m_Key;
+		int32      m_ContSetOrder;
+
+		tControllerConfigBind()
+		{
+			m_Key = 0;
+			m_ContSetOrder = 0;
+		}
 	};
 
-	bool firstCapture;
-	DIJOYSTATE2 m_OldState;
-	DIJOYSTATE2 m_NewState;
-	wchar m_aActionNames[TOTAL_CONTROL_ACTIONS][ACTIONNAME_LENGTH];
-	bool m_aButtonStates[17];
-	tControllerConfigBind m_aSettings[TOTAL_CONTROL_ACTIONS][TOTAL_CONTROLLER_TYPES];
-	uint8 m_aSimCheckers[4][4];
-	bool m_bMouseAssociated;
+	bool                  m_bFirstCapture;
+	char _pad0[3];
+#ifdef __DINPUT_INCLUDED__
+	DIJOYSTATE2           m_OldState;
+	DIJOYSTATE2           m_NewState;
+#endif
+	wchar                 m_aActionNames[MAX_CONTROLLERACTIONS][40];
+	bool                  m_aButtonStates[MAX_BUTTONS];
+	char _pad1[3];
+	tControllerConfigBind m_aSettings[MAX_CONTROLLERACTIONS][MAX_CONTROLLERTYPES];
+	bool                  m_aSimCheckers[MAX_SIMS][MAX_CONTROLLERTYPES];
+	bool                  m_bMouseAssociated;
+	char _pad2[3];
 	
-	void UpdateJoyButtonState(int padnumber);
-	void UpdateJoyInConfigMenus_ButtonDown(int button, int padnumber);
-	void AffectControllerStateOn_ButtonDown(int button, eControllerType type);
-	void UpdateJoyInConfigMenus_ButtonUp(int button, int padnumber);
-	void AffectControllerStateOn_ButtonUp(int button, int padnumber);
+	CControllerConfigManager();
+
+	void  MakeControllerActionsBlank();
 	
 	int32 GetJoyButtonJustDown();
-	void LoadSettings(int32 file);
-	void SaveSettings(int32 file);
-	void MakeControllerActionsBlank();
-	void InitDefaultControlConfiguration();
-	void InitDefaultControlConfigMouse(CMouseControllerState const &mousestate);
-	void InitDefaultControlConfigJoyPad(unsigned int buttons);
-	void ClearSimButtonPressCheckers();
-	void AffectPadFromKeyBoard();
-	void AffectPadFromMouse();
-	void ClearSettingsAssociatedWithAction(int, int);
-
-	void GetWideStringOfCommandKeys(uint16, wchar*, uint16);
+	
+	void  SaveSettings(int32 file);
+	void  LoadSettings(int32 file);
+	
+	void  InitDefaultControlConfiguration();
+	void  InitDefaultControlConfigMouse(CMouseControllerState const &availableButtons);
+	void  InitDefaultControlConfigJoyPad(uint32 buttons);
+	void  InitialiseControllerActionNameArray();
+
+	void  UpdateJoyInConfigMenus_ButtonDown                           (int32 button, int32 padnumber);
+	void  AffectControllerStateOn_ButtonDown                          (int32 button, eControllerType type);
+	void  AffectControllerStateOn_ButtonDown_Driving                  (int32 button, eControllerType type, CControllerState &state);
+	void  AffectControllerStateOn_ButtonDown_FirstPersonOnly          (int32 button, eControllerType type, CControllerState &state);
+	void  AffectControllerStateOn_ButtonDown_ThirdPersonOnly          (int32 button, eControllerType type, CControllerState &state);
+	void  AffectControllerStateOn_ButtonDown_FirstAndThirdPersonOnly  (int32 button, eControllerType type, CControllerState &state);
+	void  AffectControllerStateOn_ButtonDown_AllStates                (int32 button, eControllerType type, CControllerState &state);
+	void  AffectControllerStateOn_ButtonDown_VehicleAndThirdPersonOnly(int32 button, eControllerType type, CControllerState &state);
+
+	void  UpdateJoyInConfigMenus_ButtonUp(int32 button, int32 padnumber);
+	void  AffectControllerStateOn_ButtonUp(int32 button, eControllerType type);
+	void  AffectControllerStateOn_ButtonUp_All_Player_States(int32 button, eControllerType type, CControllerState &state);
+	
+	void  AffectPadFromKeyBoard();
+	void  AffectPadFromMouse();
+	
+	void  ClearSimButtonPressCheckers();
+
+	bool  GetIsKeyboardKeyDown    (RsKeyCodes keycode);
+	bool  GetIsKeyboardKeyJustDown(RsKeyCodes keycode);
+	bool  GetIsMouseButtonDown    (RsKeyCodes keycode);
+	bool  GetIsMouseButtonUp      (RsKeyCodes keycode);
+
+
+	void DeleteMatchingCommonControls           (e_ControllerAction action, int32 key, eControllerType type);
+	void DeleteMatching3rdPersonControls        (e_ControllerAction action, int32 key, eControllerType type);
+	void DeleteMatching1rst3rdPersonControls    (e_ControllerAction action, int32 key, eControllerType type);
+	void DeleteMatchingVehicleControls          (e_ControllerAction action, int32 key, eControllerType type);
+	void DeleteMatchingVehicle_3rdPersonControls(e_ControllerAction action, int32 key, eControllerType type);
+	void DeleteMatching1rstPersonControls       (e_ControllerAction action, int32 key, eControllerType type);
+	void DeleteMatchingActionInitiators         (e_ControllerAction action, int32 key, eControllerType type);
+
+	bool GetIsKeyBlank(int32 key, eControllerType type);
+	e_ControllerActionType GetActionType(e_ControllerAction action);
+
+	void ClearSettingsAssociatedWithAction        (e_ControllerAction action, eControllerType type);
+	wchar *GetControllerSettingTextWithOrderNumber(e_ControllerAction action, eContSetOrder setorder);
+	wchar *GetControllerSettingTextKeyBoard       (e_ControllerAction action, eControllerType type);
+	wchar *GetControllerSettingTextMouse          (e_ControllerAction action);
+	wchar *GetControllerSettingTextJoystick       (e_ControllerAction action);
+
+	int32 GetNumOfSettingsForAction(e_ControllerAction action);
+	void  GetWideStringOfCommandKeys(uint16 action, wchar *text, uint16 leight);
+	int32 GetControllerKeyAssociatedWithAction(e_ControllerAction action, eControllerType type);
+
+	void  UpdateJoyButtonState(int32 padnumber);
+	
+	bool  GetIsActionAButtonCombo             (e_ControllerAction action);
+	wchar *GetButtonComboText                 (e_ControllerAction action);
+	void  SetControllerKeyAssociatedWithAction(e_ControllerAction action, int32 key, eControllerType type);
+	int32 GetMouseButtonAssociatedWithAction  (e_ControllerAction action);
+	void  SetMouseButtonAssociatedWithAction  (e_ControllerAction action, int32 button);
+	void  ResetSettingOrder                   (e_ControllerAction action);
 };
 
 VALIDATE_SIZE(CControllerConfigManager, 0x143C);
diff --git a/src/core/Frontend.cpp b/src/core/Frontend.cpp
index 5f87049a..984e693f 100644
--- a/src/core/Frontend.cpp
+++ b/src/core/Frontend.cpp
@@ -1466,7 +1466,7 @@ void CMenuManager::Process(void)
 				else {
 					DMAudio.PlayFrontEndSound(SOUND_FRONTEND_MENU_SUCCESS, 0);
 					for (int i = 0; i < 4; i++)
-						ControlsManager.ClearSettingsAssociatedWithAction(m_CurrCntrlAction, i);
+						ControlsManager.ClearSettingsAssociatedWithAction((e_ControllerAction)m_CurrCntrlAction, (eControllerType)i);
 					field_534 = false;
 					m_bKeyChangeNotProcessed = false;
 					pControlEdit = nil;
diff --git a/src/core/Frontend.h b/src/core/Frontend.h
index b588b1af..e1ee5b31 100644
--- a/src/core/Frontend.h
+++ b/src/core/Frontend.h
@@ -342,6 +342,12 @@ enum
 	NUM_MENUROWS = 18,
 };
 
+enum eControlMethod
+{
+	CONTROL_STANDART = 0,
+	CONTROL_CLASSIC,
+};
+
 struct tSkinInfo
 {
 	int field_0;
@@ -432,6 +438,9 @@ public:
 	int m_nScreenChangeDelayTimer;
 
 public:
+	bool GetIsMenuActive() {return !!m_bMenuActive;}
+
+public:
 	static int32 &OS_Language;
 	static int8 &m_PrefsUseVibration;
 	static int8 &m_DisplayControllerOnFoot;
diff --git a/src/core/Pad.h b/src/core/Pad.h
index eca334ee..61825626 100644
--- a/src/core/Pad.h
+++ b/src/core/Pad.h
@@ -1,56 +1,5 @@
 #pragma once
 
-// same as RW skeleton
-/*
-enum Key
-{
-	// ascii...
-
-	KEY_ESC   = 128,
-
-	KEY_F1    = 129,
-	KEY_F2    = 130,
-	KEY_F3    = 131,
-	KEY_F4    = 132,
-	KEY_F5    = 133,
-	KEY_F6    = 134,
-	KEY_F7    = 135,
-	KEY_F8    = 136,
-	KEY_F9    = 137,
-	KEY_F10   = 138,
-	KEY_F11   = 139,
-	KEY_F12   = 140,
-
-	KEY_INS   = 141,
-	KEY_DEL   = 142,
-	KEY_HOME  = 143,
-	KEY_END   = 144,
-	KEY_PGUP  = 145,
-	KEY_PGDN  = 146,
-
-	KEY_UP    = 147,
-	KEY_DOWN  = 148,
-	KEY_LEFT  = 149,
-	KEY_RIGHT = 150,
-
-	// some stuff ommitted
-
-	KEY_BACKSP = 168,
-	KEY_TAB    = 169,
-	KEY_CAPSLK = 170,
-	KEY_ENTER  = 171,
-	KEY_LSHIFT = 172,
-	KEY_RSHIFT = 173,
-	KEY_LCTRL  = 174,
-	KEY_RCTRL  = 175,
-	KEY_LALT   = 176,
-	KEY_RALT   = 177,
-
-	KEY_NULL,	// unused
-	KEY_NUMKEYS
-};
-*/
-
 enum {
 	PLAYERCONTROL_ENABLED = 0,
 	PLAYERCONTROL_DISABLED_1 = 1,
@@ -299,61 +248,130 @@ public:
 	static int32 *EditCodesForControls(int32 *pRsKeys, int32 nSize);
 
 	// mouse
-	bool GetLeftMouseJustDown() { return !!(NewMouseControllerState.LMB && !OldMouseControllerState.LMB); }
-	bool GetRightMouseJustDown() { return !!(NewMouseControllerState.RMB && !OldMouseControllerState.RMB); }
+	bool GetLeftMouseJustDown()   { return !!(NewMouseControllerState.LMB && !OldMouseControllerState.LMB); }
+	bool GetRightMouseJustDown()  { return !!(NewMouseControllerState.RMB && !OldMouseControllerState.RMB); }
 	bool GetMiddleMouseJustDown() { return !!(NewMouseControllerState.MMB && !OldMouseControllerState.MMB); }
+	bool GetMouseWheelUp()        { return !!(NewMouseControllerState.WHEELUP && !OldMouseControllerState.WHEELUP); }
+	bool GetMouseWheelDown()      { return !!(NewMouseControllerState.WHEELDN && !OldMouseControllerState.WHEELDN);}
+	bool GetMouseX1()             { return !!(NewMouseControllerState.MXB1    && !OldMouseControllerState.MXB1); }
+	bool GetMouseX2()             { return !!(NewMouseControllerState.MXB2    && !OldMouseControllerState.MXB2); }
+
+
+	bool GetLeftMouse()         { return NewMouseControllerState.LMB; }
+	bool GetRightMouse()        { return NewMouseControllerState.RMB; }
+	bool GetMiddleMouse()       { return NewMouseControllerState.MMB; }
+	bool GetMouseWheelUp()      { return NewMouseControllerState.WHEELUP; }
+	bool GetMouseWheelDown()    { return NewMouseControllerState.WHEELDN; }
+	bool GetMouseX1()           { return NewMouseControllerState.MXB1; }
+	bool GetMouseX2()           { return NewMouseControllerState.MXB2; }
+
+	bool GetLeftMouseUp()       { return !OldMouseControllerState.LMB; }
+	bool GetRightMouseUp()      { return !OldMouseControllerState.RMB; }
+	bool GetMiddleMouseUp()     { return !OldMouseControllerState.MMB; }
+	bool GetMouseWheelUpUp()    { return !OldMouseControllerState.WHEELUP; }
+	bool GetMouseWheelDownUp()  { return !OldMouseControllerState.WHEELDN; }
+	bool GetMouseX1Up()         { return !OldMouseControllerState.MXB1; }
+	bool GetMouseX2Up()         { return !OldMouseControllerState.MXB2; }
+
+
 	float GetMouseX() { return NewMouseControllerState.x; }
 	float GetMouseY() { return NewMouseControllerState.y; }
 
 	// keyboard
 	
 	bool GetCharJustDown(int32 c) { return !!(NewKeyState.VK_KEYS[c] && !OldKeyState.VK_KEYS[c]); }
-	bool GetFJustDown(int32 n)   { return !!(NewKeyState.F[n] && !OldKeyState.F[n]); }
-	bool GetEscapeJustDown()     { return !!(NewKeyState.ESC && !OldKeyState.ESC); }
-	bool GetInsertJustDown()     { return !!(NewKeyState.INS && !OldKeyState.INS); }
-	bool GetDeleteJustDown()     { return !!(NewKeyState.DEL && !OldKeyState.DEL); }
-	bool GetHomeJustDown()       { return !!(NewKeyState.HOME && !OldKeyState.HOME); }
-	bool GetEndJustDown()        { return !!(NewKeyState.END && !OldKeyState.END); }
-	bool GetPageUpJustDown()     { return !!(NewKeyState.PGUP && !OldKeyState.PGUP); }
-	bool GetPageDownJustDown()   { return !!(NewKeyState.PGDN && !OldKeyState.PGDN); }
-	bool GetUpJustDown()         { return !!(NewKeyState.UP && !OldKeyState.UP); }
-	bool GetDownJustDown()       { return !!(NewKeyState.DOWN && !OldKeyState.DOWN); }
-	bool GetLeftJustDown()       { return !!(NewKeyState.LEFT && !OldKeyState.LEFT); }
-	bool GetRightJustDown()      { return !!(NewKeyState.RIGHT && !OldKeyState.RIGHT); }
-	bool GetScrollLockJustDown() { return !!(NewKeyState.SCROLLLOCK && !OldKeyState.SCROLLLOCK); }
-	bool GetPauseJustDown()      { return !!(NewKeyState.PAUSE && !OldKeyState.PAUSE); }
-	bool GetNumLockJustDown()    { return !!(NewKeyState.NUMLOCK && !OldKeyState.NUMLOCK); }
-	bool GetDivideJustDown()     { return !!(NewKeyState.DIV && !OldKeyState.DIV); }
-	bool GetTimesJustDown()      { return !!(NewKeyState.MUL && !OldKeyState.MUL); }
-	bool GetMinusJustDown()      { return !!(NewKeyState.SUB && !OldKeyState.SUB); }
-	bool GetPlusJustDown()       { return !!(NewKeyState.ADD && !OldKeyState.ADD); }
-	bool GetPadEnterJustDown()   { return !!(NewKeyState.ENTER && !OldKeyState.ENTER); } //  GetEnterJustDown
-	bool GetPadDelJustDown()     { return !!(NewKeyState.DECIMAL && !OldKeyState.DECIMAL); }
-	bool GetPad1JustDown()       { return !!(NewKeyState.NUM1 && !OldKeyState.NUM1); }
-	bool GetPad2JustDown()       { return !!(NewKeyState.NUM2 && !OldKeyState.NUM2); }
-	bool GetPad3JustDown()       { return !!(NewKeyState.NUM3 && !OldKeyState.NUM3); }
-	bool GetPad4JustDown()       { return !!(NewKeyState.NUM4 && !OldKeyState.NUM4); }
-	bool GetPad5JustDown()       { return !!(NewKeyState.NUM5 && !OldKeyState.NUM5); }
-	bool GetPad6JustDown()       { return !!(NewKeyState.NUM6 && !OldKeyState.NUM6); }
-	bool GetPad7JustDown()       { return !!(NewKeyState.NUM7 && !OldKeyState.NUM7); }
-	bool GetPad8JustDown()       { return !!(NewKeyState.NUM8 && !OldKeyState.NUM8); }
-	bool GetPad9JustDown()       { return !!(NewKeyState.NUM9 && !OldKeyState.NUM9); }
-	bool GetPad0JustDown()       { return !!(NewKeyState.NUM0 && !OldKeyState.NUM0); }
-	bool GetBackspaceJustDown()  { return !!(NewKeyState.BACKSP && !OldKeyState.BACKSP); }
-	bool GetTabJustDown()        { return !!(NewKeyState.TAB && !OldKeyState.TAB); }
-	bool GetCapsLockJustDown()   { return !!(NewKeyState.CAPSLOCK && !OldKeyState.CAPSLOCK); }
-	bool GetEnterJustDown()      { return !!(NewKeyState.EXTENTER && !OldKeyState.EXTENTER); }
-	bool GetLeftShiftJustDown()  { return !!(NewKeyState.LSHIFT && !OldKeyState.LSHIFT); }
-	bool GetShiftJustDown()      { return !!(NewKeyState.SHIFT && !OldKeyState.SHIFT); }
-	bool GetRightShiftJustDown() { return !!(NewKeyState.RSHIFT && !OldKeyState.RSHIFT); }
-	bool GetLeftCtrlJustDown()   { return !!(NewKeyState.LCTRL && !OldKeyState.LCTRL); }
-	bool GetRightCtrlJustDown()  { return !!(NewKeyState.RCTRL && !OldKeyState.RCTRL); }
-	bool GetLeftAltJustDown()    { return !!(NewKeyState.LALT && !OldKeyState.LALT); }
-	bool GetRightAltJustDown()   { return !!(NewKeyState.RALT && !OldKeyState.RALT); }
-	bool GetLeftWinJustDown()    { return !!(NewKeyState.LWIN && !OldKeyState.LWIN); }
-	bool GetRightWinJustDown()   { return !!(NewKeyState.RWIN && !OldKeyState.RWIN); }
-	bool GetAppsJustDown()       { return !!(NewKeyState.APPS && !OldKeyState.APPS); }
-	
+	bool GetFJustDown(int32 n)    { return !!(NewKeyState.F[n] && !OldKeyState.F[n]); }
+	bool GetEscapeJustDown()      { return !!(NewKeyState.ESC && !OldKeyState.ESC); }
+	bool GetInsertJustDown()      { return !!(NewKeyState.INS && !OldKeyState.INS); }
+	bool GetDeleteJustDown()      { return !!(NewKeyState.DEL && !OldKeyState.DEL); }
+	bool GetHomeJustDown()        { return !!(NewKeyState.HOME && !OldKeyState.HOME); }
+	bool GetEndJustDown()         { return !!(NewKeyState.END && !OldKeyState.END); }
+	bool GetPageUpJustDown()      { return !!(NewKeyState.PGUP && !OldKeyState.PGUP); }
+	bool GetPageDownJustDown()    { return !!(NewKeyState.PGDN && !OldKeyState.PGDN); }
+	bool GetUpJustDown()          { return !!(NewKeyState.UP && !OldKeyState.UP); }
+	bool GetDownJustDown()        { return !!(NewKeyState.DOWN && !OldKeyState.DOWN); }
+	bool GetLeftJustDown()        { return !!(NewKeyState.LEFT && !OldKeyState.LEFT); }
+	bool GetRightJustDown()       { return !!(NewKeyState.RIGHT && !OldKeyState.RIGHT); }
+	bool GetScrollLockJustDown()  { return !!(NewKeyState.SCROLLLOCK && !OldKeyState.SCROLLLOCK); }
+	bool GetPauseJustDown()       { return !!(NewKeyState.PAUSE && !OldKeyState.PAUSE); }
+	bool GetNumLockJustDown()     { return !!(NewKeyState.NUMLOCK && !OldKeyState.NUMLOCK); }
+	bool GetDivideJustDown()      { return !!(NewKeyState.DIV && !OldKeyState.DIV); }
+	bool GetTimesJustDown()       { return !!(NewKeyState.MUL && !OldKeyState.MUL); }
+	bool GetMinusJustDown()       { return !!(NewKeyState.SUB && !OldKeyState.SUB); }
+	bool GetPlusJustDown()        { return !!(NewKeyState.ADD && !OldKeyState.ADD); }
+	bool GetPadEnterJustDown()    { return !!(NewKeyState.ENTER && !OldKeyState.ENTER); } //  GetEnterJustDown
+	bool GetPadDelJustDown()      { return !!(NewKeyState.DECIMAL && !OldKeyState.DECIMAL); }
+	bool GetPad1JustDown()        { return !!(NewKeyState.NUM1 && !OldKeyState.NUM1); }
+	bool GetPad2JustDown()        { return !!(NewKeyState.NUM2 && !OldKeyState.NUM2); }
+	bool GetPad3JustDown()        { return !!(NewKeyState.NUM3 && !OldKeyState.NUM3); }
+	bool GetPad4JustDown()        { return !!(NewKeyState.NUM4 && !OldKeyState.NUM4); }
+	bool GetPad5JustDown()        { return !!(NewKeyState.NUM5 && !OldKeyState.NUM5); }
+	bool GetPad6JustDown()        { return !!(NewKeyState.NUM6 && !OldKeyState.NUM6); }
+	bool GetPad7JustDown()        { return !!(NewKeyState.NUM7 && !OldKeyState.NUM7); }
+	bool GetPad8JustDown()        { return !!(NewKeyState.NUM8 && !OldKeyState.NUM8); }
+	bool GetPad9JustDown()        { return !!(NewKeyState.NUM9 && !OldKeyState.NUM9); }
+	bool GetPad0JustDown()        { return !!(NewKeyState.NUM0 && !OldKeyState.NUM0); }
+	bool GetBackspaceJustDown()   { return !!(NewKeyState.BACKSP && !OldKeyState.BACKSP); }
+	bool GetTabJustDown()         { return !!(NewKeyState.TAB && !OldKeyState.TAB); }
+	bool GetCapsLockJustDown()    { return !!(NewKeyState.CAPSLOCK && !OldKeyState.CAPSLOCK); }
+	bool GetEnterJustDown()       { return !!(NewKeyState.EXTENTER && !OldKeyState.EXTENTER); }
+	bool GetLeftShiftJustDown()   { return !!(NewKeyState.LSHIFT && !OldKeyState.LSHIFT); }
+	bool GetShiftJustDown()       { return !!(NewKeyState.SHIFT && !OldKeyState.SHIFT); }
+	bool GetRightShiftJustDown()  { return !!(NewKeyState.RSHIFT && !OldKeyState.RSHIFT); }
+	bool GetLeftCtrlJustDown()    { return !!(NewKeyState.LCTRL && !OldKeyState.LCTRL); }
+	bool GetRightCtrlJustDown()   { return !!(NewKeyState.RCTRL && !OldKeyState.RCTRL); }
+	bool GetLeftAltJustDown()     { return !!(NewKeyState.LALT && !OldKeyState.LALT); }
+	bool GetRightAltJustDown()    { return !!(NewKeyState.RALT && !OldKeyState.RALT); }
+	bool GetLeftWinJustDown()     { return !!(NewKeyState.LWIN && !OldKeyState.LWIN); }
+	bool GetRightWinJustDown()    { return !!(NewKeyState.RWIN && !OldKeyState.RWIN); }
+	bool GetAppsJustDown()        { return !!(NewKeyState.APPS && !OldKeyState.APPS); }
+								  
+	bool GetChar(int32 c)         { return NewKeyState.VK_KEYS[c]; }
+	bool GetF(int32 n)            { return NewKeyState.F[n]; }
+	bool GetEscape()              { return NewKeyState.ESC; }
+	bool GetInsert()              { return NewKeyState.INS; }
+	bool GetDelete()              { return NewKeyState.DEL; }
+	bool GetHome()                { return NewKeyState.HOME; }
+	bool GetEnd()                 { return NewKeyState.END; }
+	bool GetPageUp()              { return NewKeyState.PGUP; }
+	bool GetPageDown()            { return NewKeyState.PGDN; }
+	bool GetUp()                  { return NewKeyState.UP; }
+	bool GetDown()                { return NewKeyState.DOWN; }
+	bool GetLeft()                { return NewKeyState.LEFT; }
+	bool GetRight()               { return NewKeyState.RIGHT; }
+	bool GetScrollLock()          { return NewKeyState.SCROLLLOCK; }
+	bool GetPause()               { return NewKeyState.PAUSE; }
+	bool GetNumLock()             { return NewKeyState.NUMLOCK; }
+	bool GetDivide()              { return NewKeyState.DIV; }
+	bool GetTimes()               { return NewKeyState.MUL; }
+	bool GetMinus()               { return NewKeyState.SUB; }
+	bool GetPlus()                { return NewKeyState.ADD; }
+	bool GetPadEnter()            { return NewKeyState.ENTER; } //  GetEnterJustDown
+	bool GetPadDel()              { return NewKeyState.DECIMAL; }
+	bool GetPad1()                { return NewKeyState.NUM1; }
+	bool GetPad2()                { return NewKeyState.NUM2; }
+	bool GetPad3()                { return NewKeyState.NUM3; }
+	bool GetPad4()                { return NewKeyState.NUM4; }
+	bool GetPad5()                { return NewKeyState.NUM5; }
+	bool GetPad6()                { return NewKeyState.NUM6; }
+	bool GetPad7()                { return NewKeyState.NUM7; }
+	bool GetPad8()                { return NewKeyState.NUM8; }
+	bool GetPad9()                { return NewKeyState.NUM9; }
+	bool GetPad0()                { return NewKeyState.NUM0; }
+	bool GetBackspace()           { return NewKeyState.BACKSP; }
+	bool GetTab()                 { return NewKeyState.TAB; }
+	bool GetCapsLock()            { return NewKeyState.CAPSLOCK; }
+	bool GetEnter()               { return NewKeyState.EXTENTER; }
+	bool GetLeftShift()           { return NewKeyState.LSHIFT; }
+	bool GetShift()               { return NewKeyState.SHIFT; }
+	bool GetRightShift()          { return NewKeyState.RSHIFT; }
+	bool GetLeftCtrl()            { return NewKeyState.LCTRL; }
+	bool GetRightCtrl()           { return NewKeyState.RCTRL; }
+	bool GetLeftAlt()             { return NewKeyState.LALT; }
+	bool GetRightAlt()            { return NewKeyState.RALT; }
+	bool GetLeftWin()             { return NewKeyState.LWIN; }
+	bool GetRightWin()            { return NewKeyState.RWIN; }
+	bool GetApps()                { return NewKeyState.APPS; }
 	// pad
 
 	bool GetTriangleJustDown()       { return !!(NewState.Triangle && !OldState.Triangle); }
@@ -369,22 +387,15 @@ public:
 	bool GetRightShoulder1JustDown() { return !!(NewState.RightShoulder1 && !OldState.RightShoulder1); }
 	bool GetRightShoulder2JustDown() { return !!(NewState.RightShoulder2 && !OldState.RightShoulder2); }
 	bool GetStartJustDown()          { return !!(NewState.Start && !OldState.Start); }
-	
-/*
-	int32 GetLeftShoulder1(void)  { return NewState.LeftShoulder1; }
-	int32 GetLeftShoulder2(void)  { return NewState.LeftShoulder2; }
-	int32 GetRightShoulder1(void) { return NewState.RightShoulder1; }
-	int32 GetRightShoulder2(void) { return NewState.RightShoulder2; }
-*/
   
-	bool GetTriangle()       { return !!NewState.Triangle; }
-	bool GetCircle()         { return !!NewState.Circle; }
-	bool GetCross()          { return !!NewState.Cross; }
-	bool GetSquare()         { return !!NewState.Square; }
-	bool GetDPadUp()         { return !!NewState.DPadUp; }
-	bool GetDPadDown()       { return !!NewState.DPadDown; }
-	bool GetDPadLeft()       { return !!NewState.DPadLeft; }
-	bool GetDPadRight()      { return !!NewState.DPadRight; }
+	bool GetTriangle()           { return !!NewState.Triangle; }
+	bool GetCircle()             { return !!NewState.Circle; }
+	bool GetCross()              { return !!NewState.Cross; }
+	bool GetSquare()             { return !!NewState.Square; }
+	bool GetDPadUp()             { return !!NewState.DPadUp; }
+	bool GetDPadDown()           { return !!NewState.DPadDown; }
+	bool GetDPadLeft()           { return !!NewState.DPadLeft; }
+	bool GetDPadRight()          { return !!NewState.DPadRight; }
 	bool GetLeftShoulder1(void)  { return !!NewState.LeftShoulder1; }
 	bool GetLeftShoulder2(void)  { return !!NewState.LeftShoulder2; }
 	bool GetRightShoulder1(void) { return !!NewState.RightShoulder1; }
@@ -392,8 +403,6 @@ public:
 
   bool ArePlayerControlsDisabled(void) { return DisablePlayerControls != PLAYERCONTROL_ENABLED; }
 };
+
 VALIDATE_SIZE(CPad, 0xFC);
 extern CPad *Pads;	//[2]
-
-#define IsButtonJustDown(pad, btn) \
-	(!(pad)->OldState.btn && (pad)->NewState.btn)
diff --git a/src/core/Radar.cpp b/src/core/Radar.cpp
index 0d6cbc82..f1dbb8b4 100644
--- a/src/core/Radar.cpp
+++ b/src/core/Radar.cpp
@@ -275,7 +275,7 @@ void CRadar::DrawBlips()
 		TransformRadarPointToScreenSpace(out, in);
 
 		float angle;
-		if (TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_TOPDOWN1)
+		if (TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_TOPDOWN)
 			angle = PI + FindPlayerHeading();
 #ifdef FIX_BUGS
 		else if (TheCamera.GetLookDirection() != LOOKING_FORWARD)
@@ -1081,14 +1081,14 @@ void CRadar::TransformRadarPointToRealWorldSpace(CVector2D &out, const CVector2D
 	s = -Sin(TheCamera.GetForward().Heading());
 	c = Cos(TheCamera.GetForward().Heading());
 
-	if (TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_TOPDOWN1 || TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_TOPDOWNPED) {
+	if (TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_TOPDOWN || TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_TOP_DOWN_PED) {
 		s = 0.0f;
 		c = 1.0f;
 	}
 	else if (TheCamera.GetLookDirection() != LOOKING_FORWARD) {
 		CVector forward;
 
-		if (TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_FIRSTPERSON) {
+		if (TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_1STPERSON) {
 			forward = TheCamera.Cams[TheCamera.ActiveCam].CamTargetEntity->GetForward();
 			forward.Normalise();	// a bit useless...
 		}
@@ -1120,7 +1120,7 @@ WRAPPER void CRadar::TransformRealWorldPointToRadarSpace(CVector2D &out, const C
 void CRadar::TransformRealWorldPointToRadarSpace(CVector2D &out, const CVector2D &in)
 {
 	float s, c;
-	if (TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_TOPDOWN1 || TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_TOPDOWNPED) {
+	if (TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_TOPDOWN || TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_TOP_DOWN_PED) {
 		s = 0.0f;
 		c = 1.0f;
 	}
@@ -1131,7 +1131,7 @@ void CRadar::TransformRealWorldPointToRadarSpace(CVector2D &out, const CVector2D
 	else {
 		CVector forward;
 
-		if (TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_FIRSTPERSON) {
+		if (TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_1STPERSON) {
 			forward = TheCamera.Cams[TheCamera.ActiveCam].CamTargetEntity->GetForward();
 			forward.Normalise();	// a bit useless...
 		}
diff --git a/src/core/main.cpp b/src/core/main.cpp
index 8985d56a..8ac16d0e 100644
--- a/src/core/main.cpp
+++ b/src/core/main.cpp
@@ -379,9 +379,9 @@ Render2dStuff(void)
 	bool firstPersonWeapon = false;
 	int cammode = TheCamera.Cams[TheCamera.ActiveCam].Mode;
 	if(cammode == CCam::MODE_SNIPER ||
-	   cammode == CCam::MODE_SNIPER_RUN_AROUND ||
-	   cammode == CCam::MODE_ROCKET ||
-	   cammode == CCam::MODE_ROCKET_RUN_AROUND)
+	   cammode == CCam::MODE_SNIPER_RUNABOUT ||
+	   cammode == CCam::MODE_ROCKETLAUNCHER ||
+	   cammode == CCam::MODE_ROCKETLAUNCHER_RUNABOUT)
 		firstPersonWeapon = true;
 
 	// Draw black border for sniper and rocket launcher
diff --git a/src/peds/Ped.cpp b/src/peds/Ped.cpp
index 7ad79e32..0a76dcc5 100644
--- a/src/peds/Ped.cpp
+++ b/src/peds/Ped.cpp
@@ -4646,10 +4646,10 @@ CPed::SetAttack(CEntity *victim)
 			CPad::GetPad(0)->ResetAverageWeapon();
 
 		if ((curWeapon->m_eWeaponFire == WEAPON_FIRE_INSTANT_HIT || GetWeapon()->m_eWeaponType == WEAPONTYPE_FLAMETHROWER)
-			&& TheCamera.PlayerWeaponMode.Mode != CCam::MODE_M16FIRSTPERSON_34
-			&& TheCamera.PlayerWeaponMode.Mode != CCam::MODE_FIRSTPERSONPEDONPC_41
+			&& TheCamera.PlayerWeaponMode.Mode != CCam::MODE_M16_1STPERSON
+			&& TheCamera.PlayerWeaponMode.Mode != CCam::MODE_M16_1STPERSON_RUNABOUT
 			&& TheCamera.PlayerWeaponMode.Mode != CCam::MODE_SNIPER
-			&& TheCamera.PlayerWeaponMode.Mode != CCam::MODE_SNIPER_RUN_AROUND
+			&& TheCamera.PlayerWeaponMode.Mode != CCam::MODE_SNIPER_RUNABOUT
 			&& CheckForPointBlankPeds(victimPed) != 0) {
 			ClearAimFlag();
 
@@ -9191,10 +9191,10 @@ CPed::ProcessControl(void)
 								if (!nearPed->bIsLooking && nearPed->m_nPedState != PED_ATTACK) {
 									int16 camMode = TheCamera.Cams[TheCamera.ActiveCam].Mode;
 									if (camMode != CCam::MODE_SNIPER
-										&& camMode != CCam::MODE_ROCKET
-										&& camMode != CCam::MODE_M16FIRSTPERSON_34
-										&& camMode != CCam::MODE_FIRSTPERSON
-										&& camMode != CCam::MODE_M16FIRSTPERSON_44
+										&& camMode != CCam::MODE_ROCKETLAUNCHER
+										&& camMode != CCam::MODE_M16_1STPERSON
+										&& camMode != CCam::MODE_1STPERSON
+										&& camMode != CCam::MODE_HELICANNON_1STPERSON
 										&& !TheCamera.Cams[TheCamera.ActiveCam].GetWeaponFirstPersonOn()) {
 
 										nearPed->SetLookFlag(this, true);
@@ -10333,7 +10333,7 @@ CPed::ProcessControl(void)
 						lbAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_CAR_LB);
 
 						if (lbAssoc &&
-							TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_FIRSTPERSON
+							TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_1STPERSON
 							&& TheCamera.Cams[TheCamera.ActiveCam].DirectionWasLooking == LOOKING_LEFT) {
 							lbAssoc->blendDelta = -1000.0f;
 						}
@@ -10378,7 +10378,7 @@ CPed::ProcessControl(void)
 							lbAssoc->blendDelta = -4.0f;
 					} else {
 
-						if ((TheCamera.Cams[TheCamera.ActiveCam].Mode != CCam::MODE_FIRSTPERSON
+						if ((TheCamera.Cams[TheCamera.ActiveCam].Mode != CCam::MODE_1STPERSON
 							|| TheCamera.Cams[TheCamera.ActiveCam].DirectionWasLooking != LOOKING_LEFT)
 							&& (!lbAssoc || lbAssoc->blendAmount < 1.0f)) {
 							CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_CAR_LB, 4.0f);
diff --git a/src/render/Hud.cpp b/src/render/Hud.cpp
index aa728a5e..7c8b157c 100644
--- a/src/render/Hud.cpp
+++ b/src/render/Hud.cpp
@@ -121,15 +121,15 @@ void CHud::Draw()
 		int32 WeaponType = CWorld::Players[CWorld::PlayerInFocus].m_pPed->m_weapons[CWorld::Players[CWorld::PlayerInFocus].m_pPed->m_currentWeapon].m_eWeaponType;
 		int32 Mode = TheCamera.Cams[TheCamera.ActiveCam].Mode;
 
-		if (Mode == CCam::MODE_SNIPER || Mode == CCam::MODE_ROCKET || Mode == CCam::MODE_M16FIRSTPERSON_34 || Mode == CCam::MODE_EDITOR)
+		if (Mode == CCam::MODE_SNIPER || Mode == CCam::MODE_ROCKETLAUNCHER || Mode == CCam::MODE_M16_1STPERSON || Mode == CCam::MODE_EDITOR)
 			Mode_FirstPerson = 1;
-		if (Mode == CCam::MODE_FIRSTPERSONPEDONPC_41 || Mode == CCam::MODE_SNIPER_RUN_AROUND)
+		if (Mode == CCam::MODE_M16_1STPERSON_RUNABOUT || Mode == CCam::MODE_SNIPER_RUNABOUT)
 			Mode_RunAround = 1;
 
 		/*
 			Draw Crosshairs
 		*/
-		if (TheCamera.Cams->Using3rdPersonMouseCam() && (!CPad::GetPad(0)->GetLookBehindForPed() || TheCamera.m_bPlayerIsInGarage) || Mode == CCam::MODE_FIRSTPERSONPEDONPC_40) {
+		if (TheCamera.Cams->Using3rdPersonMouseCam() && (!CPad::GetPad(0)->GetLookBehindForPed() || TheCamera.m_bPlayerIsInGarage) || Mode == CCam::MODE_1STPERSON_RUNABOUT) {
 			if (CWorld::Players[CWorld::PlayerInFocus].m_pPed) {
 				int32 State = CWorld::Players[CWorld::PlayerInFocus].m_pPed->m_nPedState;
 				if (State != PED_ENTER_CAR && State != PED_CARJACK) {
@@ -180,8 +180,8 @@ void CHud::Draw()
 				}
 			}
 			else {
-				if (Mode == CCam::MODE_M16FIRSTPERSON_34 ||
-				    Mode == CCam::MODE_FIRSTPERSONPEDONPC_41 ||
+				if (Mode == CCam::MODE_M16_1STPERSON ||
+				    Mode == CCam::MODE_M16_1STPERSON_RUNABOUT ||
 				    Mode == CCam::MODE_EDITOR) {
 					rect.left = (SCREEN_WIDTH / 2) - SCREEN_SCALE_X(32.0f);
 					rect.top = (SCREEN_HEIGHT / 2) - SCREEN_SCALE_Y(32.0f);
@@ -189,7 +189,7 @@ void CHud::Draw()
 					rect.bottom = (SCREEN_HEIGHT / 2) + SCREEN_SCALE_Y(32.0f);
 					Sprites[HUD_SITEM16].Draw(CRect(rect), CRGBA(255, 255, 255, 255));
 				}
-				else if (Mode == CCam::MODE_ROCKET_RUN_AROUND) {
+				else if (Mode == CCam::MODE_ROCKETLAUNCHER_RUNABOUT) {
 					rect.left = (SCREEN_WIDTH / 2) - SCREEN_SCALE_X(32.0f * 0.7f);
 					rect.top = (SCREEN_HEIGHT / 2) - SCREEN_SCALE_Y(32.0f * 0.7f);
 					rect.right = (SCREEN_WIDTH / 2) + SCREEN_SCALE_X(32.0f * 0.7f);
@@ -197,7 +197,7 @@ void CHud::Draw()
 
 					Sprites[HUD_SITEM16].Draw(CRect(rect), CRGBA(255, 255, 255, 255));
 				}
-				else if (Mode == CCam::MODE_ROCKET || Mode == CCam::MODE_SNIPER_RUN_AROUND) {
+				else if (Mode == CCam::MODE_ROCKETLAUNCHER || Mode == CCam::MODE_SNIPER_RUNABOUT) {
 					RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void *)TRUE);
 					RwRenderStateSet(rwRENDERSTATESRCBLEND, (void *)rwBLENDONE);
 					RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void *)rwBLENDONE);
diff --git a/src/render/Renderer.cpp b/src/render/Renderer.cpp
index 99d50e8f..562d5882 100644
--- a/src/render/Renderer.cpp
+++ b/src/render/Renderer.cpp
@@ -353,7 +353,7 @@ CRenderer::SetupEntityVisibility(CEntity *ent)
 	}else{
 		if(mi->m_type != MITYPE_SIMPLE){
 			if(FindPlayerVehicle() == ent &&
-			   TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_FIRSTPERSON){
+			   TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_1STPERSON){
 				// Player's vehicle in first person mode
 				if(TheCamera.Cams[TheCamera.ActiveCam].DirectionWasLooking == LOOKING_FORWARD ||
 				   ent->GetModelIndex() == MI_RHINO ||
@@ -642,8 +642,8 @@ CRenderer::ScanWorld(void)
 	RwV3dTransformPoints((RwV3d*)vectors, (RwV3d*)vectors, 9, cammatrix);
 
 	m_loadingPriority = false;
-	if(TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_TOPDOWN1 ||
-	   TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_TOPDOWNPED){
+	if(TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_TOPDOWN ||
+	   TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_TOP_DOWN_PED){
 		CRect rect;
 		int x1, x2, y1, y2;
 		LimitFrustumVector(vectors[CORNER_FAR_TOPLEFT], vectors[CORNER_CAM], -100.0f);
@@ -753,8 +753,8 @@ CRenderer::RequestObjectsInFrustum(void)
 	vectors[CORNER_PRIO_RIGHT].z = vectors[CORNER_LOD_RIGHT].z;
 	RwV3dTransformPoints((RwV3d*)vectors, (RwV3d*)vectors, 9, cammatrix);
 
-	if(TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_TOPDOWN1 ||
-	   TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_TOPDOWNPED){
+	if(TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_TOPDOWN ||
+	   TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_TOP_DOWN_PED){
 		CRect rect;
 		int x1, x2, y1, y2;
 		LimitFrustumVector(vectors[CORNER_FAR_TOPLEFT], vectors[CORNER_CAM], -100.0f);
diff --git a/src/render/Shadows.cpp b/src/render/Shadows.cpp
index 4d2e4605..5b6bb976 100644
--- a/src/render/Shadows.cpp
+++ b/src/render/Shadows.cpp
@@ -532,8 +532,8 @@ CShadows::StoreCarLightShadow(CAutomobile *pCar, int32 nID, RwTexture *pTexture,
 
 	float fDistToCamSqr = (*pPosn - TheCamera.GetPosition()).MagnitudeSqr2D();
 
-	bool bSpecialCam =     TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_TOPDOWN1
-						|| TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_TOPDOWNPED
+	bool bSpecialCam =     TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_TOPDOWN
+						|| TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_TOP_DOWN_PED
 						|| CCutsceneMgr::IsRunning();
 
 	float fDrawDistance = 27.0f;
diff --git a/src/render/VisibilityPlugins.cpp b/src/render/VisibilityPlugins.cpp
index e42c9df0..bbaa08ce 100644
--- a/src/render/VisibilityPlugins.cpp
+++ b/src/render/VisibilityPlugins.cpp
@@ -98,8 +98,8 @@ CVisibilityPlugins::SetRenderWareCamera(RwCamera *camera)
 	ms_pCamera = camera;
 	ms_pCameraPosn = RwMatrixGetPos(RwFrameGetMatrix(RwCameraGetFrame(camera)));
 
-	if(TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_TOPDOWN1 ||
-	   TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_TOPDOWNPED)
+	if(TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_TOPDOWN ||
+	   TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_TOP_DOWN_PED)
 		ms_cullCompsDist = 1000000.0f;
 	else
 		ms_cullCompsDist = sq(TheCamera.LODDistMultiplier * 20.0f);
diff --git a/src/skel/skeleton.h b/src/skel/skeleton.h
index e357905d..6bf8d2fd 100644
--- a/src/skel/skeleton.h
+++ b/src/skel/skeleton.h
@@ -180,6 +180,14 @@ enum RsKeyCodes
 	rsAPPS           = 1055,
 	
 	rsNULL           = 1056,
+
+	rsMOUSELEFTBUTTON      = 1,
+	rsMOUSMIDDLEBUTTON     = 2,
+	rsMOUSERIGHTBUTTON     = 3,
+	rsMOUSEWHEELUPBUTTON   = 4,
+	rsMOUSEWHEELDOWNBUTTON = 5,
+	rsMOUSEX1BUTTON        = 6,
+	rsMOUSEX2BUTTON        = 7,
 };
 typedef enum RsKeyCodes RsKeyCodes;
 
diff --git a/src/skel/win/win.cpp b/src/skel/win/win.cpp
index 4da63fe6..89726ed2 100644
--- a/src/skel/win/win.cpp
+++ b/src/skel/win/win.cpp
@@ -115,38 +115,11 @@ DWORD _dwMemAvailVideo;
 DWORD &_dwOperatingSystemVersion = *(DWORD*)0x70F290;
 
 RwUInt32 &gGameState = *(RwUInt32*)0x8F5838;
-
-enum eJoypadState
-{
-	JOYPAD_UNUSED,
-	JOYPAD_ATTACHED,
-};
-
-struct tJoy
-{
-	eJoypadState m_State;
-	bool m_bInitialised;
-	bool m_bHasAxisZ;
-	bool m_bHasAxisR;
-	char _pad0;
-	int32 m_nVendorID;
-	int32 m_nProductID;
-};
-
-class CJoySticks
-{
-public:
-	tJoy m_aJoys[2];
-	
-	CJoySticks();
-	void ClearJoyInfo(int joyID);
-};
-
-static CJoySticks AllValidWinJoys;
+CJoySticks AllValidWinJoys;
 
 CJoySticks::CJoySticks()
 {
-	for (int i = 0; i < _TODOCONST(2); i++)
+	for (int i = 0; i < MAX_JOYSTICKS; i++)
 	{
 		ClearJoyInfo(i);
 	}
@@ -154,7 +127,6 @@ CJoySticks::CJoySticks()
 
 void CJoySticks::ClearJoyInfo(int joyID)
 {
-	
 	m_aJoys[joyID].m_State = JOYPAD_UNUSED;
 	m_aJoys[joyID].m_bInitialised = false;
 	m_aJoys[joyID].m_bHasAxisZ = false;
@@ -641,14 +613,14 @@ psInitialise(void)
 	
 	GetVersionEx(&verInfo);
 	
-	_dwOperatingSystemVersion = 0;
+	_dwOperatingSystemVersion = OS_WIN95;
 	
 	if ( verInfo.dwPlatformId == VER_PLATFORM_WIN32_NT )
 	{
 		if ( verInfo.dwMajorVersion == 4 )
 		{
 			debug("Operating System is WinNT\n");
-			_dwOperatingSystemVersion = oS_WINNT;
+			_dwOperatingSystemVersion = OS_WINNT;
 		}
 		else if ( verInfo.dwMajorVersion == 5 )
 		{
@@ -2337,12 +2309,12 @@ HRESULT CapturePad(RwInt32 padID)
 	if( FAILED( hr = (*pPad)->GetDeviceState( sizeof(DIJOYSTATE2), &js ) ) )
 		return hr; // The device should have been acquired during the Poll()
 	
-	if ( ControlsManager.firstCapture == true )
+	if ( ControlsManager.m_bFirstCapture == true )
 	{
 		memcpy(&ControlsManager.m_OldState, &js, sizeof(DIJOYSTATE2));
 		memcpy(&ControlsManager.m_NewState, &js, sizeof(DIJOYSTATE2));
 		
-		ControlsManager.firstCapture = false;
+		ControlsManager.m_bFirstCapture = false;
 	}
 	else
 	{
diff --git a/src/skel/win/win.h b/src/skel/win/win.h
index ae2c7eec..242438ea 100644
--- a/src/skel/win/win.h
+++ b/src/skel/win/win.h
@@ -24,11 +24,13 @@ enum eWinVersion
 {
 	OS_WIN95 = 0,
 	OS_WIN98,
-	oS_WINNT,
+	OS_WINNT,
 	OS_WIN2000,
 	OS_WINXP,
 };
 
+extern DWORD &_dwOperatingSystemVersion;
+
 extern RwUInt32 &gGameState;
 
 /* platform specfic global data */
@@ -50,6 +52,41 @@ psGlobalType;
 
 #define PSGLOBAL(var) (((psGlobalType *)(RsGlobal.ps))->var)
 
+enum eJoypads
+{
+	JOYSTICK1 = 0,
+	JOYSTICK2,
+	MAX_JOYSTICKS
+};
+
+enum eJoypadState
+{
+	JOYPAD_UNUSED,
+	JOYPAD_ATTACHED,
+};
+
+struct tJoy
+{
+	eJoypadState m_State;
+	bool         m_bInitialised;
+	bool         m_bHasAxisZ;
+	bool         m_bHasAxisR;
+	char _pad0;
+	int          m_nVendorID;
+	int          m_nProductID;
+};
+
+class CJoySticks
+{
+public:
+	tJoy m_aJoys[MAX_JOYSTICKS];
+	
+	CJoySticks();
+	void ClearJoyInfo(int joyID);
+};
+
+extern CJoySticks AllValidWinJoys;
+
 #ifdef    __cplusplus
 extern "C"
 {
diff --git a/src/vehicles/Automobile.cpp b/src/vehicles/Automobile.cpp
index 12c9c940..0fa8547e 100644
--- a/src/vehicles/Automobile.cpp
+++ b/src/vehicles/Automobile.cpp
@@ -2934,7 +2934,7 @@ CAutomobile::DoDriveByShootings(void)
 
 	bool lookingLeft = false;
 	bool lookingRight = false;
-	if(TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_TOPDOWN1){
+	if(TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_TOPDOWN){
 		if(CPad::GetPad(0)->GetLookLeft())
 			lookingLeft = true;
 		if(CPad::GetPad(0)->GetLookRight())
@@ -2956,7 +2956,7 @@ CAutomobile::DoDriveByShootings(void)
 				CAnimManager::AddAnimation(pDriver->GetClump(), ASSOCGRP_STD, ANIM_DRIVEBY_L);
 			else
 				anim->SetRun();
-		}else if(pDriver->m_pMyVehicle->pPassengers[0] == nil || TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_FIRSTPERSON){
+		}else if(pDriver->m_pMyVehicle->pPassengers[0] == nil || TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_1STPERSON){
 			anim = RpAnimBlendClumpGetAssociation(pDriver->GetClump(), ANIM_DRIVEBY_L);
 			if(anim)
 				anim->blendDelta = -1000.0f;