From a8acf66b0bcb34e7553374b658676e4924fc1fab Mon Sep 17 00:00:00 2001 From: djblackett <49618491+djblackett@users.noreply.github.com> Date: Mon, 2 Nov 2026 03:02:12 -0400 Subject: [PATCH 01/10] feat(android): implement Android app using Capacitor with native features - Added support for fullscreen detection and handling in the Android app. - Implemented app update prompts for outdated versions in the Android app. - Configured production API URL for the Android app in a new .env.android file. - Created documentation for building and testing the Android app. - Developed build script for the Android app to ensure proper configuration and assets. - Added tests for Android-specific functionality and configurations. - Integrated native back button handling and lifecycle management for the Android app. - Ensured system bars are hidden and safe areas are respected in the Android app. --- docs/leaderboard-backend.md | 4 +- docs/release-preflight.md | 2 +- phaser-asteroids/.env.android | 6 + phaser-asteroids/.gitignore | 1 + .../android/app/capacitor.build.gradle | 2 +- .../android/app/src/main/AndroidManifest.xml | 3 + .../davidandrea/spacearcade/MainActivity.java | 16 +- .../app/src/main/res/values/styles.xml | 3 + .../android/capacitor.settings.gradle | 3 + phaser-asteroids/capacitor.config.ts | 23 ++- phaser-asteroids/docs/android.md | 118 ++++++++++++ phaser-asteroids/docs/deployment.md | 4 + phaser-asteroids/index.html | 6 +- phaser-asteroids/package-lock.json | 10 + phaser-asteroids/package.json | 4 + phaser-asteroids/scripts/build-android.mjs | 127 +++++++++++++ .../scripts/build-android.test.mjs | 74 ++++++++ phaser-asteroids/server/wrangler.toml | 3 +- phaser-asteroids/src/input/fullscreen.ts | 9 +- phaser-asteroids/src/input/gameTouch.ts | 3 +- phaser-asteroids/src/main.ts | 4 + .../src/platform/capacitorBindings.ts | 21 +++ phaser-asteroids/src/platform/nativeApp.ts | 89 +++++++++ phaser-asteroids/src/platform/nativeBack.ts | 51 ++++++ phaser-asteroids/src/ranked/api.ts | 12 +- phaser-asteroids/src/scenes/GameScene.ts | 8 + phaser-asteroids/src/scenes/StartScene.ts | 9 +- phaser-asteroids/src/ui/menu/pages/ranked.ts | 10 +- phaser-asteroids/src/ui/touch.css | 14 +- phaser-asteroids/tests/androidRelease.test.ts | 58 ++++++ phaser-asteroids/tests/fullscreen.test.ts | 8 + phaser-asteroids/tests/mobileEntry.test.ts | 6 + phaser-asteroids/tests/nativeApp.test.ts | 171 ++++++++++++++++++ phaser-asteroids/tests/ranked.test.ts | 6 + 34 files changed, 862 insertions(+), 26 deletions(-) create mode 100644 phaser-asteroids/.env.android create mode 100644 phaser-asteroids/docs/android.md create mode 100644 phaser-asteroids/scripts/build-android.mjs create mode 100644 phaser-asteroids/scripts/build-android.test.mjs create mode 100644 phaser-asteroids/src/platform/capacitorBindings.ts create mode 100644 phaser-asteroids/src/platform/nativeApp.ts create mode 100644 phaser-asteroids/src/platform/nativeBack.ts create mode 100644 phaser-asteroids/tests/androidRelease.test.ts create mode 100644 phaser-asteroids/tests/nativeApp.test.ts diff --git a/docs/leaderboard-backend.md b/docs/leaderboard-backend.md index 64ac46d..e283a1b 100644 --- a/docs/leaderboard-backend.md +++ b/docs/leaderboard-backend.md @@ -374,7 +374,7 @@ Nothing above is a test against production Cloudflare infrastructure. The existing Cloudflare account is `620de0810a6cf29710d9fedb3a966d6f`. Production D1 `asteroids-leaderboard` is `cf4833f7-5fc9-45ca-a767-750df108f1e9` (ENAM). These identifiers are public configuration, not credentials. The `DB` binding in `env.production` points to this database; `0001_init.sql` and `0002_time_limit.sql` are applied remotely. Immediately before the approved deployment, Cloudflare confirmed that the Worker did not exist, so no existing Worker was overwritten. -Production retains the 5,000 ms CPU cap, daily `17 7 * * *` UTC housekeeping, 20-minute ranked limit and `https://djblackett.github.io` CORS origin (origins have no repository path). Both secrets are declared required for production deployments. The API uses HTTPS on `workers.dev`; version preview URLs are disabled. GitHub Pages continues to host the game. The default D1 placeholder, local origins, `dev:lan`, `migrate:lan`, LAN proxy and `.wrangler/state-lan` remain separate from production. +Production retains the 5,000 ms CPU cap, daily `17 7 * * *` UTC housekeeping, 20-minute ranked limit and the `https://djblackett.github.io` and `https://spacearcade.davidandrea.ca` (Android app, see `phaser-asteroids/docs/android.md`) CORS origins (origins have no repository path). Both secrets are declared required for production deployments. The API uses HTTPS on `workers.dev`; version preview URLs are disabled. GitHub Pages continues to host the game. The default D1 placeholder, local origins, `dev:lan`, `migrate:lan`, LAN proxy and `.wrangler/state-lan` remain separate from production. Preparation validation passed: frontend and backend typechecks, frontend production build, all 127 backend unit tests, all 32 real local Worker/D1 integration checks, production deployment dry-run with both secret bindings, and the existing LAN Chromium smoke test (ranked game, accepted replay, both boards and persistence after reload). The dry-run artifacts contain neither secret and no temporary plaintext upload file remains. @@ -442,7 +442,7 @@ coordinated workflow above. The following records initial provisioning for a new 1. `cd phaser-asteroids/server && npx wrangler login` and upgrade the account to **Workers Paid** in the dashboard (US$5/month). 2. `npx wrangler d1 create asteroids-leaderboard` — paste the printed `database_id` into `[env.production]` in `wrangler.toml`. -3. Set `ALLOWED_ORIGINS` in `[env.production.vars]` (default `https://djblackett.github.io`; include a custom domain if used). +3. Set `ALLOWED_ORIGINS` in `[env.production.vars]` (default `https://djblackett.github.io,https://spacearcade.davidandrea.ca`, the second being the Android app's origin; include a custom domain if used). 4. `npx wrangler d1 migrations apply asteroids-leaderboard --env production --remote` 5. Prepare `IP_HASH_SALT` and `ADMIN_TOKEN` securely as above. Obtain approval before any command that publishes the Worker, including `secret put`. 6. First deployment: use the helper's `Deploy` action above (or `npx wrangler deploy --env production --secrets-file `). Later code-only deployments preserve existing secrets. Note the `*.workers.dev` URL (or attach a custom domain). diff --git a/docs/release-preflight.md b/docs/release-preflight.md index eac24fb..1a6e059 100644 --- a/docs/release-preflight.md +++ b/docs/release-preflight.md @@ -138,7 +138,7 @@ Everything in this section is **for the owner to perform later; none was execute 1. Have a Cloudflare account with **Workers Paid**, permission to create D1, deploy Workers and set secrets; a Workers subdomain or intended custom domain; and permission to set the GitHub Pages build configuration. Workers Paid currently has a $5 USD/month minimum; review usage charges. [Cloudflare pricing](https://developers.cloudflare.com/workers/platform/pricing/) 2. Use the pinned lockfiles with Node 22.14+ compatible tooling. From `phaser-asteroids/`, `npm ci`; from `server/`, `npm ci`. Authenticate with `npx wrangler login` only when ready to configure the account. Do not copy test secrets into production. 3. From `server/`, `npx wrangler d1 create asteroids-leaderboard`; put its returned ID in **`[[env.production.d1_databases]]`**, keeping `binding = "DB"` and `migrations_dir = "migrations"`. The top-level zero ID is only a local placeholder; it does not configure production. -4. In `[env.production.vars]`, set exact HTTPS browser origins, comma-separated, without a path: `https://djblackett.github.io` plus any actual custom frontend origin. Keep local origins in the local configuration only. Leave `RANKED_TIME_LIMIT_SECONDS` unset (1,200 s), TTL default 3,600 s and the reviewed rate limits unless intentionally changed. Keep `cpu_ms = 5000` and the cleanup cron in production. +4. In `[env.production.vars]`, set exact HTTPS browser origins, comma-separated, without a path: `https://djblackett.github.io`, `https://spacearcade.davidandrea.ca` (the Android app; `server.hostname` in `phaser-asteroids/capacitor.config.ts`), plus any actual custom frontend origin. Keep local origins in the local configuration only. Leave `RANKED_TIME_LIMIT_SECONDS` unset (1,200 s), TTL default 3,600 s and the reviewed rate limits unless intentionally changed. Keep `cpu_ms = 5000` and the cleanup cron in production. 5. Set a long random `IP_HASH_SALT` with `npx wrangler secret put IP_HASH_SALT --env production`. For usable moderation, also set a separate random `ADMIN_TOKEN` of at least 16 characters with `npx wrangler secret put ADMIN_TOKEN --env production`. Store these securely outside the frontend/repository; no Cloudflare API credential is needed in browser code. 6. Inspect `npx wrangler d1 migrations list asteroids-leaderboard --env production --remote`, then apply with `npx wrangler d1 migrations apply asteroids-leaderboard --env production --remote`. Confirm **both 0001_init.sql and 0002_time_limit.sql** applied, including `runs.time_limit_ticks` and `scores.end_reason`. Apply schema **before** the new Worker. [D1 migrations](https://developers.cloudflare.com/d1/reference/migrations/) 7. Deploy the Worker with the production environment only when authorized, then check health, allowed/denied-origin preflights and one controlled issued-challenge/accepted-score flow. Health is liveness/configuration only; it does not query D1, so it cannot prove migrations or the binding work. diff --git a/phaser-asteroids/.env.android b/phaser-asteroids/.env.android new file mode 100644 index 0000000..5171e82 --- /dev/null +++ b/phaser-asteroids/.env.android @@ -0,0 +1,6 @@ +# Loaded ONLY by `vite build --mode android` (npm run build:android). Browser builds and GitHub Pages never read this file. +# +# The Android app talks to the production leaderboard Worker, always. scripts/build-android.mjs refuses to build if this is missing, +# not https, a loopback / private address, or contradicted by a different VITE_LEADERBOARD_API_URL in the shell environment, and +# checks afterwards that this exact origin is in the bundle. Public value (it ships inside every web build anyway). +VITE_LEADERBOARD_API_URL=https://asteroids-leaderboard.davejandrea.workers.dev diff --git a/phaser-asteroids/.gitignore b/phaser-asteroids/.gitignore index 9f93ef2..e64ab84 100644 --- a/phaser-asteroids/.gitignore +++ b/phaser-asteroids/.gitignore @@ -1,5 +1,6 @@ node_modules/ dist/ +dist-android/ *.log scripts/.smoke-output/ .node/ diff --git a/phaser-asteroids/android/app/capacitor.build.gradle b/phaser-asteroids/android/app/capacitor.build.gradle index bbfb44f..1005ebc 100644 --- a/phaser-asteroids/android/app/capacitor.build.gradle +++ b/phaser-asteroids/android/app/capacitor.build.gradle @@ -9,7 +9,7 @@ android { apply from: "../capacitor-cordova-android-plugins/cordova.variables.gradle" dependencies { - + implementation project(':capacitor-app') } diff --git a/phaser-asteroids/android/app/src/main/AndroidManifest.xml b/phaser-asteroids/android/app/src/main/AndroidManifest.xml index b06ddbf..228948e 100644 --- a/phaser-asteroids/android/app/src/main/AndroidManifest.xml +++ b/phaser-asteroids/android/app/src/main/AndroidManifest.xml @@ -15,6 +15,7 @@ android:label="@string/title_activity_main" android:theme="@style/AppTheme.NoActionBarLaunch" android:launchMode="singleTask" + android:screenOrientation="sensorLandscape" android:exported="true"> @@ -38,4 +39,6 @@ + + diff --git a/phaser-asteroids/android/app/src/main/java/ca/davidandrea/spacearcade/MainActivity.java b/phaser-asteroids/android/app/src/main/java/ca/davidandrea/spacearcade/MainActivity.java index b7f24a3..cfb0b71 100644 --- a/phaser-asteroids/android/app/src/main/java/ca/davidandrea/spacearcade/MainActivity.java +++ b/phaser-asteroids/android/app/src/main/java/ca/davidandrea/spacearcade/MainActivity.java @@ -1,5 +1,19 @@ package ca.davidandrea.spacearcade; +import android.os.Bundle; +import androidx.core.view.WindowCompat; +import androidx.core.view.WindowInsetsControllerCompat; import com.getcapacitor.BridgeActivity; -public class MainActivity extends BridgeActivity {} +public class MainActivity extends BridgeActivity { + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + // Capacitor's SystemBars plugin hides the bars (capacitor.config.ts) but has no option for how they come back. Without this a + // swipe from the edge mid-game brings them back for good and shrinks the playfield; with it they slide in over the game and + // hide again by themselves (the usual "immersive" behaviour for games). + WindowInsetsControllerCompat controller = WindowCompat.getInsetsController(getWindow(), getWindow().getDecorView()); + controller.setSystemBarsBehavior(WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE); + } +} diff --git a/phaser-asteroids/android/app/src/main/res/values/styles.xml b/phaser-asteroids/android/app/src/main/res/values/styles.xml index be874e5..2d19527 100644 --- a/phaser-asteroids/android/app/src/main/res/values/styles.xml +++ b/phaser-asteroids/android/app/src/main/res/values/styles.xml @@ -13,6 +13,9 @@ false true @null + + @android:color/black diff --git a/phaser-asteroids/android/capacitor.settings.gradle b/phaser-asteroids/android/capacitor.settings.gradle index 9a5fa87..2085c86 100644 --- a/phaser-asteroids/android/capacitor.settings.gradle +++ b/phaser-asteroids/android/capacitor.settings.gradle @@ -1,3 +1,6 @@ // DO NOT EDIT THIS FILE! IT IS GENERATED EACH TIME "capacitor update" IS RUN include ':capacitor-android' project(':capacitor-android').projectDir = new File('../node_modules/@capacitor/android/capacitor') + +include ':capacitor-app' +project(':capacitor-app').projectDir = new File('../node_modules/@capacitor/app/android') diff --git a/phaser-asteroids/capacitor.config.ts b/phaser-asteroids/capacitor.config.ts index 7d9870d..29c9132 100644 --- a/phaser-asteroids/capacitor.config.ts +++ b/phaser-asteroids/capacitor.config.ts @@ -1,9 +1,30 @@ import type { CapacitorConfig } from '@capacitor/cli'; +/** + * The Android app (see docs/android.md). The web game inside it is the normal build, made by `npm run build:android` into its own + * folder: the server-only replay verifier in dist/node is never packaged, and the production leaderboard URL is required. + */ const config: CapacitorConfig = { appId: 'ca.davidandrea.spacearcade', appName: 'phaser-asteroids', - webDir: 'dist' + webDir: 'dist-android', + server: { + // The app's page is https://spacearcade.davidandrea.ca/ (served from the APK, never fetched from the internet). This is the Origin the + // leaderboard Worker sees, so it is listed in ALLOWED_ORIGINS (server/wrangler.toml). It is not `localhost`, so the game never + // treats the app as a development machine (src/ranked/api.ts). Changing it later would also lose saved settings and local scores, + // because localStorage belongs to the origin. + hostname: 'spacearcade.davidandrea.ca', + androidScheme: 'https', + }, + plugins: { + // Capacitor 8's built-in system bars: hidden for the whole session (the game is landscape and fullscreen), light icons when the + // user swipes them in, and the real safe-area insets written to the page as --safe-area-inset-* (index.html, src/ui/touch.css). + SystemBars: { + hidden: true, + style: 'DARK', + insetsHandling: 'css', + }, + }, }; export default config; diff --git a/phaser-asteroids/docs/android.md b/phaser-asteroids/docs/android.md new file mode 100644 index 0000000..96424d4 --- /dev/null +++ b/phaser-asteroids/docs/android.md @@ -0,0 +1,118 @@ +# Android app (Capacitor) + +The Android app is the unchanged web game inside Capacitor 8. All native behaviour goes through a few small seams. +Browsers and GitHub Pages never take any of these paths. + +Status: implemented and unit/browser tested on the desktop. **Not yet tried on a phone**: see the +[device checklist](#device-checklist). Nothing has been deployed or published. + +## Building + +```bash +cd phaser-asteroids +npm run build:android # typecheck, build the web game into dist-android/, verify it +npm run android:sync # the above, then `cap sync android` (copies dist-android/ and plugins into android/) +cd android && ./gradlew assembleDebug # JDK 21 is pinned in android/gradle.properties +``` + +`npm run build:android` is separate from `npm run build` (GitHub Pages), and differs in two ways: + +1. **Only the browser game is built.** The ~8 MB server-only replay verifier (`dist/node`) used to be copied into the APK. + The web payload is now ~10 MB instead of ~19 MB. +2. **The leaderboard URL is fixed and checked.** It comes from [`.env.android`](../.env.android), which is loaded only by + `vite build --mode android`. [`scripts/build-android.mjs`](../scripts/build-android.mjs) stops the build in these cases: + - the URL is missing; + - it is not `https`; + - it is a loopback or private address; + - it has a path or a port; + - a different `VITE_LEADERBOARD_API_URL` is set in the shell. + + After building, the script checks that the exact production origin appears in the bundle and that there is no `node/` folder. + `node scripts/build-android.mjs --verify-only` re-checks an existing build. + +At runtime, [`resolveApiBase`](../src/ranked/api.ts) ignores `?api=` and the `wrangler dev` fallback whenever the page runs inside +the app. So an installed app can only reach the configured production Worker, or report "not available". + +Release items not done yet: the app name (still `phaser-asteroids`), `versionCode` / `versionName`, release signing, an AAB build, +and the launcher icon and splash artwork. + +## How each concern is handled + +| Concern | Where | What | +|---|---|---| +| App origin | [`capacitor.config.ts`](../capacitor.config.ts) | `server.hostname = spacearcade.davidandrea.ca`, `androidScheme = https`. The page origin (and the `Origin` header the Worker sees) is `https://spacearcade.davidandrea.ca`. Nothing is fetched from that domain: Capacitor serves the bundled files under that name. It is not `localhost`, so development-only rules never apply. **Do not change it after release**: `localStorage` (settings, nickname, local scores) belongs to the origin. | +| CORS | [`server/wrangler.toml`](../server/wrangler.toml) | Production `ALLOWED_ORIGINS` now also lists `https://spacearcade.davidandrea.ca`. **This only takes effect after the Worker is deployed.** Merging to `main` deploys it through CI. Until then ranked play and the boards in the app fail with `origin_not_allowed`, and practice still works. | +| Android Back | [`src/platform/nativeBack.ts`](../src/platform/nativeBack.ts), [`nativeApp.ts`](../src/platform/nativeApp.ts) | `@capacitor/app`'s `backButton` event goes to the handler the current scene registered, which uses the same logic as Escape. **Title menu:** `MenuController.back()` closes the open page; on the root page the app is minimized. **A run:** `GameScene.goBack()` pauses, closes a pause page, resumes, or leaves a finished run. Back never leaves the app from a run in progress, and never throws away an unsubmitted ranked score. | +| Pause / resume | `nativeApp.ts` | The app's `pause` / `resume` events are replayed as window `blur` / `focus`, which the existing listeners already handle. The run auto-pauses, music falls silent, held keys and touches are released, controllers go neutral, and vibration stops. WebView usually fires these itself; the native events are a backup. On resume the system bars are hidden again. | +| Fullscreen | `capacitor.config.ts` (`SystemBars.hidden`), [`MainActivity.java`](../android/app/src/main/java/ca/davidandrea/spacearcade/MainActivity.java), [`fullscreen.ts`](../src/input/fullscreen.ts) | Capacitor 8's built-in SystemBars plugin hides the status and navigation bars. One native line sets "transient bars by swipe", which SystemBars has no option for: an edge swipe shows the bars over the game for a moment instead of bringing them back for good. The in-game FULLSCREEN button is hidden in the app, because Capacitor's WebView immediately ends Fullscreen API requests. | +| Safe areas | [`index.html`](../index.html), [`src/ui/touch.css`](../src/ui/touch.css) | Every inset reads `var(--safe-area-inset-X, env(safe-area-inset-X, 0px))`. SystemBars writes the variables with the real insets. Browsers never set them, so `env()` applies as before. The theme's window background is black, so any inset band around a camera cutout is black, not white. | +| Orientation | [`AndroidManifest.xml`](../android/app/src/main/AndroidManifest.xml) | `screenOrientation="sensorLandscape"`. Android 16 ignores orientation locks on large screens (600 dp wide or more), so the game's own rotate prompt and auto-pause remain the fallback. | +| Vibration | `AndroidManifest.xml` | `android.permission.VIBRATE` (no prompt). Without it WebView silently ignores `navigator.vibrate`. | +| Audio | (unchanged) | Capacitor allows media without a user gesture. Music and effects use the existing Phaser and lifecycle code. | +| Offline | (unchanged) | Every asset is in the APK. Practice needs no network, and ranked / scores fail cleanly offline. | + +Tests: [`tests/nativeApp.test.ts`](../tests/nativeApp.test.ts) (Back routing, lifecycle, plugin failures), +[`tests/androidRelease.test.ts`](../tests/androidRelease.test.ts) (the four config files agree), the native cases in +`tests/ranked.test.ts`, `tests/fullscreen.test.ts` and `tests/mobileEntry.test.ts`, and +[`scripts/build-android.test.mjs`](../scripts/build-android.test.mjs) (`npm run test:android-build`). + +## Risk: Worker rule changes break installed apps + +The Worker supports **one** gameplay rules version at a time. It is `GAMEPLAY_RULES_VERSION`, compiled in from `src/replay` at +deploy time. A ranked client refuses a challenge for any other version (`update_required`), and the Worker rejects a run issued +under older rules (`rules_mismatch`). The Worker deploys automatically on every qualifying merge to `main`. + +On the web this costs nothing: the page reloads into the new build. An installed Android app keeps its bundled game until the +player installs an update from the store. That can mean days of review, or never for players who don't update. So: + +- **Any change to `GAMEPLAY_RULES_VERSION` (or the replay schema) disables ranked play in every installed app at the moment the + Worker deploys.** The app then shows "RANKED PLAY NEEDS A NEWER VERSION OF THE APP. UPDATE THE APP, OR PLAY PRACTICE." Practice is + unaffected. +- A run in progress when the Worker deploys is rejected on submit. +- Releasing a new APK first does not help: it would be refused by the old Worker in the same way. + +### Until a better strategy exists + +- Treat a rules-version bump as a coordinated release. Prepare the Android build with the same rules, deploy the Worker, then + publish the app update at once. Accept a window in which older apps cannot play ranked. +- Keep rule changes rare and batched. Purely visual, audio and menu changes don't need a rules bump (see `SCORING_ERAS` + in `src/ranked/scoringEras.ts`). + +### Recommended longer-term strategy + +1. **Accept several rules versions at once.** + - `POST /api/v1/runs` sends the client's `rulesVersion` and `schemaVersion`. + - The Worker issues a challenge for any version in a configured `SUPPORTED_RULES_VERSIONS` list and records it on the run, as it + already does. + - It verifies the run with the matching simulator. Older versions of `src/replay` + `src/core` would be kept as frozen, + versioned modules inside the Worker. The verifier is already deterministic and self-contained, so this is mostly a packaging + change. + - Boards are already separated by scoring era, so scores never mix incompatible rules. +2. **Give old versions a deprecation window, not a cliff.** + - Add `minSupportedRulesVersion` and `latestRulesVersion` to `/api/v1/health` and the challenge response. + - The client shows a soft "update available" notice while its version is still supported, and the hard block only after the + window ends (for example 30-60 days). +3. **Gate it in CI.** Add a check that fails when `GAMEPLAY_RULES_VERSION` changes and the previous version is dropped from + `SUPPORTED_RULES_VERSIONS` without an explicit flag. +4. Not recommended: + - Loading the game from the web (`server.url`): offline practice would stop working, and Play policy questions follow. + - Over-the-air bundle updates: extra infrastructure, and they don't remove the need for (1) when an update fails. + +## Device checklist + +Use a phone, plus a tablet or foldable for orientation. Use `chrome://inspect` on the PC for the WebView console and network. + +| # | Check | Expected | +|---|---|---| +| 1 | Cold start | Landscape, no status or navigation bar, no FULLSCREEN button on the title or pause screens, music starts. | +| 2 | Swipe from a screen edge mid-run | The bars appear over the game and hide again by themselves; the playfield does not resize. With gesture navigation, check how many swipes a Back gesture takes. | +| 3 | Back: playing → pause page → pause root → game over → title sub-page → title root | Pause, close page, resume, title, close page, app goes to the background. Back during a ranked run's result page never discards the score. | +| 4 | Home, recent apps, a phone call, the screen turned off mid-run | The game is paused on return, music is silent while away, no stuck controls, bars still hidden. | +| 5 | Notch or punch-hole camera, in both landscape directions | Touch controls and HUD clear the cutout; the band is black. | +| 6 | Portrait on a large screen (orientation lock ignored) | Rotate prompt, run paused. | +| 7 | HAPTICS ON → TEST VIBRATION, then boost / laser / damage in a run | Felt. Also try with Samsung Silent mode. | +| 8 | Ranked end to end (after the Worker with the new `ALLOWED_ORIGINS` is deployed) | Challenge issued, run verified, rank shown. Turn on airplane mode during upload: retry works with the same submission. | +| 9 | Airplane mode from a cold start | Practice plays; RANKED and SCORES say unavailable, without a crash. | +| 10 | Nickname entry on the result page | The keyboard does not cover the field; Back with the keyboard open only closes the keyboard. | +| 11 | Bluetooth controller and keyboard | Work as in the browser. | +| 12 | 10-minute session | Smooth at 90/120 Hz, no unusual battery drain or heat. | diff --git a/phaser-asteroids/docs/deployment.md b/phaser-asteroids/docs/deployment.md index 3dd780c..a797bbb 100644 --- a/phaser-asteroids/docs/deployment.md +++ b/phaser-asteroids/docs/deployment.md @@ -5,6 +5,10 @@ for ranked play. GitHub Actions validates both, deploys and checks the Worker, t **URL:** +The Android app is built separately (`npm run build:android`) and talks to the same Worker. **A Worker deploy that changes +`GAMEPLAY_RULES_VERSION` turns off ranked play in every installed Android app until players update it.** See +[android.md](android.md#risk-worker-rule-changes-break-installed-apps). + The Pages site is exactly the contents of `phaser-asteroids/dist/`. The original Python/Pygame game stays in the repository root as source code but is no longer built or published (its pygbag web build was retired when Phaser became the primary game; `BUILD_WEB.md` and `pygbag` still work locally if you want it). diff --git a/phaser-asteroids/index.html b/phaser-asteroids/index.html index 1798df2..b6d88d0 100644 --- a/phaser-asteroids/index.html +++ b/phaser-asteroids/index.html @@ -8,8 +8,10 @@ diff --git a/phaser-asteroids/package-lock.json b/phaser-asteroids/package-lock.json index 174e058..4e14269 100644 --- a/phaser-asteroids/package-lock.json +++ b/phaser-asteroids/package-lock.json @@ -9,6 +9,7 @@ "version": "0.1.0", "dependencies": { "@capacitor/android": "^8.6.0", + "@capacitor/app": "^8.1.2", "@capacitor/core": "^8.6.0", "phaser": "4.2.1" }, @@ -29,6 +30,15 @@ "@capacitor/core": "^8.6.0" } }, + "node_modules/@capacitor/app": { + "version": "8.1.2", + "resolved": "https://registry.npmjs.org/@capacitor/app/-/app-8.1.2.tgz", + "integrity": "sha512-uKBlsrXH0IdvUn69e/KKYbZ32A06pcrUdG8LWuZ/6y33YMXZXLEEdNSwl+jKS/SrsTWqnePs8EqSWaiQM3mUGA==", + "license": "MIT", + "peerDependencies": { + "@capacitor/core": ">=8.0.0" + } + }, "node_modules/@capacitor/cli": { "version": "8.6.0", "resolved": "https://registry.npmjs.org/@capacitor/cli/-/cli-8.6.0.tgz", diff --git a/phaser-asteroids/package.json b/phaser-asteroids/package.json index 47d3a2a..cccac37 100644 --- a/phaser-asteroids/package.json +++ b/phaser-asteroids/package.json @@ -7,6 +7,9 @@ "dev": "vite", "dev:lan": "vite --config vite.lan.config.ts", "build": "tsc --noEmit && vite build && vite build --outDir dist/node --target node20 --ssr src/replay/index.ts", + "build:android": "tsc --noEmit && node scripts/build-android.mjs", + "android:sync": "npm run build:android && cap sync android", + "test:android-build": "node --test scripts/build-android.test.mjs", "preview": "vite preview", "preview:lan": "vite preview --host", "typecheck": "tsc --noEmit", @@ -33,6 +36,7 @@ }, "dependencies": { "@capacitor/android": "^8.6.0", + "@capacitor/app": "^8.1.2", "@capacitor/core": "^8.6.0", "phaser": "4.2.1" }, diff --git a/phaser-asteroids/scripts/build-android.mjs b/phaser-asteroids/scripts/build-android.mjs new file mode 100644 index 0000000..c225619 --- /dev/null +++ b/phaser-asteroids/scripts/build-android.mjs @@ -0,0 +1,127 @@ +// Builds the web game for the Android app (capacitor.config.ts `webDir`) and checks the result before Capacitor can package it. +// +// npm run build:android typecheck + build into dist-android/ + verify +// npm run android:sync the above, then `cap sync android` (copies dist-android/ into the Android project) +// node scripts/build-android.mjs --verify-only check an existing dist-android/ without rebuilding +// +// Different from `npm run build` (GitHub Pages) in exactly two ways: +// 1. Only the browser game is built. The server-only replay verifier (dist/node, ~8 MB) is never in the app. +// 2. The leaderboard URL comes from .env.android and is required: the build stops if it is missing, not https, a loopback or private +// address, or if the shell has a different VITE_LEADERBOARD_API_URL. Afterwards the bundle must contain that exact origin. An +// installed app can therefore never fall back to a development endpoint (see also resolveApiBase in src/ranked/api.ts). + +import { spawnSync } from 'node:child_process'; +import fs from 'node:fs'; +import path from 'node:path'; +import { fileURLToPath, pathToFileURL } from 'node:url'; + +const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..'); +export const ANDROID_OUT_DIR = 'dist-android'; +export const ANDROID_ENV_FILE = '.env.android'; +export const API_KEY = 'VITE_LEADERBOARD_API_URL'; + +/** The `KEY=value` lines of a dotenv file (comments and blank lines ignored, optional quotes removed). */ +export function parseEnvFile(text) { + const out = new Map(); + for (const raw of text.split(/\r?\n/)) { + const line = raw.trim(); + if (!line || line.startsWith('#')) continue; + const eq = line.indexOf('='); + if (eq <= 0) continue; + const key = line.slice(0, eq).trim(); + const value = line.slice(eq + 1).trim().replace(/^(['"])(.*)\1$/, '$2'); + out.set(key, value); + } + return out; +} + +function isPrivateOrLocalHost(hostname) { + const h = hostname.toLowerCase().replace(/^\[|\]$/g, ''); + if (h === 'localhost' || h.endsWith('.localhost') || h.endsWith('.local') || h.endsWith('.internal')) return true; + if (h === '::1' || h === '::' || h.startsWith('fc') || h.startsWith('fd') || h.startsWith('fe80')) return true; + const v4 = h.match(/^(\d+)\.(\d+)\.(\d+)\.(\d+)$/); + if (!v4) return false; + const [a, b] = [Number(v4[1]), Number(v4[2])]; + return a === 0 || a === 10 || a === 127 || (a === 169 && b === 254) || (a === 172 && b >= 16 && b <= 31) || (a === 192 && b === 168); +} + +/** + * The production API origin the app may use, or an Error explaining why `value` is not one. Only a bare https origin is accepted + * (no path, query, credentials or port), so what is baked in is exactly what the server's health check and CORS rules describe. + */ +export function checkProductionApiUrl(value) { + if (!value) return new Error(`${API_KEY} is not set in ${ANDROID_ENV_FILE}`); + let url; + try { + url = new URL(value); + } catch { + return new Error(`${API_KEY} is not a URL: ${value}`); + } + if (url.protocol !== 'https:') return new Error(`${API_KEY} must be https: ${value}`); + if (url.username || url.password) return new Error(`${API_KEY} must not contain credentials`); + if (url.port) return new Error(`${API_KEY} must not name a port: ${value}`); + if (isPrivateOrLocalHost(url.hostname)) return new Error(`${API_KEY} points at a local or private address: ${value}`); + if ((url.pathname !== '/' && url.pathname !== '') || url.search || url.hash) { + return new Error(`${API_KEY} must be a bare origin (no path such as /api/v1): ${value}`); + } + return url.origin; +} + +/** Problems with a finished Android build in `dir` (empty: fine). */ +export function verifyAndroidBuild(dir, apiOrigin) { + const problems = []; + if (!fs.existsSync(path.join(dir, 'index.html'))) problems.push(`${dir}/index.html is missing`); + if (fs.existsSync(path.join(dir, 'node'))) problems.push(`${dir}/node exists: the server-only replay verifier must not be packaged`); + const assets = path.join(dir, 'assets'); + const scripts = fs.existsSync(assets) ? fs.readdirSync(assets).filter((f) => f.endsWith('.js')) : []; + if (scripts.length === 0) problems.push(`${dir}/assets has no scripts`); + const containsApi = scripts.some((f) => fs.readFileSync(path.join(assets, f), 'utf8').includes(apiOrigin)); + if (scripts.length > 0 && !containsApi) problems.push(`no script in ${dir}/assets contains the production API origin ${apiOrigin}`); + return problems; +} + +/** Reads and checks the API origin from .env.android against the shell environment. Throws with a clear message. */ +export function resolveAndroidApiOrigin(envFileText, shellValue) { + const fromFile = parseEnvFile(envFileText).get(API_KEY); + const origin = checkProductionApiUrl(fromFile); + if (origin instanceof Error) throw origin; + if (shellValue !== undefined && shellValue !== '') { + const shell = checkProductionApiUrl(shellValue); + if (shell instanceof Error || shell !== origin) { + throw new Error(`${API_KEY} in the environment (${shellValue}) disagrees with ${ANDROID_ENV_FILE} (${origin}); unset it or change the file`); + } + } + return origin; +} + +function main() { + const verifyOnly = process.argv.includes('--verify-only'); + const envPath = path.join(root, ANDROID_ENV_FILE); + if (!fs.existsSync(envPath)) throw new Error(`${ANDROID_ENV_FILE} is missing`); + const origin = resolveAndroidApiOrigin(fs.readFileSync(envPath, 'utf8'), process.env[API_KEY]); + const outDir = path.join(root, ANDROID_OUT_DIR); + + if (!verifyOnly) { + console.log(`[build:android] API ${origin} -> ${ANDROID_OUT_DIR}/`); + const vite = path.join(root, 'node_modules', 'vite', 'bin', 'vite.js'); + const result = spawnSync(process.execPath, [vite, 'build', '--mode', 'android', '--outDir', ANDROID_OUT_DIR, '--emptyOutDir'], { + cwd: root, + stdio: 'inherit', + env: { ...process.env, [API_KEY]: origin }, + }); + if (result.status !== 0) throw new Error(`vite build failed (exit ${result.status ?? result.signal})`); + } + + const problems = verifyAndroidBuild(outDir, origin); + if (problems.length > 0) throw new Error(`Android build check failed:\n - ${problems.join('\n - ')}`); + console.log(`[build:android] OK: ${ANDROID_OUT_DIR}/ uses ${origin} and has no server-only files`); +} + +if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) { + try { + main(); + } catch (e) { + console.error(`[build:android] ${e instanceof Error ? e.message : e}`); + process.exit(1); + } +} diff --git a/phaser-asteroids/scripts/build-android.test.mjs b/phaser-asteroids/scripts/build-android.test.mjs new file mode 100644 index 0000000..a4bdea5 --- /dev/null +++ b/phaser-asteroids/scripts/build-android.test.mjs @@ -0,0 +1,74 @@ +// node --test scripts/build-android.test.mjs (npm run test:android-build) +import assert from 'node:assert/strict'; +import fs from 'node:fs'; +import os from 'node:os'; +import path from 'node:path'; +import test from 'node:test'; +import { checkProductionApiUrl, parseEnvFile, resolveAndroidApiOrigin, verifyAndroidBuild } from './build-android.mjs'; + +const PROD = 'https://asteroids-leaderboard.davejandrea.workers.dev'; +const envText = `# comment\n\nVITE_LEADERBOARD_API_URL=${PROD}\r\n`; + +test('parses the dotenv file (comments, CRLF, quotes)', () => { + assert.equal(parseEnvFile(envText).get('VITE_LEADERBOARD_API_URL'), PROD); + assert.equal(parseEnvFile(`A="x y"\nB='z'`).get('A'), 'x y'); +}); + +test('accepts only a bare public https origin', () => { + assert.equal(checkProductionApiUrl(PROD), PROD); + assert.equal(checkProductionApiUrl(`${PROD}/`), PROD); + for (const bad of [ + undefined, + '', + 'not a url', + 'http://asteroids-leaderboard.davejandrea.workers.dev', + 'https://localhost', + 'https://127.0.0.1', + 'https://127.0.0.1:8787', + 'https://10.0.0.5', + 'https://192.168.1.20', + 'https://172.20.0.1', + 'https://[::1]', + 'https://box.local', + `${PROD}/api/v1`, + `${PROD}?x=1`, + 'https://user:pw@example.com', + 'https://example.com:8443', + ]) { + assert.ok(checkProductionApiUrl(bad) instanceof Error, `should reject ${bad}`); + } +}); + +test('the shell may repeat the file value but never replace it', () => { + assert.equal(resolveAndroidApiOrigin(envText, undefined), PROD); + assert.equal(resolveAndroidApiOrigin(envText, ''), PROD); + assert.equal(resolveAndroidApiOrigin(envText, `${PROD}/`), PROD); + assert.throws(() => resolveAndroidApiOrigin(envText, 'http://127.0.0.1:8787'), /disagrees/); + assert.throws(() => resolveAndroidApiOrigin(envText, 'https://other.example'), /disagrees/); + assert.throws(() => resolveAndroidApiOrigin('# nothing here\n', undefined), /not set/); + assert.throws(() => resolveAndroidApiOrigin('VITE_LEADERBOARD_API_URL=http://127.0.0.1:8787\n', undefined), /https/); +}); + +function fakeBuild({ api = PROD, node = false, index = true } = {}) { + const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'android-build-')); + fs.mkdirSync(path.join(dir, 'assets')); + if (index) fs.writeFileSync(path.join(dir, 'index.html'), ''); + fs.writeFileSync(path.join(dir, 'assets', 'index-abc.js'), `const a="${api}";`); + if (node) fs.mkdirSync(path.join(dir, 'node')); + return dir; +} + +test('a correct build passes', () => { + assert.deepEqual(verifyAndroidBuild(fakeBuild(), PROD), []); +}); + +test('a build without the production origin, with the server bundle, or without index.html fails', () => { + assert.match(verifyAndroidBuild(fakeBuild({ api: 'http://127.0.0.1:8787' }), PROD).join('\n'), /production API origin/); + assert.match(verifyAndroidBuild(fakeBuild({ node: true }), PROD).join('\n'), /server-only/); + assert.match(verifyAndroidBuild(fakeBuild({ index: false }), PROD).join('\n'), /index\.html/); +}); + +test('the committed .env.android names the production Worker', () => { + const text = fs.readFileSync(new URL('../.env.android', import.meta.url), 'utf8'); + assert.equal(resolveAndroidApiOrigin(text, undefined), PROD); +}); diff --git a/phaser-asteroids/server/wrangler.toml b/phaser-asteroids/server/wrangler.toml index b61397e..9799a75 100644 --- a/phaser-asteroids/server/wrangler.toml +++ b/phaser-asteroids/server/wrangler.toml @@ -52,4 +52,5 @@ database_id = "cf4833f7-5fc9-45ca-a767-750df108f1e9" migrations_dir = "migrations" [env.production.vars] -ALLOWED_ORIGINS = "https://djblackett.github.io" +# GitHub Pages, and the Android app (its page origin is set by server.hostname in ../capacitor.config.ts; see ../docs/android.md). +ALLOWED_ORIGINS = "https://djblackett.github.io,https://spacearcade.davidandrea.ca" diff --git a/phaser-asteroids/src/input/fullscreen.ts b/phaser-asteroids/src/input/fullscreen.ts index 9a68dd0..32e2d1c 100644 --- a/phaser-asteroids/src/input/fullscreen.ts +++ b/phaser-asteroids/src/input/fullscreen.ts @@ -209,13 +209,18 @@ export const HOME_SCREEN_TIP = { ], } as const; -/** Reads the real browser. Anything missing counts as "not available": the safe default. */ +/** + * Reads the real browser. Anything missing counts as "not available": the safe default. `nativeApp`: the page runs inside the Android + * app, which is already fullscreen (its system bars are hidden natively, see capacitor.config.ts) and whose WebView ends any Fullscreen + * API request at once, so it is treated like an installed web app: no Fullscreen button. + */ export function browserFullscreenEnvironment( doc: Document = document, win: Pick = window, nav: Navigator = navigator, + nativeApp = false, ): FullscreenEnvironment { - let standalone = (nav as Navigator & { standalone?: boolean }).standalone === true; + let standalone = nativeApp || (nav as Navigator & { standalone?: boolean }).standalone === true; try { standalone = standalone || win.matchMedia('(display-mode: standalone)').matches; } catch { diff --git a/phaser-asteroids/src/input/gameTouch.ts b/phaser-asteroids/src/input/gameTouch.ts index 989a1ca..81cd959 100644 --- a/phaser-asteroids/src/input/gameTouch.ts +++ b/phaser-asteroids/src/input/gameTouch.ts @@ -1,5 +1,6 @@ import Phaser from 'phaser'; import { browserStorage } from '../audio/audioSettings'; +import { isNativeApp } from '../platform/nativeApp'; import { SystemOverlay } from '../ui/systemOverlay'; import { TouchOverlay } from '../ui/touchOverlay'; import { browserFullscreenEnvironment, FullscreenController } from './fullscreen'; @@ -29,7 +30,7 @@ export function installTouchControls(game: Phaser.Game): { const storage = browserStorage(); const mode = new InputModeController(browserInputEnvironment(), window.location.search, storage); const movement = new MovementController(storage); - const fullscreen = new FullscreenController(browserFullscreenEnvironment()); + const fullscreen = new FullscreenController(browserFullscreenEnvironment(document, window, navigator, isNativeApp())); const touch = new TouchControls(new TouchOverlay(document, new SystemOverlay(document, fullscreen)), window, document); touch.setMovement(movement.mode); touch.setActive(mode.isTouch); diff --git a/phaser-asteroids/src/main.ts b/phaser-asteroids/src/main.ts index f1ad90b..ba26415 100644 --- a/phaser-asteroids/src/main.ts +++ b/phaser-asteroids/src/main.ts @@ -1,5 +1,6 @@ import Phaser from 'phaser'; import { SCREEN_HEIGHT, SCREEN_WIDTH } from './core/constants'; +import { installNativeApp } from './platform/nativeApp'; import { BootScene } from './scenes/BootScene'; import { GameScene } from './scenes/GameScene'; import { StartScene } from './scenes/StartScene'; @@ -22,6 +23,9 @@ const game = new Phaser.Game({ scene: [BootScene, StartScene, GameScene], }); +// Android app only (a no-op in every browser): system Back, app pause / resume and the system bars. See src/platform/nativeApp.ts. +installNativeApp(); + // `?debug` exposes the game instance for manual inspection and browser automation. if (new URLSearchParams(window.location.search).has('debug')) { (window as unknown as { __game: Phaser.Game }).__game = game; diff --git a/phaser-asteroids/src/platform/capacitorBindings.ts b/phaser-asteroids/src/platform/capacitorBindings.ts new file mode 100644 index 0000000..e1b2986 --- /dev/null +++ b/phaser-asteroids/src/platform/capacitorBindings.ts @@ -0,0 +1,21 @@ +import { App } from '@capacitor/app'; +import { SystemBars } from '@capacitor/core'; +import { wireNativeApp, type AppPluginLike } from './nativeApp'; +import { nativeBack } from './nativeBack'; + +/** + * The only module that imports Capacitor plugins. Loaded lazily by `installNativeApp`, and only inside the app, so the browser build + * never loads it (Vite emits it as its own chunk). + */ +export function installCapacitorBindings(): () => void { + const app: AppPluginLike = { + // `App.addListener` is overloaded per event name; every listener used here ignores its argument. + addListener: (eventName, listener) => { + if (eventName === 'backButton') return App.addListener('backButton', listener); + if (eventName === 'pause') return App.addListener('pause', listener); + return App.addListener('resume', listener); + }, + minimizeApp: () => App.minimizeApp(), + }; + return wireNativeApp(app, window, nativeBack, { hide: () => SystemBars.hide() }); +} diff --git a/phaser-asteroids/src/platform/nativeApp.ts b/phaser-asteroids/src/platform/nativeApp.ts new file mode 100644 index 0000000..8dac691 --- /dev/null +++ b/phaser-asteroids/src/platform/nativeApp.ts @@ -0,0 +1,89 @@ +import { nativeBack, type BackDispatcher } from './nativeBack'; + +/** + * The Android (Capacitor) app shell around the unchanged web game. Everything native is reached through here, and only when the page + * really runs inside the app: Capacitor's native bridge defines `window.Capacitor` before any script runs, so a browser (desktop, phone, + * GitHub Pages) never takes these paths and never even downloads the Capacitor plugin code (it is a separate, lazily imported chunk). + * + * What the app adds, each one routed into logic the browser build already has: + * - Back: `nativeBack` (see nativeBack.ts), i.e. the same rules as Escape; with nothing left to close, the app goes to the background. + * - pause / resume: replayed as the window `blur` / `focus` events every lifecycle listener already handles (Phaser's BLUR -> the run + * pauses and the music falls silent, held keys and touches are released, controllers go neutral, vibration stops). WebView normally + * fires these itself; the native events make it certain, and a second `blur` is harmless. + * - system bars: hidden at start by the SystemBars config (capacitor.config.ts) and hidden again on every resume. + */ + +/** The parts of `window.Capacitor` (from the native bridge) read here. */ +interface CapacitorGlobal { + isNativePlatform?: () => boolean; +} + +/** True only inside the Capacitor app (Android). Never throws; anything unexpected means "a browser". */ +export function isNativeApp(win: unknown = typeof window === 'undefined' ? undefined : window): boolean { + try { + const cap = (win as { Capacitor?: CapacitorGlobal } | undefined)?.Capacitor; + return typeof cap?.isNativePlatform === 'function' && cap.isNativePlatform() === true; + } catch { + return false; + } +} + +interface ListenerHandle { + remove(): Promise | void; +} + +/** The slice of `@capacitor/app`'s `App` used here (structural, so tests pass a fake). */ +export interface AppPluginLike { + addListener(eventName: 'backButton' | 'pause' | 'resume', listener: () => void): Promise; + minimizeApp(): Promise; +} + +/** The slice of `@capacitor/core`'s `SystemBars` used here. */ +export interface SystemBarsLike { + hide(): Promise; +} + +/** + * Connects the native events to the game. @returns a function that removes every listener again. Never throws, and a plugin call that + * fails is logged and ignored: the game keeps running either way. + */ +export function wireNativeApp(app: AppPluginLike, win: EventTarget, back: BackDispatcher = nativeBack, bars?: SystemBarsLike): () => void { + const handles: Promise[] = []; + const listen = (eventName: 'backButton' | 'pause' | 'resume', listener: () => void): void => { + handles.push( + Promise.resolve() + .then(() => app.addListener(eventName, listener)) + .catch((e: unknown) => { + console.warn(`[asteroids] could not listen for ${eventName}`, e); + return null; + }), + ); + }; + const quietly = (what: string, call: () => Promise): void => { + Promise.resolve() + .then(call) + .catch((e: unknown) => console.warn(`[asteroids] ${what} failed`, e)); + }; + + // Registering a backButton listener also turns off the plugin's default (WebView history back, else close the app). + listen('backButton', () => { + if (back.dispatch() === 'exit') quietly('minimizeApp', () => app.minimizeApp()); + }); + listen('pause', () => win.dispatchEvent(new Event('blur'))); + listen('resume', () => { + win.dispatchEvent(new Event('focus')); + if (bars) quietly('SystemBars.hide', () => bars.hide()); + }); + + return () => { + for (const handle of handles) void handle.then((h) => h?.remove()); + }; +} + +/** Called once at startup. Does nothing at all in a browser. */ +export function installNativeApp(): void { + if (!isNativeApp()) return; + void import('./capacitorBindings') + .then(({ installCapacitorBindings }) => installCapacitorBindings()) + .catch((e: unknown) => console.warn('[asteroids] native app integration unavailable', e)); +} diff --git a/phaser-asteroids/src/platform/nativeBack.ts b/phaser-asteroids/src/platform/nativeBack.ts new file mode 100644 index 0000000..b4fe39d --- /dev/null +++ b/phaser-asteroids/src/platform/nativeBack.ts @@ -0,0 +1,51 @@ +/** + * Android's system Back (button or gesture) inside the Capacitor app. Each scene registers what Back means while it is on screen; the + * same in-game rules as Escape / the controller's BACK are reused, never re-implemented here: + * + * title menu -> `MenuController.back()` (close the open page; false on the root page) + * a run -> `GameScene.goBack()` (pause, close a pause page, resume, leave a finished run; see `handleBack`) + * + * When the scene has nothing left to close (the title screen's root page, or no scene has registered yet) the answer is `exit`, and + * the app goes to the background like any Android app on its first screen. A run in progress is never left by Back. + * + * Pure: no Phaser, no Capacitor. Browsers never call `dispatch` (they have no system Back), so nothing changes for them. + */ + +/** @returns true when the game handled Back; false when there is nothing left to close. */ +export type BackHandler = () => boolean; + +export type BackDispatchResult = 'handled' | 'exit'; + +export class BackDispatcher { + private handler: BackHandler | null = null; + + /** + * Makes `handler` the meaning of Back. @returns a function that removes it again, and only it: a scene that shuts down after the + * next scene has already registered cannot remove the newer handler. + */ + setHandler(handler: BackHandler): () => void { + this.handler = handler; + return () => { + if (this.handler === handler) this.handler = null; + }; + } + + get hasHandler(): boolean { + return this.handler !== null; + } + + dispatch(): BackDispatchResult { + const handler = this.handler; + if (!handler) return 'exit'; + try { + return handler() ? 'handled' : 'exit'; + } catch (e) { + // A broken handler must not turn Back into "leave the app" in the middle of a run. + console.warn('[asteroids] Back handler failed', e); + return 'handled'; + } + } +} + +/** The one dispatcher for the game (like `rankedSession`): scenes come and go, the native listener stays. */ +export const nativeBack = new BackDispatcher(); diff --git a/phaser-asteroids/src/ranked/api.ts b/phaser-asteroids/src/ranked/api.ts index 5b05579..07dc7b0 100644 --- a/phaser-asteroids/src/ranked/api.ts +++ b/phaser-asteroids/src/ranked/api.ts @@ -1,4 +1,5 @@ import type { GameConfig } from '../core/gameConfig'; +import { isNativeApp } from '../platform/nativeApp'; import { FIXED_TICK_RATE, GAMEPLAY_RULES_VERSION, REPLAY_SCHEMA_VERSION } from '../replay/constants'; import type { ReplayEndReason, ReplayRecord } from '../replay/types'; import type { ControlScheme } from './controls'; @@ -61,8 +62,13 @@ const LOCAL_API = 'http://127.0.0.1:8787'; * the browser tests) `?api=` may point at a local backend, and with nothing configured the local `wrangler dev` address is used. * Anywhere else a query parameter is ignored: a crafted link cannot redirect a player's run to another server. Null: ranked play is * not available in this build. + * + * `nativeApp` (the Android app): only the configured URL counts, whatever the page's hostname is. The app is served from its own + * hostname (capacitor.config.ts), so the loopback rules would not apply anyway; this makes sure that a future change there can never + * point an installed app at `wrangler dev` or let `?api=` redirect it. `npm run build:android` refuses to build without the + * production URL. */ -export function resolveApiBase(search: string, hostname: string, configured?: string): string | null { +export function resolveApiBase(search: string, hostname: string, configured?: string, nativeApp = false): string | null { const clean = (u: string) => u.replace(/\/+$/, ''); const valid = (u: string | null | undefined): string | null => { if (!u) return null; @@ -73,14 +79,14 @@ export function resolveApiBase(search: string, hostname: string, configured?: st return null; } }; - if (LOOPBACK.has(hostname)) return valid(new URLSearchParams(search).get('api')) ?? valid(configured) ?? LOCAL_API; + if (!nativeApp && LOOPBACK.has(hostname)) return valid(new URLSearchParams(search).get('api')) ?? valid(configured) ?? LOCAL_API; return valid(configured); } /** The API base for this page, or null when the build has none configured (ranked play and the high scores are then "unavailable"). */ export function getApiBase(): string | null { if (typeof window === 'undefined') return null; - return resolveApiBase(window.location.search, window.location.hostname, import.meta.env.VITE_LEADERBOARD_API_URL); + return resolveApiBase(window.location.search, window.location.hostname, import.meta.env.VITE_LEADERBOARD_API_URL, isNativeApp()); } /** diff --git a/phaser-asteroids/src/scenes/GameScene.ts b/phaser-asteroids/src/scenes/GameScene.ts index cc47186..8e020bb 100644 --- a/phaser-asteroids/src/scenes/GameScene.ts +++ b/phaser-asteroids/src/scenes/GameScene.ts @@ -23,6 +23,7 @@ import { import { createKeyPressRouter } from '../input/keyPress'; import { keySchemesFor, readPlayerInput, type KeyScheme } from '../input/keyboardControls'; import { readPlayerInputs } from '../input/playerInputs'; +import { nativeBack } from '../platform/nativeBack'; import { getApiBase, type RankedChallenge } from '../ranked/api'; import { ControlTracker } from '../ranked/controls'; import { localBest, readLocalScores, startingNickname, type LocalScore } from '../ranked/localScores'; @@ -839,10 +840,17 @@ export class GameScene extends Phaser.Scene { }), this.touch.onPortrait(() => autoPause()), ]; + // Android Back (app only) is Escape: it pauses, closes a pause page, resumes, or leaves a finished run (`goBack`). It never leaves + // the app from a run, so it always counts as handled. + const stopNativeBack = nativeBack.setHandler(() => { + this.goBack(); + return true; + }); const events = this.game.events; events.on(Phaser.Core.Events.BLUR, autoPause); events.on(Phaser.Core.Events.HIDDEN, autoPause); this.events.once(Phaser.Scenes.Events.SHUTDOWN, () => { + stopNativeBack(); stopPadEvents(); for (const stop of stopTouchEvents) stop(); this.touch.setLayer('off'); diff --git a/phaser-asteroids/src/scenes/StartScene.ts b/phaser-asteroids/src/scenes/StartScene.ts index 3bf7217..f7f88ee 100644 --- a/phaser-asteroids/src/scenes/StartScene.ts +++ b/phaser-asteroids/src/scenes/StartScene.ts @@ -10,6 +10,7 @@ import { getInputMode, getMovement, getTouchControls } from '../input/gameTouch' import type { GamepadHub } from '../input/gamepadHub'; import type { InputModeController } from '../input/inputMode'; import { createKeyPressRouter } from '../input/keyPress'; +import { nativeBack } from '../platform/nativeBack'; import { rankedInputAvailable } from '../input/rankedInput'; import { getApiBase, RANKED_MAX_TICKS, RankedApiError, rankedRequested, requestChallenge } from '../ranked/api'; import { readLocalScores } from '../ranked/localScores'; @@ -148,7 +149,13 @@ export class StartScene extends Phaser.Scene { // The system controls (Fullscreen) belong to the touch screens; leaving the scene takes them away again. const touch = getTouchControls(this); touch.setLayer('menu'); - this.events.once(Phaser.Scenes.Events.SHUTDOWN, () => touch.setLayer('off')); + // Android Back (app only): the same as Escape on this menu. On the root page there is nothing to close, so the app goes to the + // background; while a run is starting Back is swallowed. + const stopNativeBack = nativeBack.setHandler(() => this.starting || this.menu.controller.back()); + this.events.once(Phaser.Scenes.Events.SHUTDOWN, () => { + touch.setLayer('off'); + stopNativeBack(); + }); const keyboard = this.input.keyboard; if (keyboard) { diff --git a/phaser-asteroids/src/ui/menu/pages/ranked.ts b/phaser-asteroids/src/ui/menu/pages/ranked.ts index 3a4f41a..31c9956 100644 --- a/phaser-asteroids/src/ui/menu/pages/ranked.ts +++ b/phaser-asteroids/src/ui/menu/pages/ranked.ts @@ -1,3 +1,4 @@ +import { isNativeApp } from '../../../platform/nativeApp'; import type { PersonalBest } from '../../../ranked/personalBest'; import { formatEraScore } from '../../../ranked/scoresModel'; import { COLORS } from '../../text'; @@ -37,12 +38,15 @@ export interface RankedMenuContext { const WIDE = { w: 600, h: 110 }; /** What the player is told when the ranked service cannot start a run, and whether trying again could help. */ -export function describeRankedFailure(code: string): { lines: [string, string]; retry: boolean } { +export function describeRankedFailure(code: string, nativeApp = false): { lines: [string, string]; retry: boolean } { switch (code) { case 'unconfigured': return { lines: ['RANKED PLAY IS NOT AVAILABLE IN THIS BUILD YET.', 'YOU CAN STILL PLAY PRACTICE.'], retry: false }; case 'update_required': - return { lines: ['THE GAME HAS BEEN UPDATED.', 'RELOAD THE PAGE TO PLAY RANKED.'], retry: false }; + // Reloading the Android app loads the same bundled game again; only a store update brings the new rules. + return nativeApp + ? { lines: ['RANKED PLAY NEEDS A NEWER VERSION OF THE APP.', 'UPDATE THE APP, OR PLAY PRACTICE.'], retry: false } + : { lines: ['THE GAME HAS BEEN UPDATED.', 'RELOAD THE PAGE TO PLAY RANKED.'], retry: false }; case 'rate_limited': return { lines: ['TOO MANY RANKED RUNS STARTED RECENTLY.', 'TRY AGAIN IN A WHILE, OR PLAY PRACTICE.'], retry: true }; default: @@ -77,7 +81,7 @@ export function buildRankedPage(kit: PageKit, ctx: RankedMenuContext, nav: PageN } if (status.kind === 'error') { - const failure = describeRankedFailure(status.code); + const failure = describeRankedFailure(status.code, isNativeApp()); kit.text(CENTER_X, 190, failure.lines[0], { size: TEXT.body + 2, originX: 0.5, originY: 0.5, color: '#ff9696' }); kit.text(CENTER_X, 236, failure.lines[1], { size: TEXT.body, originX: 0.5, originY: 0.5, color: COLORS.hint }); let y = 300; diff --git a/phaser-asteroids/src/ui/touch.css b/phaser-asteroids/src/ui/touch.css index b4e90d0..98cbf42 100644 --- a/phaser-asteroids/src/ui/touch.css +++ b/phaser-asteroids/src/ui/touch.css @@ -18,10 +18,10 @@ body.tc-active { --tc-sec: clamp(64px, 19vh, 92px); --tc-gap: 14px; --tc-edge: 18px; - --tc-left: calc(env(safe-area-inset-left, 0px) + var(--tc-edge)); - --tc-right: calc(env(safe-area-inset-right, 0px) + var(--tc-edge)); - --tc-bottom: calc(env(safe-area-inset-bottom, 0px) + 14px); - --tc-top: calc(env(safe-area-inset-top, 0px) + 10px); + --tc-left: calc(var(--safe-area-inset-left, env(safe-area-inset-left, 0px)) + var(--tc-edge)); + --tc-right: calc(var(--safe-area-inset-right, env(safe-area-inset-right, 0px)) + var(--tc-edge)); + --tc-bottom: calc(var(--safe-area-inset-bottom, env(safe-area-inset-bottom, 0px)) + 14px); + --tc-top: calc(var(--safe-area-inset-top, env(safe-area-inset-top, 0px)) + 10px); --tc-dpad: clamp(132px, 44vh, 188px); /* the D-pad's diameter: bigger than FIRE, it is the control the thumb lives on */ position: fixed; inset: 0; @@ -292,8 +292,8 @@ body.tc-active { /* System controls (Fullscreen) over the title and pause screens: DOM so the browser sees a real tap. Hidden during play. */ .tc-system { - --tc-right: calc(env(safe-area-inset-right, 0px) + 18px); - --tc-top: calc(env(safe-area-inset-top, 0px) + 10px); + --tc-right: calc(var(--safe-area-inset-right, env(safe-area-inset-right, 0px)) + 18px); + --tc-top: calc(var(--safe-area-inset-top, env(safe-area-inset-top, 0px)) + 10px); position: fixed; inset: 0; z-index: 11; @@ -346,7 +346,7 @@ body.tc-active { align-items: center; justify-content: center; box-sizing: border-box; - padding: max(16px, env(safe-area-inset-top, 0px)) max(24px, env(safe-area-inset-right, 0px)) max(16px, env(safe-area-inset-bottom, 0px)) max(24px, env(safe-area-inset-left, 0px)); + padding: max(16px, var(--safe-area-inset-top, env(safe-area-inset-top, 0px))) max(24px, var(--safe-area-inset-right, env(safe-area-inset-right, 0px))) max(16px, var(--safe-area-inset-bottom, env(safe-area-inset-bottom, 0px))) max(24px, var(--safe-area-inset-left, env(safe-area-inset-left, 0px))); background: rgba(0, 0, 10, 0.95); pointer-events: auto; touch-action: none; diff --git a/phaser-asteroids/tests/androidRelease.test.ts b/phaser-asteroids/tests/androidRelease.test.ts new file mode 100644 index 0000000..340c4bf --- /dev/null +++ b/phaser-asteroids/tests/androidRelease.test.ts @@ -0,0 +1,58 @@ +import { readFileSync } from 'node:fs'; +import { resolve } from 'node:path'; +import { describe, expect, it } from 'vitest'; +import config from '../capacitor.config'; +import { resolveApiBase } from '../src/ranked/api'; + +/** + * The Android app's settings live in four files that must agree: capacitor.config.ts (the app's origin and web folder), .env.android + * (the leaderboard URL baked into the app), server/wrangler.toml (the origins the production Worker accepts) and the manifest. + */ +const read = (file: string): string => new TextDecoder().decode(readFileSync(resolve(import.meta.dirname, '..', file))); + +function productionOrigins(): string[] { + const toml = read('server/wrangler.toml'); + const section = toml.slice(toml.indexOf('[env.production.vars]')); + const line = section.match(/^ALLOWED_ORIGINS\s*=\s*"([^"]*)"/m); + return (line?.[1] ?? '').split(',').map((o) => o.trim()).filter(Boolean); +} + +const appOrigin = `${config.server?.androidScheme ?? 'https'}://${config.server?.hostname}`; + +describe('Android app configuration', () => { + it('is served from its own https hostname, not localhost', () => { + expect(config.server?.androidScheme).toBe('https'); + expect(config.server?.hostname).toBe('spacearcade.davidandrea.ca'); + }); + + it('the production Worker accepts the app origin (and still accepts GitHub Pages)', () => { + expect(productionOrigins()).toEqual(expect.arrayContaining([appOrigin, 'https://djblackett.github.io'])); + }); + + it('local Worker origins are unchanged (the app origin is production-only)', () => { + const toml = read('server/wrangler.toml'); + const local = toml.slice(0, toml.indexOf('[env.production')); + expect(local).not.toContain(appOrigin); + }); + + it('packages the dedicated Android build, never dist/ (which carries the server-only verifier)', () => { + expect(config.webDir).toBe('dist-android'); + }); + + it('bakes the production API into the app, and on the app hostname nothing else can be used', () => { + const api = read('.env.android').match(/^VITE_LEADERBOARD_API_URL=(.+)$/m)?.[1]?.trim(); + expect(api).toBe('https://asteroids-leaderboard.davejandrea.workers.dev'); + expect(resolveApiBase('?api=http://127.0.0.1:8787', config.server!.hostname!, api)).toBe(api); + expect(resolveApiBase('', config.server!.hostname!, undefined)).toBeNull(); + }); + + it('hides the system bars with the built-in SystemBars plugin and writes the safe-area variables', () => { + expect(config.plugins?.SystemBars).toMatchObject({ hidden: true, insetsHandling: 'css' }); + }); + + it('the manifest locks landscape and allows vibration', () => { + const manifest = read('android/app/src/main/AndroidManifest.xml'); + expect(manifest).toContain('android:screenOrientation="sensorLandscape"'); + expect(manifest).toContain('android.permission.VIBRATE'); + }); +}); diff --git a/phaser-asteroids/tests/fullscreen.test.ts b/phaser-asteroids/tests/fullscreen.test.ts index 6caab8e..3779bfc 100644 --- a/phaser-asteroids/tests/fullscreen.test.ts +++ b/phaser-asteroids/tests/fullscreen.test.ts @@ -109,6 +109,14 @@ describe('fullscreen support detection', () => { expect(browserFullscreenEnvironment(doc, { matchMedia: () => ({ matches: false }) } as unknown as Window, { standalone: true } as unknown as Navigator).standalone).toBe(true); expect(browserFullscreenEnvironment(doc, { matchMedia: () => ({ matches: false }) } as unknown as Window, nav).standalone).toBe(false); }); + + it('inside the Android app: already fullscreen natively, so no Fullscreen button (WebView would end the request at once)', () => { + const doc = { documentElement: {} } as unknown as Document; + const win = { matchMedia: () => ({ matches: false }) } as unknown as Window; + const env = browserFullscreenEnvironment(doc, win, {} as Navigator, true); + expect(env.standalone).toBe(true); + expect(fullscreenButtonSpec({ support: detectSupport(env), active: false, failure: null }).visible).toBe(false); + }); }); describe('entering and leaving fullscreen', () => { diff --git a/phaser-asteroids/tests/mobileEntry.test.ts b/phaser-asteroids/tests/mobileEntry.test.ts index 9d43af4..8de8f17 100644 --- a/phaser-asteroids/tests/mobileEntry.test.ts +++ b/phaser-asteroids/tests/mobileEntry.test.ts @@ -35,4 +35,10 @@ describe('ranked service failures keep the choice explicit', () => { lines: ['THE GAME HAS BEEN UPDATED.', 'RELOAD THE PAGE TO PLAY RANKED.'], retry: false, }); }); + it('the Android app asks for an app update instead (reloading it loads the same bundled game)', () => { + expect(describeRankedFailure('update_required', true)).toEqual({ + lines: ['RANKED PLAY NEEDS A NEWER VERSION OF THE APP.', 'UPDATE THE APP, OR PLAY PRACTICE.'], retry: false, + }); + expect(describeRankedFailure('network', true)).toEqual(describeRankedFailure('network')); + }); }); diff --git a/phaser-asteroids/tests/nativeApp.test.ts b/phaser-asteroids/tests/nativeApp.test.ts new file mode 100644 index 0000000..242e669 --- /dev/null +++ b/phaser-asteroids/tests/nativeApp.test.ts @@ -0,0 +1,171 @@ +import { describe, expect, it, vi } from 'vitest'; +import { isNativeApp, wireNativeApp, type AppPluginLike } from '../src/platform/nativeApp'; +import { BackDispatcher } from '../src/platform/nativeBack'; +import { handleBack, type BackEnv } from '../src/ui/menu/backAction'; + +type AppEvent = 'backButton' | 'pause' | 'resume'; + +/** A recording stand-in for `@capacitor/app`'s `App`. */ +class FakeApp implements AppPluginLike { + readonly listeners = new Map void>>(); + removed = 0; + minimized = 0; + failAddListener = false; + addListener(eventName: AppEvent, listener: () => void) { + if (this.failAddListener) return Promise.reject(new Error('plugin not implemented')); + const list = this.listeners.get(eventName) ?? []; + list.push(listener); + this.listeners.set(eventName, list); + return Promise.resolve({ remove: () => void this.removed++ }); + } + minimizeApp() { + this.minimized++; + return Promise.resolve(); + } + fire(eventName: AppEvent): void { + for (const listener of this.listeners.get(eventName) ?? []) listener(); + } +} + +const settle = () => new Promise((r) => setTimeout(r, 0)); + +async function rig(bars?: { hide: () => Promise }) { + const app = new FakeApp(); + const win = new EventTarget(); + const seen: string[] = []; + win.addEventListener('blur', () => seen.push('blur')); + win.addEventListener('focus', () => seen.push('focus')); + const back = new BackDispatcher(); + const stop = wireNativeApp(app, win, back, bars); + await settle(); + return { app, win, seen, back, stop }; +} + +/** A run in GameScene, reduced to the state `handleBack` reads (the same object Escape uses). */ +function run(): BackEnv & { log: string[]; state: { paused: boolean; gameOver: boolean; pageOpen: boolean } } { + const state = { paused: false, gameOver: false, pageOpen: false }; + const log: string[] = []; + return { + state, + log, + get gameOver() { return state.gameOver; }, + get paused() { return state.paused; }, + get menuShown() { return state.paused; }, + menuBack: () => { + if (!state.pageOpen) return false; + state.pageOpen = false; + log.push('closed-page'); + return true; + }, + pause: () => ((state.paused = true), log.push('pause')), + resume: () => ((state.paused = false), log.push('resume')), + leaveFinishedRun: () => log.push('left'), + }; +} + +describe('isNativeApp', () => { + it('is true only when the Capacitor bridge says it is a native platform', () => { + expect(isNativeApp({ Capacitor: { isNativePlatform: () => true } })).toBe(true); + expect(isNativeApp({ Capacitor: { isNativePlatform: () => false } })).toBe(false); + expect(isNativeApp({ Capacitor: {} })).toBe(false); + expect(isNativeApp({})).toBe(false); + expect(isNativeApp(undefined)).toBe(false); + expect(isNativeApp({ Capacitor: { isNativePlatform: () => { throw new Error('x'); } } })).toBe(false); + }); + it('is false in the test environment (no window): browsers never take the native paths', () => { + expect(isNativeApp()).toBe(false); + }); +}); + +describe('BackDispatcher', () => { + it('with no scene registered, Back leaves the app', () => { + expect(new BackDispatcher().dispatch()).toBe('exit'); + }); + it('the handler decides: true is handled, false (nothing left to close) leaves', () => { + const back = new BackDispatcher(); + let open = true; + back.setHandler(() => { + const had = open; + open = false; + return had; + }); + expect(back.dispatch()).toBe('handled'); + expect(back.dispatch()).toBe('exit'); + }); + it('a scene shutting down after the next one registered cannot remove the newer handler', () => { + const back = new BackDispatcher(); + const stopOld = back.setHandler(() => false); + back.setHandler(() => true); + stopOld(); + expect(back.dispatch()).toBe('handled'); + }); + it('a handler that throws never turns Back into leaving the app', () => { + const back = new BackDispatcher(); + const warn = vi.spyOn(console, 'warn').mockImplementation(() => undefined); + back.setHandler(() => { + throw new Error('boom'); + }); + expect(back.dispatch()).toBe('handled'); + warn.mockRestore(); + }); +}); + +describe('wireNativeApp: Back', () => { + it('in a run, Back follows the Escape rules and never leaves the app', async () => { + const { app, back } = await rig(); + const game = run(); + back.setHandler(() => (handleBack(game), true)); // what GameScene registers + app.fire('backButton'); // playing -> pause + game.state.pageOpen = true; + app.fire('backButton'); // a pause page -> closes it + app.fire('backButton'); // the pause root -> resume + game.state.gameOver = true; + app.fire('backButton'); // game over -> the title screen + expect(game.log).toEqual(['pause', 'closed-page', 'resume', 'left']); + expect(app.minimized).toBe(0); + }); + it('on the title screen, Back closes pages and only minimizes from the root page', async () => { + const { app, back } = await rig(); + let depth = 2; + back.setHandler(() => (depth > 0 ? (depth--, true) : false)); // MenuController.back(): false on the root + app.fire('backButton'); + app.fire('backButton'); + expect(app.minimized).toBe(0); + app.fire('backButton'); + await settle(); + expect(app.minimized).toBe(1); + }); +}); + +describe('wireNativeApp: lifecycle', () => { + it('app pause / resume become the window blur / focus every existing lifecycle listener handles', async () => { + const { app, seen } = await rig(); + app.fire('pause'); + app.fire('resume'); + expect(seen).toEqual(['blur', 'focus']); + }); + it('resume hides the system bars again', async () => { + const hide = vi.fn(() => Promise.resolve()); + const { app } = await rig({ hide }); + app.fire('pause'); + expect(hide).not.toHaveBeenCalled(); + app.fire('resume'); + await settle(); + expect(hide).toHaveBeenCalledTimes(1); + }); + it('a failing plugin is logged, not thrown, and the game carries on', async () => { + const warn = vi.spyOn(console, 'warn').mockImplementation(() => undefined); + const app = new FakeApp(); + app.failAddListener = true; + expect(() => wireNativeApp(app, new EventTarget(), new BackDispatcher(), { hide: () => Promise.reject(new Error('no bars')) })).not.toThrow(); + await settle(); + expect(warn).toHaveBeenCalled(); + warn.mockRestore(); + }); + it('the returned function removes every listener', async () => { + const { app, stop } = await rig(); + stop(); + await settle(); + expect(app.removed).toBe(3); + }); +}); diff --git a/phaser-asteroids/tests/ranked.test.ts b/phaser-asteroids/tests/ranked.test.ts index bb8cf3c..469acc4 100644 --- a/phaser-asteroids/tests/ranked.test.ts +++ b/phaser-asteroids/tests/ranked.test.ts @@ -77,6 +77,12 @@ describe('resolveApiBase', () => { expect(resolveApiBase('?api=http://127.0.0.1:8792/', '127.0.0.1')).toBe('http://127.0.0.1:8792'); expect(resolveApiBase('', 'localhost')).toBe('http://127.0.0.1:8787'); }); + it('the Android app only ever uses the configured URL: no ?api=, no wrangler dev fallback, even on a loopback hostname', () => { + for (const host of ['spacearcade.davidandrea.ca', 'localhost', '127.0.0.1']) { + expect(resolveApiBase('?api=http://127.0.0.1:8792/', host, 'https://lb.example.dev', true)).toBe('https://lb.example.dev'); + expect(resolveApiBase('', host, undefined, true)).toBeNull(); + } + }); it('rejects non-http(s) and malformed URLs', () => { expect(resolveApiBase('?api=javascript:alert(1)', '127.0.0.1', undefined)).toBe('http://127.0.0.1:8787'); expect(resolveApiBase('', 'example.com', 'not a url')).toBeNull(); From e74d458fd171c76c0f8841ed1fc191e5e7f6f605 Mon Sep 17 00:00:00 2001 From: djblackett <49618491+djblackett@users.noreply.github.com> Date: Mon, 2 Nov 2026 11:07:04 -0400 Subject: [PATCH 02/10] docs(android): add the Android release-readiness audit The audit of the ranked backend, replay security and the failing touch/menu browser suites, moved from a scratch file into the repository. Probe output is kept as evidence; references to the scratch folder are described instead of linked. File and line references are to a8acf66. Co-Authored-By: Claude Opus 5.5 --- .../docs/android-release-audit.md | 419 ++++++++++++++++++ 1 file changed, 419 insertions(+) create mode 100644 phaser-asteroids/docs/android-release-audit.md diff --git a/phaser-asteroids/docs/android-release-audit.md b/phaser-asteroids/docs/android-release-audit.md new file mode 100644 index 0000000..1d37e2c --- /dev/null +++ b/phaser-asteroids/docs/android-release-audit.md @@ -0,0 +1,419 @@ +# Audit: Android release risks — ranked backend, security, browser suites + +2026-11-02 · branch `dev` @ `a8acf66` (working tree clean; the Android work is committed there) · paths relative to `phaser-asteroids/` +· file and line references are to `a8acf66` + +Scope rules followed: nothing deployed, pushed, merged or committed. No repo file changed (only `dist/` was rebuilt, which is +git-ignored). No production request was made. No secret was read. The probes were throwaway scripts in a scratch folder outside the +repository and are not committed; their output is quoted below. They were: router + service tests against in-memory SQLite (the +"audit probe"), a Playwright phone probe against a local static server (the "phone probe"), and patched *copies* of two suites. + +--- + +## 1. Executive summary + +1. **The main release risk is confirmed, and it is worse on Android than `docs/android.md` says.** On a phone the big PLAY button + *is* ranked play (`src/ui/menu/pages/title.ts:28-30`, `src/scenes/StartScene.ts:285`). The Worker verifies exactly one rules + version, ignores what the client runs, and CI redeploys it on every merge to `main` that touches `phaser-asteroids/**`. So the + first gameplay merge after release makes the main button of **every installed app** say "RANKED PLAY NEEDS A NEWER VERSION OF THE + APP" until that user updates. Runs in progress at deploy time are rejected for good. Rules changed three times in about 36 hours + (1.0.0 on Oct 22, then 1.1.0 and 1.2.0 on Oct 23), so this will happen soon after release unless something prevents it. +2. **Multi-version support is cheap in this codebase.** The whole simulation plus verifier already builds into one self-contained + module (`dist/node/index.js`: 88.7 KB, 26 KB gzipped, no imports) that exports exactly what the server needs. Keep one frozen copy + per supported rules version, pick it by `runs.rules_version` (already stored), and add one query parameter. Router, D1 schema, run + lifecycle and boards stay as they are. No migration. +3. **Before release, P1 needs only two small items:** (a) the APK sends its rules version when it asks for a challenge, so no future + server has to guess; (b) a CI guard that stops a rules bump from deploying while it would strand shipped apps. The registry itself + can come after release, but it must land before the first rules bump after release. +4. **The backend core is sound.** Re-simulation, single-use claims, idempotent retries, race handling, bounded body reading and + secret handling all held up under code review and probes. I found no way to tamper with a replay beyond the known, documented + bot / offline-optimisation limit. +5. **Two rate-limit weaknesses are confirmed but unlikely to be exploited.** Requests with no token use up the *global* + verification budget. Per-IP buckets use the full IPv6 address, so one /64 gets unlimited buckets. Both are cheap to fix and + neither blocks the release. +6. **Both reported browser failures are stale test expectations, not app regressions, and have nothing to do with Android.** Two + Oct 23 commits changed the app without updating `touch.mjs` and `menu.mjs`: `5033ac8` made phone PLAY = ranked, and `ccce3ce` + (Chain Lightning) changed the MEGA POWER legend text. Each suite aborted at its first stale PLAY tap, which hid the rest of it. + With only the stale expectations corrected (in scratch copies), the suites ran to completion and surfaced **one real regression**: + since Chain Lightning added a seventh row, the POWER-UPS guide's Revive sentence sits under the BACK button at every phone and + desktop size (#9). They also showed one pre-existing intermittent touch flake. Details in §6. + +--- + +## 2. Confirmed issues, ranked + +| # | Issue | Impact | Likelihood | Before release? | +|---|---|---|---|---| +| 1 | A rules bump strands every installed app (PLAY breaks; in-flight runs rejected) | High | Near-certain at the next gameplay merge | **Yes: send the version + CI guard** | +| 2 | Nothing catches a simulation change that ships without a rules bump | Medium (high once there are several versions) | Likely over time | **Yes: same CI work as #1** | +| 3 | Requests with no token use up the global submit/start budgets | Medium (ranked unavailable for everyone for ≤1 h) | Low (needs a motivated griefer) | No; fix soon | +| 4 | Per-IP buckets key on the full IPv6 address | Low–Medium (cancels out per-IP limits) | Low | No; fix along with #3 | +| 5 | A finished but unsent ranked run exists only in memory | Low–Medium (run lost if Android kills the app) | Medium on mobile | No | +| 6 | `rules_mismatch` uses up the run and reads like a cheating verdict | Low (UX) | Only around deploys | No; goes away with #1 | +| 7 | A run stuck in `verifying` past expiry answers 409 "busy" until pruned (≥24 h) | Low | Very low | No | +| 8 | `touch.mjs` / `menu.mjs` expect the old phone PLAY and the old legend text | Test-only | Certain (fails every run) | Fix before relying on them for release testing | +| 9 | POWER-UPS guide: the Revive sentence overlaps the BACK button (all sizes) | Low (visible text overlap on a menu page) | Certain | Yes: cheap and player-visible | + +### #1 A rules bump strands installed apps + +Exactly how it breaks: + +1. A gameplay change bumps `GAMEPLAY_RULES_VERSION` (`src/replay/constants.ts`) and is merged to `main`. +2. CI deploys the Worker (`.github/workflows/deploy-gh-pages.yml:156`), and only then Pages. The Worker's only version is compiled in + (`server/src/config.ts:16`, `:82`). +3. **New ranked starts from an installed APK.** `POST /api/v1/runs` sends no body (`src/ranked/api.ts:130`). The server issues + `settings.rulesVersion` whatever the client is running (`server/src/runs.ts:90`). The app compares that to its own compiled + version (`api.ts:142-143`) and gives up with `update_required`. The ranked page then shows "RANKED PLAY NEEDS A NEWER VERSION OF + THE APP. UPDATE THE APP, OR PLAY PRACTICE." (`src/ui/menu/pages/ranked.ts:45-49`). Because phone PLAY is the ranked door, the + main button stops working. Recovery depends on Play review time plus each user's update delay (days to weeks). A sideloaded APK + never recovers. +4. **Runs in progress, or finished but not yet sent** (web and Android): the submit is claimed and then rejected at + `server/src/verify.ts:64` with `rules_mismatch`. The run is marked `rejected`, which is final. The result page says "THE SERVER + COULD NOT CONFIRM THIS RUN, SO IT WAS NOT ADDED TO THE LEADERBOARD. REASON CODE: RULES_MISMATCH" + (`rankedResult.ts:175`, `:77`). +5. **The opposite order fails too.** A 1.3.0 APK released before the Worker deploys gets the same block, telling the *newer* app it + "needs a newer version". So today the only safe order is: deploy the Worker first, then publish the APK, and accept that the + older APKs break. +6. Reading the boards keeps working. An old app shows "VERSION UNKNOWN" next to scores from an era it doesn't know + (`src/ranked/scoringEras.ts:19-21`). That is cosmetic. + +Evidence (audit probe: real router + in-memory SQLite): + +``` +PROBE rules-bump first 422 {"code":"replay_rejected",...,"reason":"rules_mismatch","detail":"this run was issued under rules 1.2.0; the server now verifies 1.3.0"} +PROBE rules-bump retry 409 run_rejected row {"status":"rejected","reject_reason":"rules_mismatch"} +PROBE old-client update_required +PROBE runs-ignores-client-version 201 1.2.0 <- asked for 1.1.0 by query AND body; server issued its own +``` + +Can the current design support several versions safely? **Not as it stands, but it is close.** The places that hard-code "one +version" are few: the equality check at `verify.ts:64`, `settings.rulesVersion` at issue time (`runs.ts:90`), the health payload +(`router.ts:51`) and the deploy gate (`scripts/production-health.mjs:20`). Everything else is already per-run: +`runs.rules_version`, `config_json` and `time_limit_ticks` are stored at issue and used at verify time, and `scores.rules_version` +drives the boards. The only true single-version dependency is the import of one simulator (`server/src/verify.ts` → +`src/replay/verifier` → `src/core`). + +### #2 No guard against simulation changes without a rules bump + +`tests/replayDeterminism.test.ts` checks that the *current* code agrees with itself (two runs, different refresh rates). It cannot +notice that today's code differs from last week's. The bot reference score (`server/tests/lifecycle.test.ts:66`, `34735`) does fail +when the sim changes, but the bot replays against the current sim, so the usual fix is to update the number. Commit `c41789e` "update +gain and UFO drop expectations" shows that habit. Nothing ties updating the number to bumping the version. + +What it costs when this slips: clients always send `claimedResult` (`src/replay/recorder.ts:86-131`), so a recording from an older +client verified by drifted code ends in a **final** `score_mismatch` rejection (`verifier.ts:283-293`, `verify.ts`). Honest players +see a cheating-style rejection. Once frozen per-version bundles exist (§5), this guard decides whether a frozen bundle really +reproduces the version it is named after. + +The boss merge (`25aa823`) was checked and changed only tests, so no unbumped sim change has shipped so far. + +### #3 Requests with no token use up the global budget + +`server/src/router.ts:71-72` increments `submit:ip:*` and then `submit:global` **before** `submitRun` checks that the run exists or +that the token is valid. The same happens for starts at `:58-59`. Junk POSTs to random run ids (404) therefore use up the hourly +budget meant to cap verification CPU (default 1200/h). Real players then get 429, which the client turns into "network error" after +two automatic retries. + +``` +PROBE junk 0..2 404 run_not_found (3 junk requests, 3 different IPs, submitGlobal = 3) +PROBE legit-after-junk 429 rate_limited <- a genuine, verifiable run is refused +``` + +Fix: check the per-IP bucket, then load the run and check the token, then count against `submit:global`. Only requests that can +actually reach verification should spend the CPU budget. The start bucket cannot be protected the same way (anyone may start a run); +#4 is what limits that. + +### #4 IPv6 per-IP buckets + +`router.ts:126` hashes the whole `cf-connecting-ip`. A single /64 (an ordinary home line or a cheap VPS) holds 2⁶⁴ addresses. + +``` +PROBE ipv6-rotation 201,201,201,201,201,201 same-ip 201,201,429 (startPerIp = 2) +``` + +Fix: for IPv6, bucket on the /64 prefix. That is one line in `clientHash`. + +### #5 A finished but unsent run lives only in memory + +The token, the challenge and the prepared body are in memory only (`api.ts:14`, `submission.ts`). Only accepted scores reach +`localStorage` (`localScores.ts:91`). On Android, if the player finishes offline, switches apps and the OS kills the WebView, the +run is gone even though the server would still accept it for up to 60 minutes. A fix is to store the `PreparedSubmission` until a +final outcome and offer it again on the next launch. Small, but not needed for a first release. + +### #6 Wording of `rules_mismatch` + +It is a server limitation, not something the player did wrong, yet it uses up the run and displays like a verification failure +(#1, step 4). With #1 fixed it only happens when a version is finally retired. At that point a plain "THE GAME WAS UPDATED DURING +THIS RUN" line in `reasonText` (`rankedResult.ts:75-78`) is enough. + +### #7 Run stuck in `verifying` after its expiry + +If the Worker is killed mid-verification (CPU limit, eviction), the 30 s lease lets a retry take over. But the takeover UPDATE also +requires `expires_at > now` (`runs.ts:155-158`). If the crash falls inside the run's last 30 s, every retry gets +`409 run_in_progress` (`runs.ts:249-250`). The client treats that as temporary, so the player sees an endless "retry" until the daily +prune removes the row a day later. + +``` +PROBE stuck-verifying-after-expiry 409 run_in_progress +``` + +Fix (optional): in `resolveLostClaim`, answer 410 when `status = 'verifying'` and the run has expired. + +### #8 Stale browser-suite expectations + +See §6. + +### #9 POWER-UPS guide: Revive text under the BACK button + +Found by the `menu.mjs` layout review (10 failures, one per screen size: 5 phones, 5 desktops). That review never ran on `main`, +because the suite aborts at line 680 first. Every failure reports the same thing: `[powerups] text "Brings back a teammate w" runs +over button back`. The layout review's screenshot of the iPhone POWER-UPS page (written to a scratch folder, not kept) shows the last row's two-line description cut +off by BACK. Cause: `ccce3ce` added a seventh entry (LIGHTNING) to `POWERUP_INFO` (`src/ui/menu/powerupInfo.ts`), while the guide +page (`src/ui/menu/pages/powerups.ts`, unchanged since Oct 20) still lays rows out for six. This is a real, player-visible +regression in every build, the Android app included. Fix by tightening the row pitch or moving BACK; the layout review will then +check it. + +--- + +## 3. Checked and sound (no action) + +- **Replay tampering.** The server re-simulates. The issued seed, rules version and exact config are enforced, with extra config + keys rejected (`verify.ts:34-47`, `:64-71`). The claimed score is only a cross-check and is never used as the score. A tick cap, + an elapsed-time rule and a strict game-over / exact-time-limit end are all enforced (`verify.ts:73-106`, `verifier.ts:231-279`). +- **Challenge issue and expiry.** Run id is a UUIDv4. The token is 256-bit CSPRNG, only its SHA-256 is stored, and comparison is + constant-time on the hashes. The seed is CSPRNG. The challenge response is `no-store`. Expiry is checked before the body is read, + and the client corrects for its own clock (`localExpiry`). +- **Duplicates and retries.** The client builds the body once and resends identical bytes (`submission.ts`). The server hashes the + *decoded* body, so a gzip resend matches: `PROBE idempotent 200 false | 200 true | 409 run_already_submitted`. +- **Concurrent submissions.** Every state change is a conditional UPDATE or a D1 batch tied to a claim token, with + `scores.run_id UNIQUE` as a backstop. Probe: 8 identical parallel submits → `200, 7×200:replayed`, `scores 1`. Caveat: one JS + thread serialises this probe, so it checks the state machine, not real D1 parallelism. The existing lifecycle tests also cover + different-nickname races, DB failure on finalize, lease takeover and verifier crashes (`lifecycle.test.ts:251-512`). +- **Body limits.** Content-Encoding allow-list, Content-Length pre-check, streaming byte counting, and a cap on decompressed output + that stops gzip bombs (`body.ts`). The body is read only after the token check. +- **CORS.** Correct, and correctly described as hygiene rather than authentication (`router.ts:165-190`). Probe: allowed origin + 201 + ACAO, foreign origin 403, no origin 201, spoofed origin from a non-browser 201 (expected; that is why the run token is the + real credential). The Capacitor origin `https://spacearcade.davidandrea.ca` (`capacitor.config.ts`) matches production + `ALLOWED_ORIGINS`, which only takes effect once the Worker deploys. `dev` changes no sim or server code compared with `main`, only + that origin. +- **Credentials and dev surfaces.** No secret is committed: `.dev.vars.example` holds placeholders, and the production secrets are + generated locally and DPAPI-encrypted under the git-ignored `server/.wrangler/`. Production declares both secrets `required`, so + the `'dev-only-salt'` fallback (`config.ts:106`) cannot reach production. Local origins live only in `[vars]`, which `env.production` + does not inherit. `preview_urls = false`. The admin route doesn't exist without a ≥16-character token, has no CORS headers, and + rate-limits failed attempts. The Android API base cannot be redirected by `?api=` or loopback rules (`api.ts:97-110`), and + `build-android.mjs` enforces the production URL. The only dev-only game hook is gated by `import.meta.env.DEV` + (`GameScene.ts:290`). `.env.android` holds only the public `VITE_LEADERBOARD_API_URL`. +- **DB consistency and cleanup.** CHECK constraints tie status to `score_id` / `reject_reason`, and FKs are on. The daily cron prunes + abandoned runs (expiry + 1 day), rejected runs (30 days) and old rate-limit windows. Accepted runs are kept for their scores. All + growth is capped by the global rate limits. +- **Mobile timeouts.** 10 s for challenge and board fetches; 30 s XHR for submit with automatic retries at 1.5 s and 4 s, then a + manual Retry with the same bytes. A response lost after acceptance comes back as the same score. That is a sensible design for + cellular links. + +## 4. Hypothetical risks (not findings) + +- **Bots / offline optimisation on the revealed seed.** Already documented as known limitation #1 in `docs/leaderboard-backend.md`. + The 60-min TTL against a 20-min run leaves about 40 minutes of offline search. Shortening the TTL trades this against Android + pause/resume tolerance. Leave it as is until there are real players. +- **Carrier-grade NAT** could put unrelated mobile players in one per-IP bucket (30/h). That is unlikely at this scale. Watch for + 429s (`run_rejected` / `rate_limited` are already logged) before acting. +- **Request-flood cost.** As with any public Worker, every request costs a D1 write for the rate-limit row, so cost exposure equals + the attacker's request rate. A Workers Rate Limiting binding in front would be the cheap mitigation if it ever matters. +- **`CapacitorHttp`.** If someone later enables it, requests go native: the `Origin` header and `xhr.upload.onload` (used for the + "verifying" state) behave differently. It is off today. Note it in `docs/android.md`. + +--- + +## 5. Recommended design for several replay-rule versions + +### Compatibility units: three, not two + +| Unit | What it covers | Policy | +|---|---|---| +| **HTTP API** (`/api/v1`) | request envelope, response fields, error codes | Additive only. Never remove or retype a field a supported client reads. A breaking change becomes `/api/v2` running beside v1. | +| **Rules + replay schema** | simulation behaviour and replay JSON shape | **One unit: one frozen verifier bundle.** Each bundle's `validateReplayStructure` already pins both (`verifier.ts:43-47`). Don't give them separate support policies; a schema bump always ships as a new bundle. | +| **Issue policy** | ranked config, time limit | Already stored per run (`config_json`, `time_limit_ticks`). Keep it that way. | + +So the answer to "should schemas and rules have independent compatibility policies" is: **keep them distinguishable, but support +them together.** Two independent support matrices would cost more than they give. The axis that truly needs its own policy is the +HTTP API. + +### Shape (the whole design) + +``` +server/rules/1.2.0.mjs frozen copy of dist/node/index.js, built while 1.2.0 was current. Never edited. +server/rules/fixtures/1.2.0/*.json golden replays + expected {score, totalTicks, endReason}. Never edited. +server/rules/released.json rules versions shipped in Play builds (+ release date) +server/src/engines.ts ~10 lines: +``` + +```ts +import * as current from '../../src/replay'; +import * as v1_2_0 from '../rules/1.2.0.mjs'; +type Engine = Pick; +export const ENGINES: Readonly> = { '1.2.0': v1_2_0, [current.GAMEPLAY_RULES_VERSION]: current }; +``` + +Changes to existing code: + +- **Client** (`api.ts:130`): `POST /api/v1/runs?rules=${GAMEPLAY_RULES_VERSION}&schema=${REPLAY_SCHEMA_VERSION}`. A query string + keeps it a CORS "simple" request, so mobile pays no extra preflight round trip. The server can ignore it until the registry lands. +- **Issue** (`router.ts` / `runs.ts:90`): `rules = ENGINES[asked] ? asked : current`, and issue that engine's schema version. For an + unsupported or missing version the server keeps doing exactly what it does today. The client check already shipped + (`api.ts:142`) then shows the correct "update the app" message, with no new error path. That fallback is also what makes the + query parameter safe to add now. +- **Verify** (`verify.ts:64`): swap the equality for `const engine = ENGINES[run.rulesVersion]` (missing → `rules_mismatch`) and + call `engine.verifyReplay(...)`. The `verifyReplay(replay, { maxTicks, requireGameOver, timeLimitTicks })` signature becomes a + contract that every bundle must keep. The fixture test enforces it. +- **Health** (`router.ts:51`): add `supportedRules: Object.keys(ENGINES)`. Keep `rulesVersion` (current) for existing readers. +- **Freeze step**: `npm run rules:freeze` builds the SSR bundle from the *current* tree into `server/rules/.mjs` and records + a sha256. Run it **before** editing gameplay for the next bump. No worktrees, tags or old toolchains. +- **Boards**: no change in mechanics. `SCORING_ERAS` decides each time: put a small balance bump in the *same* era so old-app and + new-app players share the weekly board, or give it a new era so old-app scores appear only on all-time. That is a product call per + bump. +- **Retirement**: remove an engine once usage is near zero and a window has passed (say 30 days after the successor APK reached + 100 % in Play). Usage needs no new telemetry, because `runs.rules_version` already records it: + `SELECT rules_version, COUNT(*) FROM runs WHERE created_at > ? GROUP BY 1`. + +Cost: about 26 KB gzipped per retained version, against the 10 MB compressed limit on Workers Paid. CPU per submit is unchanged, +since one engine runs. + +Alternatives considered and rejected: +- *Version flags inside `src/core`* (`if rules >= 1.3`): every balance tweak turns into permanent branches in the hot loop, and old + versions break silently. +- *One Worker per rules version*: duplicates the backend, D1 binding, cron and secrets, and cross-version ranks would need + coordination. +- *Rebuilding old bundles from git tags in CI*: depends on old toolchains reproducing byte-for-byte. A committed artifact is simpler + and easy to audit. + +### How CI catches breaking changes before deploy + +1. **Golden fixtures.** A unit test checks every `fixtures//*.json` through `ENGINES[v]` and asserts the recorded result. The + fixture for the current version fails when gameplay changes without a bump, and the only way to make it pass is to bump and + freeze. The existing bot (`server/testing/bot.mjs`, `REFERENCE_SEED`) can generate a game-over run plus a time-limited run. +2. **Immutability.** A CI step checks that + `git diff --name-only --diff-filter=MD origin/main...HEAD -- phaser-asteroids/server/rules` is empty. Adding files is allowed. +3. **Supported-set guard.** A unit test requires every version in `released.json` that is still inside its window to be in + `ENGINES`. `scripts/production-health.mjs` checks `supportedRules ⊇ released ∪ {current}` after deploy. CI then refuses to + promote a Worker that strands an installed app. +4. **APK preflight.** When building a release, `build-android.mjs` GETs production `/health` and refuses if the app's rules version + is not in `supportedRules`. That covers the "APK before Worker" hazard. It is a read-only GET. + +**Interim minimum, before the registry exists:** `released.json` plus one test: "if `released.json` is not empty, +`GAMEPLAY_RULES_VERSION` must be listed in it." That blocks any rules bump while an APK is live. It is crude but enough for the +release. + +### Is a staged rollout worth it? + +- **Yes, as an order of steps** for each rules bump: *expand* (the Worker verifies old and new) → *migrate* (web updates at once; + the APK goes through Play) → *contract* (retire the old engine after the window). This is what removes the cliff. +- **Yes, Play Console staged rollout** for the first releases. It is free and catches WebView or device problems, not rules problems. +- **Not now: Cloudflare gradual deployments, or a separate staging Worker.** When every Worker serves a superset of versions, any + version can verify any run, and `wrangler rollback` is enough. LAN `wrangler dev` already covers device testing + (`docs/android-lan-testing.md`). Add a staging Worker only if a Play internal-testing track needs a stable backend. + +--- + +## 6. Root cause of the two failing browser suites + +**Classification: outdated test expectations.** Not app regressions, not timing, not Android. The test harness itself is fine. +One environmental detail changes the error text but not the outcome (below). Once the suites could run past those points, they +also exposed a real layout regression (#9) and a pre-existing intermittent flake. + +### Cause A: phone PLAY became ranked (`5033ac8`, 2026-10-23); both suites + +`5033ac8` "add mobile entry point for practice mode" made a one-player touch or coarse-pointer title use `buildMobilePlay` +(`title.ts:205-227`). There, **PLAY = ranked** ("ONLINE LEADERBOARD / 20:00 LIMIT") and the casual game is **PRACTICE**. +`StartScene.start()` sends PLAY to `requestRanked()` (`StartScene.ts:282-292`). That commit added `scripts/mobile-entry.mjs` and +`tests/mobileEntry.test.ts`, but `touch.mjs` and `menu.mjs` were last edited Oct 21–22 and still tap `play` expecting `GameScene`. +No Worker runs during these suites, so the challenge request fails and the scene never changes. Each suite has a 5 s +`waitForFunction` that throws, which **aborts the rest of the suite**. + +Phone probe (844×390, `isMobile`, `hasTouch`, fresh build of HEAD): + +``` +title items: ["play=PLAY","practice=PRACTICE","scores=HIGH SCORES","audio=AUDIO","controls=CONTROLS","ranked=RANKED INFO","powerups=POWER-UPS"] +after PLAY + 5 s: scene = StartScene | menu page = ranked | ranked = {"phase":"failed",...,"message":"The ranked service could not be reached"} +network: ["REQ POST http://127.0.0.1:8787/api/v1/runs","FAILED POST http://127.0.0.1:8787/api/v1/runs net::ERR_FAILED"] +after PRACTICE + 1.5 s: scene = GameScene +``` + +Stale sites: +- `scripts/touch.mjs:1596-1597`: the shared `play()` helper. This is the reported timeout, and the first section already calls it. +- `scripts/touch.mjs:1028-1029`: iOS "Fullscreen unsupported" section, same pattern. +- `scripts/touch.mjs:1958` and `:1963-1964`: a phone in keyboard mode now also gets the mobile layout (`title.ts:73`), so the label + is `PLAY`, not `PLAY WITH KEYBOARD`, and Space (the PLAY hotkey) goes to ranked. +- `scripts/touch.mjs:1986`: `?touch=0` on a phone expects `PLAY WITH KEYBOARD`. A probe shows `?touch=0` is honoured + (`tc-active` absent); only the label changed. +- `scripts/menu.mjs:679-680`: the reported timeout. +- `scripts/menu.mjs:847-848`: the phone layout review. It never runs today because the suite aborts at 680. + +Environmental detail: `127.0.0.1:8787` is held by `wslrelay` (a WSL port-forward running since Oct 30), so the failure shows as a +CORS rejection rather than connection refused. If a permissive local Worker were ever listening there, these suites would quietly +start **ranked** runs instead of casual ones. That is one more reason to tap PRACTICE. + +### Cause B: legend text changed by Chain Lightning (`ccce3ce`, 2026-10-23); menu.mjs only + +`ccce3ce` changed MEGA POWER's short label from `'All powers!'` to `'4 powers!'` (`src/ui/menu/powerupInfo.ts`) and added +LIGHTNING. `scripts/menu.mjs:289` still requires `'All powers!'`, and the probe confirms the title shows `4 powers!` and +`LIGHTNING`. This is the "power-ups text assertion failure" logged just before the timeout. + +### Confirmation run: patched copies + +A small script copied both suites into a scratch folder. It corrected only the stale sites above (PLAY → PRACTICE +where PRACTICE exists, `All powers!` → `4 powers!`; for the keyboard-on-phone case, one key press followed by the scene's own +`playNormally()`) and pointed screenshots at the scratch folder. The suites ran one after another with nothing else running, against a +fresh build of HEAD. + +| Suite | Result | Remaining failures | +|---|---|---| +| `touch.mjs` (full, 4m44s) | **356 pass / 3 fail** (previously aborted after a few checks) | 2 × stale label (`:1958`, `:1986`, cause A); 1 × intermittent flake (below) | +| `menu.mjs` (full) | **117 pass / 10 fail** (previously aborted at 680) | 10 × the real POWER-UPS overlap, one per screen size (#9) | + +**Intermittent flake: `touch.mjs:189` "[Point-to-Fly] thumb … four diagonals".** I ran the movement section on its own 4 more +times. It failed in 2 of 5 runs overall, each time on a *different* diagonal (`up-right: rot 295 vs 225`, `down-left: rot 20 vs +45`), and passed in the other three. The turn rate is 300°/s (`src/core/constants.ts:70`), so under a constant command every case +settles well inside the 0.9 s of *simulated* time the check waits. Ending 25–70° off means the input changed during the window: a +race in the test's finger-up → 60 ms → recentre → finger-down loop (`touch.mjs:169-180`), not a steering defect. The steering +path is the same on `dev` and `main`: the only touch changes on `dev` are the fullscreen environment and CSS safe-area fallbacks, +which resolve to the same `env()` values in a browser. Earlier sessions logged similar one-off movement flakes in this suite. I +did not A/B it against a `main` worktree. Do that only if it starts failing consistently. + +--- + +## 7. Minimal implementation plan, in order + +**Before the Android release** + +1. Client sends `?rules=&schema=` on `POST /api/v1/runs` (`api.ts:130`), plus a unit test. The server ignores it for now. About + 3 lines. +2. Add a golden replay fixture for 1.2.0 (bot-generated: game over + time limit), a test that verifies it, and the CI + immutability step. +3. Add `server/rules/released.json` and the interim guard ("no rules bump while an APK is live"). +4. Update the 7 stale browser-suite sites (§6) so `touch` and `menu` become a usable regression signal for release testing. Then + fix the POWER-UPS layout (#9), which the layout review will check. +5. Deploy the Worker (Android origin) before handing out any APK, then run the device checklist (`docs/android.md`). + +**Before the first rules bump after release** + +6. Freeze script, `server/rules/1.2.0.mjs`, `engines.ts`, the issue/verify changes, `supportedRules` in health, and the updated + health gate and APK preflight. +7. Write the bump runbook into `docs/leaderboard-backend.md` §8: freeze → change gameplay → bump → add new fixture → decide the + era → merge (the Worker now serves both) → build and submit the APK → retire after the window. + +**Can wait** + +8. Rate limits: count `submit:global` after the token check, and bucket IPv6 by /64 (#3, #4). +9. Keep the prepared submission until a final outcome (#5). +10. Answer 410 for expired-while-verifying runs (#7), and give `rules_mismatch` friendlier wording (#6). + +## 8. Before release vs later + +| Before release | Can wait | +|---|---| +| Client sends its rules version (#1) | Full engine registry (needed before the *first post-release* rules bump) | +| CI guard: golden fixture + immutability + released-version guard (#1, #2) | Global-budget ordering, IPv6 /64 buckets (#3, #4) | +| Worker deployed with the Android origin before any APK goes out | Persisting unsent runs (#5) | +| Stale suite expectations fixed, so release testing has a working signal (#8) | 410 for expired-while-verifying; `rules_mismatch` wording (#6, #7) | +| POWER-UPS Revive/BACK overlap (#9) | Point-to-Fly diagonal test race (§6) | +| Device checklist (already planned) | Bot detection, staging Worker, Cloudflare gradual deploys | From 6943ac3bbe317bc66159abd9ee09109f7f8f563f Mon Sep 17 00:00:00 2001 From: djblackett <49618491+djblackett@users.noreply.github.com> Date: Mon, 2 Nov 2026 11:07:04 -0400 Subject: [PATCH 03/10] fix(menu): fit the POWER-UPS guide's rows above BACK Chain Lightning added a seventh entry to POWERUP_INFO, but the guide still laid rows out at a fixed 74 px pitch from y=130, so the last row (Revive) and its two-line description ran under the BACK button at every phone and desktop size. The rows now start higher and their pitch shrinks to fit the space between the title and BACK (capped at the old 74 px). Found by the menu.mjs layout review once the suite could run past its stale PLAY tap. Co-Authored-By: Claude Opus 5.5 --- phaser-asteroids/src/ui/menu/pages/powerups.ts | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/phaser-asteroids/src/ui/menu/pages/powerups.ts b/phaser-asteroids/src/ui/menu/pages/powerups.ts index ff55fbb..f2ec9ab 100644 --- a/phaser-asteroids/src/ui/menu/pages/powerups.ts +++ b/phaser-asteroids/src/ui/menu/pages/powerups.ts @@ -5,10 +5,13 @@ import type { MenuContext, PageNav } from '../context'; import type { PageDef } from '../menuView'; import { POWERUP_INFO } from '../powerupInfo'; import { iconClock, TEXT, type PageKit } from '../widgets'; -import { backButton, pageTitle } from './common'; +import { BACK_Y, backButton, pageTitle } from './common'; -const FIRST_Y = 130; -const STEP = 74; +// The rows share the space between the title and BACK. Seven rows (LIGHTNING made it seven) at the old 74 px pitch ran the last +// description into BACK; the pitch now shrinks to fit, and never grows past what two-line descriptions look right at. +const FIRST_Y = 92; +const LAST_Y = BACK_Y - 16; +const STEP = Math.min(74, Math.floor((LAST_Y - FIRST_Y) / POWERUP_INFO.length)); const ICON_X = 90; const NAME_X = 160; const DETAIL_X = 470; From c7726ce97fb171328b31ad137f80d1d1f811703a Mon Sep 17 00:00:00 2001 From: djblackett <49618491+djblackett@users.noreply.github.com> Date: Mon, 2 Nov 2026 11:36:50 -0400 Subject: [PATCH 04/10] test(touch): fix two movement checks that raced the simulation The Point-to-Fly "four diagonals" check failed at random (2 of 5 runs in the audit). recentre() emptied the asteroids but never the UFOs: a UFO was alive in every direction case, and when it hit the ship (lives 99 -> 98) the ship respawned facing 0 and was still re-turning when the window ended. recentre() and quiet() now remove UFOs and their shots and stop new ones; the failure detail includes the ship's lives so a hit shows up. Movement section: 6/6 clean runs afterwards, against 1 hit in 4 before. The "Assisted Flight gets going up sooner" check measured between two wall-clock snapshots, so its window varied by a tick or more (~5 px) with browser latency, once landing inside the 10 px margin. It now traces sim.step and measures exactly 0.35 s of simulation time from the step that first received the flick. Same assertion and margins; the result is now identical on every run (Assisted 91 px up / 26 px sideways, Point-to-Fly 75 / 55). Co-Authored-By: Claude Opus 5.5 --- phaser-asteroids/scripts/touch.mjs | 45 ++++++++++++++++++++++++++---- 1 file changed, 39 insertions(+), 6 deletions(-) diff --git a/phaser-asteroids/scripts/touch.mjs b/phaser-asteroids/scripts/touch.mjs index 4654be9..2a186df 100644 --- a/phaser-asteroids/scripts/touch.mjs +++ b/phaser-asteroids/scripts/touch.mjs @@ -117,11 +117,19 @@ const angleApart = (a, b) => Math.abs((((a - b) % 360) + 540) % 360 - 180); const headingOfMove = (dx, dy) => ((((Math.atan2(-dx, dy) * 180) / Math.PI) % 360) + 360) % 360; /** Puts the ship at the middle of the playfield facing `rot`, with nothing else going on, and waits a moment. */ +/** + * Puts the ship back in the middle, facing `rot`, in an empty world. UFOs and their shots go too, and none are scheduled: the UFO + * timer keeps running in these long sections, and a hit sends the ship to the respawn point facing 0, which once made a movement + * check fail at random (the ship was re-turning when the window ended). + */ async function recentre(t, rot = 0) { await t.page.evaluate( ([rot]) => { const s = window.__game.scene.getScene('GameScene').sim; s.spawner.spawnTimer = -1e9; + s.ufoSpawner.enabled = false; + s.ufos.length = 0; + s.ufoShots.length = 0; s.asteroids.length = 0; s.player.position = { x: 640, y: 360 }; s.player.rotation = rot; @@ -184,7 +192,7 @@ async function runMovement() { angleApart(after.rot, heading) < 2 && Math.hypot(after.x - before.x, after.y - before.y) > 150; // Assisted travels straight at the thumb; Point-to-Fly curves round while it is still turning, so only the later part is straight. const straight = mode === 'assisted' ? angleApart(moved, heading) < 25 : true; - results.push(`${name}:${ok && straight ? 'ok' : `BAD(${JSON.stringify([cmd.steer, Math.round(after.rot), Math.round(moved)])})`}`); + results.push(`${name}:${ok && straight ? 'ok' : `BAD(${JSON.stringify([cmd.steer, Math.round(after.rot), Math.round(moved), { lives: after.lives }])})`}`); } check(`[${label}] thumb up / down / left / right and the four diagonals: the nose settles on that heading and the ship flies off`, results.every((r) => r.endsWith(':ok')), results.join(' ')); await t.finger.up(1); @@ -291,13 +299,38 @@ async function runMovement() { await t.finger.down(1, 150, 250); await t.finger.move(1, 150 + 46, 250); // right await simSeconds(t, 0.5); - const a = await t.sim(); + // Measure in simulation time from the step that first received the flick, not between two wall-clock snapshots: how long the + // flick takes to reach the game varies, and at ~5 px per tick that once moved the result by more than the margin below. + await t.page.evaluate(() => { + const s = window.__game.scene.getScene('GameScene').sim; + const step = s.step.bind(s); + window.__flickTrace = []; + s.step = (dt, input, input2) => { + const before = { t: s.time, x: s.player.position.x, y: s.player.position.y }; + const events = step(dt, input, input2); + window.__flickTrace.push({ ...before, t1: s.time, x1: s.player.position.x, y1: s.player.position.y, heading: input?.steer?.heading ?? null }); + return events; + }; + }); await t.finger.move(1, 150, 250 - 46); // flick to up - await simSeconds(t, 0.35); - const b = await t.sim(); + const WINDOW = 0.35; + await t.page.waitForFunction((w) => { + const tr = window.__flickTrace; + const k = tr.findIndex((e) => e.heading !== null && Math.abs(e.heading - 180) < 1); + return k >= 0 && tr[tr.length - 1].t1 >= tr[k].t + w; + }, WINDOW, { timeout: 8000, polling: 16 }); + const { start, end } = await t.page.evaluate((w) => { + const tr = window.__flickTrace; + delete window.__game.scene.getScene('GameScene').sim.step; // back to the class's own step + const k = tr.findIndex((e) => e.heading !== null && Math.abs(e.heading - 180) < 1); + const at = tr[k].t + w; + const e = tr.find((x) => x.t1 >= at); + const f = e.t1 === e.t ? 1 : (at - e.t) / (e.t1 - e.t); // position exactly `w` seconds after the flick, within that step + return { start: { x: tr[k].x, y: tr[k].y }, end: { x: e.x + (e.x1 - e.x) * f, y: e.y + (e.y1 - e.y) * f } }; + }, WINDOW); await t.finger.up(1); await sleep(80); - return { sideways: b.x - a.x, up: a.y - b.y }; + return { sideways: end.x - start.x, up: start.y - end.y }; }; const p = await trial('pointToFly'); const a = await trial('assisted'); @@ -1574,7 +1607,7 @@ async function mobilePage(width, height, { query = '?debug', mobile = true, touc x: p.position.x, y: p.position.y, rot: p.rotation, lives: p.lives, score: p.score, phase: s.phase, shots: s.shots.length, laser: p.laser.shotsRemaining, boost: p.boost.active, boostCd: p.boost.cooldown, retry: s.retryDelay, paused: sc.paused, time: s.time }; })()`), quiet: () => - page.evaluate(`(() => { const s = window.__game.scene.getScene('GameScene').sim; s.spawner.spawnTimer = -1e9; s.asteroids.length = 0; s.shots.length = 0; s.startCooldown = 0; })()`), + page.evaluate(`(() => { const s = window.__game.scene.getScene('GameScene').sim; s.spawner.spawnTimer = -1e9; s.ufoSpawner.enabled = false; s.ufos.length = 0; s.ufoShots.length = 0; s.asteroids.length = 0; s.shots.length = 0; s.startCooldown = 0; })()`), audio: () => page.evaluate(`(() => { const g = window.__game, a = g.registry.get('audio'), m = a.musicSound; return { locked: g.sound.locked, ctx: g.sound.context ? g.sound.context.state : 'n/a', playing: !!m && m.isPlaying, paused: !!m && m.isPaused, From a6641ea0b6932b8804a6331cac8772e5c9d57a68 Mon Sep 17 00:00:00 2001 From: djblackett <49618491+djblackett@users.noreply.github.com> Date: Mon, 2 Nov 2026 11:37:05 -0400 Subject: [PATCH 05/10] test(browser): update suites for the ranked-first phone menu 5033ac8 made PLAY on a one-player phone the ranked entry (casual play is PRACTICE) and a740fe1 / ccce3ce changed some texts, but touch.mjs, menu.mjs and ranked-browser.mjs still expected the old behaviour. Each stale PLAY tap timed out and aborted the rest of its suite. - touch.mjs / menu.mjs: tap PRACTICE where a casual game is wanted; a phone in keyboard mode keeps the PLAY / PRACTICE entry, so check that, and that a tap on PRACTICE asks for a keyboard first and a finger cannot press START WITH KEYBOARD; ?touch=0 is checked by the touch-on button rather than the old "PLAY WITH KEYBOARD" label; the rotate-prompt check taps where PRACTICE is (a tap on PLAY never starts a game on a phone). - menu.mjs: the legend lists six one-player power-ups (LIGHTNING / Chain hits, and MEGA POWER says "4 powers!"). - ranked-browser.mjs: nicknames are shown as typed, and the outage page says "YOU CAN STILL PLAY PRACTICE.". touch 360/360, menu 127/127, ranked-browser 61/61. Co-Authored-By: Claude Opus 5.5 --- phaser-asteroids/scripts/menu.mjs | 8 ++--- phaser-asteroids/scripts/ranked-browser.mjs | 4 +-- phaser-asteroids/scripts/touch.mjs | 34 +++++++++++++-------- 3 files changed, 28 insertions(+), 18 deletions(-) diff --git a/phaser-asteroids/scripts/menu.mjs b/phaser-asteroids/scripts/menu.mjs index 58f7fcd..d8acc49 100644 --- a/phaser-asteroids/scripts/menu.mjs +++ b/phaser-asteroids/scripts/menu.mjs @@ -286,7 +286,7 @@ async function run() { // RANKED is PLAY's twin (same size, same row, to its right); every secondary button is smaller and below them. check('PLAY (with RANKED beside it) is the biggest button and sits above the secondary buttons, with PLAY focused first', play.h > Math.max(...others.map((i) => i.h)) && play.y < Math.min(...others.map((i) => i.y)) && ranked.y === play.y && ranked.h === play.h && ranked.w === play.w && ranked.x > play.x + play.w && snap.focus === 'play'); check('the title screen answers "how do I control my ship": the real keys with what they do', ['HOW TO PLAY', 'W', 'S', 'A', 'D', 'SPACE', 'E', 'SHIFT', 'Move forward / back', 'Turn left / right', 'Laser beam', 'Boost'].every((t) => words.includes(t)) && words.some((t) => /^Shoot/.test(t)), words.slice(0, 20).join(' | ')); - check('...and "what do the power-ups do": all five with their in-game names and a few words each', ['RAPID FIRE', 'MULTI-SHOT', 'SHIELD', 'SLOW MOTION', 'MEGA POWER', 'Shoot faster', 'Triple shot', 'Blocks 1 hit', 'Slow asteroids', 'All powers!'].every((t) => words.includes(t)) && !words.includes('REVIVE'), words.join(' | ').slice(0, 300)); + check('...and "what do the power-ups do": all six one-player power-ups with their in-game names and a few words each', ['RAPID FIRE', 'MULTI-SHOT', 'SHIELD', 'SLOW MOTION', 'LIGHTNING', 'MEGA POWER', 'Shoot faster', 'Triple shot', 'Blocks 1 hit', 'Slow asteroids', 'Chain hits', '4 powers!'].every((t) => words.includes(t)) && !words.includes('REVIVE'), words.join(' | ').slice(0, 300)); check('no settings on the first screen: no volumes, music, track, haptics, steering, controller status', !words.some((t) => /VOLUME|SOUND EFFECTS|^MUSIC|HAPTIC|STEERING|TRACK|Controller/i.test(t)), words.join(' | ').slice(0, 300)); await d.shot('desktop-title'); @@ -676,11 +676,11 @@ async function run() { // phones: a touch on a menu never also steers, shoots or fires the laser / boost const tp = await open({ w: 844, h: 390, touch: true }); await tp.goto(); - await tp.tap('play'); + await tp.tap('practice'); // PLAY on a one-player phone is the ranked entry; PRACTICE is the casual game await tp.page.waitForFunction(() => window.__game.scene.isActive('GameScene'), null, { timeout: 5000 }); await sleep(400); await tp.page.evaluate(`(() => { const s = window.__game.scene.getScene('GameScene').sim; s.spawner.spawnTimer = -1e9; s.asteroids.length = 0; s.player.lives = 99; })()`); - check('PLAY started the run and the finger that tapped it fired nothing', (await tp.sim()).shots === 0 && (await tp.sim()).laser === 15 && !(await tp.sim()).boost); + check('PRACTICE started the run and the finger that tapped it fired nothing', (await tp.sim()).shots === 0 && (await tp.sim()).laser === 15 && !(await tp.sim()).boost); const pauseBtn = await tp.page.evaluate(() => { const r = document.querySelector('.tc-pause').getBoundingClientRect(); return { x: r.left + r.width / 2, y: r.top + r.height / 2 }; }); await tp.page.touchscreen.tap(pauseBtn.x, pauseBtn.y); await sleep(500); @@ -844,7 +844,7 @@ async function run() { await p.tap('controls'); await review('controls'); await p.tap('back'); - await p.tap('play'); + await p.tap('practice'); await p.page.waitForFunction(() => window.__game.scene.isActive('GameScene'), null, { timeout: 5000 }); await sleep(400); await p.page.evaluate(() => window.dispatchEvent(new Event('blur'))); diff --git a/phaser-asteroids/scripts/ranked-browser.mjs b/phaser-asteroids/scripts/ranked-browser.mjs index 826b48a..301c2d3 100644 --- a/phaser-asteroids/scripts/ranked-browser.mjs +++ b/phaser-asteroids/scripts/ranked-browser.mjs @@ -230,7 +230,7 @@ try { await sleep(500); await clickItem(page, 'ranked', 'title'); await waitText(page, 'StartScene', /^YOUR BEST VERIFIED SCORE:/); - check('after a reload the ranked page still shows the verified personal best', (await sceneTexts(page, 'StartScene')).some((t) => t.includes(browserScore.toLocaleString('en-US')) && t.includes(NICK.toUpperCase()))); + check('after a reload the ranked page still shows the verified personal best', (await sceneTexts(page, 'StartScene')).some((t) => t.includes(browserScore.toLocaleString('en-US')) && t.includes(NICK))); await page.evaluate(() => localStorage.clear()); await page.reload(); await page.waitForFunction(() => window.__game?.scene.isActive('StartScene'), null, { timeout: 20000 }); @@ -266,7 +266,7 @@ try { await down.waitForFunction(() => window.__ASTEROIDS_RANKED__?.phase === 'failed', null, { timeout: 15000 }); await sleep(500); const downTexts = await sceneTexts(down, 'StartScene'); - check('ranked play with the backend down stays on the title screen and says so, in plain words', downTexts.includes('RANKED PLAY IS TEMPORARILY UNAVAILABLE.') && downTexts.includes('YOU CAN STILL PLAY NORMALLY.') && (await down.evaluate(() => !window.__game.scene.isActive('GameScene')))); + check('ranked play with the backend down stays on the title screen and says so, in plain words', downTexts.includes('RANKED PLAY IS TEMPORARILY UNAVAILABLE.') && downTexts.includes('YOU CAN STILL PLAY PRACTICE.') && (await down.evaluate(() => !window.__game.scene.isActive('GameScene')))); const downItems = await menuItems(down, 'title'); check('it offers TRY AGAIN, PLAY NORMALLY and BACK (never a dead end)', ['start', 'play-normally', 'back'].every((id) => downItems.items.some((i) => i.id === id))); await clickItem(down, 'back', 'title'); diff --git a/phaser-asteroids/scripts/touch.mjs b/phaser-asteroids/scripts/touch.mjs index 2a186df..843f4c0 100644 --- a/phaser-asteroids/scripts/touch.mjs +++ b/phaser-asteroids/scripts/touch.mjs @@ -1058,7 +1058,7 @@ async function runFullscreen() { await ios.finger.tap(ok.x, ok.y, 70); await sleep(200); check('OK closes the tip, and the title screen is unaffected', !(await ios.page.evaluate(() => document.querySelector('.tc-tip').classList.contains('tc-tip-open'))) && (await ios.activeScene()) === 'StartScene'); - await ios.tapItem('play'); + await ios.tapItem('practice'); await ios.page.waitForFunction(() => window.__game.scene.isActive('GameScene'), null, { timeout: 5000 }); await sleep(300); check('the game itself is unaffected by the missing Fullscreen API (starts and plays)', (await ios.overlayShown()) && !(await pillState(ios)).shown); @@ -1624,9 +1624,12 @@ async function mobilePage(width, height, { query = '?debug', mobile = true, touc if (steering === 'joystick') await page.evaluate(() => window.__game.registry.get('touchControls').setSteering('joystick')); await sleep(250); }, - /** Taps PLAY and waits for the run. */ + /** + * Taps PRACTICE and waits for the run. On a one-player phone PLAY is the ranked entry (it needs the leaderboard service, which + * these tests do not run); PRACTICE is the same game without an online score. + */ play: async () => { - await api.tapItem('play'); + await api.tapItem('practice'); await page.waitForFunction(() => window.__game.scene.isActive('GameScene'), null, { timeout: 5000 }); await sleep(350); }, @@ -1661,7 +1664,7 @@ async function run() { check('the rotate prompt is not shown in landscape', (await m.rect('.tc-rotate')).display === 'none'); await m.play(); - check('tapping PLAY (a real touch) starts a one-player run', (await m.activeScene()) === 'GameScene' && (await m.page.evaluate(`window.__game.scene.getScene('GameScene').sim.players.length`)) === 1); + check('tapping PRACTICE (a real touch) starts a one-player run', (await m.activeScene()) === 'GameScene' && (await m.page.evaluate(`window.__game.scene.getScene('GameScene').sim.players.length`)) === 1); const a1 = await m.audio(); check('that touch unlocks audio and starts exactly one music instance', !a1.locked && a1.playing && a1.instances === 1, JSON.stringify(a1)); check('the control overlay appears in landscape during play', await m.overlayShown()); @@ -1987,14 +1990,19 @@ async function run() { const turnOn = await m.itemRect('touch-on'); const turnOnTexts = await m.texts('StartScene'); check('the way back is a big button, not small text: at least 44 CSS px tall and 120 wide, top right, labelled in words', turnOn.height >= 44 && turnOn.width >= 120 && turnOn.top < 40 && turnOn.right > 422 && turnOnTexts.some((t) => /^TOUCH CONTROLS: OFF\nTAP TO TURN ON$/.test(t)), JSON.stringify({ w: Math.round(turnOn.width), h: Math.round(turnOn.height), texts: turnOnTexts.filter((t) => /TOUCH/.test(t)) })); - const playLabel = (await m.menu()).items.find((i) => i.id === 'play'); - check('a phone in keyboard mode offers PLAY WITH KEYBOARD, which says it needs SPACE (the green button above is the main thing)', playLabel.label === 'PLAY WITH KEYBOARD' && turnOnTexts.includes('PRESS SPACE ON A KEYBOARD'), turnOnTexts.filter((t) => /PLAY|SPACE/.test(t)).join('|')); + const keyboardTitle = (await m.menu()).items; + const playLabel = keyboardTitle.find((i) => i.id === 'play'); + check('a phone in keyboard mode keeps the phone entry (PLAY for ranked, PRACTICE beside it; the green button above is the way back)', playLabel?.label === 'PLAY' && keyboardTitle.some((i) => i.id === 'practice'), keyboardTitle.map((i) => `${i.id}=${i.label}`).join('|')); await m.tapGame(300, 300); // empty space, over the controls reference await m.tapGame(640, 52); // the title itself - await m.tapItem('play'); // a tap on PLAY WITH KEYBOARD: a phone has no keyboard, so a tap alone does not start it either + await m.tapItem('practice'); // no keyboard has been used yet, so a tap alone must not start a game nobody could steer await sleep(400); - check('a stray tap anywhere on the keyboard title screen of a phone, even on PLAY itself, does NOT start a game', (await m.activeScene()) === 'StartScene'); - await m.page.keyboard.press('Space'); + const gate = await m.menu(); + check('a stray tap anywhere on the keyboard title screen of a phone, even on PRACTICE itself, does NOT start a game: it asks for a keyboard first', (await m.activeScene()) === 'StartScene' && gate.page === 'practice' && gate.items.some((i) => i.id === 'start'), JSON.stringify({ page: gate.page, items: gate.items.map((i) => i.id) })); + await m.tapItem('start'); + await sleep(300); + check('...and a finger cannot press its START WITH KEYBOARD', (await m.activeScene()) === 'StartScene'); + await m.page.keyboard.press('Enter'); await m.page.waitForFunction(() => window.__game.scene.isActive('GameScene'), null, { timeout: 5000 }); await sleep(250); check('in keyboard mode no touch controls are shown and touches do nothing to the ship', !(await m.overlayShown()) && (await m.cmd()).shoot === false); @@ -2016,7 +2024,8 @@ async function run() { // ?touch=0 on a phone: the URL decides for the visit const forced = await mobilePage(844, 390, { query: '?debug&touch=0' }); await forced.start(); - check('?touch=0 forces the keyboard game on a phone', !(await forced.bodyClasses()).includes('tc-active') && (await forced.texts('StartScene')).includes('PLAY WITH KEYBOARD')); + const forcedItems = (await forced.menu()).items; + check('?touch=0 forces the keyboard game on a phone (touch controls off, the way back to touch offered)', !(await forced.bodyClasses()).includes('tc-active') && forcedItems.some((i) => i.id === 'touch-on') && forcedItems.some((i) => i.id === 'practice'), forcedItems.map((i) => i.id).join('|')); check('...and saves nothing (the URL only decides for this visit)', (await forced.page.evaluate(() => localStorage.getItem('asteroids.inputMode'))) === null); // The way back must also survive a clumsy touch: two fingers landing on it together switch once, not twice (back to keyboard). const turnOn3 = await forced.itemRect('touch-on'); @@ -2069,8 +2078,9 @@ async function run() { const portrait = await mobilePage(390, 844); await portrait.start(); check('opening the page in portrait shows the rotate prompt straight away', (await portrait.rect('.tc-rotate')).display !== 'none'); - const playBox = (await portrait.menu()).items.find((i) => i.id === 'play'); - await portrait.tapGame(playBox.x + playBox.w / 2, playBox.y + playBox.h / 2); // a tap where PLAY is must not start a game + // PRACTICE, not PLAY: on a phone PLAY only opens the ranked page, so a tap on it would never start a game anyway. + const playBox = (await portrait.menu()).items.find((i) => i.id === 'practice'); + await portrait.tapGame(playBox.x + playBox.w / 2, playBox.y + playBox.h / 2); // a tap where PRACTICE is must not start a game await sleep(300); check('and a tap through the prompt does not start a game', (await portrait.activeScene()) === 'StartScene'); await portrait.shot('08-portrait-start'); From 662a964c40d281cb10d616a1d5225f5c1275dfc9 Mon Sep 17 00:00:00 2001 From: djblackett <49618491+djblackett@users.noreply.github.com> Date: Mon, 2 Nov 2026 11:37:18 -0400 Subject: [PATCH 06/10] fix(server): spend the global submit budget only after the token check The router counted every POST /runs/:id/submit against submit:global before submitRun had loaded the run or checked its token, so junk requests to random run ids from many addresses could use up the hourly verification budget (default 1200) and make every honest submission fail with 429. The per-address bucket still runs first, before any work. The global bucket is now charged by submitRun once the run exists, the caller has shown its token and the run is still open (not rejected or expired), just before the body is read. Authentication, the per-address limit and the global ceiling on verification are unchanged for requests that can actually reach verification. Regression tests: unknown runs, malformed ids, missing and wrong tokens leave the global counter at zero and a real run still verifies; token holders are still capped (third of three gets 429 and stays issued); expired and rejected runs answer 410 / 409, not 429. Co-Authored-By: Claude Opus 5.5 --- phaser-asteroids/server/src/router.ts | 7 ++-- phaser-asteroids/server/src/runs.ts | 7 ++++ .../server/tests/lifecycle.test.ts | 42 +++++++++++++++++++ 3 files changed, 53 insertions(+), 3 deletions(-) diff --git a/phaser-asteroids/server/src/router.ts b/phaser-asteroids/server/src/router.ts index 41c7f53..32abb91 100644 --- a/phaser-asteroids/server/src/router.ts +++ b/phaser-asteroids/server/src/router.ts @@ -66,14 +66,15 @@ async function route(request: Request, url: URL, origin: string | null, deps: Se only(method, 'POST'); requireAllowedOrigin(origin, deps); const ipHash = await clientHash(request, deps); - // Throttle before doing any work, so an abusive client cannot make us spend CPU. The global bucket is the hard ceiling on - // how much replay verification the service will perform per hour. + // Throttle each address before doing any work. The global bucket is the hard ceiling on how much replay verification the + // service will perform per hour; submitRun spends it only after the run token has been checked, so anonymous junk (which the + // per-address bucket still limits) cannot use it up for everyone. await hitRateLimit(deps.db, `submit:ip:${ipHash}`, settings.rate.submitPerIp, settings.rate.windowMs, deps.now()); - await hitRateLimit(deps.db, 'submit:global', settings.rate.submitGlobal, settings.rate.windowMs, deps.now()); const result = await submitRun(deps, { runId: submit[1]!, token: bearer(request), readBody: () => readBoundedBody(request, settings), + chargeVerification: () => hitRateLimit(deps.db, 'submit:global', settings.rate.submitGlobal, settings.rate.windowMs, deps.now()), }); return json(result, 200, { 'Cache-Control': 'no-store' }); } diff --git a/phaser-asteroids/server/src/runs.ts b/phaser-asteroids/server/src/runs.ts index 4ea65b2..d015f1a 100644 --- a/phaser-asteroids/server/src/runs.ts +++ b/phaser-asteroids/server/src/runs.ts @@ -111,6 +111,12 @@ export interface SubmitInput { token: string | null; /** Reads the (size-bounded) body. Called only after the run and its token have been checked. */ readBody: () => Promise; + /** + * Spends one unit of the shared hourly verification budget (throws 429 when it is used up). Called only once the caller has shown + * the run's token and the run can still be submitted, so requests that could never reach verification (unknown run, wrong or + * missing token, a finished or expired run) cannot exhaust the budget for every honest player. + */ + chargeVerification?: () => Promise; } const loadRun = (db: Db, id: string) => db.first('SELECT * FROM runs WHERE id = ?', [id]); @@ -127,6 +133,7 @@ export async function submitRun(deps: ServiceDeps, input: SubmitInput): Promise< } if (run.status === 'rejected') throw rejectedError(run); if (run.status === 'issued' && run.expires_at <= deps.now()) throw expiredError(); + await input.chargeVerification?.(); // 2. Read and hash the body. Problems up to and including step 3 are about the transport or the envelope, not about the play // itself, so they do not consume the run: the client can fix or repeat the request. diff --git a/phaser-asteroids/server/tests/lifecycle.test.ts b/phaser-asteroids/server/tests/lifecycle.test.ts index 14fc8fd..a813ad8 100644 --- a/phaser-asteroids/server/tests/lifecycle.test.ts +++ b/phaser-asteroids/server/tests/lifecycle.test.ts @@ -541,6 +541,48 @@ describe('rate limits', () => { expect(await count(h.db, 'scores')).toBe(0); }); + it('submissions that cannot reach verification do not spend the global budget', async () => { + const h = makeHarness({ settings: { rate: { ...makeHarness().settings.rate, submitGlobal: 2 } } }); + const run = await h.start({ seed: REFERENCE_SEED }); + const bot = reference(); + h.clock.advance(bot.ticks / 60 * 1000 + 1500); + // Junk from many addresses: unknown runs, a malformed id, a missing token and a wrong token for a real run. + for (let i = 0; i < 5; i++) { + const junk = await h.call('POST', `/api/v1/runs/${crypto.randomUUID()}/submit`, { ip: `198.51.100.${i}`, json: { replay: {} } }); + expect(junk.status).toBe(404); + } + expect((await h.call('POST', '/api/v1/runs/not-a-uuid/submit', { ip: '198.51.100.20', json: {} })).status).toBe(404); + expect((await h.submit(run, bot.replay, { token: null, ip: '198.51.100.21' })).status).toBe(401); + expect((await h.submit(run, bot.replay, { token: 'guessed', ip: '198.51.100.22' })).status).toBe(401); + expect((await h.db.first<{ n: number }>("SELECT COALESCE(SUM(count), 0) AS n FROM rate_limits WHERE bucket = 'submit:global'"))!.n).toBe(0); + + const res = await h.submit(run, bot.replay); + expect(res.status).toBe(200); + expect(res.body.score.score).toBe(34735); + }); + + it('the global budget still caps verification by token holders, from any address', async () => { + const h = makeHarness({ settings: { rate: { ...makeHarness().settings.rate, submitGlobal: 2, startPerIp: 100 } } }); + const runs = [await h.start(), await h.start(), await h.start()]; + h.clock.advance(5_000); + const status: number[] = []; + for (const [i, run] of runs.entries()) status.push((await h.submit(run, { header: {} }, { ip: `192.0.2.${i + 10}` })).status); + expect(status).toEqual([422, 422, 429]); + // The refused run was never claimed, so it can still be submitted once the window rolls over. + expect((await h.db.first<{ status: string }>('SELECT status FROM runs WHERE id = ?', [runs[2]!.runId]))!.status).toBe('issued'); + }); + + it('expired and already-rejected runs are refused without spending the global budget', async () => { + const h = makeHarness({ settings: { runTtlMs: 60_000, rate: { ...makeHarness().settings.rate, submitGlobal: 1 } } }); + const expired = await h.start(); + const rejected = await h.start(); + h.clock.advance(5_000); + expect((await h.submit(rejected, { header: {} })).status).toBe(422); // spends the only unit + expect((await h.submit(rejected, { header: {} })).status).toBe(409); // run_rejected, not 429 + h.clock.advance(60_000); // still inside the same hourly window + expect((await h.submit(expired, { header: {} })).status).toBe(410); // run_expired, not 429 + }); + it('refuses browser origins that are not allow-listed, but serves origin-less callers', async () => { const h = makeHarness({ settings: { allowedOrigins: ['https://game.example'] } }); expect((await h.call('POST', '/api/v1/runs', { headers: { origin: 'https://evil.example' } })).status).toBe(403); From 79c1026136a860cfc348b4a36308f7f7dd876a0c Mon Sep 17 00:00:00 2001 From: djblackett <49618491+djblackett@users.noreply.github.com> Date: Mon, 2 Nov 2026 11:37:46 -0400 Subject: [PATCH 07/10] feat(ranked): verify each run with a frozen engine for its issued rules Until now the Worker verified exactly one gameplay rules version, compiled in from src/replay, and ignored what the client played. Since PLAY on a phone is ranked, the first rules bump after the Android release would have broken the main button of every installed app, and rejected any run in progress at deploy time (see docs/android-release-audit.md, #1). - server/rules//engine.mjs: the simulation + verifier for one rules version, built from src/replay exactly like dist/node (one self-contained module, no imports), plus engine.d.mts and gzipped reference replays with the results that engine computes. Written by `npm run rules:freeze`; hashes recorded in server/rules/versions.json; stored byte-for-byte (-text) so Windows and CI agree. 1.2.0 frozen from a8acf66 (identical to today's dist/node build). - server/src/engines.ts: the explicit allowlist. Untrusted version strings only match the registry's own keys (no prototype keys). - Issue: POST /api/v1/runs?rules=&schema= gets that version when it is registered with that schema; anything else, or no query (existing web clients), gets the current version as before, which the client already refuses with "update". No new error path, no client change needed for old builds. - Verify: the engine is chosen by runs.rules_version, stored at issue, never by the submission; a replay naming other rules is rejected before any engine runs; an unregistered version is rules_mismatch. Tokens, idempotency, claim races, limits, elapsed-time and expiry rules are untouched. No migration: each engine reads exactly one schema, so the stored rules version fixes both. - Health adds supportedRules; rulesVersion / schemaVersion keep their meaning (the current version). - Client: requestChallenge names GAMEPLAY_RULES_VERSION and REPLAY_SCHEMA_VERSION in the query string (keeps the request CORS-simple). - The Worker bundle now contains no live simulation code: 121 KiB (32.6 KiB gzipped) in a wrangler --dry-run build. Tests: issuing by version (fallbacks, hostile values, body ignored), a 1.2.0 run verified by the frozen engine on a server whose current version is newer, a rules update mid-run not invalidating the run, a submission unable to pick its verifier, retirement. Browser suites match the challenge request by path now that it has a query string, and ranked-browser / worker-e2e check the query and supportedRules for real (worker-e2e also stops expecting the old 1.1.0). The chain-lightning verifier test spies on the frozen engine's GameSim, which is now the authoritative one. Co-Authored-By: Claude Opus 5.5 --- phaser-asteroids/package.json | 1 + phaser-asteroids/scripts/lib/rankedStack.mjs | 13 + phaser-asteroids/scripts/mobile-entry.mjs | 14 +- phaser-asteroids/scripts/ranked-browser.mjs | 4 + phaser-asteroids/scripts/ranked-input.mjs | 8 +- phaser-asteroids/scripts/ranked-ui.mjs | 4 +- phaser-asteroids/server/rules/.gitattributes | 2 + .../server/rules/1.2.0/engine.d.mts | 5 + .../server/rules/1.2.0/engine.mjs | 2911 +++++++++++++++++ .../rules/1.2.0/fixtures/forged-claim.json.gz | Bin 0 -> 108844 bytes .../fixtures/game-over-reference.json.gz | Bin 0 -> 108772 bytes .../1.2.0/fixtures/game-over-stress.json.gz | Bin 0 -> 104291 bytes .../1.2.0/fixtures/stopped-early.json.gz | Bin 0 -> 4079 bytes .../rules/1.2.0/fixtures/time-limit.json.gz | Bin 0 -> 8770 bytes phaser-asteroids/server/rules/policy.mjs | 124 + phaser-asteroids/server/rules/versions.json | 17 + .../server/scripts/freeze-rules.mjs | 138 + .../server/scripts/worker-e2e.mjs | 8 +- phaser-asteroids/server/src/config.ts | 4 +- phaser-asteroids/server/src/engines.ts | 71 + phaser-asteroids/server/src/router.ts | 20 +- phaser-asteroids/server/src/runs.ts | 32 +- phaser-asteroids/server/src/verify.ts | 17 +- .../server/tests/versions.test.ts | 144 + phaser-asteroids/src/ranked/api.ts | 11 +- phaser-asteroids/tests/chainLightning.test.ts | 27 +- phaser-asteroids/tests/ranked.test.ts | 13 + 27 files changed, 3542 insertions(+), 46 deletions(-) create mode 100644 phaser-asteroids/server/rules/.gitattributes create mode 100644 phaser-asteroids/server/rules/1.2.0/engine.d.mts create mode 100644 phaser-asteroids/server/rules/1.2.0/engine.mjs create mode 100644 phaser-asteroids/server/rules/1.2.0/fixtures/forged-claim.json.gz create mode 100644 phaser-asteroids/server/rules/1.2.0/fixtures/game-over-reference.json.gz create mode 100644 phaser-asteroids/server/rules/1.2.0/fixtures/game-over-stress.json.gz create mode 100644 phaser-asteroids/server/rules/1.2.0/fixtures/stopped-early.json.gz create mode 100644 phaser-asteroids/server/rules/1.2.0/fixtures/time-limit.json.gz create mode 100644 phaser-asteroids/server/rules/policy.mjs create mode 100644 phaser-asteroids/server/rules/versions.json create mode 100644 phaser-asteroids/server/scripts/freeze-rules.mjs create mode 100644 phaser-asteroids/server/src/engines.ts create mode 100644 phaser-asteroids/server/tests/versions.test.ts diff --git a/phaser-asteroids/package.json b/phaser-asteroids/package.json index cccac37..2345b35 100644 --- a/phaser-asteroids/package.json +++ b/phaser-asteroids/package.json @@ -28,6 +28,7 @@ "test:mobile-entry": "npm run build && node scripts/mobile-entry.mjs", "test:pages": "npm run build && node scripts/pages-check.mjs", "test:server": "vitest run server/tests", + "rules:freeze": "node server/scripts/freeze-rules.mjs", "test:ranked": "npm run build && node scripts/ranked-browser.mjs", "test:ranked:ui": "npm run build && node scripts/ranked-ui.mjs", "test:lan": "node scripts/lan-check.mjs", diff --git a/phaser-asteroids/scripts/lib/rankedStack.mjs b/phaser-asteroids/scripts/lib/rankedStack.mjs index 8643bf5..af6a107 100644 --- a/phaser-asteroids/scripts/lib/rankedStack.mjs +++ b/phaser-asteroids/scripts/lib/rankedStack.mjs @@ -22,6 +22,19 @@ export async function loadEngine() { return import(pathToFileURL(path.join(root, 'dist', 'node', 'index.js')).href); } +/** + * page.route() pattern for the challenge request, POST /api/v1/runs. The client adds `?rules=&schema=` to it, so an exact URL + * string would no longer match. One RegExp per API base, so page.unroute() receives the same object page.route() was given. + */ +const challengeRoutes = new Map(); +export function challengeRoute(api) { + if (!challengeRoutes.has(api)) challengeRoutes.set(api, new RegExp(`^${api.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}/api/v1/runs(\\?.*)?$`)); + return challengeRoutes.get(api); +} + +/** True for the challenge request itself (POST /api/v1/runs, whatever its query string). */ +export const isChallengeRequest = (r) => r.method() === 'POST' && new URL(r.url()).pathname.endsWith('/api/v1/runs'); + export function makeChecker() { const state = { total: 0, failures: 0 }; return { diff --git a/phaser-asteroids/scripts/mobile-entry.mjs b/phaser-asteroids/scripts/mobile-entry.mjs index 8f93731..ec3031b 100644 --- a/phaser-asteroids/scripts/mobile-entry.mjs +++ b/phaser-asteroids/scripts/mobile-entry.mjs @@ -1,7 +1,7 @@ // Focused title-entry regression checks against the production build and real local Worker/D1. // Faults are injected at the browser network boundary; no gameplay or ranked validation is bypassed. import fs from 'node:fs'; -import { clickItem, itemPoint, makeChecker, menuItems, openTitle, requireBuild, sceneTexts, sleep, startGameAndBrowser, WorkerStack } from './lib/rankedStack.mjs'; +import { challengeRoute, clickItem, isChallengeRequest, itemPoint, makeChecker, menuItems, openTitle, requireBuild, sceneTexts, sleep, startGameAndBrowser, WorkerStack } from './lib/rankedStack.mjs'; const PORT = 4417; const worker = new WorkerStack({ port: 8797, gamePort: PORT }); @@ -25,7 +25,7 @@ try { }, off); const page = await openTitle(ctx, GAME, { api: worker.API, query }); let requests = 0; - page.on('request', (r) => { if (r.method() === 'POST' && r.url().endsWith('/api/v1/runs')) requests++; }); + page.on('request', (r) => { if (isChallengeRequest(r)) requests++; }); return { ctx, page, requests: () => requests }; }; const tap = async (page, id) => { @@ -38,7 +38,7 @@ try { const titleActive = (page) => page.evaluate(() => window.__game.scene.isActive('StartScene')); const prefsOff = (page) => page.evaluate(() => localStorage.getItem('asteroids.inputMode') === 'desktop' && localStorage.getItem('asteroids.touchMovement') === 'pointToFly'); const waitError = (page) => page.waitForFunction(() => window.__game.scene.getScene('StartScene').menuSnapshot().items.some((i) => i.id === 'play-normally')); - const outage = (page) => page.route(`${worker.API}/api/v1/runs`, (route) => route.request().method() === 'POST' + const outage = (page) => page.route(challengeRoute(worker.API), (route) => route.request().method() === 'POST' ? route.fulfill({ status: 503, contentType: 'application/json', body: '{"error":{"code":"unavailable","message":"Test outage"}}' }) : route.continue()); const putPad = (page, pressed = false) => page.evaluate((pressed) => { @@ -128,7 +128,7 @@ try { await outage(page); await tap(page, 'play'); await waitError(page); - await page.unroute(`${worker.API}/api/v1/runs`); + await page.unroute(challengeRoute(worker.API)); await tap(page, 'start'); await playing(page, true); check('RETRY after service recovery starts the existing ranked flow', requests() === 2); @@ -179,7 +179,7 @@ try { const held = new Promise((r) => { release = r; }); let received; const responseReady = new Promise((r) => { received = r; }); - await page.route(`${worker.API}/api/v1/runs`, async (route) => { + await page.route(challengeRoute(worker.API), async (route) => { if (route.request().method() !== 'POST') return route.continue(); const response = await route.fetch(); received(); @@ -199,7 +199,7 @@ try { const { ctx, page, requests } = await phone(); let release; const held = new Promise((r) => { release = r; }); - await page.route(`${worker.API}/api/v1/runs`, async (route) => { + await page.route(challengeRoute(worker.API), async (route) => { if (route.request().method() !== 'POST') return route.continue(); const response = await route.fetch(); await held; @@ -224,7 +224,7 @@ try { }); const page = await openTitle(ctx, GAME, { api: worker.API }); let requests = 0; - page.on('request', (r) => { if (r.method() === 'POST' && r.url().endsWith('/api/v1/runs')) requests++; }); + page.on('request', (r) => { if (isChallengeRequest(r)) requests++; }); const snap = await menuItems(page); check(`desktop touch-capable=${touchCapable}: original PLAY / RANKED / player selector remain`, !snap.items.some((i) => i.id === 'practice') && ['play', 'ranked', 'players', 'scores'].every((id) => snap.items.some((i) => i.id === id))); await page.keyboard.press('Digit2'); diff --git a/phaser-asteroids/scripts/ranked-browser.mjs b/phaser-asteroids/scripts/ranked-browser.mjs index 301c2d3..87e31dd 100644 --- a/phaser-asteroids/scripts/ranked-browser.mjs +++ b/phaser-asteroids/scripts/ranked-browser.mjs @@ -56,6 +56,8 @@ try { const page = await openTitle(context, GAME, { api: API }); const apiCalls = []; page.on('request', (r) => r.url().startsWith(API) && apiCalls.push(`${r.method()} ${new URL(r.url()).pathname}`)); + const challengeQueries = []; + page.on('request', (r) => r.url().startsWith(API) && r.method() === 'POST' && new URL(r.url()).pathname === '/api/v1/runs' && challengeQueries.push(new URL(r.url()).search)); const submitCalls = () => apiCalls.filter((c) => /POST \/api\/v1\/runs\/[0-9a-f-]+\/submit/.test(c)).length; const title = await menuItems(page, 'title'); @@ -88,6 +90,8 @@ try { if (attempt === 1) { check('the challenge came from the server before play (phase=playing, run id held)', session.ranked?.phase === 'playing' && /^[0-9a-f-]{36}$/.test(session.ranked.runId ?? '')); check('the challenge was requested with POST /api/v1/runs', apiCalls.includes('POST /api/v1/runs')); + const engine = await loadEngine(); + check('...naming the rules and replay schema this build plays', challengeQueries[0] === `?rules=${engine.GAMEPLAY_RULES_VERSION}&schema=${engine.REPLAY_SCHEMA_VERSION}`, challengeQueries[0]); check('simulation seed is the server-issued seed (not a default, not from the URL)', Number.isInteger(session.seed) && session.seed > 1 && !new URL(page.url()).searchParams.has('seed')); check('the ranked indicator is on screen during play', (await sceneTexts(page, 'GameScene')).includes('RANKED')); diff --git a/phaser-asteroids/scripts/ranked-input.mjs b/phaser-asteroids/scripts/ranked-input.mjs index d798496..69fbcd1 100644 --- a/phaser-asteroids/scripts/ranked-input.mjs +++ b/phaser-asteroids/scripts/ranked-input.mjs @@ -1,5 +1,5 @@ // Focused release-blocker checks. Real local Worker/D1 + production browser build; no legacy browser sweep. -import { clickItem, itemPoint, makeChecker, menuItems, openTitle, requireBuild, sceneTexts, sleep, startGameAndBrowser, WorkerStack } from './lib/rankedStack.mjs'; +import { challengeRoute, clickItem, isChallengeRequest, itemPoint, makeChecker, menuItems, openTitle, requireBuild, sceneTexts, sleep, startGameAndBrowser, WorkerStack } from './lib/rankedStack.mjs'; import { settleTitleInput } from './lib/menuWaits.mjs'; const PORT = 4416; @@ -23,7 +23,7 @@ try { }); const page = await openTitle(ctx, GAME, { api: worker.API }); let requests = 0; - page.on('request', (r) => { if (r.method() === 'POST' && r.url().endsWith('/api/v1/runs')) requests++; }); + page.on('request', (r) => { if (isChallengeRequest(r)) requests++; }); return { ctx, page, requests: () => requests }; }; const tap = async (page, id) => { @@ -104,7 +104,7 @@ try { await sleep(200); await joinPad(page); await tap(page, 'ranked'); - await page.route(`${worker.API}/api/v1/runs`, (route) => route.request().method() === 'POST' ? route.fulfill({ status: 503, contentType: 'application/json', body: '{"error":{"code":"unavailable","message":"Test outage"}}' }) : route.continue()); + await page.route(challengeRoute(worker.API), (route) => route.request().method() === 'POST' ? route.fulfill({ status: 503, contentType: 'application/json', body: '{"error":{"code":"unavailable","message":"Test outage"}}' }) : route.continue()); await tap(page, 'start'); await page.waitForFunction(() => window.__game.scene.getScene('StartScene').menuSnapshot().items.some((i) => i.id === 'play-normally')); check('service failure offers TRY AGAIN and PLAY NORMALLY with usable input', (await menuItems(page)).items.some((i) => i.id === 'start')); @@ -127,7 +127,7 @@ try { const held = new Promise((r) => { release = r; }); let received; const responseReady = new Promise((r) => { received = r; }); - await page.route(`${worker.API}/api/v1/runs`, async (route) => { + await page.route(challengeRoute(worker.API), async (route) => { if (route.request().method() !== 'POST') return route.continue(); const response = await route.fetch(); received(); diff --git a/phaser-asteroids/scripts/ranked-ui.mjs b/phaser-asteroids/scripts/ranked-ui.mjs index 9864b83..895bbf0 100644 --- a/phaser-asteroids/scripts/ranked-ui.mjs +++ b/phaser-asteroids/scripts/ranked-ui.mjs @@ -8,7 +8,7 @@ // Network faults are injected with Playwright routes on the browser side of the wire ("the response got lost"); the server stays real. import crypto from 'node:crypto'; import { playUntilScoredThenDie } from './lib/browserPlay.mjs'; -import { clickItem, itemPoint, makeChecker, menuItems, openTitle, rankedState, requireBuild, sceneTexts, sleep, startGameAndBrowser, WorkerStack } from './lib/rankedStack.mjs'; +import { challengeRoute, clickItem, itemPoint, makeChecker, menuItems, openTitle, rankedState, requireBuild, sceneTexts, sleep, startGameAndBrowser, WorkerStack } from './lib/rankedStack.mjs'; const GAME_PORT = Number(process.env.RANKED_GAME_PORT ?? 4411); const A = new WorkerStack({ port: Number(process.env.RANKED_API_PORT_A ?? 8794), gamePort: GAME_PORT }); @@ -393,7 +393,7 @@ INSERT INTO scores (id, run_id, score, nickname, completed_at, rules_version, ti const page = await openTitle(ctx, GAME, { api: A.API }); const submits = []; page.on('request', (r) => /\/submit$/.test(r.url()) && r.method() === 'POST' && submits.push(r.url())); - await page.route(`${A.API}/api/v1/runs`, async (route) => { + await page.route(challengeRoute(A.API), async (route) => { if (route.request().method() !== 'POST') return route.continue(); const res = await route.fetch(); const body = await res.json(); diff --git a/phaser-asteroids/server/rules/.gitattributes b/phaser-asteroids/server/rules/.gitattributes new file mode 100644 index 0000000..a0abb42 --- /dev/null +++ b/phaser-asteroids/server/rules/.gitattributes @@ -0,0 +1,2 @@ +# Frozen engines and their records must be byte-identical on every checkout (their hashes are pinned in versions.json). +* -text diff --git a/phaser-asteroids/server/rules/1.2.0/engine.d.mts b/phaser-asteroids/server/rules/1.2.0/engine.d.mts new file mode 100644 index 0000000..740644d --- /dev/null +++ b/phaser-asteroids/server/rules/1.2.0/engine.d.mts @@ -0,0 +1,5 @@ +// Types for engine.mjs, generated by `npm run rules:freeze`. Only what server/src/engines.ts uses. Never edit: see ../README.md. +export declare const GAMEPLAY_RULES_VERSION: string; +export declare const REPLAY_SCHEMA_VERSION: number; +export declare const FIXED_TICK_RATE: number; +export declare function verifyReplay(replay: unknown, options?: object): unknown; diff --git a/phaser-asteroids/server/rules/1.2.0/engine.mjs b/phaser-asteroids/server/rules/1.2.0/engine.mjs new file mode 100644 index 0000000..a2de34a --- /dev/null +++ b/phaser-asteroids/server/rules/1.2.0/engine.mjs @@ -0,0 +1,2911 @@ +// FROZEN replay engine for gameplay rules 1.2.0 (replay schema 1). Generated by `npm run rules:freeze` from a8acf66. +// Never edit this file: the server verifies every 1.2.0 run with it, and its hash is pinned in ../versions.json. See ../README.md. +//#region src/replay/constants.ts +/** +* Deterministic replay and verification constants. +*/ +var REPLAY_SCHEMA_VERSION = 1; +/** Semantic rules version defining simulation outcomes, including spawn/drop balance. */ +var GAMEPLAY_RULES_VERSION = "1.2.0"; +/** Authoritative simulation tick rate in Hz. */ +var FIXED_TICK_RATE = 60; +/** Simulation delta per tick in seconds (1/60 s = 0.016666666666666666 s). */ +var FIXED_DT = 1 / 60; +/** +* Maximum accumulated wall-clock delta allowed in a single render frame (seconds). +* Prevents spiral of death if the browser tab freezes or drops frames. +* 0.25 s = at most 15 simulation ticks in one render step. +*/ +var MAX_ACCUMULATOR_DT = .25; +/** Maximum replay duration supported (30 simulated minutes at 60 Hz). */ +var MAX_REPLAY_TICKS = 108e3; +/** Maximum number of recorded input change events allowed. */ +var MAX_REPLAY_INPUT_CHANGES = 1e5; +//#endregion +//#region src/replay/fixedStepRunner.ts +/** +* Manages fixed-timestep simulation ticking in variable-refresh browser environments. +* +* Requirements addressed: +* 1. Independent of refresh rate (60Hz, 90Hz, 120Hz, 144Hz devices produce the same ticks). +* 2. Pausing freezes the accumulator; no ticks advance while paused. +* 3. Tab suspension/blur and frame stalls are capped at `maxAccumulatorDt` (0.25s / 15 ticks max), +* preventing the spiral of death while preserving deterministic consecutive tick advancement. +*/ +var FixedStepRunner = class { + tickRate; + fixedDt; + maxAccumulatorDt; + accumulator = 0; + currentTick = 0; + isPaused = false; + constructor(tickRate = 60, fixedDt = FIXED_DT, maxAccumulatorDt = MAX_ACCUMULATOR_DT) { + this.tickRate = tickRate; + this.fixedDt = fixedDt; + this.maxAccumulatorDt = maxAccumulatorDt; + } + get tick() { + return this.currentTick; + } + get paused() { + return this.isPaused; + } + setPaused(paused) { + if (this.isPaused === paused) return; + this.isPaused = paused; + if (paused) this.accumulator = 0; + } + /** + * Advances the clock by `frameDt` seconds. + * + * @param frameDt Real elapsed wall-clock seconds since the last frame. + * @param onTick Callback executed for each discrete simulation tick. + * @returns Number of ticks executed in this update. + */ + update(frameDt, onTick) { + if (this.isPaused || frameDt <= 0) return 0; + const delta = Math.min(frameDt, this.maxAccumulatorDt); + this.accumulator += delta; + let ticksExecuted = 0; + while (this.accumulator >= this.fixedDt - 1e-9) { + onTick(this.currentTick, this.fixedDt); + this.currentTick++; + this.accumulator -= this.fixedDt; + ticksExecuted++; + } + if (Math.abs(this.accumulator) < 1e-9) this.accumulator = 0; + return ticksExecuted; + } + reset(startTick = 0) { + this.accumulator = 0; + this.currentTick = startTick; + this.isPaused = false; + } +}; +//#endregion +//#region src/replay/types.ts +/** +* Normalizes a live `PlayerInput` into a canonical `RecordedInput`. +*/ +function toRecordedInput(input) { + const rec = { + rotate: Number.isFinite(input.rotate) ? Math.round(input.rotate * 1e3) / 1e3 : 0, + move: Number.isFinite(input.move) ? Math.round(input.move * 1e3) / 1e3 : 0, + shoot: !!input.shoot + }; + if (input.laser) rec.laser = true; + if (input.boost) rec.boost = true; + if (input.steer) rec.steer = { + heading: Math.round(input.steer.heading * 100) / 100, + mode: input.steer.mode + }; + return rec; +} +/** +* Converts a `RecordedInput` back into a `PlayerInput` suitable for `GameSim.step()`. +*/ +function toPlayerInput(rec) { + return { + rotate: rec.rotate, + move: rec.move, + shoot: rec.shoot, + laser: !!rec.laser, + boost: !!rec.boost, + steer: rec.steer ? { + heading: rec.steer.heading, + mode: rec.steer.mode + } : void 0 + }; +} +/** +* Compares two inputs for equality to avoid emitting redundant records when nothing has changed. +*/ +function areRecordedInputsEqual(a, b) { + if (a.rotate !== b.rotate) return false; + if (a.move !== b.move) return false; + if (a.shoot !== b.shoot) return false; + if (!!a.laser !== !!b.laser) return false; + if (!!a.boost !== !!b.boost) return false; + const aSteer = a.steer; + const bSteer = b.steer; + if (!aSteer && !bSteer) return true; + if (!aSteer || !bSteer) return false; + if (aSteer.mode !== bSteer.mode) return false; + return Math.abs(aSteer.heading - bSteer.heading) < .001; +} +function createDefaultReplayHeader(seed, config, gameVersion = "0.1.0") { + return { + schemaVersion: 1, + rulesVersion: GAMEPLAY_RULES_VERSION, + gameVersion, + seed: seed >>> 0, + tickRate: 60, + config, + playerCount: 1, + recordedAt: (/* @__PURE__ */ new Date()).toISOString() + }; +} +//#endregion +//#region src/replay/recorder.ts +var ReplayRecorder = class { + seed; + config; + header; + inputChanges = []; + lastRecordedInput = null; + currentTicks = 0; + completedGameOver = false; + claimedResult = null; + isAbandoned = false; + constructor(seed, config, gameVersion = "0.1.0") { + this.seed = seed; + this.config = config; + const clonedConfig = JSON.parse(JSON.stringify(config)); + this.header = createDefaultReplayHeader(seed, clonedConfig, gameVersion); + } + get ticks() { + return this.currentTicks; + } + get changeCount() { + return this.inputChanges.length; + } + get isFinalized() { + return this.completedGameOver; + } + get abandoned() { + return this.isAbandoned; + } + /** + * Called on every fixed simulation tick with the effective player input for that tick. + * Only records when the input changes from the previously recorded input. + */ + recordTick(tick, input, sim) { + if (this.completedGameOver || this.isAbandoned) return; + if (tick > 108e3) { + this.isAbandoned = true; + throw new Error(`Replay tick count exceeded maximum limit of ${MAX_REPLAY_TICKS}`); + } + const recorded = toRecordedInput(input); + if (!this.lastRecordedInput || !areRecordedInputsEqual(this.lastRecordedInput, recorded)) { + if (this.inputChanges.length >= 1e5) { + this.isAbandoned = true; + throw new Error(`Replay input change count exceeded limit of ${MAX_REPLAY_INPUT_CHANGES}`); + } + this.inputChanges.push({ + tick, + input: recorded + }); + this.lastRecordedInput = recorded; + } + this.currentTicks = tick + 1; + if (sim?.isGameOver) this.markGameOver(sim); + } + /** + * Finalizes the recording with game-over state. + */ + markGameOver(sim) { + if (this.completedGameOver) return; + this.completedGameOver = true; + this.claimedResult = { + totalTicks: this.currentTicks, + score: sim.totalScore, + gameOverReason: sim.gameOverReason, + phase: sim.phase, + endReason: "game_over" + }; + } + /** + * Finalizes a ranked run that reached the tick limit the server issued while the ship was still alive. Like `markGameOver` it only + * records what the client believes (the server never trusts it); the recording simply stops here and nothing further is recorded. + */ + markTimeLimit(sim) { + if (this.completedGameOver) return; + this.completedGameOver = true; + this.claimedResult = { + totalTicks: this.currentTicks, + score: sim.totalScore, + gameOverReason: sim.gameOverReason, + phase: sim.phase, + endReason: "time_limit" + }; + } + /** + * Marks this recording as explicitly abandoned (e.g. user quit to menu mid-game). + */ + abandon() { + this.isAbandoned = true; + } + /** + * Finalizes the recording and returns the full `ReplayRecord`. + */ + exportReplay() { + if (!this.inputChanges.length) this.inputChanges.push({ + tick: 0, + input: { + rotate: 0, + move: 0, + shoot: false + } + }); + return { + header: JSON.parse(JSON.stringify(this.header)), + inputs: JSON.parse(JSON.stringify(this.inputChanges)), + totalTicks: this.currentTicks, + claimedResult: this.claimedResult ? { ...this.claimedResult } : void 0 + }; + } + /** + * Serializes the replay record to a JSON string. + */ + serialize() { + return JSON.stringify(this.exportReplay()); + } +}; +//#endregion +//#region src/core/constants.ts +/** +* Gameplay constants, ported 1:1 from the Python game's constants.py. +* Values for features that are not implemented yet are deliberately omitted. +*/ +var SCREEN_WIDTH = 1280; +var ASTEROID_SPAWN_RATE = .5; +var ASTEROID_ARCHETYPES = { + standard: { + hitPoints: 1, + pointsMultiplier: 1, + pointsBonus: 0, + color: 16777215, + outlineWidth: 2 + }, + armored: { + hitPoints: 2, + pointsMultiplier: 1.5, + pointsBonus: 10, + color: 11197695, + outlineWidth: 3 + }, + volatile: { + hitPoints: 1, + pointsMultiplier: 1.75, + pointsBonus: 20, + color: 16757850, + outlineWidth: 2 + } +}; +/** Seconds of play before each archetype can spawn (continuous mode). */ +var ASTEROID_ARCHETYPE_TIME_UNLOCKS = { + standard: 0, + armored: 25, + volatile: 60 +}; +/** Relative weights among unlocked archetypes; volatile remains uncommon. */ +var ASTEROID_ARCHETYPE_SPAWN_WEIGHTS = { + standard: 1, + armored: .35, + volatile: .12 +}; +var ASTEROID_ARMORED_HIT_FLASH_DURATION = .12; +Math.floor(SCREEN_WIDTH / 2); +/** Two players start on, and respawn at, their own spawn points (Python P1_SPAWN / P2_SPAWN); index = player number - 1. */ +var PLAYER_SPAWNS = [{ + x: SCREEN_WIDTH * .25, + y: Math.floor(360) +}, { + x: SCREEN_WIDTH * .75, + y: Math.floor(360) +}]; +var PLAYER_SHOOT_COOLDOWN = .3; +var RAPID_FIRE_COOLDOWN = .1; +var SLOW_MOTION_FACTOR = .4; +/** Score multiplier by kills in the current combo. Python: `COMBO_MULTIPLIERS.get(count, COMBO_MULTIPLIERS[5])`. */ +var COMBO_MULTIPLIERS = { + 1: 1, + 2: 1.5, + 3: 2, + 4: 2.5, + 5: 3 +}; +/** Banner shown the moment the combo count reaches `kills`. Ascending order. */ +var KILL_STREAK_MILESTONES = [ + { + kills: 15, + name: "KILLING SPREE!", + color: 16762930 + }, + { + kills: 30, + name: "RAMPAGE!", + color: 16750080 + }, + { + kills: 50, + name: "DOMINATING!", + color: 16737535 + }, + { + kills: 75, + name: "UNSTOPPABLE!", + color: 16724530 + }, + { + kills: 100, + name: "GODLIKE!", + color: 16711680 + }, + { + kills: 150, + name: "LEGENDARY!", + color: 16766720 + }, + { + kills: 200, + name: "BEYOND LEGENDARY!", + color: 65535 + } +]; +var KILL_STREAK_NOTIFICATION_DURATION = 2.5; +var UFO_SMALL_SHOOT_COOLDOWN = 1.5; +var UFO_SMALL_SHOOT_ACCURACY = .7; +/** First shot comes after a random delay in this range. */ +var UFO_FIRST_SHOT_MIN = .5; +var UFO_FIRST_SHOT_MAX = 1.5; +/** Spawn point along the chosen edge, as a fraction of its length. */ +var UFO_SPAWN_EDGE_MIN = .2; +var UFO_SPAWN_EDGE_MAX = .8; +/** +* Continuous mode: when small UFOs enter the schedule. Python picks the type from the *wave* number, which only wave mode +* ever advances, so in continuous mode small UFOs never appeared. Here the existing difficulty progression is reused +* instead: `GameSim.difficultyLevel` goes up by one every `DIFFICULTY_INCREASE_INTERVAL` (30 s) and is what makes the +* asteroids faster. Each row is "from this difficulty level on, a UFO spawn is small with this probability" (the highest +* row reached wins; before the first row every spawn is a large UFO and no random number is drawn). +* +* level 2 (1:00) 10 % - an occasional early small UFO +* level 4 (2:00) 20 % - the odd small UFO +* level 8 (4:00) 40 % - the rate Python uses from wave 5 +* level 12 (6:00) 60 % - small UFOs are now the more likely spawn +* +* Spawn timing (first at 5 s, then every 15 s) and the maximum of 2 UFOs are unchanged. Set the table to `[]` to restore +* the original "large only" behaviour. +*/ +var UFO_SMALL_PROGRESSION = [ + { + level: 2, + chance: .1 + }, + { + level: 4, + chance: .2 + }, + { + level: 8, + chance: .4 + }, + { + level: 12, + chance: .6 + } +]; +var LASER_BEAM_LIFETIME = .3; +var BOOST_SPEED_MULTIPLIER = 2.5; +/** Python: `velocity *= 0.85` every frame at 60 FPS. */ +var BOUNCE_DAMPING_PER_FRAME = .85; +/** Minimum seconds between spark bursts while the ship is pushed against a wall. */ +var BOUNDARY_SPARK_INTERVAL = 1 / 60; +var SCREEN_SHAKE_COOLDOWN = .1; +/** Python: `velocity *= 0.95` every frame at 60 FPS. */ +var PARTICLE_DAMPING_PER_FRAME = .95; +var EXHAUST_PARTICLE_SPAWN_RATE = .05; +var DIFFICULTY_SPEED_INCREMENT = .15; +var DIFFICULTY_SPAWN_RATE_INCREMENT = .05; +var DIFFICULTY_SPAWN_RATE_MIN = .2; +var GAME_OVER_RETRY_DELAY = 1.5; +var STARFIELD_PARALLAX_FACTORS = [ + .1, + .3, + .5 +]; +/** Real frames longer than this (tab stalls, debugger pauses) are clamped. */ +var MAX_FRAME_DT = .1; +/** Frames longer than this are subdivided so fast shots cannot tunnel through small asteroids. */ +var MAX_SUBSTEP_DT = 1 / 30; +//#endregion +//#region src/core/scoring.ts +function createCombo() { + return { + count: 0, + timer: 0, + lastMilestone: 0 + }; +} +/** Python `COMBO_MULTIPLIERS.get(count, COMBO_MULTIPLIERS[5])`. */ +function comboMultiplier(count) { + return COMBO_MULTIPLIERS[count] ?? COMBO_MULTIPLIERS[5] ?? 1; +} +/** Python `int(base_points * multiplier)`. */ +function scaledPoints(basePoints, multiplier) { + return Math.trunc(basePoints * multiplier); +} +/** Python `check_kill_streak_milestone`: the highest milestone reached that is above the last announced one. */ +function milestoneFor(count, lastMilestone) { + for (let i = KILL_STREAK_MILESTONES.length - 1; i >= 0; i--) { + const m = KILL_STREAK_MILESTONES[i]; + if (m && count >= m.kills && m.kills > lastMilestone) return m; + } + return null; +} +/** Python `increment_combo_and_check_streak`: one kill. Restarts the 3 s window. */ +function registerKill(combo) { + combo.count += 1; + combo.timer = 3; + const milestone = milestoneFor(combo.count, combo.lastMilestone); + if (milestone) combo.lastMilestone = milestone.kills; + return { + count: combo.count, + multiplier: comboMultiplier(combo.count), + milestone + }; +} +/** Counts the window down. @returns true on the step in which the combo expired and was cleared. */ +function tickCombo(combo, dt) { + if (combo.timer <= 0) return false; + combo.timer -= dt; + if (combo.timer > 0) return false; + resetCombo(combo); + return true; +} +function resetCombo(combo) { + combo.count = 0; + combo.timer = 0; + combo.lastMilestone = 0; +} +function createBanner(milestone) { + return { + kills: milestone.kills, + name: milestone.name, + color: milestone.color, + timer: KILL_STREAK_NOTIFICATION_DURATION, + duration: KILL_STREAK_NOTIFICATION_DURATION + }; +} +/** @returns false once the banner has run out. */ +function tickBanner(banner, dt) { + banner.timer -= dt; + return banner.timer > 0; +} +//#endregion +//#region src/replay/snapshot.ts +function round(n, decimals = 4) { + const factor = 10 ** decimals; + return Math.round(n * factor) / factor; +} +function capturePlayerSnapshot(p) { + return { + position: { + x: round(p.position.x), + y: round(p.position.y) + }, + velocity: { + x: round(p.velocity.x), + y: round(p.velocity.y) + }, + rotation: round(p.rotation, 3), + lives: p.lives, + score: p.score, + canShoot: p.canShoot, + shootTimer: round(p.shootTimer, 3), + isRespawning: p.isRespawning, + respawnTimer: round(p.respawnTimer, 3), + isMoving: p.isMoving, + travelHeading: p.travelHeading === null ? null : round(p.travelHeading, 3), + rapidFire: { + active: p.rapidFire.active, + timer: round(p.rapidFire.timer, 3) + }, + multiShot: { + active: p.multiShot.active, + timer: round(p.multiShot.timer, 3) + }, + chainLightning: { + active: p.chainLightning.active, + timer: round(p.chainLightning.timer, 3) + }, + megaPower: { + active: p.megaPower.active, + timer: round(p.megaPower.timer, 3) + }, + shieldActive: p.shieldActive, + boost: { + active: p.boost.active, + timer: round(p.boost.timer, 3), + cooldown: round(p.boost.cooldown, 3), + keyHeld: p.boost.keyHeld + }, + laser: { + shotsRemaining: p.laser.shotsRemaining, + cooldown: round(p.laser.cooldown, 3), + keyHeld: p.laser.keyHeld + } + }; +} +function captureSimSnapshot(sim, tick = 0) { + return { + tick, + time: round(sim.time, 4), + phase: sim.phase, + gameOverReason: sim.gameOverReason, + totalScore: sim.totalScore, + difficultyLevel: sim.difficultyLevel, + difficultyTimer: round(sim.difficultyTimer, 3), + asteroidSpeedMultiplier: round(sim.asteroidSpeedMultiplier, 3), + asteroidSpawnRate: round(sim.asteroidSpawnRate, 3), + slowMotion: { + active: sim.slowMotion.active, + timer: round(sim.slowMotion.timer, 3) + }, + combo: { + count: sim.combo.count, + timer: round(sim.combo.timer, 3), + multiplier: comboMultiplier(sim.combo.count) + }, + player: capturePlayerSnapshot(sim.player), + player2: sim.player2 ? capturePlayerSnapshot(sim.player2) : null, + asteroids: sim.asteroids.map((a) => ({ + x: round(a.position.x), + y: round(a.position.y), + vx: round(a.velocity.x), + vy: round(a.velocity.y), + radius: a.radius, + archetype: a.archetype, + hitPoints: a.hitPoints, + dying: a.dying, + deathTimer: round(a.deathTimer, 3) + })), + ufos: sim.ufos.map((u) => ({ + x: round(u.position.x), + y: round(u.position.y), + vx: round(u.velocity.x), + vy: round(u.velocity.y), + type: u.type, + alive: u.alive, + shootTimer: round(u.shootTimer, 3) + })), + shots: sim.shots.map((s) => ({ + x: round(s.position.x), + y: round(s.position.y), + vx: round(s.velocity.x), + vy: round(s.velocity.y), + owner: s.owner, + charged: !!s.charged + })), + ufoShots: sim.ufoShots.map((s) => ({ + x: round(s.position.x), + y: round(s.position.y), + vx: round(s.velocity.x), + vy: round(s.velocity.y) + })), + lasers: sim.lasers.map((l) => ({ + direction: round(l.direction, 3), + owner: l.owner, + timer: round(l.timer, 3) + })), + powerups: sim.powerups.map((p) => ({ + x: round(p.position.x), + y: round(p.position.y), + type: p.type, + lifetime: round(p.lifetime, 3) + })) + }; +} +function compareSnapshots(a, b) { + const differences = []; + const check = (path, valA, valB) => { + if (JSON.stringify(valA) !== JSON.stringify(valB)) differences.push(`${path}: expected ${JSON.stringify(valA)} but got ${JSON.stringify(valB)}`); + }; + check("phase", a.phase, b.phase); + check("totalScore", a.totalScore, b.totalScore); + check("difficultyLevel", a.difficultyLevel, b.difficultyLevel); + check("player.lives", a.player.lives, b.player.lives); + check("player.score", a.player.score, b.player.score); + check("player.rotation", a.player.rotation, b.player.rotation); + check("player.position", a.player.position, b.player.position); + check("player.velocity", a.player.velocity, b.player.velocity); + check("player.travelHeading", a.player.travelHeading, b.player.travelHeading); + check("player.shieldActive", a.player.shieldActive, b.player.shieldActive); + check("player.chainLightning", a.player.chainLightning, b.player.chainLightning); + check("player2", a.player2, b.player2); + check("player.boost", a.player.boost, b.player.boost); + check("player.laser", a.player.laser, b.player.laser); + check("combo", a.combo, b.combo); + check("slowMotion", a.slowMotion, b.slowMotion); + check("asteroids.length", a.asteroids.length, b.asteroids.length); + check("ufos.length", a.ufos.length, b.ufos.length); + check("shots.length", a.shots.length, b.shots.length); + check("powerups.length", a.powerups.length, b.powerups.length); + if (differences.length === 0) { + check("asteroids", a.asteroids, b.asteroids); + check("ufos", a.ufos, b.ufos); + check("shots", a.shots, b.shots); + check("powerups", a.powerups, b.powerups); + } + return { + match: differences.length === 0, + differences + }; +} +//#endregion +//#region src/core/math.ts +function degToRad(degrees) { + return degrees * Math.PI / 180; +} +/** +* Pygame's `Vector2(0, 1).rotate(degrees)`. +* +* Screen coordinates (y points down). 0 deg = Down, 90 = Left, 180 = Up, 270 = Right. +* Every piece of gameplay (thrust, shots, ship geometry) goes through this one function so the +* conventions cannot drift apart. +*/ +function getForwardVector(degrees) { + const radians = degToRad(degrees); + return { + x: -Math.sin(radians), + y: Math.cos(radians) + }; +} +/** Pygame's `Vector2.rotate(degrees)` for an arbitrary vector. */ +function rotateVec(v, degrees) { + const r = degToRad(degrees); + const cos = Math.cos(r); + const sin = Math.sin(r); + return { + x: v.x * cos - v.y * sin, + y: v.x * sin + v.y * cos + }; +} +function lengthOf(v) { + return Math.hypot(v.x, v.y); +} +function normalize(v) { + const len = lengthOf(v); + return len === 0 ? { + x: 0, + y: 0 + } : { + x: v.x / len, + y: v.y / len + }; +} +/** +* Converts a per-frame multiplier tuned for 60 FPS (e.g. `velocity *= 0.85`) into the equivalent +* multiplier for a frame of `dt` seconds. At dt = 1/60 this returns `perFrame` exactly. +*/ +function timeNormalizedDamping(perFrame, dt) { + return Math.pow(perFrame, dt * 60); +} +/** Same test as Python's `CircleShape.check_collision` (touching counts as a hit). */ +function circlesOverlap(a, b) { + const dx = a.position.x - b.position.x; + const dy = a.position.y - b.position.y; + const r = a.radius + b.radius; + return dx * dx + dy * dy <= r * r; +} +function wrap(value, size) { + return (value % size + size) % size; +} +/** Signed shortest rotation from `from` to `to`, in degrees, in (-180, 180]. Exactly opposite headings give +180 so the choice is stable. */ +function shortestAngleDelta(from, to) { + const d = wrap(to - from, 360); + return d > 180 ? d - 360 : d; +} +/** Turns `current` toward `target` by the shortest way, by at most `maxStep` degrees. Never overshoots; the result is in [0, 360). */ +function turnToward(current, target, maxStep) { + const delta = shortestAngleDelta(current, target); + return wrap(current + Math.sign(delta) * Math.min(Math.abs(delta), Math.max(0, maxStep)), 360); +} +//#endregion +//#region src/core/rng.ts +var defaultRng = Math.random; +/** Small, fast, seedable PRNG (mulberry32) for tests and replays. */ +function seededRng(seed) { + let a = seed >>> 0; + return () => { + a = a + 1831565813 >>> 0; + let t = a; + t = Math.imul(t ^ t >>> 15, t | 1); + t ^= t + Math.imul(t ^ t >>> 7, t | 61); + return ((t ^ t >>> 14) >>> 0) / 4294967296; + }; +} +/** Python `random.uniform(a, b)`. */ +var uniform = (rng, a, b) => a + (b - a) * rng(); +/** Python `random.randint(a, b)` (inclusive on both ends). */ +var randint = (rng, a, b) => a + Math.floor(rng() * (b - a + 1)); +function pick(rng, items) { + const item = items[Math.floor(rng() * items.length)]; + if (item === void 0) throw new Error("pick() from empty array"); + return item; +} +//#endregion +//#region src/core/asteroid.ts +function sizeCategoryOf(radius) { + if (radius >= 50) return "large"; + if (radius >= 30) return "medium"; + return "small"; +} +function createAsteroid(x, y, radius, archetype = "standard", velocity = { + x: 0, + y: 0 +}) { + const config = ASTEROID_ARCHETYPES[archetype]; + return { + position: { + x, + y + }, + velocity: { + x: velocity.x, + y: velocity.y + }, + radius, + archetype, + sizeCategory: sizeCategoryOf(radius), + maxHitPoints: config.hitPoints, + hitPoints: config.hitPoints, + dying: false, + deathTimer: 0, + deathTimerReal: 0, + hitFlashTimer: 0, + shakeOffset: { + x: 0, + y: 0 + }, + alive: true + }; +} +/** Score for destroying this asteroid: `int(base * archetype multiplier + archetype bonus)`. */ +function getPoints(a) { + const base = a.sizeCategory === "large" ? 10 : a.sizeCategory === "medium" ? 20 : 50; + const config = ASTEROID_ARCHETYPES[a.archetype]; + return Math.trunc(base * config.pointsMultiplier + config.pointsBonus); +} +function getParticleCount(a) { + if (a.sizeCategory === "large") return 12; + if (a.sizeCategory === "medium") return 8; + return 5; +} +function getScreenShakeAmount(a) { + if (a.sizeCategory === "large") return 8; + if (a.sizeCategory === "medium") return 5; + return 2; +} +/** +* Applies one hit. Armored asteroids absorb the first hit (flash + sparks, no points); +* everything else is destroyed. Hits on an already-dying asteroid are ignored. +*/ +function takeHit(a) { + if (a.dying) return { + destroyed: false, + effect: null + }; + a.hitPoints -= 1; + if (a.hitPoints <= 0) return { + destroyed: true, + effect: null + }; + a.hitFlashTimer = ASTEROID_ARMORED_HIT_FLASH_DURATION; + return { + destroyed: false, + effect: { + position: { + x: a.position.x, + y: a.position.y + }, + particleCount: 4, + shakeAmount: 1 + } + }; +} +/** Python `Asteroid.split()`: starts the death animation. Returns null if already dying. */ +function beginDeath(a) { + if (a.dying) return null; + a.dying = true; + a.deathTimer = 0; + return { + position: { + x: a.position.x, + y: a.position.y + }, + particleCount: getParticleCount(a), + shakeAmount: getScreenShakeAmount(a) + }; +} +/** +* Two children at `radius - 20`, fanned out +/- a random 20-50 degrees with a 1.2x speed boost. +* Armored parents produce standard children. Asteroids at minimum size do not split. +*/ +function spawnChildren(a, rng) { + if (a.radius <= 20) return []; + const spread = uniform(rng, 20, 50); + const v1 = rotateVec(a.velocity, spread); + const v2 = rotateVec(a.velocity, -spread); + const newRadius = a.radius - 20; + const offsetDistance = newRadius * 1.5; + const o1 = normalize(v1); + const o2 = normalize(v2); + const archetype = a.archetype === "armored" ? "standard" : a.archetype; + return [createAsteroid(a.position.x + o1.x * offsetDistance, a.position.y + o1.y * offsetDistance, newRadius, archetype, { + x: v1.x * 1.2, + y: v1.y * 1.2 + }), createAsteroid(a.position.x + o2.x * offsetDistance, a.position.y + o2.y * offsetDistance, newRadius, archetype, { + x: v2.x * 1.2, + y: v2.y * 1.2 + })]; +} +/** +* Advances an asteroid. +* +* @param dt Game-time seconds (already scaled by difficulty / slow motion by the caller). +* @param realDt Real seconds; caps how long the death animation can last when game time is slowed. +* @returns Children created if the death animation finished this call. +*/ +function updateAsteroid(a, dt, realDt, rng) { + if (a.hitFlashTimer > 0) a.hitFlashTimer = Math.max(0, a.hitFlashTimer - dt); + if (a.dying) { + a.deathTimer += dt; + a.deathTimerReal += realDt; + a.shakeOffset = { + x: uniform(rng, -3, 3), + y: uniform(rng, -3, 3) + }; + if (a.deathTimer >= .15 || a.deathTimerReal >= .15) { + a.alive = false; + return spawnChildren(a, rng); + } + return []; + } + a.position.x += a.velocity.x * dt; + a.position.y += a.velocity.y * dt; + if (a.position.x < -a.radius || a.position.x > 1280 + a.radius || a.position.y < -a.radius || a.position.y > 720 + a.radius) a.alive = false; + return []; +} +//#endregion +//#region src/core/gameConfig.ts +var DEFAULT_GAME_CONFIG = { + playerCount: 1, + livesMode: "independent", + friendlyFire: true, + speed: [1, 1] +}; +/** +* Fills in defaults and drops what cannot apply: a one-player game always has independent lives, no friendly fire, +* normal speed and no second ship, whatever the menu last held, so no co-op setting can leak into single-player play. +*/ +function resolveGameConfig(partial = {}) { + const merged = { + ...DEFAULT_GAME_CONFIG, + ...partial, + speed: partial.speed ?? DEFAULT_GAME_CONFIG.speed + }; + if (merged.playerCount === 1) return { + playerCount: 1, + livesMode: "independent", + friendlyFire: false, + speed: [1, 1] + }; + return merged; +} +//#endregion +//#region src/core/laser.ts +/** Where a ray from `start` along `direction` degrees first reaches the screen boundary. */ +function laserEndPosition(start, direction) { + const d = getForwardVector(direction); + const ts = []; + if (d.x > 0) { + const t = (SCREEN_WIDTH - start.x) / d.x; + if (t > 0) ts.push(t); + } else if (d.x < 0) { + const t = -start.x / d.x; + if (t > 0) ts.push(t); + } + if (d.y > 0) { + const t = (720 - start.y) / d.y; + if (t > 0) ts.push(t); + } else if (d.y < 0) { + const t = -start.y / d.y; + if (t > 0) ts.push(t); + } + const reach = ts.length > 0 ? Math.min(...ts) : Math.max(SCREEN_WIDTH, 720); + return { + x: start.x + d.x * reach, + y: start.y + d.y * reach + }; +} +function createLaser(start, direction, owner) { + return { + start: { + x: start.x, + y: start.y + }, + end: laserEndPosition(start, direction), + direction, + owner, + timer: 0, + lifetime: LASER_BEAM_LIFETIME, + hit: /* @__PURE__ */ new Set() + }; +} +/** Advances the beam; returns false once it has expired (the expiring frame does no damage). */ +function updateLaser(laser, dt) { + laser.timer += dt; + return laser.timer < laser.lifetime; +} +/** Shortest distance from `point` to the beam segment (the projection is clamped to the segment). */ +function distanceToBeam(laser, point) { + const lx = laser.end.x - laser.start.x; + const ly = laser.end.y - laser.start.y; + const length = lengthOf({ + x: lx, + y: ly + }); + if (length === 0) return Math.hypot(point.x - laser.start.x, point.y - laser.start.y); + const nx = lx / length; + const ny = ly / length; + const projection = Math.max(0, Math.min(length, (point.x - laser.start.x) * nx + (point.y - laser.start.y) * ny)); + const cx = laser.start.x + nx * projection; + const cy = laser.start.y + ny * projection; + return Math.hypot(point.x - cx, point.y - cy); +} +/** True the first time the beam touches `target`; later calls for the same target return false. */ +function laserHits(laser, target) { + if (laser.hit.has(target)) return false; + if (distanceToBeam(laser, target.position) <= target.radius) { + laser.hit.add(target); + return true; + } + return false; +} +//#endregion +//#region src/core/particles.ts +/** +* Fixed-size particle pool (no per-frame allocation). When full, the oldest slot is recycled, +* exactly like the Python `ParticleSystem`. +*/ +var ParticleSystem = class { + capacity; + particles; + nextSlot = 0; + constructor(capacity = 500) { + this.capacity = capacity; + this.particles = Array.from({ length: capacity }, () => ({ + active: false, + x: 0, + y: 0, + vx: 0, + vy: 0, + life: 0, + maxLife: .5, + size: 3 + })); + } + get activeCount() { + let n = 0; + for (const p of this.particles) if (p.active) n++; + return n; + } + /** Emits one particle travelling along `velocity`, with the original +/-30 degree scatter. */ + emit(x, y, velocity, rng) { + const p = this.particles[this.nextSlot]; + if (!p) return; + const v = rotateVec(velocity, uniform(rng, -30, 30)); + p.active = true; + p.x = x; + p.y = y; + p.vx = v.x; + p.vy = v.y; + p.life = 0; + p.maxLife = uniform(rng, .3, .5); + p.size = randint(rng, 2, 4); + this.nextSlot = (this.nextSlot + 1) % this.capacity; + } + update(dt) { + const damping = timeNormalizedDamping(PARTICLE_DAMPING_PER_FRAME, dt); + for (const p of this.particles) { + if (!p.active) continue; + p.x += p.vx * dt; + p.y += p.vy * dt; + p.life += dt; + p.vx *= damping; + p.vy *= damping; + if (p.life >= p.maxLife) p.active = false; + } + } + clear() { + for (const p of this.particles) p.active = false; + this.nextSlot = 0; + } +}; +/** Radial burst (asteroid explosions): evenly spaced headings with +/-15 degree jitter. */ +function emitBurst(system, x, y, count, rng) { + for (let i = 0; i < count; i++) { + const dir = getForwardVector(360 / count * i + uniform(rng, -15, 15)); + system.emit(x, y, { + x: dir.x * 100, + y: dir.y * 100 + }, rng); + } +} +//#endregion +//#region src/core/shot.ts +/** `rotationDegrees` uses the Pygame convention (0 = Down). */ +function createShot(origin, rotationDegrees, owner, charged = false) { + const dir = getForwardVector(rotationDegrees); + return { + position: { + x: origin.x, + y: origin.y + }, + velocity: { + x: dir.x * 500, + y: dir.y * 500 + }, + radius: 5, + owner, + charged, + alive: true + }; +} +function isOutsidePlayfield(position, margin) { + return position.x < -margin || position.x > 1280 + margin || position.y < -margin || position.y > 720 + margin; +} +/** +* Advances a shot. Unlike the Python original, shots that leave the playfield are despawned +* (otherwise they fly forever and stay in the collision loops). +*/ +function updateShot(shot, dt) { + shot.position.x += shot.velocity.x * dt; + shot.position.y += shot.velocity.y * dt; + if (isOutsidePlayfield(shot.position, 50)) shot.alive = false; +} +//#endregion +//#region src/core/player.ts +var NO_INPUT = { + rotate: 0, + move: 0, + shoot: false, + laser: false, + boost: false +}; +function createPlayer(x, y, playerNumber = 1, speedMultiplier = 1, lives = 3) { + return { + playerNumber, + position: { + x, + y + }, + velocity: { + x: 0, + y: 0 + }, + rotation: 0, + radius: 20, + lives, + score: 0, + speedMultiplier, + shootTimer: 0, + shootCooldown: PLAYER_SHOOT_COOLDOWN, + canShoot: true, + isRespawning: false, + respawnTimer: 0, + isMoving: false, + exhaustTimer: 0, + travelHeading: null, + rapidFire: { + active: false, + timer: 0 + }, + multiShot: { + active: false, + timer: 0 + }, + chainLightning: { + active: false, + timer: 0 + }, + megaPower: { + active: false, + timer: 0 + }, + shieldActive: false, + boost: { + active: false, + timer: 0, + cooldown: 0, + keyHeld: false + }, + laser: { + shotsRemaining: 15, + cooldown: 0, + keyHeld: false + }, + motion: { + x: 0, + y: 0 + } + }; +} +/** +* Clamps the ship inside the playfield and, if a wall was hit, sets the bounce velocity. +* Direct port of `Player.check_boundary_collision`. +*/ +function applyBoundaryCollision(p) { + const dir = { + x: 0, + y: 0 + }; + let bounced = false; + if (p.position.x - p.radius < 0) { + p.position.x = p.radius; + dir.x = 1; + bounced = true; + } + if (p.position.x + p.radius > 1280) { + p.position.x = SCREEN_WIDTH - p.radius; + dir.x = -1; + bounced = true; + } + if (p.position.y - p.radius < 0) { + p.position.y = p.radius; + dir.y = 1; + bounced = true; + } + if (p.position.y + p.radius > 720) { + p.position.y = 720 - p.radius; + dir.y = -1; + bounced = true; + } + if (!bounced) return null; + const n = normalize(dir); + p.velocity = { + x: n.x * 150, + y: n.y * 150 + }; + return { + position: { + x: p.position.x, + y: p.position.y + }, + direction: n + }; +} +/** Shot headings for one trigger pull: a single shot, or a -15 / 0 / +15 degree fan with Multi-Shot. */ +function shotAngleOffsets(multiShot) { + return multiShot ? [ + -15, + 0, + 15 + ] : [0]; +} +function tryShoot(p) { + if (p.shootTimer > 0 || !p.canShoot) return []; + if (p.boost.active) return []; + const shots = shotAngleOffsets(p.multiShot.active).map((offset) => createShot(p.position, p.rotation + offset, p.playerNumber, p.chainLightning.active)); + p.shootTimer = p.rapidFire.active ? RAPID_FIRE_COOLDOWN : p.shootCooldown; + return shots; +} +function activateRapidFire(p) { + p.rapidFire = { + active: true, + timer: 5 + }; +} +function activateMultiShot(p) { + p.multiShot = { + active: true, + timer: 8 + }; +} +function activateShield(p) { + p.shieldActive = true; +} +function activateChainLightning(p) { + p.chainLightning = { + active: true, + timer: 7 + }; +} +/** MEGA POWER: Rapid Fire + Multi-Shot + Shield, all for the mega duration. (The caller adds Slow Motion.) */ +function activateMegaPower(p) { + p.megaPower = { + active: true, + timer: 6 + }; + p.rapidFire = { + active: true, + timer: 6 + }; + p.multiShot = { + active: true, + timer: 6 + }; + p.shieldActive = true; +} +/** Starts a boost if one is not already running or cooling down. The cooldown starts immediately. */ +function activateBoost(p) { + if (p.boost.cooldown > 0 || p.boost.active) return false; + p.boost.active = true; + p.boost.timer = 3; + p.boost.cooldown = 8; + return true; +} +/** Fires the laser from the ship's nose if it has charges and is off cooldown. */ +function fireLaser(p) { + if (p.laser.cooldown > 0 || p.laser.shotsRemaining <= 0) return null; + const forward = getForwardVector(p.rotation); + const tip = { + x: p.position.x + forward.x * p.radius, + y: p.position.y + forward.y * p.radius + }; + p.laser.cooldown = 1; + p.laser.shotsRemaining -= 1; + return createLaser(tip, p.rotation, p.playerNumber); +} +/** +* Advances the player by `dt` seconds. Order matches Python's `Player.update`: +* timers -> residual bounce -> power-up timers -> rotate -> translate (+ wall check) -> shoot -> laser -> boost. +*/ +function updatePlayer(p, input, dt) { + const result = { + shots: [], + bounce: null, + exhaust: null, + laser: null, + boostStarted: false + }; + if (p.lives <= 0) return result; + const startX = p.position.x; + const startY = p.position.y; + p.shootTimer -= dt; + p.exhaustTimer -= dt; + if (p.laser.cooldown > 0) p.laser.cooldown -= dt; + if (p.boost.active) { + p.boost.timer -= dt; + if (p.boost.timer <= 0) p.boost.active = false; + } + if (p.boost.cooldown > 0) p.boost.cooldown -= dt; + if (p.isRespawning) { + p.respawnTimer -= dt; + if (p.respawnTimer <= 0) p.isRespawning = false; + } + if (p.velocity.x !== 0 || p.velocity.y !== 0) { + p.position.x += p.velocity.x * dt; + p.position.y += p.velocity.y * dt; + const damping = timeNormalizedDamping(BOUNCE_DAMPING_PER_FRAME, dt); + p.velocity.x *= damping; + p.velocity.y *= damping; + if (lengthOf(p.velocity) < .05) p.velocity = { + x: 0, + y: 0 + }; + } + if (p.megaPower.active) { + p.megaPower.timer -= dt; + if (p.megaPower.timer <= 0) { + p.megaPower.active = false; + p.rapidFire.active = false; + p.multiShot.active = false; + } + } + if (p.rapidFire.active && !p.megaPower.active) { + p.rapidFire.timer -= dt; + if (p.rapidFire.timer <= 0) p.rapidFire.active = false; + } + if (p.multiShot.active && !p.megaPower.active) { + p.multiShot.timer -= dt; + if (p.multiShot.timer <= 0) p.multiShot.active = false; + } + if (p.chainLightning.active) { + p.chainLightning.timer = Math.max(0, p.chainLightning.timer - dt); + if (p.chainLightning.timer <= 0) p.chainLightning.active = false; + } + p.isMoving = false; + const steer = input.rotate === 0 ? input.steer : void 0; + if (steer) p.rotation = turnToward(p.rotation, steer.heading, 300 * dt); + else if (input.rotate !== 0) p.rotation = wrap(p.rotation + input.rotate * dt * 300, 360); + if (steer?.mode === "assist" && input.move > 0) p.travelHeading = p.travelHeading === null ? steer.heading : turnToward(p.travelHeading, steer.heading, 600 * dt); + else p.travelHeading = null; + if (input.move !== 0) { + const forward = getForwardVector(p.travelHeading ?? p.rotation); + const step = 300 * p.speedMultiplier * (p.boost.active ? BOOST_SPEED_MULTIPLIER : 1) * input.move * dt; + p.position.x += forward.x * step; + p.position.y += forward.y * step; + p.isMoving = true; + result.bounce = applyBoundaryCollision(p); + } + if (input.shoot) result.shots = tryShoot(p); + if (input.laser && !p.laser.keyHeld) { + result.laser = fireLaser(p); + p.laser.keyHeld = true; + } else if (!input.laser) p.laser.keyHeld = false; + if (input.boost && !p.boost.keyHeld) { + result.boostStarted = activateBoost(p); + p.boost.keyHeld = true; + } else if (!input.boost) p.boost.keyHeld = false; + if (p.isMoving && p.exhaustTimer <= 0) { + p.exhaustTimer = EXHAUST_PARTICLE_SPAWN_RATE; + const forward = getForwardVector(p.rotation); + const backward = { + x: -forward.x, + y: -forward.y + }; + result.exhaust = { + position: { + x: p.position.x + backward.x * p.radius, + y: p.position.y + backward.y * p.radius + }, + direction: backward + }; + } + p.motion = dt > 0 ? { + x: (p.position.x - startX) / dt, + y: (p.position.y - startY) / dt + } : { + x: 0, + y: 0 + }; + return result; +} +/** Python `take_damage`, in the same order: respawn invulnerability first, then the shield, then a life. */ +function takeDamage(p) { + if (p.isRespawning) return "invulnerable"; + if (p.shieldActive) { + p.shieldActive = false; + return "shield"; + } + p.lives -= 1; + return "life_lost"; +} +/** Moves the ship to the spawn point with 2 s of invulnerability and clears every power-up and any boost. */ +function respawnPlayer(p, x, y) { + if (p.lives <= 0) return; + p.position = { + x, + y + }; + p.rotation = 0; + p.velocity = { + x: 0, + y: 0 + }; + p.motion = { + x: 0, + y: 0 + }; + p.travelHeading = null; + p.isRespawning = true; + p.respawnTimer = 2; + p.rapidFire = { + active: false, + timer: 0 + }; + p.multiShot = { + active: false, + timer: 0 + }; + p.chainLightning = { + active: false, + timer: 0 + }; + p.megaPower = { + active: false, + timer: 0 + }; + p.shieldActive = false; + p.boost.active = false; + p.boost.timer = 0; +} +/** +* A ship that has lost its last life while its teammate plays on. It stops acting and is not drawn; everything timed is +* cleared so no stale shield, boost or power-up shows (or counts) while it is out. Score, laser charges and the boost +* cooldown are kept for a possible Revive. +*/ +function eliminatePlayer(p) { + p.velocity = { + x: 0, + y: 0 + }; + p.motion = { + x: 0, + y: 0 + }; + p.travelHeading = null; + p.isRespawning = false; + p.respawnTimer = 0; + p.isMoving = false; + p.rapidFire = { + active: false, + timer: 0 + }; + p.multiShot = { + active: false, + timer: 0 + }; + p.chainLightning = { + active: false, + timer: 0 + }; + p.megaPower = { + active: false, + timer: 0 + }; + p.shieldActive = false; + p.boost.active = false; + p.boost.timer = 0; +} +//#endregion +//#region src/core/powerup.ts +/** +* The five ordinary drops. MEGA POWER has its own, rarer roll. REVIVE never dropped in the Python game (its spawn chance +* constant is unused); here it replaces an ordinary drop only while a player is out of lives (see `chooseOrdinaryDrop`). +*/ +var ORDINARY_POWERUPS = [ + "rapid_fire", + "shield", + "multi_shot", + "slow_motion", + "chain_lightning" +]; +function createPowerUp(x, y, type, rng, lifetime) { + const dir = getForwardVector(uniform(rng, 0, 360)); + return { + position: { + x, + y + }, + velocity: { + x: dir.x * 30, + y: dir.y * 30 + }, + radius: 15, + type, + lifetime: lifetime ?? (type === "revive" ? 15 : 12), + alive: true + }; +} +/** +* Drop roll for a destroyed asteroid (Python `maybe_spawn_powerup`): first a 1.5 % chance of MEGA POWER, +* otherwise a 12 % chance of one of the five ordinary power-ups, chosen uniformly (~13.3 % overall). +*/ +function maybeSpawnPowerUp(x, y, rng, reviveEligible = false) { + if (rng() < .015) return createPowerUp(x, y, "mega_power", rng); + if (rng() < .12) return createPowerUp(x, y, chooseOrdinaryDrop(rng, reviveEligible), rng); + return null; +} +/** +* The type of an ordinary drop (an asteroid's ordinary roll, or the guaranteed UFO drop): one of the five ordinary +* power-ups, or, while a Revive is useful (`reviveEligible`), a Revive in `REVIVE_SPAWN_CHANCE` of the cases. Nothing +* extra is drawn from `rng` when it is not eligible, so single-player games and two-player games with nobody down play +* out exactly as before. +*/ +function chooseOrdinaryDrop(rng, reviveEligible) { + const type = pick(rng, ORDINARY_POWERUPS); + return reviveEligible && rng() < .3 ? "revive" : type; +} +/** Drifts, ages, and wraps around the screen edges (unlike asteroids, pickups never leave the playfield). */ +function updatePowerUp(p, dt) { + p.position.x += p.velocity.x * dt; + p.position.y += p.velocity.y * dt; + p.lifetime -= dt; + if (p.lifetime <= 0) p.alive = false; + if (p.position.x < 0) p.position.x = SCREEN_WIDTH; + else if (p.position.x > 1280) p.position.x = 0; + if (p.position.y < 0) p.position.y = 720; + else if (p.position.y > 720) p.position.y = 0; +} +//#endregion +//#region src/core/spawner.ts +var SPAWN_EDGES = [ + { + direction: { + x: 1, + y: 0 + }, + point: (t) => ({ + x: -60, + y: t * 720 + }) + }, + { + direction: { + x: -1, + y: 0 + }, + point: (t) => ({ + x: SCREEN_WIDTH + 60, + y: t * 720 + }) + }, + { + direction: { + x: 0, + y: 1 + }, + point: (t) => ({ + x: t * SCREEN_WIDTH, + y: -60 + }) + }, + { + direction: { + x: 0, + y: -1 + }, + point: (t) => ({ + x: t * SCREEN_WIDTH, + y: 780 + }) + } +]; +function createSpawner() { + return { + spawnTimer: 0, + gameplayTimer: 0 + }; +} +function availableArchetypes(gameplayTimer) { + const available = Object.keys(ASTEROID_ARCHETYPE_SPAWN_WEIGHTS).filter((a) => ASTEROID_ARCHETYPE_SPAWN_WEIGHTS[a] > 0 && gameplayTimer >= ASTEROID_ARCHETYPE_TIME_UNLOCKS[a]); + return available.length > 0 ? available : ["standard"]; +} +/** Weighted pick among the currently unlocked archetypes. */ +function chooseArchetype(gameplayTimer, rng) { + const available = availableArchetypes(gameplayTimer); + const roll = uniform(rng, 0, available.reduce((sum, a) => sum + ASTEROID_ARCHETYPE_SPAWN_WEIGHTS[a], 0)); + let running = 0; + for (const archetype of available) { + running += ASTEROID_ARCHETYPE_SPAWN_WEIGHTS[archetype]; + if (roll <= running) return archetype; + } + return available[available.length - 1] ?? "standard"; +} +/** One attempt: random edge, speed 40-100 px/s, +/-30 degree jitter, radius 20/40/60. */ +function spawnEdgeAsteroid(gameplayTimer, rng) { + const edge = pick(rng, SPAWN_EDGES); + const speed = randint(rng, 40, 100); + const velocity = rotateVec({ + x: edge.direction.x * speed, + y: edge.direction.y * speed + }, randint(rng, -30, 30)); + const position = edge.point(uniform(rng, 0, 1)); + const kind = randint(rng, 1, 3); + return createAsteroid(position.x, position.y, 20 * kind, chooseArchetype(gameplayTimer, rng), velocity); +} +/** +* Continuous-mode spawner: at most one asteroid per call, once `spawnRate` seconds have elapsed +* (the timer resets rather than carrying over, as in Python). +* +* Faithful quirk: edge spawn points sit exactly `ASTEROID_MAX_RADIUS` outside the screen, so a +* radius-20 or radius-40 spawn is already past the "fully off-screen" cull test on its first +* update and vanishes. In practice only large asteroids enter the field, at roughly a third of the +* nominal spawn rate. This is preserved because it defines the original game's difficulty. +*/ +function updateSpawner(state, dt, spawnRate, rng) { + state.gameplayTimer += dt; + state.spawnTimer += dt; + if (state.spawnTimer > spawnRate) { + state.spawnTimer = 0; + return [spawnEdgeAsteroid(state.gameplayTimer, rng)]; + } + return []; +} +//#endregion +//#region src/core/starfield.ts +/** (share of stars, [min size, max size], [min brightness, max brightness]) per layer, far to near. */ +var LAYERS = [ + [ + .5, + [1, 1], + [80, 120] + ], + [ + .3, + [1, 2], + [140, 180] + ], + [ + .2, + [2, 3], + [200, 255] + ] +]; +var Starfield = class { + stars = []; + /** Accumulated camera movement in pixels. */ + cameraOffset = { + x: 0, + y: 0 + }; + constructor(rng, starCount = 200) { + LAYERS.forEach(([share, size, brightness], index) => { + const layer = index; + const count = Math.trunc(starCount * share); + for (let i = 0; i < count; i++) this.stars.push({ + x: uniform(rng, 0, SCREEN_WIDTH), + y: uniform(rng, 0, 720), + size: randint(rng, size[0], size[1]), + brightness: randint(rng, brightness[0], brightness[1]), + layer, + parallax: STARFIELD_PARALLAX_FACTORS[layer] + }); + }); + this.stars.sort((a, b) => a.parallax - b.parallax); + } + /** + * Feeds the camera with how far the ship actually moved this frame. (The Python version used the + * ship's bounce velocity, which is zero during normal flight, so the parallax effect never worked.) + */ + scroll(displacement) { + this.cameraOffset.x += displacement.x * 1; + this.cameraOffset.y += displacement.y * 1; + } + /** Screen position of a star: farther layers move less, and everything wraps. */ + project(star) { + return { + x: wrap(star.x - this.cameraOffset.x * star.parallax, SCREEN_WIDTH), + y: wrap(star.y - this.cameraOffset.y * star.parallax, 720) + }; + } +}; +//#endregion +//#region src/core/ufo.ts +var UFO_STATS = { + large: { + radius: 30, + speed: 100, + shootCooldown: 2, + accuracy: 0, + points: 200 + }, + small: { + radius: 20, + speed: 180, + shootCooldown: UFO_SMALL_SHOOT_COOLDOWN, + accuracy: UFO_SMALL_SHOOT_ACCURACY, + points: 500 + } +}; +/** Python `UFO._set_random_movement`: a random heading at full speed; small UFOs often go straight left or right. */ +function chooseHeading(ufo, rng) { + const dir = getForwardVector(uniform(rng, 0, 360)); + ufo.targetVelocity = { + x: dir.x * ufo.speed, + y: dir.y * ufo.speed + }; + if (ufo.type === "small" && rng() < .4) ufo.targetVelocity = { + x: pick(rng, [-1, 1]) * ufo.speed, + y: 0 + }; +} +/** The random draws happen in the Python order: direction-change interval, heading, first-shot delay. */ +function createUfo(x, y, type, rng) { + const stats = UFO_STATS[type]; + const ufo = { + type, + position: { + x, + y + }, + velocity: { + x: 0, + y: 0 + }, + targetVelocity: { + x: 0, + y: 0 + }, + radius: stats.radius, + speed: stats.speed, + shootCooldown: stats.shootCooldown, + accuracy: stats.accuracy, + movementTimer: 0, + directionChangeInterval: uniform(rng, 2, 4), + shootTimer: 0, + blinkTimer: 0, + blinkState: false, + alive: true, + contactGrace: [0, 0] + }; + chooseHeading(ufo, rng); + ufo.shootTimer = uniform(rng, UFO_FIRST_SHOT_MIN, UFO_FIRST_SHOT_MAX); + return ufo; +} +/** +* Direction of a UFO shot in the Pygame convention (0 = down), aimed at `target` and then spoiled by up to +* `180 * (1 - accuracy)` degrees either way. This is the whole of the "70 % accuracy": a small UFO (0.7) strays at +* most 54 degrees, uniformly, and a large UFO (0.0) at most 180, i.e. it fires in a uniformly random direction. +*/ +function aimAngle(from, target, accuracy, rng) { + const dx = target.x - from.x; + const dy = target.y - from.y; + if (dx === 0 && dy === 0) return uniform(rng, 0, 360); + const toTarget = Math.atan2(dy, dx) * 180 / Math.PI - 90; + const maxDeviation = 180 * (1 - accuracy); + return toTarget + uniform(rng, -maxDeviation, maxDeviation); +} +function createUfoShot(origin, angleDegrees) { + const dir = getForwardVector(angleDegrees); + return { + position: { + x: origin.x, + y: origin.y + }, + velocity: { + x: dir.x * 350, + y: dir.y * 350 + }, + radius: 6, + alive: true + }; +} +/** +* Advances a UFO by `dt` seconds and returns the shot it fired, if any. `target` is where the nearest living, +* non-respawning player is (null when there is none, in which case the UFO fires at a random point of the screen). +* Order as in Python `UFO.update`: heading timer -> ease velocity -> move -> wrap -> shoot -> blink. +* UFOs wrap around the screen (unlike asteroids) once they are a full radius outside it. +*/ +function updateUfo(ufo, dt, target, rng) { + ufo.movementTimer += dt; + if (ufo.movementTimer >= ufo.directionChangeInterval) { + ufo.movementTimer = 0; + ufo.directionChangeInterval = uniform(rng, 2, 4); + chooseHeading(ufo, rng); + } + const ease = 1 - Math.exp(-2 * dt); + ufo.velocity.x += (ufo.targetVelocity.x - ufo.velocity.x) * ease; + ufo.velocity.y += (ufo.targetVelocity.y - ufo.velocity.y) * ease; + const p = ufo.position; + p.x += ufo.velocity.x * dt; + p.y += ufo.velocity.y * dt; + if (p.x < -ufo.radius) p.x = SCREEN_WIDTH + ufo.radius; + else if (p.x > 1280 + ufo.radius) p.x = -ufo.radius; + if (p.y < -ufo.radius) p.y = 720 + ufo.radius; + else if (p.y > 720 + ufo.radius) p.y = -ufo.radius; + let shot = null; + ufo.shootTimer -= dt; + if (ufo.shootTimer <= 0) { + ufo.shootTimer = ufo.shootCooldown; + shot = createUfoShot(p, aimAngle(p, target ?? { + x: uniform(rng, 0, 1280), + y: uniform(rng, 0, 720) + }, ufo.accuracy, rng)); + } + ufo.blinkTimer += dt; + if (ufo.blinkTimer >= .3) { + ufo.blinkTimer = 0; + ufo.blinkState = !ufo.blinkState; + } + return shot; +} +function createUfoSpawner(enabled = true) { + return { + enabled, + nextSpawnTime: 5 + }; +} +/** Probability that a continuous-mode spawn is a small UFO at this difficulty level (see `UFO_SMALL_PROGRESSION`). */ +function smallUfoChance(difficultyLevel) { + let chance = 0; + for (const step of UFO_SMALL_PROGRESSION) if (difficultyLevel >= step.level) chance = step.chance; + return chance; +} +/** Continuous-mode type roll. No random number is drawn while the chance is 0, so early games are unchanged. */ +function chooseContinuousUfoType(difficultyLevel, rng) { + const chance = smallUfoChance(difficultyLevel); + return chance > 0 && rng() < chance ? "small" : "large"; +} +/** +* Continuous-mode UFO schedule: the first attempt after 5 s of play, then one every 15 s counted from the moment the +* previous attempt was made. An attempt made while `UFO_MAX_ACTIVE` UFOs are alive is simply skipped (not retried). +* The UFO appears on a random edge, 20-80 % along it, exactly as far outside the screen as an asteroid spawn +* (Python reuses the asteroid edge table), so it spends a moment wrapping from side to side before it flies in. +* Neither difficulty scaling nor Slow Motion affects the timing. The *type* does follow the difficulty level: large UFOs +* only at first, small ones from level 2 on and more and more often (`UFO_SMALL_PROGRESSION`). +*/ +function updateUfoSpawner(state, gameplayTimer, activeUfos, rng, difficultyLevel = 0) { + if (!state.enabled || gameplayTimer < state.nextSpawnTime) return null; + state.nextSpawnTime = gameplayTimer + 15; + if (activeUfos >= 2) return null; + const type = chooseContinuousUfoType(difficultyLevel, rng); + const at = pick(rng, SPAWN_EDGES).point(uniform(rng, UFO_SPAWN_EDGE_MIN, UFO_SPAWN_EDGE_MAX)); + return createUfo(at.x, at.y, type, rng); +} +//#endregion +//#region src/core/game.ts +var PICKUP_FLASH_DURATION = .4; +var VOLATILE_FLASH_DURATION = .32; +var LIGHTNING_FLASH_DURATION = .16; +/** +* The whole game rules, with no rendering or Phaser dependency. A scene feeds it input and a frame +* time, then draws whatever state it finds. Mirrors the update order of the Python `gameloop.py`: +* timers -> difficulty -> players -> entities -> starfield -> collisions. +* +* One simulation owns the shared world; one or two `PlayerState`s (`players`, `player` = Player 1) live in it. +*/ +var GameSim = class { + rng; + config; + phase = "playing"; + /** Why the run ended; null while it is on. */ + gameOverReason = null; + /** Player 1. */ + player; + /** Player 2, or null in a one-player game. */ + player2; + /** Everybody in the run in player order (length 1 or 2). */ + players; + shots = []; + asteroids = []; + powerups = []; + ufos = []; + /** Enemy projectiles; see `UfoShot` for how they differ from `shots`. */ + ufoShots = []; + lasers = []; + pickupFlashes = []; + volatileFlashes = []; + lightningFlashes = []; + particles = new ParticleSystem(); + starfield; + spawner = createSpawner(); + ufoSpawner; + /** Combo / kill-streak counter (see `scoring.ts`). Shared by the whole team, as in Python. */ + combo = createCombo(); + /** The kill-streak banner on screen, if any. */ + streakBanner = null; + /** Seconds of play since (re)start. */ + time = 0; + difficultyTimer = 0; + /** How many difficulty steps (every 30 s) have happened; also what brings small UFOs into the schedule. */ + difficultyLevel = 0; + asteroidSpeedMultiplier = 1; + asteroidSpawnRate = ASTEROID_SPAWN_RATE; + startCooldown; + /** + * Slow Motion is a property of the world, not the player, and only slows asteroids: the spawner, + * shots, pickups, ships, cooldowns and every timer keep running on real time. + */ + slowMotion = { + active: false, + timer: 0 + }; + /** Current screen-shake magnitude in pixels; decays linearly. */ + screenShake = 0; + screenShakeCooldown = 0; + /** Wall-spark rate limiter per player. */ + sparkTimers = []; + /** Counts down after game over; retry is only allowed once it reaches zero. */ + retryDelay = 0; + events = []; + laserHitsUfos; + constructor(options = {}) { + this.rng = options.rng ?? defaultRng; + this.laserHitsUfos = options.laserHitsUfos ?? true; + this.config = resolveGameConfig({ + ...DEFAULT_GAME_CONFIG, + ...options.config + }); + this.startCooldown = options.startCooldown ?? .2; + const lives = this.config.livesMode === "shared" ? 6 : void 0; + if (this.config.playerCount === 1) { + this.player = createPlayer(640, 360, 1, this.config.speed[0]); + this.player2 = null; + } else { + const [s1, s2] = PLAYER_SPAWNS; + this.player = createPlayer(s1.x, s1.y, 1, this.config.speed[0], lives); + this.player2 = createPlayer(s2.x, s2.y, 2, this.config.speed[1], lives); + } + this.players = this.player2 ? [this.player, this.player2] : [this.player]; + this.sparkTimers = this.players.map(() => 0); + this.starfield = new Starfield(this.rng); + this.ufoSpawner = createUfoSpawner(options.ufos ?? true); + } + /** Adds a UFO (the schedule uses this too). It starts at rest and picks its first heading at random. */ + spawnUfo(type, x, y) { + const ufo = createUfo(x, y, type, this.rng); + this.ufos.push(ufo); + this.events.push({ + type: "ufo_spawned", + ufoType: type + }); + return ufo; + } + get isGameOver() { + return this.phase === "gameOver"; + } + /** The team's lives in a shared-lives game, otherwise null (every player counts their own). */ + get sharedLives() { + return this.config.livesMode === "shared" && this.players.length > 1 ? this.player.lives : null; + } + /** Sum of every player's score (the only score in a one-player game). */ + get totalScore() { + return this.players.reduce((sum, p) => sum + p.score, 0); + } + playerByNumber(number) { + return this.players.find((p) => p.playerNumber === number) ?? this.player; + } + /** The player a UFO at `from` shoots at: the nearest one that is alive and not under respawn protection (Player 1 on a tie). */ + targetFor(from) { + let best = null; + let bestDistance = Infinity; + for (const p of this.players) { + if (p.lives <= 0 || p.isRespawning) continue; + const distance = (p.position.x - from.x) ** 2 + (p.position.y - from.y) ** 2; + if (distance < bestDistance) { + best = p; + bestDistance = distance; + } + } + return best; + } + /** True while a player is out of lives (independent lives), a teammate is alive to collect it, and no Revive is lying around. */ + get reviveEligible() { + if (this.players.length < 2 || this.config.livesMode !== "independent" || this.reviveOnField) return false; + return this.players.some((p) => p.lives <= 0) && this.players.some((p) => p.lives > 0); + } + get reviveOnField() { + return this.powerups.some((p) => p.alive && p.type === "revive"); + } + /** + * Advances the game by one rendered frame. Long frames are clamped and split into short + * sub-steps so behaviour (and collision detection) stays stable at any refresh rate. + * `input` is Player 1's controls, `input2` Player 2's (ignored in a one-player game). + */ + step(frameDt, input = NO_INPUT, input2 = NO_INPUT) { + this.events = []; + const dt = Math.min(Math.max(frameDt, 0), MAX_FRAME_DT); + if (dt === 0) return this.events; + const inputs = [input, input2]; + const steps = Math.ceil(dt / MAX_SUBSTEP_DT); + const sub = dt / steps; + for (let i = 0; i < steps; i++) if (this.phase === "playing") this.substep(sub, inputs); + else this.stepGameOver(sub); + return this.events; + } + stepGameOver(dt) { + this.retryDelay = Math.max(0, this.retryDelay - dt); + this.particles.update(dt); + this.updateVolatileFlashes(dt); + } + substep(dt, inputs) { + this.updateTimers(dt); + this.updateDifficulty(); + this.updatePlayers(dt, inputs); + this.updateEntities(dt); + this.scrollStarfield(dt); + this.processCollisions(dt); + this.particles.update(dt); + this.shots = this.shots.filter((s) => s.alive); + this.ufoShots = this.ufoShots.filter((s) => s.alive); + this.ufos = this.ufos.filter((u) => u.alive); + this.asteroids = this.asteroids.filter((a) => a.alive); + this.powerups = this.powerups.filter((p) => p.alive); + } + updateTimers(dt) { + this.updateVolatileFlashes(dt); + if (this.startCooldown > 0) this.startCooldown -= dt; + this.time += dt; + this.difficultyTimer += dt; + tickCombo(this.combo, dt); + if (this.streakBanner && !tickBanner(this.streakBanner, dt)) this.streakBanner = null; + if (this.slowMotion.active) { + this.slowMotion.timer -= dt; + if (this.slowMotion.timer <= 0) this.slowMotion.active = false; + } + if (this.screenShake > 0) this.screenShake = Math.max(0, this.screenShake - 20 * dt); + if (this.screenShakeCooldown > 0) this.screenShakeCooldown -= dt; + this.sparkTimers = this.sparkTimers.map((t) => t > 0 ? t - dt : t); + for (const flash of this.pickupFlashes) flash.age += dt; + this.pickupFlashes = this.pickupFlashes.filter((f) => f.age < PICKUP_FLASH_DURATION); + } + /** Every 30 s asteroids get 15% faster and spawn a little more often. */ + updateDifficulty() { + if (this.difficultyTimer >= 30) { + this.difficultyTimer = 0; + this.difficultyLevel += 1; + this.asteroidSpeedMultiplier += DIFFICULTY_SPEED_INCREMENT; + this.asteroidSpawnRate = Math.max(this.asteroidSpawnRate - DIFFICULTY_SPAWN_RATE_INCREMENT, DIFFICULTY_SPAWN_RATE_MIN); + } + } + updatePlayers(dt, inputs) { + this.players.forEach((player, index) => { + const input = inputs[index] ?? NO_INPUT; + if (player.lives <= 0) { + player.laser.keyHeld = !!input.laser; + player.boost.keyHeld = !!input.boost; + return; + } + player.canShoot = this.startCooldown <= 0; + const result = updatePlayer(player, input, dt); + const number = player.playerNumber; + if (result.shots.length > 0) { + this.shots.push(...result.shots); + this.events.push({ + type: "shot_fired", + player: number + }); + } + if (result.laser) { + this.lasers.push(result.laser); + this.events.push({ + type: "laser_fired", + player: number + }); + } + if (result.boostStarted) this.events.push({ + type: "boost_started", + player: number + }); + if (result.bounce) { + this.addScreenShake(4); + if ((this.sparkTimers[index] ?? 0) <= 0) { + this.sparkTimers[index] = BOUNDARY_SPARK_INTERVAL; + for (let i = 0; i < 6; i++) { + const dir = rotateVec(result.bounce.direction, uniform(this.rng, -30, 30)); + const speed = 80; + this.particles.emit(result.bounce.position.x, result.bounce.position.y, { + x: dir.x * speed, + y: dir.y * speed + }, this.rng); + } + this.events.push({ type: "wall_bounce" }); + } + } + if (result.exhaust) { + const dir = rotateVec(result.exhaust.direction, uniform(this.rng, -10, 10)); + this.particles.emit(result.exhaust.position.x, result.exhaust.position.y, { + x: dir.x * 80, + y: dir.y * 80 + }, this.rng); + } + }); + } + /** The stars follow the average movement of the ships still in play (Python `Starfield.update`). */ + scrollStarfield(dt) { + const living = this.players.filter((p) => p.lives > 0); + if (living.length === 0) return; + const x = living.reduce((sum, p) => sum + p.motion.x, 0) / living.length; + const y = living.reduce((sum, p) => sum + p.motion.y, 0) / living.length; + this.starfield.scroll({ + x: x * dt, + y: y * dt + }); + } + updateEntities(dt) { + this.asteroids.push(...updateSpawner(this.spawner, dt, this.asteroidSpawnRate, this.rng)); + const newUfo = updateUfoSpawner(this.ufoSpawner, this.spawner.gameplayTimer, this.ufos.length, this.rng, this.difficultyLevel); + if (newUfo) { + this.ufos.push(newUfo); + this.events.push({ + type: "ufo_spawned", + ufoType: newUfo.type + }); + } + for (const shot of this.shots) updateShot(shot, dt); + for (const shot of this.ufoShots) updateShot(shot, dt); + const baseDt = dt * this.asteroidSpeedMultiplier; + const asteroidDt = this.slowMotion.active ? baseDt * SLOW_MOTION_FACTOR : baseDt; + const children = []; + for (const asteroid of this.asteroids) children.push(...updateAsteroid(asteroid, asteroidDt, dt, this.rng)); + this.asteroids.push(...children); + for (const powerup of this.powerups) updatePowerUp(powerup, dt); + for (const ufo of this.ufos) { + const shot = updateUfo(ufo, dt, this.targetFor(ufo.position)?.position ?? null, this.rng); + if (shot) { + this.ufoShots.push(shot); + this.events.push({ + type: "ufo_fired", + ufoType: ufo.type + }); + } + } + } + processCollisions(dt) { + if (!this.collidePlayersWithAsteroids()) return; + this.collideShotsWithAsteroids(); + this.collideLasersWithTargets(dt); + this.collideShotsWithUfos(); + if (!this.collidePlayersWithUfos(dt)) return; + if (!this.collideUfoShotsWithPlayers()) return; + this.collectPowerUps(); + if (this.players.length > 1 && this.config.friendlyFire) this.collideFriendlyFire(); + } + /** The living ship nearest to `target` that overlaps it (Player 1 wins a tie), or null. */ + nearestOverlappingPlayer(target) { + let best = null; + let bestDistance = Infinity; + for (const p of this.players) { + if (p.lives <= 0 || !circlesOverlap(p, target)) continue; + const distance = (p.position.x - target.position.x) ** 2 + (p.position.y - target.position.y) ** 2; + if (distance < bestDistance) { + best = p; + bestDistance = distance; + } + } + return best; + } + /** One hit on a ship from `source`. @returns what happened to it, or 'game_over' if that ended the run. */ + hurt(player, source) { + const result = takeDamage(player); + if (result !== "life_lost") return result; + return this.afterLifeLost(player, source) ? "life_lost" : "game_over"; + } + /** + * A ship just lost a life: respawn it, or, with none left, either put it out (its teammate plays on) or end the run. + * In a shared-lives game the pool is every ship's `lives` kept in step, so any loss costs the team one life and the + * run ends when the pool is empty. @returns false if the run ended. + */ + afterLifeLost(player, source) { + if (this.config.livesMode === "shared") for (const p of this.players) p.lives = player.lives; + this.events.push({ + type: "player_hit", + livesLeft: player.lives, + source, + player: player.playerNumber + }); + if (player.lives > 0) { + const spawn = this.spawnFor(player); + respawnPlayer(player, spawn.x, spawn.y); + return true; + } + for (const p of this.players) if (p.lives <= 0) eliminatePlayer(p); + if (this.players.some((p) => p.lives > 0)) { + this.events.push({ + type: "player_eliminated", + player: player.playerNumber + }); + return true; + } + this.triggerGameOver(this.config.livesMode === "shared" ? "shared_lives_exhausted" : "all_eliminated"); + return false; + } + spawnFor(player) { + return PLAYER_SPAWNS[player.playerNumber - 1] ?? PLAYER_SPAWNS[0]; + } + /** @returns false if the game ended during this check. */ + collidePlayersWithAsteroids() { + for (const asteroid of this.asteroids) { + if (!asteroid.alive || asteroid.dying) continue; + const player = this.nearestOverlappingPlayer(asteroid); + if (!player) continue; + if (player.boost.active) { + this.hitAsteroid(asteroid, player); + continue; + } + if (this.hurt(player, "asteroid") === "game_over") return false; + this.destroyWithoutScore(asteroid, .5); + } + return true; + } + collideShotsWithAsteroids() { + for (const shot of this.shots) { + if (!shot.alive) continue; + for (const asteroid of this.asteroids) { + if (!asteroid.alive || asteroid.dying) continue; + if (!circlesOverlap(shot, asteroid)) continue; + shot.alive = false; + const owner = this.playerByNumber(shot.owner); + this.hitAsteroid(asteroid, owner); + if (shot.charged) this.chainLightning(asteroid, owner); + break; + } + } + for (const shot of this.ufoShots) { + if (!shot.alive) continue; + for (const asteroid of this.asteroids) { + if (!asteroid.alive || asteroid.dying) continue; + if (!circlesOverlap(shot, asteroid)) continue; + this.hitAsteroid(asteroid, null); + shot.alive = false; + break; + } + } + } + /** + * Each beam hits every asteroid and UFO it touches exactly once while it lasts, paying its owner. Children spawned + * into the beam's path before it fades are new objects, so they can be hit too (as in the Python game). + */ + collideLasersWithTargets(dt) { + const remaining = []; + for (const laser of this.lasers) { + if (!updateLaser(laser, dt)) continue; + remaining.push(laser); + const owner = this.playerByNumber(laser.owner); + for (const asteroid of this.asteroids) { + if (!asteroid.alive || asteroid.dying) continue; + if (laserHits(laser, asteroid)) this.hitAsteroid(asteroid, owner); + } + if (this.laserHitsUfos) { + for (const ufo of this.ufos) if (ufo.alive && laserHits(laser, ufo)) this.destroyUfo(ufo, owner); + } + } + this.lasers = remaining; + } + /** A player shot is used up by the first UFO it touches. */ + collideShotsWithUfos() { + for (const ufo of this.ufos) { + if (!ufo.alive) continue; + for (const shot of this.shots) { + if (!shot.alive || !circlesOverlap(ufo, shot)) continue; + this.destroyUfo(ufo, this.playerByNumber(shot.owner)); + shot.alive = false; + break; + } + } + } + /** + * Ramming with a boost destroys the UFO and costs the ship nothing (no shield, no life). Otherwise `takeDamage` + * runs, but the UFO survives the contact, so a shield that absorbed it starts a grace period (`contactGrace`): that + * ship is not hit again while it stays in that same contact, until it separates or the grace runs out. Each ship has + * its own grace. @returns false if the game ended. + */ + collidePlayersWithUfos(dt) { + for (const ufo of this.ufos) for (const player of this.players) { + if (!ufo.alive) break; + const slot = player.playerNumber - 1; + if (player.lives <= 0 || !circlesOverlap(player, ufo)) { + ufo.contactGrace[slot] = 0; + continue; + } + if (player.boost.active) { + this.destroyUfo(ufo, player); + continue; + } + const grace = ufo.contactGrace[slot] ?? 0; + if (grace > 0) { + ufo.contactGrace[slot] = grace - dt; + continue; + } + const result = this.hurt(player, "ufo"); + if (result === "game_over") return false; + if (result === "shield") ufo.contactGrace[slot] = 1; + } + return true; + } + /** + * UFO shots hurt a boosting ship too (the boost only protects against ramming). Every shot that connects is used up, + * by the nearest ship if it touches both (Python hit both; one projectile is one hit here). + */ + collideUfoShotsWithPlayers() { + for (const shot of this.ufoShots) { + if (!shot.alive) continue; + const player = this.nearestOverlappingPlayer(shot); + if (!player) continue; + shot.alive = false; + if (this.hurt(player, "ufo_shot") === "game_over") return false; + } + return true; + } + collectPowerUps() { + for (const powerup of this.powerups) { + if (!powerup.alive) continue; + const collector = this.players.find((p) => p.lives > 0 && circlesOverlap(p, powerup)); + if (!collector) continue; + powerup.alive = false; + this.applyPowerUp(powerup.type, collector); + this.pickupFlashes.push({ + position: { ...powerup.position }, + type: powerup.type, + age: 0 + }); + this.events.push({ + type: "powerup_collected", + powerType: powerup.type, + player: collector.playerNumber + }); + } + } + applyPowerUp(type, player) { + switch (type) { + case "chain_lightning": + activateChainLightning(player); + break; + case "mega_power": + activateMegaPower(player); + this.slowMotion = { + active: true, + timer: 6 + }; + break; + case "rapid_fire": + activateRapidFire(player); + break; + case "multi_shot": + activateMultiShot(player); + break; + case "shield": + activateShield(player); + break; + case "slow_motion": + this.slowMotion = { + active: true, + timer: 6 + }; + break; + case "revive": this.reviveTeammate(player); + } + } + /** + * Python `handle_powerup_collection`: the collector brings back a teammate who is out of lives with `REVIVE_LIVES` + * lives, at that player's spawn point with the usual 2 s of protection, all power-ups cleared and score kept. With + * nobody to revive (one player, shared lives, teammate alive) the pickup is simply consumed. + */ + reviveTeammate(collector) { + if (this.config.livesMode !== "independent") return; + const downed = this.players.find((p) => p !== collector && p.lives <= 0); + if (!downed) return; + downed.lives = 3; + const spawn = this.spawnFor(downed); + respawnPlayer(downed, spawn.x, spawn.y); + this.pickupFlashes.push({ + position: { ...spawn }, + type: "revive", + age: 0 + }); + this.events.push({ + type: "player_revived", + player: downed.playerNumber, + by: collector.playerNumber + }); + } + /** + * Python's friendly fire: a player's shot or Laser Beam hurts the *other* ship (never its owner), with the same + * shield / respawn-protection rules as any hit, and a shot that connects is used up. A beam hurts a given ship at most + * once. There is no ship-versus-ship collision and a boost does not hurt the other ship. @returns false if the game ended. + */ + collideFriendlyFire() { + for (const shot of this.shots) { + if (!shot.alive) continue; + for (const player of this.players) { + if (player.playerNumber === shot.owner || player.lives <= 0 || !circlesOverlap(player, shot)) continue; + shot.alive = false; + if (this.hurt(player, "friendly_shot") === "game_over") return false; + break; + } + } + for (const laser of this.lasers) for (const player of this.players) { + if (player.playerNumber === laser.owner || player.lives <= 0) continue; + if (laserHits(laser, player) && this.hurt(player, "friendly_laser") === "game_over") return false; + } + return true; + } + /** + * One hit on an asteroid from a shot, laser or boost ram. Armored asteroids absorb the first hit + * (flash + sparks, no points); a kill scores, starts the death animation and may drop a power-up. + * `scorer` is the player credited (null for UFO shots, which pay nobody). + */ + hitAsteroid(asteroid, scorer, blasts, depth = 0) { + if (!asteroid.alive || asteroid.dying) return; + const result = takeHit(asteroid); + if (!result.destroyed) { + this.applyEffect(result.effect, 1); + if (result.effect) this.events.push({ + type: "asteroid_hit", + position: { ...asteroid.position } + }); + return; + } + const credit = registerKill(this.combo); + const points = scorer ? scaledPoints(getPoints(asteroid), credit.multiplier) : 0; + if (scorer) scorer.score += points; + const drop = maybeSpawnPowerUp(asteroid.position.x, asteroid.position.y, this.rng, this.reviveEligible); + const effect = beginDeath(asteroid); + if (asteroid.archetype !== "volatile") this.applyEffect(effect, 1); + this.events.push({ + type: "asteroid_destroyed", + radius: asteroid.radius, + points, + combo: credit.count, + multiplier: credit.multiplier, + ...asteroid.archetype === "volatile" ? { volatile: true } : {}, + ...scorer ? { player: scorer.playerNumber } : {} + }); + if (credit.milestone) { + this.streakBanner = createBanner(credit.milestone); + this.events.push({ + type: "kill_streak", + kills: credit.milestone.kills, + name: credit.milestone.name, + color: credit.milestone.color + }); + } + if (drop) { + this.powerups.push(drop); + this.events.push({ + type: "powerup_dropped", + powerType: drop.type + }); + } + this.detonateVolatile(asteroid, scorer, blasts, depth); + } + /** + * A UFO dies: flat points (200 / 500, never multiplied), no combo or kill-streak progress, a burst, a screen shake + * and one guaranteed ordinary power-up (never MEGA POWER; a Revive instead when one is needed). Callers check + * `ufo.alive` first, which is what stops a UFO being destroyed, paid or dropped for twice. + */ + destroyUfo(ufo, scorer) { + ufo.alive = false; + const points = UFO_STATS[ufo.type].points; + scorer.score += points; + this.addScreenShake(6); + emitBurst(this.particles, ufo.position.x, ufo.position.y, 10, this.rng); + const drop = createPowerUp(ufo.position.x, ufo.position.y, chooseOrdinaryDrop(this.rng, this.reviveEligible), this.rng); + this.powerups.push(drop); + this.events.push({ + type: "ufo_destroyed", + ufoType: ufo.type, + points, + radius: ufo.radius, + position: { ...ufo.position }, + player: scorer.playerNumber + }); + this.events.push({ + type: "powerup_dropped", + powerType: drop.type + }); + } + destroyWithoutScore(asteroid, shakeScale) { + if (!asteroid.alive || asteroid.dying) return; + const effect = beginDeath(asteroid); + const volatile = asteroid.archetype === "volatile"; + if (!volatile) this.applyEffect(effect, shakeScale); + if (effect) this.events.push({ + type: "asteroid_destroyed", + radius: asteroid.radius, + points: 0, + ...volatile ? { volatile: true } : {} + }); + this.detonateVolatile(asteroid, null); + } + /** + * Breadth-first, synchronous damage in stable asteroid-list order. A nested kill only appends to the queue. + * beginDeath has already marked each source dying, so it can be queued once and cannot be paid again. + * Children appear after the usual death delay, outside this snapshot and this blast's lifetime. + */ + detonateVolatile(asteroid, scorer, pending, depth = 0) { + if (asteroid.archetype !== "volatile") return; + const blasts = pending ?? []; + blasts.push({ + position: { ...asteroid.position }, + scorer, + depth + }); + if (pending) return; + const targets = this.asteroids.slice(); + for (let i = 0; i < blasts.length; i++) { + const blast = blasts[i]; + const radius = 110; + this.volatileFlashes.push({ + position: { ...blast.position }, + radius, + depth: blast.depth, + age: -Math.min(blast.depth, 4) * .025 + }); + if (this.volatileFlashes.length > 32) this.volatileFlashes.shift(); + this.events.push({ + type: "volatile_exploded", + position: { ...blast.position }, + radius, + depth: blast.depth + }); + this.addScreenShake(6); + for (const target of targets) { + if (!target.alive || target.dying || !circlesOverlap({ + position: blast.position, + radius + }, target)) continue; + this.hitAsteroid(target, blast.scorer, blasts, blast.depth + 1); + } + } + } + /** One chain per consumed bullet. Explosions resolve normally before choosing the next living target. */ + chainLightning(source, scorer) { + const visited = /* @__PURE__ */ new Set([source]); + const points = [{ ...source.position }]; + let previous = source; + for (let jump = 0; jump < 2; jump++) { + let nearest = null; + let bestDistance = Infinity; + for (const target of this.asteroids) { + if (!target.alive || target.dying || visited.has(target)) continue; + const distance = (target.position.x - previous.position.x) ** 2 + (target.position.y - previous.position.y) ** 2; + if (distance <= 160 ** 2 && distance < bestDistance) { + nearest = target; + bestDistance = distance; + } + } + if (!nearest) break; + visited.add(nearest); + points.push({ ...nearest.position }); + this.hitAsteroid(nearest, scorer); + previous = nearest; + } + this.lightningFlashes.push({ + points, + age: 0 + }); + if (this.lightningFlashes.length > 24) this.lightningFlashes.shift(); + this.events.push({ + type: "lightning_discharged", + player: scorer.playerNumber + }); + } + updateVolatileFlashes(dt) { + for (const flash of this.lightningFlashes) flash.age += dt; + this.lightningFlashes = this.lightningFlashes.filter((flash) => flash.age < LIGHTNING_FLASH_DURATION); + for (const flash of this.volatileFlashes) flash.age += dt; + this.volatileFlashes = this.volatileFlashes.filter((flash) => flash.age < VOLATILE_FLASH_DURATION); + } + applyEffect(effect, shakeScale) { + if (!effect) return; + this.addScreenShake(effect.shakeAmount * shakeScale); + emitBurst(this.particles, effect.position.x, effect.position.y, effect.particleCount, this.rng); + } + addScreenShake(amount) { + if (this.screenShakeCooldown > 0) return; + this.screenShake = Math.min(this.screenShake + amount, 12); + this.screenShakeCooldown = SCREEN_SHAKE_COOLDOWN; + } + triggerGameOver(reason) { + this.phase = "gameOver"; + this.gameOverReason = reason; + this.retryDelay = GAME_OVER_RETRY_DELAY; + this.lasers = []; + this.streakBanner = null; + this.events.push({ + type: "game_over", + score: this.totalScore, + scores: this.players.map((p) => p.score), + reason + }); + } +}; +//#endregion +//#region src/replay/verifier.ts +/** +* Validates untrusted replay data structure and constraints at runtime. +*/ +function validateReplayStructure(raw) { + const issues = []; + if (!raw || typeof raw !== "object" || Array.isArray(raw)) return { + ok: false, + error: "Replay must be a JSON object", + issues: [{ + field: "root", + message: "Not an object" + }] + }; + const r = raw; + if (!r.header || typeof r.header !== "object" || Array.isArray(r.header)) issues.push({ + field: "header", + message: "Missing or invalid header" + }); + else { + const h = r.header; + if (h.schemaVersion !== 1) issues.push({ + field: "header.schemaVersion", + message: `Unsupported schema version: ${h.schemaVersion}; expected 1` + }); + if (h.rulesVersion !== "1.2.0") issues.push({ + field: "header.rulesVersion", + message: `Unsupported rules version: ${h.rulesVersion}; expected ${GAMEPLAY_RULES_VERSION}` + }); + if (typeof h.seed !== "number" || !Number.isInteger(h.seed) || h.seed < 0 || h.seed > 4294967295) issues.push({ + field: "header.seed", + message: `Seed must be a 32-bit unsigned integer; got ${h.seed}` + }); + if (h.tickRate !== 60) issues.push({ + field: "header.tickRate", + message: `Unsupported tick rate: ${h.tickRate}; expected 60` + }); + if (h.playerCount !== 1) issues.push({ + field: "header.playerCount", + message: `Phase 1 only supports single-player replays; got ${h.playerCount}` + }); + if (!h.config || typeof h.config !== "object") issues.push({ + field: "header.config", + message: "Missing or invalid game config" + }); + else { + const cfg = h.config; + if (cfg.playerCount !== 1) issues.push({ + field: "header.config.playerCount", + message: "Config playerCount must be 1" + }); + if (cfg.livesMode !== "independent" && cfg.livesMode !== "shared") issues.push({ + field: "header.config.livesMode", + message: `Invalid livesMode: ${cfg.livesMode}` + }); + } + } + if (typeof r.totalTicks !== "number" || !Number.isInteger(r.totalTicks) || r.totalTicks <= 0) issues.push({ + field: "totalTicks", + message: "totalTicks must be a positive integer" + }); + else if (r.totalTicks > 108e3) issues.push({ + field: "totalTicks", + message: `totalTicks exceeds limit of ${MAX_REPLAY_TICKS}` + }); + if (!Array.isArray(r.inputs)) issues.push({ + field: "inputs", + message: "inputs must be an array" + }); + else { + if (r.inputs.length === 0) issues.push({ + field: "inputs", + message: "inputs array cannot be empty" + }); + if (r.inputs.length > 1e5) issues.push({ + field: "inputs", + message: `inputs change count exceeds limit of ${MAX_REPLAY_INPUT_CHANGES}` + }); + let prevTick = -1; + for (let i = 0; i < r.inputs.length; i++) { + const change = r.inputs[i]; + if (!change || typeof change !== "object") { + issues.push({ + field: `inputs[${i}]`, + message: "Input entry must be an object" + }); + break; + } + const tick = change.tick; + if (typeof tick !== "number" || !Number.isInteger(tick) || tick < 0) { + issues.push({ + field: `inputs[${i}].tick`, + message: `Invalid tick index: ${tick}` + }); + break; + } + if (i === 0 && tick !== 0) issues.push({ + field: "inputs[0].tick", + message: `First input change must start at tick 0; got ${tick}` + }); + if (tick <= prevTick) { + issues.push({ + field: `inputs[${i}].tick`, + message: `Ticks must be strictly increasing: tick ${tick} <= prev ${prevTick}` + }); + break; + } + if (typeof r.totalTicks === "number" && tick >= r.totalTicks) { + issues.push({ + field: `inputs[${i}].tick`, + message: `Input tick ${tick} cannot be >= totalTicks ${r.totalTicks}` + }); + break; + } + prevTick = tick; + const inp = change.input; + if (!inp || typeof inp !== "object") { + issues.push({ + field: `inputs[${i}].input`, + message: "Input object missing" + }); + break; + } + const inpObj = inp; + if (typeof inpObj.rotate !== "number" || !Number.isFinite(inpObj.rotate) || inpObj.rotate < -1 || inpObj.rotate > 1) { + issues.push({ + field: `inputs[${i}].input.rotate`, + message: `Invalid rotate value: ${inpObj.rotate}` + }); + break; + } + if (typeof inpObj.move !== "number" || !Number.isFinite(inpObj.move) || inpObj.move < -1 || inpObj.move > 1) { + issues.push({ + field: `inputs[${i}].input.move`, + message: `Invalid move value: ${inpObj.move}` + }); + break; + } + if (typeof inpObj.shoot !== "boolean") { + issues.push({ + field: `inputs[${i}].input.shoot`, + message: "shoot must be boolean" + }); + break; + } + if (inpObj.laser !== void 0 && typeof inpObj.laser !== "boolean") { + issues.push({ + field: `inputs[${i}].input.laser`, + message: "laser must be boolean if present" + }); + break; + } + if (inpObj.boost !== void 0 && typeof inpObj.boost !== "boolean") { + issues.push({ + field: `inputs[${i}].input.boost`, + message: "boost must be boolean if present" + }); + break; + } + if (inpObj.steer !== void 0) { + if (!inpObj.steer || typeof inpObj.steer !== "object") { + issues.push({ + field: `inputs[${i}].input.steer`, + message: "steer must be an object if present" + }); + break; + } + const st = inpObj.steer; + if (typeof st.heading !== "number" || !Number.isFinite(st.heading)) { + issues.push({ + field: `inputs[${i}].input.steer.heading`, + message: `Invalid steer heading: ${st.heading}` + }); + break; + } + if (st.mode !== "point" && st.mode !== "assist") { + issues.push({ + field: `inputs[${i}].input.steer.mode`, + message: `Invalid steer mode: ${st.mode}` + }); + break; + } + } + } + } + if (issues.length > 0) return { + ok: false, + error: `Validation failed with ${issues.length} issue(s): ${issues[0]?.message}`, + issues + }; + return { + ok: true, + record: raw + }; +} +function verifyReplay(replayData, options = {}) { + const requireGameOver = options.requireGameOver ?? true; + let parsed; + if (typeof replayData === "string") try { + parsed = JSON.parse(replayData); + } catch (e) { + return errorResult(`Malformed JSON: ${e.message}`); + } + else parsed = replayData; + const structure = validateReplayStructure(parsed); + if (!structure.ok) return errorResult(structure.error); + const { header, inputs, totalTicks, claimedResult } = structure.record; + if (options.maxTicks && totalTicks > options.maxTicks) return errorResult(`totalTicks ${totalTicks} exceeds configured maximum ${options.maxTicks}`); + const sim = new GameSim({ + rng: seededRng(header.seed), + config: resolveGameConfig(header.config) + }); + const stats = { + asteroidsDestroyed: 0, + ufosDestroyed: 0, + shotsFired: 0, + lasersFired: 0, + boostsUsed: 0, + powerupsCollected: 0, + hitsTaken: 0, + finalLives: sim.player.lives + }; + let inputIndex = 0; + let currentInput = toPlayerInput(inputs[0]?.input ?? { + rotate: 0, + move: 0, + shoot: false + }); + let gameOverTick = null; + for (let tick = 0; tick < totalTicks; tick++) { + if (gameOverTick !== null && tick > gameOverTick) { + const postGameOverInput = inputs.find((inp) => inp.tick > gameOverTick); + if (postGameOverInput) return errorResult(`Unexpected input change at tick ${postGameOverInput.tick} after game over occurred at tick ${gameOverTick}`); + return errorResult(`Unexpected simulation tick ${tick} after game over occurred at tick ${gameOverTick}`); + } + while (inputIndex < inputs.length && inputs[inputIndex].tick === tick) { + if (sim.isGameOver && gameOverTick !== null) return errorResult(`Unexpected input change at tick ${tick} after game over occurred at tick ${gameOverTick}`); + currentInput = toPlayerInput(inputs[inputIndex].input); + inputIndex++; + } + const events = sim.step(FIXED_DT, currentInput, NO_INPUT); + for (const ev of events) trackEvent(ev, stats); + if (sim.isGameOver && gameOverTick === null) gameOverTick = tick; + } + stats.finalLives = sim.player.lives; + const timeLimited = !sim.isGameOver && options.timeLimitTicks !== void 0 && totalTicks === options.timeLimitTicks; + const endReason = sim.isGameOver ? "game_over" : timeLimited ? "time_limit" : void 0; + if (requireGameOver && !sim.isGameOver && !timeLimited) return { + valid: false, + calculatedScore: sim.totalScore, + totalTicks, + simulatedDuration: totalTicks * FIXED_DT, + phase: sim.phase, + gameOverReason: sim.gameOverReason, + stats, + error: "Replay simulation completed without reaching a legitimate game-over state" + }; + let discrepancy; + if (claimedResult) { + if (claimedResult.score !== sim.totalScore) discrepancy = `Score mismatch: claimed ${claimedResult.score} but independently calculated ${sim.totalScore}`; + else if (claimedResult.totalTicks !== totalTicks) discrepancy = `Tick mismatch: claimed ${claimedResult.totalTicks} but replay contained ${totalTicks}`; + else if (claimedResult.gameOverReason !== sim.gameOverReason) discrepancy = `GameOverReason mismatch: claimed ${claimedResult.gameOverReason} but calculated ${sim.gameOverReason}`; + else if (claimedResult.endReason !== void 0 && endReason !== void 0 && claimedResult.endReason !== endReason) discrepancy = `End reason mismatch: claimed ${claimedResult.endReason} but calculated ${endReason}`; + } + return { + valid: !discrepancy, + calculatedScore: sim.totalScore, + totalTicks, + simulatedDuration: totalTicks * FIXED_DT, + phase: sim.phase, + gameOverReason: sim.gameOverReason, + ...endReason && { endReason }, + stats, + discrepancy, + error: discrepancy + }; +} +function trackEvent(event, stats) { + switch (event.type) { + case "asteroid_destroyed": + stats.asteroidsDestroyed++; + break; + case "ufo_destroyed": + stats.ufosDestroyed++; + break; + case "shot_fired": + stats.shotsFired++; + break; + case "laser_fired": + stats.lasersFired++; + break; + case "boost_started": + stats.boostsUsed++; + break; + case "powerup_collected": + stats.powerupsCollected++; + break; + case "player_hit": stats.hitsTaken++; + } +} +function errorResult(message) { + return { + valid: false, + calculatedScore: 0, + totalTicks: 0, + simulatedDuration: 0, + phase: "playing", + gameOverReason: null, + stats: { + asteroidsDestroyed: 0, + ufosDestroyed: 0, + shotsFired: 0, + lasersFired: 0, + boostsUsed: 0, + powerupsCollected: 0, + hitsTaken: 0, + finalLives: 0 + }, + error: message + }; +} +//#endregion +export { FIXED_DT, FIXED_TICK_RATE, FixedStepRunner, GAMEPLAY_RULES_VERSION, GameSim, MAX_ACCUMULATOR_DT, MAX_REPLAY_INPUT_CHANGES, MAX_REPLAY_TICKS, REPLAY_SCHEMA_VERSION, ReplayRecorder, areRecordedInputsEqual, captureSimSnapshot, compareSnapshots, createDefaultReplayHeader, seededRng, toPlayerInput, toRecordedInput, validateReplayStructure, verifyReplay }; diff --git a/phaser-asteroids/server/rules/1.2.0/fixtures/forged-claim.json.gz b/phaser-asteroids/server/rules/1.2.0/fixtures/forged-claim.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..9c8d98c67f825075b4aa64c9f431fb88911bdc5f GIT binary patch literal 108844 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

t|7CLB=_jQ}>IR&-^TU~9 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�fWm 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Μ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

U4>BwT@=S3Po>mOgMyY(rk?)de( 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 z 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 literal 0 HcmV?d00001 diff --git a/phaser-asteroids/server/rules/1.2.0/fixtures/stopped-early.json.gz b/phaser-asteroids/server/rules/1.2.0/fixtures/stopped-early.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..db3b8920f2962c09ff75870715a2ec74d6f3976d GIT binary patch literal 4079 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 JSON.parse(fs.readFileSync(path.join(dir, file), 'utf8')); +export const readManifest = (dir) => readJson('versions.json', dir); +export const readReleased = (dir) => readJson('released.json', dir); + +const VERSION = /^\d+\.\d+\.\d+$/; +const DATE = /^\d{4}-\d{2}-\d{2}$/; + +/** Problems with the shape of released.json (empty: fine). */ +export function releasedProblems(released) { + const problems = []; + if (!Number.isInteger(released?.policy?.supportDays) || released.policy.supportDays < 1) problems.push('policy.supportDays must be a positive integer'); + if (!Array.isArray(released?.builds)) return [...problems, 'builds must be an array']; + const seen = new Set(); + for (const [i, b] of released.builds.entries()) { + const at = `builds[${i}]`; + if (b.platform !== 'android') problems.push(`${at}.platform must be "android"`); + if (!Number.isInteger(b.versionCode) || b.versionCode < 1) problems.push(`${at}.versionCode must be a positive integer`); + if (typeof b.versionName !== 'string' || !b.versionName) problems.push(`${at}.versionName is required`); + if (!VERSION.test(b.rulesVersion ?? '')) problems.push(`${at}.rulesVersion must look like 1.2.0`); + if (!Number.isInteger(b.schemaVersion)) problems.push(`${at}.schemaVersion must be an integer`); + for (const f of ['distributed', 'supersededOn']) if (b[f] !== null && !DATE.test(b[f] ?? '')) problems.push(`${at}.${f} must be null or YYYY-MM-DD`); + const key = `${b.platform}:${b.versionCode}`; + if (seen.has(key)) problems.push(`${at}: versionCode ${b.versionCode} is listed twice`); + seen.add(key); + } + return problems; +} + +/** + * The rules versions the server must still verify on `today`: every version a listed build plays, until `supportDays` after the day + * that build was superseded (a successor that no longer needs those rules reached all users). A build not yet superseded, or not yet + * handed out at all, always counts. Over time this set can only shrink, so a passing check never starts failing by itself. + */ +export function requiredVersions(released, today = new Date()) { + const now = today.getTime(); + const out = new Set(); + for (const b of released.builds) { + const end = b.supersededOn === null ? Infinity : Date.parse(`${b.supersededOn}T00:00:00Z`) + released.policy.supportDays * DAY_MS; + if (now < end) out.add(b.rulesVersion); + } + return [...out].sort(); +} + +/** Problems with a set of supported versions (what the server registers or what /health reports) against the release record. */ +export function supportProblems({ supported, current, released, today }) { + const have = new Set(supported); + const problems = []; + if (!have.has(current)) problems.push(`the current rules version ${current} is not supported`); + for (const v of requiredVersions(released, today)) { + if (!have.has(v)) { + const builds = released.builds.filter((b) => b.rulesVersion === v).map((b) => `${b.versionName} (${b.versionCode})`).join(', '); + problems.push(`rules ${v} is still needed by distributed Android build(s) ${builds} and must stay supported`); + } + } + return problems; +} + +/** The version directory a path inside server/rules belongs to (`1.2.0/engine.mjs` -> `1.2.0`), or null for the shared files. */ +export function versionOf(relPath) { + const first = relPath.replace(/\\/g, '/').split('/')[0]; + return VERSION.test(first) ? first : null; +} + +/** + * The frozen-files guard, given what changed under server/rules between the base and the head of a change: + * changes [{ status: 'A' | 'M' | 'D', path }] with paths relative to server/rules + * base/head { manifest, released } as parsed at each end + * A frozen version's files may be added, never modified; they may be deleted only when the version is retired (gone from the head + * manifest and not required by any distributed build). Manifest entries of existing versions never change. Release records are + * append-only: a build's `distributed` and `supersededOn` dates are filled in once (supersededOn not backdated), nothing else changes. + */ +export function guardProblems({ changes, base, head, today }) { + const problems = []; + const required = new Set(requiredVersions(head.released, today)); + for (const { status, path: p } of changes) { + const v = versionOf(p); + if (!v) continue; + if (status === 'M') problems.push(`${p}: frozen file modified (rules ${v} is released; bump the rules version and freeze a new one instead)`); + if (status === 'D' && (head.manifest.versions[v] || required.has(v))) { + problems.push(`${p}: frozen file deleted while rules ${v} is still ${required.has(v) ? 'required by a distributed Android build' : 'registered in versions.json'}`); + } + } + for (const [v, entry] of Object.entries(base.manifest.versions)) { + const now = head.manifest.versions[v]; + if (now && JSON.stringify(now) !== JSON.stringify(entry)) problems.push(`versions.json: the entry for released rules ${v} changed`); + if (!now && required.has(v)) problems.push(`versions.json: rules ${v} was removed but distributed builds still need it`); + } + for (const b of base.released.builds) { + const now = head.released.builds.find((x) => x.platform === b.platform && x.versionCode === b.versionCode); + const at = `released.json: build ${b.versionCode}`; + if (!now) { + problems.push(`${at} was removed (records are permanent)`); + continue; + } + for (const f of ['versionName', 'rulesVersion', 'schemaVersion']) if (now[f] !== b[f]) problems.push(`${at}: ${f} changed`); + // The two dates are filled in once (null -> date) and never changed afterwards. + for (const f of ['distributed', 'supersededOn']) if (b[f] !== null && now[f] !== b[f]) problems.push(`${at}: ${f} changed after it was set`); + if (b.supersededOn === null && now.supersededOn !== null && Date.parse(`${now.supersededOn}T00:00:00Z`) < today.getTime() - 2 * DAY_MS) { + problems.push(`${at} is marked superseded on ${now.supersededOn}, before this change (no backdating: the support period starts when it is recorded)`); + } + } + return problems; +} diff --git a/phaser-asteroids/server/rules/versions.json b/phaser-asteroids/server/rules/versions.json new file mode 100644 index 0000000..a4e8c9d --- /dev/null +++ b/phaser-asteroids/server/rules/versions.json @@ -0,0 +1,17 @@ +{ + "versions": { + "1.2.0": { + "schemaVersion": 1, + "frozenAt": "2026-11-02", + "files": { + "engine.mjs": "e8852c740372cc3499287215aa86bdd95951c1b14fd47ab814ed6a400f44e72f", + "engine.d.mts": "2823580b116fdd0b46205382f47472fcfe0a5a5a719f1a64062afa7dd9435379", + "fixtures/game-over-reference.json.gz": "b47e22817f034b977ac97627310a952db1d7a770aa3634ffa6b923bfaf703fbe", + "fixtures/game-over-stress.json.gz": "136ea6641cdc1746299cdae61b87a7622b429f32010ba9a9b98df0c50ae063b7", + "fixtures/time-limit.json.gz": "ad9e658a5ad4f18b55792183801b3bf423b18bece5a84218839ac150586d9cb5", + "fixtures/stopped-early.json.gz": "f73083da65a7cba1d08ad5529175337c1b8c0f2750ae698ca3ca121ffc90f057", + "fixtures/forged-claim.json.gz": "b1a8328882f3be974e395acc452fe84667006ce1ebf3d6556ccd0bef0d88c59e" + } + } + } +} diff --git a/phaser-asteroids/server/scripts/freeze-rules.mjs b/phaser-asteroids/server/scripts/freeze-rules.mjs new file mode 100644 index 0000000..7b9baa1 --- /dev/null +++ b/phaser-asteroids/server/scripts/freeze-rules.mjs @@ -0,0 +1,138 @@ +// Freezes the CURRENT replay engine (simulation + verifier) as the server's verifier for the current gameplay rules version. +// +// npm run rules:freeze write server/rules// (engine + reference replays) and its server/rules/versions.json entry +// npm run rules:freeze -- --check rebuild in a temporary folder and report whether the committed engine still matches; writes nothing +// npm run rules:freeze -- --replace overwrite a version that is NOT yet on main (the CI guard refuses it for anything already released) +// +// It builds `src/replay/index.ts` exactly as `npm run build` does for dist/node (one self-contained ES module, no imports), copies it to +// server/rules//engine.mjs, then uses THAT file and the test bot to record reference replays with the results that engine +// computes for them. server/tests/rulesCompat.test.ts replays them through the frozen engine and, for the current version, through the +// live sources too: a gameplay change made without a rules version bump fails there. See server/rules/README.md. + +import { spawnSync } from 'node:child_process'; +import fs from 'node:fs'; +import os from 'node:os'; +import path from 'node:path'; +import { fileURLToPath, pathToFileURL } from 'node:url'; +import zlib from 'node:zlib'; +import { digest } from '../rules/policy.mjs'; +import { generateBotReplay } from '../testing/bot.mjs'; + +const serverDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..'); +const root = path.resolve(serverDir, '..'); +const rulesDir = path.join(serverDir, 'rules'); +const manifestPath = path.join(rulesDir, 'versions.json'); + +const RANKED_TICKS = 72_000; // 20 minutes at 60 Hz: what the server issues (config.ts MAX_RANKED_TICKS) +const ranked = { maxTicks: RANKED_TICKS, requireGameOver: true, timeLimitTicks: RANKED_TICKS }; +const SHORT_LIMIT = 1800; + +/** The reference replays recorded for every frozen version. Each one pins a different part of the verifier's behaviour. */ +const FIXTURES = [ + { name: 'game-over-reference', note: 'the bot plays seed 54321 until game over (the server tests use the same game)', bot: { seed: 54321 }, options: ranked }, + { name: 'game-over-stress', note: 'an aggressive bot on another seed, until game over', bot: { seed: 20261102, stress: true }, options: ranked }, + { name: 'time-limit', note: `still alive at an issued ${SHORT_LIMIT}-tick limit: a valid time_limit ending`, bot: { seed: 54321, maxTicks: SHORT_LIMIT }, options: { maxTicks: SHORT_LIMIT, requireGameOver: true, timeLimitTicks: SHORT_LIMIT } }, + { name: 'stopped-early', note: 'stops while alive, before the limit: must be rejected', bot: { seed: 54321, maxTicks: 900 }, options: ranked }, + { name: 'forged-claim', note: 'the reference game with its claimed score raised by 1000: must be rejected', bot: { seed: 54321 }, options: ranked, forge: (r) => void (r.claimedResult.score += 1000) }, +]; + +const git = (...args) => spawnSync('git', args, { cwd: root, encoding: 'utf8' }).stdout.trim(); + +function buildEngine(outDir) { + const vite = path.join(root, 'node_modules', 'vite', 'bin', 'vite.js'); + const res = spawnSync(process.execPath, [vite, 'build', '--outDir', outDir, '--emptyOutDir', '--target', 'node20', '--ssr', 'src/replay/index.ts', '--logLevel', 'warn'], { cwd: root, stdio: 'inherit' }); + if (res.status !== 0) throw new Error(`vite build failed (exit ${res.status ?? res.signal})`); + return fs.readFileSync(path.join(outDir, 'index.js')); +} + +function header(version, schema) { + const commit = git('rev-parse', '--short', 'HEAD') || 'unknown'; + const dirty = git('status', '--porcelain', '--', 'src/core', 'src/replay') ? ' plus uncommitted changes to src/core or src/replay' : ''; + return ( + `// FROZEN replay engine for gameplay rules ${version} (replay schema ${schema}). Generated by \`npm run rules:freeze\` from ${commit}${dirty}.\n` + + `// Never edit this file: the server verifies every ${version} run with it, and its hash is pinned in ../versions.json. See ../README.md.\n` + ); +} + +/** Types for engine.mjs: only what server/src/engines.ts relies on (it checks them at load time too). Same for every version. */ +const TYPES = `// Types for engine.mjs, generated by \`npm run rules:freeze\`. Only what server/src/engines.ts uses. Never edit: see ../README.md. +export declare const GAMEPLAY_RULES_VERSION: string; +export declare const REPLAY_SCHEMA_VERSION: number; +export declare const FIXED_TICK_RATE: number; +export declare function verifyReplay(replay: unknown, options?: object): unknown; +`; + +export function fixtureResults(engine) { + return FIXTURES.map((f) => { + const run = generateBotReplay(engine, f.bot); + const replay = structuredClone(run.replay); + f.forge?.(replay); + const expected = engine.verifyReplay(replay, f.options); + return { name: f.name, fixture: { note: f.note, options: f.options, expected, replay } }; + }); +} + +async function main() { + const check = process.argv.includes('--check'); + const replace = process.argv.includes('--replace'); + const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'rules-freeze-')); + try { + const built = buildEngine(tmp); + const probe = await import(pathToFileURL(path.join(tmp, 'index.js')).href); + const version = probe.GAMEPLAY_RULES_VERSION; + const schema = probe.REPLAY_SCHEMA_VERSION; + const dir = path.join(rulesDir, version); + const enginePath = path.join(dir, 'engine.mjs'); + const existing = fs.existsSync(enginePath) ? fs.readFileSync(enginePath) : null; + const body = (buf) => buf.toString('utf8').split('\n').filter((l) => !l.startsWith('// FROZEN') && !l.startsWith('// Never edit')).join('\n'); + const same = existing !== null && body(existing) === body(built); + + if (check) { + console.log(existing === null ? `rules ${version} is not frozen yet` : same ? `rules ${version}: the frozen engine matches the current sources byte for byte` : `rules ${version}: the current sources build a DIFFERENT engine than the frozen one (fine if only non-gameplay code changed; the reference replays decide)`); + return; + } + if (existing !== null && !same && !replace) { + throw new Error(`server/rules/${version}/ already exists and the current sources build a different engine. If gameplay changed, bump GAMEPLAY_RULES_VERSION in src/replay/constants.ts and freeze again. Use --replace only for a version that has never been merged to main.`); + } + if (existing !== null && same && !replace) { + console.log(`rules ${version} is already frozen and unchanged; nothing to do`); + return; + } + + fs.rmSync(dir, { recursive: true, force: true }); + fs.mkdirSync(path.join(dir, 'fixtures'), { recursive: true }); + fs.writeFileSync(enginePath, header(version, schema) + built.toString('utf8')); + const engine = await import(`${pathToFileURL(enginePath).href}?t=${Date.now()}`); + if (engine.GAMEPLAY_RULES_VERSION !== version || typeof engine.verifyReplay !== 'function') throw new Error('frozen engine does not load'); + + fs.writeFileSync(path.join(dir, 'engine.d.mts'), TYPES); + + const files = { 'engine.mjs': digest(fs.readFileSync(enginePath), 'engine.mjs'), 'engine.d.mts': digest(TYPES, 'engine.d.mts') }; + for (const { name, fixture } of fixtureResults(engine)) { + // gzip: the bot changes its input almost every tick, so a 20 000-tick game is ~1.7 MB of JSON and ~110 KB compressed. + const rel = `fixtures/${name}.json.gz`; + const bytes = zlib.gzipSync(JSON.stringify(fixture), { level: 9 }); + fs.writeFileSync(path.join(dir, rel), bytes); + files[rel] = digest(bytes, rel); + const e = fixture.expected; + console.log(` ${rel.padEnd(37)} valid=${e.valid} score=${e.calculatedScore} ticks=${e.totalTicks} end=${e.endReason ?? '-'} (${Math.round(bytes.length / 1024)} KB)`); + } + + const manifest = fs.existsSync(manifestPath) ? JSON.parse(fs.readFileSync(manifestPath, 'utf8')) : { versions: {} }; + manifest.versions[version] = { schemaVersion: schema, frozenAt: new Date().toISOString().slice(0, 10), files }; + manifest.versions = Object.fromEntries(Object.entries(manifest.versions).sort(([a], [b]) => a.localeCompare(b, 'en', { numeric: true }))); + fs.writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`); + + console.log(`\nFroze rules ${version} (schema ${schema}) into server/rules/${version}/ and server/rules/versions.json.`); + console.log(`Next: register it in server/src/engines.ts:\n import * as rules_${version.replace(/\W/g, '_')} from '../rules/${version}/engine.mjs';\n ...registry([..., frozen(rules_${version.replace(/\W/g, '_')})])`); + } finally { + fs.rmSync(tmp, { recursive: true, force: true }); + } +} + +if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) { + main().catch((e) => { + console.error(`[rules:freeze] ${e instanceof Error ? e.message : e}`); + process.exit(1); + }); +} diff --git a/phaser-asteroids/server/scripts/worker-e2e.mjs b/phaser-asteroids/server/scripts/worker-e2e.mjs index 7c1c70f..735fd4e 100644 --- a/phaser-asteroids/server/scripts/worker-e2e.mjs +++ b/phaser-asteroids/server/scripts/worker-e2e.mjs @@ -87,10 +87,14 @@ try { // --- challenge issuance ------------------------------------------------------------------------------------------------- const health = await api('GET', '/api/v1/health'); - check('health reports rules version', health.json?.rulesVersion === '1.1.0'); + const RULES = engine.GAMEPLAY_RULES_VERSION; + check('health reports the current rules version and every supported one', health.json?.rulesVersion === RULES && Array.isArray(health.json?.supportedRules) && health.json.supportedRules.includes(RULES), JSON.stringify(health.json)); const probe = await api('POST', '/api/v1/runs', { body: JSON.stringify({ seed: 1, config: { playerCount: 2 } }), headers: { 'content-type': 'application/json' } }); check('POST /runs issues a challenge (201) with server-chosen seed and approved config', probe.status === 201 && probe.json.seed !== 1 && probe.json.config.playerCount === 1); - check('challenge carries id, secret token, rules version, expiry', !!probe.json.runId && probe.json.token?.length >= 40 && probe.json.rulesVersion === '1.1.0' && Date.parse(probe.json.expiresAt) > Date.now()); + check('challenge carries id, secret token, rules version, expiry', !!probe.json.runId && probe.json.token?.length >= 40 && probe.json.rulesVersion === RULES && Date.parse(probe.json.expiresAt) > Date.now()); + const asked = await api('POST', `/api/v1/runs?rules=${RULES}&schema=${engine.REPLAY_SCHEMA_VERSION}`); + const unknownRules = await api('POST', '/api/v1/runs?rules=0.0.1&schema=1'); + check('a client naming its supported rules gets them; an unknown version gets the current one', asked.status === 201 && asked.json.rulesVersion === RULES && asked.json.schemaVersion === engine.REPLAY_SCHEMA_VERSION && unknownRules.status === 201 && unknownRules.json.rulesVersion === RULES); // --- prepare several real games, all played against server-issued seeds ----------------------------------------------------- const honest = await playableRun(); diff --git a/phaser-asteroids/server/src/config.ts b/phaser-asteroids/server/src/config.ts index 8252876..11c4a35 100644 --- a/phaser-asteroids/server/src/config.ts +++ b/phaser-asteroids/server/src/config.ts @@ -1,5 +1,5 @@ import type { GameConfig } from '../../src/core/gameConfig'; -import { FIXED_TICK_RATE, GAMEPLAY_RULES_VERSION, REPLAY_SCHEMA_VERSION } from '../../src/replay/constants'; +import { FIXED_TICK_RATE, GAMEPLAY_RULES_VERSION } from '../../src/replay/constants'; import type { D1Like } from './d1'; /** @@ -13,8 +13,8 @@ export const RANKED_CONFIG: Readonly = Object.freeze({ speed: Object.freeze([1, 1]) as unknown as readonly [number, number], }); +/** What a challenge is issued under when the client does not ask for a supported version; must be registered in engines.ts. */ export const RANKED_RULES_VERSION = GAMEPLAY_RULES_VERSION; -export const RANKED_SCHEMA_VERSION = REPLAY_SCHEMA_VERSION; export const RANKED_TICK_RATE = FIXED_TICK_RATE; /** Bindings and variables the Worker receives (see wrangler.toml). Everything except `DB` is optional so local runs need no setup. */ diff --git a/phaser-asteroids/server/src/engines.ts b/phaser-asteroids/server/src/engines.ts new file mode 100644 index 0000000..9f25c16 --- /dev/null +++ b/phaser-asteroids/server/src/engines.ts @@ -0,0 +1,71 @@ +import type { VerificationResult } from '../../src/replay/types'; +import type { VerifyOptions } from '../../src/replay/verifier'; +import * as rules_1_2_0 from '../rules/1.2.0/engine.mjs'; + +/** + * The gameplay rules versions this server can verify, as an explicit allowlist. Each entry is a FROZEN build of the replay engine + * (simulation + verifier) for exactly one rules version and one replay schema, committed under ../rules// and never edited + * afterwards (see ../rules/README.md). The live game sources in ../../src are not used to verify anything: a gameplay change cannot + * alter how runs of an existing version are scored, and a run keeps verifying under the version it was issued with for as long as + * that version is listed here. + * + * To add a version: `npm run rules:freeze` (it writes ../rules// and its manifest entry), then add one import and one + * `frozen(...)` line below. To retire one: see the retirement policy in ../rules/README.md; tests refuse to drop a version that a + * distributed Android build still needs (../rules/released.json). + */ +export const ENGINES: EngineRegistry = registry([frozen(rules_1_2_0)]); + +export interface RulesEngine { + readonly rulesVersion: string; + /** The one replay schema this engine reads. A schema change always comes with a new rules version. */ + readonly schemaVersion: number; + readonly tickRate: number; + /** The contract every frozen engine keeps: `verifyReplay(replay, { maxTicks, requireGameOver, timeLimitTicks })`. */ + verifyReplay(replay: unknown, options: VerifyOptions): VerificationResult; +} + +export type EngineRegistry = Readonly>; + +/** What a frozen bundle (`vite build --ssr src/replay/index.ts`) exports that the server relies on. */ +export interface FrozenModule { + GAMEPLAY_RULES_VERSION: string; + REPLAY_SCHEMA_VERSION: number; + FIXED_TICK_RATE: number; + verifyReplay: (replay: unknown, options?: VerifyOptions) => VerificationResult; +} + +/** Wraps a frozen bundle's module namespace (typed `unknown`: TypeScript's guesses about a plain JS file do not matter here). */ +export function frozen(namespace: unknown): RulesEngine { + const mod = namespace as FrozenModule; + const { GAMEPLAY_RULES_VERSION: rulesVersion, REPLAY_SCHEMA_VERSION: schemaVersion, FIXED_TICK_RATE: tickRate } = mod; + if (typeof rulesVersion !== 'string' || !Number.isInteger(schemaVersion) || !Number.isInteger(tickRate) || typeof mod.verifyReplay !== 'function') { + throw new Error('not a replay engine bundle'); + } + return Object.freeze({ rulesVersion, schemaVersion, tickRate, verifyReplay: (replay: unknown, options: VerifyOptions) => mod.verifyReplay(replay, options) }); +} + +export function registry(engines: readonly RulesEngine[]): EngineRegistry { + const out: Record = Object.create(null); + for (const e of engines) { + if (out[e.rulesVersion]) throw new Error(`rules ${e.rulesVersion} registered twice`); + out[e.rulesVersion] = e; + } + return Object.freeze(out); +} + +/** The engine for an exact version string, or null. Untrusted input is fine: only the registry's own keys match. */ +export function engineFor(engines: EngineRegistry, version: unknown): RulesEngine | null { + return typeof version === 'string' && Object.prototype.hasOwnProperty.call(engines, version) ? engines[version]! : null; +} + +/** + * Which rules a new challenge is issued under. A client that names a supported rules version (and, if it names one, that version's + * schema) gets exactly that, so an installed app keeps working after the server learns a newer version. Anything else, including no + * request at all (web clients from before this existed), gets the server's current version, which is what every client got before; + * a client running something else then sees the challenge does not match it and says "update". Never an error: the client decides. + */ +export function issueEngine(engines: EngineRegistry, currentVersion: string, requestedRules: string | null, requestedSchema: string | null): RulesEngine | null { + const asked = engineFor(engines, requestedRules); + if (asked && (requestedSchema === null || requestedSchema === String(asked.schemaVersion))) return asked; + return engineFor(engines, currentVersion); +} diff --git a/phaser-asteroids/server/src/router.ts b/phaser-asteroids/server/src/router.ts index 32abb91..b8479da 100644 --- a/phaser-asteroids/server/src/router.ts +++ b/phaser-asteroids/server/src/router.ts @@ -1,6 +1,7 @@ -import { RANKED_SCHEMA_VERSION, RANKED_TICK_RATE } from './config'; +import { RANKED_TICK_RATE } from './config'; import { constantTimeEqual, sha256Hex } from './crypto'; import { readBoundedBody } from './body'; +import { ENGINES, engineFor } from './engines'; import { ApiError } from './errors'; import { getLeaderboard, getScoreDetail, type Scope } from './leaderboard'; import { hitRateLimit } from './ratelimit'; @@ -13,7 +14,7 @@ const API = '/api/v1'; * Worker, in Node (tests) or behind any other fetch-style host. * * GET /api/v1/health - * POST /api/v1/runs issue a ranked challenge + * POST /api/v1/runs issue a ranked challenge (?rules=&schema=: the client's own versions) * POST /api/v1/runs/:id/submit submit the recording for that challenge (Bearer run token) * GET /api/v1/leaderboard/all-time|weekly ?limit=&offset= * GET /api/v1/scores/:id one entry with its ranks @@ -48,7 +49,18 @@ async function route(request: Request, url: URL, origin: string | null, deps: Se if (path === `${API}/health`) { only(method, 'GET'); - return json({ ok: true, rulesVersion: settings.rulesVersion, schemaVersion: RANKED_SCHEMA_VERSION, maxTicks: settings.maxTicks, timeLimitSeconds: settings.maxTicks / RANKED_TICK_RATE, time: new Date(deps.now()).toISOString() }); + const engines = deps.engines ?? ENGINES; + // rulesVersion / schemaVersion: what a request without ?rules= is issued (the current version). supportedRules: every version + // this deployment verifies and issues on request; the release gate checks that it covers every distributed app. + return json({ + ok: true, + rulesVersion: settings.rulesVersion, + schemaVersion: engineFor(engines, settings.rulesVersion)?.schemaVersion ?? null, + supportedRules: Object.keys(engines).sort((a, b) => a.localeCompare(b, 'en', { numeric: true })), + maxTicks: settings.maxTicks, + timeLimitSeconds: settings.maxTicks / RANKED_TICK_RATE, + time: new Date(deps.now()).toISOString(), + }); } if (path === `${API}/runs`) { @@ -57,7 +69,7 @@ async function route(request: Request, url: URL, origin: string | null, deps: Se const ipHash = await clientHash(request, deps); await hitRateLimit(deps.db, `start:ip:${ipHash}`, settings.rate.startPerIp, settings.rate.windowMs, deps.now()); await hitRateLimit(deps.db, 'start:global', settings.rate.startGlobal, settings.rate.windowMs, deps.now()); - const run = await createRun(deps, ipHash); + const run = await createRun(deps, ipHash, { rules: url.searchParams.get('rules'), schema: url.searchParams.get('schema') }); return json(run, 201, { 'Cache-Control': 'no-store' }); } diff --git a/phaser-asteroids/server/src/runs.ts b/phaser-asteroids/server/src/runs.ts index d015f1a..5ec8242 100644 --- a/phaser-asteroids/server/src/runs.ts +++ b/phaser-asteroids/server/src/runs.ts @@ -1,7 +1,8 @@ import type { GameConfig } from '../../src/core/gameConfig'; -import { RANKED_CONFIG, RANKED_SCHEMA_VERSION, RANKED_TICK_RATE, type ServerSettings } from './config'; +import { RANKED_CONFIG, type ServerSettings } from './config'; import { constantTimeEqual, randomId, randomSeed, randomToken, sha256Hex } from './crypto'; import type { Db } from './db'; +import { ENGINES, issueEngine, type EngineRegistry } from './engines'; import { ApiError } from './errors'; import { getScoreRow, rankOf, type PublicScore } from './leaderboard'; import { sanitizeNickname } from './nickname'; @@ -24,6 +25,14 @@ export interface ServiceDeps { now: () => number; /** Replaceable in tests only; production always uses verifyRankedReplay. */ verify?: (replay: unknown, run: IssuedRunFacts, now: number, settings: ServerSettings) => RankedVerdict; + /** The frozen rules engines this server issues and verifies (engines.ts). Replaceable in tests only. */ + engines?: EngineRegistry; +} + +/** What the client asked to play (`POST /runs?rules=&schema=`). Untrusted: it only selects among the registered engines. */ +export interface IssueRequest { + rules: string | null; + schema: string | null; } export interface IssuedRun { @@ -80,16 +89,25 @@ export function sanitizeControls(input: unknown): string { // --- issuing --------------------------------------------------------------------------------------------------------------- -export async function createRun(deps: ServiceDeps, issuerHash: string | null): Promise { +export async function createRun(deps: ServiceDeps, issuerHash: string | null, requested: IssueRequest = { rules: null, schema: null }): Promise { const { db, settings } = deps; const now = deps.now(); + // The stored rules_version is what later selects the verifier (verify.ts); the schema is the one that engine reads. + const engine = issueEngine(deps.engines ?? ENGINES, settings.rulesVersion, requested.rules, requested.schema); + if (!engine) { + console.error(JSON.stringify({ evt: 'no_current_engine', rules: settings.rulesVersion })); + throw new ApiError(503, 'service_unavailable', 'Ranked play is temporarily unavailable', {}, { 'Retry-After': '60' }); + } + if (requested.rules !== null && engine.rulesVersion !== requested.rules) { + console.warn(JSON.stringify({ evt: 'rules_not_supported', requested: requested.rules.slice(0, 32), issued: engine.rulesVersion })); + } const run: IssuedRun = { runId: randomId(), token: randomToken(), seed: randomSeed(), - rulesVersion: settings.rulesVersion, - schemaVersion: RANKED_SCHEMA_VERSION, - tickRate: RANKED_TICK_RATE, + rulesVersion: engine.rulesVersion, + schemaVersion: engine.schemaVersion, + tickRate: engine.tickRate, config: { ...RANKED_CONFIG, speed: [...RANKED_CONFIG.speed] as [number, number] }, timeLimitTicks: settings.maxTicks, issuedAt: new Date(now).toISOString(), @@ -177,7 +195,9 @@ export async function submitRun(deps: ServiceDeps, input: SubmitInput): Promise< createdAt: run.created_at, timeLimitTicks: run.time_limit_ticks, }; - verdict = (deps.verify ?? verifyRankedReplay)(payload.replay, facts, claimedAt, settings); + verdict = deps.verify + ? deps.verify(payload.replay, facts, claimedAt, settings) + : verifyRankedReplay(payload.replay, facts, claimedAt, settings, deps.engines ?? ENGINES); } catch (e) { // A replay that crashes the verifier cannot be scored. Treat it as a rejection (not a retryable error) so a crafted // payload cannot be resubmitted indefinitely; the stack trace goes to the operator's logs. diff --git a/phaser-asteroids/server/src/verify.ts b/phaser-asteroids/server/src/verify.ts index 9f60a30..15d60e8 100644 --- a/phaser-asteroids/server/src/verify.ts +++ b/phaser-asteroids/server/src/verify.ts @@ -1,8 +1,7 @@ import type { GameConfig } from '../../src/core/gameConfig'; -import { FIXED_TICK_RATE } from '../../src/replay/constants'; -import { verifyReplay } from '../../src/replay/verifier'; import type { VerificationResult } from '../../src/replay/types'; import { MAX_RANKED_TICKS, type ServerSettings } from './config'; +import { ENGINES, engineFor, type EngineRegistry } from './engines'; /** What the server issued for this run; the replay must agree with every field. */ export interface IssuedRunFacts { @@ -54,16 +53,16 @@ function configMatches(actual: unknown, expected: GameConfig): boolean { * Whatever the replay says about its own score (`claimedResult`) is never used as the score; verifyReplay only cross-checks it, * and a disagreement is a rejection. */ -export function verifyRankedReplay(replay: unknown, run: IssuedRunFacts, now: number, settings: ServerSettings): RankedVerdict { +export function verifyRankedReplay(replay: unknown, run: IssuedRunFacts, now: number, settings: ServerSettings, engines: EngineRegistry = ENGINES): RankedVerdict { if (!replay || typeof replay !== 'object' || Array.isArray(replay)) return reject('invalid_replay', 'replay must be an object'); const r = replay as { header?: Record; totalTicks?: unknown }; const header = r.header; if (!header || typeof header !== 'object' || Array.isArray(header)) return reject('invalid_replay', 'replay header is missing'); - // The verifier in this deployment only knows one rules version. A run issued before an upgrade can no longer be reproduced. - if (run.rulesVersion !== settings.rulesVersion) { - return reject('rules_mismatch', `this run was issued under rules ${run.rulesVersion}; the server now verifies ${settings.rulesVersion}`); - } + // The engine is chosen by the rules version stored when the run was ISSUED, never by anything in the submission. Each one is a + // frozen build (engines.ts), so a run verifies the same way whatever the current rules are, until its version is retired. + const engine = engineFor(engines, run.rulesVersion); + if (!engine) return reject('rules_mismatch', `this run was issued under rules ${run.rulesVersion}, which this server no longer verifies`); if (header.seed !== run.seed) return reject('seed_mismatch', 'replay seed is not the seed issued for this run'); if (header.rulesVersion !== run.rulesVersion) { return reject('rules_mismatch', `replay rules version ${String(header.rulesVersion)} is not the issued ${run.rulesVersion}`); @@ -84,7 +83,7 @@ export function verifyRankedReplay(replay: unknown, run: IssuedRunFacts, now: nu // The game clock cannot run faster than the wall clock: ticks advance at most once per 1/60 s of real time, and the client // could not begin playing before the challenge existed. This rejects "ten minutes of play submitted five seconds later". // It cannot prove a human played; a bot may simply wait. - const simulatedMs = (totalTicks * 1000) / FIXED_TICK_RATE; + const simulatedMs = (totalTicks * 1000) / engine.tickRate; const elapsedMs = now - run.createdAt; if (simulatedMs > elapsedMs + settings.elapsedSlackMs) { return reject('too_fast', `replay covers ${Math.round(simulatedMs)} ms of play but only ${Math.max(0, Math.round(elapsedMs))} ms have passed since the challenge was issued`); @@ -92,7 +91,7 @@ export function verifyRankedReplay(replay: unknown, run: IssuedRunFacts, now: nu // A run still alive at the limit ends there; the client cannot pick the tick, because only a replay of exactly `limit` ticks // qualifies and a game over before it always takes precedence. A run issued without a recorded limit can only end in game over. - const result = verifyReplay(replay, { + const result = engine.verifyReplay(replay, { maxTicks: limit, requireGameOver: true, ...(run.timeLimitTicks != null && { timeLimitTicks: limit }), diff --git a/phaser-asteroids/server/tests/versions.test.ts b/phaser-asteroids/server/tests/versions.test.ts new file mode 100644 index 0000000..0cc5ad4 --- /dev/null +++ b/phaser-asteroids/server/tests/versions.test.ts @@ -0,0 +1,144 @@ +import { describe, expect, it, vi } from 'vitest'; +import type { VerificationResult } from '../../src/replay/types'; +import { ENGINES, engineFor, issueEngine, registry, type RulesEngine } from '../src/engines'; +import { botRun, count, makeHarness, REFERENCE_SEED } from './harness'; + +// Several rules versions served side by side: how a challenge's version is chosen, and that the version recorded at issue (never the +// submission) selects the frozen verifier. Real games, verified by the real frozen 1.2.0 engine; "1.3.0" is a stand-in for a future +// version, so its verifier is a spy. +vi.setConfig({ testTimeout: 60_000 }); + +const V12 = ENGINES['1.2.0']!; + +function futureEngine(): RulesEngine & { calls: number } { + const engine = { + rulesVersion: '1.3.0', + schemaVersion: 1, + tickRate: 60, + calls: 0, + verifyReplay(): VerificationResult { + engine.calls++; + return { valid: false, calculatedScore: 0, totalTicks: 0, simulatedDuration: 0, phase: 'playing', gameOverReason: null, stats: {} as VerificationResult['stats'], error: 'stand-in engine' }; + }, + }; + return engine; +} + +/** A server that has been upgraded: it issues 1.3.0 by default and still verifies 1.2.0. */ +function upgraded() { + const h = makeHarness({ settings: { rulesVersion: '1.3.0' } }); + const future = futureEngine(); + h.deps.engines = registry([V12, future]); + return { h, future }; +} + +const startWith = (h: ReturnType, query: string, ip = '203.0.113.9') => h.call('POST', `/api/v1/runs${query}`, { ip }); + +describe('choosing the rules a challenge is issued under', () => { + it('a client naming a supported version gets exactly that version and its schema', async () => { + const { h } = upgraded(); + const res = await startWith(h, '?rules=1.2.0&schema=1'); + expect(res.status).toBe(201); + expect(res.body).toMatchObject({ rulesVersion: '1.2.0', schemaVersion: 1, tickRate: 60 }); + expect((await h.db.first<{ rules_version: string }>('SELECT rules_version FROM runs'))!.rules_version).toBe('1.2.0'); + }); + + it('a client that names nothing (web pages from before this) gets the current version, as before', async () => { + const { h } = upgraded(); + expect((await startWith(h, '')).body.rulesVersion).toBe('1.3.0'); + }); + + it('an unsupported, malformed or hostile version falls back to the current one, which the client then refuses ("update")', async () => { + const { h } = upgraded(); + const asked = ['?rules=1.1.0&schema=1', '?rules=9.9.9', '?rules=1.2.0&schema=2', '?rules=1.2.0&schema=', '?rules=__proto__', '?rules=constructor', '?rules=toString', '?rules=hasOwnProperty', `?rules=${'9'.repeat(5000)}`, '?rules=1.2.0%00']; + const issued = []; + for (const [i, q] of asked.entries()) issued.push((await startWith(h, q, `198.51.100.${i}`)).body.rulesVersion); + expect(issued).toEqual(asked.map(() => '1.3.0')); + }); + + it('only the query string counts: a body cannot choose the version (or anything else)', async () => { + const { h } = upgraded(); + const res = await h.call('POST', '/api/v1/runs', { json: { rules: '1.2.0', rulesVersion: '1.2.0', schema: 1 }, ip: '198.51.100.40' }); + expect(res.body.rulesVersion).toBe('1.3.0'); + }); + + it('engineFor and issueEngine only ever match registered keys', () => { + for (const k of ['__proto__', 'constructor', 'toString', 'valueOf', '', null, undefined, 1.2, {}]) expect(engineFor(ENGINES, k)).toBeNull(); + expect(engineFor(ENGINES, '1.2.0')).toBe(V12); + expect(issueEngine(ENGINES, '1.2.0', 'nope', null)).toBe(V12); + expect(issueEngine(ENGINES, 'missing', null, null)).toBeNull(); + }); + + it('a server whose current version is not registered refuses to issue rather than issuing something unverifiable', async () => { + const h = makeHarness({ settings: { rulesVersion: '7.0.0' } }); + const res = await startWith(h, ''); + expect(res.status).toBe(503); + expect(await count(h.db, 'runs')).toBe(0); + }); + + it('health lists every supported version and keeps the fields existing readers use', async () => { + const { h } = upgraded(); + const res = await h.call('GET', '/api/v1/health'); + expect(res.body).toMatchObject({ ok: true, rulesVersion: '1.3.0', schemaVersion: 1, supportedRules: ['1.2.0', '1.3.0'] }); + }); +}); + +describe('verifying with the version recorded at issue', () => { + it('a 1.2.0 run from an installed app is verified by the frozen 1.2.0 engine on a server whose current version is newer', async () => { + const { h, future } = upgraded(); + const run = (await startWith(h, '?rules=1.2.0&schema=1')).body; + await h.db.run('UPDATE runs SET seed = ? WHERE id = ?', [REFERENCE_SEED, run.runId]); + const res = await h.playAndSubmit(run, botRun(REFERENCE_SEED).replay); + expect(res.status).toBe(200); + expect(res.body.score).toMatchObject({ score: 34735, rulesVersion: '1.2.0' }); + expect(future.calls).toBe(0); + }); + + it('a rules update deployed while a run is in progress does not invalidate it', async () => { + const h = makeHarness(); // today's server: 1.2.0 only + const run = await h.start({ seed: REFERENCE_SEED }); + expect(run.rulesVersion).toBe('1.2.0'); + // ...the player is mid-game when the new version deploys: + h.settings.rulesVersion = '1.3.0'; + h.deps.engines = registry([V12, futureEngine()]); + const res = await h.playAndSubmit(run, botRun(REFERENCE_SEED).replay); + expect(res.status).toBe(200); + expect(res.body.score.score).toBe(34735); + }); + + it('a submission cannot pick its verifier: a 1.3.0 run with a replay that claims 1.2.0 is rejected without running 1.2.0', async () => { + const { h, future } = upgraded(); + const run = (await startWith(h, '')).body; + expect(run.rulesVersion).toBe('1.3.0'); + await h.db.run('UPDATE runs SET seed = ? WHERE id = ?', [REFERENCE_SEED, run.runId]); + const spy = vi.fn(V12.verifyReplay); + h.deps.engines = registry([{ ...V12, verifyReplay: spy }, future]); + const res = await h.playAndSubmit(run, botRun(REFERENCE_SEED).replay); // a genuine 1.2.0 recording + expect(res.status).toBe(422); + expect(res.body.error.reason).toBe('rules_mismatch'); + expect(spy).not.toHaveBeenCalled(); + expect(future.calls).toBe(0); + }); + + it('a 1.2.0 run whose recording is altered is still rejected by the frozen engine (re-simulation, not trust)', async () => { + const { h } = upgraded(); + const run = (await startWith(h, '?rules=1.2.0&schema=1')).body; + await h.db.run('UPDATE runs SET seed = ? WHERE id = ?', [REFERENCE_SEED, run.runId]); + const forged = botRun(REFERENCE_SEED).replay; + forged.claimedResult!.score += 5000; + const res = await h.playAndSubmit(run, forged); + expect(res.body.error.reason).toBe('score_mismatch'); + expect(await count(h.db, 'scores')).toBe(0); + }); + + it('once a version is retired, its remaining runs are refused as rules_mismatch (final), and nothing is scored', async () => { + const h = makeHarness(); + const run = await h.start({ seed: REFERENCE_SEED }); + h.settings.rulesVersion = '1.3.0'; + h.deps.engines = registry([futureEngine()]); + const res = await h.playAndSubmit(run, botRun(REFERENCE_SEED).replay); + expect(res.status).toBe(422); + expect(res.body.error).toMatchObject({ reason: 'rules_mismatch' }); + expect(await count(h.db, 'scores')).toBe(0); + }); +}); diff --git a/phaser-asteroids/src/ranked/api.ts b/phaser-asteroids/src/ranked/api.ts index 07dc7b0..61adca3 100644 --- a/phaser-asteroids/src/ranked/api.ts +++ b/phaser-asteroids/src/ranked/api.ts @@ -123,11 +123,20 @@ async function withTimeout(fetchFn: FetchLike, url: string, init: RequestInit, m // --- starting a run ---------------------------------------------------------------------------------------------------------- +/** + * The challenge request's URL. It names the rules and replay schema this build plays, so a server that has learned a newer version + * still issues this one for as long as it supports it (an installed app keeps working through a gameplay update). A query string, not + * a body or a header, keeps the request a CORS "simple" request: no preflight round trip on a phone. + */ +export function challengeUrl(base: string): string { + return `${base}/api/v1/runs?rules=${encodeURIComponent(GAMEPLAY_RULES_VERSION)}&schema=${REPLAY_SCHEMA_VERSION}`; +} + /** Asks the server for a ranked challenge. Throws RankedApiError; the caller must then NOT start a ranked run. */ export async function requestChallenge(base: string, fetchFn: FetchLike = realFetch): Promise { let res: Response; try { - res = await withTimeout(fetchFn, `${base}/api/v1/runs`, { method: 'POST' }, 10_000); + res = await withTimeout(fetchFn, challengeUrl(base), { method: 'POST' }, 10_000); } catch { throw new RankedApiError('network', 'The ranked service could not be reached'); } diff --git a/phaser-asteroids/tests/chainLightning.test.ts b/phaser-asteroids/tests/chainLightning.test.ts index 1fbeb56..5858b60 100644 --- a/phaser-asteroids/tests/chainLightning.test.ts +++ b/phaser-asteroids/tests/chainLightning.test.ts @@ -238,18 +238,26 @@ describe('Chain Lightning power-up', () => { expect(eventsOfType(sim.step(FRAME), 'lightning_discharged')).toHaveLength(0); }); - it('reproduces genuine lightning pickups and destruction order in the authoritative current-rules verifier', () => { + it('reproduces genuine lightning pickups and destruction order in the authoritative current-rules verifier', async () => { const seed = 54321; + // The server verifies with the frozen engine for the current rules (server/rules//engine.mjs), which has its own copy of + // GameSim: record live play's events from the live class and the verifier's events from the frozen one. + const frozen = (await import(`../server/rules/${GAMEPLAY_RULES_VERSION}/engine.mjs`)) as { GameSim: typeof GameSim }; + const record = (cls: typeof GameSim, into: ReturnType) => { + const original = cls.prototype.step; + return vi.spyOn(cls.prototype, 'step').mockImplementation(function (this: GameSim, ...args) { + const result = original.apply(this, args); + into.push(...result); + return result; + }); + }; + const trace: ReturnType = []; const events: ReturnType = []; - const original = GameSim.prototype.step; - const spy = vi.spyOn(GameSim.prototype, 'step').mockImplementation(function (this: GameSim, ...args) { - const result = original.apply(this, args); - events.push(...result); - return result; - }); + const liveSpy = record(GameSim, trace); + const frozenSpy = record(frozen.GameSim, events); try { const run = generateBotReplay(engine, { seed }); - const trace = events.splice(0); + expect(events).toHaveLength(0); const verdict = verifyRankedReplay(run.replay, { seed, rulesVersion: GAMEPLAY_RULES_VERSION, config: RANKED_CONFIG, createdAt: 0, }, run.ticks * FIXED_DT * 1000, loadSettings()); @@ -262,7 +270,8 @@ describe('Chain Lightning power-up', () => { oldReplay.header.rulesVersion = '1.1.0'; expect(verifyRankedReplay(oldReplay, { seed, rulesVersion: GAMEPLAY_RULES_VERSION, config: RANKED_CONFIG, createdAt: 0 }, 1e9, loadSettings()).ok).toBe(false); } finally { - spy.mockRestore(); + liveSpy.mockRestore(); + frozenSpy.mockRestore(); } }); }); diff --git a/phaser-asteroids/tests/ranked.test.ts b/phaser-asteroids/tests/ranked.test.ts index 469acc4..2644664 100644 --- a/phaser-asteroids/tests/ranked.test.ts +++ b/phaser-asteroids/tests/ranked.test.ts @@ -25,6 +25,7 @@ import { rulesInScoringEra, scoringEra, scoringEraLabel } from '../src/ranked/sc import { rankedSession } from '../src/ranked/session'; import { SubmissionFlow } from '../src/ranked/submission'; import type { ReplayRecord } from '../src/replay'; +import { GAMEPLAY_RULES_VERSION, REPLAY_SCHEMA_VERSION } from '../src/replay/constants'; const challenge: RankedChallenge = { runId: '11111111-1111-4111-8111-111111111111', @@ -100,6 +101,18 @@ describe('requestChallenge', () => { expect(c.seed).toBe(123456); expect(c.timeLimitTicks).toBe(72_000); }); + it('names the rules and schema this build plays, as a CORS-simple POST (no body, no custom headers)', async () => { + const seen: { url: string; init?: RequestInit }[] = []; + await requestChallenge('http://x', async (url, init) => { + seen.push({ url, init }); + return reply(201, challenge); + }); + expect(seen).toHaveLength(1); + expect(seen[0]!.url).toBe(`http://x/api/v1/runs?rules=${GAMEPLAY_RULES_VERSION}&schema=${REPLAY_SCHEMA_VERSION}`); + expect(seen[0]!.init?.method).toBe('POST'); + expect(seen[0]!.init?.body).toBeUndefined(); + expect(seen[0]!.init?.headers).toBeUndefined(); + }); it('fails (never invents a challenge) when offline, rate limited, or refused', async () => { await expect(requestChallenge('http://x', async () => Promise.reject(new TypeError('offline')))).rejects.toMatchObject({ code: 'network' }); await expect(requestChallenge('http://x', async () => reply(429, {}))).rejects.toMatchObject({ code: 'rate_limited' }); From 241cfde767548a10cfe10940fcd2cf0be9dc572e Mon Sep 17 00:00:00 2001 From: djblackett <49618491+djblackett@users.noreply.github.com> Date: Mon, 2 Nov 2026 11:38:01 -0400 Subject: [PATCH 08/10] ci: guard frozen rules versions and the Android builds that need them - server/rules/released.json: every Android build handed out, the rules it plays, and when a successor replaced it; policy.supportDays = 90. The release candidate (1.0, versionCode 1, rules 1.2.0) is recorded with distributed: null, so 1.2.0 is protected from now on. - server/tests/rulesCompat.test.ts (runs with npm test, before the Worker deploys): engines.ts registers exactly the versions in versions.json; the current GAMEPLAY_RULES_VERSION is frozen and registered; every version a released build still needs is supported; each frozen file matches its pinned hash and nothing is added or missing; engines import nothing; the reference replays give the recorded results through their frozen engine, and the current version's also through the live sources, so a gameplay change without a rules bump fails here (checked: a 1-degree turn-speed change fails 4 reference checks and the lifecycle tests). - scripts/rules-guard.mjs (CI step, against the merge base; checkout now fetches full history): frozen files may be added, never modified, and deleted only once retired; versions.json entries never change; released.json records are permanent and only gain their dates, without backdating supersededOn. node:test runs it against scratch git repos. - scripts/production-health.mjs: after deploy, the Worker's supportedRules must include the current rules and every version distributed builds still need. - scripts/build-android.mjs: refuses to package unless the app's rules are frozen and its versionCode is recorded in released.json with those rules. Its tests now run in CI too. Co-Authored-By: Claude Opus 5.5 --- .github/workflows/deploy-gh-pages.yml | 20 +++ phaser-asteroids/package.json | 1 + phaser-asteroids/scripts/build-android.mjs | 46 ++++++ .../scripts/build-android.test.mjs | 23 ++- .../scripts/production-health.mjs | 12 +- .../scripts/production-health.test.mjs | 21 ++- phaser-asteroids/scripts/rules-guard.mjs | 63 ++++++++ phaser-asteroids/scripts/rules-guard.test.mjs | 77 +++++++++ phaser-asteroids/server/rules/released.json | 16 ++ .../server/tests/rulesCompat.test.ts | 153 ++++++++++++++++++ 10 files changed, 427 insertions(+), 5 deletions(-) create mode 100644 phaser-asteroids/scripts/rules-guard.mjs create mode 100644 phaser-asteroids/scripts/rules-guard.test.mjs create mode 100644 phaser-asteroids/server/rules/released.json create mode 100644 phaser-asteroids/server/tests/rulesCompat.test.ts diff --git a/.github/workflows/deploy-gh-pages.yml b/.github/workflows/deploy-gh-pages.yml index 841b15c..196c59e 100644 --- a/.github/workflows/deploy-gh-pages.yml +++ b/.github/workflows/deploy-gh-pages.yml @@ -47,6 +47,9 @@ jobs: steps: - name: Checkout repository uses: actions/checkout@v7 + with: + # Full history: the frozen-rules guard below compares this commit with the base it would merge into. + fetch-depth: 0 - name: Set up Node.js uses: actions/setup-node@v7 @@ -62,9 +65,22 @@ jobs: - name: Typecheck run: npm run typecheck + # Includes server/tests/rulesCompat.test.ts, the release compatibility gate: every rules version a distributed Android build + # plays is still registered, frozen engines match their pinned hashes, and the reference replays still give the recorded results + # (an unversioned gameplay change fails here). See phaser-asteroids/server/rules/README.md. - name: Unit tests run: npm test + # A frozen engine may be added but never edited, and dropped only after its support period. The unit tests above check files + # against their pinned hashes; this checks the hashes and release records themselves were not rewritten. + - name: Frozen replay engines guard + env: + BASE: ${{ github.event_name == 'pull_request' && format('origin/{0}', github.base_ref) || github.event.before }} + run: | + node --test scripts/rules-guard.test.mjs + if [ -z "$BASE" ] || [ "$BASE" = "0000000000000000000000000000000000000000" ]; then BASE=origin/main; fi + node scripts/rules-guard.mjs "$BASE" + - name: Build (typecheck + vite build) env: # Public Worker origin; set this repository Actions variable after backend verification. @@ -92,6 +108,10 @@ jobs: - name: Test production health verification (mock HTTP only) run: node --test scripts/production-health.test.mjs + # Includes the check that the Android versionCode is recorded in server/rules/released.json with the rules it plays. + - name: Test the Android build checks (no Android SDK needed) + run: node --test scripts/build-android.test.mjs + - name: Upload build for deployment if: ${{ github.event_name != 'pull_request' && github.ref == 'refs/heads/main' }} uses: actions/upload-artifact@v7 diff --git a/phaser-asteroids/package.json b/phaser-asteroids/package.json index 2345b35..d8dad52 100644 --- a/phaser-asteroids/package.json +++ b/phaser-asteroids/package.json @@ -29,6 +29,7 @@ "test:pages": "npm run build && node scripts/pages-check.mjs", "test:server": "vitest run server/tests", "rules:freeze": "node server/scripts/freeze-rules.mjs", + "rules:guard": "node scripts/rules-guard.mjs", "test:ranked": "npm run build && node scripts/ranked-browser.mjs", "test:ranked:ui": "npm run build && node scripts/ranked-ui.mjs", "test:lan": "node scripts/lan-check.mjs", diff --git a/phaser-asteroids/scripts/build-android.mjs b/phaser-asteroids/scripts/build-android.mjs index c225619..5ae2720 100644 --- a/phaser-asteroids/scripts/build-android.mjs +++ b/phaser-asteroids/scripts/build-android.mjs @@ -4,6 +4,10 @@ // npm run android:sync the above, then `cap sync android` (copies dist-android/ into the Android project) // node scripts/build-android.mjs --verify-only check an existing dist-android/ without rebuilding // +// Before building it also checks that the leaderboard will keep accepting this app's runs after later gameplay updates: the rules +// version it plays must be frozen (server/rules/versions.json) and its versionCode recorded with those rules in +// server/rules/released.json, which is what makes CI refuse to drop them (see server/rules/README.md). +// // Different from `npm run build` (GitHub Pages) in exactly two ways: // 1. Only the browser game is built. The server-only replay verifier (dist/node, ~8 MB) is never in the app. // 2. The leaderboard URL comes from .env.android and is required: the build stops if it is missing, not https, a loopback or private @@ -14,6 +18,7 @@ import { spawnSync } from 'node:child_process'; import fs from 'node:fs'; import path from 'node:path'; import { fileURLToPath, pathToFileURL } from 'node:url'; +import { readManifest, readReleased } from '../server/rules/policy.mjs'; const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..'); export const ANDROID_OUT_DIR = 'dist-android'; @@ -80,6 +85,40 @@ export function verifyAndroidBuild(dir, apiOrigin) { return problems; } +/** versionCode and versionName from android/app/build.gradle. */ +export function parseGradleVersion(text) { + const code = /^\s*versionCode\s+(\d+)\s*$/m.exec(text); + const name = /^\s*versionName\s+"([^"]+)"\s*$/m.exec(text); + if (!code || !name) throw new Error('android/app/build.gradle: versionCode / versionName not found'); + return { versionCode: Number(code[1]), versionName: name[1] }; +} + +/** The rules and replay schema this source tree plays (src/replay/constants.ts). */ +export function parseReplayVersions(text) { + const rules = /export const GAMEPLAY_RULES_VERSION = '([^']+)';/.exec(text); + const schema = /export const REPLAY_SCHEMA_VERSION = (\d+);/.exec(text); + if (!rules || !schema) throw new Error('src/replay/constants.ts: GAMEPLAY_RULES_VERSION / REPLAY_SCHEMA_VERSION not found'); + return { rulesVersion: rules[1], schemaVersion: Number(schema[1]) }; +} + +/** Why this app build must not be packaged yet, as far as ranked compatibility goes (empty: fine). */ +export function releaseRecordProblems({ rulesVersion, schemaVersion, versionCode, versionName }, manifest, released) { + const problems = []; + if (manifest.versions[rulesVersion]?.schemaVersion !== schemaVersion) { + problems.push(`rules ${rulesVersion} (schema ${schemaVersion}) are not frozen: run \`npm run rules:freeze\` and register them in server/src/engines.ts`); + } + const record = released.builds.find((b) => b.platform === 'android' && b.versionCode === versionCode); + const wanted = JSON.stringify({ platform: 'android', versionName, versionCode, rulesVersion, schemaVersion, distributed: null, supersededOn: null }); + if (!record) { + problems.push(`versionCode ${versionCode} is not recorded in server/rules/released.json; add ${wanted}`); + } else if (record.rulesVersion !== rulesVersion || record.schemaVersion !== schemaVersion) { + problems.push(`versionCode ${versionCode} is recorded with rules ${record.rulesVersion} (schema ${record.schemaVersion}) but this build plays ${rulesVersion} (schema ${schemaVersion}): raise versionCode in android/app/build.gradle and add ${wanted}`); + } else if (record.versionName !== versionName) { + problems.push(`versionCode ${versionCode} is recorded as versionName ${record.versionName}, but build.gradle says ${versionName}`); + } + return problems; +} + /** Reads and checks the API origin from .env.android against the shell environment. Throws with a clear message. */ export function resolveAndroidApiOrigin(envFileText, shellValue) { const fromFile = parseEnvFile(envFileText).get(API_KEY); @@ -100,6 +139,13 @@ function main() { if (!fs.existsSync(envPath)) throw new Error(`${ANDROID_ENV_FILE} is missing`); const origin = resolveAndroidApiOrigin(fs.readFileSync(envPath, 'utf8'), process.env[API_KEY]); const outDir = path.join(root, ANDROID_OUT_DIR); + const build = { + ...parseGradleVersion(fs.readFileSync(path.join(root, 'android', 'app', 'build.gradle'), 'utf8')), + ...parseReplayVersions(fs.readFileSync(path.join(root, 'src', 'replay', 'constants.ts'), 'utf8')), + }; + const recordProblems = releaseRecordProblems(build, readManifest(), readReleased()); + if (recordProblems.length > 0) throw new Error(`ranked compatibility check failed:\n - ${recordProblems.join('\n - ')}`); + console.log(`[build:android] ${build.versionName} (${build.versionCode}) plays rules ${build.rulesVersion}, schema ${build.schemaVersion}: frozen and recorded`); if (!verifyOnly) { console.log(`[build:android] API ${origin} -> ${ANDROID_OUT_DIR}/`); diff --git a/phaser-asteroids/scripts/build-android.test.mjs b/phaser-asteroids/scripts/build-android.test.mjs index a4bdea5..bb572f9 100644 --- a/phaser-asteroids/scripts/build-android.test.mjs +++ b/phaser-asteroids/scripts/build-android.test.mjs @@ -4,7 +4,8 @@ import fs from 'node:fs'; import os from 'node:os'; import path from 'node:path'; import test from 'node:test'; -import { checkProductionApiUrl, parseEnvFile, resolveAndroidApiOrigin, verifyAndroidBuild } from './build-android.mjs'; +import { checkProductionApiUrl, parseEnvFile, parseGradleVersion, parseReplayVersions, releaseRecordProblems, resolveAndroidApiOrigin, verifyAndroidBuild } from './build-android.mjs'; +import { readManifest, readReleased } from '../server/rules/policy.mjs'; const PROD = 'https://asteroids-leaderboard.davejandrea.workers.dev'; const envText = `# comment\n\nVITE_LEADERBOARD_API_URL=${PROD}\r\n`; @@ -72,3 +73,23 @@ test('the committed .env.android names the production Worker', () => { const text = fs.readFileSync(new URL('../.env.android', import.meta.url), 'utf8'); assert.equal(resolveAndroidApiOrigin(text, undefined), PROD); }); + +test('this tree can be packaged: its rules are frozen and its versionCode is recorded with them', () => { + const build = { + ...parseGradleVersion(fs.readFileSync(new URL('../android/app/build.gradle', import.meta.url), 'utf8')), + ...parseReplayVersions(fs.readFileSync(new URL('../src/replay/constants.ts', import.meta.url), 'utf8')), + }; + assert.deepEqual(releaseRecordProblems(build, readManifest(), readReleased()), []); +}); + +test('refuses to package a build whose rules are not frozen, or whose versionCode is unrecorded or recorded with other rules', () => { + const manifest = { versions: { '1.2.0': { schemaVersion: 1 } } }; + const released = { policy: { supportDays: 90 }, builds: [{ platform: 'android', versionName: '1.0', versionCode: 1, rulesVersion: '1.2.0', schemaVersion: 1, distributed: null, supersededOn: null }] }; + const build = { versionCode: 1, versionName: '1.0', rulesVersion: '1.2.0', schemaVersion: 1 }; + assert.deepEqual(releaseRecordProblems(build, manifest, released), []); + assert.match(releaseRecordProblems({ ...build, rulesVersion: '1.3.0' }, manifest, released).join(), /not frozen.*raise versionCode/s); + assert.match(releaseRecordProblems({ ...build, versionCode: 2 }, manifest, released).join(), /versionCode 2 is not recorded/); + assert.match(releaseRecordProblems({ ...build, versionName: '1.1' }, manifest, released).join(), /recorded as versionName 1\.0/); + assert.throws(() => parseGradleVersion('defaultConfig {}'), /versionCode/); + assert.deepEqual(parseGradleVersion(' versionCode 12\r\n versionName "1.4"\r\n'), { versionCode: 12, versionName: '1.4' }); +}); diff --git a/phaser-asteroids/scripts/production-health.mjs b/phaser-asteroids/scripts/production-health.mjs index 8c5e3ff..9a1289d 100644 --- a/phaser-asteroids/scripts/production-health.mjs +++ b/phaser-asteroids/scripts/production-health.mjs @@ -2,10 +2,15 @@ import { setTimeout } from 'node:timers/promises'; import { pathToFileURL } from 'node:url'; import { GAMEPLAY_RULES_VERSION, REPLAY_SCHEMA_VERSION } from '../dist/node/index.js'; +import { readReleased, supportProblems } from '../server/rules/policy.mjs'; const HEALTH_URL = 'https://asteroids-leaderboard.davejandrea.workers.dev/api/v1/health'; -export async function verifyProductionHealth(fetchImpl = fetch, wait = setTimeout) { +/** + * Checks the deployed Worker before Pages publishes the web build: it must issue the web build's rules by default (rulesVersion / + * schemaVersion), and its supportedRules must still include every rules version a distributed Android build plays (released.json). + */ +export async function verifyProductionHealth(fetchImpl = fetch, wait = setTimeout, { released = readReleased(), today = new Date() } = {}) { console.log(`Expected rules=${GAMEPLAY_RULES_VERSION}, schema=${REPLAY_SCHEMA_VERSION}`); for (let attempt = 1; attempt <= 5; attempt++) { try { @@ -20,7 +25,10 @@ export async function verifyProductionHealth(fetchImpl = fetch, wait = setTimeou if (health?.ok !== true || health.rulesVersion !== GAMEPLAY_RULES_VERSION || health.schemaVersion !== REPLAY_SCHEMA_VERSION) { throw new Error(`Incompatible health: ok=${JSON.stringify(health?.ok)}, rules=${JSON.stringify(health?.rulesVersion)}, schema=${JSON.stringify(health?.schemaVersion)}`); } - console.log(`Production Worker healthy: rules=${health.rulesVersion}, schema=${health.schemaVersion}`); + if (!Array.isArray(health.supportedRules)) throw new Error('Health does not list supportedRules'); + const problems = supportProblems({ supported: health.supportedRules, current: GAMEPLAY_RULES_VERSION, released, today }); + if (problems.length) throw new Error(`Worker would strand installed apps: ${problems.join('; ')}`); + console.log(`Production Worker healthy: rules=${health.rulesVersion}, schema=${health.schemaVersion}, supported=${health.supportedRules.join(',')}`); return; } catch (error) { console.error(`Health attempt ${attempt}/5 failed: ${error.message}`); diff --git a/phaser-asteroids/scripts/production-health.test.mjs b/phaser-asteroids/scripts/production-health.test.mjs index 86b51eb..e343be0 100644 --- a/phaser-asteroids/scripts/production-health.test.mjs +++ b/phaser-asteroids/scripts/production-health.test.mjs @@ -3,7 +3,9 @@ import test from 'node:test'; import { GAMEPLAY_RULES_VERSION, REPLAY_SCHEMA_VERSION } from '../dist/node/index.js'; import { verifyProductionHealth } from './production-health.mjs'; -const healthy = { ok: true, rulesVersion: GAMEPLAY_RULES_VERSION, schemaVersion: REPLAY_SCHEMA_VERSION }; +const healthy = { ok: true, rulesVersion: GAMEPLAY_RULES_VERSION, schemaVersion: REPLAY_SCHEMA_VERSION, supportedRules: [GAMEPLAY_RULES_VERSION] }; +// An Android build on older rules that is still inside its support period. +const releasedOld = { policy: { supportDays: 90 }, builds: [{ platform: 'android', versionName: '1.0', versionCode: 1, rulesVersion: '0.9.0', schemaVersion: 1, distributed: '2026-11-01', supersededOn: null }] }; test('accepts matching production versions with a read-only unauthenticated request', async () => { await verifyProductionHealth(async (url, options) => { @@ -30,6 +32,19 @@ test('retries propagation failures, then accepts a compatible Worker', async () assert.deepEqual(waits, [5_000, 5_000]); }); +test('accepts a Worker that still supports an older version a distributed app needs', async () => { + await verifyProductionHealth(async () => Response.json({ ...healthy, supportedRules: ['0.9.0', GAMEPLAY_RULES_VERSION] }), async () => {}, { released: releasedOld }); +}); + +test('blocks publication when the Worker dropped a version a distributed app still needs', async () => { + let calls = 0; + await assert.rejects(verifyProductionHealth(async () => { + calls++; + return Response.json(healthy); + }, async () => {}, { released: releasedOld }), /verification failed; do not publish/); + assert.equal(calls, 5); +}); + for (const [name, response] of [ ['HTTP failure', () => new Response('unavailable', { status: 503 })], ['invalid JSON', () => new Response('not JSON')], @@ -38,7 +53,9 @@ for (const [name, response] of [ ['truthy ok', () => Response.json({ ...healthy, ok: 'true' })], ['wrong rules', () => Response.json({ ...healthy, rulesVersion: 'previous-version' })], ['wrong schema', () => Response.json({ ...healthy, schemaVersion: REPLAY_SCHEMA_VERSION + 1 })], - ['missing schema', () => Response.json({ ok: true, rulesVersion: GAMEPLAY_RULES_VERSION })], + ['missing schema', () => Response.json({ ok: true, rulesVersion: GAMEPLAY_RULES_VERSION, supportedRules: [GAMEPLAY_RULES_VERSION] })], + ['missing supportedRules (a Worker from before multi-version support)', () => Response.json({ ok: true, rulesVersion: GAMEPLAY_RULES_VERSION, schemaVersion: REPLAY_SCHEMA_VERSION })], + ['supportedRules without the current rules', () => Response.json({ ...healthy, supportedRules: ['0.9.0'] })], ['network timeout', () => { throw new Error('request timed out'); }], ]) { test(`blocks publication after five attempts: ${name}`, async () => { diff --git a/phaser-asteroids/scripts/rules-guard.mjs b/phaser-asteroids/scripts/rules-guard.mjs new file mode 100644 index 0000000..b2ea72e --- /dev/null +++ b/phaser-asteroids/scripts/rules-guard.mjs @@ -0,0 +1,63 @@ +// CI guard for the frozen replay engines (server/rules/): compares this commit with a base commit and refuses changes that would make the +// server verify an already released rules version differently, or stop verifying one a distributed Android build still needs. +// +// node scripts/rules-guard.mjs e.g. origin/main (pull request) or the previous main commit (push) +// npm run rules:guard -- origin/main +// +// The unit tests (server/tests/rulesCompat.test.ts) already check the files against their pinned hashes; this guard is what stops the +// hashes being re-pinned. The rules themselves are in server/rules/policy.mjs (guardProblems). Needs the base commit in the clone +// (actions/checkout with fetch-depth: 0). + +import { spawnSync } from 'node:child_process'; +import path from 'node:path'; +import { fileURLToPath, pathToFileURL } from 'node:url'; +import { guardProblems, RULES_DIR } from '../server/rules/policy.mjs'; + +const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..'); + +function git(args, cwd = root) { + const res = spawnSync('git', args, { cwd, encoding: 'utf8' }); + if (res.status !== 0) throw new Error(`git ${args.join(' ')} failed: ${res.stderr.trim()}`); + return res.stdout; +} + +/** `git diff --name-status` lines for paths under server/rules, relative to it. Renames are reported as delete + add. */ +export function parseNameStatus(text, prefix) { + return text + .split('\n') + .filter(Boolean) + .map((line) => { + const [status, file] = line.split('\t'); + return { status: status[0], path: file.startsWith(prefix) ? file.slice(prefix.length) : file }; + }); +} + +function main() { + const base = process.argv[2]; + if (!base) throw new Error('usage: node scripts/rules-guard.mjs '); + const top = git(['rev-parse', '--show-toplevel']).trim(); + const rel = path.relative(top, RULES_DIR).split(path.sep).join('/'); + const mergeBase = git(['merge-base', base, 'HEAD']).trim(); + // Both ends are read from commits, not the working tree, so the guard judges exactly what would be merged. Paths are relative to + // the top of the repository, so git runs there. + const show = (rev, file) => { + const res = spawnSync('git', ['show', `${rev}:${rel}/${file}`], { cwd: top, encoding: 'utf8' }); + return res.status === 0 ? JSON.parse(res.stdout) : null; + }; + // Before server/rules existed there is nothing to protect. + const state = (rev) => ({ manifest: show(rev, 'versions.json') ?? { versions: {} }, released: show(rev, 'released.json') ?? { policy: { supportDays: 1 }, builds: [] } }); + const changes = parseNameStatus(git(['diff', '--name-status', '--no-renames', mergeBase, 'HEAD', '--', rel], top), `${rel}/`); + const problems = guardProblems({ changes, base: state(mergeBase), head: state('HEAD'), today: new Date() }); + console.log(`[rules:guard] ${changes.length} change(s) under ${rel} since ${mergeBase.slice(0, 12)}`); + if (problems.length) throw new Error(`frozen rules guard failed:\n - ${problems.join('\n - ')}`); + console.log('[rules:guard] OK: no released rules version was modified or dropped'); +} + +if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) { + try { + main(); + } catch (e) { + console.error(`[rules:guard] ${e instanceof Error ? e.message : e}`); + process.exit(1); + } +} diff --git a/phaser-asteroids/scripts/rules-guard.test.mjs b/phaser-asteroids/scripts/rules-guard.test.mjs new file mode 100644 index 0000000..f7f7756 --- /dev/null +++ b/phaser-asteroids/scripts/rules-guard.test.mjs @@ -0,0 +1,77 @@ +// node --test scripts/rules-guard.test.mjs +// Runs the real guard script against a scratch git repository laid out like this one, so the CI step is shown to fail on the changes +// it exists to stop. The rules themselves are unit-tested in server/tests/rulesCompat.test.ts. +import assert from 'node:assert/strict'; +import { spawnSync } from 'node:child_process'; +import fs from 'node:fs'; +import os from 'node:os'; +import path from 'node:path'; +import { test } from 'node:test'; +import { fileURLToPath } from 'node:url'; +import { parseNameStatus } from './rules-guard.mjs'; + +const app = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..'); + +function scratchRepo() { + const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'rules-guard-')); + const rules = path.join(dir, 'phaser-asteroids', 'server', 'rules'); + fs.mkdirSync(path.join(rules, '1.2.0'), { recursive: true }); + fs.mkdirSync(path.join(dir, 'phaser-asteroids', 'scripts'), { recursive: true }); + fs.copyFileSync(path.join(app, 'scripts', 'rules-guard.mjs'), path.join(dir, 'phaser-asteroids', 'scripts', 'rules-guard.mjs')); + fs.copyFileSync(path.join(app, 'server', 'rules', 'policy.mjs'), path.join(rules, 'policy.mjs')); + const write = (file, content) => { + fs.mkdirSync(path.dirname(path.join(rules, file)), { recursive: true }); + fs.writeFileSync(path.join(rules, file), typeof content === 'string' ? content : `${JSON.stringify(content, null, 2)}\n`); + }; + const manifest = (hash) => ({ versions: { '1.2.0': { schemaVersion: 1, files: { 'engine.mjs': hash } } } }); + const released = (supersededOn = null) => ({ policy: { supportDays: 90 }, builds: [{ platform: 'android', versionName: '1.0', versionCode: 1, rulesVersion: '1.2.0', schemaVersion: 1, distributed: null, supersededOn }] }); + const git = (...args) => spawnSync('git', ['-c', 'user.name=t', '-c', 'user.email=t@example.com', '-c', 'core.autocrlf=false', ...args], { cwd: dir, encoding: 'utf8' }); + const commit = (msg) => { git('add', '-A'); git('commit', '-q', '-m', msg); }; + const guard = () => spawnSync(process.execPath, ['phaser-asteroids/scripts/rules-guard.mjs', 'HEAD~1'], { cwd: dir, encoding: 'utf8' }); + git('init', '-q'); + write('1.2.0/engine.mjs', 'export const GAMEPLAY_RULES_VERSION = "1.2.0";\n'); + write('versions.json', manifest('a')); + write('released.json', released()); + commit('freeze 1.2.0'); + return { dir, write, manifest, released, commit, guard, rm: (f) => fs.rmSync(path.join(rules, f), { recursive: true }) }; +} + +test('adding a new frozen version and filling in a release date passes', () => { + const r = scratchRepo(); + r.write('1.3.0/engine.mjs', 'export const GAMEPLAY_RULES_VERSION = "1.3.0";\n'); + r.commit('freeze 1.3.0'); + const res = r.guard(); + assert.equal(res.status, 0, res.stderr); + fs.rmSync(r.dir, { recursive: true, force: true }); +}); + +test('editing a frozen engine (and re-pinning its hash) fails', () => { + const r = scratchRepo(); + r.write('1.2.0/engine.mjs', 'export const GAMEPLAY_RULES_VERSION = "1.2.0"; // tweaked\n'); + r.write('versions.json', r.manifest('b')); + r.commit('edit'); + const res = r.guard(); + assert.equal(res.status, 1); + assert.match(res.stderr, /frozen file modified/, res.stdout); + assert.match(res.stderr, /entry for released rules 1\.2\.0 changed/); + fs.rmSync(r.dir, { recursive: true, force: true }); +}); + +test('dropping a version that a distributed Android build needs fails, even with its records removed too', () => { + const r = scratchRepo(); + r.rm('1.2.0'); + r.write('versions.json', { versions: {} }); + r.write('released.json', { policy: { supportDays: 90 }, builds: [] }); + r.commit('drop'); + const res = r.guard(); + assert.equal(res.status, 1); + assert.match(res.stderr, /was removed \(records are permanent\)/); + fs.rmSync(r.dir, { recursive: true, force: true }); +}); + +test('parseNameStatus keeps only the status letter and strips the rules prefix', () => { + assert.deepEqual(parseNameStatus('A\tp/server/rules/1.3.0/engine.mjs\nM\tp/server/rules/released.json\n', 'p/server/rules/'), [ + { status: 'A', path: '1.3.0/engine.mjs' }, + { status: 'M', path: 'released.json' }, + ]); +}); diff --git a/phaser-asteroids/server/rules/released.json b/phaser-asteroids/server/rules/released.json new file mode 100644 index 0000000..bf4b4be --- /dev/null +++ b/phaser-asteroids/server/rules/released.json @@ -0,0 +1,16 @@ +{ + "policy": { + "supportDays": 90 + }, + "builds": [ + { + "platform": "android", + "versionName": "1.0", + "versionCode": 1, + "rulesVersion": "1.2.0", + "schemaVersion": 1, + "distributed": null, + "supersededOn": null + } + ] +} diff --git a/phaser-asteroids/server/tests/rulesCompat.test.ts b/phaser-asteroids/server/tests/rulesCompat.test.ts new file mode 100644 index 0000000..648006d --- /dev/null +++ b/phaser-asteroids/server/tests/rulesCompat.test.ts @@ -0,0 +1,153 @@ +import fs from 'node:fs'; +import path from 'node:path'; +import zlib from 'node:zlib'; +import { describe, expect, it, vi } from 'vitest'; +import { GAMEPLAY_RULES_VERSION, REPLAY_SCHEMA_VERSION } from '../../src/replay/constants'; +import { verifyReplay as liveVerifyReplay } from '../../src/replay/verifier'; +import { ENGINES } from '../src/engines'; +import { loadSettings } from '../src/config'; +import { digest, guardProblems, readManifest, readReleased, releasedProblems, requiredVersions, RULES_DIR, supportProblems } from '../rules/policy.mjs'; + +// The release compatibility gate. It runs with the unit tests, which CI runs before it deploys the Worker, so a change that would strand +// an installed app, edit a frozen engine, or change gameplay without a rules version bump never reaches production. See ../rules/README.md. +vi.setConfig({ testTimeout: 120_000 }); + +interface Fixture { + note: string; + options: { maxTicks: number; requireGameOver: boolean; timeLimitTicks?: number }; + expected: unknown; + replay: unknown; +} + +const manifest = readManifest() as { versions: Record }> }; +const released = readReleased(); +const versions = Object.keys(manifest.versions); + +const filesUnder = (dir: string): string[] => + fs.readdirSync(dir, { withFileTypes: true }).flatMap((e) => (e.isDirectory() ? filesUnder(path.join(dir, e.name)).map((f) => `${e.name}/${f}`) : [e.name])); + +const fixtures = (version: string): [string, Fixture][] => + Object.keys(manifest.versions[version]!.files) + .filter((f) => f.startsWith('fixtures/')) + .map((f) => [f, JSON.parse(zlib.gunzipSync(fs.readFileSync(path.join(RULES_DIR, version, f))).toString('utf8')) as Fixture]); + +describe('the registry of supported rules versions', () => { + it('engines.ts registers exactly the frozen versions in versions.json, each with its recorded schema', () => { + expect(Object.keys(ENGINES).sort()).toEqual([...versions].sort()); + for (const v of versions) { + expect(ENGINES[v]!.rulesVersion).toBe(v); + expect(ENGINES[v]!.schemaVersion).toBe(manifest.versions[v]!.schemaVersion); + expect(ENGINES[v]!.tickRate).toBe(60); + } + }); + + it(`the current rules (${GAMEPLAY_RULES_VERSION}, schema ${REPLAY_SCHEMA_VERSION}) are frozen and registered: bump + \`npm run rules:freeze\` go together`, () => { + expect(loadSettings().rulesVersion).toBe(GAMEPLAY_RULES_VERSION); + expect(ENGINES[GAMEPLAY_RULES_VERSION], `rules ${GAMEPLAY_RULES_VERSION} is not frozen: run npm run rules:freeze and register it in server/src/engines.ts`).toBeDefined(); + expect(ENGINES[GAMEPLAY_RULES_VERSION]!.schemaVersion).toBe(REPLAY_SCHEMA_VERSION); + }); + + it('released.json is well formed, and every version a distributed Android build needs is still supported', () => { + expect(releasedProblems(released)).toEqual([]); + expect(supportProblems({ supported: Object.keys(ENGINES), current: GAMEPLAY_RULES_VERSION, released, today: new Date() })).toEqual([]); + }); +}); + +describe('frozen engines are never modified', () => { + for (const v of versions) { + it(`rules ${v}: every file matches the hash pinned in versions.json, and nothing is added or missing`, () => { + const pinned = manifest.versions[v]!.files; + expect(filesUnder(path.join(RULES_DIR, v)).sort()).toEqual(Object.keys(pinned).sort()); + for (const [file, hash] of Object.entries(pinned)) expect(digest(fs.readFileSync(path.join(RULES_DIR, v, file)), file), `${v}/${file}`).toBe(hash); + }); + + it(`rules ${v}: the engine is self-contained (imports nothing, so no live source can leak into it)`, () => { + const src = fs.readFileSync(path.join(RULES_DIR, v, 'engine.mjs'), 'utf8'); + expect(src).not.toMatch(/^\s*import\s|\bimport\(|\brequire\(/m); + }); + } +}); + +describe('reference replays', () => { + for (const v of versions) { + for (const [file, fixture] of fixtures(v)) { + it(`rules ${v} ${file}: the frozen engine still computes the recorded result (${fixture.note})`, () => { + expect(ENGINES[v]!.verifyReplay(fixture.replay, fixture.options)).toEqual(fixture.expected); + }); + } + } + + // The guard against an unversioned gameplay change: today's sources must reproduce the current version's reference games exactly. + for (const [file, fixture] of fixtures(GAMEPLAY_RULES_VERSION)) { + it(`the live sources reproduce rules ${GAMEPLAY_RULES_VERSION} ${file}`, () => { + const live = liveVerifyReplay(fixture.replay, fixture.options); + expect( + live, + `The simulation now gives a different result for a ${GAMEPLAY_RULES_VERSION} reference game. If gameplay changed on purpose, bump ` + + 'GAMEPLAY_RULES_VERSION in src/replay/constants.ts and run `npm run rules:freeze` (see server/rules/README.md). If it did not, it is a ' + + 'determinism bug: players on installed apps would be rejected.', + ).toEqual(fixture.expected); + }); + } + + it('the reference set covers both legitimate endings and two rejections', () => { + const results = fixtures(GAMEPLAY_RULES_VERSION).map(([, f]) => f.expected as { valid: boolean; endReason?: string; discrepancy?: string }); + expect(results.some((r) => r.valid && r.endReason === 'game_over')).toBe(true); + expect(results.some((r) => r.valid && r.endReason === 'time_limit')).toBe(true); + expect(results.some((r) => !r.valid && r.discrepancy)).toBe(true); + expect(results.some((r) => !r.valid && !r.discrepancy)).toBe(true); + }); +}); + +describe('compatibility policy', () => { + const build = (b: Record) => ({ platform: 'android', versionName: '1.0', versionCode: 1, rulesVersion: '1.2.0', schemaVersion: 1, distributed: '2026-11-10', supersededOn: null, ...b }); + const rel = (...builds: Record[]) => ({ policy: { supportDays: 90 }, builds: builds.map(build) }); + const day = (d: string) => new Date(`${d}T12:00:00Z`); + + it('a version stays required until supportDays after its last build is superseded', () => { + const r = rel({ versionCode: 1, rulesVersion: '1.2.0', supersededOn: '2027-01-01' }, { versionCode: 2, rulesVersion: '1.3.0' }); + expect(requiredVersions(r, day('2027-03-31'))).toEqual(['1.2.0', '1.3.0']); + expect(requiredVersions(r, day('2027-04-01'))).toEqual(['1.3.0']); + // Another build on the same rules keeps them required. + const r2 = rel({ versionCode: 1, rulesVersion: '1.2.0', supersededOn: '2027-01-01' }, { versionCode: 2, rulesVersion: '1.2.0' }); + expect(requiredVersions(r2, day('2028-01-01'))).toEqual(['1.2.0']); + }); + + it('dropping a required version, or the current one, is reported', () => { + const r = rel({ versionCode: 1, rulesVersion: '1.2.0' }); + expect(supportProblems({ supported: ['1.3.0'], current: '1.3.0', released: r, today: day('2027-01-01') })).toEqual([expect.stringContaining('rules 1.2.0 is still needed')]); + expect(supportProblems({ supported: ['1.2.0'], current: '1.3.0', released: r, today: day('2027-01-01') })).toEqual([expect.stringContaining('current rules version 1.3.0')]); + expect(releasedProblems({ policy: { supportDays: 0 }, builds: [build({ versionCode: 1 }), build({ versionCode: 1, rulesVersion: 'x' })] })).toHaveLength(3); + }); + + const frozen = { '1.2.0': { schemaVersion: 1, files: { 'engine.mjs': 'a' } } }; + const state = (versionsIn: object, releasedIn: object) => ({ manifest: { versions: versionsIn }, released: releasedIn }); + const today = day('2027-06-01'); + + it('the CI guard: frozen files may be added but never modified, and deleted only once retired', () => { + const r = rel({ versionCode: 1, rulesVersion: '1.2.0' }); + const same = state(frozen, r); + expect(guardProblems({ changes: [{ status: 'A', path: '1.3.0/engine.mjs' }, { status: 'M', path: 'policy.mjs' }, { status: 'M', path: 'released.json' }], base: same, head: same, today })).toEqual([]); + expect(guardProblems({ changes: [{ status: 'M', path: '1.2.0/engine.mjs' }], base: same, head: same, today })).toEqual([expect.stringContaining('frozen file modified')]); + expect(guardProblems({ changes: [{ status: 'M', path: '1.2.0\\fixtures\\x.json.gz' }], base: same, head: same, today })).toHaveLength(1); + // deleting a version that a distributed build still needs, even with the manifest entry removed too + expect(guardProblems({ changes: [{ status: 'D', path: '1.2.0/engine.mjs' }], base: same, head: state({}, r), today }).length).toBeGreaterThan(0); + // retiring after the support period: allowed + const retired = rel({ versionCode: 1, rulesVersion: '1.2.0', supersededOn: '2027-01-01' }, { versionCode: 2, rulesVersion: '1.3.0' }); + expect(guardProblems({ changes: [{ status: 'D', path: '1.2.0/engine.mjs' }], base: state(frozen, retired), head: state({}, retired), today })).toEqual([]); + // a manifest entry rewritten in place (e.g. to cover an edited engine) + expect(guardProblems({ changes: [], base: same, head: state({ '1.2.0': { schemaVersion: 1, files: { 'engine.mjs': 'b' } } }, r), today })).toEqual([expect.stringContaining('changed')]); + }); + + it('the CI guard: release records are permanent and only gain their dates, without backdating', () => { + const base = state(frozen, rel({ versionCode: 1, distributed: null })); + const head = (b: Record[]) => state(frozen, rel(...b)); + expect(guardProblems({ changes: [], base, head: head([{ versionCode: 1, distributed: '2027-05-30' }, { versionCode: 2, rulesVersion: '1.3.0' }]), today })).toEqual([]); + expect(guardProblems({ changes: [], base, head: head([{ versionCode: 2 }]), today })).toEqual([expect.stringContaining('was removed')]); + expect(guardProblems({ changes: [], base, head: head([{ versionCode: 1, distributed: null, rulesVersion: '1.3.0' }]), today })).toEqual([expect.stringContaining('rulesVersion changed')]); + expect(guardProblems({ changes: [], base, head: head([{ versionCode: 1, distributed: null, supersededOn: '2027-06-01' }]), today })).toEqual([]); + expect(guardProblems({ changes: [], base, head: head([{ versionCode: 1, distributed: null, supersededOn: '2026-01-01' }]), today })).toEqual([expect.stringContaining('no backdating')]); + const set = state(frozen, rel({ versionCode: 1, supersededOn: '2027-06-01' })); + expect(guardProblems({ changes: [], base: set, head: state(frozen, rel({ versionCode: 1, supersededOn: '2027-06-02' })), today })).toEqual([expect.stringContaining('supersededOn changed')]); + }); +}); From cccce49494d4006c23204fd2b5997600ccd57efe Mon Sep 17 00:00:00 2001 From: djblackett <49618491+djblackett@users.noreply.github.com> Date: Mon, 2 Nov 2026 11:38:01 -0400 Subject: [PATCH 09/10] docs: multi-version ranked replay, deployment order and retirement policy server/rules/README.md describes the frozen engines, how a version is chosen at issue and verify, what each check protects, the rules-bump procedure (backend serves both versions -> web and the new app ship -> the old version retires after its support period) and the initial retirement policy: Android rules stay supported at least 90 days after their last build is superseded (CI-enforced) and until they are under about 2% of issued runs; web-only versions at least 7 days. leaderboard-backend.md, deployment.md and android.md drop the one-version-at-a-time description (android.md keeps it as history), and the audit gets a status note listing what has been done since. Co-Authored-By: Claude Opus 5.5 --- docs/leaderboard-backend.md | 15 ++-- .../docs/android-release-audit.md | 6 ++ phaser-asteroids/docs/android.md | 20 ++++- phaser-asteroids/docs/deployment.md | 14 ++-- phaser-asteroids/server/rules/README.md | 78 +++++++++++++++++++ 5 files changed, 120 insertions(+), 13 deletions(-) create mode 100644 phaser-asteroids/server/rules/README.md diff --git a/docs/leaderboard-backend.md b/docs/leaderboard-backend.md index e283a1b..5b50abc 100644 --- a/docs/leaderboard-backend.md +++ b/docs/leaderboard-backend.md @@ -196,7 +196,11 @@ Indexes: partial board index `(rules_version, score DESC, completed_at ASC, id A All JSON, all under `/api/v1`. Errors: `{"error":{"code":"…","message":"…", …}}`. -### `POST /runs` → 201 +### `POST /runs?rules=1.2.0&schema=1` → 201 + +The query names the rules and replay schema the client plays (clients since 2026-11 always send it; it keeps the request CORS-simple). +A version the Worker supports is issued as asked; anything else, or no query, gets the current version. Anything in the body is ignored. +See [`phaser-asteroids/server/rules/README.md`](../phaser-asteroids/server/rules/README.md). ```json { @@ -258,7 +262,8 @@ Query: `limit` (1–100, default 10), `offset` (0–1000). Anything else → 400 } ``` ### `GET /scores/:id` → 200 `{ "score": {…}, "ranks": { "allTime": 3, "weekly": 1 } }` (404 if unknown **or hidden**) -### `GET /health` → `{ "ok": true, "rulesVersion": "1.0.0", "schemaVersion": 1, "maxTicks": 72000, "timeLimitSeconds": 1200, "time": "…" }` +### `GET /health` → `{ "ok": true, "rulesVersion": "1.2.0", "schemaVersion": 1, "supportedRules": ["1.2.0"], "maxTicks": 72000, "timeLimitSeconds": 1200, "time": "…" }` +`rulesVersion` / `schemaVersion` are what a request without `?rules=` is issued; `supportedRules` lists every version this deployment verifies. ### `POST /admin/scores/:id/visibility` — body `{"visible": false, "reason": "offensive"}`, `Authorization: Bearer `. The route does not exist (404) unless `ADMIN_TOKEN` (≥ 16 chars) is configured; never sends CORS headers; failed attempts are rate limited. Public entries expose only `id, rank, nickname, score, rulesVersion, completedAt, durationSeconds, endReason` (`game_over` or `time_limit`). @@ -277,10 +282,10 @@ Tested: 12 simultaneous identical submissions and 5 simultaneous *different* one ## 8. Scoring-version compatibility policy -* `GAMEPLAY_RULES_VERSION` (`src/replay/constants.ts`) must change whenever physics, spawning, collision or scoring changes. The server only verifies the version it was built with, and the replay header and the run must both match it. +* `GAMEPLAY_RULES_VERSION` (`src/replay/constants.ts`) must change whenever physics, spawning, collision or scoring changes. The server verifies several versions side by side: each one is a frozen build of the engine in `phaser-asteroids/server/rules//`, registered in `server/src/engines.ts`, and chosen by the version stored with the run when it was issued. The replay header must match that version. The unit tests fail if gameplay changes without a bump (reference replays), and CI refuses to drop a version a distributed Android build still plays. Bump procedure, deployment order and retirement policy: [`phaser-asteroids/server/rules/README.md`](../phaser-asteroids/server/rules/README.md). * Public display support is defined separately in `src/ranked/scoringEras.ts`: `1.0.0` = **V1**, `1.1.0` = **V2**. These are deliberate scoring eras, not software release numbers. Compatible technical versions can be explicitly added to an existing era; introduce a new era only for substantial scoring/difficulty changes. Unknown versions receive no invented label and are excluded from public boards. * A client built for different rules refuses to start ranked play (`update_required`) when the challenge's rules version differs from its own. -* Deploy the new game and the new Worker together. Runs issued before a server upgrade can no longer be reproduced and are rejected with `rules_mismatch` (a player mid-game at deploy time loses that one run). +* A rules bump deploys a Worker that verifies the old and the new version, so runs issued before the deploy still verify. Only retiring a version (after its support period) makes its remaining runs fail with `rules_mismatch`. ## 9. Weekly / all-time definitions @@ -301,7 +306,7 @@ The extra API field is additive; replay schema and gameplay rules remain unchang ## 10. Abuse prevention -One-use run ids; CSPRNG tokens and seeds; expiry; atomic state transitions; per-client and global rate limits stored in the database (exact, shared by all instances); credentials and cheap checks before the body is read; strict size/encoding limits; validation before simulation; minimum-elapsed-time rule; rejection of non-approved configuration; an `Origin` allow-list for browser POSTs (hygiene, not authentication); nickname charset with no markup characters; admin routes disabled by default; no frontend API key (none would be secret). Rate limits (defaults, env-tunable): 30 run starts and 30 submissions per client-hash per hour; 3,000 starts and 1,200 submissions per hour globally. Client identity is a salted hash of `CF-Connecting-IP`, used only as one coarse layer; shared networks share a bucket, so limits are generous and nothing is *granted* based on an IP. Turnstile was not added: it adds friction and the main risk (bots playing well) is not something it fixes. +One-use run ids; CSPRNG tokens and seeds; expiry; atomic state transitions; per-client and global rate limits stored in the database (exact, shared by all instances); credentials and cheap checks before the body is read; strict size/encoding limits; validation before simulation; minimum-elapsed-time rule; rejection of non-approved configuration; an `Origin` allow-list for browser POSTs (hygiene, not authentication); nickname charset with no markup characters; admin routes disabled by default; no frontend API key (none would be secret). Rate limits (defaults, env-tunable): 30 run starts and 30 submissions per client-hash per hour; 3,000 starts and 1,200 submissions per hour globally. The global submission budget is spent only after the run token has been checked (and the run is still open), so unauthenticated junk, which the per-client bucket still limits, cannot use it up for everyone. Client identity is a salted hash of `CF-Connecting-IP`, used only as one coarse layer; shared networks share a bucket, so limits are generous and nothing is *granted* based on an IP. Turnstile was not added: it adds friction and the main risk (bots playing well) is not something it fixes. Minimal logging (no IPs, nicknames or tokens): `run_rejected`, `verifier_threw`, `submit_failed`, `unhandled`, `prune`. diff --git a/phaser-asteroids/docs/android-release-audit.md b/phaser-asteroids/docs/android-release-audit.md index 1d37e2c..cbdd41b 100644 --- a/phaser-asteroids/docs/android-release-audit.md +++ b/phaser-asteroids/docs/android-release-audit.md @@ -8,6 +8,12 @@ git-ignored). No production request was made. No secret was read. The probes wer repository and are not committed; their output is quoted below. They were: router + service tests against in-memory SQLite (the "audit probe"), a Playwright phone probe against a local static server (the "phone probe"), and patched *copies* of two suites. +> **Status (follow-up, 2026-11-02, also on `dev`).** Done since this audit: #1 and #2 (multi-version ranked replay with frozen +> engines, reference replays, CI guards; see [`server/rules/README.md`](../server/rules/README.md)), #3 (the global submission budget +> is now spent only after the token check), #8 (stale suite expectations updated), #9 (POWER-UPS layout fixed) and the Point-to-Fly +> flake in §6 (root-caused to a UFO hitting the ship during the check; the test's world reset now removes UFOs). Still open, by +> decision: #4 (IPv6 /64 buckets), #5 (persisting unsent runs), #6 and #7. The body below is the audit as written. + --- ## 1. Executive summary diff --git a/phaser-asteroids/docs/android.md b/phaser-asteroids/docs/android.md index 96424d4..49f7cca 100644 --- a/phaser-asteroids/docs/android.md +++ b/phaser-asteroids/docs/android.md @@ -56,10 +56,24 @@ Tests: [`tests/nativeApp.test.ts`](../tests/nativeApp.test.ts) (Back routing, li `tests/ranked.test.ts`, `tests/fullscreen.test.ts` and `tests/mobileEntry.test.ts`, and [`scripts/build-android.test.mjs`](../scripts/build-android.test.mjs) (`npm run test:android-build`). -## Risk: Worker rule changes break installed apps +## Gameplay updates and installed apps -The Worker supports **one** gameplay rules version at a time. It is `GAMEPLAY_RULES_VERSION`, compiled in from `src/replay` at -deploy time. A ranked client refuses a challenge for any other version (`update_required`), and the Worker rejects a run issued +Resolved on 2026-11-02 (see [android-release-audit.md](android-release-audit.md) and [server/rules/README.md](../server/rules/README.md)): +the app names its rules version when it asks for a ranked run, and the Worker verifies every version in its frozen-engine registry, +chosen by the version recorded at issue. A rules bump therefore deploys a Worker that serves the old and the new version; installed +apps keep playing ranked until their version is retired, at least 90 days after a successor build reached all users. CI refuses +to drop a version a build in `server/rules/released.json` still plays, and `npm run build:android` refuses to package a build whose +`versionCode` is not recorded there with its rules. + +**Releasing a build:** raise `versionCode` / `versionName` in `android/app/build.gradle` whenever the rules differ from the last +recorded build, add the build to `server/rules/released.json`, and build only from a commit whose Worker is deployed. + +The rest of this section is the analysis from before the fix, kept for the record. + +### Before 2026-11-02: one rules version at a time + +The Worker supported **one** gameplay rules version at a time. It was `GAMEPLAY_RULES_VERSION`, compiled in from `src/replay` at +deploy time. A ranked client refuses a challenge for any other version (`update_required`), and the Worker rejected a run issued under older rules (`rules_mismatch`). The Worker deploys automatically on every qualifying merge to `main`. On the web this costs nothing: the page reloads into the new build. An installed Android app keeps its bundled game until the diff --git a/phaser-asteroids/docs/deployment.md b/phaser-asteroids/docs/deployment.md index a797bbb..88a6cad 100644 --- a/phaser-asteroids/docs/deployment.md +++ b/phaser-asteroids/docs/deployment.md @@ -5,9 +5,10 @@ for ranked play. GitHub Actions validates both, deploys and checks the Worker, t **URL:** -The Android app is built separately (`npm run build:android`) and talks to the same Worker. **A Worker deploy that changes -`GAMEPLAY_RULES_VERSION` turns off ranked play in every installed Android app until players update it.** See -[android.md](android.md#risk-worker-rule-changes-break-installed-apps). +The Android app is built separately (`npm run build:android`) and talks to the same Worker. The Worker verifies every gameplay +rules version a distributed app still plays (frozen engines in `server/rules/`), so a gameplay update does not stop ranked play in +installed apps. The bump procedure, the deployment order and the retirement policy are in +[server/rules/README.md](../server/rules/README.md). The Pages site is exactly the contents of `phaser-asteroids/dist/`. The original Python/Pygame game stays in the repository root as source code but is no longer built or published (its pygbag web build was retired when Phaser became the primary @@ -26,7 +27,9 @@ game; `BUILD_WEB.md` and `pygbag` still work locally if you want it). Changes to the Python game or to root docs do not deploy. **These block deployment** (job `phaser`, Node 22, Ubuntu): `npm ci` → `npm run typecheck` → `npm test` (Vitest unit tests) → -`npm run build` → `node scripts/pages-check.mjs`. The last step loads the production build in real headless Chrome, served +`npm run build` → `node scripts/pages-check.mjs`. `npm test` includes the release compatibility gate +(`server/tests/rulesCompat.test.ts`), and a separate step runs `scripts/rules-guard.mjs` against the merge base (frozen engines +and release records were not rewritten; the checkout fetches full history for it). The last step loads the production build in real headless Chrome, served as the site root at `/asteroids-bootdev/` (the Pages URL path) **and** at `/` (a custom domain), and checks: no console or page errors, no HTTP errors, all 10 start-up audio files load from under that path, the two extra soundtracks are *not* requested at start-up but load from under it when picked (and a saved choice plays after a reload), nothing is requested outside it, the title screen renders in WebGL, a one-player game starts with the music playing, `?keydebug` loads, and the Gamepad API is available. @@ -42,7 +45,8 @@ runs and old reruns fail without deploying. It runs `npx wrangler deploy --env p Next, `scripts/production-health.mjs` makes only a read-only GET to . It requires HTTP success, `ok: true`, and exact `rulesVersion` / `schemaVersion` matches with `GAMEPLAY_RULES_VERSION` / `REPLAY_SCHEMA_VERSION` exported by the -build's `dist/node/index.js`. These come from shared `src/replay/constants.ts`; there is no separate CI version. +build's `dist/node/index.js`, and a `supportedRules` list that includes them and every rules version a distributed Android +build still needs (`server/rules/released.json`). These come from shared `src/replay/constants.ts`; there is no separate CI version. Exact schema equality follows the existing replay compatibility policy. It attempts at most five requests, each with a 10-second timeout, waiting five seconds between failures. Logs show expected versions and failure reasons. It never creates challenges or scores. This checks Worker compatibility, not D1 connectivity; an optional read-only diff --git a/phaser-asteroids/server/rules/README.md b/phaser-asteroids/server/rules/README.md new file mode 100644 index 0000000..9977614 --- /dev/null +++ b/phaser-asteroids/server/rules/README.md @@ -0,0 +1,78 @@ +# Frozen replay engines (supported gameplay rules versions) + +The leaderboard Worker verifies a ranked run by re-simulating it. An installed Android app keeps the game it was built with until the +player updates it, so the Worker has to verify **several** rules versions at once: the current one and every older one a distributed +app still plays. This folder holds one frozen engine per supported version. + +``` +server/rules/ + 1.2.0/engine.mjs the simulation + verifier for rules 1.2.0: one self-contained ES module, built from src/replay. Never edited. + 1.2.0/engine.d.mts its types (the four exports the server uses) + 1.2.0/fixtures/*.json.gz reference replays with the results this engine computes for them + versions.json every frozen version, its replay schema and the sha256 of each of its files + released.json every Android build handed out: the rules it plays, and when a successor replaced it + policy.mjs the compatibility rules as functions (used by the tests, the CI guard, the health gate, build:android) +``` + +[`../src/engines.ts`](../src/engines.ts) is the **allowlist**: one import and one `frozen(...)` line per version. Nothing outside it is +ever used to verify a run; the live sources in `src/` only produce the next frozen engine. + +## How a version is chosen + +| Step | What decides | Code | +|---|---|---| +| Issue (`POST /api/v1/runs?rules=1.2.0&schema=1`) | The client names the rules and schema it plays. A registered version (with that schema) is issued; anything else, or no query at all (web pages from before this), gets the current version, which is what every client got before. The client then refuses a challenge for rules it does not play ("update the app"). | `issueEngine` in `engines.ts`, `createRun` in `runs.ts` | +| Record | `runs.rules_version` stores the issued version. Each engine reads exactly one schema, so the version also fixes the schema. No migration was needed. | `runs.ts` | +| Verify (`POST /runs/:id/submit`) | The engine for the **stored** `rules_version`. Nothing in the submission can choose it: a replay whose header names other rules is rejected (`rules_mismatch`) before any engine runs. A version no longer registered is also `rules_mismatch`. | `verifyRankedReplay` in `verify.ts` | +| Health (`GET /api/v1/health`) | `rulesVersion` / `schemaVersion`: the current (default) version, as before. `supportedRules`: every registered version. | `router.ts` | + +Run tokens, idempotent retries, the claim/finalize race handling, the elapsed-time rule, expiry and limits are unchanged: they never +depended on the version. A run issued under a version stays verifiable for its whole 60-minute window as long as that version is +registered, so a gameplay update deployed mid-run does not cost the player that run. + +## What protects it + +| Check | Where | Stops | +|---|---|---| +| Registry = `versions.json`; the current `GAMEPLAY_RULES_VERSION` is registered | `server/tests/rulesCompat.test.ts` (unit tests, before every deploy) | A rules bump without a frozen engine | +| Every file under `/` matches its pinned hash; nothing added or missing; the engine imports nothing | same | An accidental edit of a frozen engine | +| Each version's reference replays still give the recorded results through its frozen engine, and the current version's also through the **live sources** | same | A gameplay change made without a rules bump (it fails here, and the server lifecycle tests fail too, so "update the expected score" no longer works) | +| Every version a distributed Android build still needs is registered | same, and `scripts/production-health.mjs` against the deployed Worker's `supportedRules` | Dropping a version too early | +| Frozen files are never modified and only deleted once retired; `versions.json` entries never change; `released.json` records are permanent (their dates are filled in once, `supersededOn` not backdated) | `scripts/rules-guard.mjs` in CI, against the merge base | Re-pinning a hash, or deleting the records that make a version required | +| The app's rules are frozen and its `versionCode` is recorded with those rules | `npm run build:android` (`scripts/build-android.mjs`) | Shipping an app the CI gate does not know about | + +## Changing gameplay (a rules bump) + +Visual, audio and menu changes need no bump. Anything that changes the simulation's outcome (physics, spawning, collisions, scoring, +drops) does; `rulesCompat.test.ts` tells you when. + +1. Change gameplay. Bump `GAMEPLAY_RULES_VERSION` in `src/replay/constants.ts` (and `REPLAY_SCHEMA_VERSION` if the replay format changes). +2. `npm run rules:freeze`. It builds the engine from the current sources into `server/rules//`, records reference replays with it and + adds the `versions.json` entry. Register it in `server/src/engines.ts` (the script prints the two lines). **Keep the old version + registered.** Until the change is merged you can re-freeze with `npm run rules:freeze -- --replace`; once on `main` it is final. +3. Decide the scoring era in `src/ranked/scoringEras.ts` (same era: old-app and new-app players share the weekly board; new era: old + scores only on all-time). That is a product decision, not a compatibility one. +4. `npm test`, then merge. CI deploys a Worker that verifies **both** versions, checks `supportedRules` covers every distributed app, + then publishes the web build (web players move to the new rules at once). +5. Android: raise `versionCode` / `versionName` in `android/app/build.gradle`, add the build to `released.json` + (`"distributed": null, "supersededOn": null`), `npm run build:android`, upload, staged rollout. Build the APK only from a commit whose + Worker is already deployed (`node scripts/production-health.mjs` must pass): an app whose rules the Worker does not know yet would be + told to "update". +6. When the new build reaches 100 % of the rollout, set `distributed` on it and `supersededOn` (that day) on every older build. That + starts the older rules' support period. + +## Retirement policy (initial) + +- **Android rules versions:** supported for at least **90 days** (`policy.supportDays`) after the last build that plays them is + superseded. CI enforces this minimum. Before removing a version, also check it is barely used: + `SELECT rules_version, COUNT(*) FROM runs WHERE created_at > GROUP BY 1` should show it at under about 2 % of issued + runs; if not, wait another 30 days and look again. Players still on it then see "update the app" and keep Practice. +- **Web-only versions** (never in an Android build): they only serve web tabs opened before a deploy and runs started under them (60 min). + Keep them at least 7 days, then retire them with the next clean-up. CI does not track them. +- **Retiring:** one change that removes the `frozen(...)` line and import from `engines.ts`, deletes `server/rules//` and its + `versions.json` entry. The guard allows that only when no `released.json` build still requires the version. Runs of that version issued + in the hour before the deploy are then rejected (`rules_mismatch`); that is the accepted cost at the end of the support period. +- Each engine is about 89 KB (26 KB gzipped) in the Worker bundle; even a dozen versions are far below the Workers size limit. CPU per + submission does not grow, since one engine runs. + +Not done on purpose: no soft "update available" notice, no per-version kill switch, no staging Worker. Add them when real usage asks. From c1871a92c6f2a99bbac6f8dc8885691804826737 Mon Sep 17 00:00:00 2001 From: djblackett <49618491+djblackett@users.noreply.github.com> Date: Tue, 3 Nov 2026 03:11:46 -0400 Subject: [PATCH 10/10] feat(android): enhance safe area handling and viewport fit for better layout --- .../android/.idea/deviceManager.xml | 13 ++++ phaser-asteroids/capacitor.config.ts | 3 + phaser-asteroids/docs/android.md | 4 +- phaser-asteroids/index.html | 11 ++- phaser-asteroids/scripts/touch.mjs | 76 +++++++++++++++++++ phaser-asteroids/tests/androidRelease.test.ts | 5 ++ 6 files changed, 108 insertions(+), 4 deletions(-) create mode 100644 phaser-asteroids/android/.idea/deviceManager.xml diff --git a/phaser-asteroids/android/.idea/deviceManager.xml b/phaser-asteroids/android/.idea/deviceManager.xml new file mode 100644 index 0000000..91f9558 --- /dev/null +++ b/phaser-asteroids/android/.idea/deviceManager.xml @@ -0,0 +1,13 @@ + + + + + + \ No newline at end of file diff --git a/phaser-asteroids/capacitor.config.ts b/phaser-asteroids/capacitor.config.ts index 29c9132..c155580 100644 --- a/phaser-asteroids/capacitor.config.ts +++ b/phaser-asteroids/capacitor.config.ts @@ -23,6 +23,9 @@ const config: CapacitorConfig = { hidden: true, style: 'DARK', insetsHandling: 'css', + // index.html's viewport has viewport-fit=cover. Without the hint the plugin assumes it does not until the page has rendered, and + // until then pads the WebView natively by the insets: an off-centre, smaller game at start, then one resize. + initialViewportFitValueHint: 'cover', }, }, }; diff --git a/phaser-asteroids/docs/android.md b/phaser-asteroids/docs/android.md index 49f7cca..fbc89e0 100644 --- a/phaser-asteroids/docs/android.md +++ b/phaser-asteroids/docs/android.md @@ -45,7 +45,7 @@ and the launcher icon and splash artwork. | Android Back | [`src/platform/nativeBack.ts`](../src/platform/nativeBack.ts), [`nativeApp.ts`](../src/platform/nativeApp.ts) | `@capacitor/app`'s `backButton` event goes to the handler the current scene registered, which uses the same logic as Escape. **Title menu:** `MenuController.back()` closes the open page; on the root page the app is minimized. **A run:** `GameScene.goBack()` pauses, closes a pause page, resumes, or leaves a finished run. Back never leaves the app from a run in progress, and never throws away an unsubmitted ranked score. | | Pause / resume | `nativeApp.ts` | The app's `pause` / `resume` events are replayed as window `blur` / `focus`, which the existing listeners already handle. The run auto-pauses, music falls silent, held keys and touches are released, controllers go neutral, and vibration stops. WebView usually fires these itself; the native events are a backup. On resume the system bars are hidden again. | | Fullscreen | `capacitor.config.ts` (`SystemBars.hidden`), [`MainActivity.java`](../android/app/src/main/java/ca/davidandrea/spacearcade/MainActivity.java), [`fullscreen.ts`](../src/input/fullscreen.ts) | Capacitor 8's built-in SystemBars plugin hides the status and navigation bars. One native line sets "transient bars by swipe", which SystemBars has no option for: an edge swipe shows the bars over the game for a moment instead of bringing them back for good. The in-game FULLSCREEN button is hidden in the app, because Capacitor's WebView immediately ends Fullscreen API requests. | -| Safe areas | [`index.html`](../index.html), [`src/ui/touch.css`](../src/ui/touch.css) | Every inset reads `var(--safe-area-inset-X, env(safe-area-inset-X, 0px))`. SystemBars writes the variables with the real insets. Browsers never set them, so `env()` applies as before. The theme's window background is black, so any inset band around a camera cutout is black, not white. | +| Safe areas | [`index.html`](../index.html), [`src/ui/touch.css`](../src/ui/touch.css) | Every inset reads `var(--safe-area-inset-X, env(safe-area-inset-X, 0px))`. SystemBars writes the variables with the real insets (`initialViewportFitValueHint: 'cover'` makes it do so from the first frame). Browsers never set them, so `env()` applies as before. The game box uses the larger of the left and right insets on both sides, so a cutout on one side never moves the playfield off the physical centre; the touch controls keep each side's own inset. The theme's window background is black, so any inset band around a camera cutout is black, not white. | | Orientation | [`AndroidManifest.xml`](../android/app/src/main/AndroidManifest.xml) | `screenOrientation="sensorLandscape"`. Android 16 ignores orientation locks on large screens (600 dp wide or more), so the game's own rotate prompt and auto-pause remain the fallback. | | Vibration | `AndroidManifest.xml` | `android.permission.VIBRATE` (no prompt). Without it WebView silently ignores `navigator.vibrate`. | | Audio | (unchanged) | Capacitor allows media without a user gesture. Music and effects use the existing Phaser and lifecycle code. | @@ -122,7 +122,7 @@ Use a phone, plus a tablet or foldable for orientation. Use `chrome://inspect` o | 2 | Swipe from a screen edge mid-run | The bars appear over the game and hide again by themselves; the playfield does not resize. With gesture navigation, check how many swipes a Back gesture takes. | | 3 | Back: playing → pause page → pause root → game over → title sub-page → title root | Pause, close page, resume, title, close page, app goes to the background. Back during a ranked run's result page never discards the score. | | 4 | Home, recent apps, a phone call, the screen turned off mid-run | The game is paused on return, music is silent while away, no stuck controls, bars still hidden. | -| 5 | Notch or punch-hole camera, in both landscape directions | Touch controls and HUD clear the cutout; the band is black. | +| 5 | Notch or punch-hole camera, in both landscape directions | Touch controls and HUD clear the cutout; the band is black. The playfield stays in the same place, centred on the screen, when the phone is turned 180°. | | 6 | Portrait on a large screen (orientation lock ignored) | Rotate prompt, run paused. | | 7 | HAPTICS ON → TEST VIBRATION, then boost / laser / damage in a run | Felt. Also try with Samsung Silent mode. | | 8 | Ranked end to end (after the Worker with the new `ALLOWED_ORIGINS` is deployed) | Challenge issued, run verified, rank shown. Turn on airplane mode during upload: retry works with the same submission. | diff --git a/phaser-asteroids/index.html b/phaser-asteroids/index.html index b6d88d0..eb86bf6 100644 --- a/phaser-asteroids/index.html +++ b/phaser-asteroids/index.html @@ -10,8 +10,15 @@ /* The canvas stays inside the notch / rounded-corner safe area (all four insets are 0 on desktop, so nothing changes there). The touch controls (src/ui/touch.css) use the full viewport and place themselves inside the same insets. Each inset reads Capacitor's --safe-area-inset-* first: the Android app's SystemBars plugin writes it, matching what the - WebView really leaves free. Browsers never set it, so they use env() exactly as before. */ - #game { position: fixed; inset: var(--safe-area-inset-top, env(safe-area-inset-top, 0px)) var(--safe-area-inset-right, env(safe-area-inset-right, 0px)) var(--safe-area-inset-bottom, env(safe-area-inset-bottom, 0px)) var(--safe-area-inset-left, env(safe-area-inset-left, 0px)); } + WebView really leaves free. Browsers never set it, so they use env() exactly as before. + Left and right both use the larger of the two side insets: Phaser centres the canvas inside #game, so a camera cutout on one + side only (an Android phone in landscape) would otherwise push the playfield off the physical centre, and the other way when + the phone is turned round. Top and bottom keep their own insets. */ + #game { + --game-inset-x: max(var(--safe-area-inset-left, env(safe-area-inset-left, 0px)), var(--safe-area-inset-right, env(safe-area-inset-right, 0px))); + position: fixed; + inset: var(--safe-area-inset-top, env(safe-area-inset-top, 0px)) var(--game-inset-x) var(--safe-area-inset-bottom, env(safe-area-inset-bottom, 0px)) var(--game-inset-x); + } canvas { display: block; } diff --git a/phaser-asteroids/scripts/touch.mjs b/phaser-asteroids/scripts/touch.mjs index 843f4c0..7ab60de 100644 --- a/phaser-asteroids/scripts/touch.mjs +++ b/phaser-asteroids/scripts/touch.mjs @@ -1425,6 +1425,81 @@ async function runHaptics() { await d.close(); } +// --------------------------------------------------------------------------------------------------------- +// Safe areas: a camera cutout on one side (the Android app in landscape) must not move the playfield off the physical centre +// --------------------------------------------------------------------------------------------------------- + +async function runSafeArea() { + // A Samsung-shaped phone (about 20:9). The insets are written the way Capacitor's SystemBars writes them in the app: --safe-area-inset-* + // on . Turning the phone round moves the cutout to the other side, i.e. swaps left and right. + const W = 915; + const H = 412; + const s = await mobilePage(W, H); + await s.start(); + const layout = () => + s.page.evaluate(() => { + const box = (r) => ({ left: r.left, top: r.top, right: r.right, bottom: r.bottom, width: r.width, height: r.height }); + const scale = window.__game.scale; + return { canvas: box(document.querySelector('canvas').getBoundingClientRect()), game: box(document.getElementById('game').getBoundingClientRect()), bounds: { x: scale.canvasBounds.x, y: scale.canvasBounds.y, width: scale.canvasBounds.width } }; + }); + /** Sets the insets (unlisted sides removed), then waits for Phaser's parent-size poll (every 500 ms) to refit the canvas. */ + const insets = async (values) => { + await s.page.evaluate((values) => { + for (const side of ['top', 'right', 'bottom', 'left']) { + if (values[side] === undefined) document.documentElement.style.removeProperty(`--safe-area-inset-${side}`); + else document.documentElement.style.setProperty(`--safe-area-inset-${side}`, `${values[side]}px`); + } + }, values); + await sleep(100); + await s.page + .waitForFunction(() => { + const scale = window.__game.scale, c = document.querySelector('canvas').getBoundingClientRect(), g = document.getElementById('game').getBoundingClientRect(); + return Math.abs(scale.parentSize.width - g.width) < 0.5 && Math.abs(scale.parentSize.height - g.height) < 0.5 && Math.abs(scale.canvasBounds.x - c.left) < 0.5 && Math.abs(scale.canvasBounds.y - c.top) < 0.5; + }, null, { timeout: 3000 }) + .catch(() => info('Phaser had not refitted the canvas within 3 s; the checks below report what is there')); + await sleep(100); + return layout(); + }; + const near = (a, b) => Math.abs(a - b) < 0.75; + const centreX = (r) => (r.left + r.right) / 2; + const centreY = (r) => (r.top + r.bottom) / 2; + const fmt = (l) => JSON.stringify({ game: [l.game.left, l.game.right], canvas: [l.canvas.left, l.canvas.right, l.canvas.width, l.canvas.height] }); + + const plain = await insets({}); + check('safe area: with no insets the canvas is centred and fills the height (16:9 inside a 20:9 phone)', near(centreX(plain.canvas), W / 2) && near(plain.canvas.height, H), fmt(plain)); + + const left = await insets({ left: 32 }); + check('safe area: a cutout on the left keeps the canvas on the physical centre, the same size, clear of the cutout', near(centreX(left.canvas), W / 2) && near(left.canvas.width, plain.canvas.width) && left.canvas.left >= 32, fmt(left)); + check('safe area: #game is inset by the larger side inset on both sides', near(left.game.left, 32) && near(left.game.right, W - 32), fmt(left)); + check("safe area: Phaser's input bounds follow the canvas", near(left.bounds.x, left.canvas.left) && near(left.bounds.width, left.canvas.width), JSON.stringify(left.bounds)); + await s.tapItem('audio'); + check('safe area: a real tap on a menu button lands on it with the cutout inset in place', (await s.menu()).page === 'audio'); + await s.tapItem('back'); + check('safe area: ... and BACK returns to the title root', (await s.menu()).page !== 'audio'); + + const right = await insets({ right: 32 }); + check('safe area: turning the phone round (cutout on the right) leaves the canvas exactly where it was', near(right.canvas.left, left.canvas.left) && near(right.canvas.width, left.canvas.width) && near(right.canvas.top, left.canvas.top), `${fmt(left)} vs ${fmt(right)}`); + + const both = await insets({ left: 47, right: 47 }); + check('safe area: equal side insets (iOS in landscape) give the same #game box as before', near(both.game.left, 47) && near(both.game.right, W - 47) && near(centreX(both.canvas), W / 2), fmt(both)); + + const bottom = await insets({ bottom: 21 }); + check('safe area: top and bottom still use their own insets (a home indicator only shrinks the bottom)', near(bottom.game.top, 0) && near(bottom.game.bottom, H - 21) && near(centreY(bottom.canvas), (H - 21) / 2), JSON.stringify({ game: [bottom.game.top, bottom.game.bottom], canvas: [bottom.canvas.top, bottom.canvas.bottom] })); + + // The touch controls are positioned on the full viewport and keep clear of each side's own inset, exactly as before. + await insets({ right: 32 }); + await s.play(); + const fireRight = (await s.rect('.tc-fire')).right; + const pauseRight = (await s.rect('.tc-pause')).right; + check('safe area: FIRE and PAUSE keep clear of a cutout on their side by the usual 18 px', near(fireRight, W - 32 - 18) && near(pauseRight, W - 32 - 18), `fire ${fireRight}, pause ${pauseRight}`); + await insets({ left: 32 }); + const fireRightL = (await s.rect('.tc-fire')).right; + check('safe area: a cutout on the other side does not move FIRE (the controls are not made symmetric)', near(fireRightL, W - 18), `fire ${fireRightL}`); + await s.shot('safe-area-left-cutout'); + check('safe area: no console errors', s.problems.length === 0, s.problems.join(' | ')); + await s.context.close(); +} + async function waitForServer() { for (let i = 0; i < 100; i++) { const ok = await new Promise((resolve) => { @@ -2150,6 +2225,7 @@ async function run() { await runMovement(); await runFullscreen(); await runHaptics(); + await runSafeArea(); // ===================================================================================================== // 9. Overall health diff --git a/phaser-asteroids/tests/androidRelease.test.ts b/phaser-asteroids/tests/androidRelease.test.ts index 340c4bf..dd9247b 100644 --- a/phaser-asteroids/tests/androidRelease.test.ts +++ b/phaser-asteroids/tests/androidRelease.test.ts @@ -50,6 +50,11 @@ describe('Android app configuration', () => { expect(config.plugins?.SystemBars).toMatchObject({ hidden: true, insetsHandling: 'css' }); }); + it('tells SystemBars up front that the page uses viewport-fit=cover, and the page really does', () => { + expect(config.plugins?.SystemBars).toMatchObject({ initialViewportFitValueHint: 'cover' }); + expect(read('index.html')).toMatch(/ { const manifest = read('android/app/src/main/AndroidManifest.xml'); expect(manifest).toContain('android:screenOrientation="sensorLandscape"');