feat: implement Monocle-style input system and take newer input for controls

Author: CoolSpring8

docs/tech-checklist.md

@@ -38,7 +38,7 @@ Legend:
 | Grounded Ultras | WORKS | 390 burst observed from 325 * 1.2 |
 | Grounded Ultra Cancel | EXCLUDED | Requires dash interruption sources not present |
 | Delayed Ultra | WORKS | Landing after a down-diagonal dash still applies the ultra slide conversion |
-| Demodash | EXCLUDED | No dedicated crouch-dash/manual-demo input path yet, and the exact solution is not in the local reference file |
+| Demodash | EXCLUDED | Input system implements Monocle-style directional handling but demo-specific startup behavior doesn't emerge |
 | Demohyper | EXCLUDED | Depends on the excluded demo input path |
 | Up Diagonal Demo | EXCLUDED | Depends on the excluded demo input path |
 | Wallbounce | WORKS | Updash + wall jump yields super wall jump values (170/-160) |

src/GameScene.ts

@@ -4,6 +4,7 @@ import { EntityWorld, spikeTriangles } from "./entities/EntityWorld";
 import { RefillEntity, RefillType } from "./entities/types";
 import { TILE_JUMP_THROUGH, tileAt } from "./grid";
 import { parseLevel } from "./level";
+import { PlayerControls } from "./input/PlayerControls";
 import { addFloat, approach, maxFloat, stepTimer, subFloat, toFloat } from "./player/math";
 import { Player } from "./player/Player";
 import { InputState, PlayerEffect } from "./player/types";
