iw4x-client/src/Components/Modules/Gamepad.cpp

#include "STDInclude.hpp"

namespace Components
{
    Game::ButtonToCodeMap_t Gamepad::buttonList[]
    {
        {Game::GPAD_X, Game::K_BUTTON_X},
        {Game::GPAD_A, Game::K_BUTTON_A},
        {Game::GPAD_B, Game::K_BUTTON_B},
        {Game::GPAD_Y, Game::K_BUTTON_Y},
        {Game::GPAD_L_TRIG, Game::K_BUTTON_LTRIG},
        {Game::GPAD_R_TRIG, Game::K_BUTTON_RTRIG},
        {Game::GPAD_L_SHLDR, Game::K_BUTTON_LSHLDR},
        {Game::GPAD_R_SHLDR, Game::K_BUTTON_RSHLDR},
        {Game::GPAD_START, Game::K_BUTTON_START},
        {Game::GPAD_BACK, Game::K_BUTTON_BACK},
        {Game::GPAD_L3, Game::K_BUTTON_LSTICK},
        {Game::GPAD_R3, Game::K_BUTTON_RSTICK},
        {Game::GPAD_UP, Game::K_DPAD_UP},
        {Game::GPAD_DOWN, Game::K_DPAD_DOWN},
        {Game::GPAD_LEFT, Game::K_DPAD_LEFT},
        {Game::GPAD_RIGHT, Game::K_DPAD_RIGHT}
    };

    Game::StickToCodeMap_t Gamepad::analogStickList[4]
    {
        {Game::GPAD_LX, Game::K_APAD_RIGHT, Game::K_APAD_LEFT},
        {Game::GPAD_LY, Game::K_APAD_UP, Game::K_APAD_DOWN},
        {Game::GPAD_RX, Game::K_APAD_RIGHT, Game::K_APAD_LEFT},
        {Game::GPAD_RY, Game::K_APAD_UP, Game::K_APAD_DOWN},
    };

    Game::GamePadStick Gamepad::stickForAxis[Game::GPAD_PHYSAXIS_COUNT]
    {
        Game::GPAD_RX,
        Game::GPAD_RY,
        Game::GPAD_LX,
        Game::GPAD_LY,
        Game::GPAD_INVALID,
        Game::GPAD_INVALID
    };

    Game::GamepadPhysicalAxis Gamepad::axisSameStick[Game::GPAD_PHYSAXIS_COUNT]
    {
        Game::GPAD_PHYSAXIS_RSTICK_Y,
        Game::GPAD_PHYSAXIS_RSTICK_X,
        Game::GPAD_PHYSAXIS_LSTICK_Y,
        Game::GPAD_PHYSAXIS_LSTICK_X,
        Game::GPAD_PHYSAXIS_NONE,
        Game::GPAD_PHYSAXIS_NONE
    };

    const char* Gamepad::physicalAxisNames[Game::GPAD_PHYSAXIS_COUNT]
    {
        "A_RSTICK_X",
        "A_RSTICK_Y",
        "A_LSTICK_X",
        "A_LSTICK_Y",
        "A_RTRIGGER",
        "A_LTRIGGER"
    };

    const char* Gamepad::virtualAxisNames[Game::GPAD_VIRTAXIS_COUNT]
    {
        "VA_SIDE",
        "VA_FORWARD",
        "VA_UP",
        "VA_YAW",
        "VA_PITCH",
        "VA_ATTACK"
    };

    const char* Gamepad::gamePadMappingTypeNames[Game::GPAD_MAP_COUNT]
    {
        "MAP_LINEAR",
        "MAP_SQUARED"
    };

    Game::keyNum_t Gamepad::menuScrollButtonList[]
    {
        Game::K_APAD_UP,
        Game::K_APAD_DOWN,
        Game::K_APAD_LEFT,
        Game::K_APAD_RIGHT,
        Game::K_DPAD_UP,
        Game::K_DPAD_DOWN,
        Game::K_DPAD_LEFT,
        Game::K_DPAD_RIGHT
    };

    Game::keyname_t Gamepad::extendedKeyNames[]
    {
        {"BUTTON_A", Game::K_BUTTON_A},
        {"BUTTON_B", Game::K_BUTTON_B},
        {"BUTTON_X", Game::K_BUTTON_X},
        {"BUTTON_Y", Game::K_BUTTON_Y},
        {"BUTTON_LSHLDR", Game::K_BUTTON_LSHLDR},
        {"BUTTON_RSHLDR", Game::K_BUTTON_RSHLDR},
        {"BUTTON_START", Game::K_BUTTON_START},
        {"BUTTON_BACK", Game::K_BUTTON_BACK},
        {"BUTTON_LSTICK", Game::K_BUTTON_LSTICK},
        {"BUTTON_RSTICK", Game::K_BUTTON_RSTICK},
        {"BUTTON_LTRIG", Game::K_BUTTON_LTRIG},
        {"BUTTON_RTRIG", Game::K_BUTTON_RTRIG},
        {"DPAD_UP", Game::K_DPAD_UP},
        {"DPAD_DOWN", Game::K_DPAD_DOWN},
        {"DPAD_LEFT", Game::K_DPAD_LEFT},
        {"DPAD_RIGHT", Game::K_DPAD_RIGHT},
    };

    Game::keyname_t Gamepad::extendedLocalizedKeyNamesXenon[]
    {
        // Material text icons pattern: 0x01 width height material_name_len
        {"^\x01\x32\x32\x08""button_a", Game::K_BUTTON_A},
        {"^\x01\x32\x32\x08""button_b", Game::K_BUTTON_B},
        {"^\x01\x32\x32\x08""button_x", Game::K_BUTTON_X},
        {"^\x01\x32\x32\x08""button_y", Game::K_BUTTON_Y},
        {"^\x01\x32\x32\x0D""button_lshldr", Game::K_BUTTON_LSHLDR},
        {"^\x01\x32\x32\x0D""button_rshldr", Game::K_BUTTON_RSHLDR},
        {"^\x01\x32\x32\x0C""button_start", Game::K_BUTTON_START},
        {"^\x01\x32\x32\x0B""button_back", Game::K_BUTTON_BACK},
        {"^\x01\x48\x32\x0D""button_lstick", Game::K_BUTTON_LSTICK},
        {"^\x01\x48\x32\x0D""button_rstick", Game::K_BUTTON_RSTICK},
        {"^\x01\x32\x32\x0C""button_ltrig", Game::K_BUTTON_LTRIG},
        {"^\x01\x32\x32\x0C""button_rtrig", Game::K_BUTTON_RTRIG},
        {"^\x01\x32\x32\x07""dpad_up", Game::K_DPAD_UP},
        {"^\x01\x32\x32\x09""dpad_down", Game::K_DPAD_DOWN},
        {"^\x01\x32\x32\x09""dpad_left", Game::K_DPAD_LEFT},
        {"^\x01\x32\x32\x0A""dpad_right", Game::K_DPAD_RIGHT},
    };

    Game::keyname_t Gamepad::extendedLocalizedKeyNamesPs3[]
    {
        // Material text icons pattern: 0x01 width height material_name_len
        {"^\x01\x32\x32\x10""button_ps3_cross", Game::K_BUTTON_A},
        {"^\x01\x32\x32\x11""button_ps3_circle", Game::K_BUTTON_B},
        {"^\x01\x32\x32\x11""button_ps3_square", Game::K_BUTTON_X},
        {"^\x01\x32\x32\x13""button_ps3_triangle", Game::K_BUTTON_Y},
        {"^\x01\x32\x32\x0D""button_ps3_l1", Game::K_BUTTON_LSHLDR},
        {"^\x01\x32\x32\x0D""button_ps3_r1", Game::K_BUTTON_RSHLDR},
        {"^\x01\x32\x32\x10""button_ps3_start", Game::K_BUTTON_START},
        {"^\x01\x32\x32\x0F""button_ps3_back", Game::K_BUTTON_BACK},
        {"^\x01\x48\x32\x0D""button_ps3_l3", Game::K_BUTTON_LSTICK},
        {"^\x01\x48\x32\x0D""button_ps3_r3", Game::K_BUTTON_RSTICK},
        {"^\x01\x32\x32\x0D""button_ps3_l2", Game::K_BUTTON_LTRIG},
        {"^\x01\x32\x32\x0D""button_ps3_r2", Game::K_BUTTON_RTRIG},
        {"^\x01\x32\x32\x0B""dpad_ps3_up", Game::K_DPAD_UP},
        {"^\x01\x32\x32\x0D""dpad_ps3_down", Game::K_DPAD_DOWN},
        {"^\x01\x32\x32\x0D""dpad_ps3_left", Game::K_DPAD_LEFT},
        {"^\x01\x32\x32\x0E""dpad_ps3_right", Game::K_DPAD_RIGHT},
    };
    Game::keyname_t Gamepad::combinedKeyNames[Game::KEY_NAME_COUNT + std::extent_v<decltype(extendedKeyNames)> + 1];
    Game::keyname_t Gamepad::combinedLocalizedKeyNamesXenon[Game::KEY_NAME_COUNT + std::extent_v<decltype(extendedLocalizedKeyNamesXenon)> + 1];
    Game::keyname_t Gamepad::combinedLocalizedKeyNamesPs3[Game::KEY_NAME_COUNT + std::extent_v<decltype(extendedLocalizedKeyNamesPs3)> + 1];

    Gamepad::ControllerMenuKeyMapping Gamepad::controllerMenuKeyMappings[]
    {
        {Game::K_BUTTON_A, Game::K_ENTER},
        {Game::K_BUTTON_START, Game::K_ENTER},
        {Game::K_BUTTON_B, Game::K_ESCAPE},
        {Game::K_BUTTON_BACK, Game::K_ESCAPE},
        {Game::K_DPAD_UP, Game::K_UPARROW},
        {Game::K_APAD_UP, Game::K_UPARROW},
        {Game::K_DPAD_DOWN, Game::K_DOWNARROW},
        {Game::K_APAD_DOWN, Game::K_DOWNARROW},
        {Game::K_DPAD_LEFT, Game::K_LEFTARROW},
        {Game::K_APAD_LEFT, Game::K_LEFTARROW},
        {Game::K_DPAD_RIGHT, Game::K_RIGHTARROW},
        {Game::K_APAD_RIGHT, Game::K_RIGHTARROW},
    };

    Gamepad::GamePad Gamepad::gamePads[Game::MAX_GAMEPADS]{};
    Gamepad::GamePadGlobals Gamepad::gamePadGlobals[Game::MAX_GAMEPADS]{{}};
    int Gamepad::gamePadBindingsModifiedFlags = 0;

