Rim/iw4x-client
Rim/iw4x-client
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 2 Wiki Activity

[General]: Re-order some dvars (#748)

Browse Source
This commit is contained in:
Edo 2023-02-03 14:13:51 +00:00 committed by GitHub
parent a468cdfae9
commit ea2a0d9114
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
6 changed files with 249 additions and 199 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

347
src/Components/Modules/Gamepad.cpp
View File

@ -314,11 +314,11 @@ namespace Components
} }
} }
bool Gamepad::GPad_Check(const int gamePadIndex, const int portIndex) bool Gamepad::GPad_Check(const int localClientNum, const int portIndex)
{ {
AssertIn(gamePadIndex, Game::MAX_GPAD_COUNT); AssertIn(localClientNum, Game::MAX_GPAD_COUNT);
auto& gamePad = gamePads[gamePadIndex]; auto& gamePad = gamePads[localClientNum];
if (XInputGetCapabilities(portIndex, XINPUT_FLAG_GAMEPAD, &gamePad.caps) == ERROR_SUCCESS) if (XInputGetCapabilities(portIndex, XINPUT_FLAG_GAMEPAD, &gamePad.caps) == ERROR_SUCCESS)
{ {
@ -422,11 +422,11 @@ namespace Components
return AimAssist_GetBestTarget(aaGlob, range, regionWidth, regionHeight); return AimAssist_GetBestTarget(aaGlob, range, regionWidth, regionHeight);
} }
bool Gamepad::AimAssist_IsLockonActive(const int gamePadIndex) bool Gamepad::AimAssist_IsLockonActive(const int localClientNum)
{ {
AssertIn(gamePadIndex, Game::MAX_GPAD_COUNT); AssertIn(localClientNum, Game::MAX_GPAD_COUNT);
auto& aaGlob = Game::aaGlobArray[gamePadIndex]; auto& aaGlob = Game::aaGlobArray[localClientNum];
if (!aim_lockon_enabled.get<bool>() || !gpad_lockon_enabled.get<bool>()) if (!aim_lockon_enabled.get<bool>() || !gpad_lockon_enabled.get<bool>())
return false; return false;
@ -793,11 +793,11 @@ namespace Components
return !Game::Key_IsCatcherActive(localClientNum, Game::KEYCATCH_MASK_ANY) || Game::UI_GetActiveMenu(localClientNum) == Game::UIMENU_SCOREBOARD; return !Game::Key_IsCatcherActive(localClientNum, Game::KEYCATCH_MASK_ANY) || Game::UI_GetActiveMenu(localClientNum) == Game::UIMENU_SCOREBOARD;
} }
float Gamepad::CL_GamepadAxisValue(const int gamePadIndex, const Game::GamepadVirtualAxis virtualAxis) float Gamepad::CL_GamepadAxisValue(const int localClientNum, const Game::GamepadVirtualAxis virtualAxis)
{ {
assert(virtualAxis > Game::GPAD_VIRTAXIS_NONE && virtualAxis < Game::GPAD_VIRTAXIS_COUNT); assert(virtualAxis > Game::GPAD_VIRTAXIS_NONE && virtualAxis < Game::GPAD_VIRTAXIS_COUNT);
const auto& gamePadGlobal = gamePadGlobals[gamePadIndex]; const auto& gamePadGlobal = gamePadGlobals[localClientNum];
const auto& [physicalAxis, mapType] = gamePadGlobal.axes.virtualAxes[virtualAxis]; const auto& [physicalAxis, mapType] = gamePadGlobal.axes.virtualAxes[virtualAxis];
@ -827,26 +827,23 @@ namespace Components
return static_cast<char>(std::clamp<int>(value, std::numeric_limits<char>::min(), std::numeric_limits<char>::max())); return static_cast<char>(std::clamp<int>(value, std::numeric_limits<char>::min(), std::numeric_limits<char>::max()));
} }
void Gamepad::CL_GamepadMove(const int gamePadIndex, Game::usercmd_s* cmd, const float frameTimeBase) void Gamepad::CL_GamepadMove(const int localClientNum, const float frameTimeBase, Game::usercmd_s* cmd)
{ {
AssertIn(gamePadIndex, Game::MAX_GPAD_COUNT); AssertIn(localClientNum, Game::MAX_GPAD_COUNT);
auto& gamePad = gamePads[gamePadIndex]; auto& gamePad = gamePads[localClientNum];
auto& clientActive = Game::clients[gamePadIndex]; auto& clientActive = Game::clients[localClientNum];
if (!gpad_enabled.get<bool>() || !gamePad.enabled) auto pitch = CL_GamepadAxisValue(localClientNum, Game::GPAD_VIRTAXIS_PITCH);
return;
auto pitch = CL_GamepadAxisValue(gamePadIndex, Game::GPAD_VIRTAXIS_PITCH);
if (!input_invertPitch.get<bool>()) if (!input_invertPitch.get<bool>())
pitch *= -1; pitch *= -1;
auto yaw = -CL_GamepadAxisValue(gamePadIndex, Game::GPAD_VIRTAXIS_YAW); auto yaw = -CL_GamepadAxisValue(localClientNum, Game::GPAD_VIRTAXIS_YAW);
auto forward = CL_GamepadAxisValue(gamePadIndex, Game::GPAD_VIRTAXIS_FORWARD); auto forward = CL_GamepadAxisValue(localClientNum, Game::GPAD_VIRTAXIS_FORWARD);
auto side = CL_GamepadAxisValue(gamePadIndex, Game::GPAD_VIRTAXIS_SIDE); auto side = CL_GamepadAxisValue(localClientNum, Game::GPAD_VIRTAXIS_SIDE);
// The game implements an attack axis at this location. This axis is unused however so for this patch it was not implemented. // The game implements an attack axis at this location. This axis is unused however so for this patch it was not implemented.
//auto attack = CL_GamepadAxisValue(gamePadIndex, Game::GPAD_VIRTAXIS_ATTACK); //auto attack = CL_GamepadAxisValue(localClientNum, Game::GPAD_VIRTAXIS_ATTACK);
auto moveScale = static_cast<float>(std::numeric_limits<char>::max()); auto moveScale = static_cast<float>(std::numeric_limits<char>::max());
@ -865,7 +862,7 @@ namespace Components
cmd->forwardmove = ClampChar(cmd->forwardmove + forwardMove); cmd->forwardmove = ClampChar(cmd->forwardmove + forwardMove);
// Swap attack and throw buttons when using controller and akimbo to match "left trigger"="left weapon" and "right trigger"="right weapon" // Swap attack and throw buttons when using controller and akimbo to match "left trigger"="left weapon" and "right trigger"="right weapon"
if(gamePad.inUse && clientActive.snap.ps.weapCommon.lastWeaponHand == Game::WEAPON_HAND_LEFT) if (gamePad.inUse && clientActive.snap.ps.weapCommon.lastWeaponHand == Game::WEAPON_HAND_LEFT)
{ {
auto oldButtons = cmd->buttons; auto oldButtons = cmd->buttons;
if (oldButtons & Game::CMD_BUTTON_ATTACK) if (oldButtons & Game::CMD_BUTTON_ATTACK)
@ -880,13 +877,13 @@ namespace Components
} }
// Check for frozen controls. Flag name should start with PMF_ // Check for frozen controls. Flag name should start with PMF_
if (CG_ShouldUpdateViewAngles(gamePadIndex) && (clientActive.snap.ps.pm_flags & Game::PMF_FROZEN) == 0) if (CG_ShouldUpdateViewAngles(localClientNum) && (clientActive.snap.ps.pm_flags & Game::PMF_FROZEN) == 0)
{ {
Game::AimInput aimInput{}; Game::AimInput aimInput{};
Game::AimOutput aimOutput{}; Game::AimOutput aimOutput{};
aimInput.deltaTime = frameTimeBase; aimInput.deltaTime = frameTimeBase;
aimInput.buttons = cmd->buttons; aimInput.buttons = cmd->buttons;
aimInput.localClientNum = gamePadIndex; aimInput.localClientNum = localClientNum;
aimInput.deltaTimeScaled = static_cast<float>(Game::cls->frametime) * 0.001f; aimInput.deltaTimeScaled = static_cast<float>(Game::cls->frametime) * 0.001f;
aimInput.pitch = clientActive.clViewangles[0]; aimInput.pitch = clientActive.clViewangles[0];
aimInput.pitchAxis = pitch; aimInput.pitchAxis = pitch;
@ -902,23 +899,32 @@ namespace Components
} }
} }
constexpr auto CL_MouseMove = 0x5A6240; void Gamepad::CL_MouseMove(const int localClientNum, Game::usercmd_s* cmd, const float frametime_base)
{
auto& gamePad = gamePads[localClientNum];
if (!gamePad.inUse)
{
Game::CL_MouseMove(localClientNum, cmd, frametime_base);
}
else if (gpad_enabled.get<bool>() && gamePad.enabled)
{
CL_GamepadMove(localClientNum, frametime_base, cmd);
}
}
__declspec(naked) void Gamepad::CL_MouseMove_Stub() __declspec(naked) void Gamepad::CL_MouseMove_Stub()
{ {
__asm __asm
{ {
// Prepare args for our function call pushad
push [esp+0x4] // frametime_base
push [esp + 0x20 + 0x4] // frametime_base
push ebx // cmd push ebx // cmd
push eax // localClientNum push eax // localClientNum
push [esp+0x8] // restore frametime_base on the stack
call CL_MouseMove call CL_MouseMove
add esp,4 add esp, 0xC
// Call our function, the args were already prepared earlier popad
call CL_GamepadMove
add esp,0xC
ret ret
} }
@ -970,11 +976,11 @@ namespace Components
|| key >= Game::K_FIRSTGAMEPADBUTTON_RANGE_3 && key <= Game::K_LASTGAMEPADBUTTON_RANGE_3; || key >= Game::K_FIRSTGAMEPADBUTTON_RANGE_3 && key <= Game::K_LASTGAMEPADBUTTON_RANGE_3;
} }
void Gamepad::CL_GamepadResetMenuScrollTime(const int gamePadIndex, const int key, const bool down, const unsigned time) void Gamepad::CL_GamepadResetMenuScrollTime(const int localClientNum, const int key, const bool down, const unsigned time)
{ {
AssertIn(gamePadIndex, Game::MAX_GPAD_COUNT); AssertIn(localClientNum, Game::MAX_GPAD_COUNT);
auto& gamePadGlobal = gamePadGlobals[gamePadIndex]; auto& gamePadGlobal = gamePadGlobals[localClientNum];
if (!down) if (!down)
return; return;
@ -990,12 +996,12 @@ namespace Components
} }
} }
void Gamepad::CL_GamepadGenerateAPad(const int gamePadIndex, const Game::GamepadPhysicalAxis physicalAxis, unsigned time) void Gamepad::CL_GamepadGenerateAPad(const int localClientNum, const Game::GamepadPhysicalAxis physicalAxis, unsigned time)
{ {
AssertIn(gamePadIndex, Game::MAX_GPAD_COUNT); AssertIn(localClientNum, Game::MAX_GPAD_COUNT);
assert(physicalAxis >= 0 && physicalAxis < Game::GPAD_PHYSAXIS_COUNT); assert(physicalAxis >= 0 && physicalAxis < Game::GPAD_PHYSAXIS_COUNT);
auto& gamePad = gamePads[gamePadIndex]; auto& gamePad = gamePads[localClientNum];
const auto stick = stickForAxis[physicalAxis]; const auto stick = stickForAxis[physicalAxis];
const auto stickIndex = stick & Game::GPAD_VALUE_MASK; const auto stickIndex = stick & Game::GPAD_VALUE_MASK;
@ -1007,34 +1013,34 @@ namespace Components
if (gamePad.stickDown[stickIndex][Game::GPAD_STICK_POS]) if (gamePad.stickDown[stickIndex][Game::GPAD_STICK_POS])
{ {
const Game::GamePadButtonEvent event = gamePad.stickDownLast[stickIndex][Game::GPAD_STICK_POS] ? Game::GPAD_BUTTON_UPDATE : Game::GPAD_BUTTON_PRESSED; const Game::GamePadButtonEvent event = gamePad.stickDownLast[stickIndex][Game::GPAD_STICK_POS] ? Game::GPAD_BUTTON_UPDATE : Game::GPAD_BUTTON_PRESSED;
CL_GamepadButtonEvent(gamePadIndex, mapping.posCode, event, time); CL_GamepadButtonEvent(localClientNum, mapping.posCode, event, time);
} }
else if (gamePad.stickDown[stickIndex][Game::GPAD_STICK_NEG]) else if (gamePad.stickDown[stickIndex][Game::GPAD_STICK_NEG])
{ {
const Game::GamePadButtonEvent event = gamePad.stickDownLast[stickIndex][Game::GPAD_STICK_NEG] ? Game::GPAD_BUTTON_UPDATE : Game::GPAD_BUTTON_PRESSED; const Game::GamePadButtonEvent event = gamePad.stickDownLast[stickIndex][Game::GPAD_STICK_NEG] ? Game::GPAD_BUTTON_UPDATE : Game::GPAD_BUTTON_PRESSED;
CL_GamepadButtonEvent(gamePadIndex, mapping.negCode, event, time); CL_GamepadButtonEvent(localClientNum, mapping.negCode, event, time);
} }
else if (gamePad.stickDownLast[stickIndex][Game::GPAD_STICK_POS]) else if (gamePad.stickDownLast[stickIndex][Game::GPAD_STICK_POS])
{ {
CL_GamepadButtonEvent(gamePadIndex, mapping.posCode, Game::GPAD_BUTTON_RELEASED, time); CL_GamepadButtonEvent(localClientNum, mapping.posCode, Game::GPAD_BUTTON_RELEASED, time);
} }
else if (gamePad.stickDownLast[stickIndex][Game::GPAD_STICK_NEG]) else if (gamePad.stickDownLast[stickIndex][Game::GPAD_STICK_NEG])
{ {
CL_GamepadButtonEvent(gamePadIndex, mapping.negCode, Game::GPAD_BUTTON_RELEASED, time); CL_GamepadButtonEvent(localClientNum, mapping.negCode, Game::GPAD_BUTTON_RELEASED, time);
} }
} }
} }
void Gamepad::CL_GamepadEvent(const int gamePadIndex, const Game::GamepadPhysicalAxis physicalAxis, const float value, const unsigned time) void Gamepad::CL_GamepadEvent(const int localClientNum, const Game::GamepadPhysicalAxis physicalAxis, const float value, const unsigned time)
{ {
AssertIn(gamePadIndex, Game::MAX_GPAD_COUNT); AssertIn(localClientNum, Game::MAX_GPAD_COUNT);
assert(physicalAxis >= 0 && physicalAxis < Game::GPAD_PHYSAXIS_COUNT); assert(physicalAxis >= 0 && physicalAxis < Game::GPAD_PHYSAXIS_COUNT);
auto& gamePad = gamePads[gamePadIndex]; auto& gamePad = gamePads[localClientNum];
auto& gamePadGlobal = gamePadGlobals[gamePadIndex]; auto& gamePadGlobal = gamePadGlobals[localClientNum];
gamePadGlobal.axes.axesValues[physicalAxis] = value; gamePadGlobal.axes.axesValues[physicalAxis] = value;
CL_GamepadGenerateAPad(gamePadIndex, physicalAxis, time); CL_GamepadGenerateAPad(localClientNum, physicalAxis, time);
if (std::fabs(value) > 0.0f) if (std::fabs(value) > 0.0f)
{ {
@ -1043,12 +1049,12 @@ namespace Components
} }
} }
void Gamepad::UI_GamepadKeyEvent(const int gamePadIndex, const int key, const bool down) void Gamepad::UI_GamepadKeyEvent(const int localClientNum, const int key, const bool down)
{ {
// If we are currently capturing a key for menu bind inputs then do not map keys and pass to game // If we are currently capturing a key for menu bind inputs then do not map keys and pass to game
if (*Game::g_waitingForKey) if (*Game::g_waitingForKey)
{ {
Game::UI_KeyEvent(gamePadIndex, key, down); Game::UI_KeyEvent(localClientNum, key, down);
return; return;
} }
@ -1056,24 +1062,24 @@ namespace Components
{ {
if (mapping.controllerKey == key) if (mapping.controllerKey == key)
{ {
Game::UI_KeyEvent(gamePadIndex, mapping.pcKey, down); Game::UI_KeyEvent(localClientNum, mapping.pcKey, down);
return; return;
} }
} }
// No point in sending unmapped controller keystrokes to the key event handler since it doesn't know how to use it anyway // No point in sending unmapped controller keystrokes to the key event handler since it doesn't know how to use it anyway
// Game::UI_KeyEvent(gamePadIndex, key, down); // Game::UI_KeyEvent(localClientNum, key, down);
} }
bool Gamepad::Scoreboard_HandleInput(int gamePadIndex, int key) bool Gamepad::Scoreboard_HandleInput(int localClientNum, int key)
{ {
AssertIn(gamePadIndex, Game::STATIC_MAX_LOCAL_CLIENTS); AssertIn(localClientNum, Game::STATIC_MAX_LOCAL_CLIENTS);
auto& keyState = Game::playerKeys[gamePadIndex]; auto& keyState = Game::playerKeys[localClientNum];
if (keyState.keys[key].binding && strcmp(keyState.keys[key].binding, "togglescores") == 0) if (keyState.keys[key].binding && strcmp(keyState.keys[key].binding, "togglescores") == 0)
{ {
Game::Cbuf_AddText(gamePadIndex, "togglescores\n"); Game::Cbuf_AddText(localClientNum, "togglescores\n");
return true; return true;
} }
@ -1092,13 +1098,13 @@ namespace Components
} }
} }
bool Gamepad::CL_CheckForIgnoreDueToRepeat(const int gamePadIndex, const int key, const int repeatCount, const unsigned time) bool Gamepad::CL_CheckForIgnoreDueToRepeat(const int localClientNum, const int key, const int repeatCount, const unsigned time)
{ {
AssertIn(gamePadIndex, Game::STATIC_MAX_LOCAL_CLIENTS); AssertIn(localClientNum, Game::STATIC_MAX_LOCAL_CLIENTS);
auto& gamePadGlobal = gamePadGlobals[gamePadIndex]; auto& gamePadGlobal = gamePadGlobals[localClientNum];
if (Game::Key_IsCatcherActive(gamePadIndex, Game::KEYCATCH_UI)) if (Game::Key_IsCatcherActive(localClientNum, Game::KEYCATCH_UI))
{ {
const int scrollDelayFirst = gpad_menu_scroll_delay_first.get<int>(); const int scrollDelayFirst = gpad_menu_scroll_delay_first.get<int>();
const int scrollDelayRest = gpad_menu_scroll_delay_rest.get<int>(); const int scrollDelayRest = gpad_menu_scroll_delay_rest.get<int>();
@ -1126,14 +1132,14 @@ namespace Components
return repeatCount > 1; return repeatCount > 1;
} }
void Gamepad::CL_GamepadButtonEvent(const int gamePadIndex, const int key, const Game::GamePadButtonEvent buttonEvent, const unsigned time) void Gamepad::CL_GamepadButtonEvent(const int localClientNum, const int key, const Game::GamePadButtonEvent buttonEvent, const unsigned time)
{ {
AssertIn(gamePadIndex, Game::MAX_GPAD_COUNT); AssertIn(localClientNum, Game::MAX_GPAD_COUNT);
const auto pressed = buttonEvent == Game::GPAD_BUTTON_PRESSED; const auto pressed = buttonEvent == Game::GPAD_BUTTON_PRESSED;
const auto pressedOrUpdated = pressed || buttonEvent == Game::GPAD_BUTTON_UPDATE; const auto pressedOrUpdated = pressed || buttonEvent == Game::GPAD_BUTTON_UPDATE;
auto& keyState = Game::playerKeys[gamePadIndex]; auto& keyState = Game::playerKeys[localClientNum];
keyState.keys[key].down = pressedOrUpdated; keyState.keys[key].down = pressedOrUpdated;
if (pressedOrUpdated) if (pressedOrUpdated)
@ -1148,10 +1154,10 @@ namespace Components
keyState.anyKeyDown = 0; keyState.anyKeyDown = 0;
} }
if (pressedOrUpdated && CL_CheckForIgnoreDueToRepeat(gamePadIndex, key, keyState.keys[key].repeats, time)) if (pressedOrUpdated && CL_CheckForIgnoreDueToRepeat(localClientNum, key, keyState.keys[key].repeats, time))
return; return;
if (Game::Key_IsCatcherActive(gamePadIndex, Game::KEYCATCH_LOCATION_SELECTION) && pressedOrUpdated) if (Game::Key_IsCatcherActive(localClientNum, Game::KEYCATCH_LOCATION_SELECTION) && pressedOrUpdated)
{ {
if (key == Game::K_BUTTON_B || keyState.keys[key].binding && strcmp(keyState.keys[key].binding, "+actionslot 4") == 0) if (key == Game::K_BUTTON_B || keyState.keys[key].binding && strcmp(keyState.keys[key].binding, "+actionslot 4") == 0)
{ {
@ -1164,10 +1170,10 @@ namespace Components
return; return;
} }
const auto activeMenu = Game::UI_GetActiveMenu(gamePadIndex); const auto activeMenu = Game::UI_GetActiveMenu(localClientNum);
if(activeMenu == Game::UIMENU_SCOREBOARD) if(activeMenu == Game::UIMENU_SCOREBOARD)
{ {
if (buttonEvent == Game::GPAD_BUTTON_PRESSED && Scoreboard_HandleInput(gamePadIndex, key)) if (buttonEvent == Game::GPAD_BUTTON_PRESSED && Scoreboard_HandleInput(localClientNum, key))
return; return;
} }
@ -1178,9 +1184,9 @@ namespace Components
char cmd[1024]; char cmd[1024];
if (pressedOrUpdated) if (pressedOrUpdated)
{ {
if (Game::Key_IsCatcherActive(gamePadIndex, Game::KEYCATCH_UI)) if (Game::Key_IsCatcherActive(localClientNum, Game::KEYCATCH_UI))
{ {
UI_GamepadKeyEvent(gamePadIndex, key, pressedOrUpdated); UI_GamepadKeyEvent(localClientNum, key, pressedOrUpdated);
return; return;
} }
@ -1189,11 +1195,11 @@ namespace Components
if (keyBinding[0] == '+') if (keyBinding[0] == '+')
{ {
sprintf_s(cmd, "%s %i %i\n", keyBinding, key, time); sprintf_s(cmd, "%s %i %i\n", keyBinding, key, time);
Game::Cbuf_AddText(gamePadIndex, cmd); Game::Cbuf_AddText(localClientNum, cmd);
} }
else else
{ {
Game::Cbuf_InsertText(gamePadIndex, keyBinding); Game::Cbuf_InsertText(localClientNum, keyBinding);
} }
} }
} }
@ -1202,29 +1208,29 @@ namespace Components
if (keyBinding && keyBinding[0] == '+') if (keyBinding && keyBinding[0] == '+')
{ {
sprintf_s(cmd, "-%s %i %i\n", &keyBinding[1], key, time); sprintf_s(cmd, "-%s %i %i\n", &keyBinding[1], key, time);
Game::Cbuf_AddText(gamePadIndex, cmd); Game::Cbuf_AddText(localClientNum, cmd);
} }
if (Game::Key_IsCatcherActive(gamePadIndex, Game::KEYCATCH_UI)) if (Game::Key_IsCatcherActive(localClientNum, Game::KEYCATCH_UI))
{ {
UI_GamepadKeyEvent(gamePadIndex, key, pressedOrUpdated); UI_GamepadKeyEvent(localClientNum, key, pressedOrUpdated);
} }
} }
} }
void Gamepad::CL_GamepadButtonEventForPort(const int gamePadIndex, const int key, const Game::GamePadButtonEvent buttonEvent, const unsigned time) void Gamepad::CL_GamepadButtonEventForPort(const int localClientNum, const int key, const Game::GamePadButtonEvent buttonEvent, const unsigned time)
{ {
AssertIn(gamePadIndex, Game::MAX_GPAD_COUNT); AssertIn(localClientNum, Game::MAX_GPAD_COUNT);
auto& gamePad = gamePads[gamePadIndex]; auto& gamePad = gamePads[localClientNum];
gamePad.inUse = true; gamePad.inUse = true;
gpad_in_use.setRaw(true); gpad_in_use.setRaw(true);
if (Game::Key_IsCatcherActive(gamePadIndex, Game::KEYCATCH_UI)) if (Game::Key_IsCatcherActive(localClientNum, Game::KEYCATCH_UI))
CL_GamepadResetMenuScrollTime(gamePadIndex, key, buttonEvent == Game::GPAD_BUTTON_PRESSED, time); CL_GamepadResetMenuScrollTime(localClientNum, key, buttonEvent == Game::GPAD_BUTTON_PRESSED, time);
CL_GamepadButtonEvent(gamePadIndex, key, buttonEvent, time); CL_GamepadButtonEvent(localClientNum, key, buttonEvent, time);
} }
void Gamepad::GPad_ConvertStickToFloat(const short x, const short y, float& outX, float& outY) void Gamepad::GPad_ConvertStickToFloat(const short x, const short y, float& outX, float& outY)
@ -1257,20 +1263,20 @@ namespace Components
outY = stickVec[1] * len; outY = stickVec[1] * len;
} }
float Gamepad::GPad_GetStick(const int gamePadIndex, const Game::GamePadStick stick) float Gamepad::GPad_GetStick(const int localClientNum, const Game::GamePadStick stick)
{ {
AssertIn(gamePadIndex, Game::MAX_GPAD_COUNT); AssertIn(localClientNum, Game::MAX_GPAD_COUNT);
assert(stick & Game::GPAD_STICK_MASK); assert(stick & Game::GPAD_STICK_MASK);
auto& gamePad = gamePads[gamePadIndex]; auto& gamePad = gamePads[localClientNum];
return gamePad.sticks[stick]; return gamePad.sticks[stick];
} }
float Gamepad::GPad_GetButton(const int gamePadIndex, Game::GamePadButton button) float Gamepad::GPad_GetButton(const int localClientNum, Game::GamePadButton button)
{ {
AssertIn(gamePadIndex, Game::MAX_GPAD_COUNT); AssertIn(localClientNum, Game::MAX_GPAD_COUNT);
auto& gamePad = gamePads[gamePadIndex]; auto& gamePad = gamePads[localClientNum];
float value = 0.0f; float value = 0.0f;
@ -1291,12 +1297,12 @@ namespace Components
return value; return value;
} }
bool Gamepad::GPad_IsButtonPressed(const int gamePadIndex, Game::GamePadButton button) bool Gamepad::GPad_IsButtonPressed(const int localClientNum, Game::GamePadButton button)
{ {
AssertIn(gamePadIndex, Game::MAX_GPAD_COUNT); AssertIn(localClientNum, Game::MAX_GPAD_COUNT);
assert(button & (Game::GPAD_DIGITAL_MASK | Game::GPAD_ANALOG_MASK)); assert(button & (Game::GPAD_DIGITAL_MASK | Game::GPAD_ANALOG_MASK));
auto& gamePad = gamePads[gamePadIndex]; auto& gamePad = gamePads[localClientNum];
bool down = false; bool down = false;
bool lastDown = false; bool lastDown = false;
@ -1322,16 +1328,16 @@ namespace Components
return down && !lastDown; return down && !lastDown;
} }
bool Gamepad::GPad_ButtonRequiresUpdates(const int gamePadIndex, Game::GamePadButton button) bool Gamepad::GPad_ButtonRequiresUpdates(const int localClientNum, Game::GamePadButton button)
{ {
return (button & Game::GPAD_ANALOG_MASK || button & Game::GPAD_DPAD_MASK) && GPad_GetButton(gamePadIndex, button) > 0.0f; return (button & Game::GPAD_ANALOG_MASK || button & Game::GPAD_DPAD_MASK) && GPad_GetButton(localClientNum, button) > 0.0f;
} }
bool Gamepad::GPad_IsButtonReleased(int gamePadIndex, Game::GamePadButton button) bool Gamepad::GPad_IsButtonReleased(int localClientNum, Game::GamePadButton button)
{ {
AssertIn(gamePadIndex, Game::MAX_GPAD_COUNT); AssertIn(localClientNum, Game::MAX_GPAD_COUNT);
auto& gamePad = gamePads[gamePadIndex]; auto& gamePad = gamePads[localClientNum];
bool down = false; bool down = false;
bool lastDown = false; bool lastDown = false;
@ -1358,11 +1364,11 @@ namespace Components
return !down && lastDown; return !down && lastDown;
} }
void Gamepad::GPad_UpdateSticksDown(const int gamePadIndex) void Gamepad::GPad_UpdateSticksDown(const int localClientNum)
{ {
AssertIn(gamePadIndex, Game::MAX_GPAD_COUNT); AssertIn(localClientNum, Game::MAX_GPAD_COUNT);
auto& gamePad = gamePads[gamePadIndex]; auto& gamePad = gamePads[localClientNum];
for (auto stickIndex = 0u; stickIndex < std::extent_v<decltype(GamePad::sticks)>; stickIndex++) for (auto stickIndex = 0u; stickIndex < std::extent_v<decltype(GamePad::sticks)>; stickIndex++)
{ {
@ -1390,11 +1396,11 @@ namespace Components
} }
} }
void Gamepad::GPad_UpdateSticks(const int gamePadIndex, const XINPUT_GAMEPAD& state) void Gamepad::GPad_UpdateSticks(const int localClientNum, const XINPUT_GAMEPAD& state)
{ {
AssertIn(gamePadIndex, Game::MAX_GPAD_COUNT); AssertIn(localClientNum, Game::MAX_GPAD_COUNT);
auto& gamePad = gamePads[gamePadIndex]; auto& gamePad = gamePads[localClientNum];
Game::vec2_t lVec, rVec; Game::vec2_t lVec, rVec;
GPad_ConvertStickToFloat(state.sThumbLX, state.sThumbLY, lVec[0], lVec[1]); GPad_ConvertStickToFloat(state.sThumbLX, state.sThumbLY, lVec[0], lVec[1]);
@ -1409,7 +1415,7 @@ namespace Components
gamePad.lastSticks[3] = gamePad.sticks[3]; gamePad.lastSticks[3] = gamePad.sticks[3];
gamePad.sticks[3] = rVec[1]; gamePad.sticks[3] = rVec[1];
GPad_UpdateSticksDown(gamePadIndex); GPad_UpdateSticksDown(localClientNum);
if (gpad_debug.get<bool>()) if (gpad_debug.get<bool>())
{ {
@ -1422,11 +1428,11 @@ namespace Components
} }
} }
void Gamepad::GPad_UpdateDigitals(const int gamePadIndex, const XINPUT_GAMEPAD& state) void Gamepad::GPad_UpdateDigitals(const int localClientNum, const XINPUT_GAMEPAD& state)
{ {
AssertIn(gamePadIndex, Game::MAX_GPAD_COUNT); AssertIn(localClientNum, Game::MAX_GPAD_COUNT);
auto& gamePad = gamePads[gamePadIndex]; auto& gamePad = gamePads[localClientNum];
gamePad.lastDigitals = gamePad.digitals; gamePad.lastDigitals = gamePad.digitals;
gamePad.digitals = state.wButtons; gamePad.digitals = state.wButtons;
@ -1444,11 +1450,11 @@ namespace Components
} }
} }
void Gamepad::GPad_UpdateAnalogs(const int gamePadIndex, const XINPUT_GAMEPAD& state) void Gamepad::GPad_UpdateAnalogs(const int localClientNum, const XINPUT_GAMEPAD& state)
{ {
AssertIn(gamePadIndex, Game::MAX_GPAD_COUNT); AssertIn(localClientNum, Game::MAX_GPAD_COUNT);
auto& gamePad = gamePads[gamePadIndex]; auto& gamePad = gamePads[localClientNum];
const auto buttonDeadZone = gpad_button_deadzone.get<float>(); const auto buttonDeadZone = gpad_button_deadzone.get<float>();
@ -1473,19 +1479,21 @@ namespace Components
{ {
GPad_RefreshAll(); GPad_RefreshAll();
for (auto currentGamePadIndex = 0; currentGamePadIndex < Game::MAX_GPAD_COUNT; currentGamePadIndex++) for (auto localClientNum = 0; localClientNum < Game::MAX_GPAD_COUNT; ++localClientNum)
{ {
const auto& gamePad = gamePads[currentGamePadIndex]; const auto& gamePad = gamePads[localClientNum];
if (!gamePad.enabled) if (!gamePad.enabled)
{
continue; continue;
}
XINPUT_STATE inputState; XINPUT_STATE inputState;
if (XInputGetState(gamePad.portIndex, &inputState) != ERROR_SUCCESS) if (XInputGetState(gamePad.portIndex, &inputState) != ERROR_SUCCESS)
continue; continue;
GPad_UpdateSticks(currentGamePadIndex, inputState.Gamepad); GPad_UpdateSticks(localClientNum, inputState.Gamepad);
GPad_UpdateDigitals(currentGamePadIndex, inputState.Gamepad); GPad_UpdateDigitals(localClientNum, inputState.Gamepad);
GPad_UpdateAnalogs(currentGamePadIndex, inputState.Gamepad); GPad_UpdateAnalogs(localClientNum, inputState.Gamepad);
} }
} }
@ -1498,53 +1506,42 @@ namespace Components
const auto time = Game::Sys_Milliseconds(); const auto time = Game::Sys_Milliseconds();
bool gpadPresent = false; bool gpadPresent = false;
for (auto gamePadIndex = 0; gamePadIndex < Game::MAX_GPAD_COUNT; gamePadIndex++) for (auto localClientNum = 0; localClientNum < Game::MAX_GPAD_COUNT; ++localClientNum)
{ {
const auto& gamePad = gamePads[gamePadIndex]; const auto& gamePad = gamePads[localClientNum];
if (!gamePad.enabled)
if (gamePad.enabled)
{ {
gpadPresent = true; continue;
const auto lx = GPad_GetStick(gamePadIndex, Game::GPAD_LX); }
const auto ly = GPad_GetStick(gamePadIndex, Game::GPAD_LY);
const auto rx = GPad_GetStick(gamePadIndex, Game::GPAD_RX);
const auto ry = GPad_GetStick(gamePadIndex, Game::GPAD_RY);
const auto leftTrig = GPad_GetButton(gamePadIndex, Game::GPAD_L_TRIG);
const auto rightTrig = GPad_GetButton(gamePadIndex, Game::GPAD_R_TRIG);
CL_GamepadEvent(gamePadIndex, Game::GPAD_PHYSAXIS_LSTICK_X, lx, time); gpadPresent = true;
CL_GamepadEvent(gamePadIndex, Game::GPAD_PHYSAXIS_LSTICK_Y, ly, time); const auto lx = GPad_GetStick(localClientNum, Game::GPAD_LX);
CL_GamepadEvent(gamePadIndex, Game::GPAD_PHYSAXIS_RSTICK_X, rx, time); const auto ly = GPad_GetStick(localClientNum, Game::GPAD_LY);
CL_GamepadEvent(gamePadIndex, Game::GPAD_PHYSAXIS_RSTICK_Y, ry, time); const auto rx = GPad_GetStick(localClientNum, Game::GPAD_RX);
CL_GamepadEvent(gamePadIndex, Game::GPAD_PHYSAXIS_LTRIGGER, leftTrig, time); const auto ry = GPad_GetStick(localClientNum, Game::GPAD_RY);
CL_GamepadEvent(gamePadIndex, Game::GPAD_PHYSAXIS_RTRIGGER, rightTrig, time); const auto leftTrig = GPad_GetButton(localClientNum, Game::GPAD_L_TRIG);
const auto rightTrig = GPad_GetButton(localClientNum, Game::GPAD_R_TRIG);
for (const auto& buttonMapping : buttonList) CL_GamepadEvent(localClientNum, Game::GPAD_PHYSAXIS_LSTICK_X, lx, time);
CL_GamepadEvent(localClientNum, Game::GPAD_PHYSAXIS_LSTICK_Y, ly, time);
CL_GamepadEvent(localClientNum, Game::GPAD_PHYSAXIS_RSTICK_X, rx, time);
CL_GamepadEvent(localClientNum, Game::GPAD_PHYSAXIS_RSTICK_Y, ry, time);
CL_GamepadEvent(localClientNum, Game::GPAD_PHYSAXIS_LTRIGGER, leftTrig, time);
CL_GamepadEvent(localClientNum, Game::GPAD_PHYSAXIS_RTRIGGER, rightTrig, time);
for (const auto& buttonMapping : buttonList)
{
if (GPad_IsButtonPressed(localClientNum, buttonMapping.padButton))
{ {
if (GPad_IsButtonPressed(gamePadIndex, buttonMapping.padButton)) CL_GamepadButtonEventForPort(localClientNum, buttonMapping.code, Game::GPAD_BUTTON_PRESSED, time);
{ }
CL_GamepadButtonEventForPort( else if (GPad_ButtonRequiresUpdates(localClientNum, buttonMapping.padButton))
gamePadIndex, {
buttonMapping.code, CL_GamepadButtonEventForPort(localClientNum, buttonMapping.code, Game::GPAD_BUTTON_UPDATE, time);
Game::GPAD_BUTTON_PRESSED, }
time); else if (GPad_IsButtonReleased(localClientNum, buttonMapping.padButton))
} {
else if (GPad_ButtonRequiresUpdates(gamePadIndex, buttonMapping.padButton)) CL_GamepadButtonEventForPort(localClientNum, buttonMapping.code, Game::GPAD_BUTTON_RELEASED, time);
{
CL_GamepadButtonEventForPort(
gamePadIndex,
buttonMapping.code,
Game::GPAD_BUTTON_UPDATE,
time);
}
else if (GPad_IsButtonReleased(gamePadIndex, buttonMapping.padButton))
{
CL_GamepadButtonEventForPort(
gamePadIndex,
buttonMapping.code,
Game::GPAD_BUTTON_RELEASED,
time);
}
} }
} }
} }
@ -1559,19 +1556,19 @@ namespace Components
IN_GamePadsMove(); IN_GamePadsMove();
} }
void Gamepad::Gamepad_WriteBindings(const int gamePadIndex, const int handle) void Gamepad::Gamepad_WriteBindings(const int localClientNum, const int handle)
{ {
AssertIn(gamePadIndex, Game::MAX_GPAD_COUNT); AssertIn(localClientNum, Game::MAX_GPAD_COUNT);
auto& gamePadGlobal = gamePadGlobals[gamePadIndex]; auto& gamePadGlobal = gamePadGlobals[localClientNum];
Game::FS_Printf(handle, "unbindallaxis\n"); Game::FS_Printf(handle, "unbindallaxis\n");
for (auto virtualAxisIndex = 0u; virtualAxisIndex < Game::GPAD_VIRTAXIS_COUNT; virtualAxisIndex++) for (auto virtualAxisIndex = 0u; virtualAxisIndex < Game::GPAD_VIRTAXIS_COUNT; ++virtualAxisIndex)
{ {
const auto& axisMapping = gamePadGlobal.axes.virtualAxes[virtualAxisIndex]; const auto& axisMapping = gamePadGlobal.axes.virtualAxes[virtualAxisIndex];
if (axisMapping.physicalAxis <= Game::GPAD_PHYSAXIS_NONE || axisMapping.physicalAxis >= Game::GPAD_PHYSAXIS_COUNT if (axisMapping.physicalAxis <= Game::GPAD_PHYSAXIS_NONE || axisMapping.physicalAxis >= Game::GPAD_PHYSAXIS_COUNT ||
|| axisMapping.mapType <= Game::GPAD_MAP_NONE || axisMapping.mapType >= Game::GPAD_MAP_COUNT) axisMapping.mapType <= Game::GPAD_MAP_NONE || axisMapping.mapType >= Game::GPAD_MAP_COUNT)
{ {
continue; continue;
} }
@ -1612,14 +1609,14 @@ namespace Components
} }
} }
void Gamepad::Gamepad_BindAxis(const int gamePadIndex, const Game::GamepadPhysicalAxis realIndex, const Game::GamepadVirtualAxis axisIndex, const Game::GamepadMapping mapType) void Gamepad::Gamepad_BindAxis(const int localClientNum, const Game::GamepadPhysicalAxis realIndex, const Game::GamepadVirtualAxis axisIndex, const Game::GamepadMapping mapType)
{ {
AssertIn(gamePadIndex, Game::MAX_GPAD_COUNT); AssertIn(localClientNum, Game::MAX_GPAD_COUNT);
assert(realIndex > Game::GPAD_PHYSAXIS_NONE && realIndex < Game::GPAD_PHYSAXIS_COUNT); assert(realIndex > Game::GPAD_PHYSAXIS_NONE && realIndex < Game::GPAD_PHYSAXIS_COUNT);
assert(axisIndex > Game::GPAD_VIRTAXIS_NONE && axisIndex < Game::GPAD_VIRTAXIS_COUNT); assert(axisIndex > Game::GPAD_VIRTAXIS_NONE && axisIndex < Game::GPAD_VIRTAXIS_COUNT);
assert(mapType > Game::GPAD_MAP_NONE && mapType < Game::GPAD_MAP_COUNT); assert(mapType > Game::GPAD_MAP_NONE && mapType < Game::GPAD_MAP_COUNT);
auto& gamePadGlobal = gamePadGlobals[gamePadIndex]; auto& gamePadGlobal = gamePadGlobals[localClientNum];
gamePadGlobal.axes.virtualAxes[axisIndex].physicalAxis = realIndex; gamePadGlobal.axes.virtualAxes[axisIndex].physicalAxis = realIndex;
gamePadGlobal.axes.virtualAxes[axisIndex].mapType = mapType; gamePadGlobal.axes.virtualAxes[axisIndex].mapType = mapType;
@ -1628,10 +1625,12 @@ namespace Components
Game::GamepadPhysicalAxis Gamepad::StringToPhysicalAxis(const char* str) Game::GamepadPhysicalAxis Gamepad::StringToPhysicalAxis(const char* str)
{ {
for (auto i = 0u; i < std::extent_v<decltype(physicalAxisNames)>; i++) for (std::size_t i = 0; i < std::extent_v<decltype(physicalAxisNames)>; i++)
{ {
if (strcmp(str, physicalAxisNames[i]) == 0) if (std::strcmp(str, physicalAxisNames[i]) == 0)
{
return static_cast<Game::GamepadPhysicalAxis>(i); return static_cast<Game::GamepadPhysicalAxis>(i);
}
} }
return Game::GPAD_PHYSAXIS_NONE; return Game::GPAD_PHYSAXIS_NONE;
@ -1639,10 +1638,12 @@ namespace Components
Game::GamepadVirtualAxis Gamepad::StringToVirtualAxis(const char* str) Game::GamepadVirtualAxis Gamepad::StringToVirtualAxis(const char* str)
{ {
for (auto i = 0u; i < std::extent_v<decltype(virtualAxisNames)>; i++) for (std::size_t i = 0; i < std::extent_v<decltype(virtualAxisNames)>; ++i)
{ {
if (strcmp(str, virtualAxisNames[i]) == 0) if (std::strcmp(str, virtualAxisNames[i]) == 0)
{
return static_cast<Game::GamepadVirtualAxis>(i); return static_cast<Game::GamepadVirtualAxis>(i);
}
} }
return Game::GPAD_VIRTAXIS_NONE; return Game::GPAD_VIRTAXIS_NONE;
@ -1650,10 +1651,12 @@ namespace Components
Game::GamepadMapping Gamepad::StringToGamePadMapping(const char* str) Game::GamepadMapping Gamepad::StringToGamePadMapping(const char* str)
{ {
for (auto i = 0u; i < std::extent_v<decltype(gamePadMappingTypeNames)>; i++) for (std::size_t i = 0; i < std::extent_v<decltype(gamePadMappingTypeNames)>; ++i)
{ {
if (strcmp(str, gamePadMappingTypeNames[i]) == 0) if (std::strcmp(str, gamePadMappingTypeNames[i]) == 0)
{
return static_cast<Game::GamepadMapping>(i); return static_cast<Game::GamepadMapping>(i);
}
} }
return Game::GPAD_MAP_NONE; return Game::GPAD_MAP_NONE;
@ -1720,12 +1723,16 @@ namespace Components
void Gamepad::Scores_Toggle_f(Command::Params*) void Gamepad::Scores_Toggle_f(Command::Params*)
{ {
if(Game::cgArray[0].nextSnap) if (Game::cgArray[0].nextSnap)
{ {
if (Game::UI_GetActiveMenu(0) != Game::UIMENU_SCOREBOARD) if (Game::UI_GetActiveMenu(0) != Game::UIMENU_SCOREBOARD)
{
Game::CG_ScoresDown_f(); Game::CG_ScoresDown_f();
}
else else
{
Game::CG_ScoresUp_f(); Game::CG_ScoresUp_f();
}
} }
} }
@ -2023,7 +2030,7 @@ namespace Components
// Add gamepad inputs to location selection (eg airstrike location) handling // Add gamepad inputs to location selection (eg airstrike location) handling
Utils::Hook(0x5A6D72, CG_HandleLocationSelectionInput_Stub, HOOK_CALL).install()->quick(); Utils::Hook(0x5A6D72, CG_HandleLocationSelectionInput_Stub, HOOK_CALL).install()->quick();
// Add gamepad inputs to usercmds // Add gamepad inputs to user commands if it is enabled
Utils::Hook(0x5A6DAE, CL_MouseMove_Stub, HOOK_CALL).install()->quick(); Utils::Hook(0x5A6DAE, CL_MouseMove_Stub, HOOK_CALL).install()->quick();
} }
} }

47
src/Components/Modules/Gamepad.hpp
View File

@ -125,7 +125,7 @@ namespace Components
static const Game::AimScreenTarget* AimAssist_GetBestTarget(const Game::AimAssistGlobals* aaGlob, float range, float regionWidth, float regionHeight); static const Game::AimScreenTarget* AimAssist_GetBestTarget(const Game::AimAssistGlobals* aaGlob, float range, float regionWidth, float regionHeight);
static const Game::AimScreenTarget* AimAssist_GetTargetFromEntity(const Game::AimAssistGlobals* aaGlob, int entIndex); static const Game::AimScreenTarget* AimAssist_GetTargetFromEntity(const Game::AimAssistGlobals* aaGlob, int entIndex);
static const Game::AimScreenTarget* AimAssist_GetPrevOrBestTarget(const Game::AimAssistGlobals* aaGlob, float range, float regionWidth, float regionHeight, int prevTargetEnt); static const Game::AimScreenTarget* AimAssist_GetPrevOrBestTarget(const Game::AimAssistGlobals* aaGlob, float range, float regionWidth, float regionHeight, int prevTargetEnt);
static bool AimAssist_IsLockonActive(int gamePadIndex); static bool AimAssist_IsLockonActive(int localClientNum);
static void AimAssist_ApplyLockOn(const Game::AimInput* input, Game::AimOutput* output); static void AimAssist_ApplyLockOn(const Game::AimInput* input, Game::AimOutput* output);
static void AimAssist_CalcAdjustedAxis(const Game::AimInput* input, float* pitchAxis, float* yawAxis); static void AimAssist_CalcAdjustedAxis(const Game::AimInput* input, float* pitchAxis, float* yawAxis);
static bool AimAssist_IsSlowdownActive(const Game::AimAssistPlayerState* ps); static bool AimAssist_IsSlowdownActive(const Game::AimAssistPlayerState* ps);
@ -139,47 +139,48 @@ namespace Components
static bool CG_HandleLocationSelectionInput_GamePad(int localClientNum, Game::usercmd_s* cmd); static bool CG_HandleLocationSelectionInput_GamePad(int localClientNum, Game::usercmd_s* cmd);
static void CG_HandleLocationSelectionInput_Stub(); static void CG_HandleLocationSelectionInput_Stub();
static bool CG_ShouldUpdateViewAngles(int localClientNum); static bool CG_ShouldUpdateViewAngles(int localClientNum);
static float CL_GamepadAxisValue(int gamePadIndex, Game::GamepadVirtualAxis virtualAxis); static float CL_GamepadAxisValue(int localClientNum, Game::GamepadVirtualAxis virtualAxis);
static char ClampChar(int value); static char ClampChar(int value);
static void CL_GamepadMove(int gamePadIndex, Game::usercmd_s* cmd, float frameTimeBase); static void CL_GamepadMove(int localClientNum, float frameTimeBase, Game::usercmd_s* cmd);
static void CL_MouseMove(int localClientNum, Game::usercmd_s* cmd, float frametime_base);
static void CL_MouseMove_Stub(); static void CL_MouseMove_Stub();
static bool Gamepad_ShouldUse(const Game::gentity_s* playerEnt, unsigned useTime); static bool Gamepad_ShouldUse(const Game::gentity_s* playerEnt, unsigned useTime);
static void Player_UseEntity_Stub(); static void Player_UseEntity_Stub();
static bool Key_IsValidGamePadChar(int key); static bool Key_IsValidGamePadChar(int key);
static void CL_GamepadResetMenuScrollTime(int gamePadIndex, int key, bool down, unsigned int time); static void CL_GamepadResetMenuScrollTime(int localClientNum, int key, bool down, unsigned int time);
static bool Scoreboard_HandleInput(int gamePadIndex, int key); static bool Scoreboard_HandleInput(int localClientNum, int key);
static bool CL_CheckForIgnoreDueToRepeat(int gamePadIndex, int key, int repeatCount, unsigned int time); static bool CL_CheckForIgnoreDueToRepeat(int localClientNum, int key, int repeatCount, unsigned int time);
static void UI_GamepadKeyEvent(int gamePadIndex, int key, bool down); static void UI_GamepadKeyEvent(int localClientNum, int key, bool down);
static void CL_GamepadGenerateAPad(int gamePadIndex, Game::GamepadPhysicalAxis physicalAxis, unsigned time); static void CL_GamepadGenerateAPad(int localClientNum, Game::GamepadPhysicalAxis physicalAxis, unsigned time);
static void CL_GamepadEvent(int gamePadIndex, Game::GamepadPhysicalAxis physicalAxis, float value, unsigned time); static void CL_GamepadEvent(int localClientNum, Game::GamepadPhysicalAxis physicalAxis, float value, unsigned time);
static void CL_GamepadButtonEvent(int gamePadIndex, int key, Game::GamePadButtonEvent buttonEvent, unsigned time); static void CL_GamepadButtonEvent(int localClientNum, int key, Game::GamePadButtonEvent buttonEvent, unsigned time);
static void CL_GamepadButtonEventForPort(int gamePadIndex, int key, Game::GamePadButtonEvent buttonEvent, unsigned int time); static void CL_GamepadButtonEventForPort(int localClientNum, int key, Game::GamePadButtonEvent buttonEvent, unsigned int time);
static void GPad_ConvertStickToFloat(short x, short y, float& outX, float& outY); static void GPad_ConvertStickToFloat(short x, short y, float& outX, float& outY);
static float GPad_GetStick(int gamePadIndex, Game::GamePadStick stick); static float GPad_GetStick(int localClientNum, Game::GamePadStick stick);
static float GPad_GetButton(int gamePadIndex, Game::GamePadButton button); static float GPad_GetButton(int localClientNum, Game::GamePadButton button);
static bool GPad_IsButtonPressed(int gamePadIndex, Game::GamePadButton button); static bool GPad_IsButtonPressed(int localClientNum, Game::GamePadButton button);
static bool GPad_ButtonRequiresUpdates(int gamePadIndex, Game::GamePadButton button); static bool GPad_ButtonRequiresUpdates(int localClientNum, Game::GamePadButton button);
static bool GPad_IsButtonReleased(int gamePadIndex, Game::GamePadButton button); static bool GPad_IsButtonReleased(int localClientNum, Game::GamePadButton button);
static void GPad_UpdateSticksDown(int gamePadIndex); static void GPad_UpdateSticksDown(int localClientNum);
static void GPad_UpdateSticks(int gamePadIndex, const XINPUT_GAMEPAD& state); static void GPad_UpdateSticks(int localClientNum, const XINPUT_GAMEPAD& state);
static void GPad_UpdateDigitals(int gamePadIndex, const XINPUT_GAMEPAD& state); static void GPad_UpdateDigitals(int localClientNum, const XINPUT_GAMEPAD& state);
static void GPad_UpdateAnalogs(int gamePadIndex, const XINPUT_GAMEPAD& state); static void GPad_UpdateAnalogs(int localClientNum, const XINPUT_GAMEPAD& state);
static bool GPad_Check(int gamePadIndex, int portIndex); static bool GPad_Check(int localClientNum, int portIndex);
static void GPad_RefreshAll(); static void GPad_RefreshAll();
static void GPad_UpdateAll(); static void GPad_UpdateAll();
static void IN_GamePadsMove(); static void IN_GamePadsMove();
static void IN_Frame_Hk(); static void IN_Frame_Hk();
static void Gamepad_WriteBindings(int gamePadIndex, int handle); static void Gamepad_WriteBindings(int localClientNum, int handle);
static void Key_WriteBindings_Hk(int localClientNum, int handle); static void Key_WriteBindings_Hk(int localClientNum, int handle);
static void Com_WriteConfiguration_Modified_Stub(); static void Com_WriteConfiguration_Modified_Stub();
static void Gamepad_BindAxis(int gamePadIndex, Game::GamepadPhysicalAxis realIndex, Game::GamepadVirtualAxis axisIndex, Game::GamepadMapping mapType); static void Gamepad_BindAxis(int localClientNum, Game::GamepadPhysicalAxis realIndex, Game::GamepadVirtualAxis axisIndex, Game::GamepadMapping mapType);
static Game::GamepadPhysicalAxis StringToPhysicalAxis(const char* str); static Game::GamepadPhysicalAxis StringToPhysicalAxis(const char* str);
static Game::GamepadVirtualAxis StringToVirtualAxis(const char* str); static Game::GamepadVirtualAxis StringToVirtualAxis(const char* str);
static Game::GamepadMapping StringToGamePadMapping(const char* str); static Game::GamepadMapping StringToGamePadMapping(const char* str);

31
src/Game/Client.cpp
View File

@ -27,6 +27,8 @@ namespace Game
CL_WriteDemoMessage_t CL_WriteDemoMessage = CL_WriteDemoMessage_t(0x4707C0); CL_WriteDemoMessage_t CL_WriteDemoMessage = CL_WriteDemoMessage_t(0x4707C0);
CL_AddDebugStarWithText_t CL_AddDebugStarWithText = CL_AddDebugStarWithText_t(0x4D03C0); CL_AddDebugStarWithText_t CL_AddDebugStarWithText = CL_AddDebugStarWithText_t(0x4D03C0);
Key_ClearStates_t Key_ClearStates = Key_ClearStates_t(0x5A7F00);
float* cl_angles = reinterpret_cast<float*>(0xB2F8D0); float* cl_angles = reinterpret_cast<float*>(0xB2F8D0);
clientConnection_t* clientConnections = reinterpret_cast<clientConnection_t*>(0xA1E878); clientConnection_t* clientConnections = reinterpret_cast<clientConnection_t*>(0xA1E878);
@ -87,4 +89,33 @@ namespace Game
CL_AddDebugStarWithText(point, color, MY_NULLTEXTCOLOR, nullptr, 1.0f, duration, fromServer); CL_AddDebugStarWithText(point, color, MY_NULLTEXTCOLOR, nullptr, 1.0f, duration, fromServer);
} }
void CL_MouseMove(const int localClientNum, Game::usercmd_s* cmd, const float frametime_base)
{
static const DWORD CL_MouseMove_t = 0x5A6240;
__asm
{
pushad
mov ebx, cmd
mov eax, localClientNum
push frametime_base
call CL_MouseMove_t
add esp, 0x4
popad
}
}
void AdjustViewanglesForKeyboard(const int localClientNum)
{
static const DWORD AdjustViewanglesForKeyboard_t = 0x5A5D80;
__asm
{
pushad
mov eax, localClientNum
call AdjustViewanglesForKeyboard_t
popad
}
}
} }

