Release v0.1.1 2026-07-10

src/game/store.test.ts

@@ -173,6 +173,19 @@ describe("Disc Priest combat simulation", () => {
     expect(paused.castAbility("renew")).toBe(false);
   });
 
+  it("does not publish unchanged player positions while idle", () => {
+    let updates = 0;
+    const unsubscribe = useGameStore.subscribe(() => { updates += 1; });
+    const start = useGameStore.getState().playerPosition;
+
+    useGameStore.getState().setPlayerPosition([start[0], start[1]]);
+    expect(updates).toBe(0);
+
+    useGameStore.getState().setPlayerPosition([start[0] + 0.25, start[1]]);
+    expect(updates).toBe(1);
+    unsubscribe();
+  });
+
   it("telegraphs, executes, and recovers from a Bull charge", () => {
     while (useGameStore.getState().time < 7.1) useGameStore.getState().tick(0.1);
     const telegraph = useGameStore.getState().bossMotion;

src/game/store.ts

@@ -43,7 +43,7 @@ export interface AdditionalBossState {
   motion: BossMotionState;
 }
 
-interface GameState {
+export interface GameState {
   bossId: BossId;
   paused: boolean;
   pauseSelection: "resume" | "exit";
@@ -261,10 +261,20 @@ export const useGameStore = create<GameState>((set, get) => ({
   setPaused: (paused) => set({ paused, pauseSelection: "resume" }),
   togglePause: () => set((state) => ({ paused: !state.paused, pauseSelection: "resume" })),
   setPauseSelection: (pauseSelection) => set({ pauseSelection }),
-  setPlayerPosition: (playerPosition) => set((state) => ({
-    playerPosition,
-    partyPositions: { ...state.partyPositions, aelia: [...playerPosition] },
-  })),
+  setPlayerPosition: (playerPosition) => set((state) => {
+    const current = state.playerPosition;
+    const partyCurrent = state.partyPositions.aelia;
+    if (current[0] === playerPosition[0]
+      && current[1] === playerPosition[1]
+      && partyCurrent[0] === playerPosition[0]
+      && partyCurrent[1] === playerPosition[1]) {
+      return state;
+    }
+    return {
+      playerPosition,
+      partyPositions: { ...state.partyPositions, aelia: [...playerPosition] },
+    };
+  }),
 
   castAbility: (abilityId) => {
     const state = get();
@@ -522,6 +532,42 @@ export const useGameStore = create<GameState>((set, get) => ({
   },
 }));
 
+export type GameSnapshot = Omit<GameState,
+  | "configureHealer"
+  | "startEncounter"
+  | "restart"
+  | "tick"
+  | "castAbility"
+  | "selectMember"
+  | "cycleMember"
+  | "setActiveTab"
+  | "selectItem"
+  | "setPlayerPosition"
+  | "setPaused"
+  | "togglePause"
+  | "setPauseSelection"
+>;
+
+export function getGameSnapshot(): GameSnapshot {
+  const {
+    configureHealer: _configureHealer,
+    startEncounter: _startEncounter,
+    restart: _restart,
+    tick: _tick,
+    castAbility: _castAbility,
+    selectMember: _selectMember,
+    cycleMember: _cycleMember,
+    setActiveTab: _setActiveTab,
+    selectItem: _selectItem,
+    setPlayerPosition: _setPlayerPosition,
+    setPaused: _setPaused,
+    togglePause: _togglePause,
+    setPauseSelection: _setPauseSelection,
+    ...snapshot
+  } = useGameStore.getState();
+  return snapshot;
+}
+
 export function abilityRemaining(abilityId: AbilityId, time: number, cooldowns: Record<AbilityId, number>) {
   return Math.max(0, cooldowns[abilityId] - time);
 }

src/game/useGameLoop.ts

@@ -1,4 +1,5 @@
 import { useEffect, useRef } from "react";
+import { subscribeControllerToken } from "../input/controller";
 import { ABILITY_ORDER } from "./data";
 import { useGameStore } from "./store";
 import type { AbilityId } from "./types";
@@ -84,43 +85,32 @@ export function useActionBindings(enabled = true, onExit?: () => void) {
     return () => window.removeEventListener("keydown", onKeyDown);
   }, [enabled]);
 
-  useEffect(() => {
-    let frame = 0;
-    let previousButtons: boolean[] = [];
-    const poll = () => {
-      const gamepad = navigator.getGamepads?.()[0];
-      if (gamepad && enabled) {
-        const buttons = gamepad.buttons.map((button) => button.pressed);
-        const store = useGameStore.getState();
-        if (store.paused) {
-          if (buttons[12] && !previousButtons[12]) store.setPauseSelection("resume");
-          if (buttons[13] && !previousButtons[13]) store.setPauseSelection("exit");
-          if ((buttons[1] && !previousButtons[1]) || (buttons[9] && !previousButtons[9])) store.setPaused(false);
-          if (buttons[0] && !previousButtons[0]) {
-            if (store.pauseSelection === "resume") store.setPaused(false);
-            else exitRef.current?.();
-          }
-        } else {
-          for (const [button, ability] of Object.entries(gamepadAbilityMap)) {
-            const index = Number(button);
-            if (buttons[index] && !previousButtons[index]) store.castAbility(ability);
-          }
-          if (buttons[12] && !previousButtons[12]) store.cycleMember(-1);
-          if (buttons[13] && !previousButtons[13]) store.cycleMember(1);
-          if (buttons[8] && !previousButtons[8]) store.setActiveTab(store.activeTab === "map" ? "combat" : "map");
-          if (buttons[9] && !previousButtons[9]) {
-            if (store.phase === "briefing") store.startEncounter();
-            if (store.phase === "victory" || store.phase === "defeat") store.restart();
-            if (store.phase === "combat") store.setPaused(true);
-          }
-        }
-        previousButtons = buttons;
-      } else {
-        previousButtons = [];
+  useEffect(() => subscribeControllerToken(({ token, repeat }) => {
+    if (!enabled) return;
+    const store = useGameStore.getState();
+    if (store.paused) {
+      if (token === "Button12" || token === "Axis1-") store.setPauseSelection("resume");
+      if (token === "Button13" || token === "Axis1+") store.setPauseSelection("exit");
+      if (repeat) return;
+      if (token === "Button1" || token === "Button9") store.setPaused(false);
+      if (token === "Button0") {
+        if (store.pauseSelection === "resume") store.setPaused(false);
+        else exitRef.current?.();
       }
-      frame = requestAnimationFrame(poll);
-    };
-    frame = requestAnimationFrame(poll);
-    return () => cancelAnimationFrame(frame);
-  }, [enabled]);
+      return;
+    }
+    if (repeat) return;
+    if (token.startsWith("Button")) {
+      const ability = gamepadAbilityMap[Number(token.slice("Button".length))];
+      if (ability && store.phase === "combat") store.castAbility(ability);
+    }
+    if (token === "Button12") store.cycleMember(-1);
+    if (token === "Button13") store.cycleMember(1);
+    if (token === "Button8") store.setActiveTab(store.activeTab === "map" ? "combat" : "map");
+    if (token === "Button9" || (token === "Button0" && store.phase !== "combat")) {
+      if (store.phase === "briefing") store.startEncounter();
+      else if (store.phase === "victory" || store.phase === "defeat") store.restart();
+      else if (store.phase === "combat") store.setPaused(true);
+    }
+  }), [enabled]);
 }