@@ -48,8 +49,7 @@ export class GameScene extends Phaser.Scene {
   private tileDepths!: Int32Array;
 
   private keys!: Record<string, Phaser.Input.Keyboard.Key>;
-  private pendingJumpEdges: Array<"down" | "up"> = [];
-  private pendingDashPresses = 0;
+  private controls!: PlayerControls;
 
   private accumulator = 0;
   private readonly fixedDt = toFloat(1 / 60);
@@ -116,15 +116,12 @@ export class GameScene extends Phaser.Scene {
       right: kb.addKey(Phaser.Input.Keyboard.KeyCodes.RIGHT),
       up: kb.addKey(Phaser.Input.Keyboard.KeyCodes.UP),
       down: kb.addKey(Phaser.Input.Keyboard.KeyCodes.DOWN),
-      a: kb.addKey(Phaser.Input.Keyboard.KeyCodes.A),
-      d: kb.addKey(Phaser.Input.Keyboard.KeyCodes.D),
-      w: kb.addKey(Phaser.Input.Keyboard.KeyCodes.W),
-      s: kb.addKey(Phaser.Input.Keyboard.KeyCodes.S),
       grab: kb.addKey(Phaser.Input.Keyboard.KeyCodes.Z),
       dash: kb.addKey(Phaser.Input.Keyboard.KeyCodes.X),
       jump: kb.addKey(Phaser.Input.Keyboard.KeyCodes.C),
       restart: kb.addKey(Phaser.Input.Keyboard.KeyCodes.R),
     };
+    this.controls = new PlayerControls();
     this.keys.jump.on("down", this.onJumpDown, this);
     this.keys.jump.on("up", this.onJumpUp, this);
     this.keys.dash.on("down", this.onDashDown, this);
@@ -144,7 +141,7 @@ export class GameScene extends Phaser.Scene {
       .text(
         VIEWPORT.width - 8,
         VIEWPORT.height - 8,
-        "Move: arrows / WASD\nC jump  X dash  Z grab  R reset",
+        "Move: arrow keys\nC jump  X dash  Z grab  R reset",
         {
           fontFamily: "monospace",
           fontSize: "9px",
@@ -166,7 +163,7 @@ export class GameScene extends Phaser.Scene {
       this.player.hardRespawn(this.spawnX, this.spawnY);
       this.world.resetTransientState();
       this.syncRefillViews();
-      this.clearInputEdgeQueues();
+      this.controls.clearTransientState();
       this.forceCameraSnap();
       this.cameras.main.fadeIn(80, 10, 10, 20);
       this.accumulator = 0;
@@ -205,7 +202,7 @@ export class GameScene extends Phaser.Scene {
         this.player.hardRespawn(this.spawnX, this.spawnY);
         this.world.resetTransientState();
         this.syncRefillViews();
-        this.clearInputEdgeQueues();
+        this.controls.clearTransientState();
         this.forceCameraSnap();
         if (spiked) {
           this.cameras.main.flash(180, 0, 0, 0, false);
@@ -297,7 +294,7 @@ export class GameScene extends Phaser.Scene {
       this.keys.jump.off("up", this.onJumpUp, this);
       this.keys.dash.off("down", this.onDashDown, this);
     }
-    this.clearInputEdgeQueues();
+    this.controls?.reset();
     this.playerView?.destroy();
     this.refillEmitter?.destroy();
     for (const refill of this.refills) {
@@ -308,51 +305,29 @@ export class GameScene extends Phaser.Scene {
   }
 
   private gatherStepInput(): InputState {
-    let x = 0;
-    let y = 0;
-    if (this.keys.left.isDown || this.keys.a.isDown) x -= 1;
-    if (this.keys.right.isDown || this.keys.d.isDown) x += 1;
-    if (this.keys.up.isDown || this.keys.w.isDown) y -= 1;
-    if (this.keys.down.isDown || this.keys.s.isDown) y += 1;
-
-    const jump = this.keys.jump.isDown;
-    const jumpEdge = this.pendingJumpEdges.shift();
-    const jumpPressed = jumpEdge === "down";
-    const jumpReleased = jumpEdge === "up";
-    const dash = this.keys.dash.isDown;
-    const dashPressed = this.pendingDashPresses > 0;
-    if (dashPressed) this.pendingDashPresses--;
-    const grab = this.keys.grab.isDown;
-
-    return {
-      x,
-      y,
-      jump,
-      jumpPressed,
-      jumpReleased,
-      dash,
-      dashPressed,
-      grab,
-    };
+    this.controls.setCheck("leftArrow", this.keys.left.isDown);
+    this.controls.setCheck("rightArrow", this.keys.right.isDown);
+    this.controls.setCheck("upArrow", this.keys.up.isDown);
+    this.controls.setCheck("downArrow", this.keys.down.isDown);
+    this.controls.setCheck("jump", this.keys.jump.isDown);
+    this.controls.setCheck("dash", this.keys.dash.isDown);
+    this.controls.setCheck("grab", this.keys.grab.isDown);
+
+    return this.controls.update(this.fixedDt);
   }
 
   private onJumpDown(event: KeyboardEvent): void {
     if (event.repeat) return;
-    this.pendingJumpEdges.push("down");
+    this.controls.queuePress("jump");
   }
 
   private onJumpUp(): void {
-    this.pendingJumpEdges.push("up");
+    this.controls.queueRelease("jump");
   }
 
   private onDashDown(event: KeyboardEvent): void {
     if (event.repeat) return;
-    this.pendingDashPresses++;
-  }
-
-  private clearInputEdgeQueues(): void {
-    this.pendingJumpEdges.length = 0;
-    this.pendingDashPresses = 0;
+    this.controls.queuePress("dash");
   }
 
   private updateCamera(snapshot: ReturnType<Player["getSnapshot"]>, dt: number): void {

src/input/ButtonBank.ts

@@ -0,0 +1,102 @@
+export interface ButtonState {
+  check: boolean;
+  pressed: boolean;
+  released: boolean;
+}
+
+interface ButtonTracker {
+  check: boolean;
+  pressedQueue: number;
+  releasedQueue: number;
+}
+
+const EMPTY_BUTTON_STATE: ButtonState = {
+  check: false,
+  pressed: false,
+  released: false,
+};
+
+export class ButtonBank {
+  private readonly trackers = new Map<string, ButtonTracker>();
+  private readonly stepStates = new Map<string, ButtonState>();
+
+  constructor(names: readonly string[] = []) {
+    for (const name of names) {
+      this.register(name);
+    }
+  }
+
+  register(name: string): void {
+    if (this.trackers.has(name)) return;
+
+    this.trackers.set(name, {
+      check: false,
+      pressedQueue: 0,
+      releasedQueue: 0,
+    });
+    this.stepStates.set(name, EMPTY_BUTTON_STATE);
+  }
+
+  setCheck(name: string, value: boolean): void {
+    this.ensure(name).check = value;
+  }
+
+  queuePress(name: string): void {
+    this.ensure(name).pressedQueue++;
+  }
+
+  queueRelease(name: string): void {
+    this.ensure(name).releasedQueue++;
+  }
+
+  beginStep(): void {
+    for (const [name, tracker] of this.trackers) {
+      const pressed = tracker.pressedQueue > 0;
+      const released = tracker.releasedQueue > 0;
+      if (pressed) tracker.pressedQueue--;
+      if (released) tracker.releasedQueue--;
+
+      this.stepStates.set(name, {
+        check: tracker.check,
+        pressed,
+        released,
+      });
+    }
+  }
+
+  get(name: string): ButtonState {
+    return this.stepStates.get(name) ?? EMPTY_BUTTON_STATE;
+  }
+
+  clearQueues(): void {
+    for (const tracker of this.trackers.values()) {
+      tracker.pressedQueue = 0;
+      tracker.releasedQueue = 0;
+    }
+
+    for (const [name, tracker] of this.trackers) {
+      this.stepStates.set(name, {
+        check: tracker.check,
+        pressed: false,
+        released: false,
+      });
+    }
+  }
+
+  reset(): void {
+    for (const tracker of this.trackers.values()) {
+      tracker.check = false;
+      tracker.pressedQueue = 0;
+      tracker.releasedQueue = 0;
+    }
+
+    for (const name of this.trackers.keys()) {
+      this.stepStates.set(name, EMPTY_BUTTON_STATE);
+    }
+  }
+
+  private ensure(name: string): ButtonTracker {
+    this.register(name);
+    return this.trackers.get(name)!;
+  }
+}

src/input/PlayerControls.ts

@@ -0,0 +1,108 @@
+import { ButtonBank } from "./ButtonBank";
+import { VirtualButton } from "./VirtualButton";
+import { VirtualIntegerAxis } from "./VirtualIntegerAxis";
+import { VirtualJoystick } from "./VirtualJoystick";
+import { AxisButtonsNode, ButtonBindingNode, JoystickButtonsNode } from "./nodes";
+import { OverlapBehavior } from "./VirtualInput";
+import type { InputState } from "../player/types";
+
+export type PlayerBinding =
+  | "leftArrow"
+  | "rightArrow"
+  | "upArrow"
+  | "downArrow"
+  | "grab"
+  | "dash"
+  | "jump";
+
+const PLAYER_BINDINGS: readonly PlayerBinding[] = [
+  "leftArrow",
+  "rightArrow",
+  "upArrow",
+  "downArrow",
+  "grab",
+  "dash",
+  "jump",
+];
+
+export class PlayerControls {
+  private readonly bank = new ButtonBank(PLAYER_BINDINGS);
+
+  private readonly moveX = new VirtualIntegerAxis(
+    new AxisButtonsNode(this.bank, OverlapBehavior.TakeNewer, "leftArrow", "rightArrow"),
+  );
+
+  private readonly moveY = new VirtualIntegerAxis(
+    new AxisButtonsNode(this.bank, OverlapBehavior.TakeNewer, "upArrow", "downArrow"),
+  );
+
+  private readonly aim = new VirtualJoystick(
+    false,
+    new JoystickButtonsNode(
+      this.bank,
+      OverlapBehavior.TakeNewer,
+      "leftArrow",
+      "rightArrow",
+      "upArrow",
+      "downArrow",
+    ),
+  );
+
+  private readonly jump = new VirtualButton(0, new ButtonBindingNode(this.bank, "jump"));
+  private readonly dash = new VirtualButton(0, new ButtonBindingNode(this.bank, "dash"));
+  private readonly grab = new VirtualButton(0, new ButtonBindingNode(this.bank, "grab"));
+
+  setCheck(binding: PlayerBinding, value: boolean): void {
+    this.bank.setCheck(binding, value);
+  }
+
+  queuePress(binding: PlayerBinding): void {
+    this.bank.queuePress(binding);
+  }
+
+  queueRelease(binding: PlayerBinding): void {
+    this.bank.queueRelease(binding);
+  }
+
+  update(dt: number): InputState {
+    this.bank.beginStep();
+    this.moveX.update(dt);
+    this.moveY.update(dt);
+    this.aim.update(dt);
+    this.jump.update(dt);
+    this.dash.update(dt);
+    this.grab.update(dt);
+
+    const aim = this.aim.value;
+
+    return {
+      x: this.moveX.value,
+      y: this.moveY.value,
+      aimX: aim.x,
+      aimY: aim.y,
+      jump: this.jump.check,
+      jumpPressed: this.jump.pressed,
+      jumpReleased: this.jump.released,
+      dash: this.dash.check,
+      dashPressed: this.dash.pressed,
+      grab: this.grab.check,
+    };
+  }
+
+  clearTransientState(): void {
+    this.bank.clearQueues();
+    this.jump.reset();
+    this.dash.reset();
+    this.grab.reset();
+  }
+
+  reset(): void {
+    this.bank.reset();
+    this.moveX.reset();
+    this.moveY.reset();
+    this.aim.reset();
+    this.jump.reset();
+    this.dash.reset();
+    this.grab.reset();
+  }
+}

src/input/VirtualAxis.ts

@@ -0,0 +1,37 @@
+import { VirtualInput, VirtualInputNode } from "./VirtualInput";
+
+export abstract class VirtualAxisNode extends VirtualInputNode {
+  abstract get value(): number;
+}
+
+export class VirtualAxis extends VirtualInput {
+  readonly nodes: VirtualAxisNode[];
+  value = 0;
+  previousValue = 0;
+
+  constructor(...nodes: VirtualAxisNode[]) {
+    super();
+    this.nodes = nodes;
+  }
+
+  update(_dt: number): void {
+    for (const node of this.nodes) {
+      node.update();
+    }
+
+    this.previousValue = this.value;
+    this.value = 0;
+    for (const node of this.nodes) {
+      const value = node.value;
+      if (value !== 0) {
+        this.value = value;
+        break;
+      }
+    }
+  }
+
+  override reset(): void {
+    this.value = 0;
+    this.previousValue = 0;
+  }
+}