19
src/Game/Client.hpp
View File

@ -74,6 +74,9 @@ namespace Game
typedef void(*CL_AddDebugStarWithText_t)(const float* point, const float* starColor, const float* textColor, const char* string, float fontsize, int duration, int fromServer); typedef void(*CL_AddDebugStarWithText_t)(const float* point, const float* starColor, const float* textColor, const char* string, float fontsize, int duration, int fromServer);
extern CL_AddDebugStarWithText_t CL_AddDebugStarWithText; extern CL_AddDebugStarWithText_t CL_AddDebugStarWithText;
typedef void(*Key_ClearStates_t)(int localClientNum);
extern Key_ClearStates_t Key_ClearStates;
extern float* cl_angles; extern float* cl_angles;
extern clientConnection_t* clientConnections; extern clientConnection_t* clientConnections;
@ -86,12 +89,16 @@ namespace Game
extern voiceCommunication_t* cl_voiceCommunication; extern voiceCommunication_t* cl_voiceCommunication;
extern int CL_GetMaxXP(); extern [[nodiscard]] int CL_GetMaxXP();
extern clientConnection_t* CL_GetLocalClientConnection(int localClientNum); extern [[nodiscard]] clientConnection_t* CL_GetLocalClientConnection(int localClientNum);
extern connstate_t CL_GetLocalClientConnectionState(int localClientNum); extern [[nodiscard]] connstate_t CL_GetLocalClientConnectionState(int localClientNum);
extern voiceCommunication_t* CL_GetLocalClientVoiceCommunication(int localClientNum); extern [[nodiscard]] voiceCommunication_t* CL_GetLocalClientVoiceCommunication(int localClientNum);
extern clientUIActive_t* CL_GetLocalClientUIGlobals(int localClientNum); extern [[nodiscard]] clientUIActive_t* CL_GetLocalClientUIGlobals(int localClientNum);
extern clientActive_t* CL_GetLocalClientGlobals(int localClientNum); extern [[nodiscard]] clientActive_t* CL_GetLocalClientGlobals(int localClientNum);
extern void CL_AddDebugStar(const float* point, const float* color, int duration, int fromServer); extern void CL_AddDebugStar(const float* point, const float* color, int duration, int fromServer);
extern void CL_MouseMove(int localClientNum, Game::usercmd_s* cmd, float frametime_base);
extern void AdjustViewanglesForKeyboard(int localClientNum);
} }