    Dvar::Var Gamepad::gpad_enabled;
    Dvar::Var Gamepad::gpad_debug;
    Dvar::Var Gamepad::gpad_present;
    Dvar::Var Gamepad::gpad_in_use;
    Dvar::Var Gamepad::gpad_style;
    Dvar::Var Gamepad::gpad_sticksConfig;
    Dvar::Var Gamepad::gpad_buttonConfig;
    Dvar::Var Gamepad::gpad_menu_scroll_delay_first;
    Dvar::Var Gamepad::gpad_menu_scroll_delay_rest;
    Dvar::Var Gamepad::gpad_rumble;
    Dvar::Var Gamepad::gpad_stick_pressed_hysteresis;
    Dvar::Var Gamepad::gpad_stick_pressed;
    Dvar::Var Gamepad::gpad_stick_deadzone_max;
    Dvar::Var Gamepad::gpad_stick_deadzone_min;
    Dvar::Var Gamepad::gpad_button_deadzone;
    Dvar::Var Gamepad::gpad_button_rstick_deflect_max;
    Dvar::Var Gamepad::gpad_button_lstick_deflect_max;
    Dvar::Var Gamepad::gpad_use_hold_time;
    Dvar::Var Gamepad::gpad_lockon_enabled;
    Dvar::Var Gamepad::gpad_slowdown_enabled;
    Dvar::Var Gamepad::input_viewSensitivity;
    Dvar::Var Gamepad::input_invertPitch;
    Dvar::Var Gamepad::sv_allowAimAssist;
    Dvar::Var Gamepad::aim_turnrate_pitch;
    Dvar::Var Gamepad::aim_turnrate_pitch_ads;
    Dvar::Var Gamepad::aim_turnrate_yaw;
    Dvar::Var Gamepad::aim_turnrate_yaw_ads;
    Dvar::Var Gamepad::aim_accel_turnrate_enabled;
    Dvar::Var Gamepad::aim_accel_turnrate_lerp;
    Dvar::Var Gamepad::aim_input_graph_enabled;
    Dvar::Var Gamepad::aim_input_graph_index;
    Dvar::Var Gamepad::aim_scale_view_axis;
    Dvar::Var Gamepad::cl_bypassMouseInput;
    Dvar::Var Gamepad::cg_mapLocationSelectionCursorSpeed;
    Dvar::Var Gamepad::aim_aimAssistRangeScale;
    Dvar::Var Gamepad::aim_slowdown_enabled;
    Dvar::Var Gamepad::aim_slowdown_debug;
    Dvar::Var Gamepad::aim_slowdown_pitch_scale;
    Dvar::Var Gamepad::aim_slowdown_pitch_scale_ads;
    Dvar::Var Gamepad::aim_slowdown_yaw_scale;
    Dvar::Var Gamepad::aim_slowdown_yaw_scale_ads;
    Dvar::Var Gamepad::aim_lockon_enabled;
    Dvar::Var Gamepad::aim_lockon_deflection;
    Dvar::Var Gamepad::aim_lockon_pitch_strength;
    Dvar::Var Gamepad::aim_lockon_strength;

    Gamepad::GamePadGlobals::GamePadGlobals()
        : axes{},
          nextScrollTime(0)
    {
        for (auto& virtualAxis : axes.virtualAxes)
        {
            virtualAxis.physicalAxis = Game::GPAD_PHYSAXIS_NONE;
            virtualAxis.mapType = Game::GPAD_MAP_NONE;
        }
    }

    __declspec(naked) void Gamepad::MSG_WriteDeltaUsercmdKeyStub()
    {
        __asm
        {
            // fix stack pointer
            add esp, 0Ch

            // put both forward move and rightmove values in the movement button
            mov dl, byte ptr[edi + 1Ah] // to_forwardMove
            mov dh, byte ptr[edi + 1Bh] // to_rightMove

            mov[esp + 30h], dx // to_buttons

            mov dl, byte ptr[ebp + 1Ah] // from_forwardMove
            mov dh, byte ptr[ebp + 1Bh] // from_rightMove

            mov[esp + 2Ch], dx // from_buttons

            // return back
            push 0x60E40E
            retn
        }
    }

    void Gamepad::ApplyMovement(Game::msg_t* msg, int key, Game::usercmd_s* from, Game::usercmd_s* to)
    {
        char forward;
        char right;

        if (Game::MSG_ReadBit(msg))
        {
            short movementBits = static_cast<short>(key ^ Game::MSG_ReadBits(msg, 16));

            forward = static_cast<char>(movementBits);
            right = static_cast<char>(movementBits >> 8);
        }
        else
        {
            forward = from->forwardmove;
            right = from->rightmove;
        }

        to->forwardmove = forward;
        to->rightmove = right;
    }

    __declspec(naked) void Gamepad::MSG_ReadDeltaUsercmdKeyStub()
    {
        __asm
        {
            push ebx // to
            push ebp // from
            push edi // key
            push esi // msg
            call ApplyMovement
            add esp, 10h

            // return back
            push 0x4921BF
            ret
        }
    }

    __declspec(naked) void Gamepad::MSG_ReadDeltaUsercmdKeyStub2()
    {
        __asm
        {
            push ebx // to
            push ebp // from
            push edi // key
            push esi // msg
            call ApplyMovement
            add esp, 10h

            // return back
            push 3
            push esi
            push 0x492085
            ret
        }
    }

    bool Gamepad::GPad_Check(const int gamePadIndex, const int portIndex)
    {
        assert(gamePadIndex < Game::MAX_GAMEPADS);
        auto& gamePad = gamePads[gamePadIndex];

        if (XInputGetCapabilities(portIndex, XINPUT_FLAG_GAMEPAD, &gamePad.caps) == ERROR_SUCCESS)
        {
            gamePad.enabled = true;
            gamePad.portIndex = portIndex;
            return true;
        }

        gamePad.enabled = false;
        return false;
    }

    void Gamepad::GPad_RefreshAll()
    {
        auto currentGamePadNum = 0;

        for (auto currentPort = 0; currentPort < XUSER_MAX_COUNT && currentGamePadNum < Game::MAX_GAMEPADS; currentPort++)
        {
            if (GPad_Check(currentGamePadNum, currentPort))
                currentGamePadNum++;
        }
    }

    float Gamepad::LinearTrack(const float target, const float current, const float rate, const float deltaTime)
    {
        const auto err = target - current;
        float step;
        if (err <= 0.0f)
            step = -rate * deltaTime;
        else
            step = rate * deltaTime;

        if (std::fabs(err) <= 0.001f)
            return target;

        if (std::fabs(step) <= std::fabs(err))
            return current + step;

        return target;
    }

    bool Gamepad::AimAssist_DoBoundsIntersectCenterBox(const float* clipMins, const float* clipMaxs, const float clipHalfWidth, const float clipHalfHeight)
    {
        return clipHalfWidth >= clipMins[0] && clipMaxs[0] >= -clipHalfWidth
            && clipHalfHeight >= clipMins[1] && clipMaxs[1] >= -clipHalfHeight;
    }

    bool Gamepad::AimAssist_IsPlayerUsingOffhand(Game::AimAssistPlayerState* ps)
    {
        // Check offhand flag
        if ((ps->weapFlags & 2) == 0)
            return false;

        // If offhand weapon has no id we are not using one
        if (!ps->weapIndex)
            return false;

        const auto* weaponDef = Game::BG_GetWeaponDef(ps->weapIndex);

        return weaponDef->offhandClass != Game::OFFHAND_CLASS_NONE;
    }

    const Game::AimScreenTarget* Gamepad::AimAssist_GetBestTarget(const Game::AimAssistGlobals* aaGlob, const float range, const float regionWidth, const float regionHeight)
    {
        const auto rangeSqr = range * range;
        for (auto targetIndex = 0; targetIndex < aaGlob->screenTargetCount; targetIndex++)
        {
            const auto* currentTarget = &aaGlob->screenTargets[targetIndex];
            if (currentTarget->distSqr <= rangeSqr && AimAssist_DoBoundsIntersectCenterBox(currentTarget->clipMins, currentTarget->clipMaxs, regionWidth, regionHeight))
            {
                return currentTarget;
            }
        }

        return nullptr;
    }

    const Game::AimScreenTarget* Gamepad::AimAssist_GetTargetFromEntity(const Game::AimAssistGlobals* aaGlob, const int entIndex)
    {
        if (entIndex == Game::AIM_TARGET_INVALID)
            return nullptr;

        for (auto targetIndex = 0; targetIndex < aaGlob->screenTargetCount; targetIndex++)
        {
            const auto* currentTarget = &aaGlob->screenTargets[targetIndex];
            if (currentTarget->entIndex == entIndex)
                return currentTarget;
        }

        return nullptr;
    }

    const Game::AimScreenTarget* Gamepad::AimAssist_GetPrevOrBestTarget(const Game::AimAssistGlobals* aaGlob, const float range, const float regionWidth, const float regionHeight,
                                                                        const int prevTargetEnt)
    {
        const auto screenTarget = AimAssist_GetTargetFromEntity(aaGlob, prevTargetEnt);

        if (screenTarget && (range * range) > screenTarget->distSqr && AimAssist_DoBoundsIntersectCenterBox(screenTarget->clipMins, screenTarget->clipMaxs, regionWidth, regionHeight))
            return screenTarget;

        return AimAssist_GetBestTarget(aaGlob, range, regionWidth, regionHeight);
    }

    bool Gamepad::AimAssist_IsLockonActive(const int gamePadIndex)
    {
        assert(gamePadIndex < Game::MAX_GAMEPADS);
        auto& aaGlob = Game::aaGlobArray[gamePadIndex];

        if (!aim_lockon_enabled.get<bool>() || !gpad_lockon_enabled.get<bool>())
            return false;

        if (AimAssist_IsPlayerUsingOffhand(&aaGlob.ps))
            return false;

        if (aaGlob.autoAimActive || aaGlob.autoMeleeState == Game::AIM_MELEE_STATE_UPDATING)
            return false;

        return true;
    }

