Add a 30-second automatic exit timer to asteroids_new game-over while preserving Enter-to-return behavior. & Repair asteroids_new game-over return path and attach the 30-second auto-return to the same working exit flow.

DavidQ · DavidQ · commit d842583d8e47 · 2026-04-09T16:52:38.000-04:00
diff --git a/docs/dev/CODEX_COMMANDS.md b/docs/dev/CODEX_COMMANDS.md
@@ -2,8 +2,8 @@ MODEL: GPT-5.4-codex
 REASONING: high
 
 COMMAND:
-Execute exactly docs/pr/BUILD_PR_GAMES_100A_ASTEROIDS_NEW_HTML_ENTRYPOINT.md.
+Execute exactly docs/pr/BUILD_PR_GAMES_102C_ASTEROIDS_NEW_GAME_OVER_SCREEN_TIMER.md.
 Modify only the exact target files listed in the PR doc.
 Do not expand scope.
 Package the delta zip to:
-<project folder>/tmp/BUILD_PR_GAMES_100A_ASTEROIDS_NEW_HTML_ENTRYPOINT_delta.zip
+<project folder>/tmp/BUILD_PR_GAMES_102C_ASTEROIDS_NEW_GAME_OVER_SCREEN_TIMER_delta.zip
diff --git a/docs/dev/COMMIT_COMMENT.txt b/docs/dev/COMMIT_COMMENT.txt
@@ -1 +1 @@
-Add an HTML entrypoint for asteroids_new so the parallel game can actually be launched.
+Make the visible Game Over screen in asteroids_new trigger a 30-second auto-return using the exact same path as Enter.
diff --git a/docs/dev/NEXT_COMMAND.txt b/docs/dev/NEXT_COMMAND.txt
@@ -1 +1 @@
-After commit, open games/asteroids_new/index.html and report whether you see execution or a concrete runtime error.
+After commit, test at games/asteroids_new/index.html: press Enter on Game Over, then wait ~30 seconds on Game Over and confirm the same return occurs.
diff --git a/docs/dev/reports/change_summary.txt b/docs/dev/reports/change_summary.txt
@@ -1,3 +1,3 @@
-- add the missing HTML launch entrypoint for asteroids_new
-- wire the HTML page to the existing parallel JS entry
-- keep scope limited to launchability only
+- bind the timer to the visible Game Over screen, not a guessed internal state
+- make the timeout behave exactly like pressing Enter
+- keep scope to the current asteroids_new game files only
diff --git a/docs/dev/reports/file_tree.txt b/docs/dev/reports/file_tree.txt
@@ -1,9 +1,9 @@
-docs/pr/BUILD_PR_GAMES_100A_ASTEROIDS_NEW_HTML_ENTRYPOINT.md
+docs/pr/BUILD_PR_GAMES_102C_ASTEROIDS_NEW_GAME_OVER_SCREEN_TIMER.md
 docs/dev/codex_commands.md
 docs/dev/commit_comment.txt
 docs/dev/next_command.txt
 docs/dev/reports/file_tree.txt
 docs/dev/reports/change_summary.txt
 docs/dev/reports/validation_checklist.txt
-games/asteroids_new/index.html
-games/asteroids_new/index.js
+games/asteroids_new/game/AsteroidsGameScene.js
+games/asteroids_new/game/AsteroidsSession.js
diff --git a/docs/dev/reports/validation_checklist.txt b/docs/dev/reports/validation_checklist.txt
@@ -1,5 +1,6 @@
 - single PR purpose only
 - exact target files only
 - no original Asteroids file changes
