summaryrefslogtreecommitdiffstats
path: root/src/core
diff options
context:
space:
mode:
Diffstat (limited to 'src/core')
-rw-r--r--src/core/Camera.cpp10
-rw-r--r--src/core/Camera.h59
-rw-r--r--src/core/ControllerConfig.cpp2478
-rw-r--r--src/core/ControllerConfig.h244
-rw-r--r--src/core/Frontend.cpp2
-rw-r--r--src/core/Frontend.h9
-rw-r--r--src/core/Pad.h243
-rw-r--r--src/core/Radar.cpp10
-rw-r--r--src/core/main.cpp6
9 files changed, 2795 insertions, 266 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
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-19 00:05:19 +0100