Add weighted Asteroids beat timing based on asteroid size counts - PR_26139_026-asteroids-weighted-beat-timing

Author: DavidQ

docs/dev/reports/PR_26139_026-asteroids-weighted-beat-timing_report.md

@@ -0,0 +1,45 @@
+# PR_26139_026-asteroids-weighted-beat-timing
+
+## Summary
+- Replaced raw asteroid-count beat cadence with weighted active asteroid totals.
+- Weights are large asteroid `9`, medium asteroid `4`, and small asteroid `1`.
+- Beat timing now uses only active asteroid objects and preserves the existing cadence bounds of `0.18s` minimum and `0.98s` maximum.
+- Added targeted Asteroids Playwright validation for the expected split progression.
+
+## Runtime Behavior
+- The active wave establishes the current beat baseline from live asteroid objects; no asteroid-count totals are hardcoded in runtime cadence logic.
+- Weighted totals decrease as asteroids split, so cadence speeds up through the expected progression:
+  - `8 large = 72`
+  - `16 medium = 64`
+  - `32 small = 32`
+- Inactive asteroid-like objects with `active: false`, `alive: false`, or `destroyed: true` do not contribute to cadence.
+
+## Validation
+- PASS: `npx playwright test tests/playwright/tools/AsteroidsBeatTiming.spec.mjs --project=playwright --workers=1 --reporter=list`
+  - 1 passed.
+- PASS: `npm run build:manifest`
+- PASS: `npm run test:workspace-v2`
+  - 58 passed.
+- PASS: repeated targeted Asteroids beat timing validation after Workspace V2 for the final coverage report.
+- PASS: `git diff --check`
+
+## PR_26139_025 Regression Check
+- Workspace V2 suite re-ran the repo discovery/schema reference tests from PR_26139_025.
+- Asteroids and AITargetDummy remain discoverable through Workspace Manager V2 Select Repo.
+- No unresolved `asset-manager-v2.schema.json` or `palette-manager-v2.schema.json` schema reference regression was observed.
+
+## Playwright Impact
+- Playwright impacted: Yes.
+- Expected pass behavior: weighted totals are `72`, `64`, `32`, then `0` for inactive-only asteroids; intervals monotonically decrease as totals decrease and stay within `0.18s`/`0.98s`.
+- Expected fail behavior: raw object-count timing would make `16 medium` or `32 small` slower, or inactive objects would inflate the weighted total.
+
+## Full Samples
+- Full samples smoke test was skipped.
+- Reason: scope is limited to Asteroids beat cadence and Workspace V2 schema/game discovery regression was covered by targeted/full Workspace V2 validation.
+
+## Manual Validation
+1. Launch `games/Asteroids/index.html`.
+2. Start a game and listen for the alternating beat cadence.
+3. Split large asteroids into medium asteroids and confirm the beat becomes faster.
+4. Split medium asteroids into small asteroids and confirm the beat becomes faster again.
+5. Confirm the cadence remains bounded and does not jump outside the existing slow/fast range.

games/Asteroids/game/AsteroidsGameScene.js