    void Gamepad::AimAssist_ApplyLockOn(const Game::AimInput* input, Game::AimOutput* output)
    {
        assert(input);
        assert(input->localClientNum < Game::MAX_GAMEPADS);
        auto& aaGlob = Game::aaGlobArray[input->localClientNum];

        const auto prevTargetEnt = aaGlob.lockOnTargetEnt;
        aaGlob.lockOnTargetEnt = Game::AIM_TARGET_INVALID;

        if (!AimAssist_IsLockonActive(input->localClientNum))
            return;

        const auto* weaponDef = Game::BG_GetWeaponDef(aaGlob.ps.weapIndex);
        if (weaponDef->requireLockonToFire)
            return;

        const auto deflection = aim_lockon_deflection.get<float>();
        if (deflection > std::fabs(input->pitchAxis) && deflection > std::fabs(input->yawAxis) && deflection > std::fabs(input->rightAxis))
            return;

        if (!aaGlob.ps.weapIndex)
            return;

        const auto aimAssistRange = AimAssist_Lerp(weaponDef->aimAssistRange, weaponDef->aimAssistRangeAds, aaGlob.adsLerp) * aim_aimAssistRangeScale.get<float>();
        const auto screenTarget = AimAssist_GetPrevOrBestTarget(&aaGlob, aimAssistRange, aaGlob.tweakables.lockOnRegionWidth, aaGlob.tweakables.lockOnRegionHeight, prevTargetEnt);

        if (screenTarget && screenTarget->distSqr > 0.0f)
        {
            aaGlob.lockOnTargetEnt = screenTarget->entIndex;
            const auto arcLength = std::sqrt(screenTarget->distSqr) * static_cast<float>(M_PI);

            const auto pitchTurnRate =
                (screenTarget->velocity[0] * aaGlob.viewAxis[2][0] + screenTarget->velocity[1] * aaGlob.viewAxis[2][1] + screenTarget->velocity[2] * aaGlob.viewAxis[2][2]
                    - (aaGlob.ps.velocity[0] * aaGlob.viewAxis[2][0] + aaGlob.ps.velocity[1] * aaGlob.viewAxis[2][1] + aaGlob.ps.velocity[2] * aaGlob.viewAxis[2][2]))
                / arcLength * 180.0f * aim_lockon_pitch_strength.get<float>();

            const auto yawTurnRate = 
                (screenTarget->velocity[0] * aaGlob.viewAxis[1][0] + screenTarget->velocity[1] * aaGlob.viewAxis[1][1] + screenTarget->velocity[2] * aaGlob.viewAxis[1][2]
                - (aaGlob.ps.velocity[0] * aaGlob.viewAxis[1][0] + aaGlob.ps.velocity[1] * aaGlob.viewAxis[1][1] + aaGlob.ps.velocity[2] * aaGlob.viewAxis[1][2]))
            / arcLength * 180.0f * aim_lockon_strength.get<float>();

            output->pitch -= pitchTurnRate * input->deltaTime;
            output->yaw += yawTurnRate * input->deltaTime;
        }
    }

    void Gamepad::AimAssist_CalcAdjustedAxis(const Game::AimInput* input, float* pitchAxis, float* yawAxis)
    {
        assert(input);
        assert(pitchAxis);
        assert(yawAxis);

        const auto graphIndex = aim_input_graph_index.get<int>();
        if (aim_input_graph_enabled.get<bool>() && graphIndex >= 0 && static_cast<unsigned>(graphIndex) < Game::AIM_ASSIST_GRAPH_COUNT)
        {
            const auto deflection = std::sqrt(input->pitchAxis * input->pitchAxis + input->yawAxis * input->yawAxis);

            float fraction;
            if (deflection - 1.0f < 0.0f)
                fraction = deflection;
            else
                fraction = 1.0f;

            if (0.0f - deflection >= 0.0f)
                fraction = 0.0f;

            const auto graphScale = Game::GraphFloat_GetValue(&Game::aaInputGraph[graphIndex], fraction);
            *pitchAxis = input->pitchAxis * graphScale;
            *yawAxis = input->yawAxis * graphScale;
        }
        else
        {
            *pitchAxis = input->pitchAxis;
            *yawAxis = input->yawAxis;
        }

        if (aim_scale_view_axis.get<bool>())
        {
            const auto absPitchAxis = std::fabs(*pitchAxis);
            const auto absYawAxis = std::fabs(*yawAxis);

            if (absPitchAxis <= absYawAxis)
                *pitchAxis = (1.0f - (absYawAxis - absPitchAxis)) * *pitchAxis;
            else
                *yawAxis = (1.0f - (absPitchAxis - absYawAxis)) * *yawAxis;
        }
    }

    bool Gamepad::AimAssist_IsSlowdownActive(const Game::AimAssistPlayerState* ps)
    {
        if (!aim_slowdown_enabled.get<bool>() || !gpad_slowdown_enabled.get<bool>())
            return false;

        if (!ps->weapIndex)
            return false;

        const auto* weaponDef = Game::BG_GetWeaponDef(ps->weapIndex);
        if (weaponDef->requireLockonToFire)
            return false;

        if (ps->linkFlags & 4)
            return false;

        if (ps->weaponState >= Game::WEAPON_STUNNED_START && ps->weaponState <= Game::WEAPON_STUNNED_END)
            return false;

        // The game checks for these flags. Their meaning is to be researched if necessary.
        if (ps->eFlags & 0x100C00)
            return false;

        if (!ps->hasAmmo)
            return false;

        return true;
    }

    void Gamepad::AimAssist_CalcSlowdown(const Game::AimInput* input, float* pitchScale, float* yawScale)
    {
        assert(input);
        assert(input->localClientNum < Game::MAX_GAMEPADS);
        auto& aaGlob = Game::aaGlobArray[input->localClientNum];
        assert(pitchScale);
        assert(yawScale);

        *pitchScale = 1.0f;
        *yawScale = 1.0f;
        
        if (!AimAssist_IsSlowdownActive(&aaGlob.ps))
            return;

        const auto* weaponDef = Game::BG_GetWeaponDef(aaGlob.ps.weapIndex);
        const auto aimAssistRange = AimAssist_Lerp(weaponDef->aimAssistRange, weaponDef->aimAssistRangeAds, aaGlob.adsLerp) * aim_aimAssistRangeScale.get<float>();
        const auto screenTarget = AimAssist_GetBestTarget(&aaGlob, aimAssistRange, aaGlob.tweakables.slowdownRegionWidth, aaGlob.tweakables.slowdownRegionHeight);

        if (screenTarget)
        {
            *pitchScale = AimAssist_Lerp(aim_slowdown_pitch_scale.get<float>(), aim_slowdown_pitch_scale_ads.get<float>(), aaGlob.adsLerp);
            *yawScale = AimAssist_Lerp(aim_slowdown_yaw_scale.get<float>(), aim_slowdown_yaw_scale_ads.get<float>(), aaGlob.adsLerp);
        }

        if (AimAssist_IsPlayerUsingOffhand(&aaGlob.ps))
            *pitchScale = 1.0f;
    }

    float Gamepad::AimAssist_Lerp(const float from, const float to, const float fraction)
    {
        return (to - from) * fraction + from;
    }

    void Gamepad::AimAssist_ApplyTurnRates(const Game::AimInput* input, Game::AimOutput* output)
    {
        assert(input->localClientNum < Game::MAX_GAMEPADS);
        auto& aaGlob = Game::aaGlobArray[input->localClientNum];

        auto slowdownPitchScale = 0.0f;
        auto slowdownYawScale = 0.0f;
        float adjustedPitchAxis;
        float adjustedYawAxis;

        if (aaGlob.autoMeleeState == Game::AIM_MELEE_STATE_UPDATING)
        {
            adjustedPitchAxis = 0.0f;
            adjustedYawAxis = 0.0f;
            slowdownPitchScale = 1.0f;
            slowdownYawScale = 1.0f;
        }
        else
        {
            AimAssist_CalcAdjustedAxis(input, &adjustedPitchAxis, &adjustedYawAxis);
            AimAssist_CalcSlowdown(input, &slowdownPitchScale, &slowdownYawScale);
        }

        const auto sensitivity = input_viewSensitivity.get<float>();
        auto pitchTurnRate = AimAssist_Lerp(aim_turnrate_pitch.get<float>(), aim_turnrate_pitch_ads.get<float>(), aaGlob.adsLerp);
        pitchTurnRate = slowdownPitchScale * aaGlob.fovTurnRateScale * sensitivity * pitchTurnRate;
        auto yawTurnRate = AimAssist_Lerp(aim_turnrate_yaw.get<float>(), aim_turnrate_yaw_ads.get<float>(), aaGlob.adsLerp);
        yawTurnRate = slowdownYawScale * aaGlob.fovTurnRateScale * sensitivity * yawTurnRate;

        if (input->pitchMax > 0 && input->pitchMax < pitchTurnRate)
            pitchTurnRate = input->pitchMax;
        if (input->yawMax > 0 && input->yawMax < yawTurnRate)
            yawTurnRate = input->yawMax;

        const auto pitchSign = adjustedPitchAxis >= 0.0f ? 1.0f : -1.0f;
        const auto yawSign = adjustedYawAxis >= 0.0f ? 1.0f : -1.0f;

        const auto pitchDelta = std::fabs(adjustedPitchAxis) * pitchTurnRate;
        const auto yawDelta = std::fabs(adjustedYawAxis) * yawTurnRate;

        if (!aim_accel_turnrate_enabled.get<bool>())
        {
            aaGlob.pitchDelta = pitchDelta;
            aaGlob.yawDelta = yawDelta;
        }
        else
        {
            const auto accel = aim_accel_turnrate_lerp.get<float>() * sensitivity;
            if (pitchDelta <= aaGlob.pitchDelta)
                aaGlob.pitchDelta = pitchDelta;
            else
                aaGlob.pitchDelta = LinearTrack(pitchDelta, aaGlob.pitchDelta, accel, input->deltaTime);

            if (yawDelta <= aaGlob.yawDelta)
                aaGlob.yawDelta = yawDelta;
            else
                aaGlob.yawDelta = LinearTrack(yawDelta, aaGlob.yawDelta, accel, input->deltaTime);
        }

        output->pitch += aaGlob.pitchDelta * input->deltaTime * pitchSign;
        output->yaw += aaGlob.yawDelta * input->deltaTime * yawSign;
    }

    void Gamepad::AimAssist_UpdateGamePadInput(const Game::AimInput* input, Game::AimOutput* output)
    {
        assert(input->localClientNum < Game::MAX_GAMEPADS);
        auto& aaGlob = Game::aaGlobArray[input->localClientNum];

        output->pitch = input->pitch;
        output->yaw = input->yaw;

        if (aaGlob.initialized)
        {
            Game::AimAssist_UpdateTweakables(input->localClientNum);
            Game::AimAssist_UpdateAdsLerp(input);
            AimAssist_ApplyTurnRates(input, output);

            Game::AimAssist_ApplyAutoMelee(input, output);
            AimAssist_ApplyLockOn(input, output);
        }

        aaGlob.prevButtons = input->buttons;
    }

    void Gamepad::CL_RemoteControlMove_GamePad(const int localClientNum, Game::usercmd_s* cmd)
    {
        // Buttons are already handled by keyboard input handler

        const auto up = CL_GamepadAxisValue(localClientNum, Game::GPAD_VIRTAXIS_FORWARD);
        const auto right = CL_GamepadAxisValue(localClientNum, Game::GPAD_VIRTAXIS_SIDE);
        const auto yaw = CL_GamepadAxisValue(localClientNum, Game::GPAD_VIRTAXIS_YAW);
        const auto pitch = CL_GamepadAxisValue(localClientNum, Game::GPAD_VIRTAXIS_PITCH);
        const auto sensitivity = input_viewSensitivity.get<float>();

        constexpr auto scale = static_cast<float>(std::numeric_limits<char>::max());
        cmd->remoteControlAngles[0] = ClampChar(cmd->remoteControlAngles[0] + static_cast<int>(std::floor(-up * scale * sensitivity))
            + static_cast<int>(std::floor(-pitch * scale * sensitivity)));
        cmd->remoteControlAngles[1] = ClampChar(cmd->remoteControlAngles[1] + static_cast<int>(std::floor(-right * scale * sensitivity))
            + static_cast<int>(std::floor(-yaw * scale * sensitivity)));
    }

