1681-engine 0.0.0-stage → 0.5.8

package/dist/input/Actions.js

@@ -0,0 +1,131 @@
+import { parseChord as c, chordHeld as l } from "./keyChord.js";
+const f = ["a", "b", "x", "y", "lb", "rb", "lt", "rt", "select", "start", "ls", "rs", "up", "down", "left", "right", "home"], u = ["lx", "ly", "rx", "ry"];
+class g {
+  constructor(t, e, i = {}) {
+    this.keyboard = t, this.bindings = new Map(Object.entries(e)), this.deadZone = i.deadZone ?? 0.25, this.gamepads = i.gamepads ?? (() => typeof navigator < "u" && typeof navigator.getGamepads == "function" ? navigator.getGamepads() : []);
+  }
+  keyboard;
+  bindings;
+  virtual = /* @__PURE__ */ new Set();
+  virtualDown = /* @__PURE__ */ new Set();
+  /** Analog value of each action this step (0–1), and last step's, for edges. */
+  now = /* @__PURE__ */ new Map();
+  before = /* @__PURE__ */ new Map();
+  deadZone;
+  gamepads;
+  /** Parsed chords by binding string; null for a plain key. */
+  chords = /* @__PURE__ */ new Map();
+  /** Keys a chord holds this step: their bare bindings read 0 until the key comes up. */
+  claimed = /* @__PURE__ */ new Set();
+  keyDown = (t) => this.keyboard !== null && (this.keyboard.isDown(t) || this.keyboard.pressed(t));
+  /** Replaces one action's bindings (a player's rebinding). */
+  bind(t, e) {
+    this.bindings.set(t, [...e]);
+  }
+  bindingsOf(t) {
+    return this.bindings.get(t) ?? [];
+  }
+  /** A touch UI's virtual button went down: `touch:<name>` bindings read it. */
+  press(t) {
+    this.virtual.add(t), this.virtualDown.add(t);
+  }
+  release(t) {
+    this.virtual.delete(t);
+  }
+  /** Reads every device once; call at the start of each simulation step. */
+  poll() {
+    [this.before, this.now] = [this.now, this.before], this.now.clear();
+    const t = this.gamepads().filter((e) => e !== null);
+    this.claimChords();
+    for (const [e, i] of this.bindings) {
+      let s = 0;
+      for (const o of i) s = Math.max(s, this.read(o, t));
+      s > 0 && this.now.set(e, s);
+    }
+  }
+  /** Held this step. */
+  down(t) {
+    return (this.now.get(t) ?? 0) > 0;
+  }
+  /** How far it is held (0–1): 1 for a key, the trigger or stick amount for analog input. */
+  value(t) {
+    return this.now.get(t) ?? 0;
+  }
+  /** Went down this step. */
+  pressed(t) {
+    return this.down(t) && !((this.before.get(t) ?? 0) > 0);
+  }
+  /** Came up this step. */
+  released(t) {
+    return !this.down(t) && (this.before.get(t) ?? 0) > 0;
+  }
+  /** `value(positive) - value(negative)`, in −1…1. */
+  axis(t, e) {
+    return this.value(e) - this.value(t);
+  }
+  /** A 2D direction from four actions, never longer than 1 (a diagonal is not faster). */
+  vector(t, e, i, s) {
+    const o = this.axis(t, e), r = this.axis(i, s), n = Math.hypot(o, r);
+    return n > 1 ? [o / n, r / n] : [o, r];
+  }
+  /** Ends the step: the keyboard forgets its edges; virtual taps shorter than a step have now been seen. */
+  endStep() {
+    this.keyboard?.endStep(), this.virtualDown.clear();
+  }
+  /**
+   * Drops every pending edge: what went down or up since the last step is forgotten, and what is held now counts as
+   * already held, so the next `poll` reports no `pressed` or `released` for it. For input that sat unread while
+   * something else had the keys (a pause menu over the level; `SceneManager.pop` calls it through `Scene.useInput`).
+   */
+  flush() {
+    this.keyboard?.endStep(), this.virtualDown.clear(), this.poll(), this.before = new Map(this.now);
+  }
+  chordOf(t) {
+    let e = this.chords.get(t);
+    return e === void 0 && (e = t.startsWith("pad:") || t.startsWith("touch:") ? null : c(t), this.chords.set(t, e)), e;
+  }
+  /** Marks the keys held chords use, and frees those whose key has come up. */
+  claimChords() {
+    for (const t of this.claimed) this.keyDown(t) || this.claimed.delete(t);
+    if (this.keyboard)
+      for (const t of this.bindings.values())
+        for (const e of t) {
+          const i = this.chordOf(e);
+          i && l(i, this.keyDown) && this.claimed.add(i.code);
+        }
+  }
+  read(t, e) {
+    if (t.startsWith("touch:")) {
+      const s = t.slice(6);
+      return this.virtual.has(s) || this.virtualDown.has(s) ? 1 : 0;
+    }
+    if (t.startsWith("pad:")) {
+      const s = t.slice(4);
+      let o = 0;
+      const r = s.endsWith("+") ? 1 : s.endsWith("-") ? -1 : 0;
+      if (r !== 0) {
+        const h = u.indexOf(s.slice(0, -1));
+        if (h < 0) return 0;
+        for (const a of e) {
+          const d = (a.axes[h] ?? 0) * r;
+          d > this.deadZone && (o = Math.max(o, (d - this.deadZone) / (1 - this.deadZone)));
+        }
+        return Math.min(1, o);
+      }
+      const n = f.indexOf(s);
+      if (n < 0) return 0;
+      for (const h of e) {
+        const a = h.buttons[n];
+        a?.pressed && (o = Math.max(o, a.value > 0 ? a.value : 1));
+      }
+      return Math.min(1, o);
+    }
+    const i = this.chordOf(t);
+    return i ? l(i, this.keyDown) ? 1 : 0 : this.claimed.has(t) ? 0 : this.keyDown(t) ? 1 : 0;
+  }
+}
+export {
+  g as Actions,
+  f as PAD_BUTTONS
+};
+//# sourceMappingURL=Actions.js.map

