InputSampleSystem.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "config/InputBindings.hpp"
#include "config/UserSettings.hpp"
#include "ecs/components/Controllable.hpp"
#include "ecs/components/EmoteCatalog.hpp"
#include "ecs/components/InputSnapshot.hpp"
#include "ecs/components/LocalPlayer.hpp"
#include "ecs/components/RespawnTimer.hpp"
#include "ecs/registry/Registry.hpp"
 
#include <SDL3/SDL.h>
 
#include <algorithm>
#include <cmath>
#include <glm/geometric.hpp>
#include <glm/trigonometric.hpp>
#include <glm/vec2.hpp>

namespace systems
{

inline bool prevKillSelfKey = false;
inline bool prevGrenadeCycleKey = false;
inline bool prevGrenadeThrowKey = false;
inline bool prevGamepadGrenadeCycleKey = false;
inline bool prevGamepadGrenadeThrowKey = false;
inline bool pendingGrenadeThrow = false;
inline bool pendingGrenadeCycleNext = false;
inline bool pendingGrenadeCyclePrev = false;
inline bool prevAbilitySelectLeft = false;
inline bool prevAbilitySelectRight = false;
inline bool pendingAbilitySelectLeft = false;
inline bool pendingAbilitySelectRight = false;
inline bool prevGamepadAbilitySelectLeft = false;
inline bool prevGamepadAbilitySelectRight = false;
inline bool prevGamepadPickupKey = false;
inline Uint64 gamepadPickupDownMs = 0;     
inline bool gamepadPickupHoldFired = false; 
inline bool pendingGamepadWeaponSwap = false;
inline float gamepadLookAccel = 0.0f;
 
// ─── Emote wheel state ───────────────────────────────────────────────────────
//
// The emote wheel mirrors the radial-selection feel of a grenade wheel: hold the
// Emote binding to open the wheel, point (mouse delta on KBM, right stick on a
// pad) at one of the `emotes::kEmoteCount` sectors to highlight it, and release
// to play the highlighted emote. The highlighted sector and a latched
// "play this emote" request are read by the game loop and the HUD widget.

inline bool emoteWheelOpen = false;
inline int emoteWheelSelection = -1;
inline float emoteWheelDirX = 0.0f;
inline float emoteWheelDirY = 0.0f;
inline int pendingEmoteRequest = -1;
inline bool prevEmoteKey = false;
inline bool prevGamepadEmoteKey = false;

struct JoystickAxis
{
    SDL_GamepadAxis x;
    SDL_GamepadAxis y;
};

inline JoystickAxis getLookJoystickAxes(bool swapSticks)
{
    return {
        .x = swapSticks ? SDL_GAMEPAD_AXIS_LEFTX : SDL_GAMEPAD_AXIS_RIGHTX,
        .y = swapSticks ? SDL_GAMEPAD_AXIS_LEFTY : SDL_GAMEPAD_AXIS_RIGHTY,
    };
}

inline JoystickAxis getMoveJoystickAxes(bool swapSticks)
{
    return {
        .x = swapSticks ? SDL_GAMEPAD_AXIS_RIGHTX : SDL_GAMEPAD_AXIS_LEFTX,
        .y = swapSticks ? SDL_GAMEPAD_AXIS_RIGHTY : SDL_GAMEPAD_AXIS_LEFTY,
    };
}

inline bool gamepadConnected(SDL_Gamepad* gamepad)
{
    return gamepad != nullptr && SDL_GamepadConnected(gamepad);
}

inline bool consumePendingGrenadeThrow()
{
    const bool shouldThrow = pendingGrenadeThrow;
    pendingGrenadeThrow = false;
    return shouldThrow;
}

inline bool consumePendingGrenadeCycleNext()
{
    const bool requested = pendingGrenadeCycleNext;
    pendingGrenadeCycleNext = false;
    return requested;
}

inline bool consumePendingGrenadeCyclePrev()
{
    const bool requested = pendingGrenadeCyclePrev;
    pendingGrenadeCyclePrev = false;
    return requested;
}

inline bool consumePendingGamepadWeaponSwap()
{
    const bool requested = pendingGamepadWeaponSwap;
    pendingGamepadWeaponSwap = false;
    return requested;
}

inline int consumePendingEmote()
{
    const int emote = pendingEmoteRequest;
    pendingEmoteRequest = -1;
    return emote;
}

inline bool consumePendingAbilitySelectLeft()
{
    const bool requested = pendingAbilitySelectLeft;
    pendingAbilitySelectLeft = false;
    return requested;
}

inline bool consumePendingAbilitySelectRight()
{
    const bool requested = pendingAbilitySelectRight;
    pendingAbilitySelectRight = false;
    return requested;
}

inline void emoteWheelApplyPointing(float dx, float dy, bool accumulate)
{
    if (accumulate) {
        emoteWheelDirX += dx;
        emoteWheelDirY += dy;
    } else {
        emoteWheelDirX = dx;
        emoteWheelDirY = dy;
    }
 
    // Clamp magnitude so accumulated mouse motion can't grow without bound.
    constexpr float k_maxMag = 400.0f;
    const float mag2 = emoteWheelDirX * emoteWheelDirX + emoteWheelDirY * emoteWheelDirY;
    if (mag2 > k_maxMag * k_maxMag) {
        const float m = std::sqrt(mag2);
        emoteWheelDirX *= k_maxMag / m;
        emoteWheelDirY *= k_maxMag / m;
    }
 
    constexpr float k_deadzone = 28.0f;
    if (mag2 < k_deadzone * k_deadzone) {
        emoteWheelSelection = -1;
        return;
    }
 
    // atan2(dx, -dy): 0 at top (pointing up), increasing clockwise.
    float angle = std::atan2(emoteWheelDirX, -emoteWheelDirY);
    if (angle < 0.0f)
        angle += glm::two_pi<float>();
    const float sectorSize = glm::two_pi<float>() / static_cast<float>(emotes::kEmoteCount);
    emoteWheelSelection = static_cast<int>(std::lround(angle / sectorSize)) % emotes::kEmoteCount;
}

inline void runEmoteWheelKey(const InputBindings& bindings)
{
    const bool* const kKeys = SDL_GetKeyboardState(nullptr);
    const SDL_MouseButtonFlags mouse = SDL_GetMouseState(nullptr, nullptr);
    const bool keyNow = bindings.pressed(Action::Emote, kKeys, mouse);
 
    if (keyNow && !prevEmoteKey) {
        // Opening: clear any stale pointing/selection.
        emoteWheelDirX = 0.0f;
        emoteWheelDirY = 0.0f;
        emoteWheelSelection = -1;
    } else if (!keyNow && prevEmoteKey) {
        // Releasing: fire the highlighted emote (if any).
        if (emoteWheelSelection >= 0)
            pendingEmoteRequest = emoteWheelSelection;
        emoteWheelSelection = -1;
    }
 
    emoteWheelOpen = keyNow;
    prevEmoteKey = keyNow;
}

inline void runMouseLook(Registry& registry, float mouseSensitivity, bool gravityFlipped = false)
{
    float mdx = 0.0f;
    float mdy = 0.0f;
    SDL_GetRelativeMouseState(&mdx, &mdy);
 
    // When gravity is flipped the camera is rolled 180°, which swaps
    // both screen-left/right and screen-up/down relative to world space.
    // Negating both deltas keeps controls feeling natural.
    if (gravityFlipped) {
        mdx = -mdx;
        mdy = -mdy;
    }
 
    // While the emote wheel is open, mouse motion picks a sector instead of
    // turning the camera (standard radial-menu feel).
    if (emoteWheelOpen) {
        emoteWheelApplyPointing(mdx, mdy, /*accumulate=*/true);
        return;
    }
 
    registry.view<InputSnapshot, LocalPlayer, Controllable>().each([&](InputSnapshot& snap) {
        // Negate: SDL mdx is positive when moving right, but positive yaw
        // rotates toward +X which maps to screen-left via glm::lookAt's
        // cross(forward, up) convention.  Negating gives the standard
        // "mouse right = look right" behaviour.
        snap.yaw -= mdx * mouseSensitivity;
 
        // Wrap yaw to [-π, π] to avoid float precision drift over time.
        snap.yaw = std::remainder(snap.yaw, glm::radians(360.0f));
 
        // Clamp pitch to avoid gimbal-lock at the poles.
        snap.pitch = std::clamp(snap.pitch + mdy * mouseSensitivity, -glm::radians(89.0f), glm::radians(89.0f));
    });
}

inline void runMovementKeys(Registry& registry, const InputBindings& bindings, bool gravityFlipped = false)
{
    const bool* const kKeys = SDL_GetKeyboardState(nullptr);
    const SDL_MouseButtonFlags mouse = SDL_GetMouseState(nullptr, nullptr);
 
    // Edge-detect K key: only fire killSelf on the rising edge (key-down),
    // not while held.  Prevents respawn → immediate re-death loop.
    const bool killKeyNow = bindings.pressed(Action::KillSelf, kKeys, mouse);
    const bool killEdge = killKeyNow && !prevKillSelfKey;
    prevKillSelfKey = killKeyNow;
 
    registry.view<InputSnapshot, LocalPlayer, Controllable>().each([&](InputSnapshot& snap) {
        // Movement keys
        const bool forward = bindings.pressed(Action::Forward, kKeys, mouse);
        const bool back = bindings.pressed(Action::Back, kKeys, mouse);
        const bool left = bindings.pressed(Action::Left, kKeys, mouse);
        const bool right = bindings.pressed(Action::Right, kKeys, mouse);
 
        snap.forward = forward;
        snap.back = back;
        // When gravity is flipped the camera is rolled 180°, which negates
        // the screen-space right vector.  Swapping A/D compensates so
        // pressing A still moves the player screen-left.
        snap.left = gravityFlipped ? right : left;
        snap.right = gravityFlipped ? left : right;
        snap.jump = bindings.pressed(Action::Jump, kKeys, mouse);
        snap.crouch = bindings.pressed(Action::Crouch, kKeys, mouse);
        snap.ability1 = bindings.pressed(Action::Ability1, kKeys, mouse);
        snap.ability2 = bindings.pressed(Action::Ability2, kKeys, mouse);
        snap.killSelf = killEdge;
        snap.skipRespawn = false; // Clear stale flag from previous death.
    });
}

inline void runDeadInput(Registry& registry, const InputBindings& bindings)
{
    const bool* const kKeys = SDL_GetKeyboardState(nullptr);
    const SDL_MouseButtonFlags mouse = SDL_GetMouseState(nullptr, nullptr);
 
    registry.view<InputSnapshot, LocalPlayer, RespawnTimer>().each(
        [&](InputSnapshot& snap, const RespawnTimer& /*unused*/) {
            snap.skipRespawn = bindings.pressed(Action::Jump, kKeys, mouse);
        });
}

inline void runWeaponKeys(Registry& registry, const InputBindings& bindings)
{
    const bool* const kKeys = SDL_GetKeyboardState(nullptr);
    const SDL_MouseButtonFlags mouse = SDL_GetMouseState(nullptr, nullptr);
    const bool abilityMenuHeld = bindings.pressed(Action::AbilityMenu, kKeys, mouse);
    const bool shootDown = bindings.pressed(Action::Shoot, kKeys, mouse);
    const bool scopeDown = bindings.pressed(Action::Scope, kKeys, mouse);
    const bool selectLeftNow = abilityMenuHeld && shootDown;
    const bool selectRightNow = abilityMenuHeld && scopeDown;
    const bool selectLeftEdge = selectLeftNow && !prevAbilitySelectLeft;
    const bool selectRightEdge = selectRightNow && !prevAbilitySelectRight;
    prevAbilitySelectLeft = selectLeftNow;
    prevAbilitySelectRight = selectRightNow;
    if (selectLeftEdge)
        pendingAbilitySelectLeft = true;
    if (selectRightEdge)
        pendingAbilitySelectRight = true;
 
    // Grenade: discrete keys. Press CycleGrenade (H) to advance to the next
    // grenade type with ammo; press ThrowGrenade (G) to throw the selected one.
    // Both are edge-triggered (rising edge only) and latched here, pulsed once
    // per frame by the game loop so the server applies each exactly once.
    const bool grenadeCycleNow = bindings.pressed(Action::CycleGrenade, kKeys, mouse);
    if (grenadeCycleNow && !prevGrenadeCycleKey) {
        pendingGrenadeCycleNext = true;
    }
    prevGrenadeCycleKey = grenadeCycleNow;
 
    const bool grenadeThrowNow = bindings.pressed(Action::ThrowGrenade, kKeys, mouse);
    if (grenadeThrowNow && !prevGrenadeThrowKey) {
        pendingGrenadeThrow = true;
    }
    prevGrenadeThrowKey = grenadeThrowNow;
 
    // Suppress fire/aim while the ability menu is held (Shoot/Scope are
    // repurposed for ability selection) or while the emote wheel is open.
    const bool fireSuppressed = abilityMenuHeld || emoteWheelOpen;
 
    registry.view<InputSnapshot, LocalPlayer, Controllable>().each([&](InputSnapshot& snap) {
        snap.shooting = shootDown && !fireSuppressed;
        snap.scoped = scopeDown && !fireSuppressed;
        snap.switchToPrimary = bindings.pressed(Action::SwitchToPrimary, kKeys, mouse);
        snap.switchToSecondary = bindings.pressed(Action::SwitchToSecondary, kKeys, mouse);
        snap.reload = bindings.pressed(Action::Reload, kKeys, mouse);
        snap.pickup = bindings.pressed(Action::Pickup, kKeys, mouse);
        snap.abilitySelectHeld = abilityMenuHeld;
        snap.abilitySelectLeft = false;
        snap.abilitySelectRight = false;
    });
}

inline void runInputSample(
    Registry& registry,
    const InputBindings& bindings,
    float mouseSensitivity = user_settings::kDefaultMouseSensitivity)
{
    runMouseLook(registry, mouseSensitivity);
    runMovementKeys(registry, bindings);
    runWeaponKeys(registry, bindings);
}
 
// ─── Gamepad samplers ────────────────────────────────────────────────────────
//
// Mirror the keyboard/mouse pipeline so a controller can drive every action a
// PC player has access to.  SDL3's gamepad API gives us a standardised
// abstract layout (Xbox 360 / One, DualShock, Switch Pro, etc. all map onto
// the same buttons/axes) so a single mapping serves "all controllers behave
// the same way".  Tested on Xbox 360.
//
// Gamepad samplers OR their state into the InputSnapshot fields that the
// keyboard samplers already populated, so a player can use kbm and pad
// simultaneously without one stomping the other.  The look sampler ADDs to
// yaw/pitch the same way mouse delta does, so the two compose cleanly.
 
namespace gamepad
{

inline constexpr float k_stickDeadzone = 0.15f;

inline constexpr float k_triggerThreshold = 0.5f;

inline float normaliseAxis(Sint16 raw, float deadzone = k_stickDeadzone)
{
    // SDL_Gamepad axes are int16; normalise to [-1, 1].  -32768 is one larger
    // in magnitude than 32767 — divide by 32767 and clamp to keep the range
    // symmetric (otherwise full-down on a stick reads as -1.0000305...).
    const float v = std::clamp(static_cast<float>(raw) / 32767.0f, -1.0f, 1.0f);
    if (std::fabs(v) < deadzone)
        return 0.0f;
    // Rescale [deadzone, 1] → [0, 1] so the user gets the full output range.
    const float sign = v < 0.0f ? -1.0f : 1.0f;
    return sign * (std::fabs(v) - deadzone) / (1.0f - deadzone);
}
 
} // namespace gamepad

inline void runGamepadLook(Registry& registry,
                           SDL_Gamepad* gamepad,
                           float pitchSensitivity,
                           float yawSensitivity,
                           float deadzone,
                           float dt,
                           bool gravityFlipped = false,
                           bool swapSticks = false)
{
    if (!gamepadConnected(gamepad)) {
        gamepadLookAccel = 0.0f;
        return;
    }
 
    // While the emote wheel is open the right stick selects a sector, so don't
    // also turn the camera with it.
    if (emoteWheelOpen) {
        gamepadLookAccel = 0.0f;
        return;
    }
 
    JoystickAxis lookAxis = getLookJoystickAxes(swapSticks);
 
    float rx = gamepad::normaliseAxis(SDL_GetGamepadAxis(gamepad, lookAxis.x), deadzone);
    float ry = gamepad::normaliseAxis(SDL_GetGamepadAxis(gamepad, lookAxis.y), deadzone);
 
    if (rx == 0.0f && ry == 0.0f) {
        gamepadLookAccel = 0.0f; // stick centred — drop back to the base turn rate.
        return;
    }
 
    if (gravityFlipped) {
        rx = -rx;
        ry = -ry;
    }
 
    // COD-style view acceleration: while the look stick is held near full
    // deflection the turn rate ramps from 1x up to (1 + k_accelMaxBoost)x over
    // k_accelRampTime seconds, then snaps back to 1x once the stick eases off.
    // This keeps the (now 30%-lower) base sensitivity precise for small
    // corrections while still allowing fast full-stick spins. Tune the three
    // constants to taste.
    constexpr float k_accelEngageMag = 0.85f; 
    constexpr float k_accelRampTime = 0.5f;   
    constexpr float k_accelMaxBoost = 1.0f;   
    const float stickMag = std::max(std::fabs(rx), std::fabs(ry));
    if (stickMag >= k_accelEngageMag)
        gamepadLookAccel = std::min(1.0f, gamepadLookAccel + dt / k_accelRampTime);
    else
        gamepadLookAccel = 0.0f;
    const float accelMult = 1.0f + k_accelMaxBoost * gamepadLookAccel;
 
    registry.view<InputSnapshot, LocalPlayer, Controllable>().each([&](InputSnapshot& snap) {
        // Sign convention matches runMouseLook: stick-right (positive rx)
        // should look right, which means yaw decreases (see runMouseLook
        // comment for why the negation is correct).
        snap.yaw -= rx * yawSensitivity * dt * accelMult;
        snap.yaw = std::remainder(snap.yaw, glm::radians(360.0f));
 
        // SDL gamepad Y axis is +down/-up (screen-coord convention) — same as
        // mouse mdy — so adding directly matches mouse-down = pitch+ behaviour.
        snap.pitch =
            std::clamp(snap.pitch + ry * pitchSensitivity * dt * accelMult, -glm::radians(89.0f), glm::radians(89.0f));
    });
}

inline void runGamepadEmoteWheel(SDL_Gamepad* gamepad, const InputBindings& bindings, bool swapSticks = false)
{
    if (!gamepadConnected(gamepad))
        return;
 
    const bool padNow = bindings.controllerPressed(Action::Emote, gamepad);
    if (padNow && !prevGamepadEmoteKey) {
        emoteWheelDirX = 0.0f;
        emoteWheelDirY = 0.0f;
        emoteWheelSelection = -1;
    } else if (!padNow && prevGamepadEmoteKey) {
        if (emoteWheelSelection >= 0)
            pendingEmoteRequest = emoteWheelSelection;
        emoteWheelSelection = -1;
    }
    prevGamepadEmoteKey = padNow;
 
    if (padNow) {
        emoteWheelOpen = true;
        // Right stick gives an absolute direction; scale into the pixel-space
        // units emoteWheelApplyPointing expects so the deadzone lines up.
        const JoystickAxis lookAxis = getLookJoystickAxes(swapSticks);
        const float rx = gamepad::normaliseAxis(SDL_GetGamepadAxis(gamepad, lookAxis.x));
        const float ry = gamepad::normaliseAxis(SDL_GetGamepadAxis(gamepad, lookAxis.y));
        emoteWheelApplyPointing(rx * 200.0f, ry * 200.0f, /*accumulate=*/false);
    }
}

inline void runGamepadMovement(Registry& registry,
                               SDL_Gamepad* gamepad,
                               const InputBindings& bindings,
                               float deadzone,
                               bool gravityFlipped = false,
                               bool swapSticks = false)
{
    if (!gamepadConnected(gamepad))
        return;
 
    JoystickAxis moveAxis = getMoveJoystickAxes(swapSticks);
 
    const float lx = gamepad::normaliseAxis(SDL_GetGamepadAxis(gamepad, moveAxis.x), deadzone);
    const float ly = gamepad::normaliseAxis(SDL_GetGamepadAxis(gamepad, moveAxis.y), deadzone);
 
    // Movement booleans are derived from a stronger threshold than the deadzone
    // so a player resting their thumb on the stick doesn't drift-walk.  0.3 is
    // ~tip pressure on a 360 stick.
    constexpr float moveThresh = 0.3f;
    const bool padForward = ly < -moveThresh; // stick-up = -Y in SDL
    const bool padBack = ly > moveThresh;
    // Swap left/right when gravity is flipped (same reasoning as keyboard).
    const bool padLeft = gravityFlipped ? (lx > moveThresh) : (lx < -moveThresh);
    const bool padRight = gravityFlipped ? (lx < -moveThresh) : (lx > moveThresh);
 
    const bool padJump = bindings.controllerPressed(Action::Jump, gamepad);
    const bool padCrouch = bindings.controllerPressed(Action::Crouch, gamepad);
    const bool padAbility1 = bindings.controllerPressed(Action::Ability1, gamepad);
    const bool padAbility2 = bindings.controllerPressed(Action::Ability2, gamepad);
 
    registry.view<InputSnapshot, LocalPlayer, Controllable>().each([&](InputSnapshot& snap) {
        snap.forward |= padForward;
        snap.back |= padBack;
        snap.left |= padLeft;
        snap.right |= padRight;
        snap.jump |= padJump;
        snap.crouch |= padCrouch;
        snap.ability1 |= padAbility1;
        snap.ability2 |= padAbility2;
    });
}

inline void runGamepadWeapon(Registry& registry, SDL_Gamepad* gamepad, const InputBindings& bindings)
{
    if (!gamepadConnected(gamepad))
        return;
 
    const bool abilityMenuHeld = bindings.controllerPressed(Action::AbilityMenu, gamepad);
    const bool padShoot = bindings.controllerPressed(Action::Shoot, gamepad);
    const bool padScope = bindings.controllerPressed(Action::Scope, gamepad);
    const bool padReload = bindings.controllerPressed(Action::Reload, gamepad);
    const bool padPrimary = bindings.controllerPressed(Action::SwitchToPrimary, gamepad);
    const bool padSecondary = bindings.controllerPressed(Action::SwitchToSecondary, gamepad);
    const bool selectLeftNow = abilityMenuHeld && padShoot;
    const bool selectRightNow = abilityMenuHeld && padScope;
    const bool selectLeftEdge = selectLeftNow && !prevGamepadAbilitySelectLeft;
    const bool selectRightEdge = selectRightNow && !prevGamepadAbilitySelectRight;
    prevGamepadAbilitySelectLeft = selectLeftNow;
    prevGamepadAbilitySelectRight = selectRightNow;
    if (selectLeftEdge)
        pendingAbilitySelectLeft = true;
    if (selectRightEdge)
        pendingAbilitySelectRight = true;
 
    // Grenade: discrete buttons mirroring the keyboard path. D-pad Left cycles
    // to the next grenade type with ammo; B (East) throws the selected one.
    // Both edge-triggered and latched into the same once-per-frame pulse.
    const bool padCycleGrenade = bindings.controllerPressed(Action::CycleGrenade, gamepad);
    if (padCycleGrenade && !prevGamepadGrenadeCycleKey) {
        pendingGrenadeCycleNext = true;
    }
    prevGamepadGrenadeCycleKey = padCycleGrenade;
 
    const bool padThrowGrenade = bindings.controllerPressed(Action::ThrowGrenade, gamepad);
    if (padThrowGrenade && !prevGamepadGrenadeThrowKey) {
        pendingGrenadeThrow = true;
    }
    prevGamepadGrenadeThrowKey = padThrowGrenade;
 
    // Y (Pickup binding): tap = swap weapon, hold = pick up. A press shorter than
    // k_pickupHoldMs is treated as a tap and latches a weapon swap on release;
    // holding past the threshold sets the pickup flag (and suppresses the swap).
    constexpr Uint64 k_pickupHoldMs = 200;
    const bool padPickupBtn = bindings.controllerPressed(Action::Pickup, gamepad);
    bool padPickupHeld = false;
    const Uint64 nowMs = SDL_GetTicks();
    if (padPickupBtn && !prevGamepadPickupKey) {
        gamepadPickupDownMs = nowMs;
        gamepadPickupHoldFired = false;
    }
    if (padPickupBtn) {
        if (nowMs - gamepadPickupDownMs >= k_pickupHoldMs) {
            padPickupHeld = true;
            gamepadPickupHoldFired = true;
        }
    } else if (prevGamepadPickupKey && !gamepadPickupHoldFired) {
        // Released before the hold threshold → quick tap → swap weapon.
        pendingGamepadWeaponSwap = true;
    }
    prevGamepadPickupKey = padPickupBtn;
 
    // Suppress fire/aim while the ability menu modifier is held.
    const bool fireSuppressed = abilityMenuHeld;
 
    registry.view<InputSnapshot, LocalPlayer, Controllable>().each([&](InputSnapshot& snap) {
        snap.shooting |= padShoot && !fireSuppressed;
        snap.scoped |= padScope && !fireSuppressed;
        snap.reload |= padReload;
        snap.pickup |= padPickupHeld;
        snap.switchToPrimary |= padPrimary;
        snap.switchToSecondary |= padSecondary;
        snap.abilitySelectHeld |= abilityMenuHeld;
    });
}

inline void runGamepadDeadInput(Registry& registry, SDL_Gamepad* gamepad, const InputBindings& bindings)
{
    if (!gamepadConnected(gamepad))
        return;
    const bool skipRespawn = bindings.controllerPressed(Action::Jump, gamepad);
    // OR into the flag the keyboard path (runDeadInput) just set — the gamepad
    // sampler runs right after it, so an assignment here would stomp a Space
    // press on keyboard whenever a pad is connected. Mirrors how the alive-path
    // gamepad inputs compose with |= rather than overwriting.
    registry.view<InputSnapshot, LocalPlayer, RespawnTimer>().each(
        [&](InputSnapshot& snap, const RespawnTimer& /*unused*/) { snap.skipRespawn |= skipRespawn; });
}
 
} // namespace systems