    constexpr auto CL_RemoteControlMove = 0x5A6BA0;
    __declspec(naked) void Gamepad::CL_RemoteControlMove_Stub()
    {
        __asm
        {
            // Prepare args for our function call
            push edi // usercmd
            push eax // localClientNum

            call CL_RemoteControlMove

            // Call our function, the args were already prepared earlier
            call CL_RemoteControlMove_GamePad
            add esp, 0x8

            ret
        }
    }

    bool Gamepad::CG_HandleLocationSelectionInput_GamePad(const int localClientNum, Game::usercmd_s* /*cmd*/)
    {
        // Buttons are already handled by keyboard input handler

        const auto frameTime = static_cast<float>(Game::cgArray[0].frametime) * 0.001f;
        const auto mapAspectRatio = Game::cgArray[0].compassMapWorldSize[0] / Game::cgArray[0].compassMapWorldSize[1];
        const auto selectionRequiresAngle = (Game::cgArray[0].predictedPlayerState.locationSelectionInfo & 0x80) != 0;

        auto up = CL_GamepadAxisValue(localClientNum, Game::GPAD_VIRTAXIS_FORWARD);
        auto right = CL_GamepadAxisValue(localClientNum, Game::GPAD_VIRTAXIS_SIDE);
        auto magnitude = up * up + right * right;

        if (magnitude > 1.0f)
        {
            magnitude = std::sqrt(magnitude);
            up /= magnitude;
            right /= magnitude;
        }

        Game::cgArray[0].selectedLocation[0] += right * cg_mapLocationSelectionCursorSpeed.get<float>() * frameTime;
        Game::cgArray[0].selectedLocation[1] -= up * mapAspectRatio * cg_mapLocationSelectionCursorSpeed.get<float>() * frameTime;

        if (selectionRequiresAngle)
        {
            const auto yawUp = CL_GamepadAxisValue(localClientNum, Game::GPAD_VIRTAXIS_PITCH);
            const auto yawRight = CL_GamepadAxisValue(localClientNum, Game::GPAD_VIRTAXIS_YAW);

            if (std::fabs(yawUp) > 0.0f || std::fabs(yawRight) > 0.0f)
            {
                Game::vec2_t vec
                {
                    yawUp,
                    -yawRight
                };

                Game::cgArray[0].selectedLocationAngle = Game::AngleNormalize360(Game::vectoyaw(&vec));
                Game::cgArray[0].selectedAngleLocation[0] = Game::cgArray[0].selectedLocation[0];
                Game::cgArray[0].selectedAngleLocation[1] = Game::cgArray[0].selectedLocation[1];
            }
        }
        else
        {
            Game::cgArray[0].selectedAngleLocation[0] = Game::cgArray[0].selectedLocation[0];
            Game::cgArray[0].selectedAngleLocation[1] = Game::cgArray[0].selectedLocation[1];
        }

        return true;
    }

    constexpr auto CG_HandleLocationSelectionInput = 0x5A67A0;
    __declspec(naked) void Gamepad::CG_HandleLocationSelectionInput_Stub()
    {
        __asm
        {
            // Prepare args for our function call
            push esi // usercmd
            push eax // localClientNum

            call CG_HandleLocationSelectionInput

            test al,al
            jz exit_handling

            // Call our function, the args were already prepared earlier
            call CG_HandleLocationSelectionInput_GamePad

        exit_handling:
            add esp, 0x8
            ret
        }
    }

    bool Gamepad::CG_ShouldUpdateViewAngles(const int localClientNum)
    {
        return !Game::Key_IsKeyCatcherActive(localClientNum, Game::KEYCATCH_MASK_ANY) || Game::UI_GetActiveMenu(localClientNum) == Game::UIMENU_SCOREBOARD;
    }

    float Gamepad::CL_GamepadAxisValue(const int gamePadIndex, const Game::GamepadVirtualAxis virtualAxis)
    {
        assert(gamePadIndex < Game::MAX_GAMEPADS);
        assert(virtualAxis > Game::GPAD_VIRTAXIS_NONE && virtualAxis < Game::GPAD_VIRTAXIS_COUNT);
        const auto& gamePadGlobal = gamePadGlobals[gamePadIndex];

        const auto& [physicalAxis, mapType] = gamePadGlobal.axes.virtualAxes[virtualAxis];

        if (physicalAxis <= Game::GPAD_PHYSAXIS_NONE || physicalAxis >= Game::GPAD_PHYSAXIS_COUNT)
            return 0.0f;

        auto axisDeflection = gamePadGlobal.axes.axesValues[physicalAxis];

        if (mapType == Game::GPAD_MAP_SQUARED)
        {
            const auto otherAxisSameStick = axisSameStick[physicalAxis];

            float otherAxisDeflection;
            if (otherAxisSameStick <= Game::GPAD_PHYSAXIS_NONE || otherAxisSameStick >= Game::GPAD_PHYSAXIS_COUNT)
                otherAxisDeflection = 0.0f;
            else
                otherAxisDeflection = gamePadGlobal.axes.axesValues[otherAxisSameStick];

            axisDeflection = std::sqrt(axisDeflection * axisDeflection + otherAxisDeflection * otherAxisDeflection) * axisDeflection;
        }

        return axisDeflection;
    }