package/dist/input/Actions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Actions.js","sources":["../../src/input/Actions.ts"],"sourcesContent":["import type { Keyboard } from './Keyboard';\nimport { chordHeld, parseChord, type KeyChord } from './keyChord';\n\n/**\n * Named actions bound to any input: keys, gamepad buttons and sticks, and virtual buttons a touch UI presses. Game\n * code asks for `'jump'`, never for `Space`, so players can rebind and every device works the same.\n *\n * ```ts\n * const input = new Actions(keyboard, {\n *   left: ['KeyA', 'ArrowLeft', 'pad:left', 'pad:lx-'],\n *   right: ['KeyD', 'ArrowRight', 'pad:right', 'pad:lx+'],\n *   jump: ['Space', 'pad:a'],\n * });\n * // in a fixed system:\n * input.poll();\n * if (input.pressed('jump')) …\n * const [x, y] = input.vector('left', 'right', 'up', 'down');\n * input.endStep();\n * ```\n *\n * Bindings: a `KeyboardEvent.code` (`KeyW`, `Space`, `ArrowUp`), a chord of modifiers and a code (`Shift+Tab`,\n * `Ctrl+KeyS`: `Shift`, `Ctrl`, `Alt`, `Meta`, either side), `pad:<button>` (standard mapping names below),\n * `pad:<axis>+` / `pad:<axis>-` for a stick half (`lx`, `ly`, `rx`, `ry`), or `touch:<name>` for a virtual button\n * (`press`/`release`).\n *\n * A chord wins over its bare key: while `Shift+Tab` is held, an action bound to plain `Tab` is not, and it stays off\n * until Tab itself comes up (letting Shift go first must not turn a Shift+Tab into a Tab). A bare key held with a\n * modifier no chord names still counts (Shift held to run does not stop the jump key).\n */\nexport type Bindings<A extends string> = Record<A, readonly string[]>;\n\n/** Button names of the browser's standard gamepad mapping, in index order. */\nexport const PAD_BUTTONS = ['a', 'b', 'x', 'y', 'lb', 'rb', 'lt', 'rt', 'select', 'start', 'ls', 'rs', 'up', 'down', 'left', 'right', 'home'] as const;\nconst PAD_AXES = ['lx', 'ly', 'rx', 'ry'] as const;\n\n/** What the actions read from a gamepad; `navigator.getGamepads()` entries satisfy it. */\nexport interface PadState {\n  readonly buttons: readonly { readonly pressed: boolean; readonly value: number }[];\n  readonly axes: readonly number[];\n}\n\nexport interface ActionsOptions {\n  /** Stick values under this count as 0 (default 0.25). */\n  deadZone?: number;\n  /** Where gamepads come from (default `navigator.getGamepads`); tests pass their own. */\n  gamepads?: () => readonly (PadState | null)[];\n}\n\nexport class Actions<A extends string> {\n  private bindings: Map<A, readonly string[]>;\n  private readonly virtual = new Set<string>();\n  private readonly virtualDown = new Set<string>();\n  /** Analog value of each action this step (0–1), and last step's, for edges. */\n  private now = new Map<A, number>();\n  private before = new Map<A, number>();\n  private readonly deadZone: number;\n  private readonly gamepads: () => readonly (PadState | null)[];\n  /** Parsed chords by binding string; null for a plain key. */\n  private readonly chords = new Map<string, KeyChord | null>();\n  /** Keys a chord holds this step: their bare bindings read 0 until the key comes up. */\n  private readonly claimed = new Set<string>();\n  private readonly keyDown = (code: string) => this.keyboard !== null && (this.keyboard.isDown(code) || this.keyboard.pressed(code));\n\n  constructor(\n    private readonly keyboard: Keyboard | null,\n    bindings: Bindings<A>,\n    options: ActionsOptions = {},\n  ) {\n    this.bindings = new Map(Object.entries(bindings) as [A, readonly string[]][]);\n    this.deadZone = options.deadZone ?? 0.25;\n    this.gamepads =\n      options.gamepads ?? (() => (typeof navigator !== 'undefined' && typeof navigator.getGamepads === 'function' ? navigator.getGamepads() : []));\n  }\n\n  /** Replaces one action's bindings (a player's rebinding). */\n  bind(action: A, inputs: readonly string[]): void {\n    this.bindings.set(action, [...inputs]);\n  }\n\n  bindingsOf(action: A): readonly string[] {\n    return this.bindings.get(action) ?? [];\n  }\n\n  /** A touch UI's virtual button went down: `touch:<name>` bindings read it. */\n  press(name: string): void {\n    this.virtual.add(name);\n    this.virtualDown.add(name);\n  }\n\n  release(name: string): void {\n    this.virtual.delete(name);\n  }\n\n  /** Reads every device once; call at the start of each simulation step. */\n  poll(): void {\n    [this.before, this.now] = [this.now, this.before];\n    this.now.clear();\n    const pads = this.gamepads().filter((p): p is PadState => p !== null);\n    this.claimChords();\n    for (const [action, inputs] of this.bindings) {\n      let v = 0;\n      for (const input of inputs) v = Math.max(v, this.read(input, pads));\n      if (v > 0) this.now.set(action, v);\n    }\n  }\n\n  /** Held this step. */\n  down(action: A): boolean {\n    return (this.now.get(action) ?? 0) > 0;\n  }\n\n  /** How far it is held (0–1): 1 for a key, the trigger or stick amount for analog input. */\n  value(action: A): number {\n    return this.now.get(action) ?? 0;\n  }\n\n  /** Went down this step. */\n  pressed(action: A): boolean {\n    return this.down(action) && !((this.before.get(action) ?? 0) > 0);\n  }\n\n  /** Came up this step. */\n  released(action: A): boolean {\n    return !this.down(action) && (this.before.get(action) ?? 0) > 0;\n  }\n\n  /** `value(positive) - value(negative)`, in −1…1. */\n  axis(negative: A, positive: A): number {\n    return this.value(positive) - this.value(negative);\n  }\n\n  /** A 2D direction from four actions, never longer than 1 (a diagonal is not faster). */\n  vector(left: A, right: A, up: A, down: A): [number, number] {\n    const x = this.axis(left, right);\n    const y = this.axis(up, down);\n    const len = Math.hypot(x, y);\n    return len > 1 ? [x / len, y / len] : [x, y];\n  }\n\n  /** Ends the step: the keyboard forgets its edges; virtual taps shorter than a step have now been seen. */\n  endStep(): void {\n    this.keyboard?.endStep();\n    this.virtualDown.clear();\n  }\n\n  /**\n   * Drops every pending edge: what went down or up since the last step is forgotten, and what is held now counts as\n   * already held, so the next `poll` reports no `pressed` or `released` for it. For input that sat unread while\n   * something else had the keys (a pause menu over the level; `SceneManager.pop` calls it through `Scene.useInput`).\n   */\n  flush(): void {\n    this.keyboard?.endStep();\n    this.virtualDown.clear();\n    this.poll();\n    this.before = new Map(this.now);\n  }\n\n  private chordOf(input: string): KeyChord | null {\n    let c = this.chords.get(input);\n    if (c === undefined) {\n      c = input.startsWith('pad:') || input.startsWith('touch:') ? null : parseChord(input);\n      this.chords.set(input, c);\n    }\n    return c;\n  }\n\n  /** Marks the keys held chords use, and frees those whose key has come up. */\n  private claimChords(): void {\n    for (const code of this.claimed) if (!this.keyDown(code)) this.claimed.delete(code);\n    if (!this.keyboard) return;\n    for (const inputs of this.bindings.values())\n      for (const input of inputs) {\n        const chord = this.chordOf(input);\n        if (chord && chordHeld(chord, this.keyDown)) this.claimed.add(chord.code);\n      }\n  }\n\n  private read(input: string, pads: readonly PadState[]): number {\n    if (input.startsWith('touch:')) {\n      const name = input.slice(6);\n      return this.virtual.has(name) || this.virtualDown.has(name) ? 1 : 0;\n    }\n    if (input.startsWith('pad:')) {\n      const what = input.slice(4);\n      let v = 0;\n      const sign = what.endsWith('+') ? 1 : what.endsWith('-') ? -1 : 0;\n      if (sign !== 0) {\n        const axis = PAD_AXES.indexOf(what.slice(0, -1) as (typeof PAD_AXES)[number]);\n        if (axis < 0) return 0;\n        for (const p of pads) {\n          const raw = (p.axes[axis] ?? 0) * sign;\n          if (raw > this.deadZone) v = Math.max(v, (raw - this.deadZone) / (1 - this.deadZone));\n        }\n        return Math.min(1, v);\n      }\n      const button = PAD_BUTTONS.indexOf(what as (typeof PAD_BUTTONS)[number]);\n      if (button < 0) return 0;\n      // a digital button reports value 1 when pressed; an analog trigger its depth (some pads report 0 for a press)\n      for (const p of pads) {\n        const b = p.buttons[button];\n        if (b?.pressed) v = Math.max(v, b.value > 0 ? b.value : 1);\n      }\n      return Math.min(1, v);\n    }\n    const chord = this.chordOf(input);\n    if (chord) return chordHeld(chord, this.keyDown) ? 1 : 0;\n    if (this.claimed.has(input)) return 0;\n    return this.keyDown(input) ? 1 : 0;\n  }\n}\n"],"names":["PAD_BUTTONS","PAD_AXES","Actions","keyboard","bindings","options","code","action","inputs","name","pads","p","v","input","negative","positive","left","right","up","down","x","y","len","c","parseChord","chord","chordHeld","what","sign","axis","raw","button","b"],"mappings":";AAgCO,MAAMA,IAAc,CAAC,KAAK,KAAK,KAAK,KAAK,MAAM,MAAM,MAAM,MAAM,UAAU,SAAS,MAAM,MAAM,MAAM,QAAQ,QAAQ,SAAS,MAAM,GACtIC,IAAW,CAAC,MAAM,MAAM,MAAM,IAAI;AAejC,MAAMC,EAA0B;AAAA,EAerC,YACmBC,GACjBC,GACAC,IAA0B,CAAA,GAC1B;AAHiB,SAAA,WAAAF,GAIjB,KAAK,WAAW,IAAI,IAAI,OAAO,QAAQC,CAAQ,CAA6B,GAC5E,KAAK,WAAWC,EAAQ,YAAY,MACpC,KAAK,WACHA,EAAQ,aAAa,MAAO,OAAO,YAAc,OAAe,OAAO,UAAU,eAAgB,aAAa,UAAU,YAAA,IAAgB,CAAA;AAAA,EAC5I;AAAA,EARmB;AAAA,EAfX;AAAA,EACS,8BAAc,IAAA;AAAA,EACd,kCAAkB,IAAA;AAAA;AAAA,EAE3B,0BAAU,IAAA;AAAA,EACV,6BAAa,IAAA;AAAA,EACJ;AAAA,EACA;AAAA;AAAA,EAEA,6BAAa,IAAA;AAAA;AAAA,EAEb,8BAAc,IAAA;AAAA,EACd,UAAU,CAACC,MAAiB,KAAK,aAAa,SAAS,KAAK,SAAS,OAAOA,CAAI,KAAK,KAAK,SAAS,QAAQA,CAAI;AAAA;AAAA,EAchI,KAAKC,GAAWC,GAAiC;AAC/C,SAAK,SAAS,IAAID,GAAQ,CAAC,GAAGC,CAAM,CAAC;AAAA,EACvC;AAAA,EAEA,WAAWD,GAA8B;AACvC,WAAO,KAAK,SAAS,IAAIA,CAAM,KAAK,CAAA;AAAA,EACtC;AAAA;AAAA,EAGA,MAAME,GAAoB;AACxB,SAAK,QAAQ,IAAIA,CAAI,GACrB,KAAK,YAAY,IAAIA,CAAI;AAAA,EAC3B;AAAA,EAEA,QAAQA,GAAoB;AAC1B,SAAK,QAAQ,OAAOA,CAAI;AAAA,EAC1B;AAAA;AAAA,EAGA,OAAa;AACX,KAAC,KAAK,QAAQ,KAAK,GAAG,IAAI,CAAC,KAAK,KAAK,KAAK,MAAM,GAChD,KAAK,IAAI,MAAA;AACT,UAAMC,IAAO,KAAK,SAAA,EAAW,OAAO,CAACC,MAAqBA,MAAM,IAAI;AACpE,SAAK,YAAA;AACL,eAAW,CAACJ,GAAQC,CAAM,KAAK,KAAK,UAAU;AAC5C,UAAII,IAAI;AACR,iBAAWC,KAASL,EAAQ,CAAAI,IAAI,KAAK,IAAIA,GAAG,KAAK,KAAKC,GAAOH,CAAI,CAAC;AAClE,MAAIE,IAAI,KAAG,KAAK,IAAI,IAAIL,GAAQK,CAAC;AAAA,IACnC;AAAA,EACF;AAAA;AAAA,EAGA,KAAKL,GAAoB;AACvB,YAAQ,KAAK,IAAI,IAAIA,CAAM,KAAK,KAAK;AAAA,EACvC;AAAA;AAAA,EAGA,MAAMA,GAAmB;AACvB,WAAO,KAAK,IAAI,IAAIA,CAAM,KAAK;AAAA,EACjC;AAAA;AAAA,EAGA,QAAQA,GAAoB;AAC1B,WAAO,KAAK,KAAKA,CAAM,KAAK,GAAG,KAAK,OAAO,IAAIA,CAAM,KAAK,KAAK;AAAA,EACjE;AAAA;AAAA,EAGA,SAASA,GAAoB;AAC3B,WAAO,CAAC,KAAK,KAAKA,CAAM,MAAM,KAAK,OAAO,IAAIA,CAAM,KAAK,KAAK;AAAA,EAChE;AAAA;AAAA,EAGA,KAAKO,GAAaC,GAAqB;AACrC,WAAO,KAAK,MAAMA,CAAQ,IAAI,KAAK,MAAMD,CAAQ;AAAA,EACnD;AAAA;AAAA,EAGA,OAAOE,GAASC,GAAUC,GAAOC,GAA2B;AAC1D,UAAMC,IAAI,KAAK,KAAKJ,GAAMC,CAAK,GACzBI,IAAI,KAAK,KAAKH,GAAIC,CAAI,GACtBG,IAAM,KAAK,MAAMF,GAAGC,CAAC;AAC3B,WAAOC,IAAM,IAAI,CAACF,IAAIE,GAAKD,IAAIC,CAAG,IAAI,CAACF,GAAGC,CAAC;AAAA,EAC7C;AAAA;AAAA,EAGA,UAAgB;AACd,SAAK,UAAU,QAAA,GACf,KAAK,YAAY,MAAA;AAAA,EACnB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,QAAc;AACZ,SAAK,UAAU,QAAA,GACf,KAAK,YAAY,MAAA,GACjB,KAAK,KAAA,GACL,KAAK,SAAS,IAAI,IAAI,KAAK,GAAG;AAAA,EAChC;AAAA,EAEQ,QAAQR,GAAgC;AAC9C,QAAIU,IAAI,KAAK,OAAO,IAAIV,CAAK;AAC7B,WAAIU,MAAM,WACRA,IAAIV,EAAM,WAAW,MAAM,KAAKA,EAAM,WAAW,QAAQ,IAAI,OAAOW,EAAWX,CAAK,GACpF,KAAK,OAAO,IAAIA,GAAOU,CAAC,IAEnBA;AAAA,EACT;AAAA;AAAA,EAGQ,cAAoB;AAC1B,eAAWjB,KAAQ,KAAK,QAAS,CAAK,KAAK,QAAQA,CAAI,KAAG,KAAK,QAAQ,OAAOA,CAAI;AAClF,QAAK,KAAK;AACV,iBAAWE,KAAU,KAAK,SAAS,OAAA;AACjC,mBAAWK,KAASL,GAAQ;AAC1B,gBAAMiB,IAAQ,KAAK,QAAQZ,CAAK;AAChC,UAAIY,KAASC,EAAUD,GAAO,KAAK,OAAO,KAAG,KAAK,QAAQ,IAAIA,EAAM,IAAI;AAAA,QAC1E;AAAA,EACJ;AAAA,EAEQ,KAAKZ,GAAeH,GAAmC;AAC7D,QAAIG,EAAM,WAAW,QAAQ,GAAG;AAC9B,YAAMJ,IAAOI,EAAM,MAAM,CAAC;AAC1B,aAAO,KAAK,QAAQ,IAAIJ,CAAI,KAAK,KAAK,YAAY,IAAIA,CAAI,IAAI,IAAI;AAAA,IACpE;AACA,QAAII,EAAM,WAAW,MAAM,GAAG;AAC5B,YAAMc,IAAOd,EAAM,MAAM,CAAC;AAC1B,UAAID,IAAI;AACR,YAAMgB,IAAOD,EAAK,SAAS,GAAG,IAAI,IAAIA,EAAK,SAAS,GAAG,IAAI,KAAK;AAChE,UAAIC,MAAS,GAAG;AACd,cAAMC,IAAO5B,EAAS,QAAQ0B,EAAK,MAAM,GAAG,EAAE,CAA8B;AAC5E,YAAIE,IAAO,EAAG,QAAO;AACrB,mBAAWlB,KAAKD,GAAM;AACpB,gBAAMoB,KAAOnB,EAAE,KAAKkB,CAAI,KAAK,KAAKD;AAClC,UAAIE,IAAM,KAAK,aAAUlB,IAAI,KAAK,IAAIA,IAAIkB,IAAM,KAAK,aAAa,IAAI,KAAK,SAAS;AAAA,QACtF;AACA,eAAO,KAAK,IAAI,GAAGlB,CAAC;AAAA,MACtB;AACA,YAAMmB,IAAS/B,EAAY,QAAQ2B,CAAoC;AACvE,UAAII,IAAS,EAAG,QAAO;AAEvB,iBAAWpB,KAAKD,GAAM;AACpB,cAAMsB,IAAIrB,EAAE,QAAQoB,CAAM;AAC1B,QAAIC,GAAG,YAASpB,IAAI,KAAK,IAAIA,GAAGoB,EAAE,QAAQ,IAAIA,EAAE,QAAQ,CAAC;AAAA,MAC3D;AACA,aAAO,KAAK,IAAI,GAAGpB,CAAC;AAAA,IACtB;AACA,UAAMa,IAAQ,KAAK,QAAQZ,CAAK;AAChC,WAAIY,IAAcC,EAAUD,GAAO,KAAK,OAAO,IAAI,IAAI,IACnD,KAAK,QAAQ,IAAIZ,CAAK,IAAU,IAC7B,KAAK,QAAQA,CAAK,IAAI,IAAI;AAAA,EACnC;AACF;"}

package/dist/input/AimGesture.js

@@ -0,0 +1,75 @@
+const u = 10, y = 28, d = 180, S = 0.2;
+function o(s, t = !0, n = 10, i = 28, e = 180) {
+  return t && s < e ? i : n;
+}
+class _ {
+  dragged = !1;
+  over = !1;
+  /** Where the knob is drawn, clamped to the circle, relative to the button's centre. */
+  knob = { x: 0, y: 0 };
+  /** The knob as a vector of length ≤ 1: what the world reads. */
+  share = { x: 0, y: 0 };
+  radius;
+  sensitivity;
+  centreCancels;
+  tapSlop;
+  earlySlop;
+  pressMs;
+  centre;
+  constructor(t) {
+    this.radius = Math.max(1e-6, t.radius), this.sensitivity = t.sensitivity ?? 1, this.centreCancels = t.centreCancels ?? !0, this.tapSlop = t.tapSlop ?? 10, this.earlySlop = t.earlySlop ?? 28, this.pressMs = t.pressMs ?? 180, this.centre = t.centre ?? 0.2;
+  }
+  /**
+   * The thumb at `rawX, rawY` from the button's centre, `overCancel` when it is over the cancel zone, `ms` since it
+   * went down (Infinity skips the landing slop). Once a drag, always a drag for this press.
+   */
+  move(t, n, i = !1, e = 1 / 0) {
+    Math.hypot(t, n) > o(e, !0, this.tapSlop, this.earlySlop, this.pressMs) && (this.dragged = !0), this.over = i;
+    const r = t * this.sensitivity, a = n * this.sensitivity, c = Math.hypot(r, a), h = c > this.radius ? this.radius / c : 1;
+    this.knob = { x: r * h, y: a * h }, this.share = { x: this.knob.x / this.radius, y: this.knob.y / this.radius };
+  }
+  /** A drag has begun: show the aim from now on. */
+  get aiming() {
+    return this.dragged;
+  }
+  get centred() {
+    return Math.hypot(this.share.x, this.share.y) < this.centre;
+  }
+  /** Letting go now would cast nothing (draw the cancel zone lit). */
+  get cancelling() {
+    return this.dragged && (this.over || this.centreCancels && this.centred);
+  }
+  up() {
+    return this.dragged ? this.cancelling ? "cancel" : this.centred ? "tap" : "cast" : "tap";
+  }
+}
+function l(s, t = 0.2) {
+  return Math.max(0, Math.min(1, (s - t) / (1 - t)));
+}
+function g(s, t, n, i = 0.2) {
+  const e = Math.hypot(s, t);
+  if (e < 1e-6) return { x: 0, y: 0 };
+  const r = i + (1 - i) * Math.min(1, e / n);
+  return { x: s / e * r, y: t / e * r };
+}
+function p(s, t, n, i, e = 0.2) {
+  const r = Math.hypot(n.x, n.y), a = r > 1e-6 ? Math.atan2(n.y, n.x) : i;
+  if (t.kind === "point") {
+    const M = l(r, e) * t.range;
+    return { aim: a, x: s.x + Math.cos(a) * M, y: s.y + Math.sin(a) * M };
+  }
+  const c = t.snap ? Math.round(a / t.snap) * t.snap : a, h = t.backwards ? c + Math.PI : c;
+  return { aim: h, x: s.x + Math.cos(h) * t.length, y: s.y + Math.sin(h) * t.length };
+}
+export {
+  S as AIM_CENTRE,
+  y as AIM_EARLY_SLOP,
+  d as AIM_PRESS_MS,
+  u as AIM_TAP_SLOP,
+  _ as AimGesture,
+  p as aimPoint,
+  o as dragSlop,
+  l as spotReach,
+  g as spotShare
+};
+//# sourceMappingURL=AimGesture.js.map

package/dist/input/AimGesture.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AimGesture.js","sources":["../../src/input/AimGesture.ts"],"sourcesContent":["/**\n * The drag-to-aim gesture of a touch skill button (the MOBA way), kept pure so it can be tested. Pressing an aimed\n * button opens a circle round it with a knob under the thumb; where the knob sits in that circle is where the skill\n * goes. A press that never wanders past the tap slop is a tap (the game casts it the way a tap always does: at the\n * locked target, the nearest enemy, the facing). Letting go over a cancel zone casts nothing; letting go with the knob\n * back on the button casts as a tap, or cancels when `centreCancels` (the one way to cancel when there is no zone).\n *\n * The thumb gets a longer slop in the first `pressMs` of a press: a hard press slides as it lands, and a quick tap\n * that slid past the plain slop became a drag that flew wherever the slide pointed.\n *\n * ```ts\n * const g = new AimGesture({ radius: 90, centreCancels: !hasCancelZone });\n * // pointermove:  g.move(dx, dy, overCancelZone, now - downAt)\n * // pointerup:    const end = g.up(); // 'tap' | 'cast' | 'cancel'\n * // while g.aiming, draw the aim from aimPoint(caster, shape, g.share, facing)\n * ```\n */\n\nexport type AimEnd = 'tap' | 'cast' | 'cancel';\n\nexport interface AimGestureOptions {\n  /** The circle's radius, in the same units as the thumb's offsets (CSS px). */\n  radius: number;\n  /** Scales the thumb's travel into the knob's (a sensitivity setting); the slops stay the thumb's own (default 1). */\n  sensitivity?: number;\n  /** The knob let go back on the button cancels rather than casting as a tap (default true). */\n  centreCancels?: boolean;\n  /** How far the thumb may wander before a press is a drag (default 10). */\n  tapSlop?: number;\n  /** The slop in a press's first `pressMs` (default 28). */\n  earlySlop?: number;\n  /** How long a press is \"landing\" (default 180 ms). */\n  pressMs?: number;\n  /** Inside this share of the radius the knob is back on the button (default 0.2). */\n  centre?: number;\n}\n\nexport const AIM_TAP_SLOP = 10;\nexport const AIM_EARLY_SLOP = 28;\nexport const AIM_PRESS_MS = 180;\nexport const AIM_CENTRE = 0.2;\n\n/**\n * How far the thumb must wander, `ms` into a press, before it drags. `early` false keeps the plain slop throughout\n * (an attack button with nothing locked: there a slide is as good as a drag).\n */\nexport function dragSlop(ms: number, early = true, tapSlop = AIM_TAP_SLOP, earlySlop = AIM_EARLY_SLOP, pressMs = AIM_PRESS_MS): number {\n  return early && ms < pressMs ? earlySlop : tapSlop;\n}\n\ntype Point = { x: number; y: number };\n\nexport class AimGesture {\n  private dragged = false;\n  private over = false;\n  /** Where the knob is drawn, clamped to the circle, relative to the button's centre. */\n  knob: Point = { x: 0, y: 0 };\n  /** The knob as a vector of length ≤ 1: what the world reads. */\n  share: Point = { x: 0, y: 0 };\n  private readonly radius: number;\n  private readonly sensitivity: number;\n  private readonly centreCancels: boolean;\n  private readonly tapSlop: number;\n  private readonly earlySlop: number;\n  private readonly pressMs: number;\n  private readonly centre: number;\n\n  constructor(options: AimGestureOptions) {\n    this.radius = Math.max(1e-6, options.radius);\n    this.sensitivity = options.sensitivity ?? 1;\n    this.centreCancels = options.centreCancels ?? true;\n    this.tapSlop = options.tapSlop ?? AIM_TAP_SLOP;\n    this.earlySlop = options.earlySlop ?? AIM_EARLY_SLOP;\n    this.pressMs = options.pressMs ?? AIM_PRESS_MS;\n    this.centre = options.centre ?? AIM_CENTRE;\n  }\n\n  /**\n   * The thumb at `rawX, rawY` from the button's centre, `overCancel` when it is over the cancel zone, `ms` since it\n   * went down (Infinity skips the landing slop). Once a drag, always a drag for this press.\n   */\n  move(rawX: number, rawY: number, overCancel = false, ms = Infinity): void {\n    if (Math.hypot(rawX, rawY) > dragSlop(ms, true, this.tapSlop, this.earlySlop, this.pressMs)) this.dragged = true;\n    this.over = overCancel;\n    const dx = rawX * this.sensitivity;\n    const dy = rawY * this.sensitivity;\n    const len = Math.hypot(dx, dy);\n    const k = len > this.radius ? this.radius / len : 1;\n    this.knob = { x: dx * k, y: dy * k };\n    this.share = { x: this.knob.x / this.radius, y: this.knob.y / this.radius };\n  }\n\n  /** A drag has begun: show the aim from now on. */\n  get aiming(): boolean {\n    return this.dragged;\n  }\n\n  private get centred(): boolean {\n    return Math.hypot(this.share.x, this.share.y) < this.centre;\n  }\n\n  /** Letting go now would cast nothing (draw the cancel zone lit). */\n  get cancelling(): boolean {\n    return this.dragged && (this.over || (this.centreCancels && this.centred));\n  }\n\n  up(): AimEnd {\n    if (!this.dragged) return 'tap';\n    if (this.cancelling) return 'cancel';\n    return this.centred ? 'tap' : 'cast';\n  }\n}\n\n/**\n * How a skill is aimed: at a spot within `range` (a blast, a blink), or along a direction for `length` (a shot, a\n * dash; `backwards` for a leap away from the aim).\n */\nexport type AimShape =\n  | { kind: 'point'; range: number }\n  | { kind: 'direction'; length: number; backwards?: boolean; snap?: number };\n\n/**\n * How far out a spot skill's knob puts it, as a share of its range: from the centre ring's edge to the rim is the\n * whole reach, so a knob just out of the ring lands at the caster's feet — with `share × range`, nothing nearer than\n * the ring could ever be reached.\n */\nexport function spotReach(len: number, centre = AIM_CENTRE): number {\n  return Math.max(0, Math.min(1, (len - centre) / (1 - centre)));\n}\n\n/** The knob that puts a spot skill `dx, dy` from the caster: `spotReach`'s inverse (aim assist, replays). */\nexport function spotShare(dx: number, dy: number, range: number, centre = AIM_CENTRE): Point {\n  const d = Math.hypot(dx, dy);\n  if (d < 1e-6) return { x: 0, y: 0 };\n  const len = centre + (1 - centre) * Math.min(1, d / range);\n  return { x: (dx / d) * len, y: (dy / d) * len };\n}\n\n/**\n * Where an aimed skill goes, as a mouse would have said it: the aim angle and the ground point. A knob with no length\n * keeps `lastAim`. A direction may snap to `snap` radians (0 or none for free aim).\n */\nexport function aimPoint(from: Point, shape: AimShape, share: Point, lastAim: number, centre = AIM_CENTRE): { aim: number; x: number; y: number } {\n  const len = Math.hypot(share.x, share.y);\n  const angle = len > 1e-6 ? Math.atan2(share.y, share.x) : lastAim;\n  if (shape.kind === 'point') {\n    const d = spotReach(len, centre) * shape.range;\n    return { aim: angle, x: from.x + Math.cos(angle) * d, y: from.y + Math.sin(angle) * d };\n  }\n  const snapped = shape.snap ? Math.round(angle / shape.snap) * shape.snap : angle;\n  const aim = shape.backwards ? snapped + Math.PI : snapped;\n  return { aim, x: from.x + Math.cos(aim) * shape.length, y: from.y + Math.sin(aim) * shape.length };\n}\n"],"names":["AIM_TAP_SLOP","AIM_EARLY_SLOP","AIM_PRESS_MS","AIM_CENTRE","dragSlop","ms","early","tapSlop","earlySlop","pressMs","AimGesture","options","rawX","rawY","overCancel","dx","dy","len","k","spotReach","centre","spotShare","range","d","aimPoint","from","shape","share","lastAim","angle","snapped","aim"],"mappings":"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"}

package/dist/input/Keyboard.js

@@ -0,0 +1,54 @@
+class h {
+  held = /* @__PURE__ */ new Set();
+  down = /* @__PURE__ */ new Set();
+  up = /* @__PURE__ */ new Set();
+  cleanup = [];
+  constructor(e = window) {
+    const n = (t) => {
+      const s = t.code;
+      t.repeat || this.held.has(s) || (this.held.add(s), this.down.add(s));
+    }, d = (t) => {
+      const s = t.code;
+      this.held.delete(s) && this.up.add(s);
+    }, r = () => {
+      for (const t of this.held) this.up.add(t);
+      this.held.clear();
+    };
+    e.addEventListener("keydown", n), e.addEventListener("keyup", d), window.addEventListener("blur", r), this.cleanup.push(
+      () => e.removeEventListener("keydown", n),
+      () => e.removeEventListener("keyup", d),
+      () => window.removeEventListener("blur", r)
+    );
+  }
+  isDown(e) {
+    return this.held.has(e);
+  }
+  /** Any of these keys is held. */
+  anyDown(...e) {
+    return e.some((n) => this.held.has(n));
+  }
+  /** Went down since the last `endStep`. */
+  pressed(e) {
+    return this.down.has(e);
+  }
+  /** Came up since the last `endStep`. */
+  released(e) {
+    return this.up.has(e);
+  }
+  /** -1, 0 or 1 from two sets of keys: `axis(['KeyA', 'ArrowLeft'], ['KeyD', 'ArrowRight'])`. */
+  axis(e, n) {
+    return (this.anyDown(...n) ? 1 : 0) - (this.anyDown(...e) ? 1 : 0);
+  }
+  /** Forgets this step's edges; held keys stay held. */
+  endStep() {
+    this.down.clear(), this.up.clear();
+  }
+  destroy() {
+    for (const e of this.cleanup.splice(0)) e();
+    this.held.clear(), this.endStep();
+  }
+}
+export {
+  h as Keyboard
+};
+//# sourceMappingURL=Keyboard.js.map

package/dist/input/Keyboard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Keyboard.js","sources":["../../src/input/Keyboard.ts"],"sourcesContent":["/**\n * Which keys are held, by `KeyboardEvent.code` (the physical key, so WASD stays WASD on any layout). `pressed` and\n * `released` report edges since the last `endStep`; call that once per simulation step so a tap shorter than a frame\n * is still seen by exactly one step.\n *\n * It only knows keys pressed **after** it was made: a key already held when it is created (the Enter that started a\n * level, held into it) is not down here until it is pressed again. A scene that makes its own keyboard in a field\n * therefore starts with every key up, which is usually what a new screen wants; share one keyboard across scenes when\n * a held key must carry over. Modifier keys are ordinary codes here (`ShiftLeft`); `Actions` reads chords from them.\n */\nexport class Keyboard {\n  private readonly held = new Set<string>();\n  private readonly down = new Set<string>();\n  private readonly up = new Set<string>();\n  private readonly cleanup: (() => void)[] = [];\n\n  constructor(target: Window | HTMLElement = window) {\n    const keydown = (e: Event) => {\n      const k = (e as KeyboardEvent).code;\n      if ((e as KeyboardEvent).repeat || this.held.has(k)) return;\n      this.held.add(k);\n      this.down.add(k);\n    };\n    const keyup = (e: Event) => {\n      const k = (e as KeyboardEvent).code;\n      if (!this.held.delete(k)) return;\n      this.up.add(k);\n    };\n    // a key held while the window loses focus never sends its keyup: let everything go\n    const blur = () => {\n      for (const k of this.held) this.up.add(k);\n      this.held.clear();\n    };\n    target.addEventListener('keydown', keydown);\n    target.addEventListener('keyup', keyup);\n    window.addEventListener('blur', blur);\n    this.cleanup.push(\n      () => target.removeEventListener('keydown', keydown),\n      () => target.removeEventListener('keyup', keyup),\n      () => window.removeEventListener('blur', blur),\n    );\n  }\n\n  isDown(code: string): boolean {\n    return this.held.has(code);\n  }\n\n  /** Any of these keys is held. */\n  anyDown(...codes: string[]): boolean {\n    return codes.some((c) => this.held.has(c));\n  }\n\n  /** Went down since the last `endStep`. */\n  pressed(code: string): boolean {\n    return this.down.has(code);\n  }\n\n  /** Came up since the last `endStep`. */\n  released(code: string): boolean {\n    return this.up.has(code);\n  }\n\n  /** -1, 0 or 1 from two sets of keys: `axis(['KeyA', 'ArrowLeft'], ['KeyD', 'ArrowRight'])`. */\n  axis(negative: string[], positive: string[]): number {\n    return (this.anyDown(...positive) ? 1 : 0) - (this.anyDown(...negative) ? 1 : 0);\n  }\n\n  /** Forgets this step's edges; held keys stay held. */\n  endStep(): void {\n    this.down.clear();\n    this.up.clear();\n  }\n\n  destroy(): void {\n    for (const fn of this.cleanup.splice(0)) fn();\n    this.held.clear();\n    this.endStep();\n  }\n}\n"],"names":["Keyboard","target","keydown","e","k","keyup","blur","code","codes","c","negative","positive","fn"],"mappings":"AAUO,MAAMA,EAAS;AAAA,EACH,2BAAW,IAAA;AAAA,EACX,2BAAW,IAAA;AAAA,EACX,yBAAS,IAAA;AAAA,EACT,UAA0B,CAAA;AAAA,EAE3C,YAAYC,IAA+B,QAAQ;AACjD,UAAMC,IAAU,CAACC,MAAa;AAC5B,YAAMC,IAAKD,EAAoB;AAC/B,MAAKA,EAAoB,UAAU,KAAK,KAAK,IAAIC,CAAC,MAClD,KAAK,KAAK,IAAIA,CAAC,GACf,KAAK,KAAK,IAAIA,CAAC;AAAA,IACjB,GACMC,IAAQ,CAACF,MAAa;AAC1B,YAAMC,IAAKD,EAAoB;AAC/B,MAAK,KAAK,KAAK,OAAOC,CAAC,KACvB,KAAK,GAAG,IAAIA,CAAC;AAAA,IACf,GAEME,IAAO,MAAM;AACjB,iBAAWF,KAAK,KAAK,KAAM,MAAK,GAAG,IAAIA,CAAC;AACxC,WAAK,KAAK,MAAA;AAAA,IACZ;AACA,IAAAH,EAAO,iBAAiB,WAAWC,CAAO,GAC1CD,EAAO,iBAAiB,SAASI,CAAK,GACtC,OAAO,iBAAiB,QAAQC,CAAI,GACpC,KAAK,QAAQ;AAAA,MACX,MAAML,EAAO,oBAAoB,WAAWC,CAAO;AAAA,MACnD,MAAMD,EAAO,oBAAoB,SAASI,CAAK;AAAA,MAC/C,MAAM,OAAO,oBAAoB,QAAQC,CAAI;AAAA,IAAA;AAAA,EAEjD;AAAA,EAEA,OAAOC,GAAuB;AAC5B,WAAO,KAAK,KAAK,IAAIA,CAAI;AAAA,EAC3B;AAAA;AAAA,EAGA,WAAWC,GAA0B;AACnC,WAAOA,EAAM,KAAK,CAACC,MAAM,KAAK,KAAK,IAAIA,CAAC,CAAC;AAAA,EAC3C;AAAA;AAAA,EAGA,QAAQF,GAAuB;AAC7B,WAAO,KAAK,KAAK,IAAIA,CAAI;AAAA,EAC3B;AAAA;AAAA,EAGA,SAASA,GAAuB;AAC9B,WAAO,KAAK,GAAG,IAAIA,CAAI;AAAA,EACzB;AAAA;AAAA,EAGA,KAAKG,GAAoBC,GAA4B;AACnD,YAAQ,KAAK,QAAQ,GAAGA,CAAQ,IAAI,IAAI,MAAM,KAAK,QAAQ,GAAGD,CAAQ,IAAI,IAAI;AAAA,EAChF;AAAA;AAAA,EAGA,UAAgB;AACd,SAAK,KAAK,MAAA,GACV,KAAK,GAAG,MAAA;AAAA,EACV;AAAA,EAEA,UAAgB;AACd,eAAWE,KAAM,KAAK,QAAQ,OAAO,CAAC,EAAG,CAAAA,EAAA;AACzC,SAAK,KAAK,MAAA,GACV,KAAK,QAAA;AAAA,EACP;AACF;"}

package/dist/input/Keymap.js

@@ -0,0 +1,171 @@
+class g {
+  binds;
+  defaults;
+  reserved;
+  fixed;
+  listeners = [];
+  /**
+   * `reserved`: keys never bound (default Escape, Enter, Tab; pass `undefined` for the default). `fixed`: inputs each
+   * action always has besides the player's keys (gamepad, touch, a reserved key), never saved or rebound.
+   */
+  constructor(t, s = ["Escape", "Enter", "Tab"], e = {}) {
+    this.defaults = { ...t }, this.reserved = new Set(s), this.fixed = { ...e }, this.binds = this.fresh();
+  }
+  fresh() {
+    const t = {};
+    for (const s of this.actions()) t[s] = this.defaults[s].filter((e) => !this.reserved.has(e));
+    return t;
+  }
+  /** Every action, in the order the defaults named them. */
+  actions() {
+    return Object.keys(this.defaults);
+  }
+  isReserved(t) {
+    return this.reserved.has(t);
+  }
+  /** The keys of one action; the first is the one a settings screen shows and edits. */
+  keysFor(t) {
+    return this.binds[t] ?? [];
+  }
+  /** The inputs an action always has besides the player's keys (the constructor's `fixed`). */
+  fixedFor(t) {
+    return this.fixed[t] ?? [];
+  }
+  /** Which action a key belongs to, or undefined. */
+  actionFor(t) {
+    for (const s of this.actions()) if (this.binds[s].includes(t)) return s;
+  }
+  /**
+   * Puts `code` first on `action`, taking it off whatever else held it; returns the actions that lost it (to tell the
+   * player). A reserved key is refused (returns null). An action stripped of its last key keeps none: it is unbound
+   * until something is put back on it.
+   */
+  bind(t, s) {
+    if (this.reserved.has(s) || !(t in this.binds)) return null;
+    const e = [];
+    for (const n of this.actions())
+      n === t || !this.binds[n].includes(s) || (this.binds[n] = this.binds[n].filter((a) => a !== s), e.push(n));
+    const h = this.binds[t].slice(1).filter((n) => n !== s);
+    return this.binds[t] = [s, ...h], this.changed(), e;
+  }
+  /** Takes every key off `action`. */
+  unbind(t) {
+    this.binds[t]?.length && (this.binds[t] = [], this.changed());
+  }
+  /** Every action back on its defaults. */
+  reset() {
+    this.binds = this.fresh(), this.changed();
+  }
+  /** A plain object to store wherever the game keeps its settings. */
+  toJSON() {
+    const t = {};
+    for (const s of this.actions()) t[s] = [...this.binds[s]];
+    return t;
+  }
+  /**
+   * A saved set laid over this build's defaults. Only actions this build knows are read, so an old save cannot leave
+   * a key bound to nothing; an action newer than the save keeps its defaults only where no saved action holds that key
+   * (the saved one is what the player chose). Anything malformed is ignored.
+   */
+  load(t) {
+    this.binds = u(this.defaults, t, this.reserved), this.changed();
+  }
+  /**
+   * Hands the bindings to an `Actions`: each action's keys, then its fixed inputs, then its `extra` ones. Only the
+   * keymap's actions are bound, so the `Actions` may hold more (menu actions alongside the rebindable ones, each on
+   * its own fixed inputs); those are left as they are. Fixed and extra inputs are the game's, so neither the reserved
+   * keys nor one-key-one-action apply to them.
+   */
+  applyTo(t, s = {}) {
+    for (const e of this.actions()) t.bind(e, [...this.binds[e], ...this.fixed[e] ?? [], ...s[e] ?? []]);
+  }
+  /** Called after every change; returns a function that stops it. */
+  onChange(t) {
+    return this.listeners.push(t), () => {
+      const s = this.listeners.indexOf(t);
+      s >= 0 && this.listeners.splice(s, 1);
+    };
+  }
+  changed() {
+    for (const t of [...this.listeners]) t();
+  }
+}
+function u(i, t, s = /* @__PURE__ */ new Set()) {
+  const e = Object.keys(i), h = {}, n = /* @__PURE__ */ new Set(), a = t && typeof t == "object" ? t : {};
+  for (const r of e) {
+    const o = a[r];
+    Array.isArray(o) && o.every((f) => typeof f == "string") ? (h[r] = [...new Set(o)].filter((f) => !s.has(f)), n.add(r)) : h[r] = i[r].filter((f) => !s.has(f));
+  }
+  const l = /* @__PURE__ */ new Map();
+  for (const r of e)
+    n.has(r) && (h[r] = h[r].filter((o) => l.has(o) ? !1 : (l.set(o, r), !0)));
+  for (const r of e) n.has(r) || (h[r] = h[r].filter((o) => !l.has(o)));
+  return h;
+}
+function b(i) {
+  const t = () => {
+    try {
+      return typeof localStorage > "u" ? null : localStorage;
+    } catch {
+      return null;
+    }
+  };
+  return {
+    read() {
+      try {
+        const s = t()?.getItem(i);
+        return s ? JSON.parse(s) : null;
+      } catch {
+        return null;
+      }
+    },
+    write(s) {
+      try {
+        t()?.setItem(i, JSON.stringify(s));
+      } catch {
+      }
+    },
+    clear() {
+      try {
+        t()?.removeItem(i);
+      } catch {
+      }
+    }
+  };
+}
+const c = {
+  Space: "Space",
+  ShiftLeft: "Shift",
+  ShiftRight: "Right Shift",
+  ControlLeft: "Ctrl",
+  ControlRight: "Right Ctrl",
+  AltLeft: "Alt",
+  AltRight: "Right Alt",
+  ArrowUp: "Up",
+  ArrowDown: "Down",
+  ArrowLeft: "Left",
+  ArrowRight: "Right",
+  Backquote: "`",
+  Minus: "-",
+  Equal: "=",
+  Semicolon: ";",
+  Quote: "'",
+  Comma: ",",
+  Period: ".",
+  Slash: "/",
+  Backslash: "\\",
+  BracketLeft: "[",
+  BracketRight: "]"
+};
+function d(i, t = {}) {
+  if (i.length > 1 && i.includes("+")) return i.split("+").map((e) => d(e, t)).join("+");
+  const s = t[i];
+  return s !== void 0 ? s : i.startsWith("Key") ? i.slice(3) : i.startsWith("Digit") ? i.slice(5) : i.startsWith("Numpad") ? `Num ${i.slice(6)}` : c[i] ?? i;
+}
+export {
+  g as Keymap,
+  d as keyLabel,
+  b as keymapStorage,
+  u as mergeKeymap
+};
+//# sourceMappingURL=Keymap.js.map

package/dist/input/Keymap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Keymap.js","sources":["../../src/input/Keymap.ts"],"sourcesContent":["import type { Actions } from './Actions';\n\n/**\n * Which keys each action sits on, as the player has rebound them: one table the input, the key hints on screen and\n * a settings screen all read. A binding is a `KeyboardEvent.code` (`KeyW`, `Digit1`), so it means the same physical\n * key on every layout. Each action keeps a list (W and ArrowUp, 1 and Q); a settings screen edits the **first** and\n * leaves the alternates alone.\n *\n * Two rules: one key serves one action at a time (a key bound twice would fire both, and the player could not tell\n * which they meant), and reserved keys (Escape, Enter, Tab by default: the interface's own) are never taken.\n *\n * Inputs the player cannot rebind — the gamepad's, a touch button, a reserved key an action should still answer to\n * (Escape also pausing) — are the keymap's **fixed** inputs: given once to the constructor, laid after the player's\n * keys by `applyTo`, and untouched by either rule above.\n *\n * ```ts\n * const keys = new Keymap({ jump: ['Space'], left: ['KeyA', 'ArrowLeft'], pause: ['KeyP'] }, undefined, { jump: ['pad:a'], pause: ['Escape'] });\n * keys.load(keymapStorage('my-game.keys').read());\n * keys.onChange(() => { keys.applyTo(actions); storage.write(keys.toJSON()); });\n * keys.bind('pause', 'KeyA'); // 'left' keeps only ArrowLeft\n * ```\n */\nexport class Keymap<A extends string> {\n  private binds: Record<A, string[]>;\n  private readonly defaults: Record<A, readonly string[]>;\n  private readonly reserved: ReadonlySet<string>;\n  private readonly fixed: Partial<Record<A, readonly string[]>>;\n  private readonly listeners: (() => void)[] = [];\n\n  /**\n   * `reserved`: keys never bound (default Escape, Enter, Tab; pass `undefined` for the default). `fixed`: inputs each\n   * action always has besides the player's keys (gamepad, touch, a reserved key), never saved or rebound.\n   */\n  constructor(\n    defaults: Readonly<Record<A, readonly string[]>>,\n    reserved: Iterable<string> = ['Escape', 'Enter', 'Tab'],\n    fixed: Partial<Record<A, readonly string[]>> = {},\n  ) {\n    this.defaults = { ...defaults };\n    this.reserved = new Set(reserved);\n    this.fixed = { ...fixed };\n    this.binds = this.fresh();\n  }\n\n  private fresh(): Record<A, string[]> {\n    const out = {} as Record<A, string[]>;\n    for (const id of this.actions()) out[id] = this.defaults[id].filter((c) => !this.reserved.has(c));\n    return out;\n  }\n\n  /** Every action, in the order the defaults named them. */\n  actions(): A[] {\n    return Object.keys(this.defaults) as A[];\n  }\n\n  isReserved(code: string): boolean {\n    return this.reserved.has(code);\n  }\n\n  /** The keys of one action; the first is the one a settings screen shows and edits. */\n  keysFor(action: A): readonly string[] {\n    return this.binds[action] ?? [];\n  }\n\n  /** The inputs an action always has besides the player's keys (the constructor's `fixed`). */\n  fixedFor(action: A): readonly string[] {\n    return this.fixed[action] ?? [];\n  }\n\n  /** Which action a key belongs to, or undefined. */\n  actionFor(code: string): A | undefined {\n    for (const id of this.actions()) if (this.binds[id].includes(code)) return id;\n    return undefined;\n  }\n\n  /**\n   * Puts `code` first on `action`, taking it off whatever else held it; returns the actions that lost it (to tell the\n   * player). A reserved key is refused (returns null). An action stripped of its last key keeps none: it is unbound\n   * until something is put back on it.\n   */\n  bind(action: A, code: string): A[] | null {\n    if (this.reserved.has(code) || !(action in this.binds)) return null;\n    const lost: A[] = [];\n    for (const id of this.actions()) {\n      if (id === action || !this.binds[id].includes(code)) continue;\n      this.binds[id] = this.binds[id].filter((c) => c !== code);\n      lost.push(id);\n    }\n    const rest = this.binds[action].slice(1).filter((c) => c !== code);\n    this.binds[action] = [code, ...rest];\n    this.changed();\n    return lost;\n  }\n\n  /** Takes every key off `action`. */\n  unbind(action: A): void {\n    if (!this.binds[action]?.length) return;\n    this.binds[action] = [];\n    this.changed();\n  }\n\n  /** Every action back on its defaults. */\n  reset(): void {\n    this.binds = this.fresh();\n    this.changed();\n  }\n\n  /** A plain object to store wherever the game keeps its settings. */\n  toJSON(): Record<A, string[]> {\n    const out = {} as Record<A, string[]>;\n    for (const id of this.actions()) out[id] = [...this.binds[id]];\n    return out;\n  }\n\n  /**\n   * A saved set laid over this build's defaults. Only actions this build knows are read, so an old save cannot leave\n   * a key bound to nothing; an action newer than the save keeps its defaults only where no saved action holds that key\n   * (the saved one is what the player chose). Anything malformed is ignored.\n   */\n  load(saved: unknown): void {\n    this.binds = mergeKeymap(this.defaults, saved, this.reserved);\n    this.changed();\n  }\n\n  /**\n   * Hands the bindings to an `Actions`: each action's keys, then its fixed inputs, then its `extra` ones. Only the\n   * keymap's actions are bound, so the `Actions` may hold more (menu actions alongside the rebindable ones, each on\n   * its own fixed inputs); those are left as they are. Fixed and extra inputs are the game's, so neither the reserved\n   * keys nor one-key-one-action apply to them.\n   */\n  applyTo<B extends string>(actions: Actions<A | B>, extra: Partial<Record<A, readonly string[]>> = {}): void {\n    for (const id of this.actions()) actions.bind(id, [...this.binds[id], ...(this.fixed[id] ?? []), ...(extra[id] ?? [])]);\n  }\n\n  /** Called after every change; returns a function that stops it. */\n  onChange(fn: () => void): () => void {\n    this.listeners.push(fn);\n    return () => {\n      const i = this.listeners.indexOf(fn);\n      if (i >= 0) this.listeners.splice(i, 1);\n    };\n  }\n\n  private changed(): void {\n    for (const fn of [...this.listeners]) fn();\n  }\n}\n\n/** `saved` laid over `defaults` by `Keymap.load`'s rules, as a fresh object. */\nexport function mergeKeymap<A extends string>(\n  defaults: Readonly<Record<A, readonly string[]>>,\n  saved: unknown,\n  reserved: ReadonlySet<string> = new Set(),\n): Record<A, string[]> {\n  const ids = Object.keys(defaults) as A[];\n  const out = {} as Record<A, string[]>;\n  const kept = new Set<A>();\n  const s: Partial<Record<A, unknown>> = saved && typeof saved === 'object' ? (saved as Partial<Record<A, unknown>>) : {};\n  for (const id of ids) {\n    const codes = s[id];\n    if (Array.isArray(codes) && codes.every((c) => typeof c === 'string')) {\n      // a saved empty list is a choice too: the player unbound it\n      out[id] = [...new Set(codes as string[])].filter((c) => !reserved.has(c));\n      kept.add(id);\n    } else out[id] = defaults[id].filter((c) => !reserved.has(c));\n  }\n  // one key one action, even in a hand-edited save: the first action listed keeps it\n  const owner = new Map<string, A>();\n  for (const id of ids)\n    if (kept.has(id))\n      out[id] = out[id].filter((c) => {\n        if (owner.has(c)) return false;\n        owner.set(c, id);\n        return true;\n      });\n  for (const id of ids) if (!kept.has(id)) out[id] = out[id].filter((c) => !owner.has(c));\n  return out;\n}\n\n/** A place to keep a keymap in the browser, under a key the game names; every failure falls back quietly. */\nexport function keymapStorage(key: string): { read(): unknown; write(binds: object): void; clear(): void } {\n  const store = (): Storage | null => {\n    try {\n      return typeof localStorage === 'undefined' ? null : localStorage;\n    } catch {\n      return null;\n    }\n  };\n  return {\n    read() {\n      try {\n        const raw = store()?.getItem(key);\n        return raw ? (JSON.parse(raw) as unknown) : null;\n      } catch {\n        // unreadable or blocked storage: the defaults are a complete set on their own\n        return null;\n      }\n    },\n    write(binds) {\n      try {\n        store()?.setItem(key, JSON.stringify(binds));\n      } catch {\n        // storage unavailable: the change lasts until the page is reloaded\n      }\n    },\n    clear() {\n      try {\n        store()?.removeItem(key);\n      } catch {\n        // nothing to clear\n      }\n    },\n  };\n}\n\nconst KEY_NAMES: Readonly<Record<string, string>> = {\n  Space: 'Space',\n  ShiftLeft: 'Shift',\n  ShiftRight: 'Right Shift',\n  ControlLeft: 'Ctrl',\n  ControlRight: 'Right Ctrl',\n  AltLeft: 'Alt',\n  AltRight: 'Right Alt',\n  ArrowUp: 'Up',\n  ArrowDown: 'Down',\n  ArrowLeft: 'Left',\n  ArrowRight: 'Right',\n  Backquote: '`',\n  Minus: '-',\n  Equal: '=',\n  Semicolon: ';',\n  Quote: \"'\",\n  Comma: ',',\n  Period: '.',\n  Slash: '/',\n  Backslash: '\\\\',\n  BracketLeft: '[',\n  BracketRight: ']',\n};\n\n/**\n * How a key code reads on screen: \"KeyW\" is W, \"Digit1\" is 1, \"Numpad3\" is \"Num 3\", a chord \"Shift+Tab\" each part in\n * turn. `names` overrides any code or modifier (a game's own language for the arrows and modifiers).\n */\nexport function keyLabel(code: string, names: Readonly<Record<string, string>> = {}): string {\n  if (code.length > 1 && code.includes('+')) return code.split('+').map((part) => keyLabel(part, names)).join('+');\n  const own = names[code];\n  if (own !== undefined) return own;\n  if (code.startsWith('Key')) return code.slice(3);\n  if (code.startsWith('Digit')) return code.slice(5);\n  if (code.startsWith('Numpad')) return `Num ${code.slice(6)}`;\n  return KEY_NAMES[code] ?? code;\n}\n"],"names":["Keymap","defaults","reserved","fixed","out","id","c","code","action","lost","rest","saved","mergeKeymap","actions","extra","fn","i","ids","kept","s","codes","owner","keymapStorage","key","store","raw","binds","KEY_NAMES","keyLabel","names","part","own"],"mappings":"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"}

package/dist/input/TargetLock.js

@@ -0,0 +1,73 @@
+const _ = 220, g = 300, d = 50 * Math.PI / 180;
+function p(e, n) {
+  let t = (e - n) % (Math.PI * 2);
+  return t > Math.PI && (t -= Math.PI * 2), t < -Math.PI && (t += Math.PI * 2), t;
+}
+function y(e, n, t, i = 220, s = d) {
+  if (Math.hypot(n.x, n.y) < 1e-6) return null;
+  const h = Math.atan2(n.y, n.x);
+  let l = null, u = 1 / 0;
+  for (const a of t) {
+    const o = Math.hypot(a.x - e.x, a.y - e.y);
+    if (o > i) continue;
+    const r = o < 1 ? 0 : Math.abs(p(Math.atan2(a.y - e.y, a.x - e.x), h));
+    if (r > s) continue;
+    const f = r / s + 0.35 * o / i;
+    f < u && (u = f, l = a.id);
+  }
+  return l;
+}
+function K(e, n, t = 220) {
+  let i = null, s = 1 / 0;
+  for (const c of n) {
+    const h = Math.hypot(c.x - e.x, c.y - e.y);
+    h > t || (h < s || h === s && i !== null && c.id < i) && (s = h, i = c.id);
+  }
+  return i;
+}
+function R(e, n, t, i = 300) {
+  if (n === null) return null;
+  const s = t.find((c) => c.id === n);
+  return !s || Math.hypot(s.x - e.x, s.y - e.y) > i ? null : s;
+}
+class b {
+  constructor(n, t = {}) {
+    this.bodies = n, this.pickRange = t.pickRange ?? 220, this.keepRange = t.keepRange ?? 300, this.cone = t.cone ?? d;
+  }
+  bodies;
+  id = null;
+  pickRange;
+  keepRange;
+  cone;
+  /** The id held, without checking it still stands (use `current` for that). */
+  get locked() {
+    return this.id;
+  }
+  /** A drag in `dir` from `from`: locks what it points at; pointing at nothing keeps the old lock. */
+  pick(n, t) {
+    const i = y(n, t, this.bodies(), this.pickRange, this.cone);
+    return i !== null && (this.id = i), this.id;
+  }
+  /** Locks the nearest body, every call, whatever was held. */
+  pickNearest(n) {
+    return this.id = K(n, this.bodies(), this.pickRange), this.id;
+  }
+  /** The held body if it still holds; a lock that no longer does is dropped. */
+  current(n) {
+    const t = R(n, this.id, this.bodies(), this.keepRange);
+    return t || (this.id = null), t;
+  }
+  clear() {
+    this.id = null;
+  }
+}
+export {
+  g as LOCK_KEEP_RANGE,
+  d as LOCK_PICK_CONE,
+  _ as LOCK_PICK_RANGE,
+  b as TargetLock,
+  R as keptTarget,
+  K as nearestTarget,
+  y as pickTarget
+};
+//# sourceMappingURL=TargetLock.js.map

package/dist/input/TargetLock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TargetLock.js","sources":["../../src/input/TargetLock.ts"],"sourcesContent":["/**\n * Picking and holding a target on a touch screen, kept pure so it can be tested. Dragging an attack button points:\n * the body lying closest to that direction is picked (and of two about as close to it, the nearer). A target button\n * picks the nearest. The lock then holds — every attack, skill and the facing goes at it, even while a stick walks\n * the body elsewhere — until that body is gone or leaves `keepRange`; a later drag that points at nothing keeps it.\n *\n * Bodies come from a callback as `{ id, x, y }`: the game decides what may be locked (monsters, a duel's opponent).\n */\n\nexport interface LockBody {\n  id: number;\n  x: number;\n  y: number;\n}\n\ntype Point = { x: number; y: number };\n\nexport const LOCK_PICK_RANGE = 220;\nexport const LOCK_KEEP_RANGE = 300;\n/** Widest angle off the drag a body may stand and still be picked: 50° each side. */\nexport const LOCK_PICK_CONE = (50 * Math.PI) / 180;\n\n/** The signed difference a − b, wrapped into −π…π. */\nfunction angleDiff(a: number, b: number): number {\n  let d = (a - b) % (Math.PI * 2);\n  if (d > Math.PI) d -= Math.PI * 2;\n  if (d < -Math.PI) d += Math.PI * 2;\n  return d;\n}\n\n/**\n * The body a drag in direction `dir` (any length > 0) picks from `from`, or null. Scored by how far off the drag's\n * line it stands, with distance as a lighter second weight, so a far body dead ahead beats a near one off to the side.\n */\nexport function pickTarget(from: Point, dir: Point, bodies: readonly LockBody[], range = LOCK_PICK_RANGE, cone = LOCK_PICK_CONE): number | null {\n  const len = Math.hypot(dir.x, dir.y);\n  if (len < 1e-6) return null;\n  const heading = Math.atan2(dir.y, dir.x);\n  let best: number | null = null;\n  let bestScore = Infinity;\n  for (const b of bodies) {\n    const d = Math.hypot(b.x - from.x, b.y - from.y);\n    if (d > range) continue;\n    // a body right on top of the player is in every direction\n    const off = d < 1 ? 0 : Math.abs(angleDiff(Math.atan2(b.y - from.y, b.x - from.x), heading));\n    if (off > cone) continue;\n    const score = off / cone + (0.35 * d) / range;\n    if (score < bestScore) {\n      bestScore = score;\n      best = b.id;\n    }\n  }\n  return best;\n}\n\n/** The nearest body within `range` (ties to the lower id, so two clients pick alike), or null. */\nexport function nearestTarget(from: Point, bodies: readonly LockBody[], range = LOCK_PICK_RANGE): number | null {\n  let best: number | null = null;\n  let bestD = Infinity;\n  for (const b of bodies) {\n    const d = Math.hypot(b.x - from.x, b.y - from.y);\n    if (d > range) continue;\n    if (d < bestD || (d === bestD && best !== null && b.id < best)) {\n      bestD = d;\n      best = b.id;\n    }\n  }\n  return best;\n}\n\n/** The locked body while the lock still holds (present, within `range`), else null. */\nexport function keptTarget<T extends LockBody>(from: Point, locked: number | null, bodies: readonly T[], range = LOCK_KEEP_RANGE): T | null {\n  if (locked === null) return null;\n  const b = bodies.find((c) => c.id === locked);\n  if (!b || Math.hypot(b.x - from.x, b.y - from.y) > range) return null;\n  return b;\n}\n\nexport interface TargetLockOptions {\n  pickRange?: number;\n  keepRange?: number;\n  /** Half-angle (radians) a drag picks within. */\n  cone?: number;\n}\n\n/** The lock as state: which body is held, picked by a drag or the nearest, let go when it is gone or too far. */\nexport class TargetLock<T extends LockBody = LockBody> {\n  private id: number | null = null;\n  private readonly pickRange: number;\n  private readonly keepRange: number;\n  private readonly cone: number;\n\n  constructor(\n    private readonly bodies: () => readonly T[],\n    options: TargetLockOptions = {},\n  ) {\n    this.pickRange = options.pickRange ?? LOCK_PICK_RANGE;\n    this.keepRange = options.keepRange ?? LOCK_KEEP_RANGE;\n    this.cone = options.cone ?? LOCK_PICK_CONE;\n  }\n\n  /** The id held, without checking it still stands (use `current` for that). */\n  get locked(): number | null {\n    return this.id;\n  }\n\n  /** A drag in `dir` from `from`: locks what it points at; pointing at nothing keeps the old lock. */\n  pick(from: Point, dir: Point): number | null {\n    const id = pickTarget(from, dir, this.bodies(), this.pickRange, this.cone);\n    if (id !== null) this.id = id;\n    return this.id;\n  }\n\n  /** Locks the nearest body, every call, whatever was held. */\n  pickNearest(from: Point): number | null {\n    this.id = nearestTarget(from, this.bodies(), this.pickRange);\n    return this.id;\n  }\n\n  /** The held body if it still holds; a lock that no longer does is dropped. */\n  current(from: Point): T | null {\n    const b = keptTarget(from, this.id, this.bodies(), this.keepRange);\n    if (!b) this.id = null;\n    return b;\n  }\n\n  clear(): void {\n    this.id = null;\n  }\n}\n"],"names":["LOCK_PICK_RANGE","LOCK_KEEP_RANGE","LOCK_PICK_CONE","angleDiff","a","b","d","pickTarget","from","dir","bodies","range","cone","heading","best","bestScore","off","score","nearestTarget","bestD","keptTarget","locked","TargetLock","options","id"],"mappings":"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"}

package/dist/input/aimAxis.js

@@ -0,0 +1,8 @@
+function h(t) {
+  const s = Math.cos(t), a = Math.sin(t), n = Math.sin(Math.PI / 8);
+  return { dx: Math.abs(s) > n ? Math.sign(s) : 0, dy: Math.abs(a) > n ? Math.sign(a) : 0 };
+}
+export {
+  h as aimAxis
+};
+//# sourceMappingURL=aimAxis.js.map

package/dist/input/aimAxis.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aimAxis.js","sources":["../../src/input/aimAxis.ts"],"sourcesContent":["/**\n * An aim turned into the eight-way axis the keyboard makes (each part -1, 0 or 1; `stepMover` scales a diagonal),\n * so a step sent along it is one a key could have sent. A part counts once the aim leans past 22.5° towards it.\n */\nexport function aimAxis(aim: number): { dx: number; dy: number } {\n  const c = Math.cos(aim);\n  const s = Math.sin(aim);\n  const lean = Math.sin(Math.PI / 8);\n  return { dx: Math.abs(c) > lean ? Math.sign(c) : 0, dy: Math.abs(s) > lean ? Math.sign(s) : 0 };\n}\n"],"names":["aimAxis","aim","c","s","lean"],"mappings":"AAIO,SAASA,EAAQC,GAAyC;AAC/D,QAAMC,IAAI,KAAK,IAAID,CAAG,GAChBE,IAAI,KAAK,IAAIF,CAAG,GAChBG,IAAO,KAAK,IAAI,KAAK,KAAK,CAAC;AACjC,SAAO,EAAE,IAAI,KAAK,IAAIF,CAAC,IAAIE,IAAO,KAAK,KAAKF,CAAC,IAAI,GAAG,IAAI,KAAK,IAAIC,CAAC,IAAIC,IAAO,KAAK,KAAKD,CAAC,IAAI,EAAA;AAC9F;"}