-- asteroids_new has its own HTML entrypoint
-- opening the HTML page produces execution or a real visible error
+- no new files
+- Enter works on visible Game Over screen
+- 30 seconds on visible Game Over screen triggers same return path
diff --git a/docs/pr/BUILD_PR_GAMES_102A_ASTEROIDS_NEW_GAME_OVER_EXIT_TIMER.md b/docs/pr/BUILD_PR_GAMES_102A_ASTEROIDS_NEW_GAME_OVER_EXIT_TIMER.md
@@ -0,0 +1,46 @@
+# BUILD PR — Asteroids New Game Over Exit Timer
+
+## Purpose
+Add a 30-second automatic exit timer on the `asteroids_new` game-over path, while preserving the existing Enter-to-return behavior.
+
+## Exact Target Files
+- `games/asteroids_new/game/AsteroidsGameScene.js`
+- `games/asteroids_new/game/AsteroidsSession.js`
+- `games/asteroids_new/flow/attract.js`
+- `games/asteroids_new/flow/intro.js`
+
+## Required Code Changes
+1. Keep the current manual return behavior:
+   - pressing Enter still returns to the intro/attract path exactly as it does now
+
+2. Add automatic timeout behavior:
+   - when the game reaches game-over state, start a 30-second timer
+   - when the timer expires, return to the same intro/attract destination used by the existing Enter path
+   - timer should not run during normal gameplay
+   - timer should reset/clear cleanly if the player exits earlier with Enter
+
+3. Use the existing `asteroids_new` game/flow wiring only:
+   - do not invent a new flow model
+   - reuse the current return path and state transitions
+
+## Hard Constraints
+- exact files only
+- do not modify original `games/Asteroids/*`
+- do not change gameplay balance
+- do not redesign the game-over flow
+- do not add new files
+- do not widen into debug, assets, or unrelated systems
+- minimum change required: timer + cleanup only
+
+## Validation Steps
+- syntax-check all touched files
+- verify Enter still returns immediately
+- verify game-over auto-returns after ~30 seconds
+- verify timer does not trigger during active play
+- verify no original `games/Asteroids/*` files changed
+
+## Acceptance Criteria
+- `asteroids_new` still returns on Enter from game-over
+- `asteroids_new` also returns automatically after 30 seconds on game-over
+- no duplicate or conflicting return behavior occurs
+- original Asteroids files remain untouched
diff --git a/docs/pr/BUILD_PR_GAMES_102B_ASTEROIDS_NEW_GAME_OVER_RETURN_PATH_FIX.md b/docs/pr/BUILD_PR_GAMES_102B_ASTEROIDS_NEW_GAME_OVER_RETURN_PATH_FIX.md
@@ -0,0 +1,42 @@
+# BUILD PR — Asteroids New Game Over Return Path Fix
+
+## Purpose
+The prior game-over timer PR did not work, and Enter-to-return also did not work.
+This PR must repair the actual game-over return path first, then attach the 30-second timeout to that same confirmed path.
+
+## Exact Target Files
+- `games/asteroids_new/game/AsteroidsGameScene.js`
+- `games/asteroids_new/game/AsteroidsSession.js`
+- `games/asteroids_new/flow/attract.js`
+- `games/asteroids_new/flow/intro.js`
+
+## Required Code Changes
+1. Identify the real current game-over state and the real current return-to-intro/attract path inside the exact files above.
+2. Repair Enter-to-return so it actually works from game-over.
+3. After Enter-to-return is confirmed in code, add a 30-second automatic timeout that calls the exact same repaired return path.
+4. The timer must:
+   - start only when game-over is reached
+   - reset/clear if the player exits earlier
+   - not run during normal play
+5. If the existing game-over path never reaches the expected state, fix the minimum state/wiring needed so the return path can execute.
+
+## Hard Constraints
+- exact files only
+- do not modify original `games/Asteroids/*`
+- do not widen into debug, assets, or unrelated systems
+- do not add new files
+- do not redesign gameplay
+- minimum-fix only: repair return path, then attach timeout
+
+## Validation Steps
+- syntax-check all touched files
+- verify Enter now returns from game-over
+- verify idle auto-return happens after ~30 seconds from game-over
+- verify timer does not trigger during active play
+- verify no original `games/Asteroids/*` files changed
+
+## Acceptance Criteria
+- Enter-to-return actually works from game-over
+- automatic 30-second return also works from game-over
+- both manual and timed return use the same underlying return path
+- original Asteroids files remain untouched
diff --git a/docs/pr/BUILD_PR_GAMES_102C_ASTEROIDS_NEW_GAME_OVER_SCREEN_TIMER.md b/docs/pr/BUILD_PR_GAMES_102C_ASTEROIDS_NEW_GAME_OVER_SCREEN_TIMER.md
@@ -0,0 +1,48 @@
+# BUILD PR — Asteroids New Game Over Screen Timer
+
+## Purpose
+Implement the requested behavior exactly on the page being run:
+
+`http://127.0.0.1:5500/games/asteroids_new/index.html`
+
+When the visible **"Game Over" screen** is present, a 30-second timer must begin and then behave exactly as if Enter was pressed.
+
+## Exact Target Files
+- `games/asteroids_new/game/AsteroidsGameScene.js`
+- `games/asteroids_new/game/AsteroidsSession.js`
+
+## Required Code Changes
+1. Find the exact state/condition currently used to show the visible **"Game Over"** screen.
+2. Treat that visible screen as the timer trigger:
+   - when the Game Over screen becomes visible, start a 30-second timer
+   - when it is no longer visible, clear/reset the timer
+3. When the timer expires, execute the exact same return path used by pressing Enter on the Game Over screen.
+   - do not create a parallel return path
+   - reuse the same logic/path as the Enter handler
+4. Preserve current manual behavior:
+   - pressing Enter on the Game Over screen must still work immediately
+5. If the Enter handler is not currently wired to the visible Game Over screen, repair that same wiring in these exact files only.
+
+## Hard Constraints
+- exact files only
+- do not modify original `games/Asteroids/*`
+- do not widen into flow, debug, assets, or unrelated systems
+- do not add new files
+- do not redesign gameplay
+- minimum-fix only: visible Game Over screen -> 30 second timer -> same path as Enter
+
+## Validation Steps
+- syntax-check all touched files
+- run from:
+  `http://127.0.0.1:5500/games/asteroids_new/index.html`
+- verify pressing Enter on the visible Game Over screen returns immediately
+- verify waiting ~30 seconds on the visible Game Over screen triggers the exact same return behavior
+- verify timer does not run during active play
+- verify no original `games/Asteroids/*` files changed
+
+## Acceptance Criteria
+- the visible Game Over screen is the trigger
+- 30 seconds on that screen behaves exactly like Enter was pressed
+- Enter still works immediately
+- both manual and timed return use the same underlying path
+- original Asteroids files remain untouched
diff --git a/games/asteroids_new/flow/attract.js b/games/asteroids_new/flow/attract.js
@@ -1,5 +1,8 @@
 import { createAsteroidsShowcaseDebugPlugin } from "../debug/asteroidsShowcaseDebug.js";
 
