@solidrt/core 0.0.56 → 0.0.58

package/src/input-gamepad-device.ts

@@ -0,0 +1,161 @@
+// A gamepad as input sources, over any accessor of pad snapshots: sticks
+// and the dpad as vec2, triggers and shoulders as axes, any button as a
+// button, any raw axis by name. Runtime-free (the accessor is injected,
+// the public `gamepad` in input-gamepad.ts hands in core's gamepads()),
+// so the join logic below runs headless in the checks.
+//
+// Every read is reactive when the accessor is (gamepads() is a signal),
+// so a stick moved while a control's frame loop is off wakes it. Sticks
+// pass through a radial dead zone; the screen convention holds (a stick
+// pushed up reads y = -1, as the web Gamepad API reports it).
+//
+// Joining: `createGamepadJoin` makes a device with no slot until a pad no
+// other joining device holds presses any button, then keeps that slot -
+// Unity's join manager, for a couch game that seats players in the order
+// they pick up a pad. A claim lasts until the owning scope is disposed
+// (an unmounted pane frees its pad); with no owner, for the session.
+
+import { createEffect, createRoot, createSignal, getOwner, onCleanup } from "@solidjs/signals"
+import type { GamepadState } from "./gamepad"
+import type { InputSource } from "./input-map"
+import type { Vec2 } from "./input-axes"
+
+// Stick deflection below which a resting stick reads as zero (radial:
+// the whole vector, so a stick nudged diagonally also rests).
+const STICK_DEADZONE = 0.15
+
+export type PadsAccessor = () => (GamepadState | null)[]
+
+export interface GamepadDevice {
+  /** The slot this device reads: a number for one pad, undefined for every
+   * connected pad (`gamepad()`) or for a joining device no pad has claimed
+   * yet (reactive: it resolves when one joins). */
+  readonly slot: number | undefined
+  leftStick: InputSource<"vec2">
+  rightStick: InputSource<"vec2">
+  /** The dpad as a digital vec2 (each component -1, 0 or 1). */
+  dpad: InputSource<"vec2">
+  /** Right trigger minus left trigger, -1..1. */
+  triggers: InputSource<"axis">
+  /** Right shoulder minus left shoulder, -1, 0 or 1. */
+  shoulders: InputSource<"axis">
+  /** A raw axis by SDL name ("leftX", "rightY", "leftTrigger", ...). */
+  axis(name: string): InputSource<"axis">
+  /** A button by SDL positional name ("south", "start", "leftShoulder", ...). */
+  button(name: string): InputSource<"button">
+}
+
+let deadzone = (x: number, y: number): Vec2 => (Math.hypot(x, y) < STICK_DEADZONE ? [0, 0] : [x, y])
+
+/**
+ * The sources over `pads()` (the pads this device reads now, reactive),
+ * with `slot()` as the device's slot and `who` as the label prefix.
+ */
+export function createGamepadDevice(pads: () => GamepadState[], slot: () => number | undefined, who: string): GamepadDevice {
+  let sumAxis = (read: (pad: GamepadState) => number) => (): number => {
+    let sum = 0
+    for (let pad of pads()) sum += read(pad)
+    return sum
+  }
+  let sumVec2 = (read: (pad: GamepadState) => Vec2) => (): Vec2 => {
+    let x = 0
+    let y = 0
+    for (let pad of pads()) {
+      let v = read(pad)
+      x += v[0]
+      y += v[1]
+    }
+    return [x, y]
+  }
+  let anyButton = (name: string) => (): boolean => pads().some(pad => pad.buttons.includes(name))
+  let pressed = (pad: GamepadState, name: string) => (pad.buttons.includes(name) ? 1 : 0)
+  let stick = (side: "left" | "right"): InputSource<"vec2"> => ({
+    kind: "vec2",
+    label: `${who} ${side} stick`,
+    rate: sumVec2(pad => deadzone(pad.axes[`${side}X`] ?? 0, pad.axes[`${side}Y`] ?? 0)),
+  })
+  return {
+    get slot() {
+      return slot()
+    },
+    leftStick: stick("left"),
+    rightStick: stick("right"),
+    dpad: {
+      kind: "vec2",
+      label: `${who} dpad`,
+      rate: sumVec2(pad => [pressed(pad, "dpadRight") - pressed(pad, "dpadLeft"), pressed(pad, "dpadDown") - pressed(pad, "dpadUp")]),
+    },
+    triggers: {
+      kind: "axis",
+      label: `${who} triggers`,
+      rate: sumAxis(pad => (pad.axes.rightTrigger ?? 0) - (pad.axes.leftTrigger ?? 0)),
+    },
+    shoulders: {
+      kind: "axis",
+      label: `${who} shoulders`,
+      rate: sumAxis(pad => pressed(pad, "rightShoulder") - pressed(pad, "leftShoulder")),
+    },
+    axis(name) {
+      if (typeof name !== "string" || name.length === 0) throw new Error(`gamepad.axis: expected an axis name, got ${String(name)}`)
+      return { kind: "axis", label: `${who} ${name}`, rate: sumAxis(pad => pad.axes[name] ?? 0) }
+    },
+    button(name) {
+      if (typeof name !== "string" || name.length === 0) throw new Error(`gamepad.button: expected a button name, got ${String(name)}`)
+      return { kind: "button", label: `${who} ${name}`, rate: anyButton(name) }
+    },
+  }
+}
+
+/** One slot, or every connected pad when `slot` is undefined. */
+export function createGamepadSlot(read: PadsAccessor, slot: number | undefined): GamepadDevice {
+  if (slot !== undefined && !(Number.isInteger(slot) && slot >= 0)) throw new Error(`gamepad: slot must be a non-negative integer, got ${String(slot)}`)
+  let pads = (): GamepadState[] => {
+    let all = read()
+    if (slot === undefined) return all.filter((p): p is GamepadState => p !== null)
+    let pad = all[slot]
+    return pad ? [pad] : []
+  }
+  return createGamepadDevice(pads, () => slot, slot === undefined ? "gamepad" : `gamepad ${slot}`)
+}
+
+// Slots held by joining devices, shared so a pad joins once.
+let claimed = new Set<number>()
+
+/** A device that claims the next unclaimed pad to press any button. */
+export function createGamepadJoin(read: PadsAccessor): GamepadDevice {
+  // ownedWrite: the claim lands inside an effect, the release in a cleanup.
+  let [slot, setSlot] = createSignal<number | undefined>(undefined, { ownedWrite: true })
+  let mine: number | undefined
+  // A root of its own: the watch outlives the render scope that created
+  // the device only when there is none to tie it to.
+  let dispose = createRoot(dispose => {
+    createEffect(
+      () => read(),
+      pads => {
+        if (mine !== undefined) return
+        for (let i = 0; i < pads.length; i++) {
+          let pad = pads[i]
+          if (!pad || claimed.has(i) || pad.buttons.length === 0) continue
+          mine = i
+          claimed.add(i)
+          setSlot(i)
+          return
+        }
+      },
+    )
+    return dispose
+  })
+  if (getOwner()) {
+    onCleanup(() => {
+      dispose()
+      if (mine !== undefined) claimed.delete(mine)
+    })
+  }
+  let pads = (): GamepadState[] => {
+    let s = slot()
+    if (s === undefined) return []
+    let pad = read()[s]
+    return pad ? [pad] : []
+  }
+  return createGamepadDevice(pads, slot, "gamepad (joined)")
+}

