feat: block pause menu and retry under certain conditions

Author: CoolSpring8

src/GameScene.ts

@@ -273,8 +273,12 @@ export class GameScene extends Phaser.Scene {
     }
 
     if (!this.pauseMenu.isOpen && !this.unpauseRecovery.active && this.actionPressed("pause")) {
-      this.openPauseMenu();
-      this.clearTransientKeyEdges();
+      if (this.canOpenPauseMenu()) {
+        this.openPauseMenu();
+        this.clearTransientKeyEdges();
+      } else {
+        this.clearActionTransientKeyEdges("pause");
+      }
     }
 
     if (this.pauseMenu.isOpen) {
@@ -653,6 +657,13 @@ export class GameScene extends Phaser.Scene {
     this.gameplayEdgesConsumed = false;
   }
 
+  private clearActionTransientKeyEdges(action: KeyBindingAction): void {
+    for (const code of this.bindingCodes(action)) {
+      this.pressedKeyCodes.delete(code);
+      this.releasedKeyCodes.delete(code);
+    }
+  }
+
   private spawnInitialPlayer(): void {
     this.revivePlayerAtCheckpoint("none");
   }
@@ -1564,7 +1575,17 @@ export class GameScene extends Phaser.Scene {
     this.pauseMenu.open(this.createPauseRootMenu());
   }
 
+  private canOpenPauseMenu(): boolean {
+    const snapshot = this.player.getSnapshot();
+    if (this.roomTransition !== null || snapshot.dead) {
+      return false;
+    }
+
+    return this.deathRespawnSequence === null || this.deathRespawnSequence.respawnStarted;
+  }
+
   private createPauseRootMenu(): PauseActionMenu {
+    const canRetry = this.canRetryFromPause();
     return {
       kind: "action",
       title: "PAUSED",
@@ -1581,6 +1602,7 @@ export class GameScene extends Phaser.Scene {
         },
         {
           label: "Retry",
+          disabled: !canRetry,
           activate: () => {
             this.closePauseMenuImmediately();
             this.retryFromPause();
@@ -1834,13 +1856,17 @@ export class GameScene extends Phaser.Scene {
   }
 
   private retryFromPause(): void {
-    if (this.deathRespawnSequence !== null || !this.player.canRetry) {
+    if (!this.canRetryFromPause()) {
       return;
     }
 
     this.beginNormalRespawn();
   }
 
+  private canRetryFromPause(): boolean {
+    return this.deathRespawnSequence === null && this.player.canRetry;
+  }
+
   private stopScreenShake(): void {
     this.cameras.main.resetFX();
   }
@@ -1866,7 +1892,13 @@ export class GameScene extends Phaser.Scene {
 
       if (result.openPause) {
         this.accumulator = 0;
-        this.openPauseMenu();
+        if (this.canOpenPauseMenu()) {
+          this.openPauseMenu();
+        } else {
+          this.clearActionTransientKeyEdges("pause");
+          this.resumePauseManagedEffects();
+          return false;
+        }
         return true;
       }
 

src/pause/menu.ts

@@ -13,6 +13,7 @@ export interface PauseMenuOption<T = unknown> {
 export interface PauseMenuSubmenuItem {
   kind: "submenu";
   label: string;
+  disabled?: boolean;
   activate: (controller: PauseMenuController) => void;
 }
 
@@ -26,6 +27,7 @@ export interface PauseMenuKeyBindingItem<TAction = unknown> {
 export interface PauseMenuCommandItem {
   kind: "command";
   label: string;
+  disabled?: boolean;
   activate: (controller: PauseMenuController) => void;
 }
 
@@ -37,6 +39,7 @@ export type PauseMenuOptionItem<T = unknown> =
 
 export interface PauseMenuItem {
   label: string;
+  disabled?: boolean;
   activate: (controller: PauseMenuController) => void;
 }
 
@@ -74,6 +77,10 @@ export function isPauseCommandItem(item: PauseMenuOptionItem<unknown>): item is
   return item.kind === "command";
 }
 
+export function isPauseMenuItemDisabled(item: { disabled?: boolean }): boolean {
+  return item.disabled === true;
+}
+
 export function currentPauseOptionValue<T>(option: PauseMenuOption<T>): T | null {
   return option.values[option.valueIndex]?.value ?? null;
 }
@@ -161,7 +168,7 @@ export class PauseMenuController {
 
     if (screen.kind === "action") {
       const item = screen.items[screen.selectedIndex];
-      if (!item) {
+      if (!item || isPauseMenuItemDisabled(item)) {
         return;
       }
 
@@ -174,7 +181,7 @@ export class PauseMenuController {
       return;
     }
 
-    if (isPauseSubmenuItem(item) || isPauseCommandItem(item)) {
+    if ((isPauseSubmenuItem(item) || isPauseCommandItem(item)) && !isPauseMenuItemDisabled(item)) {
       item.activate(this);
     }
   }

src/view/PauseOverlay.ts

@@ -5,6 +5,7 @@ import {
   isPauseChoiceOption,
   isPauseCommandItem,
   isPauseKeyBindingItem,
+  isPauseMenuItemDisabled,
   isPauseSubmenuItem,
   type PauseMenuScreen,
 } from "../pause/menu";
@@ -103,12 +104,12 @@ export class PauseOverlay {
       const rowVisible = !scrollable ||
         (y >= rowStartY - rowHeight && y <= rowStartY + visibleRowsHeight);
       const selected = i === screen.selectedIndex;
-      const labelColor = selected ? COLOR_SELECTED : COLOR_TEXT;
-
-      row.label.setVisible(rowVisible).setText(screen.items[i].label).setColor(labelColor);
-      row.label.setY(y);
 
       if (screen.kind === "action") {
+        const item = screen.items[i];
+        const labelColor = isPauseMenuItemDisabled(item) ? COLOR_DISABLED : selected ? COLOR_SELECTED : COLOR_TEXT;
+        row.label.setVisible(rowVisible).setText(item.label).setColor(labelColor);
+        row.label.setY(y);
         row.label
           .setX(centerX)
           .setOrigin(0.5, 0)
@@ -120,7 +121,11 @@ export class PauseOverlay {
       }
 
       const item = screen.items[i];
-      const valueColor = selected ? COLOR_SELECTED : COLOR_TEXT;
+      const disabled = (isPauseSubmenuItem(item) || isPauseCommandItem(item)) && isPauseMenuItemDisabled(item);
+      const labelColor = disabled ? COLOR_DISABLED : selected ? COLOR_SELECTED : COLOR_TEXT;
+      const valueColor = disabled ? COLOR_DISABLED : selected ? COLOR_SELECTED : COLOR_TEXT;
+      row.label.setVisible(rowVisible).setText(item.label).setColor(labelColor);
+      row.label.setY(y);
       if (!rowVisible) {
         row.leftArrow.setVisible(false);
         row.value.setVisible(false);

tests/model/game-scene-input-lifecycle.test.ts

@@ -91,7 +91,8 @@ async function createSceneHarness(): Promise<InstanceType<GameSceneConstructor>
   scene.player = {
     inControl: true,
     timePaused: false,
-    getSnapshot: () => ({}),
+    canRetry: true,
+    getSnapshot: () => ({ dead: false, state: "normal" }),
   };
   scene.playerView = {
     render() {},
@@ -142,6 +143,27 @@ describe("GameScene input edge lifecycle", () => {
     expect(held.jumpPressed).toBeFalse();
   });
 
+  test("pause pressed during a room transition is consumed without opening the pause menu", async () => {
+    const scene = await createSceneHarness();
+    let openedPause = false;
+    scene.openPauseMenu = () => {
+      openedPause = true;
+    };
+
+    (scene.onKeyDown as (event: KeyboardEvent) => void)(keyDown("KeyP"));
+    (scene.onKeyDown as (event: KeyboardEvent) => void)(keyDown("KeyJ"));
+    scene.roomTransition = {};
+    (scene.update as (time: number, delta: number) => void)(0, 16);
+
+    expect(openedPause).toBeFalse();
+    expect((scene.actionPressed as (action: string) => boolean)("pause")).toBeFalse();
+
+    scene.roomTransition = null;
+    const input = (scene.gatherStepInput as () => ReturnType<PlayerControls["update"]>)();
+    expect(input.jump).toBeTrue();
+    expect(input.jumpPressed).toBeTrue();
+  });
+
   test("freeze frames preserve dash press edges for the first resumed gameplay step", async () => {
     const scene = await createSceneHarness();
 
@@ -169,6 +191,50 @@ describe("GameScene input edge lifecycle", () => {
     expect(input.jumpPressed).toBeTrue();
   });
 
+  test("pause stays blocked through death and wipe until respawn starts", async () => {
+    const scene = await createSceneHarness();
+    let openedPause = false;
+    scene.openPauseMenu = () => {
+      openedPause = true;
+    };
+
+    (scene.onKeyDown as (event: KeyboardEvent) => void)(keyDown("KeyP"));
+    scene.deathRespawnSequence = {
+      revealStarted: false,
+      respawnStarted: false,
+    };
+    (scene.update as (time: number, delta: number) => void)(0, 16);
+
+    expect(openedPause).toBeFalse();
+    expect((scene.actionPressed as (action: string) => boolean)("pause")).toBeFalse();
+
+    const player = scene.player as {
+      timePaused: boolean;
+      getSnapshot: () => { dead: boolean; state: string };
+    };
+    scene.deathRespawnSequence = {
+      revealStarted: true,
+      respawnStarted: true,
+    };
+    player.timePaused = true;
+    player.getSnapshot = () => ({ dead: false, state: "intro_respawn" });
+
+    (scene.onKeyDown as (event: KeyboardEvent) => void)(keyDown("KeyP"));
+    (scene.update as (time: number, delta: number) => void)(0, 16);
+
+    expect(openedPause).toBeTrue();
+    expect((scene.actionPressed as (action: string) => boolean)("pause")).toBeFalse();
+  });
+
+  test("pause root disables retry when the player cannot retry", async () => {
+    const scene = await createSceneHarness();
+    const player = scene.player as { canRetry: boolean };
+    player.canRetry = false;
+
+    const root = (scene.createPauseRootMenu as () => { items: Array<{ label: string; disabled?: boolean }> })();
+    expect(root.items.find((item) => item.label === "Retry")?.disabled).toBeTrue();
+  });
+
   test("unpause recovery consumes held input separately and clears raw press edges", async () => {
     const scene = await createSceneHarness();
     let sampledHeld: { jump: boolean } | null = null;

tests/model/pause-menu.test.ts

@@ -148,4 +148,33 @@ describe("Pause menu controller", () => {
     controller.confirm();
     expect(commandRan).toBeTrue();
   });
+
+  test("disabled action menu items render in place but ignore confirm", () => {
+    const controller = new PauseMenuController();
+    let retried = false;
+
+    const root: PauseActionMenu = {
+      kind: "action",
+      title: "PAUSED",
+      selectedIndex: 1,
+      onCancel: (menu) => menu.close(),
+      items: [
+        { label: "Resume", activate: () => {} },
+        {
+          label: "Retry",
+          disabled: true,
+          activate: () => {
+            retried = true;
+          },
+        },
+        { label: "Options", activate: () => {} },
+      ],
+    };
+
+    controller.open(root);
+    controller.confirm();
+
+    expect(retried).toBeFalse();
+    expect(controller.current?.selectedIndex).toBe(1);
+  });
 });