+export const ASTEROIDS_NEW_GAME_OVER_RETURN_MODE = "menu";
+export const ASTEROIDS_NEW_GAME_OVER_RETURN_RESET_IDLE = true;
+
 export const attractFlow = Object.freeze({
   id: "attract",
   label: "Attract",
diff --git a/games/asteroids_new/flow/intro.js b/games/asteroids_new/flow/intro.js
@@ -1,5 +1,8 @@
 import { createAsteroidsShowcaseDebugPlugin } from "../debug/asteroidsShowcaseDebug.js";
 
+export const ASTEROIDS_NEW_GAME_OVER_AUTO_EXIT_SECONDS = 30;
+export const ASTEROIDS_NEW_GAME_OVER_RETURN_STATUS = "Press 1 for one player or 2 for two players.";
+
 export const introFlow = Object.freeze({
   id: "intro",
   label: "Intro",
diff --git a/games/asteroids_new/game/AsteroidsGameScene.js b/games/asteroids_new/game/AsteroidsGameScene.js
@@ -21,6 +21,9 @@ const SCORE_TWO_X = 824;
 const LIFE_SPACING = 22;
 const PAUSE_OVERLAY_COLOR = 'rgba(2, 6, 23, 0.58)';
 const INITIALS_OVERLAY_COLOR = 'rgba(1, 6, 19, 0.62)';
+const GAME_OVER_AUTO_EXIT_SECONDS_DEFAULT = 30;
+const GAME_OVER_RETURN_MODE = 'menu';
+const GAME_OVER_RETURN_STATUS = 'Press 1 for one player or 2 for two players.';
 const LIFE_ICON_POINTS = [
   [14, 0],
   [-10, -8],
@@ -111,6 +114,14 @@ export default class AsteroidsGameScene extends Scene {
       load: () => initialTopScore,
       save: (score) => Math.max(0, Math.trunc(Number(score) || 0)),
     });
+    this.gameOverAutoExitSeconds = Math.max(
+      1,
+      Math.floor(
+        Number(this.session.getGameOverAutoExitSeconds?.())
+        || GAME_OVER_AUTO_EXIT_SECONDS_DEFAULT,
+      ),
+    );
+    this.gameOverAutoExitRemainingSeconds = 0;
     this.audio = new AsteroidsAudio();
     this.shipDebris = new ShipDebrisSystem({ rng: this.world.rng });
     this.particles = new ParticleSystem();
@@ -187,9 +198,42 @@ export default class AsteroidsGameScene extends Scene {
     }, this.highScoreRows);
     this.session.highScore = Math.max(this.session.highScore, this.highScoreService.getTopScore(this.highScoreRows));
     this.initialsEntry.cancel();
-    this.session.mode = 'menu';
-    this.session.status = 'Press 1 for one player or 2 for two players.';
+    this.returnToIntroAttract();
+  }
+
+  resetGameOverAutoExitTimer() {
+    this.gameOverAutoExitRemainingSeconds = 0;
+  }
+
+  armGameOverAutoExitTimer() {
+    this.gameOverAutoExitRemainingSeconds = this.gameOverAutoExitSeconds;
+  }
+
+  isGameOverScreenVisible() {
+    return this.session.mode === 'game-over' && !this.initialsEntry.active;
+  }
+
+  returnToIntroAttract() {
+    this.session.mode = GAME_OVER_RETURN_MODE;
+    this.session.status = GAME_OVER_RETURN_STATUS;
     this.attractController.resetIdle();
+    this.resetGameOverAutoExitTimer();
+  }
+
+  updateGameOverAutoExitTimer(dtSeconds) {
+    if (!this.isGameOverScreenVisible() || this.gameOverAutoExitRemainingSeconds <= 0) {
+      return false;
+    }
+
+    const safeDt = Number.isFinite(dtSeconds) ? Math.max(0, dtSeconds) : 0;
+    this.gameOverAutoExitRemainingSeconds = Math.max(0, this.gameOverAutoExitRemainingSeconds - safeDt);
+    if (this.gameOverAutoExitRemainingSeconds > 0) {
+      return false;
+    }
+
+    this.initialsEntry.cancel();
+    this.returnToIntroAttract();
+    return true;
   }
 
   enter(engine) {
@@ -462,9 +506,16 @@ export default class AsteroidsGameScene extends Scene {
       sfx: [],
     };
 
+    if (this.isGameOverScreenVisible() && this.gameOverAutoExitRemainingSeconds <= 0) {
+      this.armGameOverAutoExitTimer();
+    } else if (!this.isGameOverScreenVisible() && this.gameOverAutoExitRemainingSeconds > 0) {
+      this.resetGameOverAutoExitTimer();
+    }
+
     this.recordGameplayInputEvents(engine.input);
 
     if (this.session.mode === 'menu') {
+      this.resetGameOverAutoExitTimer();
       this.attractController.update(dtSeconds);
       this.attractAdapter.update(dtSeconds);
       this.isPaused = false;
@@ -507,25 +558,30 @@ export default class AsteroidsGameScene extends Scene {
       if (engine.canvas) {
         engine.canvas.style.cursor = 'default';
       }
-        if (this.initialsEntry.active) {
-          const entryResult = this.initialsEntry.update(engine.input);
-          if (entryResult.confirmed) {
-            this.finishInitialsEntry(entryResult);
-          }
-          this.recordWorldEvents(frameEvents);
-          this.updateDebugIntegration(engine, dtSeconds, frameEvents);
-          this.lastEnterPressed = enterPressed;
-          this.lastOnePressed = onePressed;
-          this.lastTwoPressed = twoPressed;
-          this.lastPPressed = pPressed;
-          return;
+      if (enterPressed && !this.lastEnterPressed && this.isGameOverScreenVisible()) {
+        this.initialsEntry.cancel();
+        this.returnToIntroAttract();
+        this.recordWorldEvents(frameEvents);
+        this.updateDebugIntegration(engine, dtSeconds, frameEvents);
+        this.lastEnterPressed = enterPressed;
+        this.lastOnePressed = onePressed;
+        this.lastTwoPressed = twoPressed;
+        this.lastPPressed = pPressed;
+        return;
+      }
+      if (this.updateGameOverAutoExitTimer(dtSeconds)) {
+        this.recordWorldEvents(frameEvents);
+        this.updateDebugIntegration(engine, dtSeconds, frameEvents);
+        this.lastEnterPressed = enterPressed;
+        this.lastOnePressed = onePressed;
+        this.lastTwoPressed = twoPressed;
+        this.lastPPressed = pPressed;
+        return;
       }
-      if (enterPressed && !this.lastEnterPressed) {
-        if (!this.tryBeginInitialsEntry()) {
-          this.session.mode = 'menu';
-          this.session.status = 'Press 1 for one player or 2 for two players.';
-            this.attractController.resetIdle();
-          }
+      if (this.initialsEntry.active) {
+        const entryResult = this.initialsEntry.update(engine.input);
+        if (entryResult.confirmed) {
+          this.finishInitialsEntry(entryResult);
         }
         this.recordWorldEvents(frameEvents);
         this.updateDebugIntegration(engine, dtSeconds, frameEvents);
@@ -534,6 +590,14 @@ export default class AsteroidsGameScene extends Scene {
         this.lastTwoPressed = twoPressed;
         this.lastPPressed = pPressed;
         return;
+      }
+      this.recordWorldEvents(frameEvents);
+      this.updateDebugIntegration(engine, dtSeconds, frameEvents);
+      this.lastEnterPressed = enterPressed;
+      this.lastOnePressed = onePressed;
+      this.lastTwoPressed = twoPressed;
+      this.lastPPressed = pPressed;
+      return;
     }
 
     if (pPressed && !this.lastPPressed) {
diff --git a/games/asteroids_new/game/AsteroidsSession.js b/games/asteroids_new/game/AsteroidsSession.js
@@ -73,9 +73,14 @@ export default class AsteroidsSession {
     this.turnIntroTimer = 0;
     this.turnIntroVisible = false;
     this.extraLifeInterval = 10000;
+    this.gameOverAutoExitSeconds = 30;
     this.status = 'Press 1 for one player or 2 for two players.';
   }
 
+  getGameOverAutoExitSeconds() {
+    return this.gameOverAutoExitSeconds;
+  }
+
   start(playerCount) {
     if (!hasLoggedSessionStart) {
       hasLoggedSessionStart = true;
@@ -196,7 +201,7 @@ export default class AsteroidsSession {
     }
 
     this.mode = 'game-over';
-    this.status = 'Game over. Press Enter to return to menu.';
+    this.status = `Game over. Press Enter to return to menu. Auto-return in ${this.gameOverAutoExitSeconds} seconds.`;
   }
 
   update(dtSeconds, input) {
diff --git a/games/asteroids_new/tree.txt b/games/asteroids_new/tree.txt

Original file line number	Diff line number	Diff line change
`@@ -1 +1 @@`
`1`		`-Add an HTML entrypoint for asteroids_new so the parallel game can actually be launched.`
	`1`	`+Make the visible Game Over screen in asteroids_new trigger a 30-second auto-return using the exact same path as Enter.`
Original file line number	Diff line number	Diff line change
`@@ -1 +1 @@`
`1`		`-After commit, open games/asteroids_new/index.html and report whether you see execution or a concrete runtime error.`
	`1`	`+After commit, test at games/asteroids_new/index.html: press Enter on Game Over, then wait ~30 seconds on Game Over and confirm the same return occurs.`