package/src/input-gamepad.ts

@@ -0,0 +1,24 @@
+// The gamepad device over core's gamepads() snapshot: `gamepad(slot)`
+// reads one pad (slots are stable per connection, so slot 0 is player
+// one for the session); `gamepad()` sums every connected pad, the right
+// default for a single-player app that does not care which pad is picked
+// up; `gamepad.next()` claims the next pad that presses any button, for
+// split screen that seats players in pick-up order. The sources and the
+// join logic live in input-gamepad-device.ts, runtime-free.
+
+import { gamepads } from "./gamepad"
+import { createGamepadJoin, createGamepadSlot } from "./input-gamepad-device"
+import type { GamepadDevice } from "./input-gamepad-device"
+
+export type { GamepadDevice } from "./input-gamepad-device"
+
+export function gamepad(slot?: number): GamepadDevice {
+  return createGamepadSlot(gamepads, slot)
+}
+
+/**
+ * A device with no pad until one no other joining device holds presses
+ * any button, then that pad for good (`slot` resolves, reactively). The
+ * claim is released when the creating scope is disposed.
+ */
+gamepad.next = (): GamepadDevice => createGamepadJoin(gamepads)

package/src/input-keyboard.ts

@@ -0,0 +1,145 @@
+// The keyboard as input sources: a key as a button, a key pair as an
+// axis, four keys as a vec2 (the WASD composite), each holding its own
+// pressed state from the key events an input map forwards to it
+// (InputMap.handlers, spread on the window or the focused leaf). Keys
+// match on the physical code ("KeyW", layout-independent) or the logical
+// key ("w", what a synthetic event or an odd layout reports), and a
+// letter code matches its letter either way, so "KeyW" and "w" both take
+// a shifted "W".
+//
+// A spec may name modifiers ahead of the key ("Shift+Tab", "Ctrl+KeyS";
+// the chord vocabulary of input-chord.ts, shared with the pointer feed):
+// the down must carry them, while a bare spec ignores them (a shifted W
+// still walks). Within one source the most specific matching spec wins
+// a down, so `axis("Shift+Tab", "Tab")` reads -1, not 0, on Shift+Tab;
+// and an up releases on the key alone, so a modifier let go first
+// cannot leave the key stuck.
+//
+// Held state is a count behind a signal, so a source's rate is reactive
+// (a held key wakes a control's frame loop) and a blur - the up that never
+// arrives once focus has left - clears it. Composites clamp nothing: the
+// map's combination does (W and D together read [1, -1] before the
+// vec2 clamp to unit length, so diagonals walk at the same speed).
+//
+// Values use the screen convention (x right, y down): W reads [0, -1], as
+// a stick pushed up does.
+
+import { createSignal } from "@solidjs/signals"
+import type { KeyEvent } from "./types"
+import type { InputSource } from "./input-map"
+import type { Vec2 } from "./input-axes"
+import { mostSpecific, parseModifiers } from "./input-chord"
+import type { Modifier } from "./input-chord"
+
+// A parsed spec: the text as given (the held-state key and the label),
+// the key it names, and the modifiers the down must carry.
+type Spec = { text: string; key: string; mods: Modifier[] }
+
+function parse(what: string, text: unknown): Spec {
+  if (typeof text !== "string" || text.length === 0) throw new Error(`keyboard.${what}: expected a key code or key name, got ${String(text)}`)
+  let parts = text.split("+")
+  let key = parts.pop()!
+  if (key.length === 0) throw new Error(`keyboard.${what}: "${text}" names no key`)
+  return { text, key, mods: parseModifiers(`keyboard.${what}`, text, parts) }
+}
+
+// A key matches its physical code or its logical key; a letter code
+// ("KeyW") also matches the logical letter ("w", "W") and "Space" the
+// logical " ", so a synthetic event without a code (an agent's
+// send_input, an odd layout) still walks.
+let matches = (event: KeyEvent, key: string): boolean => {
+  if (event.code === key || event.key === key) return true
+  if (key === "Space" && event.key === " ") return true
+  if (event.key.length !== 1) return false
+  if (key.length === 1) return event.key.toLowerCase() === key.toLowerCase()
+  return key.length === 4 && key.startsWith("Key") && event.key.toLowerCase() === key[3]!.toLowerCase()
+}
+
+// A set of specs with a reactive "how many are held" count.
+function held(specs: Spec[]) {
+  let down = new Set<string>()
+  // ownedWrite: a map forwards key events from wherever its handlers sit.
+  let [count, setCount] = createSignal(0, { ownedWrite: true })
+  return {
+    count,
+    key(event: KeyEvent, isDown: boolean) {
+      // Every spec on this key is released first: a down settles the key
+      // on its most specific matches (a repeat under a newly held Shift
+      // moves "Tab" to "Shift+Tab" and back), an up frees them all.
+      let onKey = specs.filter(s => matches(event, s.key))
+      for (let s of onKey) down.delete(s.text)
+      if (isDown) for (let s of mostSpecific(onKey, s => s.mods, event)) down.add(s.text)
+      setCount(down.size)
+    },
+    blur() {
+      down.clear()
+      setCount(0)
+    },
+    has(text: string) {
+      return down.has(text)
+    },
+  }
+}
+
+/** One key as a button source (pressed while held). */
+function key(spec: string): InputSource<"button"> {
+  let state = held([parse("key", spec)])
+  return {
+    kind: "button",
+    label: `keyboard ${spec}`,
+    rate: () => state.count() > 0,
+    key: state.key,
+    blur: state.blur,
+  }
+}
+
+/** Two keys as an axis: `neg` reads -1, `pos` reads 1, both 0. */
+function axis(neg: string, pos: string): InputSource<"axis"> {
+  let state = held([parse("axis", neg), parse("axis", pos)])
+  return {
+    kind: "axis",
+    label: `keyboard ${neg}/${pos}`,
+    rate: () => {
+      state.count()
+      return (state.has(pos) ? 1 : 0) - (state.has(neg) ? 1 : 0)
+    },
+    key: state.key,
+    blur: state.blur,
+  }
+}
+
+export type KeyboardVec2Keys = { up: string; down: string; left: string; right: string }
+
+/** Four keys as a vec2 in the screen convention: up reads [0, -1], right
+ * reads [1, 0]; opposite keys cancel. */
+function vec2(keys: KeyboardVec2Keys): InputSource<"vec2"> {
+  let state = held((["up", "down", "left", "right"] as const).map(side => parse(`vec2 ${side}`, keys[side])))
+  return {
+    kind: "vec2",
+    label: `keyboard ${keys.up}/${keys.left}/${keys.down}/${keys.right}`,
+    rate: (): Vec2 => {
+      state.count()
+      return [(state.has(keys.right) ? 1 : 0) - (state.has(keys.left) ? 1 : 0), (state.has(keys.down) ? 1 : 0) - (state.has(keys.up) ? 1 : 0)]
+    },
+    key: state.key,
+    blur: state.blur,
+  }
+}
+
+/**
+ * The keyboard device: `keyboard.key("Space")`, `keyboard.axis("KeyQ",
+ * "KeyE")`, `keyboard.vec2({ up, down, left, right })`, and the two
+ * composites every game binds, `keyboard.wasd` and `keyboard.arrows`.
+ * A spec may carry modifiers ("Shift+Tab", "Ctrl+KeyS"). Each call makes
+ * an independent source with its own held state; the composites are
+ * shared singletons.
+ */
+export let keyboard = {
+  key,
+  axis,
+  vec2,
+  wasd: vec2({ up: "KeyW", down: "KeyS", left: "KeyA", right: "KeyD" }),
+  arrows: vec2({ up: "ArrowUp", down: "ArrowDown", left: "ArrowLeft", right: "ArrowRight" }),
+}
+
+export type KeyboardDevice = typeof keyboard