Multiple Controller Support [SYNTH-151]

fission/src/mirabuf/ScoringZoneSceneObject.ts

@@ -6,8 +6,8 @@ import ScoreTracker from "@/systems/match_mode/ScoreTracker"
 import type { ScoringZonePreferences } from "@/systems/preferences/PreferenceTypes"
 import World from "@/systems/World"
 import { findListDifference } from "@/util/Utility"
-import MirabufSceneObject from "./MirabufSceneObject"
-import { RigidNodeAssociate } from "./MirabufSceneObject"
+import type MirabufSceneObject from "./MirabufSceneObject"
+import type { RigidNodeAssociate } from "./MirabufSceneObject"
 import ZoneSceneObject from "./ZoneSceneObject"
 
 class ScoringZoneSceneObject extends ZoneSceneObject<ScoringZonePreferences> {

fission/src/systems/input/DefaultInputs.ts

@@ -106,6 +106,7 @@ class DefaultInputs {
             descriptiveName: "Full Controller",
             customized: false,
             usesGamepad: true,
+            playerSlot: 0,
             supportedDrivetrains: [DriveType.ARCADE, DriveType.TANK],
             usesTouchControls: false,
             inputs: [
@@ -133,6 +134,7 @@ class DefaultInputs {
             descriptiveName: "Left Stick",
             customized: false,
             usesGamepad: true,
+            playerSlot: 0,
             usesTouchControls: false,
             supportedDrivetrains: [DriveType.ARCADE],
             inputs: [
@@ -155,6 +157,7 @@ class DefaultInputs {
             descriptiveName: "Right Stick",
             customized: false,
             usesGamepad: true,
+            playerSlot: 0,
             supportedDrivetrains: [DriveType.ARCADE],
             usesTouchControls: false,
             inputs: [
@@ -240,6 +243,7 @@ class DefaultInputs {
             descriptiveName: "Dual Stick (Swerve)",
             customized: false,
             usesGamepad: true,
+            playerSlot: 0,
             usesTouchControls: false,
             supportedDrivetrains: [DriveType.SWERVE],
             inputs: [

fission/src/systems/input/InputSchemeManager.ts

@@ -122,7 +122,8 @@ class InputSchemeManager {
                 status: InputSchemeUseType.IN_USE,
             }
             scheme?.inputs?.forEach(input => {
-                input.keysUsed
+                input
+                    .keysUsed(scheme.playerSlot ?? 0)
                     .filter(key => key != null)
                     .forEach(key => {
                         const entry = usedKeyMap.get(key)
@@ -137,7 +138,7 @@ class InputSchemeManager {
 
         allSchemes.forEach(scheme => {
             const conflictingSchemes = scheme.inputs.flatMap(input =>
-                input.keysUsed.flatMap(key => usedKeyMap.get(key) ?? [])
+                input.keysUsed(scheme.playerSlot ?? 0).flatMap(key => usedKeyMap.get(key) ?? [])
             )
             if (conflictingSchemes.length > 0) {
                 result[scheme.schemeName] ??= {

fission/src/systems/input/InputSystem.ts

@@ -20,8 +20,8 @@ class InputSystem extends WorldSystem {
     /** Whether the command palette is currently open, which blocks robot input */
     private static _isCommandPaletteOpen: boolean = false
 
-    private static _gpIndex: number | null
-    public static gamepad: Gamepad | null
+    private static _gpIndexes: number[] = []
+    public static gamepads: (Gamepad | null)[] = []
 
     /** Normalized joystick positions (-1 to 1) set by TouchControls component via react-joystick-component */
     private static _leftJoystickPos: { x: number; y: number } = { x: 0, y: 0 }
@@ -93,8 +93,15 @@ class InputSystem extends WorldSystem {
 
     public update(_: number): void {
         // Fetch current gamepad information
-        if (InputSystem._gpIndex == null) InputSystem.gamepad = null
-        else InputSystem.gamepad = navigator.getGamepads()[InputSystem._gpIndex]
+        const rawGamepads = navigator.getGamepads()
+
+        for (const lookupIndex of InputSystem._gpIndexes) {
+            if (lookupIndex == null || rawGamepads[lookupIndex] == null) {
+                InputSystem.gamepads[lookupIndex] = null
+            } else {
+                InputSystem.gamepads[lookupIndex] = rawGamepads[lookupIndex]
+            }
+        }
 
         if (!document.hasFocus()) this.clearKeyData()
 
@@ -156,7 +163,10 @@ class InputSystem extends WorldSystem {
             )
         }
 
-        InputSystem._gpIndex = event.gamepad.index
+        const newIndex = event.gamepad.index
+        if (!InputSystem._gpIndexes.includes(newIndex)) {
+            InputSystem._gpIndexes.push(newIndex)
+        }
     }
 
     /* Called once when a gamepad is first disconnected */
@@ -165,7 +175,13 @@ class InputSystem extends WorldSystem {
             console.log("Gamepad disconnected from index %d: %s", event.gamepad.index, event.gamepad.id)
         }
 
-        InputSystem._gpIndex = null
+        const removedIndex = event.gamepad.index
+
+        InputSystem._gpIndexes = InputSystem._gpIndexes.filter(idx => idx !== removedIndex)
+
+        if (InputSystem.gamepads[removedIndex]) {
+            InputSystem.gamepads[removedIndex] = null
+        }
     }
 
     /**
@@ -197,7 +213,7 @@ class InputSystem extends WorldSystem {
 
         if (targetScheme == null || targetInput == null) return 0
 
-        return targetInput.getValue(targetScheme.usesGamepad, targetScheme.usesTouchControls)
+        return targetInput.getValue(targetScheme.usesGamepad, targetScheme.usesTouchControls, targetScheme.playerSlot)
     }
 
     /**
@@ -216,16 +232,27 @@ class InputSystem extends WorldSystem {
         )
     }
 
+    /**
+     * @param {number} playerSlot The logical player slot.
+     * @returns {Gamepad | null} The gamepad in that slot, or null if the slot is unoccupied.
+     */
+    public static getGamepadBySlot(playerSlot: number): Gamepad | null {
+        const rawIndex = InputSystem._gpIndexes[playerSlot]
+        if (rawIndex == null) return null
+        return InputSystem.gamepads[rawIndex] ?? null
+    }
+
     /**
      * @param {number} axisNumber The joystick axis index. Must be an integer.
+     * @param {number} playerSlot The logical player slot for the gamepad (0 = first connected). Must be an integer.
      * @returns {number} A number between -1 and 1 based on the position of this axis or 0 if no gamepad is connected or the axis is not found.
      */
-    public static getGamepadAxis(axisNumber: number): number {
-        if (InputSystem.gamepad == null) return 0
-
-        if (axisNumber < 0 || axisNumber >= InputSystem.gamepad.axes.length) return 0
+    public static getGamepadAxis(axisNumber: number, playerSlot: number = 0): number {
+        const targetGamepad = InputSystem.getGamepadBySlot(playerSlot)
+        if (targetGamepad == null) return 0
+        if (axisNumber < 0 || axisNumber >= targetGamepad.axes.length) return 0
 
-        const value = InputSystem.gamepad.axes[axisNumber]
+        const value = targetGamepad.axes[axisNumber]
 
         // Return value with a deadband
         return Math.abs(value) < 0.15 ? 0 : value
@@ -234,19 +261,28 @@ class InputSystem extends WorldSystem {
     /**
      *
      * @param {number} buttonNumber - The gamepad button index. Must be an integer.
+     * @param {number} playerSlot - The logical player slot for the gamepad (0 = first connected). Must be an integer.
      * @returns {boolean} True if the button is pressed, false if not, a gamepad isn't connected, or the button can't be found.
      */
-    public static isGamepadButtonPressed(buttonNumber: number): boolean {
-        if (InputSystem.gamepad == null) return false
+    public static isGamepadButtonPressed(buttonNumber: number, playerSlot: number = 0): boolean {
+        const targetGamepad = InputSystem.getGamepadBySlot(playerSlot)
+        if (targetGamepad == null) return false
 
-        if (buttonNumber < 0 || buttonNumber >= InputSystem.gamepad.buttons.length) return false
+        if (buttonNumber < 0 || buttonNumber >= targetGamepad.buttons.length) return false
 
-        const button = InputSystem.gamepad.buttons[buttonNumber]
+        const button = targetGamepad.buttons[buttonNumber]
         if (button == null) return false
 
         return button.pressed
     }
 
+    /**
+     * @returns {number} The number of currently connected gamepads, effectively all useable slots
+     */
+    public static getConnectedPlayerCount(): number {
+        return InputSystem._gpIndexes.length
+    }
+
     /** Returns a number between -1 and 1 from the touch controls */
     public static getTouchControlsAxis(axisType: TouchControlsAxes): number {
         if (axisType === TouchControlsAxes.LEFT_X) return InputSystem._leftJoystickPos.x

fission/src/systems/input/InputTypes.ts

@@ -27,6 +27,7 @@ export type InputScheme = {
     descriptiveName: string
     customized: boolean
     usesGamepad: boolean
+    playerSlot?: number
     usesTouchControls: boolean
     supportedDrivetrains: DriveType[]
     inputs: Input[]

fission/src/systems/input/inputs/AxisInput.ts

@@ -152,7 +152,7 @@ export default class AxisInput extends Input {
      * @returns {number} KEYBOARD: 1 if positive pressed, -1 if negative pressed, or 0 if none or both are pressed.
      * @returns {number} GAMEPAD: a number between -1 and 1 with a deadband in the middle.
      */
-    getValue(useGamepad: boolean, useTouchControls: boolean): number {
+    getValue(useGamepad: boolean, useTouchControls: boolean, playerSlot: number = 0): number {
         const matchModeType = MatchMode.getInstance().getMatchModeType()
         if (matchModeType === MatchModeType.MATCH_ENDED || matchModeType === MatchModeType.AUTONOMOUS) {
             return 0
@@ -161,12 +161,12 @@ export default class AxisInput extends Input {
         if (useGamepad) {
             // Gamepad joystick axis
             if (!this.useGamepadButtons)
-                return InputSystem.getGamepadAxis(this.gamepadAxisNumber) * (this.joystickInverted ? -1 : 1)
+                return InputSystem.getGamepadAxis(this.gamepadAxisNumber, playerSlot) * (this.joystickInverted ? -1 : 1)
 
             // Gamepad button axis
             return (
-                (InputSystem.isGamepadButtonPressed(this.posGamepadButton) ? 1 : 0) -
-                (InputSystem.isGamepadButtonPressed(this.negGamepadButton) ? 1 : 0)
+                (InputSystem.isGamepadButtonPressed(this.posGamepadButton, playerSlot) ? 1 : 0) -
+                (InputSystem.isGamepadButtonPressed(this.negGamepadButton, playerSlot) ? 1 : 0)
             )
         }
 
@@ -181,13 +181,13 @@ export default class AxisInput extends Input {
         )
     }
 
-    get keysUsed(): KeyDescriptor[] {
+    keysUsed(playerSlot: number = 0): KeyDescriptor[] {
         return [
             this.describeKey(this.posKeyCode, this.posKeyModifiers),
             this.describeKey(this.negKeyCode, this.negKeyModifiers),
-            this.describeGamepadBtn(this.posGamepadButton),
-            this.describeGamepadBtn(this.negGamepadButton),
-            this.describeGamepadAxis(this.gamepadAxisNumber),
+            this.describeGamepadBtn(this.posGamepadButton, playerSlot),
+            this.describeGamepadBtn(this.negGamepadButton, playerSlot),
+            this.describeGamepadAxis(this.gamepadAxisNumber, playerSlot),
             this.describeTouchAxis(this.touchControlAxis),
         ]
     }

fission/src/systems/input/inputs/ButtonInput.ts

@@ -31,23 +31,26 @@ export default class ButtonInput extends Input {
      * @param useGamepad Looks at the gamepad if true and the keyboard if false.
      * @returns 1 if pressed, 0 if not pressed or not found.
      */
-    getValue(useGamepad: boolean): number {
+    getValue(useGamepad: boolean, _useTouchControls: boolean = false, playerSlot: number = 0): number {
         const matchModeType = MatchMode.getInstance().getMatchModeType()
         if (matchModeType === MatchModeType.MATCH_ENDED || matchModeType === MatchModeType.AUTONOMOUS) {
             return 0
         }
 
         // Gamepad button input
         if (useGamepad) {
-            return InputSystem.isGamepadButtonPressed(this.gamepadButton) ? 1 : 0
+            return InputSystem.isGamepadButtonPressed(this.gamepadButton, playerSlot) ? 1 : 0
         }
 
         // Keyboard button input
         return InputSystem.isKeyPressed(this.keyCode, this.keyModifiers) ? 1 : 0
     }
 
-    get keysUsed(): KeyDescriptor[] {
-        return [this.describeKey(this.keyCode, this.keyModifiers), this.describeGamepadBtn(this.gamepadButton)]
+    keysUsed(playerSlot: number = 0): KeyDescriptor[] {
+        return [
+            this.describeKey(this.keyCode, this.keyModifiers),
+            this.describeGamepadBtn(this.gamepadButton, playerSlot),
+        ]
     }
 
     static onGamepad(inputName: InputName, gamepadButton: number) {

fission/src/systems/input/inputs/Input.ts

@@ -24,9 +24,12 @@ export default abstract class Input {
     }
 
     // Returns the current value of the input. Range depends on input type
-    abstract getValue(useGamepad: boolean, useTouchControls: boolean): number
+    abstract getValue(useGamepad: boolean, useTouchControls: boolean, playerSlot?: number): number
 
-    abstract get keysUsed(): KeyDescriptor[]
+    /**
+     * @param {number} playerSlot - The logical player slot the owning scheme reads from.
+     */
+    abstract keysUsed(playerSlot?: number): KeyDescriptor[]
 
     protected describeKey(id: KeyCode, modifiers?: ModifierState): KeyDescriptor {
         if (id == "") {
@@ -42,17 +45,17 @@ export default abstract class Input {
         }
         return `${inputDriveTypeAssociations[this.inputName] ?? ""}_${id}` as KeyDescriptor
     }
-    protected describeGamepadBtn(button: number): KeyDescriptor {
+    protected describeGamepadBtn(button: number, playerSlot: number = 0): KeyDescriptor {
         if (button == -1) {
             return null
         }
-        return `${inputDriveTypeAssociations[this.inputName] ?? ""}_gamepadBtn${button}` as KeyDescriptor
+        return `slot${playerSlot}_${inputDriveTypeAssociations[this.inputName] ?? ""}_gamepadBtn${button}` as KeyDescriptor
     }
-    protected describeGamepadAxis(axis: number): KeyDescriptor {
+    protected describeGamepadAxis(axis: number, playerSlot: number = 0): KeyDescriptor {
         if (axis == -1) {
             return null
         }
-        return `${inputDriveTypeAssociations[this.inputName] ?? ""}_gamepadAxis${axis}` as KeyDescriptor
+        return `slot${playerSlot}_${inputDriveTypeAssociations[this.inputName] ?? ""}_gamepadAxis${axis}` as KeyDescriptor
     }
     protected describeTouchAxis(axis: TouchControlsAxes): KeyDescriptor {
         if (axis == TouchControlsAxes.NONE) {

fission/src/test/InputSystem.test.ts

@@ -273,7 +273,7 @@ describe("Gamepad Input Check", () => {
     test("Disconnect event", () => {
         // The connection event is implicitly tested by registering a fake gamepad
         window.dispatchEvent(Object.assign(new Event("gamepaddisconnected"), { gamepad: fakeGamepad }))
-        expect(InputSystem["_gpIndex"]).toBeNull()
+        expect(InputSystem["_gpIndexes"]).toHaveLength(0)
     })
 
     test("Get input with gamepad scheme", () => {
@@ -299,7 +299,8 @@ describe("Default Input Scheme Checks", () => {
         DefaultInputs.defaultInputCopies.forEach(scheme => {
             const usedKeys = new Map<KeyDescriptor, number>()
             scheme.inputs.forEach(input => {
-                input.keysUsed
+                input
+                    .keysUsed(scheme.playerSlot ?? 0)
                     .filter(key => key != null)
                     .forEach(key => usedKeys.set(key, (usedKeys.get(key) ?? 0) + 1))
                 usedKeys.forEach((count, key) => {

fission/src/test/mirabuf/ProtectedZoneSceneObject.test.ts

@@ -5,7 +5,7 @@ import { ContactType } from "@/mirabuf/ZoneTypes"
 import { MatchModeType } from "@/systems/match_mode/MatchModeTypes"
 import ScoreTracker from "@/systems/match_mode/ScoreTracker"
 import type { ProtectedZonePreferences } from "@/systems/preferences/PreferenceTypes"
-import MirabufSceneObject from "../../mirabuf/MirabufSceneObject"
+import type MirabufSceneObject from "../../mirabuf/MirabufSceneObject"
 import ProtectedZoneSceneObject from "../../mirabuf/ProtectedZoneSceneObject"
 import { createBodyMock } from "../mocks/jolt"
 import JOLT from "@/util/loading/JoltSyncLoader"