@@ -32,6 +32,13 @@ 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 ASTEROID_BEAT_MIN_INTERVAL_SECONDS = 0.18;
+const ASTEROID_BEAT_MAX_INTERVAL_SECONDS = 0.98;
+const ASTEROID_BEAT_SIZE_WEIGHTS = Object.freeze({
+  1: 1,
+  2: 4,
+  3: 9,
+});
 const ATTRACT_INPUT_CODES = [
   'Digit1',
   'Digit2',
@@ -74,23 +81,29 @@ function screenDimensionsFromOptions(options) {
   return { width, height };
 }
 
-function getBeatInterval(asteroidCount) {
-  if (asteroidCount <= 1) {
-    return 0.18;
-  }
-  if (asteroidCount === 2) {
-    return 0.28;
-  }
-  if (asteroidCount <= 4) {
-    return 0.42;
-  }
-  if (asteroidCount <= 6) {
-    return 0.58;
-  }
-  if (asteroidCount <= 8) {
-    return 0.78;
+function isActiveAsteroid(asteroid) {
+  return Boolean(asteroid)
+    && typeof asteroid === 'object'
+    && asteroid.active !== false
+    && asteroid.alive !== false
+    && asteroid.destroyed !== true;
+}
+
+export function getAsteroidsBeatWeightedTotal(asteroids) {
+  if (!Array.isArray(asteroids)) {
+    return 0;
   }
-  return 0.98;
+  return asteroids.reduce((total, asteroid) => (
+    total + (isActiveAsteroid(asteroid) ? ASTEROID_BEAT_SIZE_WEIGHTS[asteroid.size] || 0 : 0)
+  ), 0);
+}
+
+export function getAsteroidsBeatInterval(weightedTotal, maxWeightedTotal) {
+  const safeWeightedTotal = Math.max(0, Number.isFinite(weightedTotal) ? weightedTotal : 0);
+  const safeMaxWeightedTotal = Math.max(1, Number.isFinite(maxWeightedTotal) ? maxWeightedTotal : safeWeightedTotal);
+  const weightedProgress = Math.min(1, safeWeightedTotal / safeMaxWeightedTotal);
+  return ASTEROID_BEAT_MIN_INTERVAL_SECONDS
+    + ((ASTEROID_BEAT_MAX_INTERVAL_SECONDS - ASTEROID_BEAT_MIN_INTERVAL_SECONDS) * weightedProgress);
 }
 
 export default class AsteroidsGameScene extends Scene {
@@ -171,6 +184,8 @@ export default class AsteroidsGameScene extends Scene {
     this.isPaused = false;
     this.beatTimer = 0;
     this.nextBeatId = 'beat1';
+    this.beatMaxWeightedTotal = 1;
+    this.resetBeatCadenceBaseline();
     this.scoreFlashTime = 0;
     this.initialsEntry = new AsteroidsInitialsEntry();
     this.attractAdapter = new AsteroidsAttractAdapter({ scene: this });
@@ -533,6 +548,20 @@ export default class AsteroidsGameScene extends Scene {
     });
   }
 
+  resetBeatCadenceBaseline() {
+    this.beatMaxWeightedTotal = Math.max(1, getAsteroidsBeatWeightedTotal(this.world?.asteroids));
+  }
+
+  resolveAsteroidsBeatTiming() {
+    const weightedTotal = getAsteroidsBeatWeightedTotal(this.world?.asteroids);
+    this.beatMaxWeightedTotal = Math.max(this.beatMaxWeightedTotal, weightedTotal, 1);
+    return {
+      intervalSeconds: getAsteroidsBeatInterval(weightedTotal, this.beatMaxWeightedTotal),
+      maxWeightedTotal: this.beatMaxWeightedTotal,
+      weightedTotal,
+    };
+  }
+
   update(dtSeconds, engine) {
     this.debugFrame += 1;
     this.objectVectorPlaybackMs += Math.max(0, Number.isFinite(dtSeconds) ? dtSeconds * 1000 : 0);
@@ -575,12 +604,14 @@ export default class AsteroidsGameScene extends Scene {
       if (onePressed && !this.lastOnePressed) {
         this.attractController.exitAttract();
         this.session.start(1);
+        this.resetBeatCadenceBaseline();
         this.pushDebugEvent('SHIP_SPAWN', { player: 1, wave: this.world.wave });
         this.pushDebugEvent('WAVE_STARTED', { wave: this.world.wave, asteroids: this.world.asteroids.length });
       }
       if (twoPressed && !this.lastTwoPressed) {
         this.attractController.exitAttract();
         this.session.start(2);
+        this.resetBeatCadenceBaseline();
         this.pushDebugEvent('SHIP_SPAWN', { player: 1, wave: this.world.wave });
         this.pushDebugEvent('WAVE_STARTED', { wave: this.world.wave, asteroids: this.world.asteroids.length });
       }
@@ -710,12 +741,12 @@ export default class AsteroidsGameScene extends Scene {
       this.audio.updateThrust(false);
       this.audio.updateUfo(null);
     } else {
-      const beatInterval = getBeatInterval(this.world.asteroids.length);
+      const beatTiming = this.resolveAsteroidsBeatTiming();
       this.beatTimer -= dtSeconds;
       if (this.beatTimer <= 0) {
         this.audio.play(this.nextBeatId);
         this.nextBeatId = this.nextBeatId === 'beat1' ? 'beat2' : 'beat1';
-        this.beatTimer = beatInterval;
+        this.beatTimer = beatTiming.intervalSeconds;
       }
       this.audio.updateThrust(this.world.ship.thrusting && this.session.mode === 'playing');
       this.audio.updateUfo(this.world.ufo?.type || null);

tests/playwright/tools/AsteroidsBeatTiming.spec.mjs

@@ -0,0 +1,71 @@
+import { expect, test } from "@playwright/test";
+import { startRepoServer } from "../../helpers/playwrightRepoServer.mjs";
+import { workspaceV2CoverageReporter as coverageReporter } from "../../helpers/workspaceV2CoverageReporter.mjs";
+
+test.afterAll(async () => {
+  await coverageReporter.writeReport();
+});
+
+async function waitForAsteroidsBoot(page) {
+  await page.waitForFunction(() => window.__asteroidsNewBootStage === "boot-complete");
+  await page.waitForFunction(() => window.__asteroidsNewEngine?.scene?.world?.asteroids?.length > 0);
+}
+
+test("uses weighted active asteroid objects for beat cadence", async ({ page }) => {
+  const server = await startRepoServer();
+  const pageErrors = [];
+
+  page.on("pageerror", (error) => {
+    pageErrors.push(error.message);
+  });
+
+  await coverageReporter.start(page);
+  try {
+    await page.goto(`${server.baseUrl}/games/Asteroids/index.html`, { waitUntil: "networkidle" });
+    await waitForAsteroidsBoot(page);
+
+    const timing = await page.evaluate(() => {
+      const scene = window.__asteroidsNewEngine.scene;
+      const createAsteroids = (count, size) => Array.from({ length: count }, () => ({ size }));
+      const inactiveAsteroids = [
+        { active: false, size: 3 },
+        { alive: false, size: 2 },
+        { destroyed: true, size: 1 },
+      ];
+
+      scene.world.asteroids = [...createAsteroids(8, 3), ...inactiveAsteroids];
+      scene.resetBeatCadenceBaseline();
+      const largeAsteroids = scene.resolveAsteroidsBeatTiming();
+
+      scene.world.asteroids = [...createAsteroids(16, 2), ...inactiveAsteroids];
+      const mediumAsteroids = scene.resolveAsteroidsBeatTiming();
+
+      scene.world.asteroids = [...createAsteroids(32, 1), ...inactiveAsteroids];
+      const smallAsteroids = scene.resolveAsteroidsBeatTiming();
+
+      scene.world.asteroids = inactiveAsteroids;
+      const noActiveAsteroids = scene.resolveAsteroidsBeatTiming();
+
+      return {
+        largeAsteroids,
+        mediumAsteroids,
+        noActiveAsteroids,
+        smallAsteroids,
+      };
+    });
+
+    expect(timing.largeAsteroids.weightedTotal).toBe(72);
+    expect(timing.mediumAsteroids.weightedTotal).toBe(64);
+    expect(timing.smallAsteroids.weightedTotal).toBe(32);
+    expect(timing.noActiveAsteroids.weightedTotal).toBe(0);
+    expect(timing.largeAsteroids.intervalSeconds).toBeCloseTo(0.98, 5);
+    expect(timing.noActiveAsteroids.intervalSeconds).toBeCloseTo(0.18, 5);
+    expect(timing.largeAsteroids.intervalSeconds).toBeGreaterThan(timing.mediumAsteroids.intervalSeconds);
+    expect(timing.mediumAsteroids.intervalSeconds).toBeGreaterThan(timing.smallAsteroids.intervalSeconds);
+    expect(timing.smallAsteroids.intervalSeconds).toBeGreaterThan(timing.noActiveAsteroids.intervalSeconds);
+    expect(pageErrors).toEqual([]);
+  } finally {
+    await coverageReporter.stop(page);
+    await server.close();
+  }
+});