    char Gamepad::ClampChar(const int value)
    {
        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)
    {
        assert(gamePadIndex < Game::MAX_GAMEPADS);
        auto& gamePad = gamePads[gamePadIndex];
        auto& clientActive = Game::clients[gamePadIndex];

        if (!gpad_enabled.get<bool>() || !gamePad.enabled)
            return;

        auto pitch = CL_GamepadAxisValue(gamePadIndex, Game::GPAD_VIRTAXIS_PITCH);
        if (!input_invertPitch.get<bool>())
            pitch *= -1;

        auto yaw = -CL_GamepadAxisValue(gamePadIndex, Game::GPAD_VIRTAXIS_YAW);
        auto forward = CL_GamepadAxisValue(gamePadIndex, Game::GPAD_VIRTAXIS_FORWARD);
        auto side = CL_GamepadAxisValue(gamePadIndex, 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.
        //auto attack = CL_GamepadAxisValue(gamePadIndex, Game::GPAD_VIRTAXIS_ATTACK);

        auto moveScale = static_cast<float>(std::numeric_limits<char>::max());

        if (std::fabs(side) > 0.0f || std::fabs(forward) > 0.0f)
        {
            const auto length = std::fabs(side) <= std::fabs(forward)
                                    ? side / forward
                                    : forward / side;
            moveScale = std::sqrt((length * length) + 1.0f) * moveScale;
        }

        const auto forwardMove = static_cast<int>(std::floor(forward * moveScale));
        const auto rightMove = static_cast<int>(std::floor(side * moveScale));

        cmd->rightmove = ClampChar(cmd->rightmove + rightMove);
        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"
        if(gamePad.inUse && clientActive.snap.ps.weapCommon.lastWeaponHand == Game::WEAPON_HAND_LEFT)
        {
            auto oldButtons = cmd->buttons;
            if (oldButtons & Game::CMD_BUTTON_ATTACK)
                cmd->buttons |= Game::CMD_BUTTON_THROW;
            else
                cmd->buttons &= ~Game::CMD_BUTTON_THROW;

            if (oldButtons & Game::CMD_BUTTON_THROW)
                cmd->buttons |= Game::CMD_BUTTON_ATTACK;
            else
                cmd->buttons &= ~Game::CMD_BUTTON_ATTACK;
        }

        // Check for frozen controls. Flag name should start with PMF_
        if (CG_ShouldUpdateViewAngles(gamePadIndex) && (clientActive.snap.ps.pm_flags & 0x800) == 0)
        {
            Game::AimInput aimInput{};
            Game::AimOutput aimOutput{};
            aimInput.deltaTime = frameTimeBase;
            aimInput.buttons = cmd->buttons;
            aimInput.localClientNum = gamePadIndex;
            aimInput.deltaTimeScaled = static_cast<float>(Game::cls->frametime) * 0.001f;
            aimInput.pitch = clientActive.clViewangles[0];
            aimInput.pitchAxis = pitch;
            aimInput.pitchMax = clientActive.cgameMaxPitchSpeed;
            aimInput.yaw = clientActive.clViewangles[1];
            aimInput.yawAxis = yaw;
            aimInput.yawMax = clientActive.cgameMaxYawSpeed;
            aimInput.forwardAxis = forward;
            aimInput.rightAxis = side;
            AimAssist_UpdateGamePadInput(&aimInput, &aimOutput);
            clientActive.clViewangles[0] = aimOutput.pitch;
            clientActive.clViewangles[1] = aimOutput.yaw;
            cmd->meleeChargeDist = aimOutput.meleeChargeDist;
            cmd->meleeChargeYaw = aimOutput.meleeChargeYaw;
        }
    }

    constexpr auto CL_MouseMove = 0x5A6240;
    __declspec(naked) void Gamepad::CL_MouseMove_Stub()
    {
        __asm
        {
            // Prepare args for our function call
            push [esp+0x4] // frametime_base
            push ebx // cmd
            push eax // localClientNum

            push [esp+0x8] // restore frametime_base on the stack
            call CL_MouseMove
            add esp,4

            // Call our function, the args were already prepared earlier
            call CL_GamepadMove
            add esp,0xC

            ret
        }
    }

    bool Gamepad::Gamepad_ShouldUse(const Game::gentity_s* playerEnt, const unsigned useTime)
    {
        // Only apply hold time to +usereload keybind
        return !(playerEnt->client->buttons & Game::CMD_BUTTON_USE_RELOAD) || useTime >= static_cast<unsigned>(gpad_use_hold_time.get<int>());
    }

    __declspec(naked) void Gamepad::Player_UseEntity_Stub()
    {
        __asm
        {
            // Execute overwritten instructions
            cmp eax, [ecx + 0x10]
            jl skipUse

            // Call our custom check
            push eax
            pushad
            push eax
            push edi
            call Gamepad_ShouldUse
            add esp, 8h
            mov [esp + 0x20], eax
            popad
            pop eax

            // Skip use if custom check returns false
            test al, al
            jz skipUse

            // perform use
            push 0x5FE39B
            ret

        skipUse:
            push 0x5FE3AF
            ret
        }
    }

    bool Gamepad::Key_IsValidGamePadChar(const int key)
    {
        return key >= Game::K_FIRSTGAMEPADBUTTON_RANGE_1 && key <= Game::K_LASTGAMEPADBUTTON_RANGE_1
            || key >= Game::K_FIRSTGAMEPADBUTTON_RANGE_2 && key <= Game::K_LASTGAMEPADBUTTON_RANGE_2
            || 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)
    {
        assert(gamePadIndex < Game::MAX_GAMEPADS);
        auto& gamePadGlobal = gamePadGlobals[gamePadIndex];

        if (!down)
            return;

        const auto scrollDelayFirst = gpad_menu_scroll_delay_first.get<int>();
        for (const auto scrollButton : menuScrollButtonList)
        {
            if (key == scrollButton)
            {
                gamePadGlobal.nextScrollTime = scrollDelayFirst + time;
                return;
            }
        }
    }

    void Gamepad::CL_GamepadGenerateAPad(const int gamePadIndex, const Game::GamepadPhysicalAxis physicalAxis, unsigned time)
    {
        assert(gamePadIndex < Game::MAX_GAMEPADS);
        assert(physicalAxis < Game::GPAD_PHYSAXIS_COUNT && physicalAxis >= 0);

        auto& gamePad = gamePads[gamePadIndex];

        const auto stick = stickForAxis[physicalAxis];
        const auto stickIndex = stick & Game::GPAD_VALUE_MASK;
        if (stick != Game::GPAD_INVALID)
        {
            assert(stickIndex < 4);
            const auto& mapping = analogStickList[stickIndex];

            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;
                CL_GamepadButtonEvent(gamePadIndex, mapping.posCode, event, time);
            }
            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;
                CL_GamepadButtonEvent(gamePadIndex, mapping.negCode, event, time);
            }
            else if (gamePad.stickDownLast[stickIndex][Game::GPAD_STICK_POS])
            {
                CL_GamepadButtonEvent(gamePadIndex, mapping.posCode, Game::GPAD_BUTTON_RELEASED, time);
            }
            else if (gamePad.stickDownLast[stickIndex][Game::GPAD_STICK_NEG])
            {
                CL_GamepadButtonEvent(gamePadIndex, mapping.negCode, Game::GPAD_BUTTON_RELEASED, time);
            }
        }
    }

    void Gamepad::CL_GamepadEvent(const int gamePadIndex, const Game::GamepadPhysicalAxis physicalAxis, const float value, const unsigned time)
    {
        assert(gamePadIndex < Game::MAX_GAMEPADS);
        assert(physicalAxis < Game::GPAD_PHYSAXIS_COUNT && physicalAxis >= 0);

        auto& gamePad = gamePads[gamePadIndex];
        auto& gamePadGlobal = gamePadGlobals[gamePadIndex];

        gamePadGlobal.axes.axesValues[physicalAxis] = value;
        CL_GamepadGenerateAPad(gamePadIndex, physicalAxis, time);

        if (std::fabs(value) > 0.0f)
        {
            gamePad.inUse = true;
            gpad_in_use.setRaw(true);
        }
    }

    void Gamepad::UI_GamepadKeyEvent(const int gamePadIndex, const int key, const bool down)
    {
        for (const auto& mapping : controllerMenuKeyMappings)
        {
            if (mapping.controllerKey == key)
            {
                Game::UI_KeyEvent(gamePadIndex, mapping.pcKey, down);
                return;
            }
        }

        // 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);
    }

    bool Gamepad::Scoreboard_HandleInput(int gamePadIndex, int key)
    {
        assert(gamePadIndex < Game::MAX_GAMEPADS);
        auto& keyState = Game::playerKeys[gamePadIndex];

        if (keyState.keys[key].binding && strcmp(keyState.keys[key].binding, "togglescores") == 0)
        {
            Game::Cbuf_AddText(gamePadIndex, "togglescores\n");
            return true;
        }

        switch (key)
        {
        case Game::K_DPAD_UP:
            Game::CG_ScrollScoreboardUp(Game::cgArray);
            return true;

        case Game::K_DPAD_DOWN:
            Game::CG_ScrollScoreboardDown(Game::cgArray);
            return true;

        default:
            return false;
        }
    }

    bool Gamepad::CL_CheckForIgnoreDueToRepeat(const int gamePadIndex, const int key, const int repeatCount, const unsigned time)
    {
        assert(gamePadIndex < Game::MAX_GAMEPADS);
        auto& gamePadGlobal = gamePadGlobals[gamePadIndex];

        if (Game::Key_IsKeyCatcherActive(gamePadIndex, Game::KEYCATCH_UI))
        {
            const int scrollDelayFirst = gpad_menu_scroll_delay_first.get<int>();
            const int scrollDelayRest = gpad_menu_scroll_delay_rest.get<int>();

            for (const auto menuScrollButton : menuScrollButtonList)
            {
                if (key == menuScrollButton)
                {
                    if (repeatCount == 1)
                    {
                        gamePadGlobal.nextScrollTime = time + scrollDelayFirst;
                        return false;
                    }

                    if (time > gamePadGlobal.nextScrollTime)
                    {
                        gamePadGlobal.nextScrollTime = time + scrollDelayRest;
                        return false;
                    }
                    break;
                }
            }
        }

        return repeatCount > 1;
    }

    void Gamepad::CL_GamepadButtonEvent(const int gamePadIndex, const int key, const Game::GamePadButtonEvent buttonEvent, const unsigned time)
    {
        assert(gamePadIndex < Game::MAX_GAMEPADS);

        const auto pressed = buttonEvent == Game::GPAD_BUTTON_PRESSED;
        const auto pressedOrUpdated = pressed || buttonEvent == Game::GPAD_BUTTON_UPDATE;

        auto& keyState = Game::playerKeys[gamePadIndex];
        keyState.keys[key].down = pressedOrUpdated;

        if (pressedOrUpdated)
        {
            if (++keyState.keys[key].repeats == 1)
                keyState.anyKeyDown++;
        }
        else if (buttonEvent == Game::GPAD_BUTTON_RELEASED && keyState.keys[key].repeats > 0)
        {
            keyState.keys[key].repeats = 0;
            if (--keyState.anyKeyDown < 0)
                keyState.anyKeyDown = 0;
        }

        if (pressedOrUpdated && CL_CheckForIgnoreDueToRepeat(gamePadIndex, key, keyState.keys[key].repeats, time))
            return;

        if (Game::Key_IsKeyCatcherActive(gamePadIndex, Game::KEYCATCH_LOCATION_SELECTION) && pressedOrUpdated)
        {
            if (key == Game::K_BUTTON_B || keyState.keys[key].binding && strcmp(keyState.keys[key].binding, "+actionslot 4") == 0)
            {
                keyState.locSelInputState = Game::LOC_SEL_INPUT_CANCEL;
            }
            else if (key == Game::K_BUTTON_A || keyState.keys[key].binding && strcmp(keyState.keys[key].binding, "+attack") == 0)
            {
                keyState.locSelInputState = Game::LOC_SEL_INPUT_CONFIRM;
            }
            return;
        }

        const auto activeMenu = Game::UI_GetActiveMenu(gamePadIndex);
        if(activeMenu == Game::UIMENU_SCOREBOARD)
        {
            if (buttonEvent == Game::GPAD_BUTTON_PRESSED && Scoreboard_HandleInput(gamePadIndex, key))
                return;
        }

        keyState.locSelInputState = Game::LOC_SEL_INPUT_NONE;

        const auto* keyBinding = keyState.keys[key].binding;

        char cmd[1024];
        if (pressedOrUpdated)
        {
            if (Game::Key_IsKeyCatcherActive(gamePadIndex, Game::KEYCATCH_UI))
            {
                UI_GamepadKeyEvent(gamePadIndex, key, pressedOrUpdated);
                return;
            }

            if (keyBinding)
            {
                if (keyBinding[0] == '+')
                {
                    sprintf_s(cmd, "%s %i %i\n", keyBinding, key, time);
                    Game::Cbuf_AddText(gamePadIndex, cmd);
                }
                else
                {
                    Game::Cbuf_AddText(gamePadIndex, keyBinding);
                    Game::Cbuf_AddText(gamePadIndex, "\n");
                }
            }
        }
        else
        {
            if (keyBinding && keyBinding[0] == '+')
            {
                sprintf_s(cmd, "-%s %i %i\n", &keyBinding[1], key, time);
                Game::Cbuf_AddText(gamePadIndex, cmd);
            }

            if (Game::Key_IsKeyCatcherActive(gamePadIndex, Game::KEYCATCH_UI))
            {
                UI_GamepadKeyEvent(gamePadIndex, key, pressedOrUpdated);
            }
        }
    }

    void Gamepad::CL_GamepadButtonEventForPort(const int gamePadIndex, const int key, const Game::GamePadButtonEvent buttonEvent, const unsigned time)
    {
        assert(gamePadIndex < Game::MAX_GAMEPADS);
        auto& gamePad = gamePads[gamePadIndex];

        gamePad.inUse = true;
        gpad_in_use.setRaw(true);

        if (Game::Key_IsKeyCatcherActive(gamePadIndex, Game::KEYCATCH_UI))
            CL_GamepadResetMenuScrollTime(gamePadIndex, key, buttonEvent == Game::GPAD_BUTTON_PRESSED, time);


        CL_GamepadButtonEvent(gamePadIndex, key, buttonEvent, time);
    }

    void Gamepad::GPad_ConvertStickToFloat(const short x, const short y, float& outX, float& outY)
    {
        if(x == 0 && y == 0)
        {
            outX = 0.0f;
            outY = 0.0f;
            return;
        }

        Game::vec2_t stickVec;
        stickVec[0] = static_cast<float>(x) / static_cast<float>(std::numeric_limits<short>::max());
        stickVec[1] = static_cast<float>(y) / static_cast<float>(std::numeric_limits<short>::max());

        const auto deadZoneTotal = gpad_stick_deadzone_min.get<float>() + gpad_stick_deadzone_max.get<float>();
        auto len = Game::Vec2Normalize(stickVec);

        if (gpad_stick_deadzone_min.get<float>() <= len)
        {
            if (1.0f - gpad_stick_deadzone_max.get<float>() >= len)
                len = (len - gpad_stick_deadzone_min.get<float>()) / (1.0f - deadZoneTotal);
            else
                len = 1.0f;
        }
        else
            len = 0.0f;

        outX = stickVec[0] * len;
        outY = stickVec[1] * len;
    }

    float Gamepad::GPad_GetStick(const int gamePadIndex, const Game::GamePadStick stick)
    {
        assert(gamePadIndex < Game::MAX_GAMEPADS);
        auto& gamePad = gamePads[gamePadIndex];

        return gamePad.sticks[stick];
    }

    float Gamepad::GPad_GetButton(const int gamePadIndex, Game::GamePadButton button)
    {
        assert(gamePadIndex < Game::MAX_GAMEPADS);
        auto& gamePad = gamePads[gamePadIndex];

        float value = 0.0f;

        if (button & Game::GPAD_DIGITAL_MASK)
        {
            const auto buttonValue = button & Game::GPAD_VALUE_MASK;
            value = buttonValue & gamePad.digitals ? 1.0f : 0.0f;
        }
        else if (button & Game::GPAD_ANALOG_MASK)
        {
            const auto analogIndex = button & Game::GPAD_VALUE_MASK;
            if (analogIndex < std::extent_v<decltype(gamePad.analogs)>)
            {
                value = gamePad.analogs[analogIndex];
            }
        }

        return value;
    }

    bool Gamepad::GPad_IsButtonPressed(const int gamePadIndex, Game::GamePadButton button)
    {
        assert(gamePadIndex < Game::MAX_GAMEPADS);
        auto& gamePad = gamePads[gamePadIndex];

        bool down = false;
        bool lastDown = false;

        if (button & Game::GPAD_DIGITAL_MASK)
        {
            const auto buttonValue = button & Game::GPAD_VALUE_MASK;
            down = (buttonValue & gamePad.digitals) != 0;
            lastDown = (buttonValue & gamePad.lastDigitals) != 0;
        }
        else if (button & Game::GPAD_ANALOG_MASK)
        {
            const auto analogIndex = button & Game::GPAD_VALUE_MASK;
            assert(analogIndex < std::extent_v<decltype(gamePad.analogs)>);

            if (analogIndex < std::extent_v<decltype(gamePad.analogs)>)
            {
                down = gamePad.analogs[analogIndex] > 0.0f;
                lastDown = gamePad.lastAnalogs[analogIndex] > 0.0f;
            }
        }

        return down && !lastDown;
    }

    bool Gamepad::GPad_ButtonRequiresUpdates(const int gamePadIndex, Game::GamePadButton button)
    {
        return (button & Game::GPAD_ANALOG_MASK || button & Game::GPAD_DPAD_MASK) && GPad_GetButton(gamePadIndex, button) > 0.0f;
    }

    bool Gamepad::GPad_IsButtonReleased(int gamePadIndex, Game::GamePadButton button)
    {
        assert(gamePadIndex < Game::MAX_GAMEPADS);
        auto& gamePad = gamePads[gamePadIndex];

        bool down = false;
        bool lastDown = false;

        if (button & Game::GPAD_DIGITAL_MASK)
        {
            const auto buttonValue = button & Game::GPAD_VALUE_MASK;

            down = (gamePad.digitals & buttonValue) != 0;
            lastDown = (gamePad.lastDigitals & buttonValue) != 0;
        }
        else if (button & Game::GPAD_ANALOG_MASK)
        {
            const auto analogIndex = button & Game::GPAD_VALUE_MASK;
            assert(analogIndex < std::extent_v<decltype(gamePad.analogs)>);

            if (analogIndex < std::extent_v<decltype(gamePad.analogs)>)
            {
                down = gamePad.analogs[analogIndex] > 0.0f;
                lastDown = gamePad.lastAnalogs[analogIndex] > 0.0f;
            }
        }

        return !down && lastDown;
    }

    void Gamepad::GPad_UpdateSticksDown(const int gamePadIndex)
    {
        assert(gamePadIndex < Game::MAX_GAMEPADS);
        auto& gamePad = gamePads[gamePadIndex];

        for (auto stickIndex = 0u; stickIndex < std::extent_v<decltype(GamePad::sticks)>; stickIndex++)
        {
            for (auto dir = 0; dir < Game::GPAD_STICK_DIR_COUNT; dir++)
            {
                gamePad.stickDownLast[stickIndex][dir] = gamePad.stickDown[stickIndex][dir];

                auto threshold = gpad_stick_pressed.get<float>();

                if (gamePad.stickDownLast[stickIndex][dir])
                    threshold -= gpad_stick_pressed_hysteresis.get<float>();
                else
                    threshold += gpad_stick_pressed_hysteresis.get<float>();

                if (dir == Game::GPAD_STICK_POS)
                {
                    gamePad.stickDown[stickIndex][dir] = gamePad.sticks[stickIndex] > threshold;
                }
                else
                {
                    assert(dir == Game::GPAD_STICK_NEG);
                    gamePad.stickDown[stickIndex][dir] = gamePad.sticks[stickIndex] < -threshold;
                }
            }
        }
    }

    void Gamepad::GPad_UpdateSticks(const int gamePadIndex, const XINPUT_GAMEPAD& state)
    {
        assert(gamePadIndex < Game::MAX_GAMEPADS);

        auto& gamePad = gamePads[gamePadIndex];

        Game::vec2_t lVec, rVec;
        GPad_ConvertStickToFloat(state.sThumbLX, state.sThumbLY, lVec[0], lVec[1]);
        GPad_ConvertStickToFloat(state.sThumbRX, state.sThumbRY, rVec[0], rVec[1]);

        gamePad.lastSticks[0] = gamePad.sticks[0];
        gamePad.sticks[0] = lVec[0];
        gamePad.lastSticks[1] = gamePad.sticks[1];
        gamePad.sticks[1] = lVec[1];
        gamePad.lastSticks[2] = gamePad.sticks[2];
        gamePad.sticks[2] = rVec[0];
        gamePad.lastSticks[3] = gamePad.sticks[3];
        gamePad.sticks[3] = rVec[1];

        GPad_UpdateSticksDown(gamePadIndex);

#ifdef DEBUG
        if (gpad_debug.get<bool>())
        {
            Logger::Print("Left: X: %f Y: %f\n", lVec[0], lVec[1]);
            Logger::Print("Right: X: %f Y: %f\n", rVec[0], rVec[1]);
            Logger::Print("Down: %i:%i %i:%i %i:%i %i:%i\n", gamePad.stickDown[0][Game::GPAD_STICK_POS], gamePad.stickDown[0][Game::GPAD_STICK_NEG],
                          gamePad.stickDown[1][Game::GPAD_STICK_POS], gamePad.stickDown[1][Game::GPAD_STICK_NEG],
                          gamePad.stickDown[2][Game::GPAD_STICK_POS], gamePad.stickDown[2][Game::GPAD_STICK_NEG],
                          gamePad.stickDown[3][Game::GPAD_STICK_POS], gamePad.stickDown[3][Game::GPAD_STICK_NEG]);
        }
#endif
    }

    void Gamepad::GPad_UpdateDigitals(const int gamePadIndex, const XINPUT_GAMEPAD& state)
    {
        assert(gamePadIndex < Game::MAX_GAMEPADS);

        auto& gamePad = gamePads[gamePadIndex];

        gamePad.lastDigitals = gamePad.digitals;
        gamePad.digitals = state.wButtons;

        const auto leftDeflect = gpad_button_lstick_deflect_max.get<float>();
        if (std::fabs(gamePad.sticks[0]) > leftDeflect || std::fabs(gamePad.sticks[1]) > leftDeflect)
            gamePad.digitals &= ~static_cast<short>(XINPUT_GAMEPAD_LEFT_THUMB);
        const auto rightDeflect = gpad_button_rstick_deflect_max.get<float>();
        if (std::fabs(gamePad.sticks[2]) > leftDeflect || std::fabs(gamePad.sticks[3]) > rightDeflect)
            gamePad.digitals &= ~static_cast<short>(XINPUT_GAMEPAD_RIGHT_THUMB);

#ifdef DEBUG
        if (gpad_debug.get<bool>())
        {
            Logger::Print("Buttons: %x\n", gamePad.digitals);
        }
#endif
    }

    void Gamepad::GPad_UpdateAnalogs(const int gamePadIndex, const XINPUT_GAMEPAD& state)
    {
        assert(gamePadIndex < Game::MAX_GAMEPADS);

        auto& gamePad = gamePads[gamePadIndex];

        const auto buttonDeadZone = gpad_button_deadzone.get<float>();

        gamePad.lastAnalogs[0] = gamePad.analogs[0];
        gamePad.analogs[0] = static_cast<float>(state.bLeftTrigger) / static_cast<float>(std::numeric_limits<unsigned char>::max());
        if (gamePad.analogs[0] < buttonDeadZone)
            gamePad.analogs[0] = 0.0f;


        gamePad.lastAnalogs[1] = gamePad.analogs[1];
        gamePad.analogs[1] = static_cast<float>(state.bRightTrigger) / static_cast<float>(std::numeric_limits<unsigned char>::max());
        if (gamePad.analogs[1] < buttonDeadZone)
            gamePad.analogs[1] = 0.0f;

#ifdef DEBUG
        if (gpad_debug.get<bool>())
        {
            Logger::Print("Triggers: %f %f\n", gamePad.analogs[0], gamePad.analogs[1]);
        }
#endif
    }

    void Gamepad::GPad_UpdateAll()
    {
        GPad_RefreshAll();

        for (auto currentGamePadIndex = 0; currentGamePadIndex < Game::MAX_GAMEPADS; currentGamePadIndex++)
        {
            const auto& gamePad = gamePads[currentGamePadIndex];
            if (!gamePad.enabled)
                continue;

            XINPUT_STATE inputState;
            if (XInputGetState(gamePad.portIndex, &inputState) != ERROR_SUCCESS)
                continue;

            GPad_UpdateSticks(currentGamePadIndex, inputState.Gamepad);
            GPad_UpdateDigitals(currentGamePadIndex, inputState.Gamepad);
            GPad_UpdateAnalogs(currentGamePadIndex, inputState.Gamepad);
        }
    }

    void Gamepad::IN_GamePadsMove()
    {
        if (!gpad_enabled.get<bool>())
            return;

        GPad_UpdateAll();
        const auto time = Game::Sys_Milliseconds();

        bool gpadPresent = false;
        for (auto gamePadIndex = 0; gamePadIndex < Game::MAX_GAMEPADS; gamePadIndex++)
        {
            const auto& gamePad = gamePads[gamePadIndex];

            if (gamePad.enabled)
            {
                gpadPresent = true;
                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);
                CL_GamepadEvent(gamePadIndex, Game::GPAD_PHYSAXIS_LSTICK_Y, ly, time);
                CL_GamepadEvent(gamePadIndex, Game::GPAD_PHYSAXIS_RSTICK_X, rx, time);
                CL_GamepadEvent(gamePadIndex, Game::GPAD_PHYSAXIS_RSTICK_Y, ry, time);
                CL_GamepadEvent(gamePadIndex, Game::GPAD_PHYSAXIS_LTRIGGER, leftTrig, time);
                CL_GamepadEvent(gamePadIndex, Game::GPAD_PHYSAXIS_RTRIGGER, rightTrig, time);

                for (const auto& buttonMapping : buttonList)
                {
                    if (GPad_IsButtonPressed(gamePadIndex, buttonMapping.padButton))
                    {
                        CL_GamepadButtonEventForPort(
                            gamePadIndex,
                            buttonMapping.code,
                            Game::GPAD_BUTTON_PRESSED,
                            time);
                    }
                    else if (GPad_ButtonRequiresUpdates(gamePadIndex, buttonMapping.padButton))
                    {
                        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);
                    }
                }
            }
        }

        gpad_present.setRaw(gpadPresent);
    }


    void Gamepad::IN_Frame_Hk()
    {
        // Call original method
        Utils::Hook::Call<void()>(0x64C490)();

        IN_GamePadsMove();
    }

    void Gamepad::Gamepad_WriteBindings(const int gamePadIndex, const int handle)
    {
        assert(gamePadIndex < Game::MAX_GAMEPADS);
        auto& gamePadGlobal = gamePadGlobals[gamePadIndex];

        Game::FS_Printf(handle, "unbindallaxis\n");

        for (auto virtualAxisIndex = 0u; virtualAxisIndex < Game::GPAD_VIRTAXIS_COUNT; virtualAxisIndex++)
        {
            const auto& axisMapping = gamePadGlobal.axes.virtualAxes[virtualAxisIndex];
            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)
            {
                continue;
            }

            const auto* physicalAxisName = physicalAxisNames[axisMapping.physicalAxis];
            const auto* virtualAxisName = virtualAxisNames[virtualAxisIndex];
            const auto* mappingName = gamePadMappingTypeNames[axisMapping.mapType];

            Game::FS_Printf(handle, "bindaxis %s %s %s\n", physicalAxisName, virtualAxisName, mappingName);
        }
    }

    void Gamepad::Key_WriteBindings_Hk(const int localClientNum, const int handle)
    {
        // Call original function
        Utils::Hook::Call<void(int, int)>(0x4A5A20)(localClientNum, handle);

        Gamepad_WriteBindings(0, handle);
    }

    void __declspec(naked) Gamepad::Com_WriteConfiguration_Modified_Stub()
    {
        __asm
        {
            mov eax, [ecx + 0x18]
            or eax, gamePadBindingsModifiedFlags // Also check for gamePadBindingsModifiedFlags
            test al, 1
            jz endMethod
            mov gamePadBindingsModifiedFlags, 0 // Reset gamePadBindingsModifiedFlags
            mov eax, [ecx + 0x18] // Restore eax to dvar_modified_flags

            push 0x60B26E
            retn

            endMethod:
            push 0x60B298
            retn
        }
    }

    void Gamepad::Gamepad_BindAxis(const int gamePadIndex, const Game::GamepadPhysicalAxis realIndex, const Game::GamepadVirtualAxis axisIndex, const Game::GamepadMapping mapType)
    {
        assert(gamePadIndex < Game::MAX_GAMEPADS);
        assert(realIndex > Game::GPAD_PHYSAXIS_NONE && realIndex < Game::GPAD_PHYSAXIS_COUNT);
        assert(axisIndex > Game::GPAD_VIRTAXIS_NONE && axisIndex < Game::GPAD_VIRTAXIS_COUNT);
        assert(mapType > Game::GPAD_MAP_NONE && mapType < Game::GPAD_MAP_COUNT);

        auto& gamePadGlobal = gamePadGlobals[gamePadIndex];
        gamePadGlobal.axes.virtualAxes[axisIndex].physicalAxis = realIndex;
        gamePadGlobal.axes.virtualAxes[axisIndex].mapType = mapType;

        gamePadBindingsModifiedFlags |= 1;
    }

    Game::GamepadPhysicalAxis Gamepad::StringToPhysicalAxis(const char* str)
    {
        for (auto i = 0u; i < std::extent_v<decltype(physicalAxisNames)>; i++)
        {
            if (strcmp(str, physicalAxisNames[i]) == 0)
                return static_cast<Game::GamepadPhysicalAxis>(i);
        }

        return Game::GPAD_PHYSAXIS_NONE;
    }

    Game::GamepadVirtualAxis Gamepad::StringToVirtualAxis(const char* str)
    {
        for (auto i = 0u; i < std::extent_v<decltype(virtualAxisNames)>; i++)
        {
            if (strcmp(str, virtualAxisNames[i]) == 0)
                return static_cast<Game::GamepadVirtualAxis>(i);
        }

        return Game::GPAD_VIRTAXIS_NONE;
    }

    Game::GamepadMapping Gamepad::StringToGamePadMapping(const char* str)
    {
        for (auto i = 0u; i < std::extent_v<decltype(gamePadMappingTypeNames)>; i++)
        {
            if (strcmp(str, gamePadMappingTypeNames[i]) == 0)
                return static_cast<Game::GamepadMapping>(i);
        }

        return Game::GPAD_MAP_NONE;
    }

    void Gamepad::Axis_Bind_f(Command::Params* params)
    {
        if (params->length() < 4)
        {
            Logger::Print("bindaxis <real axis> <virtual axis> <input type>\n");
            return;
        }

        const auto* physicalAxisText = params->get(1);
        const auto* virtualAxisText = params->get(2);
        const auto* mappingText = params->get(3);

        const Game::GamepadPhysicalAxis physicalAxis = StringToPhysicalAxis(physicalAxisText);
        if (physicalAxis == Game::GPAD_PHYSAXIS_NONE)
        {
            Logger::Print("\"%s\" isn't a valid physical axis\n", physicalAxisText);
            return;
        }

        const Game::GamepadVirtualAxis virtualAxis = StringToVirtualAxis(virtualAxisText);
        if (virtualAxis == Game::GPAD_VIRTAXIS_NONE)
        {
            Logger::Print("\"%s\" isn't a valid virtual axis\n", virtualAxisText);
            return;
        }

        const Game::GamepadMapping mapping = StringToGamePadMapping(mappingText);
        if (mapping == Game::GPAD_MAP_NONE)
        {
            Logger::Print("\"%s\" isn't a valid input type\n", mappingText);
            return;
        }

        Gamepad_BindAxis(0, physicalAxis, virtualAxis, mapping);
    }

    void Gamepad::Axis_Unbindall_f(Command::Params*)
    {
        auto& gamePadGlobal = gamePadGlobals[0];

        for (auto& virtualAxis : gamePadGlobal.axes.virtualAxes)
        {
            virtualAxis.physicalAxis = Game::GPAD_PHYSAXIS_NONE;
            virtualAxis.mapType = Game::GPAD_MAP_NONE;
        }
    }

    void Gamepad::Bind_GP_SticksConfigs_f(Command::Params*)
    {
        const auto* stickConfigName = gpad_sticksConfig.get<const char*>();
        Game::Cbuf_AddText(0, Utils::String::VA("exec %s\n", stickConfigName));
    }

    void Gamepad::Bind_GP_ButtonsConfigs_f(Command::Params*)
    {
        const auto* buttonConfigName = gpad_buttonConfig.get<const char*>();
        Game::Cbuf_AddText(0, Utils::String::VA("exec %s\n", buttonConfigName));
    }

    void Gamepad::Scores_Toggle_f(Command::Params*)
    {
        if(Game::cgArray[0].nextSnap)
        {
            if (Game::UI_GetActiveMenu(0) != Game::UIMENU_SCOREBOARD)
                Game::CG_ScoresDown_f();
            else
                Game::CG_ScoresUp_f();
        }
    }

    void Gamepad::InitDvars()
    {
        gpad_enabled = Dvar::Register<bool>("gpad_enabled", false, Game::DVAR_FLAG_SAVED, "Game pad enabled");
        gpad_debug = Dvar::Register<bool>("gpad_debug", false, Game::DVAR_FLAG_NONE, "Game pad debugging");
        gpad_present = Dvar::Register<bool>("gpad_present", false, Game::DVAR_FLAG_NONE, "Game pad present");
        gpad_in_use = Dvar::Register<bool>("gpad_in_use", false, Game::DVAR_FLAG_NONE, "A game pad is in use");
        gpad_style = Dvar::Register<bool>("gpad_style", false, Game::DVAR_FLAG_SAVED, "Switch between Xbox and PS HUD");
        gpad_sticksConfig = Dvar::Register<const char*>("gpad_sticksConfig", "", Game::DVAR_FLAG_SAVED, "Game pad stick configuration");
        gpad_buttonConfig = Dvar::Register<const char*>("gpad_buttonConfig", "", Game::DVAR_FLAG_SAVED, "Game pad button configuration");
        gpad_menu_scroll_delay_first = Dvar::Register<int>("gpad_menu_scroll_delay_first", 420, 0, 1000, Game::DVAR_FLAG_SAVED, "Menu scroll key-repeat delay, for the first repeat, in milliseconds");
        gpad_menu_scroll_delay_rest = Dvar::Register<int>("gpad_menu_scroll_delay_rest", 210, 0, 1000, Game::DVAR_FLAG_SAVED,
                                                          "Menu scroll key-repeat delay, for repeats after the first, in milliseconds");
        gpad_rumble = Dvar::Register<bool>("gpad_rumble", true, Game::DVAR_FLAG_SAVED, "Enable game pad rumble");
        gpad_stick_pressed_hysteresis = Dvar::Register<float>("gpad_stick_pressed_hysteresis", 0.1f, 0.0f, 1.0f, Game::DVAR_FLAG_NONE,
                                                              "Game pad stick pressed no-change-zone around gpad_stick_pressed to prevent bouncing");
        gpad_stick_pressed = Dvar::Register<float>("gpad_stick_pressed", 0.4f, 0.0, 1.0, Game::DVAR_FLAG_NONE, "Game pad stick pressed threshhold");
        gpad_stick_deadzone_max = Dvar::Register<float>("gpad_stick_deadzone_max", 0.01f, 0.0f, 1.0f, Game::DVAR_FLAG_NONE, "Game pad maximum stick deadzone");
        gpad_stick_deadzone_min = Dvar::Register<float>("gpad_stick_deadzone_min", 0.2f, 0.0f, 1.0f, Game::DVAR_FLAG_NONE, "Game pad minimum stick deadzone");
        gpad_button_deadzone = Dvar::Register<float>("gpad_button_deadzone", 0.13f, 0.0f, 1.0f, Game::DVAR_FLAG_NONE, "Game pad button deadzone threshhold");
        gpad_button_lstick_deflect_max = Dvar::Register<float>("gpad_button_lstick_deflect_max", 1.0f, 0.0f, 1.0f, Game::DVAR_FLAG_NONE, "Game pad maximum pad stick pressed value");
        gpad_button_rstick_deflect_max = Dvar::Register<float>("gpad_button_rstick_deflect_max", 1.0f, 0.0f, 1.0f, Game::DVAR_FLAG_NONE, "Game pad maximum pad stick pressed value");
        gpad_use_hold_time = Dvar::Register<int>("gpad_use_hold_time", 250, 0, INT32_MAX, Game::DVAR_FLAG_NONE, "Time to hold the 'use' button on gamepads to activate use");
        gpad_lockon_enabled = Dvar::Register<bool>("gpad_lockon_enabled", true, Game::DVAR_FLAG_SAVED, "Game pad lockon aim assist enabled");
        gpad_slowdown_enabled = Dvar::Register<bool>("gpad_slowdown_enabled", true, Game::DVAR_FLAG_SAVED, "Game pad slowdown aim assist enabled");

        input_viewSensitivity = Dvar::Register<float>("input_viewSensitivity", 1.0f, 0.0001f, 5.0f, Game::DVAR_FLAG_SAVED, "View Sensitivity");
        input_invertPitch = Dvar::Register<bool>("input_invertPitch", false, Game::DVAR_FLAG_SAVED, "Invert gamepad pitch");
        sv_allowAimAssist = Dvar::Register<bool>("sv_allowAimAssist", true, Game::DVAR_FLAG_NONE, "Controls whether aim assist features on clients are enabled");
        aim_turnrate_pitch = Dvar::Var("aim_turnrate_pitch");
        aim_turnrate_pitch_ads = Dvar::Var("aim_turnrate_pitch_ads");
        aim_turnrate_yaw = Dvar::Var("aim_turnrate_yaw");
        aim_turnrate_yaw_ads = Dvar::Var("aim_turnrate_yaw_ads");
        aim_accel_turnrate_enabled = Dvar::Var("aim_accel_turnrate_enabled");
        aim_accel_turnrate_lerp = Dvar::Var("aim_accel_turnrate_lerp");
        aim_input_graph_enabled = Dvar::Var("aim_input_graph_enabled");
        aim_input_graph_index = Dvar::Var("aim_input_graph_index");
        aim_scale_view_axis = Dvar::Var("aim_scale_view_axis");
        cl_bypassMouseInput = Dvar::Var("cl_bypassMouseInput");
        cg_mapLocationSelectionCursorSpeed = Dvar::Var("cg_mapLocationSelectionCursorSpeed");
        aim_aimAssistRangeScale = Dvar::Var("aim_aimAssistRangeScale");
        aim_slowdown_enabled = Dvar::Var("aim_slowdown_enabled");
        aim_slowdown_debug = Dvar::Var("aim_slowdown_debug");
        aim_slowdown_pitch_scale = Dvar::Var("aim_slowdown_pitch_scale");
        aim_slowdown_pitch_scale_ads = Dvar::Var("aim_slowdown_pitch_scale_ads");
        aim_slowdown_yaw_scale = Dvar::Var("aim_slowdown_yaw_scale");
        aim_slowdown_yaw_scale_ads = Dvar::Var("aim_slowdown_yaw_scale_ads");
        aim_lockon_enabled = Dvar::Var("aim_lockon_enabled");
        aim_lockon_deflection = Dvar::Var("aim_lockon_deflection");
        aim_lockon_pitch_strength = Dvar::Var("aim_lockon_pitch_strength");
        aim_lockon_strength = Dvar::Var("aim_lockon_strength");
    }

    void Gamepad::IN_Init_Hk()
    {
        // Call original method
        Utils::Hook::Call<void()>(0x45D620)();

        InitDvars();
    }

    const char* Gamepad::GetGamePadCommand(const char* command)
    {
        if (strcmp(command, "+activate") == 0 || strcmp(command, "+reload") == 0)
            return "+usereload";
        if (strcmp(command, "+melee_breath") == 0)
            return "+holdbreath";

        return command;
    }

    int Gamepad::Key_GetCommandAssignmentInternal_Hk(const char* cmd, int (*keys)[2])
    {
        auto keyCount = 0;

        if (gamePads[0].inUse)
        {
            cmd = GetGamePadCommand(cmd);
            for (auto keyNum = 0; keyNum < Game::K_LAST_KEY; keyNum++)
            {
                if (!Key_IsValidGamePadChar(keyNum))
                    continue;

                if (Game::playerKeys[0].keys[keyNum].binding && strcmp(Game::playerKeys[0].keys[keyNum].binding, cmd) == 0)
                {
                    (*keys)[keyCount++] = keyNum;

                    if (keyCount >= 2)
                        return keyCount;
                }
            }
        }
        else
        {
            for (auto keyNum = 0; keyNum < Game::K_LAST_KEY; keyNum++)
            {
                if (Key_IsValidGamePadChar(keyNum))
                    continue;

                if (Game::playerKeys[0].keys[keyNum].binding && strcmp(Game::playerKeys[0].keys[keyNum].binding, cmd) == 0)
                {
                    (*keys)[keyCount++] = keyNum;

                    if (keyCount >= 2)
                        return keyCount;
                }
            }
        }

        return keyCount;
    }

    void Gamepad::CL_KeyEvent_Hk(const int localClientNum, const int key, const int down, const unsigned time)
    {
        // A keyboard key has been pressed. Mark controller as unused.
        gamePads[0].inUse = false;
        gpad_in_use.setRaw(false);

        // Call original function
        Utils::Hook::Call<void(int, int, int, unsigned)>(0x4F6480)(localClientNum, key, down, time);
    }

    bool Gamepad::IsGamePadInUse()
    {
        return gamePads[0].inUse;
    }

    int Gamepad::CL_MouseEvent_Hk(const int x, const int y, const int dx, const int dy)
    {
        if (dx != 0 || dy != 0)
        {
            gamePads[0].inUse = false;
            gpad_in_use.setRaw(false);
        }

        // Call original function
        return Utils::Hook::Call<int(int, int, int, int)>(0x4D7C50)(x, y, dx, dy);
    }

    bool Gamepad::UI_RefreshViewport_Hk()
    {
        return cl_bypassMouseInput.get<bool>() || IsGamePadInUse();
    }

    Game::keyname_t* Gamepad::GetLocalizedKeyNameMap()
    {
        if(gpad_style.get<bool>())
            return combinedLocalizedKeyNamesPs3;

        return combinedLocalizedKeyNamesXenon;
    }

    void __declspec(naked) Gamepad::GetLocalizedKeyName_Stub()
    {
        __asm
        {
            push eax
            pushad

            call GetLocalizedKeyNameMap
            mov [esp + 0x20], eax

            popad
            pop eax

            // Re-execute last instruction from game to set flags again for upcoming jump
            test edi, edi
            ret
        }
    }

    void Gamepad::CreateKeyNameMap()
    {
        memcpy(combinedKeyNames, Game::keyNames, sizeof(Game::keyname_t) * Game::KEY_NAME_COUNT);
        memcpy(&combinedKeyNames[Game::KEY_NAME_COUNT], extendedKeyNames, sizeof(Game::keyname_t) * std::extent_v<decltype(extendedKeyNames)>);
        combinedKeyNames[std::extent_v<decltype(combinedKeyNames)> - 1] = {nullptr, 0};

        memcpy(combinedLocalizedKeyNamesXenon, Game::localizedKeyNames, sizeof(Game::keyname_t) * Game::LOCALIZED_KEY_NAME_COUNT);
        memcpy(&combinedLocalizedKeyNamesXenon[Game::LOCALIZED_KEY_NAME_COUNT], extendedLocalizedKeyNamesXenon,
               sizeof(Game::keyname_t) * std::extent_v<decltype(extendedLocalizedKeyNamesXenon)>);
        combinedLocalizedKeyNamesXenon[std::extent_v<decltype(combinedLocalizedKeyNamesXenon)> - 1] = {nullptr, 0};

        memcpy(combinedLocalizedKeyNamesPs3, Game::localizedKeyNames, sizeof(Game::keyname_t) * Game::LOCALIZED_KEY_NAME_COUNT);
        memcpy(&combinedLocalizedKeyNamesPs3[Game::LOCALIZED_KEY_NAME_COUNT], extendedLocalizedKeyNamesPs3,
               sizeof(Game::keyname_t) * std::extent_v<decltype(extendedLocalizedKeyNamesPs3)>);
        combinedLocalizedKeyNamesPs3[std::extent_v<decltype(combinedLocalizedKeyNamesPs3)> - 1] = {nullptr, 0};

        Utils::Hook::Set<Game::keyname_t*>(0x4A780A, combinedKeyNames);
        Utils::Hook::Set<Game::keyname_t*>(0x4A7810, combinedKeyNames);
        Utils::Hook::Set<Game::keyname_t*>(0x435C9F, combinedKeyNames);
        Utils::Hook(0x435C97, GetLocalizedKeyName_Stub, HOOK_CALL).install()->quick();
    }

    Gamepad::Gamepad()
    {
        if (ZoneBuilder::IsEnabled())
            return;

        // Initialize gamepad environment
        Utils::Hook(0x467C03, IN_Init_Hk, HOOK_CALL).install()->quick();

        // package the forward and right move components in the move buttons
        Utils::Hook(0x60E38D, MSG_WriteDeltaUsercmdKeyStub, HOOK_JUMP).install()->quick();

        // send two bytes for sending movement data
        Utils::Hook::Set<BYTE>(0x60E501, 16);
        Utils::Hook::Set<BYTE>(0x60E5CD, 16);

        // make sure to parse the movement data properly and apply it
        Utils::Hook(0x492127, MSG_ReadDeltaUsercmdKeyStub, HOOK_JUMP).install()->quick();
        Utils::Hook(0x492009, MSG_ReadDeltaUsercmdKeyStub2, HOOK_JUMP).install()->quick();

        // Also rewrite configuration when gamepad config is dirty
        Utils::Hook(0x60B264, Com_WriteConfiguration_Modified_Stub, HOOK_JUMP).install()->quick();
        Utils::Hook(0x60B223, Key_WriteBindings_Hk, HOOK_CALL).install()->quick();

        // Add hold time to gamepad usereload on hold prompts
        Utils::Hook(0x5FE396, Player_UseEntity_Stub, HOOK_JUMP).install()->quick();

        CreateKeyNameMap();

        Command::Add("bindaxis", Axis_Bind_f);
        Command::Add("unbindallaxis", Axis_Unbindall_f);
        Command::Add("bindgpsticksconfigs", Bind_GP_SticksConfigs_f);
        Command::Add("bindgpbuttonsconfigs", Bind_GP_ButtonsConfigs_f);
        Command::Add("togglescores", Scores_Toggle_f);

        if (Dedicated::IsEnabled())
            return;

        // Gamepad on frame hook
        Utils::Hook(0x475E9E, IN_Frame_Hk, HOOK_CALL).install()->quick();

        // Mark controller as unused when keyboard key is pressed
        Utils::Hook(0x43D179, CL_KeyEvent_Hk, HOOK_CALL).install()->quick();

        // Mark controller as unused when mouse is moved
        Utils::Hook(0x64C507, CL_MouseEvent_Hk, HOOK_CALL).install()->quick();

        // Hide cursor when controller is active
        Utils::Hook(0x48E527, UI_RefreshViewport_Hk, HOOK_CALL).install()->quick();

        // Only return gamepad keys when gamepad enabled and only non gamepad keys when not
        Utils::Hook(0x5A7A23, Key_GetCommandAssignmentInternal_Hk, HOOK_CALL).install()->quick();

        // Add gamepad inputs to remote control (eg predator) handling
        Utils::Hook(0x5A6D4E, CL_RemoteControlMove_Stub, HOOK_CALL).install()->quick();

        // Add gamepad inputs to location selection (eg airstrike location) handling
        Utils::Hook(0x5A6D72, CG_HandleLocationSelectionInput_Stub, HOOK_CALL).install()->quick();

        // Add gamepad inputs to usercmds
        Utils::Hook(0x5A6DAE, CL_MouseMove_Stub, HOOK_CALL).install()->quick();
    }
}