1
src/Game/Functions.cpp
View File

@ -124,6 +124,7 @@ namespace Game
Live_GetPrestige_t Live_GetPrestige = Live_GetPrestige_t(0x430F90); Live_GetPrestige_t Live_GetPrestige = Live_GetPrestige_t(0x430F90);
Live_GetXp_t Live_GetXp = Live_GetXp_t(0x404C60); Live_GetXp_t Live_GetXp = Live_GetXp_t(0x404C60);
Live_GetLocalClientName_t Live_GetLocalClientName = Live_GetLocalClientName_t(0x441FC0); Live_GetLocalClientName_t Live_GetLocalClientName = Live_GetLocalClientName_t(0x441FC0);
Live_IsSystemUiActive_t Live_IsSystemUiActive = Live_IsSystemUiActive_t(0x4F5CB0);
LiveStorage_GetStat_t LiveStorage_GetStat = LiveStorage_GetStat_t(0x471F60); LiveStorage_GetStat_t LiveStorage_GetStat = LiveStorage_GetStat_t(0x471F60);
LiveStorage_SetStat_t LiveStorage_SetStat = LiveStorage_SetStat_t(0x4CC5D0); LiveStorage_SetStat_t LiveStorage_SetStat = LiveStorage_SetStat_t(0x4CC5D0);

3
src/Game/Functions.hpp
View File

@ -311,6 +311,9 @@ namespace Game
typedef const char*(*Live_GetLocalClientName_t)(int controllerIndex); typedef const char*(*Live_GetLocalClientName_t)(int controllerIndex);
extern Live_GetLocalClientName_t Live_GetLocalClientName; extern Live_GetLocalClientName_t Live_GetLocalClientName;
typedef bool(*Live_IsSystemUiActive_t)();
extern Live_IsSystemUiActive_t Live_IsSystemUiActive;
typedef int(*LiveStorage_GetStat_t)(int controllerIndex, int index); typedef int(*LiveStorage_GetStat_t)(int controllerIndex, int index);
extern LiveStorage_GetStat_t LiveStorage_GetStat; extern LiveStorage_GetStat_t LiveStorage_GetStat;