From 81fcb2b0f340edf8e53239980b71607049cf3319 Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Thu, 10 Sep 2026 22:06:30 +0100 Subject: [PATCH 001/100] docs/TODO/204 is planned: the ship flies by touch The docked screens and the cockpit fit a phone, and nothing on the flight screen takes a touch. The brainstorm of 2026-09-10 set the shape: drag anywhere on the view to steer, hold a button to fire, a throttle slider, a row of five command buttons along the console's top edge, tappable prompts, and a flight menu of rows. No tilt, no swipe and no pinch. Five milestones, with the wanted-speed rule and the held-key methods first, because both run under node. Co-Authored-By: Claude Fable 5.1 Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- docs/TODO/204-the-ship-flies-by-touch.md | 151 +++++++++++++++++++++++ docs/TODO/QUEUE.json | 4 +- docs/TODO/README.md | 8 +- 3 files changed, 161 insertions(+), 2 deletions(-) create mode 100644 docs/TODO/204-the-ship-flies-by-touch.md diff --git a/docs/TODO/204-the-ship-flies-by-touch.md b/docs/TODO/204-the-ship-flies-by-touch.md new file mode 100644 index 00000000..8ad9f544 --- /dev/null +++ b/docs/TODO/204-the-ship-flies-by-touch.md @@ -0,0 +1,151 @@ +# 204 — The ship flies by touch + +**Kind:** enhancement · **Severity:** medium · **Size:** large · **Depends on:** +197, 200, 202 · **Blocks:** nothing · **GitHub:** none + +## Where we are + +**Chris asked for the flight screen on a phone on 2026-09-10, after the +docked screens and the cockpit fitted one.** The brainstorm of that day is +in the conversation, and this plan is its result. He likes portrait. + +**The ship reads its controls through one small interface.** `FlightControls` +in `engine/flight-controls.ts` has five inputs: which keys are held, a stick +on two axes, and whether the trigger is down. `flightDemand` is pure. It +turns those five into a roll rate, a pitch rate, a throttle of -1, 0 or 1, +and a fire flag. The mouse-flight mode already fills the stick from pointer +movement, and `Input.decayMouse` centres it when the pointer stops. + +**Every command in flight is a key in the binding table.** A docked menu +row turns a tap into a keystroke through `Input.injectPress`, since +docs/TODO/202 with no letter on the row. `game/prompts.ts` decides which +commands matter right now and returns a command, never a letter. The HUD +paints the prompt line as text, through `paintPrompts` in `hud/hud.ts`. + +**Nothing on the flight screen takes a touch.** The console has +`pointer-events: none`. The view is the canvas. A phone player can dock, +trade and read every screen, and cannot fly. + +**Two things a phone lacks.** Pointer lock, which the mouse-flight command +asks for. A held key: `Input.down` is private, and only a keydown fills it. + +## What to do + +Five milestones. + +### M1 — the input takes a wanted speed and a held button + +`Input` gains `press(code)` and `release(code)`, so a button can hold a key +as a keyboard does. It also gains `wantedSpeed: number | null`. A throttle +slider sets it, as a fraction of the ship's top speed. `FlightControls` +carries the wanted speed. `flightDemand` gains one rule, for a wanted speed +with no speed key held. The throttle is 1 below the wanted speed, and -1 +above it. It is 0 inside a small band. The band is `THROTTLE_BAND` in +`constants/player-flight.ts`. +`test/flight.test.ts` pins the rule at both sides of the band. + +### M2 — the touch overlay: drag to steer, hold to fire, slide to set speed + +A new `engine/touch.ts` lives behind the platform seam, beside the browser +shell. It listens to pointer events on one overlay element over the view. A +finger that lands on empty view steers. Its offset from where it landed is +the stick, with `TOUCH_STICK_TRAVEL` pixels for full deflection. The stick +decays when the finger lifts, as the mouse stick does. It writes +`Input.mouseFlight`, `mouseX` and `mouseY`, and nothing in `flightDemand` +changes. A second finger may hold the FIRE button in the bottom right corner +of the view, which presses the fire key. A finger on the throttle slider at +the left edge of the view sets the wanted speed. Each finger is tracked by +its pointer id, so steering and firing happen at once. + +The overlay shows only on a coarse pointer, through the media query +docs/TODO/197 uses. The keyboard keeps working beside it. The mouse-flight +command hides where pointer lock does not exist. + +### M3 — the command row and the tappable prompts + +A row of five buttons sits along the top edge of the console: MISSILE, +E.C.M., JUMP, TORUS and DOCK. Each carries the key it presses, from the +binding table, and a tap injects it. MISSILE arms on one tap and launches on +the next, because that is what the two keys do. A button is lit when the HUD +already knows its state is on: a missile armed, the torus engaged, the +docking computer engaged. + +The prompt line becomes buttons on a coarse pointer. A prompt carries a +command. The edge looks the key up through the binding table, as it does +for the text, and the button injects it. The words stay the prompt's own. + +### M4 — the flight menu + +A MENU button opens a screen with rows, as the station menu is. The rows +are these: + +1. LOCAL CHART, GALACTIC CHART; +2. COMMANDER STATUS, MISSIONS, COMMANDER'S LOG, CONTRACTS; +3. FRONT VIEW, REAR VIEW, LEFT VIEW, RIGHT VIEW; +4. PAUSE, and ESCAPE POD. + +Each row carries the flight key it stands for, and the screen host's +row cursor and tap path serve it. The escape pod row asks first, on a +confirmation with buttons. The world keeps flying while the menu is up, as +it does under the charts. + +### M5 — fullscreen, and the manual + +The first touch on the view asks the browser for fullscreen. The manual and +the briefing gain one paragraph each on how to fly by touch. + +## Decisions already made + +- **Drag anywhere to steer, with no drawn stick** (Chris, 2026-09-10). A + drawn stick invites the thumb to one spot. The decay is the mouse stick's. +- **No tilt in this plan.** iOS asks permission through a dialog, and a + player on a bus cannot tilt. It may come later as an option. +- **No swipe and no pinch.** A swipe fights the steering drag, and a pinch + fights two thumbs. The views are rows on the flight menu. +- **The console is read, never touched.** The controls sit on the view and + along the console's top edge. +- **Portrait is the phone's layout.** Landscape gets the same overlay over + the desktop console. + +## Open questions + +None. + +## Watch out for + +- **`Input.down` is private, and `held` reads it.** `press` and `release` + add and delete a code there. A test drives them with no window. +- **The overlay must not swallow a tap on a screen.** `#screen` sits above it + in the stacking order, and the overlay hides while a screen is open, as the + console does. +- **`pointer-events: none` on the console.** The command row sits outside + the console element, so the console's rule does not reach it. +- **The prompts line is rebuilt only when the text changes.** The buttons + follow the same rule, or a tap lands on a button that was just repainted. +- **A held key and `endFrame`.** A pressed code is held, not tapped, so the + carry rule does not apply. The fire key is `held`, as it always was. +- **`keyIfBound` answers null for a virtual code.** Every flight command is + a real key, so the buttons and the menu rows find one. + +## Verification + +The gates always run: `npm run check`. `npm run generate:constants` runs +first, because M1 and M2 add constants. + +The tier: a rule that changes how a flight goes, the throttle. `npm run +flight-probe` runs once. + +Evidence: + +- `test/flight.test.ts`: the wanted speed drives the throttle up, down and + not at all inside the band, and a speed key overrides it. +- `test/input.test.ts`: `press` holds a key until `release`, and a pressed + key is never carried as a tap. +- A new `test/touch.test.ts`: the stick maths from a finger's offset, the + decay after a lift, and two fingers tracked apart. +- A new `test/flight-menu.test.ts`: the rows carry the flight keys, and a + tap on each asks for its command. +- In Chrome at 390 by 844, in flight, synthetic pointer events steer the + ship, hold the trigger and set the speed. Each button opens what it + names. +- Chris flies the preview on his phone. diff --git a/docs/TODO/QUEUE.json b/docs/TODO/QUEUE.json index 189020e1..6d913873 100644 --- a/docs/TODO/QUEUE.json +++ b/docs/TODO/QUEUE.json @@ -1,4 +1,6 @@ { "version": 1, - "items": [] + "items": [ + 204 + ] } diff --git a/docs/TODO/README.md b/docs/TODO/README.md index 58522d56..16232a43 100644 --- a/docs/TODO/README.md +++ b/docs/TODO/README.md @@ -13,7 +13,13 @@ active context: ## Execution queue -The queue is empty. +1. [204](204-the-ship-flies-by-touch.md) — the ship flies by touch. + +**204 CAME FROM CHRIS ON 2026-09-10.** The docked screens and the cockpit fit +a phone, and nothing on the flight screen takes a touch. The brainstorm set +the shape. Drag anywhere to steer, and hold to fire. A throttle slider, a +row of command buttons, tappable prompts, and a flight menu of rows. No +tilt, no swipe and no pinch. The plan is written, and the work waits on his word. **203 CAME FROM CHRIS'S PLAYTEST ON 2026-09-10.** He played three side jobs and could not tell how to finish any of them. The review found two signals From aceb0fc427f665272e65cddaeb56194dbe0b2d80 Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Fri, 11 Sep 2026 08:36:33 +0100 Subject: [PATCH 002/100] docs/TODO/204 M1: the input takes a wanted speed and a held button A touch slider needs to ask for a speed, and a touch button needs to hold a key. Input gains press and release, which hold a key as a keyboard does and never make a tap, and wantedSpeed, a fraction of the top speed or null. flightDemand gains one rule: with a wanted speed and no speed key held, the throttle opens below it, brakes above it, and coasts inside PLAYER_FLIGHT.throttleBand of it. A keyboard never sets a wanted speed, so nothing changes for it. test/flight.test.ts pins the rule on both sides of the band, and the key's override. test/input.test.ts pins that a pressed key is held and is never a tap. Co-Authored-By: Claude Fable 5.1 Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- src/constants/CATALOG.md | 2 +- src/constants/player-flight.ts | 10 ++++++++++ src/engine/flight-controls.ts | 28 ++++++++++++++++++++++++++-- src/engine/input.ts | 20 ++++++++++++++++++++ test/flight.test.ts | 29 +++++++++++++++++++++++++++-- test/input.test.ts | 13 +++++++++++++ 6 files changed, 97 insertions(+), 5 deletions(-) diff --git a/src/constants/CATALOG.md b/src/constants/CATALOG.md index 7d6d1476..ee6ebf21 100644 --- a/src/constants/CATALOG.md +++ b/src/constants/CATALOG.md @@ -281,7 +281,7 @@ search names, meanings and values with `npm run constants:find -- ""`. | pass-aim | MAX_MISS_STRETCH | 3 | The most that geometry may stretch the aim, in multiples of the intended pass. | passaim.maxMissStretch | [pass-aim.ts:31](./pass-aim.ts#L31) | | planet | WITCHPOINT_RADII | 16 | How far out of the planet you drop from witch-space, in planet radii. | planet.witchpointRadii | [planet.ts:15](./planet.ts#L15) | | planet | PLANET_CRASH_ALTITUDE | 80 | The altitude above the surface at which the ship is destroyed. | | [planet.ts:24](./planet.ts#L24) | -| player-flight | PLAYER_FLIGHT | { maxSpeed: 400, accel: 220, maxRoll: 2.5, maxPitch: 1.45, rateRamp: 4.1396, rateDecay: 13.3886, } as const | The player's flight envelope, in one place that a harness can read. | flight.player.maxSpeed
flight.player.rateRamp | [player-flight.ts:21](./player-flight.ts#L21) | +| player-flight | PLAYER_FLIGHT | { maxSpeed: 400, accel: 220, throttleBand: 12, maxRoll: 2.5, maxPitch: 1.45, rateRamp: 4.1396, rateDecay: 13.3886, } as const | The player's flight envelope, in one place that a harness can read. | flight.player.maxSpeed
flight.player.throttleBand
flight.player.rateRamp | [player-flight.ts:21](./player-flight.ts#L21) | | player-gun | LASER_RANGE | 3500 | How far the player's laser reaches, in world units. | | [player-gun.ts:14](./player-gun.ts#L14) | | player-gun | LASER_PACING | { pulse: { cooldown: 0.24, heat: 0.067 }, beam: { cooldown: 0.09, heat: 0.05 }, military: { cooldown: 0.09, heat: 0.05 }, } as const | The cadence and the heat of each fitted laser. | | [player-gun.ts:29](./player-gun.ts#L29) | | player-gun | LASER_CUTOUT | 0.98 | The laser cuts out at this temperature. | | [player-gun.ts:36](./player-gun.ts#L36) | diff --git a/src/constants/player-flight.ts b/src/constants/player-flight.ts index 7961b8fb..65ac1dc8 100644 --- a/src/constants/player-flight.ts +++ b/src/constants/player-flight.ts @@ -29,6 +29,16 @@ export const PLAYER_FLIGHT = { /** Thrust, world units per second per second, in both directions. */ accel: 220, + /** + * How far the ship's speed may sit from a wanted speed before the throttle + * moves, in world units per second (docs/TODO/204 M1). Twelve is about + * one twentieth of a second of thrust, so the ship settles on the slider's + * speed and does not hunt round it. + * + * @rule flight.player.throttleBand + */ + throttleBand: 12, + /** * The player's Cobra turns at these. They are Harmless numbers, not released * ones. They are set so that you out-turn a pirate Cobra and a Krait, match a diff --git a/src/engine/flight-controls.ts b/src/engine/flight-controls.ts index e96bbb35..f68538b6 100644 --- a/src/engine/flight-controls.ts +++ b/src/engine/flight-controls.ts @@ -29,12 +29,19 @@ export interface FlightControls { readonly mouseX: number; readonly mouseY: number; readonly mouseFire: boolean; + /** the speed a throttle slider asks for, as a fraction of top speed, or null (docs/TODO/204) */ + readonly wantedSpeed?: number | null; } -/** The ramped rates the demand continues from — the ship's own, in practice. */ +/** + * The ramped rates the demand continues from — the ship's own, in practice. + * `speed` is the ship's, for the wanted-speed rule, and a caller with no + * throttle slider may leave it out. + */ export interface TurnRates { rollRate: number; pitchRate: number; + speed?: number; } /** The active bindings the flight controls need, supplied by their owner. */ @@ -70,11 +77,28 @@ export function flightDemand( // slash only decelerates unshifted — ? opens the controls guide const decelHeld = keys.decel.some((k) => c.held(k) && (k !== 'Slash' || !c.held('ShiftLeft', 'ShiftRight'))); + const accelHeld = c.held(...keys.accel); return { rollRate: rampFlightRate(from.rollRate, rollIn * PLAYER_FLIGHT.maxRoll, rollIn !== 0, dt), pitchRate: rampFlightRate(from.pitchRate, pitchIn * PLAYER_FLIGHT.maxPitch, pitchIn !== 0, dt), - throttle: (c.held(...keys.accel) ? 1 : 0) - (decelHeld ? 1 : 0), + throttle: accelHeld || decelHeld + ? (accelHeld ? 1 : 0) - (decelHeld ? 1 : 0) + : throttleToward(c.wantedSpeed ?? null, from.speed), fire: c.held(...keys.fire) || c.mouseFire, }; } + +/** + * The throttle a wanted speed asks for: open below it, brake above it, and + * coast inside `PLAYER_FLIGHT.throttleBand` of it (docs/TODO/204 M1). A + * touch slider sets the wanted speed. A keyboard never does, so with no + * wanted speed and no key the ship coasts, as it always did. + */ +export function throttleToward(wanted: number | null, speed: number | undefined): number { + if (wanted === null || speed === undefined) return 0; + const target = wanted * PLAYER_FLIGHT.maxSpeed; + if (speed < target - PLAYER_FLIGHT.throttleBand) return 1; + if (speed > target + PLAYER_FLIGHT.throttleBand) return -1; + return 0; +} diff --git a/src/engine/input.ts b/src/engine/input.ts index ab9a2bb0..2c458e0c 100644 --- a/src/engine/input.ts +++ b/src/engine/input.ts @@ -67,6 +67,12 @@ export class Input { mouseX = 0; mouseY = 0; mouseFire = false; + /** + * The speed a throttle slider asks for, as a fraction of the ship's top + * speed, or null when no slider is set (docs/TODO/204 M1). A speed key + * held overrides it, and `flightDemand` ramps toward it otherwise. + */ + wantedSpeed: number | null = null; private readonly canvas: HTMLElement | null; constructor() { @@ -137,6 +143,20 @@ export class Input { if (code === 'Slash') this.down.delete('Question'); } + /** + * Hold a key down, as a finger on a button does, until `release` + * (docs/TODO/204 M1). It is a held key and never a tap: `held` answers + * for it, `pressed` does not, and the carry rule never sees it. So a FIRE + * button holds the trigger exactly as the A key does. + */ + press(code: string): void { + this.down.add(code); + } + + release(code: string): void { + this.down.delete(code); + } + /** * Queue a press as though a finger struck the key. So a clickable UI reuses * the keyboard handlers. That covers a virtual code like 'VirtBuyMax', which diff --git a/test/flight.test.ts b/test/flight.test.ts index c4bebaed..2c11cf7f 100644 --- a/test/flight.test.ts +++ b/test/flight.test.ts @@ -15,14 +15,14 @@ import { type FlightDemand, } from '../src/player.ts'; import { PLAYER_FLIGHT } from '../src/constants/player-flight.ts'; -import { flightDemand, type FlightControls } from '../src/engine/flight-controls.ts'; +import { flightDemand, throttleToward, type FlightControls } from '../src/engine/flight-controls.ts'; import { keymap } from '../src/engine/keymap.ts'; import { CombatComputer } from '../src/game/combat-computer.ts'; import { CC_ACCEL, CC_MAX_PITCH, CC_MAX_ROLL, CC_MAX_SPEED, } from '../src/constants/combat-computer.ts'; import { freshSystems } from '../src/game/systems.ts'; -import { check } from './harness.ts'; +import { check, eq } from './harness.ts'; // --- flight demands: what the pilot wants, and who wanted it ---------------- // @@ -54,6 +54,7 @@ console.log('\nflight demands'); mouseX = 0; mouseY = 0; mouseFire = false; + wantedSpeed: number | null = null; constructor(down: string[] = []) { this.down = new Set(down); } held(...codes: string[]): boolean { return codes.some((c) => this.down.has(c)); } /** Input's own self-centring, copied because Input itself needs a document. */ @@ -374,3 +375,27 @@ console.log('\nturn ramp'); check('a released rate still snaps to exactly zero', rampFlightRate(0.0005, 0, false, 1 / 60) === 0); } + +console.log('\na wanted speed drives the throttle, and a key overrides it (docs/TODO/204 M1)'); +{ + // The hands, as the block above shapes them, with a slider on the side. + const at = (speed: number, wanted: number | null, ...keys: string[]) => { + const down = new Set(keys); + const h: FlightControls = { + held: (...codes) => codes.some((c) => down.has(c)), + mouseFlight: false, mouseX: 0, mouseY: 0, mouseFire: false, wantedSpeed: wanted, + }; + return flightDemand(h, keymap(), { rollRate: 0, pitchRate: 0, speed }, 1 / 60).throttle; + }; + const max = PLAYER_FLIGHT.maxSpeed; + const band = PLAYER_FLIGHT.throttleBand; + eq('below the wanted speed the throttle opens', at(100, 0.5), 1); + eq('above it the throttle brakes', at(300, 0.5), -1); + eq('at it the ship coasts', at(max * 0.5, 0.5), 0); + eq('...and inside the band, so it does not hunt', at(max * 0.5 - band + 1, 0.5), 0); + eq('...but just outside the band it moves', at(max * 0.5 - band - 1, 0.5), 1); + eq('with no wanted speed and no key, the ship coasts as it always did', at(100, null), 0); + eq('a held speed key overrides the slider', at(100, 0.5, 'Slash'), -1); + eq('...and so does the other one', at(300, 0.5, 'Space'), 1); + eq('a caller with no speed gets no throttle from the slider', throttleToward(0.5, undefined), 0); +} diff --git a/test/input.test.ts b/test/input.test.ts index 353723ad..c26cf972 100644 --- a/test/input.test.ts +++ b/test/input.test.ts @@ -151,6 +151,19 @@ const readPerFrame = (i: Input, code: string, frames: number): number => { eq('...and drains the carry with it', i.drainPresses().length, 0); } +// --- a button holds a key, and is never a tap (docs/TODO/204 M1) ------------ +{ + const i = new Input(); + i.press('KeyA'); + check('a pressed key is held', i.held('KeyA')); + check('...and it is not a tap', !i.pressed('KeyA')); + i.endFrame(); + check('...and the frame boundary does not let go of it', i.held('KeyA')); + i.release('KeyA'); + check('a released key is let go', !i.held('KeyA')); + check('...and left no tap behind', !i.pressed('KeyA')); +} + // --- a real key carries its own modifier (docs/TODO/202 M1) ----------------- // // The keydown that says shiftKey is the whole evidence. A Shift keydown the From e05dea6d5ba2400ad08a69724b764c4287876b7e Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Fri, 11 Sep 2026 08:41:05 +0100 Subject: [PATCH 003/100] docs/TODO/204 M2: the touch overlay: drag to steer, hold to fire, slide to set speed A new engine/touch.ts has two halves. TouchTracker is pure: a finger's down, move and up by pointer id, and the stick, the trigger and the wanted speed it writes into the input. attachTouch binds the overlay's pointer events to it, and Input calls it when the page has the overlay. A drag anywhere on the view is the mouse stick, with TOUCH_STICK_TRAVEL pixels for full deflection. A held finger holds its deflection, which stickHeld tells decayMouse, and a lifted finger decays to centre. FIRE holds the layout's fire key with press. The slider sets wantedSpeed. Two fingers are tracked apart. The overlay shows on a coarse pointer only, never under a screen, and the mouse-flight command steps aside while a finger has the stick. test/touch.test.ts drives the tracker with plain numbers. In Chrome at 390 by 844 with synthetic pointer events, the slider took the speed from 30% to 93%, a full drag right rolled the ship, FIRE heated the laser while the other finger steered, and the stick decayed after the lift. Co-Authored-By: Claude Fable 5.1 Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- play.html | 10 +++ src/constants/CATALOG.md | 3 +- src/constants/touch.ts | 13 +++ src/engine/input.ts | 14 ++- src/engine/touch.ts | 152 +++++++++++++++++++++++++++++++++ src/game/flight-instruments.ts | 1 + src/style.css | 50 +++++++++++ test/run.ts | 1 + test/touch.test.ts | 86 +++++++++++++++++++ 9 files changed, 328 insertions(+), 2 deletions(-) create mode 100644 src/constants/touch.ts create mode 100644 src/engine/touch.ts create mode 100644 test/touch.test.ts diff --git a/play.html b/play.html index b7224a57..af7b7855 100644 --- a/play.html +++ b/play.html @@ -28,6 +28,16 @@ CONDITION: GREEN
+ +
+
+
FIRE
+
-423 exported constants. Regenerate with `npm run generate:constants`; +424 exported constants. Regenerate with `npm run generate:constants`; search names, meanings and values with `npm run constants:find -- ""`. | Domain | Symbol | Literal / expression | Purpose | Rule ID | Source | @@ -402,6 +402,7 @@ search names, meanings and values with `npm run constants:find -- ""`. | torus | MASS_LOCK_STATION | 5000 | How near the station holds the drive down. | | [torus.ts:29](./torus.ts#L29) | | torus | MASS_LOCK_PLANET_ALTITUDE | 4000 | ...and how near the planet, as an ALTITUDE above the surface. | | [torus.ts:37](./torus.ts#L37) | | torus | MASS_LOCK_SHIP | 4500 | ...and how near another ship — any live one that is not a rock. | torus.massLockShip | [torus.ts:46](./torus.ts#L46) | +| touch | TOUCH_STICK_TRAVEL | 125 | How far a steering finger travels from where it landed for full deflection, in CSS pixels: 125, which is about a thumb's comfortable reach on a phone held in one hand. | touch.stickTravel | [touch.ts:13](./touch.ts#L13) | | trumbles | TRUMBLE_PURGE_TEMP | 0.55 | The cabin heat that drives them out. | | [trumbles.ts:12](./trumbles.ts#L12) | | trumbles | BREED_INTERVAL | 20 | Seconds between broods. | trumbles.breedInterval | [trumbles.ts:20](./trumbles.ts#L20) | | trumbles | BREED_RATE | 1.6 | They multiply by this, plus one, every brood. | | [trumbles.ts:23](./trumbles.ts#L23) | diff --git a/src/constants/touch.ts b/src/constants/touch.ts new file mode 100644 index 00000000..79f8c5de --- /dev/null +++ b/src/constants/touch.ts @@ -0,0 +1,13 @@ +// Flying by touch: the one number the finger's stick needs (docs/TODO/204). + +/** + * How far a steering finger travels from where it landed for full + * deflection, in CSS pixels. It is 125, which is about a thumb's + * comfortable reach on a phone held in one hand. The mouse stick uses 450 pixels of + * travel, because a mouse crosses a desk. A thumb crosses a third of a + * phone's width. + * + * @domain touch + * @rule touch.stickTravel + */ +export const TOUCH_STICK_TRAVEL = 125; diff --git a/src/engine/input.ts b/src/engine/input.ts index 2c458e0c..19eb6bf9 100644 --- a/src/engine/input.ts +++ b/src/engine/input.ts @@ -1,4 +1,5 @@ import { CARRY_LIMIT } from '../constants/world-clock.ts'; +import { attachTouch } from './touch.ts'; // Keyboard state with frame-oriented semantics: // - held(codes): live keydown state — every continuous control, the trigger @@ -73,6 +74,12 @@ export class Input { * held overrides it, and `flightDemand` ramps toward it otherwise. */ wantedSpeed: number | null = null; + /** + * A steering finger is down, so the stick holds its deflection and + * `decayMouse` waits (docs/TODO/204 M2). A still mouse decays; a still + * finger does not. + */ + stickHeld = false; private readonly canvas: HTMLElement | null; constructor() { @@ -85,6 +92,10 @@ export class Input { return; } this.canvas = document.getElementById('scene'); + // The touch overlay, where the page has one (docs/TODO/204 M2). It is the + // same bargain as the listeners below: platform wiring, here and nowhere + // else, and nothing when the page has no overlay. + attachTouch(this, document); document.addEventListener('pointerlockchange', () => { this.mouseFlight = document.pointerLockElement === this.canvas; if (!this.mouseFlight) { @@ -232,8 +243,9 @@ export class Input { if (this.mouseFlight) document.exitPointerLock(); } - /** The stick centres itself: with no input, it eases back to neutral. */ + /** The stick centres itself: with no input, it eases back to neutral. A held finger stops it. */ decayMouse(dt: number): void { + if (this.stickHeld) return; const k = Math.max(0, 1 - dt * 1.5); this.mouseX *= k; this.mouseY *= k; diff --git a/src/engine/touch.ts b/src/engine/touch.ts new file mode 100644 index 00000000..0da1111c --- /dev/null +++ b/src/engine/touch.ts @@ -0,0 +1,152 @@ +// Flying by touch: drag anywhere on the view to steer, hold FIRE, and slide +// the throttle (docs/TODO/204 M2). +// +// TWO HALVES. `TouchTracker` is pure. It takes a finger's down, move and up, +// with a pointer id and a place. It writes the stick, the trigger and the +// wanted speed into a small target that `Input` satisfies. A test drives it +// with plain numbers. `attachTouch` is the platform half. It binds the +// browser's pointer events on the overlay to the tracker. It is the only +// code here that reads the DOM. `Input` calls it when the page has the overlay. +// +// THE STICK IS THE MOUSE STICK. A finger's offset from where it landed is the +// same -1..1 pair the mouse fills, and `flightDemand` reads nothing new. Two +// things differ. A held finger holds its deflection, where a still mouse +// decays: `stickHeld` tells `Input.decayMouse` to wait. And a lifted finger +// decays to centre through the same decay, so the ship settles. +// +// A FINGER IS TRACKED BY ITS POINTER ID. One steers while another holds FIRE, +// and lifting either one leaves the other where it is. + +import { TOUCH_STICK_TRAVEL } from '../constants/touch.ts'; +import { keymap } from './keymap.ts'; + +/** What the tracker writes into: the parts of `Input` a finger can move. */ +export interface TouchTarget { + mouseFlight: boolean; + mouseX: number; + mouseY: number; + stickHeld: boolean; + wantedSpeed: number | null; + press(code: string): void; + release(code: string): void; +} + +/** Where a finger landed: the view, the FIRE button, or the throttle slider. */ +export type TouchPlace = 'view' | 'fire' | 'throttle'; + +/** The stick a drag asks for: the offset from where the finger landed, clamped to -1..1. */ +export function stickFromDrag(x0: number, y0: number, x: number, y: number, travel = TOUCH_STICK_TRAVEL): { x: number; y: number } { + const clamp = (v: number): number => Math.max(-1, Math.min(1, v)); + return { x: clamp((x - x0) / travel), y: clamp((y - y0) / travel) }; +} + +/** The speed a slider asks for: 1 at its top, 0 at its bottom, as a fraction of top speed. */ +export function sliderFraction(y: number, top: number, height: number): number { + if (height <= 0) return 0; + return Math.max(0, Math.min(1, 1 - (y - top) / height)); +} + +export class TouchTracker { + private steer: { id: number; x0: number; y0: number } | null = null; + private fire: number | null = null; + private throttle: number | null = null; + private readonly target: TouchTarget; + /** the fire key of the active layout, read at each press so a layout switch is honoured */ + private readonly fireKey: () => string; + /** the slider's box, read at each touch so a resize is honoured */ + private readonly slider: () => { top: number; height: number }; + + constructor( + target: TouchTarget, + fireKey: () => string = () => keymap().fire[0], + slider: () => { top: number; height: number } = () => ({ top: 0, height: 1 }), + ) { + this.target = target; + this.fireKey = fireKey; + this.slider = slider; + } + + down(id: number, place: TouchPlace, x: number, y: number): void { + if (place === 'fire') { + if (this.fire === null) { this.fire = id; this.target.press(this.fireKey()); } + return; + } + if (place === 'throttle') { + this.throttle = id; + this.setThrottle(y); + return; + } + if (this.steer !== null) return; // one finger steers; a second on the view is ignored + this.steer = { id, x0: x, y0: y }; + this.target.mouseFlight = true; + this.target.stickHeld = true; + this.target.mouseX = 0; + this.target.mouseY = 0; + } + + move(id: number, x: number, y: number): void { + if (this.steer?.id === id) { + const s = stickFromDrag(this.steer.x0, this.steer.y0, x, y); + this.target.mouseX = s.x; + this.target.mouseY = s.y; + } else if (this.throttle === id) { + this.setThrottle(y); + } + } + + up(id: number): void { + if (this.steer?.id === id) { + this.steer = null; + this.target.stickHeld = false; // the stick decays to centre from here + } else if (this.fire === id) { + this.fire = null; + this.target.release(this.fireKey()); + } else if (this.throttle === id) { + this.throttle = null; + } + } + + private setThrottle(y: number): void { + const box = this.slider(); + this.target.wantedSpeed = sliderFraction(y, box.top, box.height); + } +} + +/** + * Bind the overlay's pointer events to a tracker. The overlay is `#touch`, + * the button `#touch-fire` and the slider `#touch-throttle`. A page without + * them, or a headless run, attaches nothing. + * + * @returns the tracker, so a caller can read the slider back + */ +export function attachTouch(target: TouchTarget, doc: Document): TouchTracker | null { + const view = doc.getElementById('touch'); + const fire = doc.getElementById('touch-fire'); + const throttle = doc.getElementById('touch-throttle'); + if (!view || !fire || !throttle) return null; + const tracker = new TouchTracker(target, undefined, () => { + const r = throttle.getBoundingClientRect(); + return { top: r.top, height: r.height }; + }); + const placeOf = (el: EventTarget | null): TouchPlace => + (el === fire || (el instanceof Node && fire.contains(el))) ? 'fire' + : (el === throttle || (el instanceof Node && throttle.contains(el))) ? 'throttle' + : 'view'; + view.addEventListener('pointerdown', (e) => { + e.preventDefault(); + const place = placeOf(e.target); + tracker.down(e.pointerId, place, e.clientX, e.clientY); + if (place === 'throttle') throttle.style.setProperty('--throttle', String(target.wantedSpeed ?? 0)); + // capture, so a drag that leaves the overlay still steers; a synthetic + // pointer has no capture to give, and that is not an error + try { view.setPointerCapture(e.pointerId); } catch { /* no such pointer */ } + }); + view.addEventListener('pointermove', (e) => { + tracker.move(e.pointerId, e.clientX, e.clientY); + if (target.wantedSpeed !== null) throttle.style.setProperty('--throttle', String(target.wantedSpeed)); + }); + for (const type of ['pointerup', 'pointercancel'] as const) { + view.addEventListener(type, (e) => tracker.up(e.pointerId)); + } + return tracker; +} diff --git a/src/game/flight-instruments.ts b/src/game/flight-instruments.ts index a379d8b3..b91909f6 100644 --- a/src/game/flight-instruments.ts +++ b/src/game/flight-instruments.ts @@ -130,6 +130,7 @@ export class Instruments { } toggleMouseFlight(): void { + if (this.input.stickHeld) return; // a finger has the stick, and there is no lock to ask for if (this.input.mouseFlight) { this.input.releaseMouseFlight(); this.host.showMessage('MOUSE FLIGHT OFF', 2); diff --git a/src/style.css b/src/style.css index 7f171f12..ec7be49c 100644 --- a/src/style.css +++ b/src/style.css @@ -976,3 +976,53 @@ body.screen-open #exercise { display: none; } #screen .buttons button { padding: 15px 18px; } #screen table button { padding: 15px 12px; } } + +/* + * FLYING BY TOUCH (docs/TODO/204 M2). The overlay covers the view above the + * console. A drag on it steers. FIRE in its bottom right corner holds the + * trigger. The slider at its left edge sets the speed, and the knob follows + * `--throttle`, which engine/touch.ts writes. It shows on a coarse pointer + * only, and never under a screen, where the console hides too. `touch-action` + * is none, or the browser would scroll and zoom the page under a thumb. + */ +#touch { + display: none; + position: absolute; + left: 0; right: 0; top: 0; + bottom: var(--console-h, 0px); + z-index: 8; + touch-action: none; + user-select: none; + -webkit-user-select: none; +} +@media (pointer: coarse) { #touch { display: block; } } +body.screen-open #touch { display: none; } +#touch-fire { + position: absolute; + right: 14px; bottom: 14px; + width: 78px; height: 78px; + border: 1px solid var(--hud-amber); + border-radius: 50%; + color: var(--hud-amber); + background: rgba(0, 14, 2, 0.55); + font-size: 13px; + letter-spacing: 2px; + display: flex; align-items: center; justify-content: center; +} +#touch-fire:active { background: rgba(var(--hud-amber-rgb), 0.35); } +#touch-throttle { + --throttle: 0; + position: absolute; + left: 14px; bottom: 14px; + width: 44px; height: 42%; + border: 1px solid var(--hud-dim); + background: rgba(0, 14, 2, 0.55); +} +#touch-throttle-knob { + position: absolute; + left: 4px; right: 4px; + height: 18px; + bottom: calc(var(--throttle) * (100% - 18px)); + background: var(--hud-amber); + box-shadow: 0 0 8px var(--hud-amber); +} diff --git a/test/run.ts b/test/run.ts index fa68c888..38755f13 100644 --- a/test/run.ts +++ b/test/run.ts @@ -169,6 +169,7 @@ import './screen-buttons.test.ts'; import './key-prose.test.ts'; import './site-footer.test.ts'; import './input.test.ts'; +import './touch.test.ts'; import './hud-binding.test.ts'; import './console-plate.test.ts'; import './elapsed-day.test.ts'; diff --git a/test/touch.test.ts b/test/touch.test.ts new file mode 100644 index 00000000..d30c84b5 --- /dev/null +++ b/test/touch.test.ts @@ -0,0 +1,86 @@ +// Flying by touch, with no browser (docs/TODO/204 M2). +// +// The tracker is pure: a finger's down, move and up, by pointer id, and the +// stick, the trigger and the wanted speed it writes. The overlay's listeners +// are the platform half, and Chrome drives those. + +import { TouchTracker, sliderFraction, stickFromDrag, type TouchTarget } from '../src/engine/touch.ts'; +import { TOUCH_STICK_TRAVEL } from '../src/constants/touch.ts'; +import { Input } from '../src/engine/input.ts'; +import { check, eq } from './harness.ts'; + +/** A target that records what the tracker writes, and the keys it holds. */ +function target(): TouchTarget & { held: Set } { + const held = new Set(); + return { + mouseFlight: false, mouseX: 0, mouseY: 0, stickHeld: false, wantedSpeed: null, held, + press: (code) => { held.add(code); }, + release: (code) => { held.delete(code); }, + }; +} +const FIRE = 'KeyA'; +const tracker = (t: TouchTarget) => new TouchTracker(t, () => FIRE, () => ({ top: 100, height: 200 })); + +console.log('\nthe stick is the finger\'s offset from where it landed'); +{ + eq('half the travel is half deflection', stickFromDrag(100, 100, 100 + TOUCH_STICK_TRAVEL / 2, 100).x, 0.5); + eq('...and it clamps at one', stickFromDrag(100, 100, 100 + TOUCH_STICK_TRAVEL * 3, 100).x, 1); + eq('down is positive, as the mouse stick has it', stickFromDrag(0, 0, 0, TOUCH_STICK_TRAVEL).y, 1); + eq('the slider is one at its top', sliderFraction(100, 100, 200), 1); + eq('...zero at its bottom', sliderFraction(300, 100, 200), 0); + eq('...and clamps past either end', sliderFraction(500, 100, 200), 0); +} + +console.log('\na finger on the view steers, holds, and lets the stick decay when it lifts'); +{ + const t = target(); + const k = tracker(t); + k.down(1, 'view', 200, 300); + check('a landed finger takes the stick and holds it', t.mouseFlight && t.stickHeld && t.mouseX === 0 && t.mouseY === 0); + k.move(1, 200 + TOUCH_STICK_TRAVEL / 2, 300 - TOUCH_STICK_TRAVEL / 4); + eq('a drag right is half a stick right', t.mouseX, 0.5); + eq('...and a drag up is a quarter of a stick up', t.mouseY, -0.25); + k.down(2, 'view', 50, 50); + k.move(2, 150, 50); + eq('a second finger on the view does not take the stick', t.mouseX, 0.5); + k.up(1); + check('the lifted finger leaves the stick to decay', !t.stickHeld && t.mouseX === 0.5); +} + +console.log('\nFIRE holds the trigger while another finger steers'); +{ + const t = target(); + const k = tracker(t); + k.down(1, 'view', 200, 300); + k.down(2, 'fire', 350, 600); + check('the fire finger holds the layout\'s fire key', t.held.has(FIRE)); + k.move(1, 200 + TOUCH_STICK_TRAVEL / 2, 300); + eq('...while the first finger still steers', t.mouseX, 0.5); + k.up(2); + check('lifting the fire finger releases the key and leaves the stick', !t.held.has(FIRE) && t.stickHeld && t.mouseX === 0.5); +} + +console.log('\nthe throttle slider sets the wanted speed'); +{ + const t = target(); + const k = tracker(t); + k.down(3, 'throttle', 30, 150); + eq('a touch a quarter of the way down asks for three quarters of top speed', t.wantedSpeed, 0.75); + k.move(3, 30, 300); + eq('...and a slide to the bottom asks for a stop', t.wantedSpeed, 0); + k.up(3); + eq('the wanted speed holds after the finger lifts', t.wantedSpeed, 0); +} + +console.log('\nthe input holds the stick for a finger, and decays it for a mouse'); +{ + const i = new Input(); + i.mouseFlight = true; + i.mouseX = 1; + i.stickHeld = true; + i.decayMouse(1); + eq('a held stick does not decay', i.mouseX, 1); + i.stickHeld = false; + i.decayMouse(0.5); + check('...and a released one does', i.mouseX < 1); +} From db05c9df97ddac206ec1b984b769517bd6ae526e Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Fri, 11 Sep 2026 08:45:10 +0100 Subject: [PATCH 004/100] docs/TODO/204 M3: the command row and the tappable prompts Five buttons sit along the top edge of the console: MISSILE, E.C.M., JUMP, TORUS and DOCK. ui/key-help.ts paints them at boot from the binding table, so each carries the flight key it presses, and a tap takes the same path as a menu row. MISSILE carries both of its keys, and the HUD swaps the launch key in once a missile is armed and lights the button. TORUS and DOCK light while their state is on. The prompt line carries the code of each offer beside its words, and on a coarse pointer each prompt is a button. The browser shell listens on the row and the prompt line as it does on a screen, and the overlay leaves a tap on the row to that seam. test/key-help.test.ts holds the five buttons and their keys. In the 390 by 844 frame, a tap on MISSILE armed one, swapped the key and lit the button, and a tap on TORUS was refused as MASS LOCKED beside the station, which is right. Co-Authored-By: Claude Fable 5.1 Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- play.html | 2 ++ src/engine/browser-shell.ts | 13 +++++++--- src/engine/touch.ts | 18 ++++++++----- src/game/cockpit-view.ts | 31 ++++++++++++++++++++--- src/game/game.ts | 3 ++- src/hud/hud-binding.ts | 8 ++++++ src/hud/hud.ts | 50 +++++++++++++++++++++++++++++++------ src/style.css | 46 ++++++++++++++++++++++++++++++++++ src/ui/key-help.ts | 41 ++++++++++++++++++++++++++++++ test/console-plate.test.ts | 2 +- test/key-help.test.ts | 24 ++++++++++++++++-- 11 files changed, 212 insertions(+), 26 deletions(-) diff --git a/play.html b/play.html index af7b7855..d259764b 100644 --- a/play.html +++ b/play.html @@ -37,6 +37,8 @@
FIRE
+ +
+ -
-
-
FIRE
- -
- -
-424 exported constants. Regenerate with `npm run generate:constants`; +423 exported constants. Regenerate with `npm run generate:constants`; search names, meanings and values with `npm run constants:find -- ""`. | Domain | Symbol | Literal / expression | Purpose | Rule ID | Source | @@ -281,7 +281,7 @@ search names, meanings and values with `npm run constants:find -- ""`. | pass-aim | MAX_MISS_STRETCH | 3 | The most that geometry may stretch the aim, in multiples of the intended pass. | passaim.maxMissStretch | [pass-aim.ts:31](./pass-aim.ts#L31) | | planet | WITCHPOINT_RADII | 16 | How far out of the planet you drop from witch-space, in planet radii. | planet.witchpointRadii | [planet.ts:15](./planet.ts#L15) | | planet | PLANET_CRASH_ALTITUDE | 80 | The altitude above the surface at which the ship is destroyed. | | [planet.ts:24](./planet.ts#L24) | -| player-flight | PLAYER_FLIGHT | { maxSpeed: 400, accel: 220, throttleBand: 12, maxRoll: 2.5, maxPitch: 1.45, rateRamp: 4.1396, rateDecay: 13.3886, } as const | The player's flight envelope, in one place that a harness can read. | flight.player.maxSpeed
flight.player.throttleBand
flight.player.rateRamp | [player-flight.ts:21](./player-flight.ts#L21) | +| player-flight | PLAYER_FLIGHT | { maxSpeed: 400, accel: 220, maxRoll: 2.5, maxPitch: 1.45, rateRamp: 4.1396, rateDecay: 13.3886, } as const | The player's flight envelope, in one place that a harness can read. | flight.player.maxSpeed
flight.player.rateRamp | [player-flight.ts:21](./player-flight.ts#L21) | | player-gun | LASER_RANGE | 3500 | How far the player's laser reaches, in world units. | | [player-gun.ts:14](./player-gun.ts#L14) | | player-gun | LASER_PACING | { pulse: { cooldown: 0.24, heat: 0.067 }, beam: { cooldown: 0.09, heat: 0.05 }, military: { cooldown: 0.09, heat: 0.05 }, } as const | The cadence and the heat of each fitted laser. | | [player-gun.ts:29](./player-gun.ts#L29) | | player-gun | LASER_CUTOUT | 0.98 | The laser cuts out at this temperature. | | [player-gun.ts:36](./player-gun.ts#L36) | @@ -402,7 +402,6 @@ search names, meanings and values with `npm run constants:find -- ""`. | torus | MASS_LOCK_STATION | 5000 | How near the station holds the drive down. | | [torus.ts:29](./torus.ts#L29) | | torus | MASS_LOCK_PLANET_ALTITUDE | 4000 | ...and how near the planet, as an ALTITUDE above the surface. | | [torus.ts:37](./torus.ts#L37) | | torus | MASS_LOCK_SHIP | 4500 | ...and how near another ship — any live one that is not a rock. | torus.massLockShip | [torus.ts:46](./torus.ts#L46) | -| touch | TOUCH_STICK_TRAVEL | 125 | How far a steering finger travels from where it landed for full deflection, in CSS pixels. | touch.stickTravel | [touch.ts:13](./touch.ts#L13) | | trumbles | TRUMBLE_PURGE_TEMP | 0.55 | The cabin heat that drives them out. | | [trumbles.ts:12](./trumbles.ts#L12) | | trumbles | BREED_INTERVAL | 20 | Seconds between broods. | trumbles.breedInterval | [trumbles.ts:20](./trumbles.ts#L20) | | trumbles | BREED_RATE | 1.6 | They multiply by this, plus one, every brood. | | [trumbles.ts:23](./trumbles.ts#L23) | diff --git a/src/constants/player-flight.ts b/src/constants/player-flight.ts index 65ac1dc8..7961b8fb 100644 --- a/src/constants/player-flight.ts +++ b/src/constants/player-flight.ts @@ -29,16 +29,6 @@ export const PLAYER_FLIGHT = { /** Thrust, world units per second per second, in both directions. */ accel: 220, - /** - * How far the ship's speed may sit from a wanted speed before the throttle - * moves, in world units per second (docs/TODO/204 M1). Twelve is about - * one twentieth of a second of thrust, so the ship settles on the slider's - * speed and does not hunt round it. - * - * @rule flight.player.throttleBand - */ - throttleBand: 12, - /** * The player's Cobra turns at these. They are Harmless numbers, not released * ones. They are set so that you out-turn a pirate Cobra and a Krait, match a diff --git a/src/constants/touch.ts b/src/constants/touch.ts deleted file mode 100644 index 79f8c5de..00000000 --- a/src/constants/touch.ts +++ /dev/null @@ -1,13 +0,0 @@ -// Flying by touch: the one number the finger's stick needs (docs/TODO/204). - -/** - * How far a steering finger travels from where it landed for full - * deflection, in CSS pixels. It is 125, which is about a thumb's - * comfortable reach on a phone held in one hand. The mouse stick uses 450 pixels of - * travel, because a mouse crosses a desk. A thumb crosses a third of a - * phone's width. - * - * @domain touch - * @rule touch.stickTravel - */ -export const TOUCH_STICK_TRAVEL = 125; diff --git a/src/engine/browser-shell.ts b/src/engine/browser-shell.ts index a9324364..db6fbb8a 100644 --- a/src/engine/browser-shell.ts +++ b/src/engine/browser-shell.ts @@ -46,16 +46,11 @@ export function browserShell(canvas: HTMLCanvasElement, scene: THREE.Scene): She // was a listener on `#screen` in the constructor. The listener lives on the // persistent overlay container, since screen contents are re-rendered // wholesale, and it passes the closest element carrying data-key/data-row. - // - // Since docs/TODO/204 M3 it listens on the touch command row and the - // prompt line too. Their buttons carry a data-key, as a menu row does. onScreenClick: (fn) => { - for (const id of ['screen', 'touch-commands', 'touch-menu', 'prompts']) { - document.getElementById(id)?.addEventListener('click', (e) => { - const el = (e.target as HTMLElement).closest('[data-key],[data-row]'); - fn(el ?? e.target, e); - }); - } + document.getElementById('screen')!.addEventListener('click', (e) => { + const el = (e.target as HTMLElement).closest('[data-key],[data-row]'); + fn(el ?? e.target, e); + }); }, // The pointer's twin of the above, on the same persistent container. No diff --git a/src/engine/flight-controls.ts b/src/engine/flight-controls.ts index f68538b6..e96bbb35 100644 --- a/src/engine/flight-controls.ts +++ b/src/engine/flight-controls.ts @@ -29,19 +29,12 @@ export interface FlightControls { readonly mouseX: number; readonly mouseY: number; readonly mouseFire: boolean; - /** the speed a throttle slider asks for, as a fraction of top speed, or null (docs/TODO/204) */ - readonly wantedSpeed?: number | null; } -/** - * The ramped rates the demand continues from — the ship's own, in practice. - * `speed` is the ship's, for the wanted-speed rule, and a caller with no - * throttle slider may leave it out. - */ +/** The ramped rates the demand continues from — the ship's own, in practice. */ export interface TurnRates { rollRate: number; pitchRate: number; - speed?: number; } /** The active bindings the flight controls need, supplied by their owner. */ @@ -77,28 +70,11 @@ export function flightDemand( // slash only decelerates unshifted — ? opens the controls guide const decelHeld = keys.decel.some((k) => c.held(k) && (k !== 'Slash' || !c.held('ShiftLeft', 'ShiftRight'))); - const accelHeld = c.held(...keys.accel); return { rollRate: rampFlightRate(from.rollRate, rollIn * PLAYER_FLIGHT.maxRoll, rollIn !== 0, dt), pitchRate: rampFlightRate(from.pitchRate, pitchIn * PLAYER_FLIGHT.maxPitch, pitchIn !== 0, dt), - throttle: accelHeld || decelHeld - ? (accelHeld ? 1 : 0) - (decelHeld ? 1 : 0) - : throttleToward(c.wantedSpeed ?? null, from.speed), + throttle: (c.held(...keys.accel) ? 1 : 0) - (decelHeld ? 1 : 0), fire: c.held(...keys.fire) || c.mouseFire, }; } - -/** - * The throttle a wanted speed asks for: open below it, brake above it, and - * coast inside `PLAYER_FLIGHT.throttleBand` of it (docs/TODO/204 M1). A - * touch slider sets the wanted speed. A keyboard never does, so with no - * wanted speed and no key the ship coasts, as it always did. - */ -export function throttleToward(wanted: number | null, speed: number | undefined): number { - if (wanted === null || speed === undefined) return 0; - const target = wanted * PLAYER_FLIGHT.maxSpeed; - if (speed < target - PLAYER_FLIGHT.throttleBand) return 1; - if (speed > target + PLAYER_FLIGHT.throttleBand) return -1; - return 0; -} diff --git a/src/engine/input.ts b/src/engine/input.ts index 19eb6bf9..44b712bf 100644 --- a/src/engine/input.ts +++ b/src/engine/input.ts @@ -1,5 +1,4 @@ import { CARRY_LIMIT } from '../constants/world-clock.ts'; -import { attachTouch } from './touch.ts'; // Keyboard state with frame-oriented semantics: // - held(codes): live keydown state — every continuous control, the trigger @@ -68,18 +67,6 @@ export class Input { mouseX = 0; mouseY = 0; mouseFire = false; - /** - * The speed a throttle slider asks for, as a fraction of the ship's top - * speed, or null when no slider is set (docs/TODO/204 M1). A speed key - * held overrides it, and `flightDemand` ramps toward it otherwise. - */ - wantedSpeed: number | null = null; - /** - * A steering finger is down, so the stick holds its deflection and - * `decayMouse` waits (docs/TODO/204 M2). A still mouse decays; a still - * finger does not. - */ - stickHeld = false; private readonly canvas: HTMLElement | null; constructor() { @@ -92,10 +79,6 @@ export class Input { return; } this.canvas = document.getElementById('scene'); - // The touch overlay, where the page has one (docs/TODO/204 M2). It is the - // same bargain as the listeners below: platform wiring, here and nowhere - // else, and nothing when the page has no overlay. - attachTouch(this, document); document.addEventListener('pointerlockchange', () => { this.mouseFlight = document.pointerLockElement === this.canvas; if (!this.mouseFlight) { @@ -155,10 +138,14 @@ export class Input { } /** - * Hold a key down, as a finger on a button does, until `release` - * (docs/TODO/204 M1). It is a held key and never a tap: `held` answers - * for it, `pressed` does not, and the carry rule never sees it. So a FIRE - * button holds the trigger exactly as the A key does. + * Hold a key down, as a finger on a button does, until `release`. It is a + * held key and never a tap: `held` answers for it, `pressed` does not, and + * the carry rule never sees it. So a laser button holds the trigger exactly + * as the A key does. + * + * docs/TODO/204 M1 added this pair. 205 M1 took the rest of 204 out, and it + * kept the pair. 206 holds the laser with it, and 207 holds THRUST and BRAKE + * with it. */ press(code: string): void { this.down.add(code); @@ -243,9 +230,8 @@ export class Input { if (this.mouseFlight) document.exitPointerLock(); } - /** The stick centres itself: with no input, it eases back to neutral. A held finger stops it. */ + /** The stick centres itself: with no input, it eases back to neutral. */ decayMouse(dt: number): void { - if (this.stickHeld) return; const k = Math.max(0, 1 - dt * 1.5); this.mouseX *= k; this.mouseY *= k; diff --git a/src/engine/touch.ts b/src/engine/touch.ts deleted file mode 100644 index 63903dc3..00000000 --- a/src/engine/touch.ts +++ /dev/null @@ -1,193 +0,0 @@ -// Flying by touch: drag anywhere on the view to steer, hold FIRE, and slide -// the throttle (docs/TODO/204 M2). -// -// TWO HALVES. `TouchTracker` is pure. It takes a finger's down, move and up, -// with a pointer id and a place. It writes the stick, the trigger and the -// wanted speed into a small target that `Input` satisfies. A test drives it -// with plain numbers. `attachTouch` is the platform half. It binds the -// browser's pointer events on the overlay to the tracker. It is the only -// code here that reads the DOM. `Input` calls it when the page has the overlay. -// -// THE STICK IS THE MOUSE STICK. A finger's offset from where it landed is the -// same -1..1 pair the mouse fills, and `flightDemand` reads nothing new. Three -// things differ. A held finger holds its deflection, where a still mouse -// decays: `stickHeld` tells `Input.decayMouse` to wait. A lifted finger -// decays to centre through the same decay, so the ship settles. And a finger -// points where it wants to go: a drag up raises the nose. A mouse pulls back -// to climb, as a stick does, and Chris found that upside down under a thumb -// on 2026-09-11. The sign flips here, and nowhere else. -// -// A FINGER IS TRACKED BY ITS POINTER ID. One steers while another holds FIRE, -// and lifting either one leaves the other where it is. - -import { TOUCH_STICK_TRAVEL } from '../constants/touch.ts'; -import { keymap } from './keymap.ts'; - -/** What the tracker writes into: the parts of `Input` a finger can move. */ -export interface TouchTarget { - mouseFlight: boolean; - mouseX: number; - mouseY: number; - stickHeld: boolean; - wantedSpeed: number | null; - press(code: string): void; - release(code: string): void; -} - -/** Where a finger landed: the view, the FIRE button, the throttle slider, or a command button. */ -export type TouchPlace = 'view' | 'fire' | 'throttle' | 'command'; - -/** The stick a drag asks for: the offset from where the finger landed, clamped to -1..1. */ -export function stickFromDrag(x0: number, y0: number, x: number, y: number, travel = TOUCH_STICK_TRAVEL): { x: number; y: number } { - const clamp = (v: number): number => Math.max(-1, Math.min(1, v)); - return { x: clamp((x - x0) / travel), y: clamp((y - y0) / travel) }; -} - -/** The speed a slider asks for: 1 at its top, 0 at its bottom, as a fraction of top speed. */ -export function sliderFraction(y: number, top: number, height: number): number { - if (height <= 0) return 0; - return Math.max(0, Math.min(1, 1 - (y - top) / height)); -} - -export class TouchTracker { - private steer: { id: number; x0: number; y0: number } | null = null; - private fire: number | null = null; - private throttle: number | null = null; - private readonly target: TouchTarget; - /** the fire key of the active layout, read at each press so a layout switch is honoured */ - private readonly fireKey: () => string; - /** the slider's box, read at each touch so a resize is honoured */ - private readonly slider: () => { top: number; height: number }; - - constructor( - target: TouchTarget, - fireKey: () => string = () => keymap().fire[0], - slider: () => { top: number; height: number } = () => ({ top: 0, height: 1 }), - ) { - this.target = target; - this.fireKey = fireKey; - this.slider = slider; - } - - down(id: number, place: TouchPlace, x: number, y: number): void { - if (place === 'fire') { - if (this.fire === null) { this.fire = id; this.target.press(this.fireKey()); } - return; - } - if (place === 'throttle') { - this.throttle = id; - this.setThrottle(y); - return; - } - if (place === 'command') return; // a tap, and the click seam answers it - if (this.steer !== null) return; // one finger steers; a second on the view is ignored - this.steer = { id, x0: x, y0: y }; - this.target.mouseFlight = true; - this.target.stickHeld = true; - this.target.mouseX = 0; - this.target.mouseY = 0; - } - - move(id: number, x: number, y: number): void { - if (this.steer?.id === id) { - const s = stickFromDrag(this.steer.x0, this.steer.y0, x, y); - this.target.mouseX = s.x; - this.target.mouseY = -s.y; // up is up, under a finger - } else if (this.throttle === id) { - this.setThrottle(y); - } - } - - up(id: number): void { - if (this.steer?.id === id) { - this.steer = null; - this.target.stickHeld = false; // the stick decays to centre from here - } else if (this.fire === id) { - this.fire = null; - this.target.release(this.fireKey()); - } else if (this.throttle === id) { - this.throttle = null; - } - } - - private setThrottle(y: number): void { - const box = this.slider(); - this.target.wantedSpeed = sliderFraction(y, box.top, box.height); - } -} - -/** - * Bind the overlay's pointer events to a tracker. The overlay is `#touch`, - * the button `#touch-fire` and the slider `#touch-throttle`. A page without - * them, or a headless run, attaches nothing. - * - * @returns the tracker, so a caller can read the slider back - */ -export function attachTouch(target: TouchTarget, doc: Document): TouchTracker | null { - const view = doc.getElementById('touch'); - const fire = doc.getElementById('touch-fire'); - const throttle = doc.getElementById('touch-throttle'); - const commands = doc.getElementById('touch-commands'); - const menu = doc.getElementById('touch-menu'); - if (!view || !fire || !throttle) return null; - // The flight menu (docs/TODO/204 M4). MENU shows it. A row on it presses - // its key through the click seam, and hides it. The escape pod row opens - // the confirmation inside it first. All of that is show and hide. The keys - // travel the same path a station row's do. - if (menu) { - const show = (on: boolean): void => { - menu.classList.toggle('hidden', !on); - if (!on) for (const ask of menu.querySelectorAll('.touch-ask')) ask.classList.remove('open'); - }; - commands?.addEventListener('click', (e) => { - if ((e.target as HTMLElement).closest('[data-menu]')) show(menu.classList.contains('hidden')); - }); - menu.addEventListener('click', (e) => { - const el = (e.target as HTMLElement).closest('[data-ask],[data-key]'); - if (!el) return; - if (el.dataset.ask !== undefined) { - for (const ask of menu.querySelectorAll('.touch-ask')) { - ask.classList.toggle('open', ask.dataset.asks === el.dataset.ask); - } - if (el.dataset.ask === '') show(false); - return; - } - show(false); // the key is on its way through the seam - }); - } - const tracker = new TouchTracker(target, undefined, () => { - const r = throttle.getBoundingClientRect(); - return { top: r.top, height: r.height }; - }); - const within = (box: HTMLElement | null, el: EventTarget | null): boolean => - box !== null && (el === box || (el instanceof Node && box.contains(el))); - const placeOf = (el: EventTarget | null): TouchPlace => - within(fire, el) ? 'fire' - : within(throttle, el) ? 'throttle' - : within(commands, el) || within(menu, el) ? 'command' - : 'view'; - view.addEventListener('pointerdown', (e) => { - const place = placeOf(e.target); - if (place === 'command') return; // let the click through to the seam - e.preventDefault(); - // The first touch on the view asks for the whole screen (docs/TODO/204 - // M5). A phone's browser bars take a fifth of it otherwise. The browser - // may refuse, and a refusal costs nothing. - if (!doc.fullscreenElement && doc.documentElement.requestFullscreen) { - doc.documentElement.requestFullscreen().catch(() => { /* refused */ }); - } - tracker.down(e.pointerId, place, e.clientX, e.clientY); - if (place === 'throttle') throttle.style.setProperty('--throttle', String(target.wantedSpeed ?? 0)); - // capture, so a drag that leaves the overlay still steers; a synthetic - // pointer has no capture to give, and that is not an error - try { view.setPointerCapture(e.pointerId); } catch { /* no such pointer */ } - }); - view.addEventListener('pointermove', (e) => { - tracker.move(e.pointerId, e.clientX, e.clientY); - if (target.wantedSpeed !== null) throttle.style.setProperty('--throttle', String(target.wantedSpeed)); - }); - for (const type of ['pointerup', 'pointercancel'] as const) { - view.addEventListener(type, (e) => tracker.up(e.pointerId)); - } - return tracker; -} diff --git a/src/game/cockpit-view.ts b/src/game/cockpit-view.ts index 3ccc9c92..d73c896a 100644 --- a/src/game/cockpit-view.ts +++ b/src/game/cockpit-view.ts @@ -31,7 +31,7 @@ import { Hud } from '../hud/hud.ts'; import { flightPrompts, type Prompt } from './prompts.ts'; import { hitCone } from './gunnery.ts'; import { viewDirection } from './views.ts'; -import { keyCodeIfBound, keyIfBound } from '../ui/key-help.ts'; +import { keyIfBound } from '../ui/key-help.ts'; import type { ControlMode } from './controls.ts'; import type { ExerciseStrip } from './combat-sim-strip.ts'; import type { Ordnance } from './ordnance.ts'; @@ -185,29 +185,6 @@ export class CockpitView { * way. */ keyPrompts(): string[] { - return this.offers().flatMap((p) => { - const line = this.renderPrompt(p); - return line ? [line] : []; - }); - } - - /** - * The same offers as buttons: the code each presses beside the line - * (docs/TODO/204 M3). A phone taps the prompt, and the tap injects the code - * a keyboard would send. Aligned with `keyPrompts`, one for one. - */ - keyPromptButtons(): { code: string; shift: boolean; text: string }[] { - const mode = this.host.controlMode(); - if (!mode) return []; - return this.offers().flatMap((p) => { - const line = this.renderPrompt(p); - const key = keyCodeIfBound(mode, p.command); - return line && key ? [{ ...key, text: line }] : []; - }); - } - - /** The commands worth an offer right now, only in flight. */ - private offers(): Prompt[] { const mode = this.host.controlMode(); if (!this.host.inFlight() || !mode) return []; return flightPrompts({ @@ -225,6 +202,9 @@ export class CockpitView { stationDistance: this.state.player.position .distanceTo(this.state.world.station.position), dcEngaged: this.state.session.dcEngaged, + }).flatMap((p) => { + const line = this.renderPrompt(p); + return line ? [line] : []; }); } @@ -277,9 +257,6 @@ export class CockpitView { messageText: this.state.session.messageText, messageTimer: this.state.session.messageTimer, prompts: this.keyPrompts(), - promptButtons: this.keyPromptButtons(), - torus: this.state.session.torusEngaged, - docking: this.state.session.dcEngaged, // Null in career flight. It is gated on the same `active` that gives the // exercise the keyboard (controlMode). The strip is the exercise's own // view of itself, not a second opinion about one. diff --git a/src/game/flight-instruments.ts b/src/game/flight-instruments.ts index b91909f6..a379d8b3 100644 --- a/src/game/flight-instruments.ts +++ b/src/game/flight-instruments.ts @@ -130,7 +130,6 @@ export class Instruments { } toggleMouseFlight(): void { - if (this.input.stickHeld) return; // a finger has the stick, and there is no lock to ask for if (this.input.mouseFlight) { this.input.releaseMouseFlight(); this.host.showMessage('MOUSE FLIGHT OFF', 2); diff --git a/src/game/game.ts b/src/game/game.ts index be9794ae..6178b674 100644 --- a/src/game/game.ts +++ b/src/game/game.ts @@ -114,7 +114,7 @@ import { characterVerdict } from './character.ts'; import { CHARACTER_LINE_SECONDS } from '../constants/character.ts'; import { hideScreen } from '../ui/screens.ts'; import { renderNewGameConfirm } from '../ui/screens-career.ts'; -import { boundKey, keyPointer, paintCommandGuide, paintTouchCommands } from '../ui/key-help.ts'; +import { boundKey, keyPointer, paintCommandGuide } from '../ui/key-help.ts'; import { freshState, type GameState } from './state.ts'; type Mode = 'docked' | 'flight' | 'market' | 'chart' | 'local' | 'equip' | 'status' | 'data' | 'contracts' | 'saves' | 'save-name' | 'naming' | 'briefing' | 'dead'; @@ -705,10 +705,6 @@ export class Game { // same in both layouts, so the binding table paints them once. refreshHelpPanel(); paintCommandGuide(); - // The thumb's buttons and the flight menu, from the same table - // (docs/TODO/204). - paintTouchCommands(); - // ...and the key this line names comes from that same table rather than // from the sentence (docs/TODO/128 M3). The guide is a global binding. The // layout toggle is a row on the station menu, so the line points there diff --git a/src/hud/hud-binding.ts b/src/hud/hud-binding.ts index 8e9841bb..e8ee1132 100644 --- a/src/hud/hud-binding.ts +++ b/src/hud/hud-binding.ts @@ -69,11 +69,6 @@ export interface HudSources { * `ui/`, so a rule module cannot reach it. The dashboard is handed the line. */ readonly prompts: readonly string[]; - /** the same offers with the code each button presses (docs/TODO/204 M3) */ - readonly promptButtons: readonly { code: string; shift: boolean; text: string }[]; - /** the torus drive and the docking computer, for the touch row's lit buttons */ - readonly torus: boolean; - readonly docking: boolean; /** * The training exercise in progress, or null in career flight. * @@ -182,9 +177,6 @@ export function buildHudFrame(s: HudSources, scratch: HudScratch): HudFrame { messageText: s.messageText, messageTimer: s.messageTimer, prompts: s.prompts, - promptButtons: s.promptButtons, - torus: s.torus, - docking: s.docking, playerPos: s.playerPos, playerQuat: s.playerQuat, contacts: scannerContacts( diff --git a/src/hud/hud.ts b/src/hud/hud.ts index 4b527ad3..7af274ba 100644 --- a/src/hud/hud.ts +++ b/src/hud/hud.ts @@ -77,11 +77,6 @@ export interface HudState { * `boundKey`. Neither is a question a painter may answer. */ prompts: readonly string[]; - /** the same offers with the code each presses; a coarse pointer taps them (docs/TODO/204 M3) */ - promptButtons: readonly { code: string; shift: boolean; text: string }[]; - /** the torus drive and the docking computer are engaged: the touch row lights them */ - torus: boolean; - docking: boolean; speedFrac: number; rollFrac: number; // -1..1 pitchFrac: number; // -1..1 @@ -237,7 +232,6 @@ export class Hud { private readonly dayEl = byId('day-display'); private readonly messageEl = byId('message'); private readonly promptsEl = byId('prompts'); - private readonly touchRowEl = byId('touch-commands'); /** what the prompt line currently says, so a steady list is not repainted */ private promptsShown = ''; private readonly flashEl = byId('damage-flash'); @@ -271,8 +265,7 @@ export class Hud { render(_dt: number, frame: HudFrame): void { this.messageEl.textContent = frame.messageTimer > 0 ? frame.messageText : ''; - this.paintPrompts(frame.promptButtons); - this.paintTouchRow(frame); + this.paintPrompts(frame.prompts); this.speedEl.style.width = `${frame.speedFrac * 100}%`; this.rollEl.style.left = `${50 + clampUnit(frame.rollFrac) * 45}%`; this.pitchEl.style.left = `${50 + clampUnit(frame.pitchFrac) * 45}%`; @@ -323,47 +316,20 @@ export class Hud { * the only reason this is markup rather than `textContent`. The strings * themselves are built upstream, and never here. */ - private paintPrompts(prompts: readonly { code: string; shift: boolean; text: string }[]): void { - const line = prompts.map((p) => p.text).join('\u2003'); // em space: a gap, not a bullet + private paintPrompts(prompts: readonly string[]): void { + const line = prompts.join(' '); // em space: a gap, not a bullet if (line === this.promptsShown) return; this.promptsShown = line; - // Each prompt is a button too: `data-key` is the code a tap injects, - // through the same click seam a menu row uses (docs/TODO/204 M3). It is - // rebuilt only when the words change, so a thumb never lands on a - // button that was just repainted. this.promptsEl.innerHTML = prompts .map((p) => { - const gap = p.text.indexOf(' '); - const key = gap < 0 ? p.text : p.text.slice(0, gap); - const what = gap < 0 ? '' : p.text.slice(gap); - return `` - + `${key}${what}`; + const gap = p.indexOf(' '); + const key = gap < 0 ? p : p.slice(0, gap); + const what = gap < 0 ? '' : p.slice(gap); + return `${key}${what}`; }) - .join('\u2003'); + .join(' '); } - /** - * The touch command row's state (docs/TODO/204 M3). MISSILE presses the - * launch key once a missile is armed. A button for a state that can be on - * is lit while it is. The row's markup is ui/key-help.ts's, painted at boot. - */ - private paintTouchRow(frame: HudState): void { - const row = this.touchRowEl; - for (const el of row.querySelectorAll('[data-command]')) { - const command = el.dataset.command; - if (command === 'armMissile') { - const armed = frame.armed || frame.locked; - el.dataset.key = armed ? (el.dataset.launch ?? el.dataset.key ?? '') : (el.dataset.arm ?? el.dataset.key ?? ''); - el.classList.toggle('lit', armed); - } else if (command === 'toggleTorus') { - el.classList.toggle('lit', frame.torus); - } else if (command === 'toggleDockingComputer') { - el.classList.toggle('lit', frame.docking); - } - } - } - - /** * The energy gauge: one bank per segment, and red once you are into the last. * diff --git a/src/style.css b/src/style.css index e3435b8f..7f171f12 100644 --- a/src/style.css +++ b/src/style.css @@ -976,125 +976,3 @@ body.screen-open #exercise { display: none; } #screen .buttons button { padding: 15px 18px; } #screen table button { padding: 15px 12px; } } - -/* - * FLYING BY TOUCH (docs/TODO/204 M2). The overlay covers the view above the - * console. A drag on it steers. FIRE in its bottom right corner holds the - * trigger. The slider at its left edge sets the speed, and the knob follows - * `--throttle`, which engine/touch.ts writes. It shows on a coarse pointer - * only, and never under a screen, where the console hides too. `touch-action` - * is none, or the browser would scroll and zoom the page under a thumb. - */ -#touch { - display: none; - position: absolute; - inset: 0; /* the whole screen steers, the console included (Chris, 2026-09-11) */ - z-index: 8; - touch-action: none; - user-select: none; - -webkit-user-select: none; -} -@media (pointer: coarse) { #touch { display: block; } } -body.screen-open #touch { display: none; } -#touch-fire { - position: absolute; - right: 14px; bottom: 14px; - width: 78px; height: 78px; - border: 1px solid var(--hud-amber); - border-radius: 50%; - color: var(--hud-amber); - background: rgba(0, 14, 2, 0.55); - font-size: 13px; - letter-spacing: 2px; - display: flex; align-items: center; justify-content: center; -} -#touch-fire:active { background: rgba(var(--hud-amber-rgb), 0.35); } -#touch-throttle { - --throttle: 0; - position: absolute; - left: 14px; bottom: 14px; - width: 44px; height: 42%; - border: 1px solid var(--hud-dim); - background: rgba(0, 14, 2, 0.55); -} -#touch-throttle-knob { - position: absolute; - left: 4px; right: 4px; - height: 18px; - bottom: calc(var(--throttle) * (100% - 18px)); - background: var(--hud-amber); - box-shadow: 0 0 8px var(--hud-amber); -} - -/* - * The touch command row, along the top edge of the console (docs/TODO/204 - * M3). Five buttons, each with the flight key it presses, painted at boot - * from the binding table. A lit one says its state is on. The FIRE button and - * the throttle sit above the row. - */ -#touch-commands { - position: absolute; - left: 0; right: 0; bottom: var(--console-h, 0px); - height: 48px; - display: flex; - gap: 6px; - padding: 0 6px; - align-items: stretch; - background: rgba(0, 14, 2, 0.55); - border-top: 1px solid var(--hud-dim); -} -.touch-command { - flex: 1 1 0; - display: flex; align-items: center; justify-content: center; - border: 1px solid var(--hud-dim); - margin: 4px 0; - color: var(--hud-green); - font-size: 11px; - letter-spacing: 1px; -} -.touch-command:active { background: rgba(var(--hud-green-rgb), 0.2); } -.touch-command.lit { border-color: var(--hud-amber); color: var(--hud-amber); } -#touch-fire { bottom: calc(var(--console-h, 0px) + 62px); } -#touch-throttle { bottom: calc(var(--console-h, 0px) + 62px); } -/* The prompts are buttons on a coarse pointer, above the overlay and the row. */ -@media (pointer: coarse) { - #prompts { pointer-events: auto; white-space: normal; } - #prompts .prompt { - display: inline-block; - padding: 8px 12px; - margin: 3px; - border: 1px solid var(--hud-amber); - background: rgba(0, 14, 2, 0.72); - } -} -@media (max-width: 700px) { - #prompts { bottom: calc(var(--console-h, 0px) + 54px); } - #message { bottom: calc(var(--console-h, 0px) + 110px); } -} - -/* - * The flight menu (docs/TODO/204 M4): a list over the view that MENU opens. - * Its rows carry flight keys, painted at boot from the binding table. The - * escape pod's confirmation is a block inside it that opens on its row. - */ -#touch-menu { - position: absolute; - left: 8px; right: 8px; top: 8%; bottom: calc(var(--console-h, 0px) + 56px); - overflow-y: auto; - background: rgba(0, 10, 2, 0.92); - border: 1px solid var(--hud-dim); - padding: 6px; -} -#touch-menu.hidden { display: none; } -.touch-row { - padding: 12px 10px; - margin: 4px 0; - border-left: 2px solid transparent; - color: var(--hud-green); - font-size: 14px; - letter-spacing: 1px; -} -.touch-row:active { background: rgba(var(--hud-green-rgb), 0.2); border-left-color: var(--hud-green); } -.touch-ask { display: none; margin: 4px 0 8px 10px; border-left: 3px solid var(--hud-amber); padding-left: 8px; } -.touch-ask.open { display: block; } -.touch-ask p { color: var(--hud-amber); font-size: 12px; margin: 6px 0; } diff --git a/src/ui/briefing.ts b/src/ui/briefing.ts index 9523b40f..1de9cd7c 100644 --- a/src/ui/briefing.ts +++ b/src/ui/briefing.ts @@ -71,10 +71,7 @@ export const BRIEFING: { title: string; body: string }[] = [ Tap a row on this menu, or move to it with ↑ ↓ and press ENTER. ${KEY.help} shows every control, here and in flight. ${ROW.briefing} on the menu reopens this briefing - whenever you want it back.

- On a phone, drag anywhere on the screen to steer, up to climb, hold - FIRE to fire, and slide the bar at the left edge to set your - speed. MENU opens the charts and the rest.`, + whenever you want it back.`, }, { title: 'MAKE SOME MONEY', diff --git a/src/ui/key-help.ts b/src/ui/key-help.ts index d0e12b8c..5032012c 100644 --- a/src/ui/key-help.ts +++ b/src/ui/key-help.ts @@ -89,88 +89,6 @@ export const isVirtualKey = (code: string): boolean => code.startsWith('Virt'); export const STATION_MENU_NOTE = 'At a station, every command is a row on the menu. Tap a row, or move to it with \u2191 \u2193 and press ENTER. ESC goes back.'; -/** - * The code a button injects for `command` in `mode`'s table, with its - * modifier, or null when the mode binds none (docs/TODO/204 M3). A prompt - * button and the touch command row press this, as a menu row presses its - * own `data-key`. A virtual code is a row already, and answers null. - */ -export function keyCodeIfBound(mode: ControlMode, command: Command): { code: string; shift: boolean } | null { - const b = [...BINDINGS[mode], ...GLOBAL_BINDINGS].find((x) => x.command === command); - return b && !isVirtualKey(b.key) ? { code: b.key, shift: b.shift === true } : null; -} - -/** - * The five commands a thumb needs in a fight, as buttons along the top of - * the console (docs/TODO/204 M3). Each carries the flight key it presses. - * MISSILE carries both of its keys. The arm key is `data-key`, and the - * launch key is `data-launch`. The HUD swaps the launch key in once a - * missile is armed. So the button does what the two keys do, one tap each. - */ -export const TOUCH_COMMANDS: readonly { command: Command; label: string }[] = [ - { command: 'armMissile', label: 'MISSILE' }, - { command: 'fireEcm', label: 'E.C.M.' }, - { command: 'startHyperspace', label: 'JUMP' }, - { command: 'toggleTorus', label: 'TORUS' }, - { command: 'toggleDockingComputer', label: 'DOCK' }, -]; - -export function touchCommandsHtml(): string { - const launch = keyCodeIfBound('flight', 'launchMissile'); - return TOUCH_COMMANDS.map(({ command, label }) => { - const key = keyCodeIfBound('flight', command); - if (!key) return ''; - const extra = command === 'armMissile' && launch ? ` data-launch="${launch.code}" data-arm="${key.code}"` : ''; - return `
${label}
`; - }).join(''); -} - -/** - * The flight menu a MENU button opens on a phone (docs/TODO/204 M4): the - * screens, the views, pause and the escape pod, as rows. Each row carries - * the flight key it presses, so a tap takes the path a menu row takes. The - * escape pod asks first: its row opens a confirmation, and only YES carries - * the key, because the pod costs the ship and the cargo. - */ -export const TOUCH_MENU: readonly { command: Command; label: string }[] = [ - { command: 'openLocalChart', label: 'LOCAL CHART' }, - { command: 'openChart', label: 'GALACTIC CHART' }, - { command: 'openStatus', label: 'COMMANDER STATUS' }, - { command: 'openMissions', label: 'MISSIONS' }, - { command: 'openLog', label: "COMMANDER'S LOG" }, - { command: 'openContracts', label: 'CONTRACTS' }, - { command: 'view0', label: 'FRONT VIEW' }, - { command: 'view1', label: 'REAR VIEW' }, - { command: 'view2', label: 'LEFT VIEW' }, - { command: 'view3', label: 'RIGHT VIEW' }, - { command: 'togglePause', label: 'PAUSE' }, -]; - -export function touchMenuHtml(): string { - const rows = TOUCH_MENU.map(({ command, label }) => { - const key = keyCodeIfBound('flight', command); - return key - ? `
${label}
` - : ''; - }).join(''); - const pod = keyCodeIfBound('flight', 'launchEscapePod'); - const podRows = pod ? ` -
ESCAPE POD
-
-

LAUNCH THE ESCAPE POD? YOU LOSE THE SHIP AND EVERYTHING IN THE HOLD.

-
YES, LAUNCH THE POD
-
NO, STAY WITH THE SHIP
-
` : ''; - return `${rows}${podRows}
CLOSE
`; -} - -/** Paint the touch command row and the flight menu at boot, as the guide is painted. Inert with no host. */ -export function paintTouchCommands(): void { - elementById('touch-commands').innerHTML = touchCommandsHtml() - + '
MENU
'; - elementById('touch-menu').innerHTML = touchMenuHtml(); -} - /** What to print for a `KeyboardEvent.code`, with the modifier the table wants. */ export function keyLabel(code: string, shift = false): string { if (isVirtualKey(code)) return ''; diff --git a/test/console-plate.test.ts b/test/console-plate.test.ts index 5ce7efe6..4aad8ea0 100644 --- a/test/console-plate.test.ts +++ b/test/console-plate.test.ts @@ -80,7 +80,7 @@ console.log('\nthe console plate goes with its words'); viewDir: V(0, 0, -1), missiles: [], canisters: [], targetLock: null, inFlight: false, exercise: null, - prompts: [], promptButtons: [], + prompts: [], messageText, messageTimer, } as unknown as Parameters[0], { diff --git a/test/constants.test.ts b/test/constants.test.ts index 7c0e3032..91f35c36 100644 --- a/test/constants.test.ts +++ b/test/constants.test.ts @@ -437,8 +437,7 @@ const OUTSIDE: readonly Group[] = [ 'ui/briefing.ts': ['KEY', 'BRIEFING', 'BRIEFING_PAGES', 'ROW'], 'ui/screens-career.ts': ['LEVERS_OFF'], // the one sentence the guide and the manual say about the station menu (docs/TODO/202) - // ...and the two lists of buttons a thumb presses in flight (docs/TODO/204) - 'ui/key-help.ts': ['LABELS', 'ALL_BINDINGS', 'STATION_MENU_NOTE', 'TOUCH_COMMANDS', 'TOUCH_MENU'], + 'ui/key-help.ts': ['LABELS', 'ALL_BINDINGS', 'STATION_MENU_NOTE'], 'game/command-help.ts': ['COMMAND_HELP'], 'game/bindings.ts': [ 'GLOBAL_BINDINGS', 'FLIGHT_BINDINGS', 'NOT_IN_THE_SIMULATOR', 'BINDINGS', diff --git a/test/flight.test.ts b/test/flight.test.ts index 3efe19d1..c4bebaed 100644 --- a/test/flight.test.ts +++ b/test/flight.test.ts @@ -54,7 +54,6 @@ console.log('\nflight demands'); mouseX = 0; mouseY = 0; mouseFire = false; - wantedSpeed: number | null = null; constructor(down: string[] = []) { this.down = new Set(down); } held(...codes: string[]): boolean { return codes.some((c) => this.down.has(c)); } /** Input's own self-centring, copied because Input itself needs a document. */ diff --git a/test/input.test.ts b/test/input.test.ts index c26cf972..72adafa6 100644 --- a/test/input.test.ts +++ b/test/input.test.ts @@ -151,7 +151,7 @@ const readPerFrame = (i: Input, code: string, frames: number): number => { eq('...and drains the carry with it', i.drainPresses().length, 0); } -// --- a button holds a key, and is never a tap (docs/TODO/204 M1) ------------ +// --- a button holds a key, and is never a tap (docs/TODO/204 M1, kept by 205 M1) { const i = new Input(); i.press('KeyA'); diff --git a/test/run.ts b/test/run.ts index 4abc5c12..fa68c888 100644 --- a/test/run.ts +++ b/test/run.ts @@ -169,8 +169,6 @@ import './screen-buttons.test.ts'; import './key-prose.test.ts'; import './site-footer.test.ts'; import './input.test.ts'; -import './touch.test.ts'; -import './touch-controls.test.ts'; import './hud-binding.test.ts'; import './console-plate.test.ts'; import './elapsed-day.test.ts'; diff --git a/test/touch-controls.test.ts b/test/touch-controls.test.ts deleted file mode 100644 index 08fcc122..00000000 --- a/test/touch-controls.test.ts +++ /dev/null @@ -1,49 +0,0 @@ -// The thumb's buttons in flight: the command row and the flight menu -// (docs/TODO/204 M3 and M4). -// -// Both are painted from the binding table, so a button cannot press a key -// the table does not have, and a rebound key moves its button with it. -// These checks lived in test/key-help.test.ts until that file crossed the -// size ceiling, and they are one subject. - -import { - TOUCH_COMMANDS, TOUCH_MENU, keyCodeIfBound, touchCommandsHtml, touchMenuHtml, -} from '../src/ui/key-help.ts'; -import { check, eq } from './harness.ts'; - -console.log('\nthe touch command row presses the flight keys it names (docs/TODO/204 M3)'); -{ - const row = touchCommandsHtml(); - const missing = TOUCH_COMMANDS.filter(({ command }) => { - const key = keyCodeIfBound('flight', command); - return !key || !row.includes(`data-command="${command}" data-key="${key.code}"`); - }); - check('every button carries the flight key of its command', missing.length === 0, - missing.map((m) => m.command).join(', ')); - const launch = keyCodeIfBound('flight', 'launchMissile'); - check('...and MISSILE carries the launch key too, for the HUD to swap in once armed', - launch !== null && row.includes(`data-launch="${launch.code}"`)); - eq('five buttons', (row.match(/class="touch-command"/g) ?? []).length, 5); - check('a station row has no code for a button, because it is a row already', - keyCodeIfBound('docked', 'openMarket') === null); - const shifted = keyCodeIfBound('flight', 'openLog'); - check('a shifted key carries its modifier', shifted !== null && shifted.shift && shifted.code === 'KeyR'); -} - -console.log('\nthe flight menu\'s rows press the flight keys they name (docs/TODO/204 M4)'); -{ - const menu = touchMenuHtml(); - const missing = TOUCH_MENU.filter(({ command }) => { - const key = keyCodeIfBound('flight', command); - return !key || !menu.includes(`data-command="${command}" data-key="${key.code}"`); - }); - check('every row carries the flight key of its command', missing.length === 0, - missing.map((m) => m.command).join(', ')); - check('a shifted key travels with its row', /data-command="openLog" data-key="KeyR" data-shift="1"/.test(menu)); - const pod = keyCodeIfBound('flight', 'launchEscapePod'); - check('the escape pod row asks first, and only YES carries the key', - pod !== null && menu.includes('data-ask="pod">ESCAPE POD') && menu.includes(`data-command="launchEscapePod" data-key="${pod.code}"`) - && !/data-ask="pod"[^>]*data-key/.test(menu)); - check('...and the menu closes on CLOSE', menu.includes('data-ask="">CLOSE')); -} - diff --git a/test/touch.test.ts b/test/touch.test.ts deleted file mode 100644 index ef4f2e45..00000000 --- a/test/touch.test.ts +++ /dev/null @@ -1,113 +0,0 @@ -// Flying by touch, with no browser (docs/TODO/204 M2). -// -// The tracker is pure: a finger's down, move and up, by pointer id, and the -// stick, the trigger and the wanted speed it writes. The overlay's listeners -// are the platform half, and Chrome drives those. - -import { TouchTracker, sliderFraction, stickFromDrag, type TouchTarget } from '../src/engine/touch.ts'; -import { TOUCH_STICK_TRAVEL } from '../src/constants/touch.ts'; -import { Input } from '../src/engine/input.ts'; -import { flightDemand, throttleToward, type FlightControls } from '../src/engine/flight-controls.ts'; -import { keymap } from '../src/engine/keymap.ts'; -import { PLAYER_FLIGHT } from '../src/constants/player-flight.ts'; -import { check, eq } from './harness.ts'; - -/** A target that records what the tracker writes, and the keys it holds. */ -function target(): TouchTarget & { held: Set } { - const held = new Set(); - return { - mouseFlight: false, mouseX: 0, mouseY: 0, stickHeld: false, wantedSpeed: null, held, - press: (code) => { held.add(code); }, - release: (code) => { held.delete(code); }, - }; -} -const FIRE = 'KeyA'; -const tracker = (t: TouchTarget) => new TouchTracker(t, () => FIRE, () => ({ top: 100, height: 200 })); - -console.log('\nthe stick is the finger\'s offset from where it landed'); -{ - eq('half the travel is half deflection', stickFromDrag(100, 100, 100 + TOUCH_STICK_TRAVEL / 2, 100).x, 0.5); - eq('...and it clamps at one', stickFromDrag(100, 100, 100 + TOUCH_STICK_TRAVEL * 3, 100).x, 1); - eq('the raw drag reads down as positive; the tracker turns it over for the nose', stickFromDrag(0, 0, 0, TOUCH_STICK_TRAVEL).y, 1); - eq('the slider is one at its top', sliderFraction(100, 100, 200), 1); - eq('...zero at its bottom', sliderFraction(300, 100, 200), 0); - eq('...and clamps past either end', sliderFraction(500, 100, 200), 0); -} - -console.log('\na finger on the view steers, holds, and lets the stick decay when it lifts'); -{ - const t = target(); - const k = tracker(t); - k.down(1, 'view', 200, 300); - check('a landed finger takes the stick and holds it', t.mouseFlight && t.stickHeld && t.mouseX === 0 && t.mouseY === 0); - k.move(1, 200 + TOUCH_STICK_TRAVEL / 2, 300 - TOUCH_STICK_TRAVEL / 4); - eq('a drag right is half a stick right', t.mouseX, 0.5); - eq('...and a drag up raises the nose a quarter, because a finger points where it wants to go', t.mouseY, 0.25); - k.down(2, 'view', 50, 50); - k.move(2, 150, 50); - eq('a second finger on the view does not take the stick', t.mouseX, 0.5); - k.up(1); - check('the lifted finger leaves the stick to decay', !t.stickHeld && t.mouseX === 0.5); -} - -console.log('\nFIRE holds the trigger while another finger steers'); -{ - const t = target(); - const k = tracker(t); - k.down(1, 'view', 200, 300); - k.down(2, 'fire', 350, 600); - check('the fire finger holds the layout\'s fire key', t.held.has(FIRE)); - k.move(1, 200 + TOUCH_STICK_TRAVEL / 2, 300); - eq('...while the first finger still steers', t.mouseX, 0.5); - k.up(2); - check('lifting the fire finger releases the key and leaves the stick', !t.held.has(FIRE) && t.stickHeld && t.mouseX === 0.5); -} - -console.log('\nthe throttle slider sets the wanted speed'); -{ - const t = target(); - const k = tracker(t); - k.down(3, 'throttle', 30, 150); - eq('a touch a quarter of the way down asks for three quarters of top speed', t.wantedSpeed, 0.75); - k.move(3, 30, 300); - eq('...and a slide to the bottom asks for a stop', t.wantedSpeed, 0); - k.up(3); - eq('the wanted speed holds after the finger lifts', t.wantedSpeed, 0); -} - -console.log('\nthe input holds the stick for a finger, and decays it for a mouse'); -{ - const i = new Input(); - i.mouseFlight = true; - i.mouseX = 1; - i.stickHeld = true; - i.decayMouse(1); - eq('a held stick does not decay', i.mouseX, 1); - i.stickHeld = false; - i.decayMouse(0.5); - check('...and a released one does', i.mouseX < 1); -} - -console.log('\na wanted speed drives the throttle, and a key overrides it (docs/TODO/204 M1)'); -{ - // The hands, as the block above shapes them, with a slider on the side. - const at = (speed: number, wanted: number | null, ...keys: string[]) => { - const down = new Set(keys); - const h: FlightControls = { - held: (...codes) => codes.some((c) => down.has(c)), - mouseFlight: false, mouseX: 0, mouseY: 0, mouseFire: false, wantedSpeed: wanted, - }; - return flightDemand(h, keymap(), { rollRate: 0, pitchRate: 0, speed }, 1 / 60).throttle; - }; - const max = PLAYER_FLIGHT.maxSpeed; - const band = PLAYER_FLIGHT.throttleBand; - eq('below the wanted speed the throttle opens', at(100, 0.5), 1); - eq('above it the throttle brakes', at(300, 0.5), -1); - eq('at it the ship coasts', at(max * 0.5, 0.5), 0); - eq('...and inside the band, so it does not hunt', at(max * 0.5 - band + 1, 0.5), 0); - eq('...but just outside the band it moves', at(max * 0.5 - band - 1, 0.5), 1); - eq('with no wanted speed and no key, the ship coasts as it always did', at(100, null), 0); - eq('a held speed key overrides the slider', at(100, 0.5, 'Slash'), -1); - eq('...and so does the other one', at(300, 0.5, 'Space'), 1); - eq('a caller with no speed gets no throttle from the slider', throttleToward(0.5, undefined), 0); -} From a94932acc23a5bfdb5c5b97c0da8dc4944980710 Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Fri, 11 Sep 2026 21:35:55 +0100 Subject: [PATCH 012/100] docs/TODO/205 M2: the course list says what the ship can do next A course is one thing the ship does next with no hand on the stick. The new game/courses.ts decides which courses the situation allows, in order. It follows prompts.ts: a flat view in, a ranked list out, and no key. The jump's refusal words stay in hyperspace.ts. A row whose object exists shows even when the ship cannot fly it, and it says what the ship needs. A row whose object is absent never shows. The launch list cannot show the hermit. The sky is cleared while the ship is docked, and the launch draws the hermit. So the launch offers the jump, the rocks and the star, and the hermit shows in flight. The plan says so. 5,656 assertions, from 5,624. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- docs/ARCHITECTURE.md | 5 + ...the-ship-goes-and-the-ship-flies-itself.md | 21 ++- src/game/courses.ts | 154 ++++++++++++++++++ test/courses.test.ts | 118 ++++++++++++++ test/run.ts | 1 + 5 files changed, 296 insertions(+), 3 deletions(-) create mode 100644 src/game/courses.ts create mode 100644 test/courses.test.ts diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md index 4f103fa6..f066220b 100644 --- a/docs/ARCHITECTURE.md +++ b/docs/ARCHITECTURE.md @@ -33,6 +33,11 @@ rules. This file is a map. It returns a `Command` and words. It never returns a letter. `cockpit-view.ts` looks the label up, through `ui/key-help.ts`. That is how invariant 9 reaches prose. A prompt is derived state, and the code saves nothing about it. +- `src/game/courses.ts` decides what the ship can do next with no hand on the + stick (docs/TODO/205). A course is one such thing, such as a trip to the + station or a skim of the star. It follows the shape of `prompts.ts`: a flat + view in, a ranked list out, and no key. The list is derived state. The code + saves the course that the pilot picks, and never the list. - The console is one line, so `SessionState.queued` is the line that waits for it (`session.ts`). Some consequences make sense only after their cause: what a scan cost your legal record, or what a deed cost your reputation. The console diff --git a/docs/TODO/205-the-pilot-picks-where-the-ship-goes-and-the-ship-flies-itself.md b/docs/TODO/205-the-pilot-picks-where-the-ship-goes-and-the-ship-flies-itself.md index 101b56b3..d46aef2d 100644 --- a/docs/TODO/205-the-pilot-picks-where-the-ship-goes-and-the-ship-flies-itself.md +++ b/docs/TODO/205-the-pilot-picks-where-the-ship-goes-and-the-ship-flies-itself.md @@ -85,7 +85,7 @@ The course list for each situation: | situation | courses, in order | | --- | --- | -| a launch | jump to the chosen system; mine the asteroids; visit the hermit; skim the star | +| a launch | jump to the chosen system; mine the asteroids; skim the star. M2 found that the hermit cannot show here | | an arrival | the mission objective; fly to the station; investigate the derelict; mine the asteroids; visit the hermit; skim the star; jump on | | a course ends | the arrival list, less the work that is done | @@ -144,8 +144,9 @@ starts the countdown at the launch. A local course launches the ship on that course. When no course is available, the launch refuses, and the console says why. An example is *"SET A HYPERSPACE TARGET ON THE GALACTIC CHART"*. -A commander with no fuel and no money is not stuck. The local courses offer -work: the rocks, the hermit and the star. +A commander with no fuel and no money is not stuck. The launch courses offer +work: the rocks and the star. Once the ship is in flight, the hermit shows too, +where the system has one. ### M5 — the course list on screen, for every player @@ -250,3 +251,17 @@ Evidence: the touch code. - **The suite has 5,624 assertions.** That is 5,619 from before 204, plus the five checks of the kept pair. + +### M2 + +- **The launch list cannot show the hermit.** The station clears the sky + while the ship is docked, and the launch builds it again. The hermit is a + draw at the launch, on 30% of worlds. So nothing can know about it on the + pad. The rocks are certain, because every system holds `ASTEROIDS_MIN` or + more. The hermit shows on the list in flight. +- **A row whose object exists shows, even when the ship cannot fly it.** It + then says what the ship needs, for example `NEEDS FUEL SCOOPS`. A row whose + object does not exist never shows. The plan did not state this rule. +- **In flight, a chart with no target shows no jump row.** At a launch, the + jump row always shows, and its reason answers why the ship cannot leave. +- **The suite has 5,656 assertions,** from 5,624. diff --git a/src/game/courses.ts b/src/game/courses.ts new file mode 100644 index 00000000..b530997a --- /dev/null +++ b/src/game/courses.ts @@ -0,0 +1,154 @@ +// What the ship can do next, with no hand on the stick (docs/TODO/205 M2). +// +// A COURSE is one thing that the ship does next by itself. "Fly to the +// station" is a course, and so is "skim the star". The pilot picks one from +// a short list, and a computer flies it. This file decides what is on that +// list. `course-pilot.ts` flies a course, and that is a different subject. +// +// THE WORD IS "COURSE", AND NOT "ORDER". `orders.ts` and invariant 16 already +// use "order" for a signed contract or a live mission. +// +// The list is derived state, as a prompt is (`prompts.ts`). The code saves the +// course that the pilot picks. It never saves the list. Two rules hold it: +// +// - **A course carries a kind and words, and never a key.** The key that +// opens the list lives in the binding table (invariant 9). +// - **It is pure.** It reads a flat view of the situation, so a test can +// raise a situation with no world behind it. +// +// A ROW THAT THE SHIP CANNOT FLY STILL SHOWS WHEN ITS OBJECT EXISTS. The rocks +// are there and the ship has no mining laser: the row shows, and it says what +// the ship needs. A row whose object does not exist never shows. A hermit that +// is not in the sky is not a course. +// +// THE LAUNCH LIST IS SHORTER THAN THE PLAN'S TABLE. The station clears the sky +// while the ship is docked, and the launch builds it again. The rocks are +// certain, because every system holds `ASTEROIDS_MIN` or more. The hermit is a +// draw at the launch, so nothing can know about it before. So the launch offers +// the jump, the rocks and the star. The hermit shows on the list in flight. + +import type { CommanderData } from './commander.ts'; +import type { NpcRole } from './ship-roles.ts'; +import { refusalMessage, type Refusal } from './hyperspace.ts'; +import { MAX_FUEL } from '../constants/commander.ts'; +import { ASTEROIDS_MIN } from '../constants/population.ts'; + +/** What the ship can do by itself. */ +export type CourseKind = + 'jump' | 'mission' | 'station' | 'derelict' | 'mine' | 'hermit' | 'skim'; + +/** + * When the list is asked for. At a launch the ship is still on the pad, and + * the sky is not built. In flight the sky is there to read. + */ +export type CourseSituation = 'launch' | 'flight'; + +/** One row of the list. */ +export interface Course { + readonly kind: CourseKind; + /** the row's words, upper case, as a cockpit line is */ + readonly what: string; + /** null when the ship can fly it; otherwise what stops it, in words */ + readonly why: string | null; +} + +/** + * Everything the list is raised from. + * + * A flat view rather than `GameState`, for the reason `PromptWorld` gives. The + * caller asks `checkJump` for the jump, so the refusal keeps its one home. + */ +export interface CourseWorld { + readonly situation: CourseSituation; + readonly commander: CommanderData; + /** `checkJump`'s answer for the chart's target */ + readonly jump: { ok: true; cost: number } | { ok: false; reason: Refusal }; + /** the target system's name, or null when the chart has none */ + readonly targetName: string | null; + readonly witchspace: boolean; + /** the role of every ship and rock in the sky. Empty at a launch */ + readonly sky: readonly NpcRole[]; + /** the objective's words, when a live leg has its target in this system */ + readonly mission: string | null; + /** the courses this visit already finished, so they leave the list */ + readonly done: ReadonlySet; +} + +/** + * The courses that the situation allows, in the order that ranks them. + * + * In flight, the mission leads, because the missions are the spine of a + * career now (docs/TODO/208). The station follows, because it is where most + * trips end. The jump comes last in flight, and first at a launch. + */ +export function courseList(w: CourseWorld): Course[] { + if (w.situation === 'launch') { + return [jumpRow(w, true), mineRow(w, true), skimRow(w)] + .filter((c): c is Course => c !== null); + } + return [ + w.mission !== null && !w.done.has('mission') + ? { kind: 'mission', what: w.mission, why: null } as const : null, + w.witchspace ? null : { kind: 'station', what: 'FLY TO THE STATION', why: null } as const, + present(w, 'generation', 'derelict') + ? { kind: 'derelict', what: 'INVESTIGATE THE DERELICT', why: null } as const : null, + mineRow(w, false), + present(w, 'hermit', 'hermit') + ? { kind: 'hermit', what: 'VISIT THE HERMIT', why: null } as const : null, + skimRow(w), + jumpRow(w, false), + ].filter((c): c is Course => c !== null); +} + +/** Is the thing in the sky, and is its course not done yet? */ +function present(w: CourseWorld, role: NpcRole, kind: CourseKind): boolean { + return !w.done.has(kind) && w.sky.includes(role); +} + +/** + * The jump. At a launch it always shows, because it is why a ship leaves. A + * row that says why the ship cannot go answers "why can I not launch?". In + * flight it shows only for a chart that has a target. A jump under way is not + * a course to pick, so it never shows. + */ +function jumpRow(w: CourseWorld, launch: boolean): Course | null { + if (!w.jump.ok && w.jump.reason === 'alreadyJumping') return null; + if (!launch && !w.jump.ok && w.jump.reason === 'noTarget') return null; + return { + kind: 'jump', + what: w.targetName === null ? 'JUMP' : `JUMP TO ${w.targetName.toUpperCase()}`, + why: w.jump.ok ? null : refusalMessage(w.jump.reason, w.witchspace), + }; +} + +/** + * The rocks. The ore needs a mining laser to cut it and fuel scoops to take it + * aboard. Without the scoops the ore breaks on the hull (`world-step.ts`), so + * a course without them would only waste the rocks. + */ +function mineRow(w: CourseWorld, launch: boolean): Course | null { + const rocks = launch ? ASTEROIDS_MIN > 0 : w.sky.includes('asteroid'); + if (!rocks || w.done.has('mine')) return null; + const needs = [ + w.commander.equipment.miningLaser ? null : 'A MINING LASER', + w.commander.equipment.scoops ? null : 'FUEL SCOOPS', + ].filter((n): n is string => n !== null); + return { + kind: 'mine', + what: 'MINE THE ASTEROIDS', + why: needs.length ? `NEEDS ${needs.join(' AND ')}` : null, + }; +} + +/** + * The star. The scoops take fuel from it, so a full tank has nothing to gain. + * In witch-space the star is out of reach, as the station is. + */ +function skimRow(w: CourseWorld): Course | null { + if (w.witchspace || w.commander.fuel >= MAX_FUEL || w.done.has('skim')) return null; + return { + kind: 'skim', + what: 'SKIM THE STAR FOR FUEL', + why: w.commander.equipment.scoops ? null : 'NEEDS FUEL SCOOPS', + }; +} diff --git a/test/courses.test.ts b/test/courses.test.ts new file mode 100644 index 00000000..efb24d2a --- /dev/null +++ b/test/courses.test.ts @@ -0,0 +1,118 @@ +// What the ship can do next, with no hand on the stick (docs/TODO/205 M2). +// +// The rule is pure, so no world stands behind it. Each row of the plan's two +// tables is raised here on both sides of its condition. A row that the ship +// cannot fly shows with its reason. A row whose object is not there never +// shows. + +import { newCommander, type CommanderData } from '../src/game/commander.ts'; +import { courseList, type CourseKind, type CourseWorld } from '../src/game/courses.ts'; +import { MAX_FUEL } from '../src/constants/commander.ts'; +import { check, eq } from './harness.ts'; + +console.log('\nthe course list'); + +const fitted = (): CommanderData => { + const c = newCommander(); + c.equipment.miningLaser = true; + c.equipment.scoops = true; + c.fuel = MAX_FUEL - 10; + return c; +}; + +const world = (over: Partial = {}): CourseWorld => ({ + situation: 'flight', + commander: fitted(), + jump: { ok: true, cost: 30 }, + targetName: 'Lave', + witchspace: false, + sky: ['asteroid', 'hermit', 'generation', 'trader'], + mission: null, + done: new Set(), + ...over, +}); + +/** A list or a row compared by its content, which `eq` does not do. */ +const same = (name: string, actual: unknown, expected: unknown): void => + eq(name, JSON.stringify(actual), JSON.stringify(expected)); + +const kinds = (w: CourseWorld): CourseKind[] => courseList(w).map((c) => c.kind); +const row = (w: CourseWorld, kind: CourseKind) => courseList(w).find((c) => c.kind === kind); + +// --- the order --------------------------------------------------------------- +same('in flight, the list runs mission, station, derelict, rocks, hermit, star, jump', + kinds(world({ mission: 'HUNT THE KRAIT' })), + ['mission', 'station', 'derelict', 'mine', 'hermit', 'skim', 'jump']); +same('at a launch, the list runs jump, rocks, star', + kinds(world({ situation: 'launch', sky: [] })), ['jump', 'mine', 'skim']); + +// --- the jump ---------------------------------------------------------------- +same('a jump with fuel names the target and is free to fly', + row(world(), 'jump'), { kind: 'jump', what: 'JUMP TO LAVE', why: null }); +eq('at a launch, a chart with no target still shows the jump, with the reason', + row(world({ situation: 'launch', sky: [], jump: { ok: false, reason: 'noTarget' }, targetName: null }), 'jump')?.why, + 'NO HYPERSPACE TARGET SET'); +check('...and in flight, a chart with no target shows no jump', + !kinds(world({ jump: { ok: false, reason: 'noTarget' }, targetName: null })).includes('jump')); +eq('a jump the tank cannot cover shows, and says so', + row(world({ jump: { ok: false, reason: 'noFuel' } }), 'jump')?.why, 'TARGET OUT OF FUEL RANGE'); +check('a jump under way is not a course to pick', + !kinds(world({ situation: 'launch', sky: [], jump: { ok: false, reason: 'alreadyJumping' } })).includes('jump')); + +// --- the mission ------------------------------------------------------------- +same('a live leg with its target here leads the list, in its own words', + courseList(world({ mission: 'SCAN THE COBRA' }))[0], { kind: 'mission', what: 'SCAN THE COBRA', why: null }); +check('...no leg here, no row', !kinds(world()).includes('mission')); +check('...and a finished one leaves', !kinds(world({ mission: 'X', done: new Set(['mission']) })).includes('mission')); +check('...and no mission row at a launch', !kinds(world({ situation: 'launch', sky: [], mission: 'X' })).includes('mission')); + +// --- the station ------------------------------------------------------------- +check('in flight, the station is a course', kinds(world()).includes('station')); +check('...but not in witch-space, where the station is out of reach', + !kinds(world({ witchspace: true })).includes('station')); +check('...and not at a launch, which leaves it', !kinds(world({ situation: 'launch', sky: [] })).includes('station')); + +// --- the derelict and the hermit --------------------------------------------- +check('a generation ship in the sky is a course', kinds(world()).includes('derelict')); +check('...no generation ship, no row', !kinds(world({ sky: ['asteroid', 'hermit'] })).includes('derelict')); +check('...and one investigated leaves', !kinds(world({ done: new Set(['derelict']) })).includes('derelict')); +check('a hermit in the sky is a course', kinds(world()).includes('hermit')); +check('...no hermit, no row', !kinds(world({ sky: ['asteroid'] })).includes('hermit')); +check('...one visited leaves', !kinds(world({ done: new Set(['hermit']) })).includes('hermit')); +check('...and the launch never guesses at one, because the launch draws it', + !kinds(world({ situation: 'launch', sky: ['hermit'] })).includes('hermit')); + +// --- the rocks --------------------------------------------------------------- +eq('rocks with a mining laser and scoops are free to fly', row(world(), 'mine')?.why, null); +{ + const c = fitted(); c.equipment.miningLaser = false; + eq('...with no mining laser, the row says so', row(world({ commander: c }), 'mine')?.why, 'NEEDS A MINING LASER'); +} +{ + const c = fitted(); c.equipment.scoops = false; + eq('...with no scoops, the row says so', row(world({ commander: c }), 'mine')?.why, 'NEEDS FUEL SCOOPS'); +} +{ + const c = newCommander(); + eq('...with neither, it names both', row(world({ commander: c }), 'mine')?.why, + 'NEEDS A MINING LASER AND FUEL SCOOPS'); +} +check('no rocks in the sky, no row', !kinds(world({ sky: ['hermit'] })).includes('mine')); +check('...but a launch always has rocks, because every system holds some', + kinds(world({ situation: 'launch', sky: [] })).includes('mine')); + +// --- the star ---------------------------------------------------------------- +eq('a tank that is not full, with scoops, can skim', row(world(), 'skim')?.why, null); +{ + const c = fitted(); c.equipment.scoops = false; + eq('...with no scoops, the row says so', row(world({ commander: c }), 'skim')?.why, 'NEEDS FUEL SCOOPS'); +} +{ + const c = fitted(); c.fuel = MAX_FUEL; + check('...a full tank has nothing to gain', !kinds(world({ commander: c })).includes('skim')); +} +check('...and witch-space has no star in reach', !kinds(world({ witchspace: true })).includes('skim')); + +// --- witch-space ------------------------------------------------------------- +same('in witch-space, with nothing in the sky, the jump is the only course', + kinds(world({ witchspace: true, sky: ['thargoid'] })), ['jump']); diff --git a/test/run.ts b/test/run.ts index fa68c888..13b52e16 100644 --- a/test/run.ts +++ b/test/run.ts @@ -71,6 +71,7 @@ import './jettison.test.ts'; import './bribe.test.ts'; import './bribe-flight.test.ts'; import './prompts.test.ts'; +import './courses.test.ts'; import './world.test.ts'; import './docking.test.ts'; import './docking-computer.test.ts'; From 09ea4e7cc71ef76a496e02cfc022fbcafa810b73 Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Fri, 11 Sep 2026 21:48:01 +0100 Subject: [PATCH 013/100] docs/TODO/205 and 206: Chris's answers of 2026-09-11 - The flight keys stay. A key takes control during a fight, and a new button takes a mouse click on a desktop. - The bought combat computer never launches a missile. A missile costs money, so the pilot targets and fires one by hand. - The rocks and the star are launch courses. Chris confirmed the reading. - MOBILE_CONVERSION.md stays out of the repository, so the plans quote it. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- ...the-ship-goes-and-the-ship-flies-itself.md | 17 +++++---- ...ter-flies-the-fight-and-the-pilot-fires.md | 37 ++++++++++++------- 2 files changed, 33 insertions(+), 21 deletions(-) diff --git a/docs/TODO/205-the-pilot-picks-where-the-ship-goes-and-the-ship-flies-itself.md b/docs/TODO/205-the-pilot-picks-where-the-ship-goes-and-the-ship-flies-itself.md index d46aef2d..ff011ecd 100644 --- a/docs/TODO/205-the-pilot-picks-where-the-ship-goes-and-the-ship-flies-itself.md +++ b/docs/TODO/205-the-pilot-picks-where-the-ship-goes-and-the-ship-flies-itself.md @@ -11,7 +11,8 @@ words: *"The current approach does not work - it's not possible to fly the ship using mobile controls."* He saw a larger chance in that failure: *"This is chance to make the game much more than just a combat space fighting game. We can make it an immersive adventure game."* The brainstorm of that day is in the -conversation. Plans 205 to 208 are its result. +conversation. Plans 205 to 208 are its result. The note itself is not in the +repository, so the plans quote it. **Most of the parts exist already.** Each part below flies the player's ship through one `FlightDemand`. A pair of hands makes the same thing, and @@ -183,13 +184,15 @@ own style, and the house prose rules do not govern them. - **"Jump on" is a course when the tank holds the fuel** (Chris, 2026-09-11). "Skim the star" needs fuel scoops, and the ship flies to the star. - **The home system's work stays, as courses** (Chris, 2026-09-11: *"maybe we - keep these, they could be presented as options"*). The rocks, the hermit and - the star are launch courses too. That answers the commander with no fuel - money. + keep these, they could be presented as options"*). The rocks and the star are + launch courses too, and the hermit shows in flight (M2). That answers the + commander with no fuel money. Chris confirmed this reading the same day. - **Camera views wait.** They are GitHub #50. -- **The flight keys stay as an override on a keyboard.** This plan made that - call. The combat trainer, the flight probe and the dock probe fly by those - keys. The two computers already hand the ship back on a touch. +- **The flight keys stay as an override on a keyboard** (Chris, 2026-09-11: + *"keep the keys - we'll use mouse for any new buttons and hitting the + keyboard will take control during combat"*). So a new button takes a mouse + click on a desktop, and a tap on a phone. The two computers already hand the + ship back on a key. - **M1 lands on the branch of 204.** This plan made that call too. Pull request #49 then carries the attempt and its removal together, so the record stays in one place. diff --git a/docs/TODO/206-the-computer-flies-the-fight-and-the-pilot-fires.md b/docs/TODO/206-the-computer-flies-the-fight-and-the-pilot-fires.md index ab5eb46c..38e97300 100644 --- a/docs/TODO/206-the-computer-flies-the-fight-and-the-pilot-fires.md +++ b/docs/TODO/206-the-computer-flies-the-fight-and-the-pilot-fires.md @@ -83,25 +83,30 @@ units across. The standoff must keep the ship outside ### M3 — the pilot's hands -Four controls, as buttons on the flight view and as the existing keys: +Four controls, as buttons on the flight view and as the existing keys. A +button takes a mouse click on a desktop, and a tap on a phone: 1. the laser, which fires while it is held; -2. the missile, which arms on one press and launches on the next; +2. the missile, which arms on one press and launches on the next. It locks on + the target that the pilot picked; 3. the E.C.M.; 4. the target list, which opens as rows over the view. The laser heat stays the pilot's to manage. The trigger goes through the path it uses today, because a shot has legal consequences, and those are the Game's. -### M4 — the bought combat computer flies all of it +### M4 — the bought combat computer flies all of it, except the missiles -With `equipment.combatComputer`, the computer also pulls the trigger, launches -the missiles and picks the targets. The pilot watches. The pilot may still pick -a target, and the computer then fights that one. +With `equipment.combatComputer`, the computer also pulls the trigger, reaches +for the E.C.M. and picks the targets. The pilot watches. The pilot may still +pick a target, and the computer then fights that one. -The missile launch is new. The rule must say when a missile is worth it, for -example a hostile inside a range with a missile armed. Measure it with the -defence probe before the constant is written. +**The computer never launches a missile.** A missile costs money, so the +pilot decides when to spend one. The pilot arms it and fires it by hand, at +the picked target, as in M3. + +**A key takes the stick back.** During a fight, a flight key hands the ship +to the pilot, as it does to the co-pilot today. ### M5 — the ways out, as courses @@ -130,8 +135,11 @@ without the pick. - **Timing and tactics are the pilot's** (Chris, 2026-09-11). The pilot owns the laser, the missiles, the E.C.M. and the choice of target. -- **The bought combat computer takes control of everything** (Chris, - 2026-09-11). The pilot sits back and watches. +- **The bought combat computer takes control of everything but the missiles** + (Chris, 2026-09-11). The pilot sits back and watches. The pilot targets and + fires a missile by hand, because *"missiles cost money"*. +- **A flight key takes control during a fight, and a new button takes a mouse + click** (Chris, 2026-09-11). - **A trader is on the target list** (Chris, 2026-09-11). No hail or demand comes first. The law answers as it does today. - **Collection needs fuel scoops** (Chris, 2026-09-11). The ship flies round the @@ -164,8 +172,8 @@ and the Verification section names it. ## Verification -The gates always run: `npm run check`. `npm run generate:constants` runs first, -because M4 adds a constant. +The gates always run: `npm run check`. `npm run generate:constants` runs first +when a milestone adds a constant. The tier: a rule that changes how a fight goes. `survivability`, `aim-probe`, `defence-probe` and `ambush-probe` run before M2 and after M4. Each sampled @@ -177,7 +185,8 @@ Evidence: pick. - A headless fight shows that the co-pilot follows the pilot's pick, and that it fires only when the pilot's trigger is down. -- A headless fight with a combat computer shows a missile launch. +- A headless fight with a combat computer shows no missile launch, and a + missile that the pilot fires locks on the picked target. - A headless run from a police Viper opens the range, and the torus engages when the lock clears. - A headless collection scoops every canister in range, and it stops on the From dc72f61b67dd536407d1c041118772c14d93d000 Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Fri, 11 Sep 2026 22:05:39 +0100 Subject: [PATCH 014/100] docs/TODO/205 M3: the station course flies the ship into the slot A picked course now flies the ship. The new game/course-pilot.ts decides one frame and reports a FlightDemand, as the two computers do. The station course points at the station and runs the torus whenever the drive is free. Inside the docking computer's range it hands over, with no computer fitted, which is the stopgap until 207. The jump course flies straight while the countdown runs. The switch lives in flight-instruments.ts, beside the other switches that change who flies the ship. A flight key suspends the course (Chris: "keep the keys"). The course and the finished courses are session state, so a save carries them, and a dock or an arrival ends the visit. Measured over 20 systems: every trip docked, with a median of 148 s. The traffic holds the torus down for 111 s of it, three stops at the median, one in three with a hostile ship. Chris chose a skip forward button at one fixed speed, and the plan gains it as M7. 5,676 assertions, from 5,656. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- ...the-ship-goes-and-the-ship-flies-itself.md | 78 +++++++++++- src/constants/CATALOG.md | 3 +- src/constants/course.ts | 26 ++++ src/game/autopilot.ts | 20 +++ src/game/course-pilot.ts | 110 ++++++++++++++++ src/game/flight-instruments.ts | 39 +++++- src/game/flight.ts | 11 +- src/game/hyperspace-actions.ts | 2 + src/game/session.ts | 19 +++ src/game/state.ts | 2 + src/game/station.ts | 2 + test/constants.test.ts | 10 ++ test/course-pilot.test.ts | 119 ++++++++++++++++++ test/run.ts | 1 + test/snapshot.test.ts | 3 + 15 files changed, 438 insertions(+), 7 deletions(-) create mode 100644 src/constants/course.ts create mode 100644 src/game/course-pilot.ts create mode 100644 test/course-pilot.test.ts diff --git a/docs/TODO/205-the-pilot-picks-where-the-ship-goes-and-the-ship-flies-itself.md b/docs/TODO/205-the-pilot-picks-where-the-ship-goes-and-the-ship-flies-itself.md index ff011ecd..6a8898dd 100644 --- a/docs/TODO/205-the-pilot-picks-where-the-ship-goes-and-the-ship-flies-itself.md +++ b/docs/TODO/205-the-pilot-picks-where-the-ship-goes-and-the-ship-flies-itself.md @@ -55,7 +55,7 @@ use "order" for a signed contract or a live mission. One word has one meaning. ## What to do -Six milestones. +Seven milestones. ### M1 — the touch controls leave @@ -126,6 +126,10 @@ from the seeded stream. Until 207 lands, the hand-over at the docking range goes to the docking computer, free of charge. So a course to the station always ends in a dock. +**M3 is two commits.** The first flies the station course and the jump +course, and it adds the saved course and the key override. The second flies the +derelict, the hermit and the star, and it takes the skim measurement below. + **The skim altitude is a measurement, and M3 takes it first.** The heat starts to rise at 110,000 units, and the scoop works inside 80,000. A ship inside 21,000 dies at once. M3 measures a hold distance where the tank fills and the @@ -169,6 +173,32 @@ Rewrite the flight sections of the manual and of the briefing. Update the landing page where it describes how you fly. The player-facing pages keep their own style, and the house prose rules do not govern them. +### M7 — the skip forward button + +A skip forward button runs the world faster while nothing needs the pilot. It +runs the same fixed step eight times in each screen frame, and it draws the +last one. The mass lock, the traffic and the encounters behave as they do at +normal speed. So the skip shortens the wait and changes no rule. + +The button works only while no hostile ship is in scanner range. The skip +stops by itself in these cases: + +1. a hostile ship comes into scanner range; +2. the course ends, or no course is picked; +3. a new line comes to the console; +4. the pilot presses a flight key, or taps the button again. + +The skip works for the whole trip, and that includes the docking computer's +approach. A key and a button start it, and the key lives in the binding table. + +**The game loop caps the steps in one frame.** `MAX_STEPS_PER_FRAME` is 5 and +`MAX_FRAME_TIME` is 0.25 s. The skip needs eight steps in a frame, so it raises +the cap for its own frames only. A slow device that cannot keep up skips +slower. It never skips a rule. + +`test/skip.test.ts` proves that a skipped trip and a normal trip end in the +same world state, step for step. It proves each of the four stops above. + ## Decisions already made - **One flow for every player** (Chris, 2026-09-11). A keyboard player and a @@ -180,7 +210,14 @@ own style, and the house prose rules do not govern them. - **A countdown that starts runs to the jump** (Chris, 2026-09-11), as it does today. A fight during the countdown does not stop it. - **The torus drive is enough for the trip to the station** (Chris, - 2026-09-11). No course skips time. + 2026-09-11). The measurement of M3 then showed a median trip of 148 s, and + Chris chose a skip forward button the same day (M7). It runs the fixed step + faster, at one fixed speed, and it changes no rule (*"instead of being able + to cheat the mass lock we just skip time forward"*). He first chose a "carry + on" tap past the mass lock, and the skip replaced it. +- **The skip has one fixed speed** (Chris, 2026-09-11: *"Fixed speed - let's + keep it simple"*). It is eight times normal speed, and it is tuned after he + plays it. - **"Jump on" is a course when the tank holds the fuel** (Chris, 2026-09-11). "Skim the star" needs fuel scoops, and the ship flies to the star. - **The home system's work stays, as courses** (Chris, 2026-09-11: *"maybe we @@ -268,3 +305,40 @@ Evidence: - **In flight, a chart with no target shows no jump row.** At a launch, the jump row always shows, and its reason answers why the ship cannot leave. - **The suite has 5,656 assertions,** from 5,624. + +### M3, first commit: the station course and the jump course + +- **The course switch lives in `flight-instruments.ts`.** That file already + holds the switches that change who flies the ship. `flight.ts` gains four + lines, and it stays under its ceiling of 400. +- **The hand-over needs a new door, `Autopilot.handOverToDock`.** It engages + the docking computer with none fitted. It is the stopgap until 207, and its + doc comment says so. +- **A save carries the course with no new code in the snapshot.** The session + is walked generically, and an old save restores the field at its default. +- **The trip is long, and the traffic makes it long.** Measured on 2026-09-11 + over 20 systems, from the witchpoint to the dock, with no hand on the stick: + +| the sky | the trip, p10 / p50 / p90 | the torus runs | a mass lock holds | +| --- | --- | --- | --- | +| the arrival's own traffic | 116 / 148 / 164 s | 5 / 9 / 16 s | 73 / 111 / 126 s | +| an empty sky | 53 / 55 / 60 s | 19 / 21 / 26 s | 4 s | + + The course engages the torus whenever the drive is free. The time with + neither is under 3 s at p90. So the lock is the cost, and the lock is any + live ship within 4,500 units. The arrival puts traders and police along the + corridor. The last 30 s of each trip is the docking computer's approach. + All 20 trips docked, and 30 trips in one system docked too. + + **The stops, measured the same day.** A trip stops at a mass lock three + times at the median, and five at most. About one stop in three has a hostile + ship in it: + +| sample | stops per trip, median | most in one trip | stops with a hostile ship | +| --- | --- | --- | --- | +| 20 trips | 3 | 4 | 16 of 50 | +| 40 trips | 3 | 5 | 32 of 103 | + + **The step is cheap.** With no graphics, the world step ran about 2,000 + times faster than real time on the development Mac, over 5 trips and over + 10. So a skip at eight times speed costs little. That number led to M7. diff --git a/src/constants/CATALOG.md b/src/constants/CATALOG.md index 7d6d1476..0b0dad45 100644 --- a/src/constants/CATALOG.md +++ b/src/constants/CATALOG.md @@ -2,7 +2,7 @@ -423 exported constants. Regenerate with `npm run generate:constants`; +424 exported constants. Regenerate with `npm run generate:constants`; search names, meanings and values with `npm run constants:find -- ""`. | Domain | Symbol | Literal / expression | Purpose | Rule ID | Source | @@ -114,6 +114,7 @@ search names, meanings and values with `npm run constants:find -- ""`. | contracts | CONTRACT_RANGE | MAX_FUEL | How far away a contract may send you, in tenths of a light year: exactly as far as a full tank reaches. | | [contracts.ts:27](./contracts.ts#L27) | | contracts | PASSENGER_BERTH_TONNES | 2 | What one passenger costs the hold, in tonnes. | contracts.passengerBerthTonnes | [contracts.ts:51](./contracts.ts#L51) | | contracts | SMUGGLE_DELIVERY_NOTORIETY | 0.06 | How loudly a delivered smuggling run is talked about, per tonne landed. | contracts.smuggleDeliveryNotoriety | [contracts.ts:81](./contracts.ts#L81) | +| course | COURSE_TORUS_CONE | 0.1 | How far off the nose the target may sit, in radians, before the course pilot engages the torus drive. | course.torusCone | [course.ts:26](./course.ts#L26) | | docking | GATE_HALF_WIDTHS | 5 | How far out the approach gate sits, in multiples of the station half-width. | docking.gateHalfWidths | [docking.ts:25](./docking.ts#L25) | | docking | TURN_IN | Math.PI / 4 | How far round from the slot axis an approach turns in, in radians. | | [docking.ts:49](./docking.ts#L49) | | docking | RUN_IN_WIDTHS | GATE_HALF_WIDTHS * 0.6 | Where the approach stops the curve and flies straight, in station half-widths. | | [docking.ts:87](./docking.ts#L87) | diff --git a/src/constants/course.ts b/src/constants/course.ts new file mode 100644 index 00000000..b4ce5ece --- /dev/null +++ b/src/constants/course.ts @@ -0,0 +1,26 @@ +// How a course flies the ship (docs/TODO/205 M3). +// +// A course is one thing the ship does next with no hand on the stick. +// `game/course-pilot.ts` flies it, and it spends these values. + +/** + * How far off the nose the target may sit, in radians, before the course + * pilot engages the torus drive. + * + * The drive multiplies travel by eight (`TORUS_MULTIPLIER`). A drive engaged + * with the target well off the nose carries the ship a long way off the line + * before the turn finishes. So the pilot turns first, and then engages. The + * pilot still steers while the drive runs, so a small error inside the cone + * closes on the way. + * + * It equals `DC_TURN_FADE_ANGLE`, and the two rules are independent. That one + * fades the docking computer's turn near its heading. This one gates a drive. + * + * It belongs here, and not with the spawn cones in `spawn-placement.ts`. Those + * place a ship when it appears. This one gates a drive while the commander's + * own ship flies, and only the course pilot reads it. + * + * @rule course.torusCone + * @domain course + */ +export const COURSE_TORUS_CONE = 0.1; diff --git a/src/game/autopilot.ts b/src/game/autopilot.ts index 3b395fc5..401caefc 100644 --- a/src/game/autopilot.ts +++ b/src/game/autopilot.ts @@ -118,6 +118,26 @@ export class Autopilot { return events; } + /** + * A course hands the ship to the docking computer (docs/TODO/205 M3). + * + * It needs no fitted computer, and that is a stopgap. Until docs/TODO/207 + * gives the pilot a trial at the slot, a course to the station ends in a + * free dock. The course asks only inside `DOCK_COMPUTER_RANGE`, so the range + * refusal of `toggleDocking` cannot arise here. + */ + handOverToDock(): AutopilotEvent[] { + const s = this.state; + if (s.session.dcEngaged) return []; + s.session.dcEngaged = true; + s.dockPlan.phase = 'gate'; + return [ + say('DOCKING COMPUTER ENGAGED', 2), + { kind: 'sound', name: 'dockingComputerEngaged' }, + { kind: 'dockingMusic', on: true }, + ]; + } + /** * How far the commander is from the station, for the station's truce * (`truceHolds`, law.ts). diff --git a/src/game/course-pilot.ts b/src/game/course-pilot.ts new file mode 100644 index 00000000..fb3202dc --- /dev/null +++ b/src/game/course-pilot.ts @@ -0,0 +1,110 @@ +// How the ship flies the course that the pilot picked (docs/TODO/205 M3). +// +// `courses.ts` decides what is on the list. This file flies one course for one +// frame. It DECIDES and reports a `CourseStep`, as the two computers in +// `autopilot.ts` do. The demand in it is a `FlightDemand`, the same thing a +// pair of hands makes, and `PlayerShip.update` flies it. +// +// It APPLIES nothing. The switches are `flight-instruments.ts`'s: the torus +// drive, and the hand-over to the docking computer. A step asks for them, and +// the instruments throw them. It draws nothing from the seeded stream, so it +// has no order to preserve. +// +// THE STEERING IS THE CO-PILOT'S. `bankToTurn` in `pitch-roll-steer.ts` points +// the nose with pitch and roll alone, at the commander's own caps and ramp. +// The ship has no yaw axis, so there is no other way to point it. +// +// THE STEER MEMORY IS NOT SAVED. It holds which vertical a bank takes, and a +// restore that starts it fresh costs one bank at most. The scripted co-pilot +// makes the same bargain. +// +// Two courses fly today. The station course points at the station and runs +// the torus until the mass lock. It then hands the ship to the docking +// computer, at the range where that computer takes a job. The jump course +// flies straight while the countdown runs. The rest wait for their +// milestones, and a course with no flight yet returns no demand. + +import * as THREE from 'three'; +import { rampFlightRate, type FlightDemand } from '../player.ts'; +import { bankToTurn, freshSteerMemory, type SteerMemory } from './pitch-roll-steer.ts'; +import type { CourseKind } from './courses.ts'; +import { PLAYER_FLIGHT } from '../constants/player-flight.ts'; +import { DOCK_COMPUTER_RANGE } from '../constants/docking-computer.ts'; +import { COURSE_TORUS_CONE } from '../constants/course.ts'; + +/** What the course pilot reads for one frame. A flat view, so a test needs no world. */ +export interface CourseView { + readonly course: CourseKind; + readonly position: THREE.Vector3; + readonly quaternion: THREE.Quaternion; + readonly pitchRate: number; + readonly rollRate: number; + readonly stationPos: THREE.Vector3; + /** the docking computer already has the ship */ + readonly dcEngaged: boolean; +} + +/** What the course pilot asks for this frame. */ +export interface CourseStep { + /** what it wants flown, or null where something else flies the ship */ + readonly demand: FlightDemand | null; + /** whether it wants the torus drive on. The mass lock still decides */ + readonly torus: boolean; + /** hand the ship to the docking computer now */ + readonly handOver: boolean; +} + +const IDLE: CourseStep = { demand: null, torus: false, handOver: false }; + +export class CoursePilot { + private mem: SteerMemory = freshSteerMemory(); + private readonly dir = new THREE.Vector3(); + private readonly fwd = new THREE.Vector3(); + + /** Forget the bank, for a new course. */ + reset(): void { this.mem = freshSteerMemory(); } + + step(v: CourseView, dt: number): CourseStep { + if (v.course === 'station') return this.toStation(v, dt); + if (v.course === 'jump') return { demand: straight(v, dt), torus: false, handOver: false }; + return IDLE; + } + + /** + * Point at the station, and run the torus while the nose is on it. Inside + * the docking computer's range, hand over. The docking computer then flies + * the approach and the slot, and this course asks for nothing more. + */ + private toStation(v: CourseView, dt: number): CourseStep { + if (v.dcEngaged) return IDLE; + this.dir.subVectors(v.stationPos, v.position); + if (this.dir.length() <= DOCK_COMPUTER_RANGE) { + return { demand: null, torus: false, handOver: true }; + } + const stick = bankToTurn(v.quaternion, this.dir, this.mem); + this.fwd.set(0, 0, -1).applyQuaternion(v.quaternion); + const offNose = this.fwd.angleTo(this.dir); + return { + demand: { + pitchRate: rampFlightRate( + v.pitchRate, stick.pitch * PLAYER_FLIGHT.maxPitch, stick.pitch !== 0, dt), + rollRate: rampFlightRate( + v.rollRate, stick.roll * PLAYER_FLIGHT.maxRoll, stick.roll !== 0, dt), + throttle: 1, + fire: false, + }, + torus: offNose < COURSE_TORUS_CONE, + handOver: false, + }; + } +} + +/** Level the sticks and open the throttle: the ship flies on as it points. */ +function straight(v: CourseView, dt: number): FlightDemand { + return { + pitchRate: rampFlightRate(v.pitchRate, 0, false, dt), + rollRate: rampFlightRate(v.rollRate, 0, false, dt), + throttle: 1, + fire: false, + }; +} diff --git a/src/game/flight-instruments.ts b/src/game/flight-instruments.ts index a379d8b3..51a05a77 100644 --- a/src/game/flight-instruments.ts +++ b/src/game/flight-instruments.ts @@ -5,9 +5,10 @@ // `tools/sizes.mjs` calls its 400-line ceiling a detector rather than // a rule, and this is what it detected. // -// ONE RESPONSIBILITY: the instruments a pilot switches on. Five of them: +// ONE RESPONSIBILITY: the instruments a pilot switches on. Six of them: // // - the two computers that fly the ship for her; +// - the course she picked, which flies the ship too (docs/TODO/205); // - the drive that crosses the system; // - the mouse she flies with; // - the view she flies by. @@ -20,6 +21,7 @@ import { sfx } from '../audio.ts'; import { Autopilot, type AutopilotEvent } from './autopilot.ts'; +import { CoursePilot } from './course-pilot.ts'; import { massLocked } from './world-step.ts'; import { boundKey } from '../ui/key-help.ts'; import { defenceBrain } from './brains.ts'; @@ -68,6 +70,8 @@ export class Instruments { * seat. */ private readonly autopilot: Autopilot; + /** the seat that flies a picked course (docs/TODO/205 M3) */ + private readonly coursePilot = new CoursePilot(); private readonly host: InstrumentHost; constructor( @@ -102,6 +106,39 @@ export class Instruments { return { demand: auto.demand ?? null, ecm: auto.ecm }; } + /** + * The course the pilot picked, flown for one frame, or null for none + * (docs/TODO/205 M3). + * + * `course-pilot.ts` decides. This throws the two switches that a step asks + * for: the torus drive, and the hand-over to the docking computer. A flight + * key suspends the course, as it drops the two computers. The course list + * then offers the course again (Chris, 2026-09-11: *"keep the keys"*). + */ + course(dt: number, handsOn: boolean): FlightDemand | null { + const s = this.state.session; + if (s.course === null) return null; + if (handsOn) { + s.course = null; + this.coursePilot.reset(); + this.host.showMessage('COURSE SUSPENDED — MANUAL CONTROL', 2); + return null; + } + const p = this.state.player; + const step = this.coursePilot.step({ + course: s.course, + position: p.position, + quaternion: p.quaternion, + pitchRate: p.pitchRate, + rollRate: p.rollRate, + stationPos: this.state.world.station.position, + dcEngaged: s.dcEngaged, + }, dt); + if (step.handOver) this.applyAutopilot(this.autopilot.handOverToDock()); + if (step.torus !== s.torusEngaged && (!step.torus || !this.massLocked())) this.toggleTorus(); + return step.demand; + } + /** A hit worth a break: the co-pilot keeps its own record * (scripted-co-pilot.ts). */ noteUnderFire(): void { this.autopilot.noteUnderFire(); } diff --git a/src/game/flight.ts b/src/game/flight.ts index 1ed41cab..95afcc6e 100644 --- a/src/game/flight.ts +++ b/src/game/flight.ts @@ -310,8 +310,8 @@ export class Flight { /** * Who flies the ship, and what they want. * - * ONE producer per frame: the hands at the keyboard, or the combat computer - * when it is engaged and still holds the ship. The trigger is the union of + * ONE producer per frame: the hands at the keyboard, the combat computer + * when it is engaged and still holds the ship, or a picked course. The trigger is the union of * the two. A fitted combat computer flies the ship. It does not take your gun * off you. */ @@ -320,7 +320,12 @@ export class Flight { // the virtual stick self-centres; the producer is pure, so the mutation // is ours to do, immediately after the read if (this.input.mouseFlight) this.input.decayMouse(dt); - if (!this.state.session.ccEngaged) return hands; + // A picked course flies when no co-pilot does (docs/TODO/205 M3). The + // trigger stays the pilot's, as it does under the co-pilot. + if (!this.state.session.ccEngaged) { + const course = this.instruments.course(dt, this.handsOn()); + return course ? { ...course, fire: hands.fire } : hands; + } // WHICH co-pilot is the brain selection's answer. Under the shipped // 'attack-run' name it is the scripted PURE-PURSUIT co-pilot. Otherwise it // is the trained defence seat, which is dormant: defenceBrain() is null and diff --git a/src/game/hyperspace-actions.ts b/src/game/hyperspace-actions.ts index ce7642cd..be07b5cf 100644 --- a/src/game/hyperspace-actions.ts +++ b/src/game/hyperspace-actions.ts @@ -38,6 +38,7 @@ import { runMissions } from './mission-bridge.ts'; import { arrivalLines, type Sighting } from './mission-arrival.ts'; import type { WorldBuild } from './world-build.ts'; import type { GameState } from './state.ts'; +import { endVisit } from './session.ts'; import { COUNTDOWN, WITCHSPACE_ESCAPE_COST } from '../constants/jump.ts'; import { WITCHPOINT_RADII } from '../constants/planet.ts'; @@ -174,6 +175,7 @@ export class HyperspaceActions { seedWorld(this.state.commander.galaxy * 0x9e3779b1 ^ (this.state.commander.systemIndex << 8) ^ this.state.commander.day); this.state.session.witchspace = false; // any arrival leaves witch-space (incl. galactic jump) + endVisit(this.state.session); // The course and the finished work were the last system's. // Before the world is built, because the roster it is built with is this. this.world.chooseBlueprintSet(); this.world.buildWorld(); diff --git a/src/game/session.ts b/src/game/session.ts index f2840c27..6834ca6b 100644 --- a/src/game/session.ts +++ b/src/game/session.ts @@ -5,6 +5,8 @@ // walks it generically. So a new field here saves itself, and there is no list // to keep in step. +import type { CourseKind } from './courses.ts'; + /** * The flight session: every flag and timer that describes the moment. * @@ -87,6 +89,23 @@ export interface SessionState { ccEngaged: boolean; beamTimer: number; dcEngaged: boolean; + /** + * The course the pilot picked, or null for none (docs/TODO/205 M3). It is + * saved state, because it decides what flies the ship. The list it came + * from is derived, and nothing saves that (courses.ts). + */ + course: CourseKind | null; + /** the courses this visit already finished, so the list leaves them out */ + coursesDone: CourseKind[]; +} + +/** + * A visit to a system ends: at a dock, and at an arrival somewhere else. The + * picked course and the finished ones belong to the visit, so both go. + */ +export function endVisit(state: SessionState): void { + state.course = null; + state.coursesDone = []; } /** Put a message in canonical state; the HUD only paints these fields. */ diff --git a/src/game/state.ts b/src/game/state.ts index f337201e..ba07b013 100644 --- a/src/game/state.ts +++ b/src/game/state.ts @@ -156,6 +156,8 @@ export function freshSession(): SessionState { ccEngaged: false, beamTimer: 0, dcEngaged: false, + course: null, + coursesDone: [], }; } diff --git a/src/game/station.ts b/src/game/station.ts index f72ebf9c..49bf0372 100644 --- a/src/game/station.ts +++ b/src/game/station.ts @@ -42,6 +42,7 @@ import { ordersSummary, standingOrders } from './orders.ts'; import type { Command } from './controls.ts'; import type { Ordnance } from './ordnance.ts'; import { repairAtStation } from './systems.ts'; +import { endVisit } from './session.ts'; import type { GameState } from './state.ts'; import type { SoundEvent, SoundName } from './sounds.ts'; @@ -190,6 +191,7 @@ export class Station { s.session.hyperCountdown = -1; s.session.torusEngaged = false; s.session.ccEngaged = false; + endVisit(s.session); this.ordnance.armed = false; effects.push({ kind: 'presentation', action: 'releaseMouseFlight' }); // ANYONE YOU PULLED OUT OF A CAPSULE IS NOT RESOLVED HERE any more. A dock diff --git a/test/constants.test.ts b/test/constants.test.ts index 91f35c36..cb648777 100644 --- a/test/constants.test.ts +++ b/test/constants.test.ts @@ -390,6 +390,16 @@ const OUTSIDE: readonly Group[] = [ }, }, + { + why: 'STAYS: not a number at all. It is the step a course pilot returns when' + + ' it asks for nothing, one ready-made object so a frame allocates none' + + ' (docs/TODO/205 M3). The one tunable, the torus cone, is' + + ' constants/course.ts', + files: { + 'game/course-pilot.ts': ['IDLE'], + }, + }, + { why: 'STAYS: how the launch/docking tunnel effect LOOKS — the ellipse squash that' + ' reads as a bay mouth, and two fractions of the effect\'s own timeline. Pure' diff --git a/test/course-pilot.test.ts b/test/course-pilot.test.ts new file mode 100644 index 00000000..430e432a --- /dev/null +++ b/test/course-pilot.test.ts @@ -0,0 +1,119 @@ +// How the ship flies a picked course (docs/TODO/205 M3). +// +// Two halves. The pure half asks the course pilot for one frame, with no world +// behind it. The flown half picks the station course in a real headless game, +// on the real world step, and waits for the dock. That half is the claim that +// matters: a pilot with no hand on the stick gets from the witchpoint into +// the slot. + +import * as THREE from 'three'; +import { Game } from '../src/game/game.ts'; +import { headlessShell } from '../src/engine/shell.ts'; +import { withoutSaving } from '../src/game/storage.ts'; +import { seedWorld } from '../src/game/rng.ts'; +import { CoursePilot, type CourseView } from '../src/game/course-pilot.ts'; +import { DOCK_COMPUTER_RANGE } from '../src/constants/docking-computer.ts'; +import { MASS_LOCK_STATION } from '../src/constants/torus.ts'; +import { check, dismissBriefing, eq } from './harness.ts'; + +console.log('\nthe course pilot, one frame at a time'); + +/** A ship at the origin, nose down −Z, and a station somewhere. */ +const view = (station: THREE.Vector3, over: Partial = {}): CourseView => ({ + course: 'station', + position: new THREE.Vector3(), + quaternion: new THREE.Quaternion(), + pitchRate: 0, + rollRate: 0, + stationPos: station, + dcEngaged: false, + ...over, +}); + +{ + const pilot = new CoursePilot(); + const ahead = pilot.step(view(new THREE.Vector3(0, 0, -50_000)), 1 / 60); + check('a station dead ahead: the throttle opens', ahead.demand?.throttle === 1); + check('...and the pilot asks for the torus', ahead.torus); + check('...and it keeps the ship, rather than hand it over', !ahead.handOver); + + const abeam = new CoursePilot().step(view(new THREE.Vector3(50_000, 0, 0)), 1 / 60); + check('a station abeam: no torus until the nose is round', !abeam.torus); + check('...and the sticks move to bring it round', + (abeam.demand?.rollRate ?? 0) !== 0 || (abeam.demand?.pitchRate ?? 0) !== 0); + + const near = pilot.step(view(new THREE.Vector3(0, 0, -(DOCK_COMPUTER_RANGE - 1))), 1 / 60); + check('inside the docking computer\'s range, the course hands over', near.handOver); + eq('...and asks for no flight of its own', near.demand, null); + check('...and drops the torus', !near.torus); + + const docking = pilot.step(view(new THREE.Vector3(0, 0, -50_000), { dcEngaged: true }), 1 / 60); + check('once the docking computer has the ship, the course asks for nothing', + docking.demand === null && !docking.handOver && !docking.torus); + + const jump = pilot.step(view(new THREE.Vector3(50_000, 0, 0), { course: 'jump', rollRate: 1 }), 1 / 60); + check('the jump course flies on as the ship points: the throttle opens', jump.demand?.throttle === 1); + check('...and the roll dies away', Math.abs(jump.demand?.rollRate ?? 1) < 1); + check('...with no torus', !jump.torus); + + eq('a course with no flight yet asks for nothing', + pilot.step(view(new THREE.Vector3(), { course: 'hermit' }), 1 / 60).demand, null); +} + +console.log('\nthe station course, flown from the witchpoint'); + +/** A commander who arrives at the witchpoint with an empty sky. */ +function arrived(seed: number): Game { + const g = withoutSaving(() => { + seedWorld(seed); + const game = new Game(() => headlessShell()); + dismissBriefing(game); + game.launch(); + game.arriveInSystem(); + return game; + }).value; + g.state.world.clearNpcs(); + return g; +} + +{ + const g = arrived(20_260_911); + const start = g.state.player.position.distanceTo(g.state.world.station.position); + check('the ship starts far outside the station\'s mass lock', start > MASS_LOCK_STATION * 4, + `${Math.round(start)} units`); + g.state.session.course = 'station'; + + let torusSeen = false; + let handOverAt = -1; + let dockedAt = -1; + const dt = 1 / 60; + const limit = 180 / dt; + withoutSaving(() => { + for (let f = 0, at = 0; f < limit; f++) { + g.step(dt, at += dt); + if (g.state.session.torusEngaged) torusSeen = true; + if (handOverAt < 0 && g.state.session.dcEngaged) { + handOverAt = g.state.player.position.distanceTo(g.state.world.station.position); + } + if (g.mode !== 'flight') { dockedAt = f * dt; break; } + } + }); + check('the course ran the torus on the way in', torusSeen); + check('...it handed over inside the docking computer\'s range, with none fitted', + handOverAt > 0 && handOverAt <= DOCK_COMPUTER_RANGE + 50, `${Math.round(handOverAt)} units`); + check('...and the ship docked inside three minutes, with no hand on the stick', + dockedAt > 0 && g.mode === 'docked', `mode ${g.mode}, ${dockedAt.toFixed(1)} s`); + eq('...and the dock ends the visit, so no course is left', g.state.session.course, null); +} + +console.log('\n...and a flight key takes the ship back'); +{ + const g = arrived(20_260_912); + g.state.session.course = 'station'; + for (let f = 0, at = 0; f < 30; f++) g.step(1 / 60, at += 1 / 60); + check('the course holds the ship', g.state.session.course === 'station'); + g.input.press('ArrowUp'); + g.step(1 / 60, 1); + g.input.release('ArrowUp'); + eq('a flight key suspends the course', g.state.session.course, null); +} diff --git a/test/run.ts b/test/run.ts index 13b52e16..5fc2b2d1 100644 --- a/test/run.ts +++ b/test/run.ts @@ -72,6 +72,7 @@ import './bribe.test.ts'; import './bribe-flight.test.ts'; import './prompts.test.ts'; import './courses.test.ts'; +import './course-pilot.test.ts'; import './world.test.ts'; import './docking.test.ts'; import './docking-computer.test.ts'; diff --git a/test/snapshot.test.ts b/test/snapshot.test.ts index ad822ed3..2ca628f3 100644 --- a/test/snapshot.test.ts +++ b/test/snapshot.test.ts @@ -391,6 +391,9 @@ console.log('\nsnapshot round trip'); // waiting their turn (docs/TODO/129). A save taken between the deed and // the line that explains it must still say it on the other side. else if (Array.isArray(v)) session[k] = [{ text: `dirty-${k}`, seconds: (n += 1) }]; + // ...and a field that starts empty, such as the picked course + // (docs/TODO/205 M3). A null left as it was would round-trip for free. + else if (v === null) session[k] = `dirty-${k}`; } const dirty = structuredClone(session); const wireSession = JSON.stringify(serialiseState(session)); From ea9c5f7ba473cea2a73364d83c84da99a6a7d0a7 Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Fri, 11 Sep 2026 22:27:26 +0100 Subject: [PATCH 015/100] docs/TODO/205 M3: the derelict, hermit and star courses, and no ship inside the planet An arrival course flies to a standoff from its target and stops there. The derelict course matches the generation ship's drift beside it. The hermit course arrives slow enough for his trade to open. The star course holds inside the scoop range until the tank is full. Every line goes round the planet at a clearance above its mass lock. The work found a hermit 1,545 units inside the planet. The scatter round the station never checked the planet: 2 of about 2,300 ships over 128 systems appeared inside it. The traffic placement now lifts such a ship out to SPAWN_PLANET_ALTITUDE, and it draws nothing from the seeded stream. The spawning test keeps lifted ships out of its scatter band, and checks that nothing sits lower. Measured with the arrival's traffic: 20 of 20 hermit trips, 20 of 20 derelict trips and 40 of 40 star trips arrived. The cabin peaked at 0.489. 5,694 assertions, from 5,676. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- docs/ARCHITECTURE.md | 4 + ...the-ship-goes-and-the-ship-flies-itself.md | 33 ++++ src/constants/CATALOG.md | 27 ++- src/constants/commander.ts | 8 +- src/constants/course.ts | 103 +++++++++++ src/constants/spawn-placement.ts | 19 ++ src/game/course-pilot.ts | 174 ++++++++++++++++-- src/game/flight-instruments.ts | 38 +++- src/game/spawning.ts | 46 +++-- test/constants.test.ts | 8 + test/course-pilot.test.ts | 146 ++++++++++++++- test/spawning.test.ts | 12 +- 12 files changed, 572 insertions(+), 46 deletions(-) diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md index f066220b..384f2e83 100644 --- a/docs/ARCHITECTURE.md +++ b/docs/ARCHITECTURE.md @@ -38,6 +38,10 @@ rules. This file is a map. station or a skim of the star. It follows the shape of `prompts.ts`: a flat view in, a ranked list out, and no key. The list is derived state. The code saves the course that the pilot picks, and never the list. + `course-pilot.ts` flies the picked course, one frame at a time, and it + reports a `FlightDemand`. `flight-instruments.ts` throws the switches that a + course asks for: the torus drive, the hand-over to the docking computer, and + the end of the course. - The console is one line, so `SessionState.queued` is the line that waits for it (`session.ts`). Some consequences make sense only after their cause: what a scan cost your legal record, or what a deed cost your reputation. The console diff --git a/docs/TODO/205-the-pilot-picks-where-the-ship-goes-and-the-ship-flies-itself.md b/docs/TODO/205-the-pilot-picks-where-the-ship-goes-and-the-ship-flies-itself.md index 6a8898dd..a60fdfdb 100644 --- a/docs/TODO/205-the-pilot-picks-where-the-ship-goes-and-the-ship-flies-itself.md +++ b/docs/TODO/205-the-pilot-picks-where-the-ship-goes-and-the-ship-flies-itself.md @@ -342,3 +342,36 @@ Evidence: **The step is cheap.** With no graphics, the world step ran about 2,000 times faster than real time on the development Mac, over 5 trips and over 10. So a skip at eight times speed costs little. That number led to M7. + +### M3, second commit: the derelict, the hermit and the star + +- **An arrival flies to a standoff and stops there.** The speed follows the + distance that is left. The torus drops 8,000 units short. +- **Every line goes round the planet.** A launch, the star and a rock far out + have no promise that the planet is out of the way. A line that dips below + 5,000 units of height aims beside the planet instead. +- **The detour at first trapped a ship.** A hermit sat low over the planet, so + the line to it always counted as blocked. The ship circled the detour point. + The rule now ignores a line whose nearest point to the planet is the target. +- **A HERMIT CAN APPEAR INSIDE THE PLANET, and one did.** The scatter round the + station never checks the planet. Over 128 systems, at arrival and at launch, + 2 of about 2,300 ships appeared inside it: a hermit and a police ship. The + hermit course then flew the ship into the ground. The traffic placement in + `spawning.ts` now lifts such a ship out to `SPAWN_PLANET_ALTITUDE`, which is + 1,000 units. The lift draws nothing from the seeded stream. After the fix, + the same count found none. The rule first went into `World.spawn`. Four + combat tests put a ship at the origin, where the planet sits, and the lift + moved them. So the rule lives where the traffic is placed. +- **The derelict drifts at 25 u/s.** A course that asked for a stop beside it + trailed it at 19 u/s and never arrived. The arrival now matches the target's + own speed. +- **The measurements, with the arrival's own traffic in the sky:** + +| course | sample | arrived | time, median | worst | +| --- | --- | --- | --- | --- | +| the hermit | 10 / 20 systems | 10 / 20 | 119 / 114 s | 161 s | +| the derelict | 10 / 20 systems | 10 / 20 | 26 / 25 s | 32 s | +| the star | 15 / 40 systems | 15 / 40 | 112 / 105 s | 131 s | + + On the star course, the cabin peaked at 0.489 in every sample, against a + fatal 0.99. No ship came within 68,000 units of the star. diff --git a/src/constants/CATALOG.md b/src/constants/CATALOG.md index 0b0dad45..16b81482 100644 --- a/src/constants/CATALOG.md +++ b/src/constants/CATALOG.md @@ -2,7 +2,7 @@ -424 exported constants. Regenerate with `npm run generate:constants`; +433 exported constants. Regenerate with `npm run generate:constants`; search names, meanings and values with `npm run constants:find -- ""`. | Domain | Symbol | Literal / expression | Purpose | Rule ID | Source | @@ -88,13 +88,13 @@ search names, meanings and values with `npm run constants:find -- ""`. | combat-record | SIM_LOG_LIMIT | 20 | How many exercise records the in-memory ring keeps. | combatrecord.simLogLimit | [combat-record.ts:50](./combat-record.ts#L50) | | combat-record | MAX_SAMPLES | 12_000 | Samples kept before the buffer closes. | record.maxSamples | [combat-record.ts:63](./combat-record.ts#L63) | | commander | DEFAULT_NAME | 'JAMESON' | The original's own commander, and the default here. | | [commander.ts:10](./commander.ts#L10) | -| commander | STARTING_CREDITS | 1000 | The grubstake, in tenths of a credit — the classic 100.0 Cr. | | [commander.ts:14](./commander.ts#L14) | -| commander | CHEAT_CREDIT_GRANT | 100_000 | What test mode's GRANT CREDITS row hands over per press, in tenths: 10,000 Cr, which is a hundred grubstakes (`game/screens/test-mode.ts`). | | [commander.ts:36](./commander.ts#L36) | -| commander | MAX_FUEL | 70 | The tank, in tenths of a light year — the classic 7.0 LY range. | | [commander.ts:45](./commander.ts#L45) | -| commander | MAX_MISSILES | 4 | The missile rails: four, as the original's Cobra carried. | commander.maxMissiles | [commander.ts:52](./commander.ts#L52) | -| commander | BRIEFING_VERSION | 1 | Which edition of the docked briefing a commander is up to date with. | onboarding.briefingVersion | [commander.ts:69](./commander.ts#L69) | -| commander | HOLD_TONNES | 20 | What the hold carries, in tonnes, without and with the Large Cargo Bay. | commander.holdTonnes | [commander.ts:81](./commander.ts#L81) | -| commander | LARGE_BAY_TONNES | 35 | | | [commander.ts:82](./commander.ts#L82) | +| commander | STARTING_CREDITS | 1000 | The grubstake, in tenths of a credit — the classic 100.0 Cr. | commander.startingCredits | [commander.ts:18](./commander.ts#L18) | +| commander | CHEAT_CREDIT_GRANT | 100_000 | What test mode's GRANT CREDITS row hands over per press, in tenths: 10,000 Cr, which is a hundred grubstakes (`game/screens/test-mode.ts`). | | [commander.ts:40](./commander.ts#L40) | +| commander | MAX_FUEL | 70 | The tank, in tenths of a light year — the classic 7.0 LY range. | | [commander.ts:49](./commander.ts#L49) | +| commander | MAX_MISSILES | 4 | The missile rails: four, as the original's Cobra carried. | commander.maxMissiles | [commander.ts:56](./commander.ts#L56) | +| commander | BRIEFING_VERSION | 1 | Which edition of the docked briefing a commander is up to date with. | onboarding.briefingVersion | [commander.ts:73](./commander.ts#L73) | +| commander | HOLD_TONNES | 20 | What the hold carries, in tonnes, without and with the Large Cargo Bay. | commander.holdTonnes | [commander.ts:85](./commander.ts#L85) | +| commander | LARGE_BAY_TONNES | 35 | | | [commander.ts:86](./commander.ts#L86) | | commodities | ORDINARY_GOODS | [0, 1, 4, 8, 9, 12] | Ordinary goods: the unremarkable legal cargo that plain trade is made of — food, textiles, liquor, machinery, alloys, minerals. | | [commodities.ts:19](./commodities.ts#L19) | | commodities | ALIEN_ITEMS | 16 | Alien Items: the row a dead Thargon is scooped as (docs/TODO/196). | commodities.alienItems | [commodities.ts:36](./commodities.ts#L36) | | commodities | SLAVES | 3 | Slaves: the row that a rescued survivor is sold on, and the only commodity index named on its own (docs/TODO/127). | commodities.slaves | [commodities.ts:55](./commodities.ts#L55) | @@ -114,7 +114,15 @@ search names, meanings and values with `npm run constants:find -- ""`. | contracts | CONTRACT_RANGE | MAX_FUEL | How far away a contract may send you, in tenths of a light year: exactly as far as a full tank reaches. | | [contracts.ts:27](./contracts.ts#L27) | | contracts | PASSENGER_BERTH_TONNES | 2 | What one passenger costs the hold, in tonnes. | contracts.passengerBerthTonnes | [contracts.ts:51](./contracts.ts#L51) | | contracts | SMUGGLE_DELIVERY_NOTORIETY | 0.06 | How loudly a delivered smuggling run is talked about, per tonne landed. | contracts.smuggleDeliveryNotoriety | [contracts.ts:81](./contracts.ts#L81) | -| course | COURSE_TORUS_CONE | 0.1 | How far off the nose the target may sit, in radians, before the course pilot engages the torus drive. | course.torusCone | [course.ts:26](./course.ts#L26) | +| course | COURSE_TORUS_CONE | 0.1 | How far off the nose the target may sit, in radians, before the course pilot engages the torus drive. | course.torusCone | [course.ts:31](./course.ts#L31) | +| course | COURSE_TORUS_DROP | TORUS_MULTIPLIER * PLAYER_FLIGHT.maxSpeed * 2.5 | How far from its target the course pilot drops the torus drive, in world units, before an arrival. | | [course.ts:44](./course.ts#L44) | +| course | COURSE_ARRIVE_BRAKE | 0.7 | The share of the ship's thrust that an arrival plans to brake with. | course.arriveBrake | [course.ts:56](./course.ts#L56) | +| course | COURSE_ARRIVE_TOLERANCE | 75 | How near its standoff the ship must be to count as arrived, in world units. | course.arriveTolerance | [course.ts:66](./course.ts#L66) | +| course | COURSE_DERELICT_STANDOFF | GENERATION_CARGO_SCATTER + 400 | Where the derelict course stops, as a distance from the generation ship's centre, in world units. | | [course.ts:79](./course.ts#L79) | +| course | COURSE_HERMIT_STANDOFF | 240 | Where the hermit course stops, as a distance from the rock's centre, in world units. | course.hermitStandoff | [course.ts:92](./course.ts#L92) | +| course | COURSE_SKIM_DISTANCE | 65_000 | The hold distance of the skim course, from the centre of the star, in world units. | course.skimDistance | [course.ts:107](./course.ts#L107) | +| course | COURSE_PLANET_CLEARANCE | MASS_LOCK_PLANET_ALTITUDE * 1.25 | How high above the planet's surface a course keeps its line, in world units. | | [course.ts:119](./course.ts#L119) | +| course | COURSE_HERMIT_SPEED | HERMIT_DOCK_SPEED / 2 | The speed at which the hermit course arrives, in world units a second. | | [course.ts:129](./course.ts#L129) | | docking | GATE_HALF_WIDTHS | 5 | How far out the approach gate sits, in multiples of the station half-width. | docking.gateHalfWidths | [docking.ts:25](./docking.ts#L25) | | docking | TURN_IN | Math.PI / 4 | How far round from the slot axis an approach turns in, in radians. | | [docking.ts:49](./docking.ts#L49) | | docking | RUN_IN_WIDTHS | GATE_HALF_WIDTHS * 0.6 | Where the approach stops the curve and flies straight, in station half-widths. | | [docking.ts:87](./docking.ts#L87) | @@ -358,6 +366,7 @@ search names, meanings and values with `npm run constants:find -- ""`. | spawn-placement | STATION_DEFENCE_JITTER | 80 | ...and the random nudge on each, so a second launch does not look like the first. | | [spawn-placement.ts:293](./spawn-placement.ts#L293) | | spawn-placement | TRADER_ARRIVED | 900 | How near the station an arriving trader has to be to start trading. | spawn.traderArrived | [spawn-placement.ts:308](./spawn-placement.ts#L308) | | spawn-placement | TRADER_JUMP_OUT | 2500 | How near its waypoint a departing trader has to be to jump out. | spawn.traderJumpOut | [spawn-placement.ts:324](./spawn-placement.ts#L324) | +| spawn-placement | SPAWN_PLANET_ALTITUDE | 1000 | The lowest a ship may appear above the planet's surface, measured to the ship's centre, in world units. | spawn.planetAltitude | [spawn-placement.ts:343](./spawn-placement.ts#L343) | | station | STATION_SPIN | 0.26 | How fast the station spins about its slot axis, in radians a second. | | [station.ts:19](./station.ts#L19) | | station | DODO_TECH_LEVEL | 10 | The tech level at which a system's station is the dodecahedral Dodo rather than the Coriolis, in SHOWN one-based units. | | [station.ts:32](./station.ts#L32) | | station | BOUNCE_STANDOFF | 420 | Where a fluffed docking bounces you to. | | [station.ts:48](./station.ts#L48) | diff --git a/src/constants/commander.ts b/src/constants/commander.ts index 925b5e4f..ce7e7147 100644 --- a/src/constants/commander.ts +++ b/src/constants/commander.ts @@ -9,8 +9,12 @@ * every career under it, and the save screens fall back to it. */ export const DEFAULT_NAME = 'JAMESON'; -/** The grubstake, in tenths of a credit — the classic 100.0 Cr. The briefing - * interpolates this, so its prose cannot drift from the credits you get. */ +/** + * The grubstake, in tenths of a credit — the classic 100.0 Cr. The briefing + * interpolates this, so its prose cannot drift from the credits you get. + * + * @rule commander.startingCredits + */ export const STARTING_CREDITS = 1000; /** diff --git a/src/constants/course.ts b/src/constants/course.ts index b4ce5ece..87b3238b 100644 --- a/src/constants/course.ts +++ b/src/constants/course.ts @@ -3,6 +3,11 @@ // A course is one thing the ship does next with no hand on the stick. // `game/course-pilot.ts` flies it, and it spends these values. +import { HERMIT_DOCK_SPEED } from './hermit-market.ts'; +import { PLAYER_FLIGHT } from './player-flight.ts'; +import { MASS_LOCK_PLANET_ALTITUDE, TORUS_MULTIPLIER } from './torus.ts'; +import { GENERATION_CARGO_SCATTER } from './spawn-placement.ts'; + /** * How far off the nose the target may sit, in radians, before the course * pilot engages the torus drive. @@ -24,3 +29,101 @@ * @domain course */ export const COURSE_TORUS_CONE = 0.1; + +/** + * How far from its target the course pilot drops the torus drive, in world + * units, before an arrival. + * + * It is two and a half seconds of torus travel. The drive carries the ship + * 3,200 units a second, which is 53 units in one frame. The ship then brakes + * from its top speed of 400, which takes about 360 units at full thrust. So + * the margin covers both, with room to spare, and it grows with the drive. + * + * @domain course + */ +export const COURSE_TORUS_DROP = TORUS_MULTIPLIER * PLAYER_FLIGHT.maxSpeed * 2.5; + +/** + * The share of the ship's thrust that an arrival plans to brake with. + * + * The approach asks for the speed from which this share of thrust stops the + * ship at the standoff. The rest is a margin for the turn and for one frame + * of lag in the throttle. + * + * @rule course.arriveBrake + * @domain course + */ +export const COURSE_ARRIVE_BRAKE = 0.7; + +/** + * How near its standoff the ship must be to count as arrived, in world units. + * The brake plan leaves the ship within a few units of the standoff. This is + * room for the turn, and for a target that moves. + * + * @rule course.arriveTolerance + * @domain course + */ +export const COURSE_ARRIVE_TOLERANCE = 75; + +/** + * Where the derelict course stops, as a distance from the generation ship's + * centre, in world units. + * + * The hull is 340 units across the radius (`GENERATION_SHIP_RADIUS`). Its + * canisters drift within `GENERATION_CARGO_SCATTER` of the centre. So the ship + * stops 400 units outside the canisters, clear of the hull and of every + * canister, where the pilot can see them all. + * + * @domain course + */ +export const COURSE_DERELICT_STANDOFF = GENERATION_CARGO_SCATTER + 400; + +/** + * Where the hermit course stops, as a distance from the rock's centre, in + * world units. + * + * The trade opens inside `HERMIT_DOCK_RANGE`, which is 320. The rock is 120 + * units across the radius. So the ship stops between the two, clear of the + * rock and inside the range. + * + * @rule course.hermitStandoff + * @domain course + */ +export const COURSE_HERMIT_STANDOFF = 240; + +/** + * The hold distance of the skim course, from the centre of the star, in world + * units. + * + * The scoops take fuel inside `SUN_SCOOP_RANGE`, which is 80,000. The cabin + * heads toward a temperature set by the distance. It is fatal at + * `CABIN_TEMP_FATAL`, which is reached near 26,800 units. At this distance + * the cabin settles near 0.54, well short of fatal. The margin inside the + * scoop range keeps an overshoot of the brake inside it too. + * + * @rule course.skimDistance + * @domain course + */ +export const COURSE_SKIM_DISTANCE = 65_000; + +/** + * How high above the planet's surface a course keeps its line, in world + * units. + * + * It is a quarter above `MASS_LOCK_PLANET_ALTITUDE`, so the detour does not + * hold the torus drive down. A line to the target that dips below it goes + * round the planet instead. + * + * @domain course + */ +export const COURSE_PLANET_CLEARANCE = MASS_LOCK_PLANET_ALTITUDE * 1.25; + +/** + * The speed at which the hermit course arrives, in world units a second. + * + * The trade opens only below `HERMIT_DOCK_SPEED`. Half of it arrives well + * inside that rule, and it is still a real approach. + * + * @domain course + */ +export const COURSE_HERMIT_SPEED = HERMIT_DOCK_SPEED / 2; diff --git a/src/constants/spawn-placement.ts b/src/constants/spawn-placement.ts index 20be1f1e..4fcbfca4 100644 --- a/src/constants/spawn-placement.ts +++ b/src/constants/spawn-placement.ts @@ -322,3 +322,22 @@ export const TRADER_ARRIVED = 900; * @domain spawn-placement */ export const TRADER_JUMP_OUT = 2500; + +/** + * The lowest a ship may appear above the planet's surface, measured to the + * ship's centre, in world units. + * + * The scatter round the station has no idea where the planet is. So a hermit + * or a police ship could appear inside it: docs/TODO/205 M3 counted two of + * about 2,300 ships over 128 systems. A ship inside the planet then crashed + * into it the moment it moved. `aboveGround` in `game/spawning.ts` lifts such + * a ship straight out from the planet's centre to this height. The lift draws + * nothing from the seeded stream, so no other outcome moves. + * + * It is far above `PLANET_CRASH_ALTITUDE`, and above the largest hull that + * appears near the station. + * + * @rule spawn.planetAltitude + * @domain spawn-placement + */ +export const SPAWN_PLANET_ALTITUDE = 1000; diff --git a/src/game/course-pilot.ts b/src/game/course-pilot.ts index fb3202dc..64f78ba2 100644 --- a/src/game/course-pilot.ts +++ b/src/game/course-pilot.ts @@ -6,9 +6,9 @@ // pair of hands makes, and `PlayerShip.update` flies it. // // It APPLIES nothing. The switches are `flight-instruments.ts`'s: the torus -// drive, and the hand-over to the docking computer. A step asks for them, and -// the instruments throw them. It draws nothing from the seeded stream, so it -// has no order to preserve. +// drive, the hand-over to the docking computer, and the end of a course. A +// step asks for them, and the instruments throw them. It draws nothing from +// the seeded stream, so it has no order to preserve. // // THE STEERING IS THE CO-PILOT'S. `bankToTurn` in `pitch-roll-steer.ts` points // the nose with pitch and roll alone, at the commander's own caps and ramp. @@ -18,11 +18,19 @@ // restore that starts it fresh costs one bank at most. The scripted co-pilot // makes the same bargain. // -// Two courses fly today. The station course points at the station and runs -// the torus until the mass lock. It then hands the ship to the docking -// computer, at the range where that computer takes a job. The jump course -// flies straight while the countdown runs. The rest wait for their -// milestones, and a course with no flight yet returns no demand. +// THREE SHAPES OF COURSE fly today: +// +// - the station course points at the station and runs the torus. Inside the +// docking computer's range it hands the ship over; +// - an ARRIVAL flies to a standoff from a target and stops there. The +// derelict, the hermit and the star are arrivals. The star course then +// holds until the tank is full; +// - the jump course flies straight while the countdown runs. +// +// EVERY LINE GOES ROUND THE PLANET. A line that dips below the clearance +// altitude aims at a point beside the planet instead, until the line clears. +// The arrival at the witchpoint already sits on the station's side of the +// planet. A launch, the star and a rock far out have no such promise. import * as THREE from 'three'; import { rampFlightRate, type FlightDemand } from '../player.ts'; @@ -30,7 +38,11 @@ import { bankToTurn, freshSteerMemory, type SteerMemory } from './pitch-roll-ste import type { CourseKind } from './courses.ts'; import { PLAYER_FLIGHT } from '../constants/player-flight.ts'; import { DOCK_COMPUTER_RANGE } from '../constants/docking-computer.ts'; -import { COURSE_TORUS_CONE } from '../constants/course.ts'; +import { + COURSE_ARRIVE_BRAKE, COURSE_ARRIVE_TOLERANCE, COURSE_DERELICT_STANDOFF, + COURSE_HERMIT_SPEED, COURSE_HERMIT_STANDOFF, COURSE_PLANET_CLEARANCE, + COURSE_SKIM_DISTANCE, COURSE_TORUS_CONE, COURSE_TORUS_DROP, +} from '../constants/course.ts'; /** What the course pilot reads for one frame. A flat view, so a test needs no world. */ export interface CourseView { @@ -39,7 +51,19 @@ export interface CourseView { readonly quaternion: THREE.Quaternion; readonly pitchRate: number; readonly rollRate: number; + readonly speed: number; readonly stationPos: THREE.Vector3; + readonly planetPos: THREE.Vector3; + readonly planetRadius: number; + readonly sunPos: THREE.Vector3; + /** the live generation ship, or null for none */ + readonly derelictPos: THREE.Vector3 | null; + /** how fast the generation ship drifts, because the course matches it */ + readonly derelictSpeed: number; + /** the live rock hermit, or null for none */ + readonly hermitPos: THREE.Vector3 | null; + /** the tank holds all it can */ + readonly tankFull: boolean; /** the docking computer already has the ship */ readonly dcEngaged: boolean; } @@ -52,22 +76,55 @@ export interface CourseStep { readonly torus: boolean; /** hand the ship to the docking computer now */ readonly handOver: boolean; + /** the course is finished, and it leaves the ship */ + readonly done: boolean; } -const IDLE: CourseStep = { demand: null, torus: false, handOver: false }; +const IDLE: CourseStep = { demand: null, torus: false, handOver: false, done: false }; + +/** + * One arrival: where it goes, how far out it stops, and how fast it arrives. + * + * A target that moves sets the arrival speed to its own. The generation ship + * drifts at 25 u/s. A course that asked for a stop beside it trailed it at + * about 19 u/s for ever, and never counted as arrived (docs/TODO/205 M3). + */ +interface Arrival { + readonly target: THREE.Vector3; + readonly standoff: number; + readonly speed: number; +} export class CoursePilot { private mem: SteerMemory = freshSteerMemory(); private readonly dir = new THREE.Vector3(); private readonly fwd = new THREE.Vector3(); + private readonly aim = new THREE.Vector3(); /** Forget the bank, for a new course. */ reset(): void { this.mem = freshSteerMemory(); } step(v: CourseView, dt: number): CourseStep { - if (v.course === 'station') return this.toStation(v, dt); - if (v.course === 'jump') return { demand: straight(v, dt), torus: false, handOver: false }; - return IDLE; + switch (v.course) { + case 'station': return this.toStation(v, dt); + case 'jump': return { demand: straight(v, dt), torus: false, handOver: false, done: false }; + case 'derelict': + return v.derelictPos === null ? ended() + : this.arrive(v, { + target: v.derelictPos, standoff: COURSE_DERELICT_STANDOFF, speed: v.derelictSpeed, + }, dt); + case 'hermit': + return v.hermitPos === null ? ended() + : this.arrive(v, { target: v.hermitPos, standoff: COURSE_HERMIT_STANDOFF, speed: COURSE_HERMIT_SPEED }, dt); + case 'skim': { + if (v.tankFull) return ended(); + const s = this.arrive(v, { target: v.sunPos, standoff: COURSE_SKIM_DISTANCE, speed: 0 }, dt); + // An arrival at the star is not the end. The ship holds there, and the + // scoops work, until the tank is full. + return { ...s, done: false }; + } + default: return IDLE; + } } /** @@ -77,28 +134,61 @@ export class CoursePilot { */ private toStation(v: CourseView, dt: number): CourseStep { if (v.dcEngaged) return IDLE; - this.dir.subVectors(v.stationPos, v.position); - if (this.dir.length() <= DOCK_COMPUTER_RANGE) { - return { demand: null, torus: false, handOver: true }; + if (v.position.distanceTo(v.stationPos) <= DOCK_COMPUTER_RANGE) { + return { demand: null, torus: false, handOver: true, done: false }; + } + const aim = clearOfPlanet(v.position, v.stationPos, v.planetPos, v.planetRadius, this.aim); + return { ...this.pointAt(v, aim, 1, dt), handOver: false, done: false }; + } + + /** + * Fly to a standoff from a target, and stop there. + * + * The speed follows the distance that is left. It is the speed from which + * `COURSE_ARRIVE_BRAKE` of the ship's thrust stops the ship at the standoff, + * plus the speed the arrival asks for. The torus runs until + * `COURSE_TORUS_DROP` is left, and only while the nose is on the line. + */ + private arrive(v: CourseView, a: Arrival, dt: number): CourseStep { + const left = v.position.distanceTo(a.target) - a.standoff; + if (Math.abs(left) <= COURSE_ARRIVE_TOLERANCE && v.speed <= a.speed + PLAYER_FLIGHT.accel * dt) { + return { demand: hold(v, dt), torus: false, handOver: false, done: true }; } + const wanted = Math.min(PLAYER_FLIGHT.maxSpeed, + a.speed + Math.sqrt(2 * COURSE_ARRIVE_BRAKE * PLAYER_FLIGHT.accel * Math.max(0, left))); + const band = PLAYER_FLIGHT.accel * dt; + const throttle = v.speed < wanted - band ? 1 : v.speed > wanted + band ? -1 : 0; + const aim = clearOfPlanet(v.position, a.target, v.planetPos, v.planetRadius, this.aim); + const p = this.pointAt(v, aim, throttle, dt); + return { ...p, torus: p.torus && left > COURSE_TORUS_DROP, handOver: false, done: false }; + } + + /** Bank and pull the nose onto a point, with this throttle. */ + private pointAt( + v: CourseView, point: THREE.Vector3, throttle: number, dt: number, + ): { demand: FlightDemand; torus: boolean } { + this.dir.subVectors(point, v.position); const stick = bankToTurn(v.quaternion, this.dir, this.mem); this.fwd.set(0, 0, -1).applyQuaternion(v.quaternion); - const offNose = this.fwd.angleTo(this.dir); return { demand: { pitchRate: rampFlightRate( v.pitchRate, stick.pitch * PLAYER_FLIGHT.maxPitch, stick.pitch !== 0, dt), rollRate: rampFlightRate( v.rollRate, stick.roll * PLAYER_FLIGHT.maxRoll, stick.roll !== 0, dt), - throttle: 1, + throttle, fire: false, }, - torus: offNose < COURSE_TORUS_CONE, - handOver: false, + torus: this.fwd.angleTo(this.dir) < COURSE_TORUS_CONE, }; } } +/** The course has nothing left to do: its target is gone, or its work is done. */ +function ended(): CourseStep { + return { demand: null, torus: false, handOver: false, done: true }; +} + /** Level the sticks and open the throttle: the ship flies on as it points. */ function straight(v: CourseView, dt: number): FlightDemand { return { @@ -108,3 +198,47 @@ function straight(v: CourseView, dt: number): FlightDemand { fire: false, }; } + +/** Level the sticks and brake to a stop. */ +function hold(v: CourseView, dt: number): FlightDemand { + return { ...straight(v, dt), throttle: v.speed > PLAYER_FLIGHT.accel * dt ? -1 : 0 }; +} + +const seg = new THREE.Vector3(); +const off = new THREE.Vector3(); + +/** + * Where to aim, so that the line to the target clears the planet. + * + * It finds the nearest point of the line to the planet's centre. That point + * can be below `COURSE_PLANET_CLEARANCE`. Then it aims beside the planet, on + * the same side as the line, and half as high again. The line from there + * clears the planet, and the ship then turns onto the target. + * + * A target that is itself the nearest point needs no detour. docs/TODO/205 M3 + * found a hermit low over the planet. The line to it always counted as + * blocked, and the ship circled the detour point for ever. + * + * @returns `out`, holding the point to aim at. + */ +export function clearOfPlanet( + from: THREE.Vector3, to: THREE.Vector3, planet: THREE.Vector3, radius: number, + out: THREE.Vector3, +): THREE.Vector3 { + seg.subVectors(to, from); + const len2 = seg.lengthSq(); + const t = len2 > 0 ? Math.max(0, Math.min(1, off.subVectors(planet, from).dot(seg) / len2)) : 0; + // The nearest point is the target itself: the planet is not between. A + // target low over the planet is still reached, because the last of the + // line runs down to it rather than through the planet. + if (t >= 1) return out.copy(to); + off.copy(from).addScaledVector(seg, t).sub(planet); + const clear = radius + COURSE_PLANET_CLEARANCE; + if (off.length() >= clear) return out.copy(to); + // A line through the centre has no side. Any direction square to it will do. + if (off.lengthSq() < 1e-6) { + off.set(seg.y, -seg.x, 0); + if (off.lengthSq() < 1e-6) off.set(0, seg.z, -seg.y); + } + return out.copy(planet).addScaledVector(off.normalize(), radius + COURSE_PLANET_CLEARANCE * 1.5); +} diff --git a/src/game/flight-instruments.ts b/src/game/flight-instruments.ts index 51a05a77..b8b59654 100644 --- a/src/game/flight-instruments.ts +++ b/src/game/flight-instruments.ts @@ -22,6 +22,17 @@ import { sfx } from '../audio.ts'; import { Autopilot, type AutopilotEvent } from './autopilot.ts'; import { CoursePilot } from './course-pilot.ts'; +import type { CourseKind } from './courses.ts'; +import { MAX_FUEL } from '../constants/commander.ts'; + +/** + * What the console says when a course finishes its work. The hermit course + * says nothing, because the hermit's own trade screen opens on arrival. + */ +const COURSE_ENDS: Partial> = { + derelict: 'HOLDING BESIDE THE DERELICT', + skim: 'TANK FULL — SKIM COMPLETE', +}; import { massLocked } from './world-step.ts'; import { boundKey } from '../ui/key-help.ts'; import { defenceBrain } from './brains.ts'; @@ -125,20 +136,45 @@ export class Instruments { return null; } const p = this.state.player; + const w = this.state.world; + const live = (role: string) => w.npcs.find((n) => n.state.alive && n.role === role) ?? null; + const derelict = live('generation'); const step = this.coursePilot.step({ course: s.course, position: p.position, quaternion: p.quaternion, pitchRate: p.pitchRate, rollRate: p.rollRate, - stationPos: this.state.world.station.position, + speed: p.speed, + stationPos: w.station.position, + planetPos: w.planetPos, + planetRadius: w.planetRadius, + sunPos: w.sunPos, + derelictPos: derelict?.object.position ?? null, + derelictSpeed: derelict?.state.speed ?? 0, + hermitPos: live('hermit')?.object.position ?? null, + tankFull: this.state.commander.fuel >= MAX_FUEL, dcEngaged: s.dcEngaged, }, dt); if (step.handOver) this.applyAutopilot(this.autopilot.handOverToDock()); if (step.torus !== s.torusEngaged && (!step.torus || !this.massLocked())) this.toggleTorus(); + if (step.done) this.endCourse(s.course); return step.demand; } + /** + * A course finished its work. It leaves the ship, and it leaves the list + * for the rest of the visit. The console says what the ship did. + */ + private endCourse(kind: CourseKind): void { + const s = this.state.session; + s.course = null; + if (!s.coursesDone.includes(kind)) s.coursesDone.push(kind); + this.coursePilot.reset(); + const said = COURSE_ENDS[kind]; + if (said) this.host.showMessage(said, 3); + } + /** A hit worth a break: the co-pilot keeps its own record * (scripted-co-pilot.ts). */ noteUnderFire(): void { this.autopilot.noteUnderFire(); } diff --git a/src/game/spawning.ts b/src/game/spawning.ts index 5e067c31..7a0cf308 100644 --- a/src/game/spawning.ts +++ b/src/game/spawning.ts @@ -20,7 +20,8 @@ import type { World } from './world.ts'; import type { PopulationPlan } from './population.ts'; import type { NpcShip } from './npc.ts'; import { steerQuatToward } from './flight-maths.ts'; -import { pirateSpecForTier, specForDesign } from './ship-specs.ts'; +import { pirateSpecForTier, specForDesign, type NpcSpec } from './ship-specs.ts'; +import type { NpcRole } from './ship-roles.ts'; import type { TaggedItem, TaggedShip } from '../missions/model.ts'; import { memberTier } from './threat.ts'; import { slotNormal } from '../world/slot.ts'; @@ -34,7 +35,7 @@ import { MISSION_TARGET_RANGE, MISSION_TARGET_RANGE_SPAN, PIRATE_SCATTER, POLICE_PATROL_RANGE, POLICE_SCATTER, STATION_DEFENCE_JITTER, STATION_DEFENCE_MIN, STATION_DEFENCE_SPAN, - STATION_DEFENCE_STACK, STATION_DEFENCE_STANDOFF, TRADER_SCATTER, + SPAWN_PLANET_ALTITUDE, STATION_DEFENCE_STACK, STATION_DEFENCE_STANDOFF, TRADER_SCATTER, } from '../constants/spawn-placement.ts'; /** A random offset of up to `range`, biased outward. */ @@ -75,6 +76,26 @@ export interface SpawnResult { * @param playerPos where the commander is — the reception is scattered along * the corridor between them and the station, not dumped on top of them. */ +/** + * Where a ship of the traffic may appear. It is the asked position, unless + * that position is below `SPAWN_PLANET_ALTITUDE`. Then it is the same line + * from the planet's centre, at that height. + * + * The scatter round the station has no idea where the planet is. + * docs/TODO/205 M3 counted 2 ships of about 2,300 inside the planet, over 128 + * systems: a hermit and a police ship. A course then flew the ship into the + * ground after the hermit. The lift draws nothing from the seeded stream, so + * no other outcome moves. It returns a new vector. + */ +export function aboveGround(world: World, position: THREE.Vector3): THREE.Vector3 { + const at = position.clone(); + const lowest = world.planetRadius + SPAWN_PLANET_ALTITUDE; + const up = at.clone().sub(world.planetPos); + if (up.length() >= lowest) return at; + if (up.lengthSq() < 1e-6) up.set(0, 1, 0); + return at.copy(world.planetPos).addScaledVector(up.normalize(), lowest); +} + export function spawnPopulation( world: World, plan: PopulationPlan, @@ -86,6 +107,9 @@ export function spawnPopulation( ): SpawnResult { const home = world.station.position; const arriving = situation === 'arrival'; + // Every ship of the traffic appears above the ground (docs/TODO/205 M3). + const place = (role: NpcRole, pos: THREE.Vector3, seed: number, spec?: NpcSpec): NpcShip => + world.spawn(role, aboveGround(world, pos), seed, spec); // The lane the commander flies in on. A point `spread` off it, `CORRIDOR_START` // to `CORRIDOR_START + CORRIDOR_SPAN` of the way from the witchpoint to the @@ -105,10 +129,10 @@ export function spawnPopulation( // a pirate has somebody to prey on. The `arriving` phase steers them to the // station on its own (`stepTrader`, game/trader-flight.ts). if (arriving && i % 2 === 0) { - const trader = world.spawn('trader', corridorPos(TRADER_SCATTER), i + sys.index); + const trader = place('trader', corridorPos(TRADER_SCATTER), i + sys.index); trader.state.traderPhase = 'arriving'; } else { - world.spawn('trader', home.clone().add(scatter(TRADER_SCATTER)), i + sys.index); + place('trader', home.clone().add(scatter(TRADER_SCATTER)), i + sys.index); } } for (let i = 0; i < plan.police; i++) { @@ -116,7 +140,7 @@ export function spawnPopulation( // Scattered across the system for a launch, and never on the slot itself. const pos = arriving ? corridorPos(POLICE_SCATTER) : home.clone().add(scatter(POLICE_PATROL_RANGE)); - world.spawn('police', pos, i); + place('police', pos, i); } for (let i = 0; i < plan.asteroids; i++) { // On an arrival the rocks line the lane the commander flies down, so the run @@ -126,7 +150,7 @@ export function spawnPopulation( // rocks on every visit. const pos = arriving ? corridorPos(ASTEROID_LANE_SCATTER) : home.clone().add(scatter(ASTEROID_SCATTER)); - world.spawn('asteroid', pos, sys.seed[0] + i * 37); + place('asteroid', pos, sys.seed[0] + i * 37); } if (plan.threat && plan.pirates > 0) { @@ -137,17 +161,17 @@ export function spawnPopulation( const tier = memberTier(plan.threat.tier, i); // The tier table is the set's, not the catalogue's. This is the pirate // band, and a system's blueprint set narrows that band (TODO 138). - const npc = world.spawn('pirate', pos, seed, pirateSpecForTier(tier, seed, world.roster)); + const npc = place('pirate', pos, seed, pirateSpecForTier(tier, seed, world.roster)); npc.state.organised = plan.threat.organised; npc.state.threatTier = tier; } } if (plan.hunter) { - world.spawn('hunter', home.clone().add(scatter(HUNTER_SCATTER)), sys.index); + place('hunter', home.clone().add(scatter(HUNTER_SCATTER)), sys.index); } if (plan.hermit) { - world.spawn('hermit', + place('hermit', home.clone().add(scatter(HERMIT_SCATTER).addScaledVector(scatter(1), 2)), sys.index); } @@ -156,7 +180,7 @@ export function spawnPopulation( const pos = playerPos.clone() .add(randomDirection(new THREE.Vector3()) .multiplyScalar(GENERATION_SHIP_RANGE + random() * GENERATION_SHIP_RANGE_SPAN)); - generationShip = world.spawn('generation', pos, 0); + generationShip = place('generation', pos, 0); // steerQuatToward, not lookAt. Object3D.lookAt aims +Z at its target, and a // hull's nose is -Z (invariant 7). So `lookAt(home)` would point the // derelict exactly away from the station. @@ -185,7 +209,7 @@ export function spawnPopulation( const pos = playerPos.clone() .add(randomDirection(new THREE.Vector3()) .multiplyScalar(MISSION_TARGET_RANGE + random() * MISSION_TARGET_RANGE_SPAN)); - const ship = world.spawn(role, pos, 0, spec); + const ship = place(role, pos, 0, spec); ship.state.missionTag = tagged.tag; if (tagged.job === 'escort') ship.state.traderPhase = 'arriving'; // A scan's subject waits until it is scanned (docs/TODO/203 M2). A diff --git a/test/constants.test.ts b/test/constants.test.ts index cb648777..b294b31d 100644 --- a/test/constants.test.ts +++ b/test/constants.test.ts @@ -400,6 +400,14 @@ const OUTSIDE: readonly Group[] = [ }, }, + { + why: 'STAYS: words, not a number. What the console says when a course' + + ' finishes its work (docs/TODO/205 M3), beside the switch that says it', + files: { + 'game/flight-instruments.ts': ['COURSE_ENDS'], + }, + }, + { why: 'STAYS: how the launch/docking tunnel effect LOOKS — the ellipse squash that' + ' reads as a bay mouth, and two fractions of the effect\'s own timeline. Pure' diff --git a/test/course-pilot.test.ts b/test/course-pilot.test.ts index 430e432a..7c14a3bd 100644 --- a/test/course-pilot.test.ts +++ b/test/course-pilot.test.ts @@ -11,7 +11,13 @@ import { Game } from '../src/game/game.ts'; import { headlessShell } from '../src/engine/shell.ts'; import { withoutSaving } from '../src/game/storage.ts'; import { seedWorld } from '../src/game/rng.ts'; -import { CoursePilot, type CourseView } from '../src/game/course-pilot.ts'; +import { CoursePilot, clearOfPlanet, type CourseView } from '../src/game/course-pilot.ts'; +import { COURSE_DERELICT_STANDOFF, COURSE_PLANET_CLEARANCE } from '../src/constants/course.ts'; +import { HERMIT_DOCK_SPEED } from '../src/constants/hermit-market.ts'; +import { CABIN_TEMP_FATAL } from '../src/constants/sun.ts'; +import { MAX_FUEL } from '../src/constants/commander.ts'; +import { SPAWN_PLANET_ALTITUDE } from '../src/constants/spawn-placement.ts'; +import { aboveGround } from '../src/game/spawning.ts'; import { DOCK_COMPUTER_RANGE } from '../src/constants/docking-computer.ts'; import { MASS_LOCK_STATION } from '../src/constants/torus.ts'; import { check, dismissBriefing, eq } from './harness.ts'; @@ -25,7 +31,15 @@ const view = (station: THREE.Vector3, over: Partial = {}): CourseVie quaternion: new THREE.Quaternion(), pitchRate: 0, rollRate: 0, + speed: 0, stationPos: station, + planetPos: new THREE.Vector3(0, 1e7, 0), + planetRadius: 5000, + sunPos: new THREE.Vector3(1e7, 0, 0), + derelictPos: null, + derelictSpeed: 0, + hermitPos: null, + tankFull: false, dcEngaged: false, ...over, }); @@ -56,8 +70,10 @@ const view = (station: THREE.Vector3, over: Partial = {}): CourseVie check('...and the roll dies away', Math.abs(jump.demand?.rollRate ?? 1) < 1); check('...with no torus', !jump.torus); + const gone = pilot.step(view(new THREE.Vector3(), { course: 'hermit' }), 1 / 60); + check('a hermit course with no hermit in the sky ends at once', gone.done && gone.demand === null); eq('a course with no flight yet asks for nothing', - pilot.step(view(new THREE.Vector3(), { course: 'hermit' }), 1 / 60).demand, null); + pilot.step(view(new THREE.Vector3(), { course: 'mine' }), 1 / 60).demand, null); } console.log('\nthe station course, flown from the witchpoint'); @@ -117,3 +133,129 @@ console.log('\n...and a flight key takes the ship back'); g.input.release('ArrowUp'); eq('a flight key suspends the course', g.state.session.course, null); } + +console.log('\nevery line goes round the planet'); +{ + const planet = new THREE.Vector3(0, 0, -50_000); + const out = new THREE.Vector3(); + const to = new THREE.Vector3(0, 0, -100_000); + clearOfPlanet(new THREE.Vector3(), to, planet, 5000, out); + const alt = out.distanceTo(planet) - 5000; + check('a line through the planet aims beside it instead', !out.equals(to)); + check('...above the clearance, so the detour holds no mass lock', + alt > COURSE_PLANET_CLEARANCE, `${Math.round(alt)} units up`); + const clear = new THREE.Vector3(40_000, 0, -100_000); + clearOfPlanet(new THREE.Vector3(40_000, 0, 0), clear, planet, 5000, out); + check('a line that clears the planet aims at the target itself', out.equals(clear)); +} + +/** A commander at the witchpoint of a system whose sky holds this role. */ +function arrivedWith(role: string): Game { + for (let i = 0; i < 200; i++) { + const g = withoutSaving(() => { + seedWorld(4000 + i); + const game = new Game(() => headlessShell()); + dismissBriefing(game); + game.launch(); + game.state.commander.systemIndex = (i * 29) % 256; + game.arriveInSystem(); + return game; + }).value; + if (g.state.world.npcs.some((n) => n.role === role)) { + // Only the target stays, so that no fight or mass lock blurs the claim. + for (const n of g.state.world.npcs) if (n.role !== role) n.state.alive = false; + return g; + } + } + throw new Error(`no system in the sample holds a ${role}`); +} + +/** Fly the picked course until it ends, the ship dies, or the time runs out. */ +function fly(g: Game, seconds: number, until: () => boolean): number { + const dt = 1 / 60; + let f = 0; + withoutSaving(() => { + for (let at = 0; f < seconds / dt; f++) { + g.step(dt, at += dt); + if (until() || g.mode === 'dead') break; + } + }); + return f * dt; +} + +console.log('\nthe derelict course'); +{ + const g = arrivedWith('generation'); + g.state.session.course = 'derelict'; + fly(g, 300, () => g.state.session.course === null); + const gen = g.state.world.npcs.find((n) => n.role === 'generation')!; + const dist = g.state.player.position.distanceTo(gen.object.position); + check('the ship stops at the standoff from the generation ship', + Math.abs(dist - COURSE_DERELICT_STANDOFF) < 200, `${Math.round(dist)} units`); + check('...at the derelict\'s own drift', Math.abs(g.state.player.speed - gen.state.speed) < 10, + `${g.state.player.speed.toFixed(1)} u/s against ${gen.state.speed.toFixed(1)}`); + check('...and the course is done for the visit', g.state.session.coursesDone.includes('derelict')); +} + +console.log('\nthe hermit course'); +{ + const g = arrivedWith('hermit'); + g.state.session.course = 'hermit'; + fly(g, 400, () => g.state.session.hermitTrading); + check('the hermit opens his trade at the end of the course', g.state.session.hermitTrading); + check('...with the ship slow enough for the hermit\'s rule', + g.state.player.speed < HERMIT_DOCK_SPEED, `${g.state.player.speed.toFixed(1)} u/s`); + check('...and the ship never struck the rock', g.state.sys.foreShield > 0 && g.mode !== 'dead'); +} + +console.log('\nthe star course'); +{ + const g = arrived(20_260_913); + g.state.commander.equipment.scoops = true; + g.state.commander.fuel = 5; + g.state.session.course = 'skim'; + let peak = 0; + fly(g, 400, () => { + peak = Math.max(peak, g.state.sys.cabinTemp); + return g.state.session.course === null; + }); + eq('the star course fills the tank', g.state.commander.fuel, MAX_FUEL); + check('...the ship lives, and the cabin stays short of fatal', + g.mode !== 'dead' && peak < CABIN_TEMP_FATAL * 0.6, `peak ${peak.toFixed(3)}`); + check('...and the course is done for the visit', g.state.session.coursesDone.includes('skim')); +} + +console.log('\nthe station course goes round a planet in its way'); +{ + const g = arrived(20_260_914); + const w = g.state.world; + // Put the planet square between the ship and the station. + const through = w.station.position.clone().sub(w.planetPos).normalize(); + g.state.player.position.copy(w.planetPos).addScaledVector(through, -(w.planetRadius * 8)); + g.state.session.course = 'station'; + let lowest = Infinity; + fly(g, 400, () => { + lowest = Math.min(lowest, g.state.player.position.distanceTo(w.planetPos) - w.planetRadius); + return g.mode !== 'flight'; + }); + check('the ship never flies lower than the clearance', lowest > COURSE_PLANET_CLEARANCE * 0.9, + `${Math.round(lowest)} units up`); + eq('...and it still docks', g.mode, 'docked'); +} + +console.log('\nnothing appears inside the planet'); +{ + // docs/TODO/205 M3 found a hermit 1,545 units inside the planet, and a + // course flew the ship into the ground after it. The world lifts such a + // spawn out to a set height, and only such a spawn. + const g = arrived(20_260_915); + const w = g.state.world; + const inside = w.planetPos.clone().add(new THREE.Vector3(w.planetRadius * 0.5, 0, 0)); + const lifted = aboveGround(w, inside); + const alt = lifted.distanceTo(w.planetPos) - w.planetRadius; + check('a ship placed inside the planet appears above it', Math.abs(alt - SPAWN_PLANET_ALTITUDE) < 1, + `${Math.round(alt)} units up`); + const high = w.planetPos.clone().add(new THREE.Vector3(w.planetRadius * 3, 0, 0)); + check('...and a ship placed well clear of it appears where it was placed (the control)', + aboveGround(w, high).distanceTo(high) < 1e-6); +} diff --git a/test/spawning.test.ts b/test/spawning.test.ts index 3c3f0980..a715c71d 100644 --- a/test/spawning.test.ts +++ b/test/spawning.test.ts @@ -23,7 +23,7 @@ import { ASTEROID_LANE_SCATTER, ASTEROID_SCATTER, CORRIDOR_SPAN, CORRIDOR_START, HERMIT_SCATTER, HUNTER_SCATTER, PIRATE_SCATTER, POLICE_PATROL_RANGE, POLICE_SCATTER, STATION_DEFENCE_JITTER, STATION_DEFENCE_MIN, STATION_DEFENCE_SPAN, STATION_DEFENCE_STACK, STATION_DEFENCE_STANDOFF, - TRADER_SCATTER, + TRADER_SCATTER, SPAWN_PLANET_ALTITUDE, } from '../src/constants/spawn-placement.ts'; import { SCANNER_RANGE } from '../src/constants/console.ts'; import { BANISHED } from '../src/constants/witchspace.ts'; @@ -85,6 +85,12 @@ console.log('\nwhere a system puts its traffic'); spawnPopulation(world, PLAN, sys, player, [], situation); route.copy(home).sub(player).normalize(); for (const npc of world.npcs) { + // A ship the scatter put inside the planet is lifted out to one set + // height (docs/TODO/205 M3). It is the lift's ship, not the scatter's, + // so it stays out of the band. It is counted, and nothing sits lower. + const alt = npc.object.position.distanceTo(world.planetPos) - world.planetRadius; + lowest = Math.min(lowest, alt); + if (Math.abs(alt - SPAWN_PLANET_ALTITUDE) < 1) { lifted += 1; continue; } const d = npc.object.position.distanceTo(home); const b = out.band[npc.role] ?? (out.band[npc.role] = { lo: Infinity, hi: -Infinity }); b.lo = Math.min(b.lo, d); b.hi = Math.max(b.hi, d); @@ -101,8 +107,12 @@ console.log('\nwhere a system puts its traffic'); return out; }; + let lowest = Infinity; + let lifted = 0; const arrival = sweep('arrival'); const launch = sweep('launch'); + check(`no ship of the traffic sits below the lift height (${lifted} lifted, lowest ${Math.round(lowest)})`, + lowest >= SPAWN_PLANET_ALTITUDE - 1); const { band, along, off } = arrival; /** the measured spread of a role, against the nominal it was spawned from. */ From 071492e6da8e7bfc151ae6e0d1f6341159556954 Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Fri, 11 Sep 2026 22:33:46 +0100 Subject: [PATCH 016/100] docs/TODO/205 M4: the LAUNCH row asks where the ship goes Chris's rule: no ship leaves without somewhere to go. The LAUNCH row now opens the launch list. A jump leaves with its countdown running. The rocks and the star leave on their work. A row the ship cannot fly refuses, and the console says why, so a commander with no target and no work stays on the pad. The last row opens the galactic chart. course-actions.ts joins the course list to the Game: it builds the view and applies a pick. The course rows send virtual codes from COURSE_KEYS, which the flight buttons of M5 will share. jumpCheck gives the jump key and the list one question. 5,708 assertions, from 5,694. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- docs/ARCHITECTURE.md | 4 +- ...the-ship-goes-and-the-ship-flies-itself.md | 26 +++++- src/game/bindings.ts | 23 +++++ src/game/course-actions.ts | 89 +++++++++++++++++++ src/game/game.ts | 23 ++++- src/game/hyperspace-actions.ts | 18 ++-- src/game/screens/courses.ts | 56 ++++++++++++ src/ui/screen-host.ts | 2 +- src/ui/screens-courses.ts | 36 ++++++++ test/constants.test.ts | 3 +- test/course-launch.test.ts | 89 +++++++++++++++++++ test/run.ts | 1 + 12 files changed, 357 insertions(+), 13 deletions(-) create mode 100644 src/game/course-actions.ts create mode 100644 src/game/screens/courses.ts create mode 100644 src/ui/screens-courses.ts create mode 100644 test/course-launch.test.ts diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md index 384f2e83..c431e954 100644 --- a/docs/ARCHITECTURE.md +++ b/docs/ARCHITECTURE.md @@ -41,7 +41,9 @@ rules. This file is a map. `course-pilot.ts` flies the picked course, one frame at a time, and it reports a `FlightDemand`. `flight-instruments.ts` throws the switches that a course asks for: the torus drive, the hand-over to the docking computer, and - the end of the course. + the end of the course. `course-actions.ts` joins the list to the Game: it + builds the flat view, and it applies a pick. At the station, the LAUNCH row + opens `screens/courses.ts`, and a pick leaves on the course. - The console is one line, so `SessionState.queued` is the line that waits for it (`session.ts`). Some consequences make sense only after their cause: what a scan cost your legal record, or what a deed cost your reputation. The console diff --git a/docs/TODO/205-the-pilot-picks-where-the-ship-goes-and-the-ship-flies-itself.md b/docs/TODO/205-the-pilot-picks-where-the-ship-goes-and-the-ship-flies-itself.md index a60fdfdb..63f2c333 100644 --- a/docs/TODO/205-the-pilot-picks-where-the-ship-goes-and-the-ship-flies-itself.md +++ b/docs/TODO/205-the-pilot-picks-where-the-ship-goes-and-the-ship-flies-itself.md @@ -155,10 +155,12 @@ where the system has one. ### M5 — the course list on screen, for every player -The course list is a screen with rows, behind `ui/screen-host.ts`. The world -keeps flying while it is up, as it does under the charts. A tap picks a row, -and so does the row cursor with Enter. The screen returns the picked course as -an outcome, and the Game applies it (invariant 15). +In flight, the course list is a row of buttons over the view, and not a +screen. M4 found why. Under any screen the flight world stops stepping, and +many tests expect flight at once after an arrival. 204 found the same shape +for its flight menu. Each button sends its course's code from `COURSE_KEYS`, +the flight binding table answers it, and the Game applies the pick +(invariant 15). The screen opens by itself when the ship has no course: at a launch, at an arrival, and when a course ends. A key and a button open it at other times. @@ -375,3 +377,19 @@ Evidence: On the star course, the cabin peaked at 0.489 in every sample, against a fatal 0.99. No ship came within 68,000 units of the star. + +### M4 + +- **The LAUNCH row opens a screen, `screens/courses.ts`.** Each row is a + course, and a pick leaves the station on it. A row the ship cannot fly says + why, and a pick of it refuses with the reason on the console. The last row + opens the galactic chart, and ESC from the chart returns to the list. +- **`Game.launch()` is still the transition itself.** Only the LAUNCH row's + command changed. The tests that press `launch` by name still leave at once. +- **A course row sends a virtual code, `COURSE_KEYS` in `bindings.ts`.** The + launch screen and the flight buttons of M5 share the codes, so the two + cannot disagree. +- **The jump key and the course list ask one question.** `jumpCheck` in + `hyperspace-actions.ts` holds the arguments that `startHyperspace` used to + pass by hand. +- **The suite has 5,708 assertions,** from 5,694. diff --git a/src/game/bindings.ts b/src/game/bindings.ts index ec336ff6..22dcca64 100644 --- a/src/game/bindings.ts +++ b/src/game/bindings.ts @@ -33,8 +33,31 @@ // menu's rows straight from it. import type { Binding, Command, ControlMode } from './controls.ts'; +import type { CourseKind } from './courses.ts'; /** Bindings that answer whatever is on screen, overlays included. */ +/** + * The code each course row sends (docs/TODO/205 M4). + * + * A row of the course list is a click target, as a station row is. So each + * course has a virtual code: `Virt`, then `Course`, then the course. No + * keyboard produces one, so no letter is spent. The launch screen and the + * course buttons in flight send the same codes. This record is their one + * home, so the two surfaces cannot disagree about a course's code. + */ +export const COURSE_KEYS: Readonly> = { + jump: 'VirtCourseJump', + mission: 'VirtCourseMission', + station: 'VirtCourseStation', + derelict: 'VirtCourseDerelict', + mine: 'VirtCourseMine', + hermit: 'VirtCourseHermit', + skim: 'VirtCourseSkim', +}; + +/** The launch list's row for the galactic chart, where a pilot sets a target. */ +export const COURSE_CHART_KEY = 'VirtCourseChart'; + export const GLOBAL_BINDINGS: readonly Binding[] = [ // ? toggles the controls guide (plain / is the classic decelerate key) { key: 'Question', command: 'toggleHelp' }, diff --git a/src/game/course-actions.ts b/src/game/course-actions.ts new file mode 100644 index 00000000..0cd39383 --- /dev/null +++ b/src/game/course-actions.ts @@ -0,0 +1,89 @@ +// What the Game does with a course: the list it offers, and the pick it +// applies (docs/TODO/205 M4). +// +// Three files hold a course, and each holds one part: +// +// - `courses.ts` decides which courses the situation allows. It is pure; +// - `course-pilot.ts` flies the picked course, one frame at a time; +// - this file joins the two to the Game. It builds the flat view that the +// list reads, and it applies a pick. +// +// A PICK IS A CONSEQUENCE, so the orchestrator applies it (invariant 15). At a +// launch it leaves the station. For a jump it starts the countdown. So this +// reaches the Game through `CourseHost`, and it names no screen and no key. +// +// A row that says why the ship cannot fly it refuses the pick, and the console +// says the reason. That is how a launch with no target refuses: Chris's rule +// of 2026-09-11 is that no ship leaves without somewhere to go. + +import { courseList, type Course, type CourseKind, type CourseSituation, type CourseWorld } from './courses.ts'; +import type { checkJump } from './hyperspace.ts'; +import type { GameState } from './state.ts'; + +/** What a pick reaches back for. */ +export interface CourseHost { + /** the jump key's own check (`HyperspaceActions.jumpCheck`) */ + jumpCheck(): ReturnType; + /** the station's transition to flight */ + launch(): void; + startHyperspace(): void; + /** close every screen, back to the base state */ + closeScreens(): void; + showMessage(text: string, seconds: number): void; + refused(): void; +} + +export class CourseActions { + private readonly state: () => GameState; + private readonly host: CourseHost; + + constructor(state: () => GameState, host: CourseHost) { + this.state = state; + this.host = host; + } + + /** The courses the situation allows, in order. */ + list(situation: CourseSituation): Course[] { + return courseList(this.view(situation)); + } + + /** + * Pick a course. At a launch the ship leaves the station on it. A jump + * starts the countdown. + * + * @returns whether the pick stood. A row with a reason refuses, and says it. + */ + pick(kind: CourseKind, situation: CourseSituation): boolean { + const row = this.list(situation).find((c) => c.kind === kind); + if (!row || row.why !== null) { + if (row?.why) this.host.showMessage(row.why, 3); + this.host.refused(); + return false; + } + if (situation === 'launch') { + this.host.closeScreens(); + this.host.launch(); + } + this.state().session.course = kind; + if (kind === 'jump') this.host.startHyperspace(); + return true; + } + + /** The flat view `courseList` reads, built from the live state. */ + private view(situation: CourseSituation): CourseWorld { + const s = this.state(); + const target = s.chart.targetIndex; + return { + situation, + commander: s.commander, + jump: this.host.jumpCheck(), + targetName: target === null ? null : s.systems[target]?.name ?? null, + witchspace: s.session.witchspace, + // The sky is cleared while the ship is docked (courses.ts). + sky: situation === 'launch' ? [] + : s.world.npcs.filter((n) => n.state.alive).map((n) => n.role), + mission: null, + done: new Set(s.session.coursesDone), + }; + } +} diff --git a/src/game/game.ts b/src/game/game.ts index 6178b674..49c62699 100644 --- a/src/game/game.ts +++ b/src/game/game.ts @@ -108,6 +108,8 @@ import { CombatSimScreen, type CombatSimContext } from './screens/combat-sim.ts' import { TestModeScreen, type TestModeContext } from './screens/test-mode.ts'; import { QuitScreen, type QuitContext } from './screens/quit.ts'; import { SurvivorsScreen, type SurvivorsContext } from './screens/survivors.ts'; +import { CoursesScreen, type CoursesContext } from './screens/courses.ts'; +import { CourseActions, type CourseHost } from './course-actions.ts'; import { ScreenHost } from '../ui/screen-host.ts'; import { characterVerdict } from './character.ts'; @@ -372,6 +374,19 @@ export class Game { misjumpArmed: (armed) => { if (armed) sfx.misjumpArmed(); else sfx.misjumpDisarmed(); }, } satisfies HyperspaceHost); + /** + * The courses a pilot picks from, and the pick applied (docs/TODO/205 M4). + * The state is read through a function, because a respawn replaces it. + */ + private readonly courses_ = new CourseActions(() => this.state, { + jumpCheck: () => this.jump_.jumpCheck(), + launch: () => this.docked_.launch(), + startHyperspace: () => this.startHyperspace(), + closeScreens: () => this.screens.exit(), + showMessage: (text, seconds) => this.showMessage(text, seconds), + refused: () => sfx.refused(), + } satisfies CourseHost); + /** * What a career keeps when a flight ends (docs/TODO/150 M5). * @@ -691,6 +706,10 @@ export class Game { sell: () => this.docked_.answerForSurvivors('sold'), release: () => this.docked_.answerForSurvivors('released'), } satisfies SurvivorsContext)), + new CoursesScreen(() => ({ + rows: () => this.courses_.list('launch'), + pick: (kind) => { this.courses_.pick(kind, 'launch'); }, + } satisfies CoursesContext)), ]) this.screens.register(screen); // A boot enters a system too, so it chooses a roster like any arrival. A @@ -1118,7 +1137,9 @@ export class Game { // --- global ----------------------------------------------------------- toggleHelp: () => { this.helpOpen = !this.helpOpen; this.shell.toggleHelp(); }, // --- the station menu ------------------------------------------------- - launch: () => this.docked_.launch(), + // The LAUNCH row asks where to go first (docs/TODO/205 M4). `launch()` + // below is still the transition itself, which the tests press by name. + launch: () => this.screens.open('courses'), openMarket: () => this.screens.open('market'), openEquip: () => this.screens.open('equip'), openBriefing: () => this.screens.open('briefing'), diff --git a/src/game/hyperspace-actions.ts b/src/game/hyperspace-actions.ts index be07b5cf..285af250 100644 --- a/src/game/hyperspace-actions.ts +++ b/src/game/hyperspace-actions.ts @@ -92,6 +92,18 @@ export class HyperspaceActions { this.host = host; } + /** + * May the drive spin up now, for the chart's target? The jump key asks it, + * and so does the course list (docs/TODO/205 M4), so the two cannot differ. + */ + jumpCheck(): ReturnType { + return checkJump(this.state.commander, this.state.systems, this.state.chart.targetIndex, + this.state.session.witchspace, this.state.session.hyperCountdown >= 0, + // JUMP ANYWHERE (docs/TODO/121): the flag goes IN, and the refusal stays + // where it was decided. Nothing here reads the tank. + this.state.cheat); + } + /** @internal — driven by src/game/game.ts, which delegates to it. */ startHyperspace(): void { // The simulator is a room at the station, not a place you can leave. The @@ -102,11 +114,7 @@ export class HyperspaceActions { this.host.refused(); return; } - const check = checkJump(this.state.commander, this.state.systems, this.state.chart.targetIndex, - this.state.session.witchspace, this.state.session.hyperCountdown >= 0, - // JUMP ANYWHERE (docs/TODO/121): the flag goes IN, and the refusal stays - // where it was decided. Nothing here reads the tank. - this.state.cheat); + const check = this.jumpCheck(); if (!check.ok) { if (check.reason === 'alreadyJumping') return; this.host.showMessage(refusalMessage(check.reason, this.state.session.witchspace), 4); diff --git a/src/game/screens/courses.ts b/src/game/screens/courses.ts new file mode 100644 index 00000000..49e8bb02 --- /dev/null +++ b/src/game/screens/courses.ts @@ -0,0 +1,56 @@ +// The launch list: the station asks where the ship goes (docs/TODO/205 M4). +// +// The station menu's LAUNCH row opens it. Each row is one course from +// `courses.ts`, and a pick leaves the station on it. A row the ship cannot fly +// says why, and a pick of it refuses. So a ship with no target and no work +// cannot leave. The last row opens the galactic chart, where the pilot sets a +// target, and ESC from the chart comes back here. +// +// The screen decides nothing itself. `course-actions.ts` applies a pick, the +// way the survivors screen hands its answer to `game/survivors.ts`. + +import type { Screen, ScreenOutcome } from '../../ui/screen-host.ts'; +import type { Input } from '../../engine/input.ts'; +import type { Course, CourseKind } from '../courses.ts'; +import { COURSE_CHART_KEY, COURSE_KEYS } from '../bindings.ts'; +import { renderLaunchCourses } from '../../ui/screens-courses.ts'; + +/** The slice of the Game this screen is allowed to see. */ +export interface CoursesContext { + /** the launch courses, in order */ + rows(): readonly Course[]; + /** pick one; a refusal says why and leaves the screen up */ + pick(kind: CourseKind): void; +} + +export class CoursesScreen implements Screen { + readonly id = 'courses' as const; + private readonly ctx: () => CoursesContext; + + constructor(ctx: () => CoursesContext) { + this.ctx = ctx; + } + + open(): void { + this.render(); + } + + render(): void { + renderLaunchCourses( + this.ctx().rows().map((course) => ({ code: COURSE_KEYS[course.kind], course })), + COURSE_CHART_KEY); + } + + input(i: Input): ScreenOutcome { + const ctx = this.ctx(); + for (const course of ctx.rows()) { + if (i.pressed(COURSE_KEYS[course.kind])) { + ctx.pick(course.kind); + return 'stay'; + } + } + if (i.pressed(COURSE_CHART_KEY)) return { open: 'chart' }; + if (i.pressed('Escape')) return 'back'; + return 'stay'; + } +} diff --git a/src/ui/screen-host.ts b/src/ui/screen-host.ts index d6f418ab..66b8c674 100644 --- a/src/ui/screen-host.ts +++ b/src/ui/screen-host.ts @@ -23,7 +23,7 @@ import type { Input } from '../engine/input.ts'; export type ScreenId = | 'market' | 'equip' | 'contracts' | 'status' | 'data' | 'missions' | 'log' | 'chart' | 'local' | 'saves' | 'save-name' | 'naming' | 'new-name' - | 'briefing' | 'combat-sim' | 'test-mode' | 'quit' | 'survivors'; + | 'briefing' | 'combat-sim' | 'test-mode' | 'quit' | 'survivors' | 'courses'; /** What a screen asks the host to do next. */ export type ScreenOutcome = diff --git a/src/ui/screens-courses.ts b/src/ui/screens-courses.ts new file mode 100644 index 00000000..6184c34d --- /dev/null +++ b/src/ui/screens-courses.ts @@ -0,0 +1,36 @@ +// The launch list: where the ship goes when it leaves the station +// (docs/TODO/205 M4). +// +// It is a render function, as every screen's is. `game/screens/courses.ts` +// owns the input and the state. Each row is a click target with the code that +// `COURSE_KEYS` gives its course. A tap and the menu cursor's Enter send the +// same code. + +import type { Course } from '../game/courses.ts'; +import { show } from './screen-shell.ts'; + +/** One row, and the code it sends. */ +export interface CourseRow { + readonly code: string; + readonly course: Course; +} + +export function renderLaunchCourses(rows: readonly CourseRow[], chartCode: string): void { + const line = (r: CourseRow): string => r.course.why === null + ? `
${r.course.what}
` + : `
${r.course.what}` + + ` — ${r.course.why}
`; + show(` +

LAUNCH

+
+
+ WHERE DOES THE SHIP GO WHEN IT LEAVES? +
+
+ ${rows.map(line).join('\n ')} +
GALACTIC CHART — CHOOSE WHERE TO JUMP
+
+
+
TAP A ROW · ↑ ↓ SELECT · ENTER CHOOSE · ESC STAY DOCKED
+ `); +} diff --git a/test/constants.test.ts b/test/constants.test.ts index b294b31d..9be582f9 100644 --- a/test/constants.test.ts +++ b/test/constants.test.ts @@ -457,9 +457,10 @@ const OUTSIDE: readonly Group[] = [ // the one sentence the guide and the manual say about the station menu (docs/TODO/202) 'ui/key-help.ts': ['LABELS', 'ALL_BINDINGS', 'STATION_MENU_NOTE'], 'game/command-help.ts': ['COMMAND_HELP'], + // ...and the codes a course row sends, on both of its surfaces (docs/TODO/205 M4) 'game/bindings.ts': [ 'GLOBAL_BINDINGS', 'FLIGHT_BINDINGS', 'NOT_IN_THE_SIMULATOR', 'BINDINGS', - 'WHILE_PAUSED', + 'WHILE_PAUSED', 'COURSE_KEYS', 'COURSE_CHART_KEY', ], 'game/screens/save-transfer.ts': ['NOT_A_SAVE', 'WRONG_VERSION', 'STORE_FULL'], 'engine/keymap.ts': ['LAYOUTS', 'STORAGE_KEY'], diff --git a/test/course-launch.test.ts b/test/course-launch.test.ts new file mode 100644 index 00000000..8c640569 --- /dev/null +++ b/test/course-launch.test.ts @@ -0,0 +1,89 @@ +// The LAUNCH row asks where the ship goes (docs/TODO/205 M4). +// +// Chris's rule of 2026-09-11: no ship leaves without somewhere to go. So the +// row opens a list of courses. A jump starts its countdown at the launch. A +// local course leaves on its work. A row the ship cannot fly refuses, and the +// console says why. These run the real Game through the row's own code. + +import { Game } from '../src/game/game.ts'; +import { headlessShell } from '../src/engine/shell.ts'; +import { withoutSaving } from '../src/game/storage.ts'; +import { seedWorld } from '../src/game/rng.ts'; +import { COURSE_CHART_KEY, COURSE_KEYS } from '../src/game/bindings.ts'; +import { checkJump } from '../src/game/hyperspace.ts'; +import { check, dismissBriefing, eq } from './harness.ts'; + +console.log('\nthe LAUNCH row asks where the ship goes'); + +/** A fresh commander on the pad, with the menu up. */ +function docked(): Game { + return withoutSaving(() => { + seedWorld(20_260_916); + const game = new Game(() => headlessShell()); + dismissBriefing(game); + return game; + }).value; +} + +/** Press one code, and give the game one frame to answer it. */ +function press(g: Game, code: string): void { + g.input.injectPress(code); + withoutSaving(() => g.step(1 / 60, 1)); +} + +/** The first system the tank can reach, as the chart would set it. */ +function reachable(g: Game): number { + const c = g.state.commander; + const i = g.state.systems.findIndex((_, n) => + checkJump(c, g.state.systems, n, false, false).ok); + if (i < 0) throw new Error('no system in range of a full tank'); + return i; +} + +{ + const g = docked(); + press(g, 'VirtLaunch'); + eq('the LAUNCH row opens the course list rather than leaving', g.mode, 'courses'); + + press(g, COURSE_KEYS.jump); + eq('a jump with no target refuses, and the ship stays on the pad', g.mode, 'courses'); + eq('...and the console says why', g.state.session.messageText, 'NO HYPERSPACE TARGET SET'); + + press(g, COURSE_CHART_KEY); + eq('the chart row opens the galactic chart', g.mode, 'chart'); + press(g, 'Escape'); + eq('...and ESC from the chart comes back to the list', g.mode, 'courses'); + + press(g, 'Escape'); + eq('ESC from the list stays docked', g.mode, 'docked'); +} + +{ + const g = docked(); + g.state.chart.targetIndex = reachable(g); + press(g, 'VirtLaunch'); + press(g, COURSE_KEYS.jump); + eq('a jump with a target leaves the station', g.mode, 'flight'); + eq('...on the jump course', g.state.session.course, 'jump'); + check('...with the countdown already running', g.state.session.hyperCountdown >= 0); +} + +{ + const g = docked(); + g.state.commander.equipment.scoops = true; + g.state.commander.fuel = 10; + press(g, 'VirtLaunch'); + press(g, COURSE_KEYS.skim); + eq('a commander with no target but scoops can leave to skim the star', g.mode, 'flight'); + eq('...on the star course', g.state.session.course, 'skim'); + check('...and no countdown runs', g.state.session.hyperCountdown < 0); +} + +{ + const g = docked(); + press(g, 'VirtLaunch'); + press(g, COURSE_KEYS.mine); + eq('the rocks with no mining laser refuse', g.mode, 'courses'); + eq('...and the console names what is missing', g.state.session.messageText, + 'NEEDS A MINING LASER AND FUEL SCOOPS'); +} diff --git a/test/run.ts b/test/run.ts index 5fc2b2d1..a7c050fd 100644 --- a/test/run.ts +++ b/test/run.ts @@ -73,6 +73,7 @@ import './bribe-flight.test.ts'; import './prompts.test.ts'; import './courses.test.ts'; import './course-pilot.test.ts'; +import './course-launch.test.ts'; import './world.test.ts'; import './docking.test.ts'; import './docking-computer.test.ts'; From ce76026abc969a326e4204d14ada133b598eca38 Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Fri, 11 Sep 2026 22:42:55 +0100 Subject: [PATCH 017/100] docs/TODO/205 M5: the course list flies with the ship, as buttons over the view In flight the course list is a set of buttons at the top right of the view. It shows by itself when the ship has nowhere to go: after an arrival, when a course ends, and when a key takes the ship. A lit button says what the ship is doing, such as HEADING TO THE STATION, and a click or a tap on it opens the list again. A button the ship cannot use says what to do about it. It is not a screen, because the flight world stops under a screen. Each button sends a code, as a menu row does, and the course actions read the codes in flight. No key is bound (Chris: "We don't need to use the keyboard. We have mouse and touch."). The words are the player's (Chris: "A user does not have all our context."). 5,721 assertions, from 5,708. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- docs/ARCHITECTURE.md | 10 +- ...the-ship-goes-and-the-ship-flies-itself.md | 29 ++++- play.html | 7 ++ src/engine/browser-shell.ts | 13 ++- src/game/bindings.ts | 7 ++ src/game/cockpit-view.ts | 35 +++++- src/game/course-actions.ts | 51 +++++++++ src/game/courses.ts | 33 +++++- src/game/flight-instruments.ts | 6 +- src/game/game.ts | 19 +++- src/hud/hud-binding.ts | 3 + src/hud/hud-buttons.ts | 49 +++++++++ src/hud/hud.ts | 9 ++ src/style.css | 31 ++++++ src/ui/key-help.ts | 11 ++ src/ui/screens-courses.ts | 4 +- test/console-plate.test.ts | 2 +- test/constants.test.ts | 9 +- test/course-buttons.test.ts | 101 ++++++++++++++++++ test/course-launch.test.ts | 3 +- test/courses.test.ts | 4 +- test/run.ts | 1 + 22 files changed, 410 insertions(+), 27 deletions(-) create mode 100644 src/hud/hud-buttons.ts create mode 100644 test/course-buttons.test.ts diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md index c431e954..546f9d85 100644 --- a/docs/ARCHITECTURE.md +++ b/docs/ARCHITECTURE.md @@ -24,9 +24,11 @@ rules. This file is a map. seams cross the platform seam. `onScreenClick` is input. `onScreenMove` reports only: a screen may repaint what it describes, but it must never select or spend. -- The HUD is a read-only painter, and it is three files. `hud/hud-model.ts` +- The HUD is a read-only painter, and it is four files. `hud/hud-model.ts` works out where a marker goes. `hud-binding.ts` turns the state into a - dashboard. `hud.ts` paints one. A screen lives behind `ui/screen-host.ts`, and + dashboard. `hud.ts` paints one. `hud-buttons.ts` paints the buttons over the + flight view, such as the course buttons, and a click on one sends its code + (docs/TODO/205). A screen lives behind `ui/screen-host.ts`, and it reaches the page through `ui/screen-shell.ts`. A screen owns its own rendering, its own input and its own local state. - `src/game/prompts.ts` decides what a key can do about the situation right now. @@ -43,7 +45,9 @@ rules. This file is a map. course asks for: the torus drive, the hand-over to the docking computer, and the end of the course. `course-actions.ts` joins the list to the Game: it builds the flat view, and it applies a pick. At the station, the LAUNCH row - opens `screens/courses.ts`, and a pick leaves on the course. + opens `screens/courses.ts`, and a pick leaves on the course. In flight, the + list is a set of buttons over the view, and not a screen, because the flight + world stops under a screen. - The console is one line, so `SessionState.queued` is the line that waits for it (`session.ts`). Some consequences make sense only after their cause: what a scan cost your legal record, or what a deed cost your reputation. The console diff --git a/docs/TODO/205-the-pilot-picks-where-the-ship-goes-and-the-ship-flies-itself.md b/docs/TODO/205-the-pilot-picks-where-the-ship-goes-and-the-ship-flies-itself.md index 63f2c333..44ee89a0 100644 --- a/docs/TODO/205-the-pilot-picks-where-the-ship-goes-and-the-ship-flies-itself.md +++ b/docs/TODO/205-the-pilot-picks-where-the-ship-goes-and-the-ship-flies-itself.md @@ -162,9 +162,10 @@ for its flight menu. Each button sends its course's code from `COURSE_KEYS`, the flight binding table answers it, and the Game applies the pick (invariant 15). -The screen opens by itself when the ship has no course: at a launch, at an -arrival, and when a course ends. A key and a button open it at other times. -Invariant 9 holds: the key lives in the binding table and nowhere else. +The list shows by itself when the ship has no course: at an arrival, when a +course ends, and when a key takes the ship. A button opens it over a course +that flies. No new key does (Chris, 2026-09-11: *"We don't need to use the +keyboard. We have mouse and touch."*). The existing flight keys stay. The course list also carries two fixed rows: the galactic chart and the pause. A phone needs the chart in flight to pick the next jump. @@ -203,6 +204,10 @@ same world state, step for step. It proves each of the four stops above. ## Decisions already made +- **A new control takes a mouse click or a tap, and no key** (Chris, + 2026-09-11: *"We don't need to use the keyboard. We have mouse and + touch."*). The flight keys of today stay as they are. + - **One flow for every player** (Chris, 2026-09-11). A keyboard player and a phone player pick from the same course list. - **The touch controls of 204 go, all five milestones of them** (Chris, @@ -393,3 +398,21 @@ Evidence: `hyperspace-actions.ts` holds the arguments that `startHyperspace` used to pass by hand. - **The suite has 5,708 assertions,** from 5,694. + +### M5 + +- **The course buttons read their codes as a screen reads its own.** + `CourseActions.read` takes the codes of `COURSE_KEYS` in flight. So no key + table spends a row on a button, and the `?` guide keeps no blank rows. +- **Chris ruled out a new key the same day.** The first draft bound Z to open + the list. His words: *"We don't need to use the keyboard. We have mouse and + touch."* The button that opens the list sends its own code instead. +- **The words on the buttons are the player's, and not the plan's.** Chris + asked for plain words the same day: *"A user does not have all our + context."* So no button says "course". A button under way says what the + ship does, such as HEADING TO THE STATION. A reason says what to do, such as + CHOOSE A SYSTEM ON THE GALACTIC CHART FIRST. +- **A launch and an arrival each play a tunnel.** The cockpit reads only a few + keys while one runs, so a button pressed then does nothing. That is the game + of today, and the test waits for the tunnel. +- **The suite has 5,721 assertions,** from 5,708. diff --git a/play.html b/play.html index b7224a57..4a08bf60 100644 --- a/play.html +++ b/play.html @@ -36,6 +36,13 @@ console is deliberately one line. -->
+ +
-433 exported constants. Regenerate with `npm run generate:constants`; +434 exported constants. Regenerate with `npm run generate:constants`; search names, meanings and values with `npm run constants:find -- ""`. | Domain | Symbol | Literal / expression | Purpose | Rule ID | Source | @@ -54,7 +54,7 @@ search names, meanings and values with `npm run constants:find -- ""`. | chart-metric | LOCAL_CANVAS | 560 | Square, so a light year is the same number of pixels whichever way you go. | | [chart-metric.ts:54](./chart-metric.ts#L54) | | chart-metric | CHART_CANVAS_W | 780 | The galactic chart's canvas, in px. | | [chart-metric.ts:66](./chart-metric.ts#L66) | | chart-metric | CHART_CANVAS_H | 400 | Its height. | | [chart-metric.ts:74](./chart-metric.ts#L74) | -| chart-metric | LANE_PICK_PX | 8 | How near the pointer must come to a trade lane to be pointing AT it, in canvas pixels. | | [chart-metric.ts:85](./chart-metric.ts#L85) | +| chart-metric | LANE_PICK_PX | 8 | How near the pointer must come to a trade lane to be pointing AT it, in canvas pixels. | chart.lanePickPx | [chart-metric.ts:87](./chart-metric.ts#L87) | | chart-overlay | LANE_FADE_FLOOR | 0.35 | The alpha that the quietest drawn trade lane keeps, with the busiest at 1. | chart.laneFadeFloor | [chart-overlay.ts:25](./chart-overlay.ts#L25) | | chart-overlay | LANE_CARGO_NAMED | 3 | How many of a lane's commodities the detail line names before it counts the rest ("+2"). | chart.laneCargoNamed | [chart-overlay.ts:37](./chart-overlay.ts#L37) | | collision | PLAYER_SPEED_KEPT | 0.3 | Speed kept after a collision. | | [collision.ts:10](./collision.ts#L10) | @@ -123,6 +123,7 @@ search names, meanings and values with `npm run constants:find -- ""`. | course | COURSE_SKIM_DISTANCE | 65_000 | The hold distance of the skim course, from the centre of the star, in world units. | course.skimDistance | [course.ts:107](./course.ts#L107) | | course | COURSE_PLANET_CLEARANCE | MASS_LOCK_PLANET_ALTITUDE * 1.25 | How high above the planet's surface a course keeps its line, in world units. | | [course.ts:119](./course.ts#L119) | | course | COURSE_HERMIT_SPEED | HERMIT_DOCK_SPEED / 2 | The speed at which the hermit course arrives, in world units a second. | | [course.ts:129](./course.ts#L129) | +| course | SKIP_SPEED | 8 | How much faster the world runs under the fast forward button, as a count of fixed steps in one screen frame (docs/TODO/205 M7). | course.skipSpeed | [course.ts:145](./course.ts#L145) | | docking | GATE_HALF_WIDTHS | 5 | How far out the approach gate sits, in multiples of the station half-width. | docking.gateHalfWidths | [docking.ts:25](./docking.ts#L25) | | docking | TURN_IN | Math.PI / 4 | How far round from the slot axis an approach turns in, in radians. | | [docking.ts:49](./docking.ts#L49) | | docking | RUN_IN_WIDTHS | GATE_HALF_WIDTHS * 0.6 | Where the approach stops the curve and flies straight, in station half-widths. | | [docking.ts:87](./docking.ts#L87) | @@ -154,12 +155,12 @@ search names, meanings and values with `npm run constants:find -- ""`. | exercise | OPENING_RANGE | 4500 | The opening range for a fight that you are meant to see coming. | exercise.openingRange | [exercise.ts:33](./exercise.ts#L33) | | exercise | AMBUSH_RANGE | 2400 | An ambush opens INSIDE their gun, because that is what an ambush is. | | [exercise.ts:40](./exercise.ts#L40) | | exercise | MIN_OPENING_RANGE | 2 * PASS_FAR | No opening may be closer than this. | | [exercise.ts:49](./exercise.ts#L49) | -| exercise | OPENING_CONE_DEG | 8 | The cone that a visible opening is scattered through, as a half-angle in degrees. | | [exercise.ts:58](./exercise.ts#L58) | -| exercise | AMBUSH_CONE_DEG | 30 | An ambush spreads wide behind you: 16 to 43 degrees off your tail. | exercise.ambushCone | [exercise.ts:69](./exercise.ts#L69) | -| exercise | IN_VIEW_DEG | 20 | How far off the nose still counts as "the pilot can see it". | exercise.inViewDeg | [exercise.ts:80](./exercise.ts#L80) | -| exercise | ENTRY_THROTTLE | 0.25 | Where the exercise starts you, as a fraction of the ship's top speed. | | [exercise.ts:83](./exercise.ts#L83) | -| exercise | SCENARIO_TIMEOUT | 120 | Seconds a scenario exercise may run before it times out. | | [exercise.ts:86](./exercise.ts#L86) | -| exercise | NO_AMBIENT_TRAFFIC | 1e9 | How far out the encounter timers are pushed while an exercise runs. | | [exercise.ts:96](./exercise.ts#L96) | +| exercise | OPENING_CONE_DEG | 8 | The cone that a visible opening is scattered through, as a half-angle in degrees. | exercise.openingConeDeg | [exercise.ts:60](./exercise.ts#L60) | +| exercise | AMBUSH_CONE_DEG | 30 | An ambush spreads wide behind you: 16 to 43 degrees off your tail. | exercise.ambushCone | [exercise.ts:71](./exercise.ts#L71) | +| exercise | IN_VIEW_DEG | 20 | How far off the nose still counts as "the pilot can see it". | exercise.inViewDeg | [exercise.ts:82](./exercise.ts#L82) | +| exercise | ENTRY_THROTTLE | 0.25 | Where the exercise starts you, as a fraction of the ship's top speed. | | [exercise.ts:85](./exercise.ts#L85) | +| exercise | SCENARIO_TIMEOUT | 120 | Seconds a scenario exercise may run before it times out. | | [exercise.ts:88](./exercise.ts#L88) | +| exercise | NO_AMBIENT_TRAFFIC | 1e9 | How far out the encounter timers are pushed while an exercise runs. | | [exercise.ts:98](./exercise.ts#L98) | | extend-arc | EXTEND_ARC_ANGLE | (60 * Math.PI) / 180 | The angle that the run-out holds off the OUTWARD radial, at its tightest. | | [extend-arc.ts:13](./extend-arc.ts#L13) | | extend-arc | CLEAR_RANGE | 340 | How far out the ship gets before it starts to curve at all. | | [extend-arc.ts:22](./extend-arc.ts#L22) | | hermit-market | HERMIT_ORE | new Set(['Minerals', 'Gold', 'Platinum', 'Gem-Stones']) | What a hermit sits on: whatever they dug up. | | [hermit-market.ts:16](./hermit-market.ts#L16) | @@ -401,23 +402,23 @@ search names, meanings and values with `npm run constants:find -- ""`. | threat | COURTESY_RATE | 0.15 | Professional courtesy: the share of receptions that never form at all, because somebody recognised a commander they would rather not cross. | | [threat.ts:110](./threat.ts#L110) | | threat | PRIZE_SATURATION | 25000 | The cargo value at which the prize term saturates, in tenths of a credit: 25,000, which is 2,500 Cr. | | [threat.ts:118](./threat.ts#L118) | | threat | DEFENCE_WEIGHT | 12 | The weights on the three fields of `sourceThreatScore`: 1. how much fire a hull survives (`maxEnergy`, weight 1, the base); 2. how much of each hit it shrugs off (`perHitDefence`, a subtraction); 3. how hard it hits back (`laserPower`). | | [threat.ts:131](./threat.ts#L131) | -| threat | LASER_WEIGHT | 8 | | | [threat.ts:132](./threat.ts#L132) | -| threat | PROFESSIONAL_SCORE | 110 | The tier ladder over `sourceThreatScore`. | | [threat.ts:138](./threat.ts#L138) | -| threat | GANG_SCORE | 160 | | | [threat.ts:139](./threat.ts#L139) | -| threat | MAX_TIER | 2 | The ladder's top rung. | threat.maxTier | [threat.ts:150](./threat.ts#L150) | -| threat | CURATED_TIER | { 'elite-a:design:17': 0, } | Hulls held at a tier that the score alone would not give them. | | [threat.ts:160](./threat.ts#L160) | +| threat | LASER_WEIGHT | 8 | The weight on how hard a hull hits back (`laserPower`), the third field of `sourceThreatScore`. | threat.laserWeight | [threat.ts:139](./threat.ts#L139) | +| threat | PROFESSIONAL_SCORE | 110 | The tier ladder over `sourceThreatScore`. | | [threat.ts:145](./threat.ts#L145) | +| threat | GANG_SCORE | 160 | | | [threat.ts:146](./threat.ts#L146) | +| threat | MAX_TIER | 2 | The ladder's top rung. | threat.maxTier | [threat.ts:157](./threat.ts#L157) | +| threat | CURATED_TIER | { 'elite-a:design:17': 0, } | Hulls held at a tier that the score alone would not give them. | | [threat.ts:167](./threat.ts#L167) | | threat-lock | THREAT_SWITCH_MARGIN | 2.0 | A rival threat must be this much NEARER than the threat under fire before the defender may switch to it. | threat.switchMargin | [threat-lock.ts:14](./threat-lock.ts#L14) | | threat-lock | THREAT_MIN_HOLD | 5 | Seconds that the defender fights a threat before it considers a rival. | threat.minHold | [threat-lock.ts:25](./threat-lock.ts#L25) | -| torus | TORUS_MULTIPLIER | 8 | How much faster the torus drive travels than ordinary flight. | | [torus.ts:17](./torus.ts#L17) | -| torus | MASS_LOCK_STATION | 5000 | How near the station holds the drive down. | | [torus.ts:29](./torus.ts#L29) | -| torus | MASS_LOCK_PLANET_ALTITUDE | 4000 | ...and how near the planet, as an ALTITUDE above the surface. | | [torus.ts:37](./torus.ts#L37) | -| torus | MASS_LOCK_SHIP | 4500 | ...and how near another ship — any live one that is not a rock. | torus.massLockShip | [torus.ts:46](./torus.ts#L46) | +| torus | TORUS_MULTIPLIER | 8 | How much faster the torus drive travels than ordinary flight. | torus.multiplier | [torus.ts:19](./torus.ts#L19) | +| torus | MASS_LOCK_STATION | 5000 | How near the station holds the drive down. | | [torus.ts:31](./torus.ts#L31) | +| torus | MASS_LOCK_PLANET_ALTITUDE | 4000 | ...and how near the planet, as an ALTITUDE above the surface. | | [torus.ts:39](./torus.ts#L39) | +| torus | MASS_LOCK_SHIP | 4500 | ...and how near another ship — any live one that is not a rock. | torus.massLockShip | [torus.ts:48](./torus.ts#L48) | | trumbles | TRUMBLE_PURGE_TEMP | 0.55 | The cabin heat that drives them out. | | [trumbles.ts:12](./trumbles.ts#L12) | | trumbles | BREED_INTERVAL | 20 | Seconds between broods. | trumbles.breedInterval | [trumbles.ts:20](./trumbles.ts#L20) | | trumbles | BREED_RATE | 1.6 | They multiply by this, plus one, every brood. | | [trumbles.ts:23](./trumbles.ts#L23) | | trumbles | MAX_TRUMBLES | 999 | No more than this many, or the hold report becomes a novel. | | [trumbles.ts:26](./trumbles.ts#L26) | -| trumbles | APPETITE_DIVISOR | 8 | One tonne eaten per this many trumbles, per brood. | | [trumbles.ts:29](./trumbles.ts#L29) | -| trumbles | NOTICEABLE | 4 | Below this many, they are not worth a word. | trumbles.noticeable | [trumbles.ts:37](./trumbles.ts#L37) | +| trumbles | APPETITE_DIVISOR | 8 | One tonne eaten per this many trumbles, per brood. | trumbles.appetiteDivisor | [trumbles.ts:33](./trumbles.ts#L33) | +| trumbles | NOTICEABLE | 4 | Below this many, they are not worth a word. | trumbles.noticeable | [trumbles.ts:41](./trumbles.ts#L41) | | waves | WAVE_MAX_COUNT | 6 | The most ships a wave ever holds — the ceiling the ramp exists to have. | waves.waveMaxCount | [waves.ts:21](./waves.ts#L21) | | waves | WAVE_COUNT_EVERY | 2 | The count grows by one every this many waves... | waves.countEvery | [waves.ts:31](./waves.ts#L31) | | waves | WAVE_TIER_EVERY | 3 | ...and the tier climbs a rung every this many. | waves.tierEvery | [waves.ts:38](./waves.ts#L38) | diff --git a/src/constants/chart-metric.ts b/src/constants/chart-metric.ts index abb8c4eb..8e249340 100644 --- a/src/constants/chart-metric.ts +++ b/src/constants/chart-metric.ts @@ -81,5 +81,7 @@ export const CHART_CANVAS_H = 400; * It is smaller than the 28 px a click snaps to a system by. Lanes are long * targets, and dozens of them are on screen. A generous radius would pick a * neighbouring lane while the pointer sat on a star. + * + * @rule chart.lanePickPx */ export const LANE_PICK_PX = 8; diff --git a/src/constants/course.ts b/src/constants/course.ts index 87b3238b..6be02d75 100644 --- a/src/constants/course.ts +++ b/src/constants/course.ts @@ -127,3 +127,19 @@ export const COURSE_PLANET_CLEARANCE = MASS_LOCK_PLANET_ALTITUDE * 1.25; * @domain course */ export const COURSE_HERMIT_SPEED = HERMIT_DOCK_SPEED / 2; + +/** + * How much faster the world runs under the fast forward button, as a count of + * fixed steps in one screen frame (docs/TODO/205 M7). + * + * Chris chose one fixed speed on 2026-09-11: *"Fixed speed - let's keep it + * simple."* Eight turns the median trip to the station, 148 s, into about + * 19 s of the player's time. The world step ran about 2,000 times faster than + * real time with no graphics, so eight costs little. + * + * It equals `TORUS_MULTIPLIER`, and the two rules are independent. That one is + * how far the drive carries the ship. This one is how fast time passes. + * + * @rule course.skipSpeed + */ +export const SKIP_SPEED = 8; diff --git a/src/constants/exercise.ts b/src/constants/exercise.ts index d7376f65..acef4f48 100644 --- a/src/constants/exercise.ts +++ b/src/constants/exercise.ts @@ -54,6 +54,8 @@ export const MIN_OPENING_RANGE = 2 * PASS_FAR; * nose, and the nearest is 4.4. That is inside the canopy, and off-centre enough * that a gang is a spread rather than a stack. The 1.45 is * `OPPOSITION_CONE_FAR`, the spawner's widest fraction. + * + * @rule exercise.openingConeDeg */ export const OPENING_CONE_DEG = 8; diff --git a/src/constants/threat.ts b/src/constants/threat.ts index 20fcb693..f112f32a 100644 --- a/src/constants/threat.ts +++ b/src/constants/threat.ts @@ -129,6 +129,13 @@ export const PRIZE_SATURATION = 25000; * the source's. */ export const DEFENCE_WEIGHT = 12; +/** + * The weight on how hard a hull hits back (`laserPower`), the third field of + * `sourceThreatScore`. The comment on `DEFENCE_WEIGHT` above explains all + * three weights. + * + * @rule threat.laserWeight + */ export const LASER_WEIGHT = 8; /** diff --git a/src/constants/torus.ts b/src/constants/torus.ts index a409d057..fb207057 100644 --- a/src/constants/torus.ts +++ b/src/constants/torus.ts @@ -13,6 +13,8 @@ * At the commander's 400 this is 3,200 units/s. That is the figure the * starfield's streaks are faded against, and roughly a 28-second run from the * witchpoint. + * + * @rule torus.multiplier */ export const TORUS_MULTIPLIER = 8; diff --git a/src/constants/trumbles.ts b/src/constants/trumbles.ts index a6a742d7..09d7403f 100644 --- a/src/constants/trumbles.ts +++ b/src/constants/trumbles.ts @@ -25,7 +25,11 @@ export const BREED_RATE = 1.6; /** No more than this many, or the hold report becomes a novel. */ export const MAX_TRUMBLES = 999; -/** One tonne eaten per this many trumbles, per brood. */ +/** + * One tonne eaten per this many trumbles, per brood. + * + * @rule trumbles.appetiteDivisor + */ export const APPETITE_DIVISOR = 8; /** diff --git a/src/game/bindings.ts b/src/game/bindings.ts index 2a425da7..33d93283 100644 --- a/src/game/bindings.ts +++ b/src/game/bindings.ts @@ -65,6 +65,9 @@ export const COURSE_CHART_KEY = 'VirtCourseChart'; */ export const COURSE_TOGGLE_KEY = 'VirtCourseToggle'; +/** The fast forward button in flight (docs/TODO/205 M7). It has no key either. */ +export const COURSE_SKIP_KEY = 'VirtCourseSkip'; + export const GLOBAL_BINDINGS: readonly Binding[] = [ // ? toggles the controls guide (plain / is the classic decelerate key) { key: 'Question', command: 'toggleHelp' }, diff --git a/src/game/cockpit-view.ts b/src/game/cockpit-view.ts index fd9dc576..b61814ca 100644 --- a/src/game/cockpit-view.ts +++ b/src/game/cockpit-view.ts @@ -35,7 +35,8 @@ import { keyCodeIfBound, keyIfBound } from '../ui/key-help.ts'; import type { HudButton } from '../hud/hud-buttons.ts'; import type { CoursePanel } from './course-actions.ts'; import { COURSE_NAMES } from './courses.ts'; -import { COURSE_KEYS, COURSE_TOGGLE_KEY } from './bindings.ts'; +import { SKIP_SPEED } from '../constants/course.ts'; +import { COURSE_KEYS, COURSE_SKIP_KEY, COURSE_TOGGLE_KEY } from './bindings.ts'; import type { ControlMode } from './controls.ts'; import type { ExerciseStrip } from './combat-sim-strip.ts'; import type { Ordnance } from './ordnance.ts'; @@ -88,8 +89,10 @@ export interface CockpitHost { */ export function courseButtonsFor(p: CoursePanel, chart: string | null): HudButton[] { if (p.rows === null) { - return p.current === null ? [] - : [{ code: COURSE_TOGGLE_KEY, label: COURSE_NAMES[p.current], lit: true, hint: 'CHOOSE SOMEWHERE ELSE' }]; + return p.current === null ? [] : [ + { code: COURSE_TOGGLE_KEY, label: COURSE_NAMES[p.current], lit: true, hint: 'CHOOSE SOMEWHERE ELSE' }, + skipButton(p), + ].filter((b): b is HudButton => b !== null); } const out: HudButton[] = p.rows.map((c) => ({ code: COURSE_KEYS[c.kind], label: c.what, ...(c.why === null ? {} : { note: c.why }), @@ -99,6 +102,18 @@ export function courseButtonsFor(p: CoursePanel, chart: string | null): HudButto return out; } +/** The fast forward button, while a course flies (docs/TODO/205 M7). */ +function skipButton(p: CoursePanel): HudButton | null { + if (!p.skip) return null; + if (p.skip.on) { + return { code: COURSE_SKIP_KEY, label: 'FAST FORWARD IS ON', lit: true, hint: 'BACK TO NORMAL SPEED' }; + } + return { + code: COURSE_SKIP_KEY, label: 'FAST FORWARD', + ...(p.skip.block === null ? { hint: `TIME RUNS ${SKIP_SPEED} TIMES FASTER` } : { note: p.skip.block }), + }; +} + export class CockpitView { private readonly state: GameState; private readonly ordnance: Ordnance; diff --git a/src/game/course-actions.ts b/src/game/course-actions.ts index dd7ea6d4..ece8a3cb 100644 --- a/src/game/course-actions.ts +++ b/src/game/course-actions.ts @@ -20,7 +20,9 @@ import { courseList, type Course, type CourseKind, type CourseSituation, type Co import type { checkJump } from './hyperspace.ts'; import type { GameState } from './state.ts'; import type { Input } from '../engine/input.ts'; -import { COURSE_KEYS, COURSE_TOGGLE_KEY } from './bindings.ts'; +import { COURSE_KEYS, COURSE_SKIP_KEY, COURSE_TOGGLE_KEY } from './bindings.ts'; +import { hostilesNear } from './hostility.ts'; +import { SKIP_SPEED } from '../constants/course.ts'; /** * What the course buttons show in flight: the list, or the course under way. @@ -29,6 +31,12 @@ import { COURSE_KEYS, COURSE_TOGGLE_KEY } from './bindings.ts'; export interface CoursePanel { readonly rows: readonly Course[] | null; readonly current: CourseKind | null; + /** + * The fast forward button, while a course flies: whether it is on, and why + * it cannot start, or null when it can. Null for the whole field with no + * course. + */ + readonly skip: { readonly on: boolean; readonly block: string | null } | null; } const KINDS = Object.keys(COURSE_KEYS) as CourseKind[]; @@ -54,6 +62,12 @@ export class CourseActions { * show, and never what the ship does, so no save carries it. */ private opened = false; + /** + * The fast forward button is on (docs/TODO/205 M7). Like `opened`, it is + * how fast time passes for the player, and never what the world does. So no + * save carries it, and a restore starts at normal speed. + */ + private skipping = false; constructor(state: () => GameState, host: CourseHost) { this.state = state; @@ -69,9 +83,49 @@ export class CourseActions { return { rows: current === null || this.opened ? this.list('flight') : null, current, + skip: current === null ? null : { on: this.skipping, block: this.skipBlock() }, }; } + /** + * How many fixed steps one screen frame runs: `SKIP_SPEED` under fast + * forward, and one otherwise. The Game's loop multiplies its time by it. + */ + get speed(): number { + return this.skipping ? SKIP_SPEED : 1; + } + + /** + * Why fast forward cannot run now, or null when it can. It runs only while a + * course flies, and only while the condition light is not red. So it + * shortens a wait, and it never flies a fight. + */ + private skipBlock(): string | null { + const s = this.state(); + if (s.session.course === null) return 'CHOOSE WHERE TO GO FIRST'; + if (hostilesNear(s.world.npcs, s.player.position, s.commander.legalStatus, + s.player.position.distanceTo(s.world.station.position))) { + return 'NOT WITH A HOSTILE SHIP NEARBY'; + } + return null; + } + + /** + * After each step: fast forward stops by itself when it may no longer run. + * The console says why when a hostile ship is the reason. + * + * @internal — driven by src/game/game.ts, once per fixed step. + */ + watchSkip(): void { + if (!this.skipping) return; + const block = this.skipBlock(); + if (block === null) return; + this.skipping = false; + if (this.state().session.course !== null) { + this.host.showMessage('HOSTILE SHIP NEARBY — BACK TO NORMAL SPEED', 3); + } + } + /** * A course button was pressed in flight. The codes are `COURSE_KEYS` and @@ -85,6 +139,14 @@ export class CourseActions { this.opened = !this.opened; return; } + // The fast forward button. A second press stops it. + if (i.pressed(COURSE_SKIP_KEY)) { + const block = this.skipBlock(); + if (this.skipping) this.skipping = false; + else if (block === null) this.skipping = true; + else { this.host.showMessage(block, 3); this.host.refused(); } + return; + } for (const kind of KINDS) { if (i.pressed(COURSE_KEYS[kind])) { if (this.pick(kind, 'flight')) this.opened = false; diff --git a/src/game/game.ts b/src/game/game.ts index 1d770761..c808caef 100644 --- a/src/game/game.ts +++ b/src/game/game.ts @@ -792,16 +792,19 @@ export class Game { let accumulator = 0; let simTime = 0; this.shell.runLoop((now: number): void => { - accumulator += Math.min((now - last) / 1000, MAX_FRAME_TIME); + // Fast forward runs more steps in each frame, and changes no step + // (docs/TODO/205 M7). A device that cannot keep up runs slower. + const speed = this.courses_.speed; + accumulator += Math.min((now - last) / 1000, MAX_FRAME_TIME) * speed; last = now; let steps = 0; - while (accumulator >= FIXED_DT && steps < MAX_STEPS_PER_FRAME) { + while (accumulator >= FIXED_DT && steps < MAX_STEPS_PER_FRAME * speed) { simTime += FIXED_DT; this.step(FIXED_DT, simTime); accumulator -= FIXED_DT; steps += 1; } - if (steps === MAX_STEPS_PER_FRAME) accumulator = 0; // gave up catching up + if (steps === MAX_STEPS_PER_FRAME * speed) accumulator = 0; // gave up catching up this.draw(FIXED_DT); }); } @@ -1023,7 +1026,9 @@ export class Game { * whatever the frame rate. */ step(dt: number, elapsed: number): void { - tickMessage(this.state.session, dt); + // A console line keeps its time in the player's seconds under fast + // forward, so it can still be read (docs/TODO/205 M7). + tickMessage(this.state.session, dt / this.courses_.speed); // Flight is the only state that can be paused. While it is paused, route // input through the same command table as any other frame, but apply only // what a paused cockpit answers — controls.ts's WHILE_PAUSED. @@ -1045,6 +1050,7 @@ export class Game { } this.tunnel.update(dt); if (this.mode === 'flight') this.flight_.update(dt, elapsed); + this.courses_.watchSkip(); this.finishStep(dt); } diff --git a/test/constants.test.ts b/test/constants.test.ts index 578bf931..9f47deb9 100644 --- a/test/constants.test.ts +++ b/test/constants.test.ts @@ -465,7 +465,7 @@ const OUTSIDE: readonly Group[] = [ // ...and the codes a course row sends, on both of its surfaces (docs/TODO/205 M4) 'game/bindings.ts': [ 'GLOBAL_BINDINGS', 'FLIGHT_BINDINGS', 'NOT_IN_THE_SIMULATOR', 'BINDINGS', - 'WHILE_PAUSED', 'COURSE_KEYS', 'COURSE_CHART_KEY', 'COURSE_TOGGLE_KEY', + 'WHILE_PAUSED', 'COURSE_KEYS', 'COURSE_CHART_KEY', 'COURSE_TOGGLE_KEY', 'COURSE_SKIP_KEY', ], 'game/screens/save-transfer.ts': ['NOT_A_SAVE', 'WRONG_VERSION', 'STORE_FULL'], 'engine/keymap.ts': ['LAYOUTS', 'STORAGE_KEY'], diff --git a/test/course-buttons.test.ts b/test/course-buttons.test.ts index d40cd887..e739ee9e 100644 --- a/test/course-buttons.test.ts +++ b/test/course-buttons.test.ts @@ -55,8 +55,8 @@ function press(g: Game, code: string): void { press(g, COURSE_KEYS.station); eq('the station button picks the station course', g.state.session.course, 'station'); eq('...and the list folds away', g.coursePanel()?.rows ?? null, null); - eq('...leaving one button that says what the ship is doing', - courseButtonsFor(g.coursePanel()!, null).map((b) => b.label).join(), 'HEADING TO THE STATION'); + eq('...leaving a button that says what the ship is doing, and fast forward', + courseButtonsFor(g.coursePanel()!, null).map((b) => b.label).join(), 'HEADING TO THE STATION,FAST FORWARD'); press(g, COURSE_TOGGLE_KEY); check('that button opens the list again over the course', (g.coursePanel()?.rows?.length ?? 0) > 0); diff --git a/test/elite-a-live-combat.test.ts b/test/elite-a-live-combat.test.ts index b6418bb1..184cca4b 100644 --- a/test/elite-a-live-combat.test.ts +++ b/test/elite-a-live-combat.test.ts @@ -326,12 +326,14 @@ console.log('\nlive combat — regeneration'); // A backgrounded tab hands the loop one enormous frame. It never reaches a // ship, because game.ts clamps the accumulator and caps the catch-up steps — // asserted here against the source, since a regeneration rule that IS - // per-frame can only be as safe as the loop that feeds it. + // per-frame can only be as safe as the loop that feeds it. Fast forward + // (docs/TODO/205 M7) scales the clamp and the cap by one fixed speed, so a + // frame still banks a bounded amount of world time. const loop = readFileSync(new URL('../src/game/game.ts', import.meta.url), 'utf8'); check('the frame loop clamps a long frame and gives up catching up', - /accumulator \+= Math\.min\(\(now - last\) \/ 1000, MAX_FRAME_TIME\)/.test(loop) - && /steps < MAX_STEPS_PER_FRAME/.test(loop) - && /if \(steps === MAX_STEPS_PER_FRAME\) accumulator = 0/.test(loop)); + /accumulator \+= Math\.min\(\(now - last\) \/ 1000, MAX_FRAME_TIME\) \* speed/.test(loop) + && /steps < MAX_STEPS_PER_FRAME \* speed/.test(loop) + && /if \(steps === MAX_STEPS_PER_FRAME \* speed\) accumulator = 0/.test(loop)); const twoSteps = ship(60); twoSteps.n.regenerate(1 / 60); twoSteps.n.regenerate(1 / 60); diff --git a/test/run.ts b/test/run.ts index b43da323..b601acd4 100644 --- a/test/run.ts +++ b/test/run.ts @@ -75,6 +75,7 @@ import './courses.test.ts'; import './course-pilot.test.ts'; import './course-launch.test.ts'; import './course-buttons.test.ts'; +import './skip.test.ts'; import './world.test.ts'; import './docking.test.ts'; import './docking-computer.test.ts'; diff --git a/test/skip.test.ts b/test/skip.test.ts new file mode 100644 index 00000000..12704709 --- /dev/null +++ b/test/skip.test.ts @@ -0,0 +1,123 @@ +// The fast forward button (docs/TODO/205 M7). +// +// Chris's words of 2026-09-11: *"instead of being able to cheat the mass lock +// we just skip time forward."* So fast forward runs more fixed steps in each +// screen frame, and it changes no step. The first block proves that claim: a +// trip under fast forward and a trip at normal speed end in the same world, +// step for step. The rest prove each way that fast forward stops by itself. + +import * as THREE from 'three'; +import { Game } from '../src/game/game.ts'; +import { headlessShell } from '../src/engine/shell.ts'; +import { withoutSaving } from '../src/game/storage.ts'; +import { restoreRng, rngState, seedWorld } from '../src/game/rng.ts'; +import { COURSE_SKIP_KEY } from '../src/game/bindings.ts'; +import { SKIP_SPEED } from '../src/constants/course.ts'; +import { check, dismissBriefing, eq } from './harness.ts'; + +console.log('\nfast forward'); + +/** A commander at the witchpoint on the station course, past both tunnels. */ +function onCourse(seed: number): Game { + const g = withoutSaving(() => { + seedWorld(seed); + const game = new Game(() => headlessShell()); + dismissBriefing(game); + game.launch(); + return game; + }).value; + const settle = (): void => { + withoutSaving(() => { for (let f = 0, at = 0; f < 400; f++) g.step(1 / 60, at += 1 / 60); }); + }; + settle(); + g.arriveInSystem(); + settle(); + g.state.session.course = 'station'; + return g; +} + +function run(g: Game, steps: number, from = 10): void { + withoutSaving(() => { for (let f = 0; f < steps; f++) g.step(1 / 60, from + f / 60); }); +} + +function press(g: Game, code: string): void { + g.input.injectPress(code); + run(g, 1, 5); +} + +/** The world a step leaves, without the console, which counts the player's time. */ +function world(g: Game): string { + const r = (v: THREE.Vector3 | THREE.Quaternion) => v.toArray().map((x) => x.toFixed(6)).join(); + const { messageText, messageTimer, queued, ...session } = g.state.session; + void messageText; void messageTimer; void queued; + return JSON.stringify({ + player: [r(g.state.player.position), r(g.state.player.quaternion), g.state.player.speed.toFixed(6)], + npcs: g.state.world.npcs.map((n) => [n.role, n.state.alive, r(n.object.position)]), + commander: [g.state.commander.fuel, g.state.commander.credits], + session, + }); +} + +{ + // Both games draw from ONE seeded stream (game/rng.ts). So each trip starts + // from the same point of it, or the second trip sees other numbers. + const quiet = (n: Game): void => { + for (const s of n.state.world.npcs) if (s.role === 'pirate' || s.role === 'hunter') s.state.alive = false; + }; + const normal = onCourse(20_260_919); + quiet(normal); + const start = rngState(); + press(normal, 'Unbound'); + run(normal, 1200); + + const fast = onCourse(20_260_919); + quiet(fast); + restoreRng(start); + press(fast, COURSE_SKIP_KEY); + eq('the button turns fast forward on', fast.coursePanel()?.skip?.on, true); + eq('...and the loop runs the fixed step that many times in a frame', (fast as unknown as { + courses_: { speed: number } }).courses_.speed, SKIP_SPEED); + run(fast, 1200); + eq('a trip under fast forward and a trip at normal speed reach the same world, step for step', + world(fast), world(normal)); + run(fast, 1, 40); + check('...where one step more is a different world (the control)', world(fast) !== world(normal)); +} + +{ + const g = onCourse(20_260_920); + for (const s of g.state.world.npcs) if (s.role === 'pirate' || s.role === 'hunter') s.state.alive = false; + press(g, COURSE_SKIP_KEY); + press(g, COURSE_SKIP_KEY); + eq('a second press stops fast forward', g.coursePanel()?.skip?.on, false); + + press(g, COURSE_SKIP_KEY); + g.input.press('ArrowUp'); + run(g, 1, 6); + g.input.release('ArrowUp'); + eq('a flight key takes the ship, and fast forward stops with the course', g.coursePanel()?.skip ?? null, null); +} + +{ + const g = onCourse(20_260_921); + for (const s of g.state.world.npcs) if (s.role === 'pirate' || s.role === 'hunter') s.state.alive = false; + press(g, COURSE_SKIP_KEY); + // A pirate appears beside the ship, as the encounters put one. + const pirate = g.state.world.spawn('pirate', + g.state.player.position.clone().add(new THREE.Vector3(0, 0, -1500)), 7); + pirate.state.provokedByPlayer = true; + run(g, 2, 7); + eq('a hostile ship nearby stops fast forward by itself', g.coursePanel()?.skip?.on, false); + eq('...and the console says why', g.state.session.messageText, 'HOSTILE SHIP NEARBY — BACK TO NORMAL SPEED'); + + press(g, COURSE_SKIP_KEY); + eq('...and with the hostile ship still there, the button refuses', g.coursePanel()?.skip?.on, false); + eq('...and says why', g.state.session.messageText, 'NOT WITH A HOSTILE SHIP NEARBY'); +} + +{ + const g = onCourse(20_260_922); + g.state.session.course = null; + press(g, COURSE_SKIP_KEY); + check('with no course there is no fast forward button', g.coursePanel()?.skip === null); +} From e696336a1267f0f221d66c780d8b646dade0190a Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Fri, 11 Sep 2026 22:54:08 +0100 Subject: [PATCH 019/100] docs/TODO/205 M6 lands 205: the manual and the briefing teach the buttons The manual's first hour and the briefing's FLY THERE page now teach the launch list, FLY TO THE STATION and FAST FORWARD, in place of the jump key and the torus key. The manual says that a steering key takes the controls back. The briefing's journey test now asks for the buttons. The browser run found two faults. The station menu's two columns split the launch list, so the list has one column. The course buttons showed during a tunnel, where a press does nothing, so none show then. 205 lands: the flight probe runs, and the dock probe docks 504 of 504 approaches with no scrape. 5,733 assertions. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- docs/TODO/QUEUE.json | 1 - docs/TODO/README.md | 17 +++++++--- ...the-ship-goes-and-the-ship-flies-itself.md | 31 +++++++++++++++++ docs/TODO/completed/README.md | 1 + manual.html | 33 ++++++++++++++----- src/game/courses.ts | 2 +- src/game/game.ts | 6 ++-- src/style.css | 9 +++++ src/ui/briefing.ts | 31 +++++++++-------- src/ui/screens-courses.ts | 6 ++-- test/key-help.test.ts | 9 ++++- 11 files changed, 110 insertions(+), 36 deletions(-) rename docs/TODO/{ => completed}/205-the-pilot-picks-where-the-ship-goes-and-the-ship-flies-itself.md (93%) diff --git a/docs/TODO/QUEUE.json b/docs/TODO/QUEUE.json index 22d804bd..d82fa14b 100644 --- a/docs/TODO/QUEUE.json +++ b/docs/TODO/QUEUE.json @@ -1,7 +1,6 @@ { "version": 1, "items": [ - 205, 206, 207, 208 diff --git a/docs/TODO/README.md b/docs/TODO/README.md index 20dae05a..a96af9e3 100644 --- a/docs/TODO/README.md +++ b/docs/TODO/README.md @@ -13,10 +13,9 @@ active context: ## Execution queue -1. [205](205-the-pilot-picks-where-the-ship-goes-and-the-ship-flies-itself.md) — the pilot picks where the ship goes, and the ship flies itself. -2. [206](206-the-computer-flies-the-fight-and-the-pilot-fires.md) — the computer flies the fight, and the pilot fires. -3. [207](207-the-pilot-takes-the-ship-into-the-slot-by-hand.md) — the pilot takes the ship into the slot by hand. -4. [208](208-every-kind-of-mission-has-a-way-to-fly-it.md) — every kind of mission has a way to fly it. +1. [206](206-the-computer-flies-the-fight-and-the-pilot-fires.md) — the computer flies the fight, and the pilot fires. +2. [207](207-the-pilot-takes-the-ship-into-the-slot-by-hand.md) — the pilot takes the ship into the slot by hand. +3. [208](208-every-kind-of-mission-has-a-way-to-fly-it.md) — every kind of mission has a way to fly it. **205 TO 208 CAME FROM CHRIS ON 2026-09-11, the day 204 landed.** He flew the touch controls of 204 on a phone, and he could not fly the ship. He @@ -26,7 +25,7 @@ pilot fires the laser, the missiles and the E.C.M. The dock stays a challenge. The missions become part of the flight. 205 also takes out the touch controls of 204. He played four docking concepts the same day, and he picked Match the spin for 207. The plans are written, and the work waits -on his word. +on his word. **205 landed the same day**, and it is below. **204 CAME FROM CHRIS ON 2026-09-10.** The docked screens and the cockpit fit a phone, and nothing on the flight screen takes a touch. The brainstorm set @@ -298,6 +297,14 @@ it: *"display is good"*. **#23** closed with 134, as #22 did with 127, #18 with ## What landed on 2026-09-11 +**205 — the pilot picks where the ship goes, and the ship flies itself.** +The LAUNCH row asks where to go, and a ship with nowhere to go stays on the +pad. In flight, buttons over the view show where the ship can go: the +station, a derelict, the rock hermit and the star. A click or a tap sends the +ship, and a flight key takes it back. FAST FORWARD runs the world eight times +faster while nothing hostile is near. The work found a hermit that could +appear inside the planet, and nothing does now. 5,733 assertions, from 5,624. + **204 — the ship flies by touch.** Nothing on the flight screen took a touch. A drag anywhere on the view is the mouse stick now, and a held finger holds it. FIRE holds the trigger. A slider sets a wanted speed, and diff --git a/docs/TODO/205-the-pilot-picks-where-the-ship-goes-and-the-ship-flies-itself.md b/docs/TODO/completed/205-the-pilot-picks-where-the-ship-goes-and-the-ship-flies-itself.md similarity index 93% rename from docs/TODO/205-the-pilot-picks-where-the-ship-goes-and-the-ship-flies-itself.md rename to docs/TODO/completed/205-the-pilot-picks-where-the-ship-goes-and-the-ship-flies-itself.md index 00c0c5cf..888e37d3 100644 --- a/docs/TODO/205-the-pilot-picks-where-the-ship-goes-and-the-ship-flies-itself.md +++ b/docs/TODO/completed/205-the-pilot-picks-where-the-ship-goes-and-the-ship-flies-itself.md @@ -438,3 +438,34 @@ Evidence: - **The skip stops at the condition light's own rule.** `hostilesNear` turns the light red, so the pilot sees the same reason on the dashboard. - **The suite has 5,732 assertions,** from 5,721. + +### M6 + +- **The manual and the briefing now teach the buttons.** The launch list, + FLY TO THE STATION and FAST FORWARD replace the jump key and the torus key + in the first journey. The manual says that a steering key takes the + controls back. +- **The briefing's own test pinned the old journey.** `test/key-help.test.ts` + asked the briefing to quote the jump key and the torus key. It now asks it + to name the three buttons instead. +- **The fight text and the docking text wait for 206 and 207.** Those plans + change what they describe. +- **The browser run on 2026-09-11 found two faults, and both are mended.** + The station menu's two columns split the launch list, so the list has one + column. The course buttons showed during a tunnel, where a press does + nothing, so the cockpit shows none then. + +## Outcome + +205 landed on 2026-09-11. The pilot picks where the ship goes, and the ship +flies itself. The launch list asks where to go, and a ship with nowhere to go +stays on the pad. In flight, buttons over the view show the courses: the +station, the derelict, the hermit and the star. FAST FORWARD runs the world +eight times faster while nothing hostile is near, and it changes no step. The +work found and mended a hermit that could appear inside the planet. + +The measurements: the station course docked 50 of 50 trips, with a median of +148 s in the arrival's traffic. The hermit, derelict and star courses arrived +20 of 20, 20 of 20 and 40 of 40 times. The dock probe docked 504 of 504 +approaches with no scrape. The suite has 5,733 assertions, from 5,619 before +204. diff --git a/docs/TODO/completed/README.md b/docs/TODO/completed/README.md index 5d6964a9..547490a3 100644 --- a/docs/TODO/completed/README.md +++ b/docs/TODO/completed/README.md @@ -214,3 +214,4 @@ Supporting records: [Elite-A alignment plan](ELITE-A-COMBAT-PLAN.md), - [x] 201 — [A held mission keeps its briefing](201-a-held-mission-keeps-its-briefing.md) — Chris's playtest, 2026-09-10. An offer row showed the dossier's title and briefing, and a held row showed the current order alone. **M1** gives a held row the title and the pages, filled with the world it was accepted at, and draws the order under them in amber. 5,567 assertions. - [x] 202 — [The station menu takes a tap or the cursor](202-the-station-menu-takes-a-tap-or-the-cursor.md) — Chris, 2026-09-10. ⇧R opened the missions when the game missed the Shift keydown. **M1** makes a real key press carry the event's own modifier. **M2** makes every station command a row on a virtual code, with no letter and no shift, nineteen rows in two columns. **M3** and **M4** take the letters out of the briefing, the boot plate, the README and the manual. Every flight key stays. 5,576 assertions. - [x] 203 — [A mission tells the player where to go](203-a-mission-tells-the-player-where-to-go.md) — Chris's playtest, 2026-09-10. The game never sent the machine an arrival or a day, so one job could not complete and no deadline passed. **M1** sends both. **M2** spawns a target inside the scanner, keeps a scan's subject, and puts pirates on the lane. **M3** marks the target on the scanner and the screen. **M4** makes the console speak at every change, in full sentences. **M5** counts a scan while the subject is in view, with no missile. **M6** says how a job plays in the manual. 5,619 assertions. +- [x] 205 — [The pilot picks where the ship goes, and the ship flies itself](205-the-pilot-picks-where-the-ship-goes-and-the-ship-flies-itself.md) — Chris, 2026-09-11. **M1** takes out the touch controls of 204. **M2** is the course list, **M3** the pilot that flies it, **M4** the launch list and **M5** the buttons in flight. **M6** is the manual and the briefing, and **M7** is FAST FORWARD. 5,733 assertions. diff --git a/manual.html b/manual.html index bcaebf69..6e8488be 100644 --- a/manual.html +++ b/manual.html @@ -45,12 +45,16 @@

Your First Flight

  • Pick somewhere to sell it. LOCAL CHART on the station menu opens the short range chart. Anything inside the dashed circle is within your fuel. Industrial worlds pay well for what agricultural worlds grow.
    • -
  • Target it and jump. Move the cursor with the arrow keys, - press ENTER to target, then LAUNCH from the station - menu and H to make the jump.
    • -
  • Fly to the station. You arrive a long way out. Point at the - planet and press J for the torus drive; it cuts out near - anything solid, including pirates.
    • +
  • Target it and jump. Click the world on the chart (or move + the cursor with the arrow keys and press ENTER). Then + press LAUNCH on the station menu. The station asks where you + want to go: choose JUMP TO your target, and the ship leaves + and makes the jump by itself.
    • +
  • Fly to the station. You arrive a long way out. The buttons + at the top right show where the ship can go. Choose FLY TO THE + STATION and it flies there on the torus drive, which cuts out + near anything solid, including pirates. FAST FORWARD speeds + up the wait while nobody hostile is near.
  • Dock. Line up with the rotating port and go in slowly. See Docking. It is the hardest thing you will do today.
    • @@ -133,6 +137,15 @@

    Controls

    station menu. Arrow keys fly in both, flight-style, so pull back to climb.

    +

    + You do not need the keys to play. In flight, the buttons at the top + right of the screen show where the ship can go next: the station, a + derelict, the hermit, the star, the next jump. Click one, or tap it + on a phone, and the ship flies there by itself. A dimmed button says + what you need before you can use it. FAST FORWARD makes the + trip quicker while nothing hostile is near. Touch a flight key at any + time and you have the controls back. +

    Loading bindings…

    @@ -234,9 +247,11 @@

    Hyperspace & the Charts

    You arrive at the witch-point, a long way out from the planet, and the - journey in is part of the game. That is what the torus drive - (J) is for. It disengages near anything with mass: a planet, a - station, or somebody who wants your cargo. + journey in is part of the game. Choose FLY TO THE STATION and + the ship takes you in on the torus drive (J if you fly by + hand). It disengages near anything with mass: a planet, a station, or + somebody who wants your cargo. When the space around you is clear + again, the ship starts the drive again by itself.

    diff --git a/src/game/courses.ts b/src/game/courses.ts index f84c6d88..a2ad578e 100644 --- a/src/game/courses.ts +++ b/src/game/courses.ts @@ -130,7 +130,7 @@ function jumpRow(w: CourseWorld, launch: boolean): Course | null { if (!launch && !w.jump.ok && w.jump.reason === 'noTarget') return null; return { kind: 'jump', - what: w.targetName === null ? 'JUMP' : `JUMP TO ${w.targetName.toUpperCase()}`, + what: w.targetName === null ? 'JUMP TO ANOTHER SYSTEM' : `JUMP TO ${w.targetName.toUpperCase()}`, why: w.jump.ok ? null : JUMP_WHY[w.jump.reason], }; } diff --git a/src/game/game.ts b/src/game/game.ts index c808caef..5c7dfc98 100644 --- a/src/game/game.ts +++ b/src/game/game.ts @@ -451,8 +451,10 @@ export class Game { setSightLit: (on) => this.shell.setSightLit(on), view: () => this.render, // The course buttons, in career flight only. An exercise is a room at - // the station, and it has nowhere to go (docs/TODO/205 M5). - coursePanel: () => (this.flight_.inSimulator() ? null : this.courses_.panel()), + // the station, and it has nowhere to go (docs/TODO/205 M5). During a + // tunnel the cockpit reads no button, so it shows none. + coursePanel: () => (this.flight_.inSimulator() || this.tunnel.active + ? null : this.courses_.panel()), } satisfies CockpitHost); /** diff --git a/src/style.css b/src/style.css index 1753adeb..6e558887 100644 --- a/src/style.css +++ b/src/style.css @@ -866,6 +866,15 @@ body.screen-open #exercise { display: none; } #screen .menu div[data-key] { cursor: pointer; padding: 0 8px; border-left: 2px solid transparent; } #screen .menu div[data-key]:hover { background: rgba(var(--hud-green-rgb), 0.14); border-left-color: var(--hud-green); } #screen .menu div[data-key].sel { background: rgba(var(--hud-green-rgb), 0.2); border-left-color: var(--hud-green); } +/* + * The launch list (docs/TODO/205 M4): a short list, so one column even where + * the station menu takes two. A row the ship cannot fly is dimmed, and its + * reason sits on a line of its own under it. + */ +#screen .menu.course-list { column-count: 1; margin-left: 14%; margin-right: 14%; line-height: 1.6; } +#screen .menu.course-list div[data-key] { padding-top: 6px; padding-bottom: 6px; } +#screen .menu.course-list div.blocked { color: rgba(var(--hud-green-rgb), 0.55); } +#screen .menu.course-list .why { display: block; font-size: 11px; color: var(--hud-amber); letter-spacing: 1px; } #screen tr.pick { cursor: pointer; } #screen tr.pick:hover td { background: rgba(var(--hud-green-rgb), 0.14); } #screen tr.sel.pick:hover td { background: var(--hud-green); } diff --git a/src/ui/briefing.ts b/src/ui/briefing.ts index 1de9cd7c..284d72ba 100644 --- a/src/ui/briefing.ts +++ b/src/ui/briefing.ts @@ -40,8 +40,6 @@ import { COMMAND_HELP } from '../game/command-help.ts'; // consequences. The complete key map is the `?` guide and the manual. const KEY = { help: boundKey('docked', 'toggleHelp'), - jump: boundKey('flight', 'startHyperspace'), - torus: boundKey('flight', 'toggleTorus'), dockingComputer: boundKey('flight', 'toggleDockingComputer'), jettison: boundKey('flight', 'jettison1'), ecm: boundKey('flight', 'fireEcm'), @@ -89,22 +87,27 @@ export const BRIEFING: { title: string; body: string }[] = [ body: `Open ${ROW.localChart} on the station menu.

    The dashed circle is how far your fuel will take you — ${MAX_FUEL / 10} light years on a full tank. Anything inside it you can reach.

    - Move the cursor with the arrow keys, press ENTER to set your - target, D for a full report on a world, and F to search by - name. Look for an economy opposite to this one.`, + Click or tap a world to set your target. You can also move the cursor + with the arrow keys and press ENTER. D gives a full + report on a world, and F searches by name. Look for an economy + opposite to this one.`, }, { title: 'FLY THERE', - body: `${ROW.launch} from the station menu, then ${KEY.jump} - to jump once you are clear of the station. The game saves on its own: a checkpoint at - every docking, and an autosave every ${AUTOSAVE_INTERVAL} seconds in - flight.

    - You come out of hyperspace a long way from the planet. Point at it and - press ${KEY.torus} for the torus drive — ${TORUS_MULTIPLIER} times speed. It cuts out near - anything with mass: a planet, a station, or somebody who has come to meet - you.

    + body: `Press ${ROW.launch} on the station menu. The station asks + where you want to go: choose JUMP TO your target, and the ship + leaves and makes the jump by itself. The game saves on its own: a + checkpoint at every docking, and an autosave every ${AUTOSAVE_INTERVAL} + seconds in flight.

    + You come out of hyperspace a long way from the planet. The buttons at + the top right show where the ship can go. Choose + FLY TO THE STATION and it flies there on the torus drive, at + ${TORUS_MULTIPLIER} times speed. The drive cuts out near anything with mass: a planet, a + station, or somebody who has come to meet you. FAST FORWARD makes + the trip quicker while nothing hostile is near.

    Watch the scanner in the middle of the console. You are the centre. Red - contacts are hostile.`, + contacts are hostile. Press a steering key at any time and you fly the + ship by hand.`, }, { title: 'A FIGHT', diff --git a/src/ui/screens-courses.ts b/src/ui/screens-courses.ts index 1caa1cf7..56b93a2a 100644 --- a/src/ui/screens-courses.ts +++ b/src/ui/screens-courses.ts @@ -18,15 +18,15 @@ export interface CourseRow { export function renderLaunchCourses(rows: readonly CourseRow[], chartCode: string): void { const line = (r: CourseRow): string => r.course.why === null ? `
    ${r.course.what}
    ` - : `
    ${r.course.what}` - + ` — ${r.course.why}
    `; + : `
    ${r.course.what}` + + `${r.course.why}
    `; show(`

    LAUNCH

    CHOOSE WHERE TO GO
    -
    +
    ${rows.map(line).join('\n ')}
    GALACTIC CHART — PICK A SYSTEM TO JUMP TO
    diff --git a/test/key-help.test.ts b/test/key-help.test.ts index 697d647d..2b9319fe 100644 --- a/test/key-help.test.ts +++ b/test/key-help.test.ts @@ -292,9 +292,12 @@ console.log('\nthe briefing surfaces the whole first journey'); // with the key the table actually binds; the pages interpolate `boundKey`, // so a REBOUND key rewrites its own prose, and what this holds is that the // guidance is not REMOVED — docs/TODO/106 milestone 3. + // + // The jump and the trip in are buttons since docs/TODO/205: the launch list + // and the course buttons in flight. So the briefing names those buttons' + // words, and the two keys that used to carry the trip leave this list. const journey: [ControlMode, Command][] = [ ['docked', 'toggleHelp'], - ['flight', 'startHyperspace'], ['flight', 'toggleTorus'], ['flight', 'armMissile'], ['flight', 'launchMissile'], ['flight', 'fireEcm'], ['flight', 'jettison1'], ['flight', 'toggleDockingComputer'], @@ -311,6 +314,10 @@ console.log('\nthe briefing surfaces the whole first journey'); unnamed.length === 0, unnamed.join(', ')); check(`every journey command is quoted with its bound key (${journey.length})`, unquoted.length === 0, unquoted.join(', ')); + const buttons = ['JUMP TO', 'FLY TO THE STATION', 'FAST FORWARD']; + const untaught = buttons.filter((b) => !text.includes(`${b}`)); + check(`...and every button of the trip is named (${buttons.length})`, + untaught.length === 0, untaught.join(', ')); // The control: a bound key the briefing deliberately does not teach. check('...and the check can fail — the briefing does not quote ⇧Y', From 30858bb4f7302eb4f89af1fae93e2c01c524467d Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Fri, 11 Sep 2026 22:58:17 +0100 Subject: [PATCH 020/100] docs/TODO/206 M1: the target list says what the ship can fight The new game/targets.ts lists every ship, rock and derelict within scanner range. The ships that attack come first, nearest first, and the rest follow. Each row says what the ship is, and what an attack costs where the law protects it. A trader is on the list (Chris). The pilot's pick is one flag on the picked ship's state, so a save carries it with the ship. It sits on top of threat-lock.ts, which keeps its rule for the three places that share it. 5,746 assertions, from 5,733. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- docs/ARCHITECTURE.md | 4 + ...ter-flies-the-fight-and-the-pilot-fires.md | 16 +++ src/game/npc-state.ts | 9 +- src/game/targets.ts | 107 ++++++++++++++++++ test/constants.test.ts | 2 + test/run.ts | 1 + test/targets.test.ts | 60 ++++++++++ 7 files changed, 198 insertions(+), 1 deletion(-) create mode 100644 src/game/targets.ts create mode 100644 test/targets.test.ts diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md index 546f9d85..2caf01bc 100644 --- a/docs/ARCHITECTURE.md +++ b/docs/ARCHITECTURE.md @@ -171,6 +171,10 @@ Two quirks are deliberate: both callers agree. `combat.ts` takes each ingredient separately, so a test can drive it. `combat-player.ts` is the assembly step that builds the player's own trigger out of one `GameState`. +- `src/game/targets.ts` lists what the ship can fight, and holds the pilot's + pick (docs/TODO/206). The pick is one flag on the picked ship's own state, + so a save carries it. It sits on top of `threat-lock.ts`, and never changes + that rule. - `src/game/threat.ts` computes the pirate count, the group tier and the organisation from the visible value and the reputation. `ship-specs.ts` maps a tier to a hull. The campaign simulator calls the same rules. diff --git a/docs/TODO/206-the-computer-flies-the-fight-and-the-pilot-fires.md b/docs/TODO/206-the-computer-flies-the-fight-and-the-pilot-fires.md index 38e97300..9419edff 100644 --- a/docs/TODO/206-the-computer-flies-the-fight-and-the-pilot-fires.md +++ b/docs/TODO/206-the-computer-flies-the-fight-and-the-pilot-fires.md @@ -193,3 +193,19 @@ Evidence: pick of another course. - Chris flies a fight on his phone. His verdict on whether it is FUN is the one measure that no probe reaches. + +## What the milestones found + +### M1 + +- **A ship has no stable id, so the pick is a flag on its state.** + `NpcState.targeted` is saved with each ship, as every field of that state + is. A pick in the session would hold an index into the ships, and the index + moves when a ship leaves. +- **The name a player sees is the scene object's name**, as the arrival + lines use it. +- **The list says what an attack costs in its own words.** `harmVerdict` in + `law.ts` still decides whom the law protects. Its words are for the moment + of the hit, so the list writes THE LAW PROTECTS THIS SHIP instead. The + hermit is not the law's, and the list says what killing him costs. +- **The suite has 5,746 assertions,** from 5,733. diff --git a/src/game/npc-state.ts b/src/game/npc-state.ts index 3f88d74e..62a939fd 100644 --- a/src/game/npc-state.ts +++ b/src/game/npc-state.ts @@ -112,6 +112,13 @@ export interface NpcState { * names. */ missionTag: string | null; + /** + * The pilot picked this ship on the target list (docs/TODO/206 M1). One + * ship at most carries it. The computer then aims at this ship rather than + * at the threat it would choose. It is saved, because it decides what the + * computer flies at. + */ + targeted: boolean; /** seconds under the scanner lock so far: a scan leg's clock */ observed: number; /** the escort or the scan verdict was sent once; it is never sent again */ @@ -261,7 +268,7 @@ export function freshNpcState(maxEnergy: number): NpcState { tumbleAxis: randomDirection(new THREE.Vector3()), energy: maxEnergy, regenCarry: 0, alive: true, provoked: false, provokedByPlayer: false, missiles: 0, - missionTag: null, observed: 0, missionReported: false, fleeing: false, attackPhase: 'closing', underFire: 0, flownBy: 'none', + missionTag: null, targeted: false, observed: 0, missionReported: false, fleeing: false, attackPhase: 'closing', underFire: 0, flownBy: 'none', extendRange: EXTEND_RANGE_MAX, passSide: 1, passesMade: 0, tactic: 'run', tacticClock: 0, dryFor: 0, tradeTimer: 0, diff --git a/src/game/targets.ts b/src/game/targets.ts new file mode 100644 index 00000000..31996357 --- /dev/null +++ b/src/game/targets.ts @@ -0,0 +1,107 @@ +// What the ship can fight, and which one the pilot picked (docs/TODO/206 M1). +// +// In a fight the computer lines the ship up, and the pilot fires. The pilot +// chooses what to fight from this list: every ship, rock and derelict within +// scanner range. Chris's words of 2026-09-11: a trader is on the list, and +// the law answers as it does today. +// +// THE LIST IS DERIVED STATE, as the course list is (`courses.ts`). The pick +// is saved, because it decides what the computer flies at. It is one flag on +// the picked ship's own state, `NpcState.targeted`. A ship has no stable id, +// and its state is saved with it, so the flag goes where the ship goes. +// +// THE PICK SITS ON TOP OF `threat-lock.ts`, and it never changes that rule. +// Three places share the lock: the co-pilot, an armed trader, and the +// training episode. With no pick, the co-pilot takes the lock's threat. +// +// It is pure over the fleet. It spends no rule of its own: who attacks the +// commander is `hostility.ts`, and whom the law protects is `law.ts`. + +import type * as THREE from 'three'; +import type { NpcShip } from './npc.ts'; +import { isHostileToPlayer } from './hostility.ts'; +import { harmVerdict } from './law.ts'; +import { SCANNER_RANGE } from '../constants/console.ts'; + +/** One row of the list. */ +export interface TargetRow { + readonly ship: NpcShip; + /** what the player sees the ship called, as the arrival lines name it */ + readonly name: string; + readonly range: number; + /** what the ship is to the pilot, in the player's words */ + readonly standing: string; + /** what an attack costs, where it costs something beyond the fight */ + readonly cost: string | null; + readonly picked: boolean; +} + +/** Everything the list is raised from. */ +export interface TargetView { + readonly npcs: readonly NpcShip[]; + readonly playerPos: THREE.Vector3; + readonly legalStatus: number; + /** for the station's truce, as `isHostileToPlayer` asks */ + readonly playerToStation: number; +} + +/** What each role is to the pilot, when it is not attacking. */ +const STANDING: Readonly> = { + trader: 'TRADER', + police: 'POLICE', + pirate: 'PIRATE', + hunter: 'BOUNTY HUNTER', + thargoid: 'THARGOID', + thargon: 'THARGON', + asteroid: 'ASTEROID', + hermit: 'ROCK HERMIT', + generation: 'DERELICT SHIP', +}; + +/** + * The ships the pilot can fight, in order. The ships that attack come first, + * nearest first. Every other ship follows, nearest first. The picked ship is + * always on the list, even beyond scanner range. + */ +export function targetList(v: TargetView): TargetRow[] { + const rows = v.npcs + .filter((n) => n.state.alive && !n.state.docked + && (n.state.targeted || n.object.position.distanceTo(v.playerPos) <= SCANNER_RANGE)) + .map((ship) => { + const hostile = isHostileToPlayer(ship, v.legalStatus, v.playerToStation); + return { + row: { + ship, + name: ship.object.name.toUpperCase(), + range: ship.object.position.distanceTo(v.playerPos), + standing: hostile ? 'HOSTILE' : STANDING[ship.role] ?? 'SHIP', + cost: costOf(ship.role), + picked: ship.state.targeted, + }, + hostile, + }; + }); + rows.sort((a, b) => Number(b.hostile) - Number(a.hostile) || a.row.range - b.row.range); + return rows.map((r) => r.row); +} + +/** + * What an attack costs beyond the fight. The law's own rule says whom it + * protects (`harmVerdict`). The hermit is not the law's, and a dead hermit + * costs the commander's name (`DISREPUTE_HERMIT_KILL`). + */ +function costOf(role: string): string | null { + if (harmVerdict(role) !== null) return 'THE LAW PROTECTS THIS SHIP'; + if (role === 'hermit') return 'KILLING THE HERMIT HURTS YOUR REPUTATION'; + return null; +} + +/** The ship the pilot picked, if it still lives. */ +export function pickedTarget(npcs: readonly NpcShip[]): NpcShip | null { + return npcs.find((n) => n.state.targeted && n.state.alive) ?? null; +} + +/** Pick one ship, and let go of any other. Null lets go of all of them. */ +export function pickTarget(npcs: readonly NpcShip[], ship: NpcShip | null): void { + for (const n of npcs) n.state.targeted = n === ship; +} diff --git a/test/constants.test.ts b/test/constants.test.ts index 9f47deb9..98700528 100644 --- a/test/constants.test.ts +++ b/test/constants.test.ts @@ -410,6 +410,8 @@ const OUTSIDE: readonly Group[] = [ 'game/flight-instruments.ts': ['COURSE_ENDS'], 'game/courses.ts': ['COURSE_NAMES', 'JUMP_WHY'], 'game/course-actions.ts': ['KINDS'], + // what each role is called on the target list (docs/TODO/206 M1) + 'game/targets.ts': ['STANDING'], }, }, diff --git a/test/run.ts b/test/run.ts index b601acd4..ee437cb1 100644 --- a/test/run.ts +++ b/test/run.ts @@ -76,6 +76,7 @@ import './course-pilot.test.ts'; import './course-launch.test.ts'; import './course-buttons.test.ts'; import './skip.test.ts'; +import './targets.test.ts'; import './world.test.ts'; import './docking.test.ts'; import './docking-computer.test.ts'; diff --git a/test/targets.test.ts b/test/targets.test.ts new file mode 100644 index 00000000..15a2cf9d --- /dev/null +++ b/test/targets.test.ts @@ -0,0 +1,60 @@ +// What the ship can fight, and which one the pilot picked (docs/TODO/206 M1). +// +// A real World with a few ships placed by hand. The list puts the ships that +// attack first, then the rest, each group nearest first. The pick is a flag +// on one ship's state, so a save carries it with the ship. + +import * as THREE from 'three'; +import { World } from '../src/game/world.ts'; +import { seedWorld } from '../src/game/rng.ts'; +import { generateGalaxy } from '../src/galaxy/galaxy.ts'; +import { pickTarget, pickedTarget, targetList } from '../src/game/targets.ts'; +import { SCANNER_RANGE } from '../src/constants/console.ts'; +import { check, eq } from './harness.ts'; + +console.log('\nthe target list'); + +seedWorld(20_260_923); +const world = new World(); +world.build(generateGalaxy(1)[7]); +world.clearNpcs(); +// Far from the station, so its truce holds nobody back. +const here = world.station.position.clone().add(new THREE.Vector3(0, 0, 60_000)); +const at = (d: number) => here.clone().add(new THREE.Vector3(d, 0, 0)); +const trader = world.spawn('trader', at(900), 1); +const farPirate = world.spawn('pirate', at(3000), 2); +const nearPirate = world.spawn('pirate', at(2000), 3); +const police = world.spawn('police', at(1500), 4); +const rock = world.spawn('asteroid', at(500), 5); +const beyond = world.spawn('trader', at(SCANNER_RANGE + 2000), 6); + +const view = () => ({ npcs: world.npcs, playerPos: here, legalStatus: 0, playerToStation: 60_000 }); +const names = () => targetList(view()).map((r) => r.ship); + +const list = names(); +check('the ships that attack come first, nearest first', + list[0] === nearPirate && list[1] === farPirate); +check('...then every other ship, nearest first', list.slice(2).join() === [rock, trader, police].join()); +check('a ship beyond scanner range is not on the list', !list.includes(beyond)); +eq('a pirate that attacks reads HOSTILE', targetList(view())[0].standing, 'HOSTILE'); +eq('a trader is on the list, and says the law protects it', + targetList(view()).find((r) => r.ship === trader)?.cost, 'THE LAW PROTECTS THIS SHIP'); +eq('...and so does the police ship', + targetList(view()).find((r) => r.ship === police)?.cost, 'THE LAW PROTECTS THIS SHIP'); +eq('a rock costs nothing to shoot', targetList(view()).find((r) => r.ship === rock)?.cost, null); + +eq('with no pick, no ship is picked', pickedTarget(world.npcs), null); +pickTarget(world.npcs, trader); +eq('a pick marks one ship', pickedTarget(world.npcs), trader); +pickTarget(world.npcs, police); +check('...and a second pick lets go of the first', pickedTarget(world.npcs) === police && !trader.state.targeted); +pickTarget(world.npcs, beyond); +check('the picked ship stays on the list beyond scanner range', names().includes(beyond)); +beyond.state.alive = false; +eq('a picked ship that dies is picked no more', pickedTarget(world.npcs), null); + +// The pick travels with the ship through a save, because it is state. +pickTarget(world.npcs, rock); +const saved = JSON.parse(JSON.stringify(world.captureNpcs())); +check('the save writes the pick on the picked ship', + saved.some((n: { state: { targeted: boolean } }) => n.state.targeted)); From fdfb70dbf88d63d9a4b600cb63107fc3811e72ad Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Fri, 11 Sep 2026 23:03:38 +0100 Subject: [PATCH 021/100] docs/TODO/206 M2 and M4: every pilot gets the aim, and the bought computer the trigger A fight now gives every pilot the computer's aim. When a hostile ship is near, or the pilot picked a target, the co-pilot lines the ship up. It flies at the pilot's pick first, and at the threat lock's choice with no pick. Without a combat computer it never fires: the laser, the missiles and the E.C.M. are the pilot's (Chris). With one fitted, it also fires the laser and the E.C.M., and never a missile (Chris: "missiles cost money"). A flight key takes the controls, and the computer waits until the pilot picks a course or presses the aim's key. A course waits through a fight and flies on when the area is clear. The automatic start says nothing on the console, because a fight's first lines matter more. 5,756 assertions, from 5,746. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- ...ter-flies-the-fight-and-the-pilot-fires.md | 24 ++++ src/game/autopilot.ts | 62 +++++++-- src/game/course-actions.ts | 1 + src/game/flight-instruments.ts | 9 ++ src/game/flight.ts | 16 ++- src/game/scripted-co-pilot.ts | 8 +- src/game/session.ts | 8 ++ src/game/state.ts | 1 + src/hud/hud.ts | 3 +- test/aim.test.ts | 127 ++++++++++++++++++ test/run.ts | 1 + test/ui.test.ts | 10 +- 12 files changed, 245 insertions(+), 25 deletions(-) create mode 100644 test/aim.test.ts diff --git a/docs/TODO/206-the-computer-flies-the-fight-and-the-pilot-fires.md b/docs/TODO/206-the-computer-flies-the-fight-and-the-pilot-fires.md index 9419edff..71d01e85 100644 --- a/docs/TODO/206-the-computer-flies-the-fight-and-the-pilot-fires.md +++ b/docs/TODO/206-the-computer-flies-the-fight-and-the-pilot-fires.md @@ -209,3 +209,27 @@ Evidence: of the hit, so the list writes THE LAW PROTECTS THIS SHIP instead. The hermit is not the law's, and the list says what killing him costs. - **The suite has 5,746 assertions,** from 5,733. + +### M2, with M4 folded in + +- **M4 is one line of M2, so it landed in the same commit.** The seat's + trigger and E.C.M. requests pass only with `equipment.combatComputer`. So a + ship without one gets the aim, and a ship with one gets the whole fight, + except the missiles. The co-pilot never launched a missile, so M4 had + nothing to take out. +- **One flag says who flies: `SessionState.handFlown`.** A flight key sets + it, in a fight or on a course. A pick of a course clears it, and so does + the aim's key. While it is set, no computer takes the stick back. +- **The automatic start says nothing on the console.** The first draft said + THE COMPUTER IS LINING YOU UP. That line took the console at the moment a + fight starts, which is when the lines that matter arrive. Six tests of the + law's lines caught it. The label over the view says THE COMPUTER IS AIMING, + and a sound marks the moment. +- **The aim's key no longer refuses an unfitted ship.** Every ship has the + aim now. `test/ui.test.ts` pinned the old refusal, and it pins the new one. +- **The four probes cannot see this change.** `survivability`, `aim-probe` + and `defence-probe` build no Game, and `ambush-probe` builds its own + co-pilot with no pick. So they fly exactly as before. The measure of a + fight under the new seat is the headless test in `test/aim.test.ts`, and + Chris's verdict on whether it is fun. +- **The suite has 5,756 assertions,** from 5,746. diff --git a/src/game/autopilot.ts b/src/game/autopilot.ts index 401caefc..d9d76e66 100644 --- a/src/game/autopilot.ts +++ b/src/game/autopilot.ts @@ -36,6 +36,7 @@ import type { FlightDemand } from '../player.ts'; import type { Brain } from '../ai-training/policy.ts'; import type { V3 } from '../ai-training/observation.ts'; import { hostilesNear } from './hostility.ts'; +import { pickedTarget } from './targets.ts'; import { defenceBrainNameFor } from './brain-names.ts'; import type { CombatComputer } from './combat-computer.ts'; import { ScriptedCoPilot } from './scripted-co-pilot.ts'; @@ -152,24 +153,58 @@ export class Autopilot { } /** - * The combat computer, on or off. + * Is there a fight for the computer to line the ship up in? A hostile ship + * near, by the condition light's own rule, or a target the pilot picked. + */ + private fightOn(): boolean { + const s = this.state; + return pickedTarget(s.world.npcs) !== null || hostilesNear( + s.world.npcs, s.player.position, s.commander.legalStatus, this.playerToStation); + } + + /** + * A fight starts, and the computer takes the stick to line the ship up + * (docs/TODO/206 M2). Every pilot gets the aim now. The bought combat + * computer adds the trigger and the E.C.M., and the Game applies those. + * + * It does nothing while the pilot flies by hand. A flight key set that, and + * a pick of a course or a target clears it. So a pilot who takes the stick + * keeps it (Chris, 2026-09-11: *"hitting the keyboard will take control + * during combat"*). + */ + autoEngage(): AutopilotEvent[] { + const s = this.state; + if (s.session.ccEngaged || s.session.handFlown || !this.fightOn()) return []; + // The LIVE BRAINS row can set the co-pilot to NONE outright. + if (defenceBrainNameFor(s.brains) === 'scripted') return []; + s.session.ccEngaged = true; + s.session.view = 0; // it aims the front laser + // NO CONSOLE LINE. A fight starts at the very moment the lines that + // matter arrive, such as what a shot cost the commander. The label over + // the view says that the computer aims, and the sound marks the moment. + return [{ kind: 'sound', name: 'combatComputerEngaged' }]; + } + + /** + * The computer's aim, on or off, on its key. + * + * Every pilot has the aim since docs/TODO/206, so an unfitted ship no longer + * refuses. Off hands the controls to the pilot, and the computer then waits + * to be asked. On hands the stick back. * * It refuses to engage with nothing to fight, and that is not a limitation. - * The policy trained to fly a defence. In an empty sky it would merely hold - * the ship, while the player wondered why the controls felt odd. + * In an empty sky it would merely hold the ship, while the player wondered + * why the controls felt odd. */ toggleCombat(): AutopilotEvent[] { const s = this.state; - if (!s.commander.equipment.combatComputer) { - return [say('NO COMBAT COMPUTER FITTED', 3), REFUSED]; - } if (s.session.ccEngaged) { s.session.ccEngaged = false; - return [say('COMBAT COMPUTER OFF', 2)]; + s.session.handFlown = true; + return [say('YOU HAVE THE CONTROLS', 2)]; } - if (!hostilesNear( - s.world.npcs, s.player.position, s.commander.legalStatus, this.playerToStation)) { - return [say('NO HOSTILES — COMBAT COMPUTER IDLE', 3), REFUSED]; + if (!this.fightOn()) { + return [say('NOTHING TO FIGHT', 3), REFUSED]; } // The LIVE BRAINS row can set the co-pilot to NONE outright. A refusal // here, in the row's own words, beats a pilot that engages and hands back @@ -178,9 +213,10 @@ export class Autopilot { return [say('COMBAT COMPUTER SET TO NONE — SEE THE COMBAT TRAINER', 4), REFUSED]; } s.session.ccEngaged = true; + s.session.handFlown = false; s.session.view = 0; // it aims the front laser return [ - say('COMBAT COMPUTER ENGAGED — ANY FLIGHT KEY OVERRIDES', 4), + say('THE COMPUTER IS LINING YOU UP — A FLIGHT KEY TAKES THE CONTROLS', 4), { kind: 'sound', name: 'combatComputerEngaged' }, ]; } @@ -207,6 +243,7 @@ export class Autopilot { missilePos, this.playerToStation); if (step.kind === 'disengage') { s.session.ccEngaged = false; + if (handsOn) s.session.handFlown = true; return { demand: null, ecm: false, @@ -232,9 +269,10 @@ export class Autopilot { const s = this.state; const step = this.scripted.step( dt, s.player, s.world.npcs, s.commander.legalStatus, handsOn, missilePos, - this.playerToStation); + this.playerToStation, pickedTarget(s.world.npcs)); if (step.kind === 'disengage') { s.session.ccEngaged = false; + if (handsOn) s.session.handFlown = true; return { demand: null, ecm: false, diff --git a/src/game/course-actions.ts b/src/game/course-actions.ts index ece8a3cb..de88499c 100644 --- a/src/game/course-actions.ts +++ b/src/game/course-actions.ts @@ -178,6 +178,7 @@ export class CourseActions { this.host.launch(); } this.state().session.course = kind; + this.state().session.handFlown = false; if (kind === 'jump') this.host.startHyperspace(); return true; } diff --git a/src/game/flight-instruments.ts b/src/game/flight-instruments.ts index a5b901f9..712a61bb 100644 --- a/src/game/flight-instruments.ts +++ b/src/game/flight-instruments.ts @@ -131,6 +131,7 @@ export class Instruments { if (s.course === null) return null; if (handsOn) { s.course = null; + s.handFlown = true; this.coursePilot.reset(); this.host.showMessage('MANUAL CONTROL — AUTOPILOT OFF', 2); return null; @@ -175,6 +176,14 @@ export class Instruments { if (said) this.host.showMessage(said, 3); } + /** + * A fight starts, and the computer takes the stick, unless the pilot flies + * by hand (docs/TODO/206 M2). `autopilot.ts` decides. + */ + autoEngage(): void { + this.applyAutopilot(this.autopilot.autoEngage()); + } + /** A hit worth a break: the co-pilot keeps its own record * (scripted-co-pilot.ts). */ noteUnderFire(): void { this.autopilot.noteUnderFire(); } diff --git a/src/game/flight.ts b/src/game/flight.ts index 95afcc6e..70f9f659 100644 --- a/src/game/flight.ts +++ b/src/game/flight.ts @@ -320,6 +320,8 @@ export class Flight { // the virtual stick self-centres; the producer is pure, so the mutation // is ours to do, immediately after the read if (this.input.mouseFlight) this.input.decayMouse(dt); + // A fight gives every pilot the computer's aim (docs/TODO/206 M2). + this.instruments.autoEngage(); // A picked course flies when no co-pilot does (docs/TODO/205 M3). The // trigger stays the pilot's, as it does under the co-pilot. if (!this.state.session.ccEngaged) { @@ -334,13 +336,15 @@ export class Flight { // The trained one flies at its fitted CC_* caps. So the Game flies either // the same way, and the HUD reads both. const auto = this.instruments.coPilot(dt, this.handsOn()); - // A co-pilot that can answer a warhead — the same button, the same price - // and the same messages as the player's own E.C.M. key (docs/TODO/72). It - // is applied here rather than inside the autopilot, because the spend from - // the bank is a consequence, and consequences are the orchestrator's. - if (auto.ecm) this.weapons.triggerEcm(); + // ONLY THE BOUGHT COMBAT COMPUTER PULLS THE TRIGGER AND FIRES THE E.C.M. + // (docs/TODO/206). Every other pilot gets the aim and keeps the trigger. + // Both are applied here rather than inside the autopilot. A shot and a + // spend from the bank are consequences, and those are the orchestrator's + // (docs/TODO/72). + const bought = this.state.commander.equipment.combatComputer; + if (auto.ecm && bought) this.weapons.triggerEcm(); return auto.demand - ? { ...auto.demand, fire: auto.demand.fire || hands.fire } + ? { ...auto.demand, fire: (bought && auto.demand.fire) || hands.fire } : hands; } diff --git a/src/game/scripted-co-pilot.ts b/src/game/scripted-co-pilot.ts index 3e1d7678..67aede10 100644 --- a/src/game/scripted-co-pilot.ts +++ b/src/game/scripted-co-pilot.ts @@ -99,6 +99,7 @@ export class ScriptedCoPilot { manualInput: boolean, missilePos: V3 | null, playerToStation = Infinity, + picked: NpcShip | null = null, ): CoPilotStep { if (manualInput) return { kind: 'disengage', reason: 'MANUAL OVERRIDE' }; this.underFire = Math.max(0, this.underFire - dt); @@ -106,7 +107,10 @@ export class ScriptedCoPilot { const offNose = (npc: NpcShip): number => this.nose.set(0, 0, -1) .applyQuaternion(player.quaternion) .angleTo(this.toThreat.copy(npc.object.position).sub(player.position)); - const threat = this.lock.pick( + // The pilot's pick comes first (docs/TODO/206 M2). It may be any ship on + // the target list, a trader or a rock too. With no pick, the lock chooses, + // by its own rule, which two other places share. + const threat = picked ?? this.lock.pick( dt, npcs.filter((npc) => isHostileToPlayer(npc, legalStatus, playerToStation) && npc.object.position.distanceTo(player.position) < THREAT_RANGE), @@ -130,7 +134,7 @@ export class ScriptedCoPilot { ); if (!threat) { this.reset(); - return { kind: 'disengage', reason: 'AREA CLEAR — COMBAT COMPUTER OFF' }; + return { kind: 'disengage', reason: 'AREA CLEAR' }; } const targetPos = threat.object.position; const dist = targetPos.distanceTo(player.position); diff --git a/src/game/session.ts b/src/game/session.ts index 6834ca6b..459e7a3c 100644 --- a/src/game/session.ts +++ b/src/game/session.ts @@ -97,6 +97,13 @@ export interface SessionState { course: CourseKind | null; /** the courses this visit already finished, so the list leaves them out */ coursesDone: CourseKind[]; + /** + * The pilot took the controls with a flight key (docs/TODO/206 M2). Until + * the pilot picks a course or a target, no computer takes the stick back: + * not a course, and not the aim in a fight. It is saved, because it + * decides who flies. + */ + handFlown: boolean; } /** @@ -106,6 +113,7 @@ export interface SessionState { export function endVisit(state: SessionState): void { state.course = null; state.coursesDone = []; + state.handFlown = false; } /** Put a message in canonical state; the HUD only paints these fields. */ diff --git a/src/game/state.ts b/src/game/state.ts index ba07b013..9afea6ec 100644 --- a/src/game/state.ts +++ b/src/game/state.ts @@ -158,6 +158,7 @@ export function freshSession(): SessionState { dcEngaged: false, course: null, coursesDone: [], + handFlown: false, }; } diff --git a/src/hud/hud.ts b/src/hud/hud.ts index 92792be5..84886916 100644 --- a/src/hud/hud.ts +++ b/src/hud/hud.ts @@ -286,7 +286,8 @@ export class Hud { this.altEl.style.width = `${Math.min(100, frame.altitudeFrac * 100)}%`; this.cabinEl.style.width = `${Math.min(100, frame.cabinTemp * 100)}%`; this.cabinEl.style.background = frame.cabinTemp > CABIN_GAUGE_WARN ? RED : ''; - this.viewEl.textContent = frame.assist ? '◆ COMBAT COMPUTER ◆' : (VIEW_NAMES[frame.view] ?? ''); + this.viewEl.textContent = frame.assist + ? '◆ THE COMPUTER IS AIMING ◆' : (VIEW_NAMES[frame.view] ?? ''); this.crosshairEl.style.display = frame.hasLaser ? '' : 'none'; this.shipIdEl.textContent = frame.shipId; this.drawEnergy(frame); diff --git a/test/aim.test.ts b/test/aim.test.ts new file mode 100644 index 00000000..e3d4d037 --- /dev/null +++ b/test/aim.test.ts @@ -0,0 +1,127 @@ +// The computer lines up every pilot's ship in a fight (docs/TODO/206 M2). +// +// Chris's words of 2026-09-11: timing and tactics are the pilot's. The pilot +// owns the laser, the missiles, the E.C.M. and the choice of target. The +// computer only aims. The bought combat computer takes control of everything +// but the missiles. These fly a real headless Game. + +import * as THREE from 'three'; +import { Game } from '../src/game/game.ts'; +import { headlessShell } from '../src/engine/shell.ts'; +import { withoutSaving } from '../src/game/storage.ts'; +import { seedWorld } from '../src/game/rng.ts'; +import { pickTarget } from '../src/game/targets.ts'; +import type { NpcShip } from '../src/game/npc.ts'; +import { check, dismissBriefing, eq } from './harness.ts'; + +console.log('\nthe computer lines up every pilot'); + +/** A commander in open space far from the station, with an empty sky. */ +function open(seed: number): Game { + const g = withoutSaving(() => { + seedWorld(seed); + const game = new Game(() => headlessShell()); + dismissBriefing(game); + game.launch(); + return game; + }).value; + withoutSaving(() => { for (let f = 0, at = 0; f < 400; f++) g.step(1 / 60, at += 1 / 60); }); + g.state.world.clearNpcs(); + // Well clear of the station's truce, where pirates attack. + g.state.player.position.add(new THREE.Vector3(0, 40_000, 0)); + return g; +} + +function run(g: Game, frames: number): void { + withoutSaving(() => { for (let f = 0; f < frames; f++) g.step(1 / 60, 20 + f / 60); }); +} + +/** How far off the nose a ship sits, in radians. */ +function offNose(g: Game, ship: NpcShip): number { + const nose = new THREE.Vector3(0, 0, -1).applyQuaternion(g.state.player.quaternion); + return nose.angleTo(ship.object.position.clone().sub(g.state.player.position)); +} + +/** A ship placed off to one side of the commander. */ +function beside(g: Game, role: 'pirate' | 'trader', x: number, seed: number): NpcShip { + const pos = g.state.player.position.clone() + .add(new THREE.Vector3(x, 0, -1800).applyQuaternion(g.state.player.quaternion)); + return g.state.world.spawn(role, pos, seed); +} + +{ + const g = open(20_260_924); + const pirate = beside(g, 'pirate', 1400, 1); + pirate.state.speed = 0; + const before = offNose(g, pirate); + let hottest = 0; + withoutSaving(() => { + for (let f = 0; f < 150; f++) { + g.step(1 / 60, 20 + f / 60); + hottest = Math.max(hottest, g.state.sys.laserTemp); + } + }); + check('a fight starts, and the computer takes the stick of a ship with no combat computer', + g.state.session.ccEngaged); + check('...and turns the nose onto the threat', offNose(g, pirate) < before * 0.5, + `${before.toFixed(2)} to ${offNose(g, pirate).toFixed(2)} rad`); + eq('...and never fires: the trigger is the pilot\'s', hottest, 0); +} + +{ + const g = open(20_260_925); + g.state.commander.equipment.combatComputer = true; + const pirate = beside(g, 'pirate', 900, 2); + pirate.state.speed = 0; + let hottest = 0; + withoutSaving(() => { + for (let f = 0; f < 240; f++) { + g.step(1 / 60, 20 + f / 60); + hottest = Math.max(hottest, g.state.sys.laserTemp); + } + }); + check('the bought combat computer also pulls the trigger', hottest > 0, + `laser heat peaked at ${hottest.toFixed(3)}; pirate alive ${pirate.state.alive}`); +} + +{ + const g = open(20_260_926); + const pirate = beside(g, 'pirate', -1400, 3); + const trader = beside(g, 'trader', 1400, 4); + pirate.state.speed = 0; + trader.state.speed = 0; + pickTarget(g.state.world.npcs, trader); + run(g, 180); + check('with a target picked, the computer lines up on it rather than on the threat', + offNose(g, trader) < offNose(g, pirate), + `trader ${offNose(g, trader).toFixed(2)}, pirate ${offNose(g, pirate).toFixed(2)} rad`); +} + +{ + const g = open(20_260_927); + const pirate = beside(g, 'pirate', 1400, 5); + pirate.state.speed = 0; + run(g, 30); + g.input.press('ArrowUp'); + run(g, 1); + g.input.release('ArrowUp'); + check('a flight key takes the controls', !g.state.session.ccEngaged && g.state.session.handFlown); + run(g, 60); + check('...and the computer does not take them back by itself', !g.state.session.ccEngaged); + g.state.session.handFlown = false; + run(g, 1); + check('a pick hands the stick back, and the aim starts again', g.state.session.ccEngaged); +} + +{ + const g = open(20_260_928); + g.state.session.course = 'station'; + const pirate = beside(g, 'pirate', 1400, 6); + run(g, 30); + check('a fight on a course: the aim flies, and the course waits', g.state.session.ccEngaged + && g.state.session.course === 'station'); + pirate.state.alive = false; + run(g, 5); + check('...and when the area is clear, the course flies on', !g.state.session.ccEngaged + && g.state.session.course === 'station'); +} diff --git a/test/run.ts b/test/run.ts index ee437cb1..c989f8d5 100644 --- a/test/run.ts +++ b/test/run.ts @@ -77,6 +77,7 @@ import './course-launch.test.ts'; import './course-buttons.test.ts'; import './skip.test.ts'; import './targets.test.ts'; +import './aim.test.ts'; import './world.test.ts'; import './docking.test.ts'; import './docking-computer.test.ts'; diff --git a/test/ui.test.ts b/test/ui.test.ts index 089359e2..5620d3a4 100644 --- a/test/ui.test.ts +++ b/test/ui.test.ts @@ -337,8 +337,10 @@ console.log('\nautopilots'); eq('an unfitted docking computer refuses', texts(auto.toggleDocking())[0], 'NO DOCKING COMPUTER FITTED'); check('...and does not engage', !state.session.dcEngaged); - eq('an unfitted combat computer refuses', - texts(auto.toggleCombat())[0], 'NO COMBAT COMPUTER FITTED'); + // Every ship has the computer's aim since docs/TODO/206, so an unfitted + // one no longer refuses. It still refuses an empty sky. + eq('with nothing to fight, the aim refuses', + texts(auto.toggleCombat())[0], 'NOTHING TO FIGHT'); check('...and does not engage', !state.session.ccEngaged); } @@ -367,7 +369,7 @@ console.log('\nautopilots'); const { state, auto } = rig({ combatComputer: true }); clearOfTruce(state); eq('the combat computer refuses an empty sky', - texts(auto.toggleCombat())[0], 'NO HOSTILES — COMBAT COMPUTER IDLE'); + texts(auto.toggleCombat())[0], 'NOTHING TO FIGHT'); check('...and stays off', !state.session.ccEngaged); state.world.spawn('pirate', @@ -378,7 +380,7 @@ console.log('\nautopilots'); check('...and swings to the front view, because it aims the front laser', state.session.view === 0); eq('pressing it again hands the ship back', - texts(auto.toggleCombat())[0], 'COMBAT COMPUTER OFF'); + texts(auto.toggleCombat())[0], 'YOU HAVE THE CONTROLS'); check('...and it is off', !state.session.ccEngaged); } From 1e8561cb3f528419f21a0d188a06434e9814727d Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Fri, 11 Sep 2026 23:07:42 +0100 Subject: [PATCH 022/100] docs/TODO/206 M3: the pilot's hands are buttons: laser, missile, E.C.M. and targets Bottom right of the view, above the console: FIRE LASER fires while it is held, the missile button arms one and then fires it, the E.C.M. button shows when one is fitted, and TARGETS opens the list of what the ship can fight. A row picks its ship and hands the stick to the computer. LET THE COMPUTER CHOOSE lets go of the pick. The keys of today still work, and the new buttons need none (Chris). engine/hold-buttons.ts holds a key down while a button is held, one pointer at a time. A target row's code names its ship, so a list that reorders by range cannot pick the wrong one. 5,774 assertions, from 5,756. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- docs/ARCHITECTURE.md | 6 +- ...ter-flies-the-fight-and-the-pilot-fires.md | 18 +++ play.html | 7 ++ src/engine/browser-shell.ts | 2 +- src/engine/hold-buttons.ts | 38 ++++++ src/engine/input.ts | 3 + src/game/bindings.ts | 11 ++ src/game/cockpit-view.ts | 79 +++++++++++- src/game/game.ts | 18 +++ src/game/target-actions.ts | 100 ++++++++++++++++ src/hud/hud-binding.ts | 3 + src/hud/hud-buttons.ts | 8 +- src/hud/hud.ts | 7 ++ src/style.css | 32 +++++ test/console-plate.test.ts | 2 +- test/constants.test.ts | 1 + test/fight-buttons.test.ts | 112 ++++++++++++++++++ test/run.ts | 1 + 18 files changed, 441 insertions(+), 7 deletions(-) create mode 100644 src/engine/hold-buttons.ts create mode 100644 src/game/target-actions.ts create mode 100644 test/fight-buttons.test.ts diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md index 2caf01bc..0d0e3971 100644 --- a/docs/ARCHITECTURE.md +++ b/docs/ARCHITECTURE.md @@ -23,7 +23,8 @@ rules. This file is a map. on the GPU. The controls read an input interface, not the browser. Two pointer seams cross the platform seam. `onScreenClick` is input. `onScreenMove` reports only: a screen may repaint what it describes, but it must never select or - spend. + spend. `engine/hold-buttons.ts` is the third: a button that holds a key down + while it is held, such as the laser (docs/TODO/206). - The HUD is a read-only painter, and it is four files. `hud/hud-model.ts` works out where a marker goes. `hud-binding.ts` turns the state into a dashboard. `hud.ts` paints one. `hud-buttons.ts` paints the buttons over the @@ -174,7 +175,8 @@ Two quirks are deliberate: - `src/game/targets.ts` lists what the ship can fight, and holds the pilot's pick (docs/TODO/206). The pick is one flag on the picked ship's own state, so a save carries it. It sits on top of `threat-lock.ts`, and never changes - that rule. + that rule. `target-actions.ts` joins the list to its buttons, and gives each + ship a code that names it for as long as it lives. - `src/game/threat.ts` computes the pirate count, the group tier and the organisation from the visible value and the reputation. `ship-specs.ts` maps a tier to a hull. The campaign simulator calls the same rules. diff --git a/docs/TODO/206-the-computer-flies-the-fight-and-the-pilot-fires.md b/docs/TODO/206-the-computer-flies-the-fight-and-the-pilot-fires.md index 71d01e85..89e3bdf9 100644 --- a/docs/TODO/206-the-computer-flies-the-fight-and-the-pilot-fires.md +++ b/docs/TODO/206-the-computer-flies-the-fight-and-the-pilot-fires.md @@ -233,3 +233,21 @@ Evidence: fight under the new seat is the headless test in `test/aim.test.ts`, and Chris's verdict on whether it is fun. - **The suite has 5,756 assertions,** from 5,746. + +### M3 + +- **A held button needs its own seam.** A click is one moment, and the laser + fires while it is held. `engine/hold-buttons.ts` presses a `data-hold` + code on pointer down and releases it on pointer up, through the + `Input.press` and `Input.release` that 205 M1 kept. Each pointer is tracked + by its id, so a second finger that lifts lets go of its own button only. +- **A target row's code names a ship, not a place in the list.** The list is + in order of range, and the order moves every frame. A code built from a + row's place could pick the ship that moved into that place between the + paint and the tap. `target-actions.ts` gives each ship a number for as long + as it lives, and no save carries it. +- **The target list works in an exercise too.** A training fight is a real + fight, so the trainer has the same buttons. +- **The buttons sit bottom right, and the laser is the lowest.** A right + thumb finds it without a look. The course buttons stay top right. +- **The suite has 5,774 assertions,** from 5,756. diff --git a/play.html b/play.html index 4a08bf60..481bbf05 100644 --- a/play.html +++ b/play.html @@ -43,6 +43,13 @@ read and never touched. -->
    + +
    -
    -434 exported constants. Regenerate with `npm run generate:constants`; +436 exported constants. Regenerate with `npm run generate:constants`; search names, meanings and values with `npm run constants:find -- ""`. | Domain | Symbol | Literal / expression | Purpose | Rule ID | Source | @@ -124,16 +124,18 @@ search names, meanings and values with `npm run constants:find -- ""`. | course | COURSE_PLANET_CLEARANCE | MASS_LOCK_PLANET_ALTITUDE * 1.25 | How high above the planet's surface a course keeps its line, in world units. | | [course.ts:119](./course.ts#L119) | | course | COURSE_HERMIT_SPEED | HERMIT_DOCK_SPEED / 2 | The speed at which the hermit course arrives, in world units a second. | | [course.ts:129](./course.ts#L129) | | course | SKIP_SPEED | 8 | How much faster the world runs under the fast forward button, as a count of fixed steps in one screen frame (docs/TODO/205 M7). | course.skipSpeed | [course.ts:145](./course.ts#L145) | +| course | RUN_CLOSE_MARGIN | 50 | Below this lead in top speed, in world units a second, the run row says the ship is only a little faster (docs/TODO/206 M5). | course.runCloseMargin | [course.ts:159](./course.ts#L159) | +| course | COURSE_RUN_REACH | 50_000 | How far ahead the run course aims, in world units, on the line away from the hostile ships (docs/TODO/206 M5). | course.runReach | [course.ts:169](./course.ts#L169) | | docking | GATE_HALF_WIDTHS | 5 | How far out the approach gate sits, in multiples of the station half-width. | docking.gateHalfWidths | [docking.ts:25](./docking.ts#L25) | | docking | TURN_IN | Math.PI / 4 | How far round from the slot axis an approach turns in, in radians. | | [docking.ts:49](./docking.ts#L49) | | docking | RUN_IN_WIDTHS | GATE_HALF_WIDTHS * 0.6 | Where the approach stops the curve and flies straight, in station half-widths. | | [docking.ts:87](./docking.ts#L87) | | docking | LINED_UP_LATERAL | 45 | The off-axis error we insist on before we commit to the run in, in world units. | | [docking.ts:100](./docking.ts#L100) | -| docking | HULL_BOX_MARGIN | 50 | The bounding cube around the station: a margin over the half-width, in world units, a little larger than the hull. | | [docking.ts:112](./docking.ts#L112) | -| docking | NPC_HULL_BOX_MARGIN | HULL_BOX_MARGIN | The same cube for every NPC. | | [docking.ts:117](./docking.ts#L117) | -| docking | SLOT_HALF_ACROSS | 26 | The slot channel, as half-extents ACROSS the slot and ALONG it, in station-local world units. | | [docking.ts:125](./docking.ts#L125) | -| docking | SLOT_HALF_ALONG | 62 | | | [docking.ts:126](./docking.ts#L126) | -| docking | SLOT_DEPTH | 60 | How far into the -Z face puts a ship in the channel, in world units. | | [docking.ts:129](./docking.ts#L129) | -| docking | ROLL_TOLERANCE | 0.65 | The wings against the slot's long axis, in radians: how badly you may be rolled and still fit through the letterbox. | | [docking.ts:140](./docking.ts#L140) | +| docking | HULL_BOX_MARGIN | 50 | The bounding cube around the station: a margin over the half-width, in world units, a little larger than the hull. | docking.hullBoxMargin | [docking.ts:114](./docking.ts#L114) | +| docking | NPC_HULL_BOX_MARGIN | HULL_BOX_MARGIN | The same cube for every NPC. | | [docking.ts:119](./docking.ts#L119) | +| docking | SLOT_HALF_ACROSS | 26 | The slot channel, as half-extents ACROSS the slot and ALONG it, in station-local world units. | | [docking.ts:127](./docking.ts#L127) | +| docking | SLOT_HALF_ALONG | 62 | | | [docking.ts:128](./docking.ts#L128) | +| docking | SLOT_DEPTH | 60 | How far into the -Z face puts a ship in the channel, in world units. | | [docking.ts:131](./docking.ts#L131) | +| docking | ROLL_TOLERANCE | 0.65 | The wings against the slot's long axis, in radians: how badly you may be rolled and still fit through the letterbox. | | [docking.ts:142](./docking.ts#L142) | | docking-computer | DOCK_COMPUTER_RANGE | 3500 | How close to the station the docking computer will take the job, in world units. | | [docking-computer.ts:46](./docking-computer.ts#L46) | | docking-computer | DC_SLOT_MARGIN | 0.30 | How much of the slot's roll tolerance the TURN may spend, as a fraction. | docking.slotMargin | [docking-computer.ts:97](./docking-computer.ts#L97) | | docking-computer | DC_TURN_FADE_ANGLE | 0.10 | The off-nose angle, in radians, over which the TURN's claim on the roll axis ramps in. | docking.turnFadeAngle | [docking-computer.ts:151](./docking-computer.ts#L151) | @@ -141,17 +143,17 @@ search names, meanings and values with `npm run constants:find -- ""`. | docking-computer | DC_PATH_LOOKAHEAD | 1.5 | How far ahead ALONG THE PATH the follower aims, in station half-widths. | docking.pathLookahead | [docking-computer.ts:272](./docking-computer.ts#L272) | | encounters | TRADER_GAP | 100 | The gap between trader arrivals in a system with no economy to speak of. | | [encounters.ts:20](./encounters.ts#L20) | | encounters | TRADER_GAP_JITTER | 60 | ...and the jitter on top, drawn flat, so the lane never runs to a metronome. | | [encounters.ts:23](./encounters.ts#L23) | -| encounters | TRADER_GAP_BUSY_MAX | 50 | The most that a busy economy can discount off `TRADER_GAP`. | | [encounters.ts:36](./encounters.ts#L36) | -| encounters | PRODUCTIVITY_PER_SECOND | 1200 | How much 1984 productivity buys one second off that gap. | | [encounters.ts:47](./encounters.ts#L47) | -| encounters | TRADER_GAP_FIRST | 20 | How long after a system's clocks start the first trader may appear. | encounters.traderGapFirst | [encounters.ts:60](./encounters.ts#L60) | -| encounters | TRADER_GAP_FIRST_JITTER | 40 | ...and its jitter, so two arrivals in one system are not the same arrival. * | encounters.traderGapFirstJitter | [encounters.ts:65](./encounters.ts#L65) | -| encounters | PIRATE_WAVE_GAP | 60 | The gap between pirate waves in the most organised system that still breeds them. | | [encounters.ts:73](./encounters.ts#L73) | -| encounters | PIRATE_WAVE_GAP_PER_GOVERNMENT | 40 | ...and how much longer the wait grows for every step up the government ladder. | encounters.pirateWaveGapPerGovernment | [encounters.ts:86](./encounters.ts#L86) | -| encounters | PIRATE_WAVE_GAP_JITTER | 90 | ...and the jitter. | | [encounters.ts:90](./encounters.ts#L90) | -| encounters | LAWLESS_GOVERNMENT | 3 | A government at or below this breeds pirate waves at all. 3 is a dictatorship on the 1984 ladder, so waves stop at communist (4) and above. | encounters.lawlessGovernment | [encounters.ts:102](./encounters.ts#L102) | -| encounters | ANARCHY_GOVERNMENT | 1 | ...and a government at or below THIS sends them two at a time: anarchy (0) and feudal (1). | encounters.anarchyGovernment | [encounters.ts:118](./encounters.ts#L118) | -| encounters | MAX_THARGONS | 2 | How many drones the Thargoids keep in the sky at once, across every mothership. | encounters.maxThargons | [encounters.ts:138](./encounters.ts#L138) | -| encounters | THARGON_REDEPLOY | 5 | Seconds between one drone and the next, and the wait for the first. | encounters.thargonRedeploy | [encounters.ts:153](./encounters.ts#L153) | +| encounters | TRADER_GAP_BUSY_MAX | 50 | The most that a busy economy can discount off `TRADER_GAP`. | encounters.traderGapBusyMax | [encounters.ts:38](./encounters.ts#L38) | +| encounters | PRODUCTIVITY_PER_SECOND | 1200 | How much 1984 productivity buys one second off that gap. | | [encounters.ts:49](./encounters.ts#L49) | +| encounters | TRADER_GAP_FIRST | 20 | How long after a system's clocks start the first trader may appear. | encounters.traderGapFirst | [encounters.ts:62](./encounters.ts#L62) | +| encounters | TRADER_GAP_FIRST_JITTER | 40 | ...and its jitter, so two arrivals in one system are not the same arrival. * | encounters.traderGapFirstJitter | [encounters.ts:67](./encounters.ts#L67) | +| encounters | PIRATE_WAVE_GAP | 60 | The gap between pirate waves in the most organised system that still breeds them. | | [encounters.ts:75](./encounters.ts#L75) | +| encounters | PIRATE_WAVE_GAP_PER_GOVERNMENT | 40 | ...and how much longer the wait grows for every step up the government ladder. | encounters.pirateWaveGapPerGovernment | [encounters.ts:88](./encounters.ts#L88) | +| encounters | PIRATE_WAVE_GAP_JITTER | 90 | ...and the jitter. | | [encounters.ts:92](./encounters.ts#L92) | +| encounters | LAWLESS_GOVERNMENT | 3 | A government at or below this breeds pirate waves at all. 3 is a dictatorship on the 1984 ladder, so waves stop at communist (4) and above. | encounters.lawlessGovernment | [encounters.ts:104](./encounters.ts#L104) | +| encounters | ANARCHY_GOVERNMENT | 1 | ...and a government at or below THIS sends them two at a time: anarchy (0) and feudal (1). | encounters.anarchyGovernment | [encounters.ts:120](./encounters.ts#L120) | +| encounters | MAX_THARGONS | 2 | How many drones the Thargoids keep in the sky at once, across every mothership. | encounters.maxThargons | [encounters.ts:140](./encounters.ts#L140) | +| encounters | THARGON_REDEPLOY | 5 | Seconds between one drone and the next, and the wait for the first. | encounters.thargonRedeploy | [encounters.ts:155](./encounters.ts#L155) | | exercise | OPENING_RANGE | 4500 | The opening range for a fight that you are meant to see coming. | exercise.openingRange | [exercise.ts:33](./exercise.ts#L33) | | exercise | AMBUSH_RANGE | 2400 | An ambush opens INSIDE their gun, because that is what an ambush is. | | [exercise.ts:40](./exercise.ts#L40) | | exercise | MIN_OPENING_RANGE | 2 * PASS_FAR | No opening may be closer than this. | | [exercise.ts:49](./exercise.ts#L49) | @@ -273,19 +275,19 @@ search names, meanings and values with `npm run constants:find -- ""`. | ordnance | MISSILE_LIFE | 25 | How long a missile lives before it gives up and detonates. | | [ordnance.ts:16](./ordnance.ts#L16) | | ordnance | HOSTILE_MISSILE_LIFE | 30 | A hostile missile lives longer, because it has further to come. | ordnance.hostileMissileLife | [ordnance.ts:26](./ordnance.ts#L26) | | ordnance | MISSILE_TURN | 2.5 | Turn rate while it homes, radians per second. | | [ordnance.ts:28](./ordnance.ts#L28) | -| ordnance | MISSILE_HIT_RANGE | 50 | Close enough to detonate. | | [ordnance.ts:30](./ordnance.ts#L30) | -| ordnance | LOCK_CONE | 0.09 | Lock cone: how near the crosshair a ship must be to be locked. | | [ordnance.ts:33](./ordnance.ts#L33) | -| ordnance | LOCK_RANGE | 5500 | ...and how far away it may be. | | [ordnance.ts:35](./ordnance.ts#L35) | -| ordnance | MISSILE_MAX_RANGE | 3200 | The far edge of the seeker's envelope. | | [ordnance.ts:40](./ordnance.ts#L40) | -| ordnance | MISSILE_LAST_STAND_HULL | 0.4 | The hull fraction below which a ship stops saving its missiles for later. | ordnance.missileLastStandHull | [ordnance.ts:51](./ordnance.ts#L51) | -| ordnance | MISSILE_LAST_STAND_GATE | Math.PI / 2 | ...and it launches on a bearing rather than on a firing line. | | [ordnance.ts:56](./ordnance.ts#L56) | -| ordnance | MISSILE_LAST_STAND_MIN_RANGE | 250 | Desperation widens the envelope INWARD, but not all the way. | | [ordnance.ts:62](./ordnance.ts#L62) | -| ordnance | MISSILE_RELOAD | 2 | Gap between launches, so a Python does not empty both rails in one frame. | ordnance.missileReload | [ordnance.ts:71](./ordnance.ts#L71) | -| ordnance | MISSILE_COMMIT_PASSES | 2 | How many passes a ship makes before it accepts that this is not going its way. | ordnance.missileCommitPasses | [ordnance.ts:83](./ordnance.ts#L83) | -| ordnance | ECM_RANGE | 2800 | A target with an E.C.M. fries an incoming missile inside this. | | [ordnance.ts:88](./ordnance.ts#L88) | -| ordnance | ECM_RATE | 0.45 | ...at this chance per second. | | [ordnance.ts:90](./ordnance.ts#L90) | -| ordnance | ECM_ENERGY_COST | ENERGY_BANK_POINTS | A shot of the E.C.M. costs one bank of energy. | | [ordnance.ts:96](./ordnance.ts#L96) | -| ordnance | ENERGY_BOMB_RANGE | 8000 | The energy bomb reaches this far. | | [ordnance.ts:99](./ordnance.ts#L99) | +| ordnance | MISSILE_HIT_RANGE | 50 | Close enough to detonate. * | ordnance.missileHitRange | [ordnance.ts:32](./ordnance.ts#L32) | +| ordnance | LOCK_CONE | 0.09 | Lock cone: how near the crosshair a ship must be to be locked. | | [ordnance.ts:35](./ordnance.ts#L35) | +| ordnance | LOCK_RANGE | 5500 | ...and how far away it may be. | | [ordnance.ts:37](./ordnance.ts#L37) | +| ordnance | MISSILE_MAX_RANGE | 3200 | The far edge of the seeker's envelope. | | [ordnance.ts:42](./ordnance.ts#L42) | +| ordnance | MISSILE_LAST_STAND_HULL | 0.4 | The hull fraction below which a ship stops saving its missiles for later. | ordnance.missileLastStandHull | [ordnance.ts:53](./ordnance.ts#L53) | +| ordnance | MISSILE_LAST_STAND_GATE | Math.PI / 2 | ...and it launches on a bearing rather than on a firing line. | | [ordnance.ts:58](./ordnance.ts#L58) | +| ordnance | MISSILE_LAST_STAND_MIN_RANGE | 250 | Desperation widens the envelope INWARD, but not all the way. | | [ordnance.ts:64](./ordnance.ts#L64) | +| ordnance | MISSILE_RELOAD | 2 | Gap between launches, so a Python does not empty both rails in one frame. | ordnance.missileReload | [ordnance.ts:73](./ordnance.ts#L73) | +| ordnance | MISSILE_COMMIT_PASSES | 2 | How many passes a ship makes before it accepts that this is not going its way. | ordnance.missileCommitPasses | [ordnance.ts:85](./ordnance.ts#L85) | +| ordnance | ECM_RANGE | 2800 | A target with an E.C.M. fries an incoming missile inside this. | | [ordnance.ts:90](./ordnance.ts#L90) | +| ordnance | ECM_RATE | 0.45 | ...at this chance per second. | | [ordnance.ts:92](./ordnance.ts#L92) | +| ordnance | ECM_ENERGY_COST | ENERGY_BANK_POINTS | A shot of the E.C.M. costs one bank of energy. | | [ordnance.ts:98](./ordnance.ts#L98) | +| ordnance | ENERGY_BOMB_RANGE | 8000 | The energy bomb reaches this far. | | [ordnance.ts:101](./ordnance.ts#L101) | | pass-aim | PASS_MISS_DISTANCE | 110 | How far to the SIDE of its target a ship aims its attack run. 110 clears the largest pirate hull, plus the commander's radius, twice over. | | [pass-aim.ts:13](./pass-aim.ts#L13) | | pass-aim | MAX_LEAD_SECONDS | 0.5 | The furthest ahead of a target that a ship will aim, in seconds. | | [pass-aim.ts:21](./pass-aim.ts#L21) | | pass-aim | MAX_MISS_STRETCH | 3 | The most that geometry may stretch the aim, in multiples of the intended pass. | passaim.maxMissStretch | [pass-aim.ts:31](./pass-aim.ts#L31) | diff --git a/src/constants/course.ts b/src/constants/course.ts index 6be02d75..40887ecb 100644 --- a/src/constants/course.ts +++ b/src/constants/course.ts @@ -143,3 +143,27 @@ export const COURSE_HERMIT_SPEED = HERMIT_DOCK_SPEED / 2; * @rule course.skipSpeed */ export const SKIP_SPEED = 8; + +/** + * Below this lead in top speed, in world units a second, the run row says the + * ship is only a little faster (docs/TODO/206 M5). + * + * The player's Cobra tops out at 400. The fastest pirate and the fastest + * bounty hunter reach 381. A run from one gains 19 u/s. The lasers of both + * reach 3,500 units. A lead under 50 u/s takes more than a minute to + * open that range, under fire. A police Viper, at 320, falls behind at 80. + * + * @rule course.runCloseMargin + * @domain course + */ +export const RUN_CLOSE_MARGIN = 50; + +/** + * How far ahead the run course aims, in world units, on the line away from + * the hostile ships (docs/TODO/206 M5). The point only gives the line a + * direction, so it sits far beyond scanner range. + * + * @rule course.runReach + * @domain course + */ +export const COURSE_RUN_REACH = 50_000; diff --git a/src/constants/docking.ts b/src/constants/docking.ts index dfd5174c..9ebfcded 100644 --- a/src/constants/docking.ts +++ b/src/constants/docking.ts @@ -108,7 +108,9 @@ export const LINED_UP_LATERAL = 45; * scale. The Coriolis reaches 160 against a 160 slot plane. The Dodo's five * tallest vertices reach 243 against a 196 one. 50 clears both, and it does not * let a ship slip past a vertex and be reported clear. - */ + * + * @rule docking.hullBoxMargin +*/ export const HULL_BOX_MARGIN = 50; /** The same cube for every NPC. It is the SAME RULE as the player's, so NPC diff --git a/src/constants/encounters.ts b/src/constants/encounters.ts index b1cdedf7..b1af1bc5 100644 --- a/src/constants/encounters.ts +++ b/src/constants/encounters.ts @@ -32,7 +32,9 @@ export const TRADER_GAP_JITTER = 60; * continuous trader stream, held back only by `MAX_TRADERS`. Live, a median * system runs its lane at about 90s plus jitter. The richest runs at about 53s * plus jitter. - */ + * + * @rule encounters.traderGapBusyMax +*/ export const TRADER_GAP_BUSY_MAX = 50; /** diff --git a/src/constants/ordnance.ts b/src/constants/ordnance.ts index a148addb..bc1c5550 100644 --- a/src/constants/ordnance.ts +++ b/src/constants/ordnance.ts @@ -26,7 +26,9 @@ export const MISSILE_LIFE = 25; export const HOSTILE_MISSILE_LIFE = 30; /** Turn rate while it homes, radians per second. */ export const MISSILE_TURN = 2.5; -/** Close enough to detonate. */ +/** Close enough to detonate. * + * @rule ordnance.missileHitRange +*/ export const MISSILE_HIT_RANGE = 50; /** Lock cone: how near the crosshair a ship must be to be locked. */ diff --git a/src/constants/witchspace.ts b/src/constants/witchspace.ts index a2ba0529..7408bf8f 100644 --- a/src/constants/witchspace.ts +++ b/src/constants/witchspace.ts @@ -60,7 +60,8 @@ export const THARGOID_AMBUSH_RANGE_SPAN = 2500; // Two constants used to end this file: STRANDED_HINT_FIRST and // STRANDED_HINT_REPEAT. They were the cadence of a console message that told -// you to press B, and they went with that message (docs/TODO/128). To be stranded is a situation, not an event. The cockpit's -// prompt line now carries the offer for as long as it is true. So there is no +// you to press B, and they went with that message (docs/TODO/128). To be +// stranded is a situation, not an event. The cockpit now offers the beacon as +// a button for as long as it is true (docs/TODO/206 M5). So there is no // repeat to time, and no letter to hard-code. The condition itself // (`WITCHSPACE_ESCAPE_COST` in the tank) is `game/prompts.ts`. diff --git a/src/game/autopilot.ts b/src/game/autopilot.ts index d9d76e66..e5faac5d 100644 --- a/src/game/autopilot.ts +++ b/src/game/autopilot.ts @@ -175,6 +175,8 @@ export class Autopilot { autoEngage(): AutopilotEvent[] { const s = this.state; if (s.session.ccEngaged || s.session.handFlown || !this.fightOn()) return []; + // A ship that runs does not turn to fight (docs/TODO/206 M5). + if (s.session.course === 'run') return []; // The LIVE BRAINS row can set the co-pilot to NONE outright. if (defenceBrainNameFor(s.brains) === 'scripted') return []; s.session.ccEngaged = true; diff --git a/src/game/bindings.ts b/src/game/bindings.ts index a08930a9..1f9ff239 100644 --- a/src/game/bindings.ts +++ b/src/game/bindings.ts @@ -53,6 +53,7 @@ export const COURSE_KEYS: Readonly> = { mine: 'VirtCourseMine', hermit: 'VirtCourseHermit', skim: 'VirtCourseSkim', + run: 'VirtCourseRun', }; /** The launch list's row for the galactic chart, where a pilot sets a target. */ diff --git a/src/game/cockpit-buttons.ts b/src/game/cockpit-buttons.ts new file mode 100644 index 00000000..9e3598c7 --- /dev/null +++ b/src/game/cockpit-buttons.ts @@ -0,0 +1,135 @@ +// The buttons over the flight view, built from what the cockpit sees +// (docs/TODO/205 M5, docs/TODO/206 M3 and M5). +// +// Two columns. The courses sit top right: where the ship can go next, the +// course it flies now, fast forward, and the offers that the situation +// raises. The pilot's hands sit bottom right: the target list, the E.C.M., +// the missile and the laser. The laser is the lowest of them, where a right +// thumb finds it without a look. +// +// PURE, and it decides nothing. Each function takes what the cockpit already +// read and returns `HudButton`s. `hud/hud-buttons.ts` paints them, and a +// click or a tap sends the button's code, as a station menu row does. +// +// THE WORDS ARE THE PLAYER'S (Chris, 2026-09-11: *"A user does not have all +// our context."*). No button says "course". A button under way says what the +// ship is doing, and a button the ship cannot use says what it needs. + +import type { HudButton } from '../hud/hud-buttons.ts'; +import type { CoursePanel } from './course-actions.ts'; +import type { TargetPanel } from './target-actions.ts'; +import type { Prompt } from './prompts.ts'; +import type { ControlMode } from './controls.ts'; +import { COURSE_NAMES } from './courses.ts'; +import { + COURSE_KEYS, COURSE_SKIP_KEY, COURSE_TOGGLE_KEY, TARGET_NONE_KEY, TARGETS_KEY, +} from './bindings.ts'; +import { keyCodeIfBound, keyIfBound } from '../ui/key-help.ts'; +import { SKIP_SPEED } from '../constants/course.ts'; +import { LASER_RANGE } from '../constants/player-gun.ts'; + +/** + * The course panel as buttons (docs/TODO/205 M5). With no course, each course + * is a button, and the galactic chart follows them. Over a course that flies, + * one lit button names it and opens the list. + */ +export function courseButtonsFor(p: CoursePanel, chart: string | null): HudButton[] { + if (p.rows === null) { + return p.current === null ? [] : [ + { code: COURSE_TOGGLE_KEY, label: COURSE_NAMES[p.current], lit: true, hint: 'CHOOSE SOMEWHERE ELSE' }, + skipButton(p), + ].filter((b): b is HudButton => b !== null); + } + const out: HudButton[] = p.rows.map((c) => ({ + code: COURSE_KEYS[c.kind], label: c.what, ...(c.why === null ? {} : { note: c.why }), + })); + if (chart) out.push({ code: chart, label: 'GALACTIC CHART' }); + if (p.current !== null) out.push({ code: COURSE_TOGGLE_KEY, label: 'CLOSE' }); + return out; +} + +/** What the pilot's buttons are built from (docs/TODO/206 M3). */ +export interface ActionSource { + /** the fire key of the live layout, which the laser button holds */ + readonly fireKey: string | null; + readonly missiles: number; + readonly armed: boolean; + readonly locked: boolean; + readonly armKey: string | null; + readonly launchKey: string | null; + /** the E.C.M.'s key, or null when none is fitted */ + readonly ecmKey: string | null; + /** a hostile missile is on its way, so the E.C.M. is the button to press */ + readonly missileInbound: boolean; + readonly targets: TargetPanel | null; +} + +/** + * The pilot's hands as buttons, top to bottom (docs/TODO/206 M3). The target + * list opens above the rest. The laser comes last, at the bottom, where a + * thumb finds it without a look. + */ +export function actionButtonsFor(a: ActionSource): HudButton[] { + const out: HudButton[] = []; + const t = a.targets; + if (t && t.open) { + for (const { code, row } of t.rows) { + out.push({ + code, label: row.name, lit: row.picked, + hint: `${row.standing} · ${row.range <= LASER_RANGE ? 'IN LASER RANGE' : 'OUT OF LASER RANGE'}`, + ...(row.cost ? { note: row.cost } : {}), + }); + } + if (t.picked) out.push({ code: TARGET_NONE_KEY, label: 'LET THE COMPUTER CHOOSE' }); + } + if (t && (t.rows.length > 0 || t.open)) { + out.push({ + code: TARGETS_KEY, label: t.open ? 'CLOSE THE TARGETS' : 'TARGETS', + hint: t.picked ? `AIMING AT THE ${t.picked.name}` : 'CHOOSE WHAT TO FIGHT', + }); + } + if (a.ecmKey) { + out.push(a.missileInbound + ? { code: a.ecmKey, label: 'E.C.M.', lit: true, hint: 'A MISSILE IS COMING — PRESS NOW' } + : { code: a.ecmKey, label: 'E.C.M.', hint: 'DESTROYS MISSILES NEARBY' }); + } + if (a.missiles > 0 && a.armKey && a.launchKey) { + out.push(a.armed + ? { + code: a.launchKey, label: 'FIRE THE MISSILE', lit: a.locked, + hint: a.locked ? 'LOCKED ON' : 'IT LOCKS ON A SHIP IN YOUR SIGHTS', + } + : { code: a.armKey, label: 'ARM A MISSILE', hint: `${a.missiles} LEFT` }); + } + if (a.fireKey) out.push({ code: a.fireKey, label: 'FIRE LASER', hint: 'HOLD TO FIRE', hold: true }); + return out; +} + +/** The fast forward button, while a course flies (docs/TODO/205 M7). */ +function skipButton(p: CoursePanel): HudButton | null { + if (!p.skip) return null; + if (p.skip.on) { + return { code: COURSE_SKIP_KEY, label: 'FAST FORWARD IS ON', lit: true, hint: 'BACK TO NORMAL SPEED' }; + } + return { + code: COURSE_SKIP_KEY, label: 'FAST FORWARD', + ...(p.skip.block === null ? { hint: `TIME RUNS ${SKIP_SPEED} TIMES FASTER` } : { note: p.skip.block }), + }; +} + + +/** + * The offers as buttons (docs/TODO/206 M5): what a key can do about the + * situation right now (`prompts.ts`). A click or a tap sends the command's own + * key, and the key is named under the words for a pilot at a keyboard. + * + * The E.C.M.'s offer is left out, because it lights the E.C.M. button instead + * of showing twice. + */ +export function offerButtons(offers: readonly Prompt[], mode: ControlMode): HudButton[] { + return offers.filter((p) => p.command !== 'fireEcm').flatMap((p) => { + const code = keyCodeIfBound(mode, p.command); + const key = keyIfBound(mode, p.command); + return code ? [{ code, label: p.what, ...(key ? { hint: `OR PRESS ${key}` } : {}) }] : []; + }); +} diff --git a/src/game/cockpit-view.ts b/src/game/cockpit-view.ts index 41fc7d3a..2cdbe304 100644 --- a/src/game/cockpit-view.ts +++ b/src/game/cockpit-view.ts @@ -15,8 +15,13 @@ // // 1. the gunsight lamp; // 2. where the laser beams meet; -// 3. the prompt line; -// 4. the dashboard frame. +// 3. the offers the situation raises (`prompts.ts`); +// 4. the dashboard frame, and the buttons over the view. +// +// WHAT A BUTTON SAYS IS `cockpit-buttons.ts`'s, since docs/TODO/206 M5. This +// file reads the world and hands that file what it read. The split came when +// this one crossed the size ceiling. The buttons are a subject of their own: +// three columns of words, and no world. // // Each one reads the world and returns a picture. Not one of them decides // anything. @@ -34,11 +39,7 @@ import { viewDirection } from './views.ts'; import { keyCodeIfBound, keyIfBound } from '../ui/key-help.ts'; import type { HudButton } from '../hud/hud-buttons.ts'; import type { CoursePanel } from './course-actions.ts'; -import { COURSE_NAMES } from './courses.ts'; -import { SKIP_SPEED } from '../constants/course.ts'; -import { - COURSE_KEYS, COURSE_SKIP_KEY, COURSE_TOGGLE_KEY, TARGET_NONE_KEY, TARGETS_KEY, -} from './bindings.ts'; +import { actionButtonsFor, courseButtonsFor, offerButtons } from './cockpit-buttons.ts'; import type { TargetPanel } from './target-actions.ts'; import { keymap } from '../engine/keymap.ts'; import type { Command, ControlMode } from './controls.ts'; @@ -63,7 +64,7 @@ import { BEAM_Z } from '../engine/render-stack.ts'; * The fourth is the sight lamp, which lives on the shell. * * `inFlight` REPLACES THREE READS OF `mode`, and they were the same question - * asked three times. The sight, the prompt line and the dashboard each tested + * asked three times. The sight, the offers and the dashboard each tested * `mode === 'flight'`. One host method now, so the three cannot drift apart. * * `view` IS A METHOD RATHER THAN A CONSTRUCTOR ARGUMENT, and boot order is why. @@ -88,89 +89,6 @@ export interface CockpitHost { targetPanel(): TargetPanel | null; } -/** - * The course panel as buttons (docs/TODO/205 M5). With no course, each course - * is a button, and the galactic chart follows them. Over a course that flies, - * one lit button names it and opens the list. - */ -export function courseButtonsFor(p: CoursePanel, chart: string | null): HudButton[] { - if (p.rows === null) { - return p.current === null ? [] : [ - { code: COURSE_TOGGLE_KEY, label: COURSE_NAMES[p.current], lit: true, hint: 'CHOOSE SOMEWHERE ELSE' }, - skipButton(p), - ].filter((b): b is HudButton => b !== null); - } - const out: HudButton[] = p.rows.map((c) => ({ - code: COURSE_KEYS[c.kind], label: c.what, ...(c.why === null ? {} : { note: c.why }), - })); - if (chart) out.push({ code: chart, label: 'GALACTIC CHART' }); - if (p.current !== null) out.push({ code: COURSE_TOGGLE_KEY, label: 'CLOSE' }); - return out; -} - -/** What the pilot's buttons are built from (docs/TODO/206 M3). */ -export interface ActionSource { - /** the fire key of the live layout, which the laser button holds */ - readonly fireKey: string | null; - readonly missiles: number; - readonly armed: boolean; - readonly locked: boolean; - readonly armKey: string | null; - readonly launchKey: string | null; - /** the E.C.M.'s key, or null when none is fitted */ - readonly ecmKey: string | null; - readonly targets: TargetPanel | null; -} - -/** - * The pilot's hands as buttons, top to bottom (docs/TODO/206 M3). The target - * list opens above the rest. The laser comes last, at the bottom, where a - * thumb finds it without a look. - */ -export function actionButtonsFor(a: ActionSource): HudButton[] { - const out: HudButton[] = []; - const t = a.targets; - if (t && t.open) { - for (const { code, row } of t.rows) { - out.push({ - code, label: row.name, lit: row.picked, - hint: `${row.standing} · ${row.range <= LASER_RANGE ? 'IN LASER RANGE' : 'OUT OF LASER RANGE'}`, - ...(row.cost ? { note: row.cost } : {}), - }); - } - if (t.picked) out.push({ code: TARGET_NONE_KEY, label: 'LET THE COMPUTER CHOOSE' }); - } - if (t && (t.rows.length > 0 || t.open)) { - out.push({ - code: TARGETS_KEY, label: t.open ? 'CLOSE THE TARGETS' : 'TARGETS', - hint: t.picked ? `AIMING AT THE ${t.picked.name}` : 'CHOOSE WHAT TO FIGHT', - }); - } - if (a.ecmKey) out.push({ code: a.ecmKey, label: 'E.C.M.', hint: 'DESTROYS MISSILES NEARBY' }); - if (a.missiles > 0 && a.armKey && a.launchKey) { - out.push(a.armed - ? { - code: a.launchKey, label: 'FIRE THE MISSILE', lit: a.locked, - hint: a.locked ? 'LOCKED ON' : 'IT LOCKS ON A SHIP IN YOUR SIGHTS', - } - : { code: a.armKey, label: 'ARM A MISSILE', hint: `${a.missiles} LEFT` }); - } - if (a.fireKey) out.push({ code: a.fireKey, label: 'FIRE LASER', hint: 'HOLD TO FIRE', hold: true }); - return out; -} - -/** The fast forward button, while a course flies (docs/TODO/205 M7). */ -function skipButton(p: CoursePanel): HudButton | null { - if (!p.skip) return null; - if (p.skip.on) { - return { code: COURSE_SKIP_KEY, label: 'FAST FORWARD IS ON', lit: true, hint: 'BACK TO NORMAL SPEED' }; - } - return { - code: COURSE_SKIP_KEY, label: 'FAST FORWARD', - ...(p.skip.block === null ? { hint: `TIME RUNS ${SKIP_SPEED} TIMES FASTER` } : { note: p.skip.block }), - }; -} - export class CockpitView { private readonly state: GameState; private readonly ordnance: Ordnance; @@ -264,8 +182,9 @@ export class CockpitView { } /** - * The prompt line: what a key can do about the situation, with the key the - * table really binds in front of it. + * The offers as text: what a key can do about the situation, with the key + * the table really binds in front of it. The cockpit paints them as buttons + * (`promptButtons`), and the tests read them here. * * The join between a pure rule and invariant 9. `prompts.ts` decides WHICH * commands are worth an offer, and what each is worth right now. `boundKey` @@ -280,6 +199,16 @@ export class CockpitView { * scrape of the painted line. `jettisonCargo` is driven directly the same * way. */ + /** + * Both button columns as the HUD paints them this frame. + * + * @internal — public so that test/run-and-offers.test.ts reads the buttons + * without a scrape of the page. + */ + buttons(): { courses: HudButton[]; actions: HudButton[] } { + return { courses: this.courseButtons(), actions: this.actionButtons() }; + } + /** The pilot's buttons, in flight only (docs/TODO/206 M3). */ private actionButtons(): HudButton[] { const mode = this.host.controlMode(); @@ -293,6 +222,7 @@ export class CockpitView { armKey: key('armMissile'), launchKey: key('launchMissile'), ecmKey: this.state.commander.equipment.ecm ? key('fireEcm') : null, + missileInbound: this.ordnance.missileInbound, targets: this.host.targetPanel(), }); } @@ -302,10 +232,21 @@ export class CockpitView { const panel = this.host.inFlight() ? this.host.coursePanel() : null; if (!panel) return []; const mode = this.host.controlMode(); - return courseButtonsFor(panel, mode ? keyCodeIfBound(mode, 'openChart') : null); + return [ + ...courseButtonsFor(panel, mode ? keyCodeIfBound(mode, 'openChart') : null), + ...(mode ? offerButtons(this.offers(), mode) : []), + ]; } keyPrompts(): string[] { + return this.offers().flatMap((p) => { + const line = this.renderPrompt(p); + return line ? [line] : []; + }); + } + + /** The commands worth an offer right now, in flight only. */ + private offers(): Prompt[] { const mode = this.host.controlMode(); if (!this.host.inFlight() || !mode) return []; return flightPrompts({ @@ -323,9 +264,6 @@ export class CockpitView { stationDistance: this.state.player.position .distanceTo(this.state.world.station.position), dcEngaged: this.state.session.dcEngaged, - }).flatMap((p) => { - const line = this.renderPrompt(p); - return line ? [line] : []; }); } @@ -377,7 +315,6 @@ export class CockpitView { ecmDetected: this.state.ecmDetectedTimer > 0, messageText: this.state.session.messageText, messageTimer: this.state.session.messageTimer, - prompts: this.keyPrompts(), courses: this.courseButtons(), actions: this.actionButtons(), // Null in career flight. It is gated on the same `active` that gives the diff --git a/src/game/course-actions.ts b/src/game/course-actions.ts index de88499c..e26baffc 100644 --- a/src/game/course-actions.ts +++ b/src/game/course-actions.ts @@ -21,7 +21,7 @@ import type { checkJump } from './hyperspace.ts'; import type { GameState } from './state.ts'; import type { Input } from '../engine/input.ts'; import { COURSE_KEYS, COURSE_SKIP_KEY, COURSE_TOGGLE_KEY } from './bindings.ts'; -import { hostilesNear } from './hostility.ts'; +import { hostilesNear, hostilesOnScanner } from './hostility.ts'; import { SKIP_SPEED } from '../constants/course.ts'; /** @@ -179,6 +179,9 @@ export class CourseActions { } this.state().session.course = kind; this.state().session.handFlown = false; + // A run is the one course that flies in a fight, so it takes the stick + // from the aim (docs/TODO/206 M5). + if (kind === 'run') this.state().session.ccEngaged = false; if (kind === 'jump') this.host.startHyperspace(); return true; } @@ -198,6 +201,19 @@ export class CourseActions { : s.world.npcs.filter((n) => n.state.alive).map((n) => n.role), mission: null, done: new Set(s.session.coursesDone), + threat: situation === 'launch' ? null : this.threat(), + }; + } + + /** The fastest hostile ship on the scanner, against the ship's own speed. */ + private threat(): CourseWorld['threat'] { + const s = this.state(); + const hostile = hostilesOnScanner(s.world.npcs, s.player.position, + s.commander.legalStatus, s.player.position.distanceTo(s.world.station.position)); + if (hostile.length === 0) return null; + return { + fastest: Math.max(...hostile.map((n) => n.maxSpeed)), + own: s.player.maxSpeed, }; } } diff --git a/src/game/course-pilot.ts b/src/game/course-pilot.ts index 64f78ba2..95c17220 100644 --- a/src/game/course-pilot.ts +++ b/src/game/course-pilot.ts @@ -41,7 +41,7 @@ import { DOCK_COMPUTER_RANGE } from '../constants/docking-computer.ts'; import { COURSE_ARRIVE_BRAKE, COURSE_ARRIVE_TOLERANCE, COURSE_DERELICT_STANDOFF, COURSE_HERMIT_SPEED, COURSE_HERMIT_STANDOFF, COURSE_PLANET_CLEARANCE, - COURSE_SKIM_DISTANCE, COURSE_TORUS_CONE, COURSE_TORUS_DROP, + COURSE_RUN_REACH, COURSE_SKIM_DISTANCE, COURSE_TORUS_CONE, COURSE_TORUS_DROP, } from '../constants/course.ts'; /** What the course pilot reads for one frame. A flat view, so a test needs no world. */ @@ -64,6 +64,8 @@ export interface CourseView { readonly hermitPos: THREE.Vector3 | null; /** the tank holds all it can */ readonly tankFull: boolean; + /** where the hostile ships on the scanner are, for the run course */ + readonly threats: readonly THREE.Vector3[]; /** the docking computer already has the ship */ readonly dcEngaged: boolean; } @@ -100,6 +102,7 @@ export class CoursePilot { private readonly dir = new THREE.Vector3(); private readonly fwd = new THREE.Vector3(); private readonly aim = new THREE.Vector3(); + private readonly away = new THREE.Vector3(); /** Forget the bank, for a new course. */ reset(): void { this.mem = freshSteerMemory(); } @@ -123,10 +126,26 @@ export class CoursePilot { // scoops work, until the tank is full. return { ...s, done: false }; } + case 'run': return v.threats.length === 0 ? ended() : this.run(v, dt); default: return IDLE; } } + /** + * Run for it (docs/TODO/206 M5). It turns away from the hostile ships and + * opens the throttle. It runs the torus once the mass lock lets go. It aims at a + * point straight away from where the hostile ships sit on average. It ends + * when no hostile ship is left on the scanner. + */ + private run(v: CourseView, dt: number): CourseStep { + this.away.set(0, 0, 0); + for (const t of v.threats) this.away.add(this.dir.subVectors(v.position, t).normalize()); + if (this.away.lengthSq() < 1e-9) this.away.set(0, 0, -1).applyQuaternion(v.quaternion); + const target = this.dir.copy(v.position).addScaledVector(this.away.normalize(), COURSE_RUN_REACH); + const aim = clearOfPlanet(v.position, target, v.planetPos, v.planetRadius, this.aim); + return { ...this.pointAt(v, aim, 1, dt), handOver: false, done: false }; + } + /** * Point at the station, and run the torus while the nose is on it. Inside * the docking computer's range, hand over. The docking computer then flies diff --git a/src/game/courses.ts b/src/game/courses.ts index a2ad578e..8ea71931 100644 --- a/src/game/courses.ts +++ b/src/game/courses.ts @@ -32,10 +32,11 @@ import type { NpcRole } from './ship-roles.ts'; import type { Refusal } from './hyperspace.ts'; import { MAX_FUEL } from '../constants/commander.ts'; import { ASTEROIDS_MIN } from '../constants/population.ts'; +import { RUN_CLOSE_MARGIN } from '../constants/course.ts'; /** What the ship can do by itself. */ export type CourseKind = - 'jump' | 'mission' | 'station' | 'derelict' | 'mine' | 'hermit' | 'skim'; + 'jump' | 'mission' | 'station' | 'derelict' | 'mine' | 'hermit' | 'skim' | 'run'; /** * When the list is asked for. At a launch the ship is still on the pad, and @@ -55,6 +56,7 @@ export const COURSE_NAMES: Readonly> = { mine: 'MINING THE ASTEROIDS', hermit: 'HEADING TO THE ROCK HERMIT', skim: 'SKIMMING THE STAR FOR FUEL', + run: 'RUNNING FOR IT', }; /** One row of the list. */ @@ -86,6 +88,12 @@ export interface CourseWorld { readonly mission: string | null; /** the courses this visit already finished, so they leave the list */ readonly done: ReadonlySet; + /** + * The fight, when there is one (docs/TODO/206 M5): the top speed of the + * fastest hostile ship on the scanner, and the ship's own. Null with no + * hostile ship on the scanner. + */ + readonly threat: { readonly fastest: number; readonly own: number } | null; } /** @@ -101,6 +109,7 @@ export function courseList(w: CourseWorld): Course[] { .filter((c): c is Course => c !== null); } return [ + runRow(w), w.mission !== null && !w.done.has('mission') ? { kind: 'mission', what: w.mission, why: null } as const : null, w.witchspace ? null : { kind: 'station', what: 'FLY TO THE STATION', why: null } as const, @@ -114,6 +123,21 @@ export function courseList(w: CourseWorld): Course[] { ].filter((c): c is Course => c !== null); } +/** + * A way out of a fight: run (docs/TODO/206 M5). It leads the list while a + * hostile ship is on the scanner. Its words say the margin, because a run + * from a fast ship is slow. The plan measured it on 2026-09-11. The player's + * Cobra beats the fastest pirate by 19 units a second. + */ +function runRow(w: CourseWorld): Course | null { + if (w.threat === null) return null; + const margin = w.threat.own - w.threat.fastest; + const words = margin <= 0 ? 'THEY ARE AS FAST AS YOU' + : margin < RUN_CLOSE_MARGIN ? 'YOU ARE ONLY A LITTLE FASTER' + : 'YOU ARE FASTER'; + return { kind: 'run', what: `RUN FOR IT — ${words}`, why: null }; +} + /** Is the thing in the sky, and is its course not done yet? */ function present(w: CourseWorld, role: NpcRole, kind: CourseKind): boolean { return !w.done.has(kind) && w.sky.includes(role); diff --git a/src/game/flight-instruments.ts b/src/game/flight-instruments.ts index 712a61bb..da8194ca 100644 --- a/src/game/flight-instruments.ts +++ b/src/game/flight-instruments.ts @@ -24,6 +24,7 @@ import { Autopilot, type AutopilotEvent } from './autopilot.ts'; import { CoursePilot } from './course-pilot.ts'; import type { CourseKind } from './courses.ts'; import { MAX_FUEL } from '../constants/commander.ts'; +import { hostilesOnScanner } from './hostility.ts'; /** * What the console says when a course finishes its work. The hermit course @@ -32,6 +33,7 @@ import { MAX_FUEL } from '../constants/commander.ts'; const COURSE_ENDS: Partial> = { derelict: 'ARRIVED AT THE DERELICT SHIP', skim: 'FUEL TANK FULL', + run: 'YOU GOT AWAY', }; import { massLocked } from './world-step.ts'; import { boundKey } from '../ui/key-help.ts'; @@ -155,6 +157,8 @@ export class Instruments { derelictSpeed: derelict?.state.speed ?? 0, hermitPos: live('hermit')?.object.position ?? null, tankFull: this.state.commander.fuel >= MAX_FUEL, + threats: hostilesOnScanner(w.npcs, p.position, this.state.commander.legalStatus, + p.position.distanceTo(w.station.position)).map((n) => n.object.position), dcEngaged: s.dcEngaged, }, dt); if (step.handOver) this.applyAutopilot(this.autopilot.handOverToDock()); diff --git a/src/game/flight-weapons.ts b/src/game/flight-weapons.ts index e5acf268..2a2c2e84 100644 --- a/src/game/flight-weapons.ts +++ b/src/game/flight-weapons.ts @@ -190,7 +190,7 @@ export class Weapons { if (!reply) return; const m = ordnanceMessage(reply); // A refusal with an answer names the COMMAND (ordnance.ts); the letter is - // this side's business, from the same table the prompt line reads. + // this side's business, from the same table the offer buttons read. const offer = m.offer ? this.cockpit.renderPrompt(m.offer) : null; this.host.showMessage(offer ? `${m.text} — ${offer}` : m.text, m.seconds); } diff --git a/src/game/game.ts b/src/game/game.ts index f21031ab..33145f67 100644 --- a/src/game/game.ts +++ b/src/game/game.ts @@ -474,6 +474,15 @@ export class Game { return this.flight_.inSimulator() ? null : this.courses_.panel(); } + /** + * Both button columns as the HUD paints them (docs/TODO/206 M5). + * + * @internal — a delegate for test/run-and-offers.test.ts. + */ + hudButtons(): ReturnType { + return this.cockpit_.buttons(); + } + /** * What the target buttons show now (docs/TODO/206 M3). * diff --git a/src/game/hostility.ts b/src/game/hostility.ts index 862fb48b..f344ee88 100644 --- a/src/game/hostility.ts +++ b/src/game/hostility.ts @@ -20,6 +20,7 @@ // It came out of `game/npc.ts`, where it sat inside a class file of 1,676 // lines (docs/TODO/169 M2). +import { SCANNER_RANGE } from '../constants/console.ts'; import type * as THREE from 'three'; import type { NpcRole } from './ship-roles.ts'; @@ -123,6 +124,20 @@ export function hostilesNear( return npcs.some((npc) => engaging(npc, playerPos, legalStatus, playerToStation)); } +/** + * Every ship that attacks the commander within scanner range (docs/TODO/206). + * The run course flies away from them, and its row weighs their speed. It is + * the same rule as `hostilesNear`, over the scanner's reach rather than the + * condition light's. + */ +export function hostilesOnScanner( + npcs: readonly T[], playerPos: THREE.Vector3, legalStatus: number, + playerToStation: number, +): T[] { + return npcs.filter((npc) => isHostileToPlayer(npc, legalStatus, playerToStation) + && npc.object.position.distanceTo(playerPos) <= SCANNER_RANGE); +} + /** * Which of the law's roles are in this fight for a reason the RECORD cannot * explain. diff --git a/src/hud/hud-binding.ts b/src/hud/hud-binding.ts index 80f3613d..c50ec849 100644 --- a/src/hud/hud-binding.ts +++ b/src/hud/hud-binding.ts @@ -60,15 +60,6 @@ export interface HudSources { readonly ecmDetected: boolean; readonly messageText: string; readonly messageTimer: number; - /** - * The key prompts, already rendered — see `HudState.prompts`. - * - * It arrives finished, for the same reason the exercise strip does. WHICH - * keys are worth an offer is `game/prompts.ts`. Which letter each is bound to - * is the binding table's answer, through `boundKey`. That function lives in - * `ui/`, so a rule module cannot reach it. The dashboard is handed the line. - */ - readonly prompts: readonly string[]; /** the course buttons, finished — see `HudState.courses` */ readonly courses: HudState['courses']; /** the pilot's buttons, finished — see `HudState.actions` */ @@ -180,7 +171,6 @@ export function buildHudFrame(s: HudSources, scratch: HudScratch): HudFrame { return { messageText: s.messageText, messageTimer: s.messageTimer, - prompts: s.prompts, courses: s.courses, actions: s.actions, playerPos: s.playerPos, diff --git a/src/hud/hud.ts b/src/hud/hud.ts index ec90abba..a6241159 100644 --- a/src/hud/hud.ts +++ b/src/hud/hud.ts @@ -68,20 +68,10 @@ export interface HudState { /** canonical message state; lifetime advances outside the painter */ messageText: string; messageTimer: number; - /** - * What a key can do about what is happening right now, ALREADY RENDERED — - * each entry is the bound key and what it does ("L PAY 141.0 Cr"). - * - * Finished strings for the same reason `messageText` is one: the painter - * reads state and paints it. WHICH commands are worth offering is - * `game/prompts.ts`. Which letter each is bound to is `controls.ts` through - * `boundKey`. Neither is a question a painter may answer. - */ - prompts: readonly string[]; /** * The course buttons over the view (docs/TODO/205 M5): the list when the - * ship has no course, or the one course it flies. Finished, as the prompts - * are. Which courses exist is `game/courses.ts`. + * ship has no course, or the one course it flies. Finished strings, as the + * message is. Which courses exist is `game/courses.ts`. */ courses: readonly HudButton[]; /** @@ -243,9 +233,6 @@ export class Hud { private readonly creditsEl = byId('credits-display'); private readonly dayEl = byId('day-display'); private readonly messageEl = byId('message'); - private readonly promptsEl = byId('prompts'); - /** what the prompt line currently says, so a steady list is not repainted */ - private promptsShown = ''; private readonly courseStrip = new ButtonStrip(byId('courses')); private readonly actionStrip = new ButtonStrip(byId('actions')); private readonly flashEl = byId('damage-flash'); @@ -279,7 +266,6 @@ export class Hud { render(_dt: number, frame: HudFrame): void { this.messageEl.textContent = frame.messageTimer > 0 ? frame.messageText : ''; - this.paintPrompts(frame.prompts); this.courseStrip.paint(frame.courses); this.actionStrip.paint(frame.actions); this.speedEl.style.width = `${frame.speedFrac * 100}%`; @@ -322,31 +308,6 @@ export class Hud { this.drawCompass(frame.playerPos, frame.playerQuat, frame.compassTarget); } - /** - * The prompt line: the keys worth pressing about what is happening. - * - * It is rebuilt only when the list CHANGES. This runs every frame, and the - * prompts are steady for seconds at a time. A patrol takes four and a half of - * them to cross its warning band. - * - * The key is separated from the words so the stylesheet can light it. That is - * the only reason this is markup rather than `textContent`. The strings - * themselves are built upstream, and never here. - */ - private paintPrompts(prompts: readonly string[]): void { - const line = prompts.join(' '); // em space: a gap, not a bullet - if (line === this.promptsShown) return; - this.promptsShown = line; - this.promptsEl.innerHTML = prompts - .map((p) => { - const gap = p.indexOf(' '); - const key = gap < 0 ? p : p.slice(0, gap); - const what = gap < 0 ? '' : p.slice(gap); - return `${key}${what}`; - }) - .join(' '); - } - /** * The energy gauge: one bank per segment, and red once you are into the last. * diff --git a/src/style.css b/src/style.css index 00084873..070dda0f 100644 --- a/src/style.css +++ b/src/style.css @@ -419,31 +419,6 @@ body.screen-open #message { line-height: 1.5; } -/* - * The key prompts, directly under the message line and quieter than it. - * - * Dim rather than amber, and smaller: a prompt is an answer offered, not an - * event announced, and it must never read as the more urgent of the two lines - * when both are up. Same centring and the same z-index band as #message, so a - * prompt raised while a screen is open is not painted underneath it. - */ -#prompts { - position: absolute; - left: 50%; bottom: 23vh; - transform: translateX(-50%); - z-index: 20; - font-size: 13px; - letter-spacing: 2px; - color: var(--hud-dim); - pointer-events: none; - white-space: nowrap; - text-align: center; -} -#prompts .prompt-key { - color: var(--hud-amber); - text-shadow: 0 0 8px rgba(var(--hud-amber-rgb), 0.7); -} - /* * The course buttons (docs/TODO/205 M5): top right of the view, under the * topbar, clear of the gunsight and of the console. They take a click and a @@ -977,7 +952,6 @@ body.screen-open #exercise { display: none; } * which were placed by eye against a console of a fixed height. */ #message { font-size: 13px; letter-spacing: 2px; bottom: calc(var(--console-h, 0px) + 6dvh); } - #prompts { bottom: calc(var(--console-h, 0px) + 2dvh); } /* * The button row of a long table sticks to the bottom of the panel. The * market has 17 rows, and on a phone BUY and SELL sat below the fold. The diff --git a/test/console-plate.test.ts b/test/console-plate.test.ts index 8e656294..c703e1e4 100644 --- a/test/console-plate.test.ts +++ b/test/console-plate.test.ts @@ -80,7 +80,7 @@ console.log('\nthe console plate goes with its words'); viewDir: V(0, 0, -1), missiles: [], canisters: [], targetLock: null, inFlight: false, exercise: null, - prompts: [], courses: [], actions: [], + courses: [], actions: [], messageText, messageTimer, } as unknown as Parameters[0], { diff --git a/test/course-buttons.test.ts b/test/course-buttons.test.ts index e739ee9e..20625bfe 100644 --- a/test/course-buttons.test.ts +++ b/test/course-buttons.test.ts @@ -9,7 +9,7 @@ import { headlessShell } from '../src/engine/shell.ts'; import { withoutSaving } from '../src/game/storage.ts'; import { seedWorld } from '../src/game/rng.ts'; import { COURSE_KEYS, COURSE_TOGGLE_KEY } from '../src/game/bindings.ts'; -import { courseButtonsFor } from '../src/game/cockpit-view.ts'; +import { courseButtonsFor } from '../src/game/cockpit-buttons.ts'; import { check, dismissBriefing, eq } from './harness.ts'; console.log('\nthe course buttons in flight'); diff --git a/test/course-pilot.test.ts b/test/course-pilot.test.ts index 7c14a3bd..4b75006e 100644 --- a/test/course-pilot.test.ts +++ b/test/course-pilot.test.ts @@ -40,6 +40,7 @@ const view = (station: THREE.Vector3, over: Partial = {}): CourseVie derelictSpeed: 0, hermitPos: null, tankFull: false, + threats: [], dcEngaged: false, ...over, }); diff --git a/test/courses.test.ts b/test/courses.test.ts index 041e4e57..f4a9dd83 100644 --- a/test/courses.test.ts +++ b/test/courses.test.ts @@ -29,6 +29,7 @@ const world = (over: Partial = {}): CourseWorld => ({ sky: ['asteroid', 'hermit', 'generation', 'trader'], mission: null, done: new Set(), + threat: null, ...over, }); @@ -116,3 +117,15 @@ check('...and witch-space has no star in reach', !kinds(world({ witchspace: true // --- witch-space ------------------------------------------------------------- same('in witch-space, with nothing in the sky, the jump is the only course', kinds(world({ witchspace: true, sky: ['thargoid'] })), ['jump']); + +// --- a way out of a fight (docs/TODO/206 M5) -------------------------------- +eq('with a hostile ship on the scanner, RUN leads the list', + kinds(world({ threat: { fastest: 381, own: 400 } }))[0], 'run'); +eq('...and says how thin the margin is', row(world({ threat: { fastest: 381, own: 400 } }), 'run')?.what, + 'RUN FOR IT — YOU ARE ONLY A LITTLE FASTER'); +eq('...or that the ship is faster, where it is', row(world({ threat: { fastest: 320, own: 400 } }), 'run')?.what, + 'RUN FOR IT — YOU ARE FASTER'); +eq('...or that it is not', row(world({ threat: { fastest: 400, own: 400 } }), 'run')?.what, + 'RUN FOR IT — THEY ARE AS FAST AS YOU'); +check('with no hostile ship on the scanner, there is nothing to run from', !kinds(world()).includes('run')); + diff --git a/test/fight-buttons.test.ts b/test/fight-buttons.test.ts index 99108c3d..94db722b 100644 --- a/test/fight-buttons.test.ts +++ b/test/fight-buttons.test.ts @@ -10,7 +10,7 @@ import { Game } from '../src/game/game.ts'; import { headlessShell } from '../src/engine/shell.ts'; import { withoutSaving } from '../src/game/storage.ts'; import { seedWorld } from '../src/game/rng.ts'; -import { actionButtonsFor } from '../src/game/cockpit-view.ts'; +import { actionButtonsFor } from '../src/game/cockpit-buttons.ts'; import { attachHoldButtons } from '../src/engine/hold-buttons.ts'; import { TARGET_NONE_KEY, TARGETS_KEY } from '../src/game/bindings.ts'; import { pickedTarget } from '../src/game/targets.ts'; @@ -20,7 +20,7 @@ console.log('\nthe pilot\'s buttons'); const base = { fireKey: 'KeyA', missiles: 3, armed: false, locked: false, - armKey: 'KeyT', launchKey: 'KeyM', ecmKey: null, targets: null, + armKey: 'KeyT', launchKey: 'KeyM', ecmKey: null, targets: null, missileInbound: false, }; { const b = actionButtonsFor(base); diff --git a/test/run-and-offers.test.ts b/test/run-and-offers.test.ts new file mode 100644 index 00000000..486185e7 --- /dev/null +++ b/test/run-and-offers.test.ts @@ -0,0 +1,84 @@ +// The ways out of a fight (docs/TODO/206 M5). +// +// Chris's words of 2026-09-11: a fight can be left. The run, the bribe and +// the cargo dump are all options. The run is a course. The bribe and the dump +// were offers on a line of text, and they are buttons now, with the key named +// under the words for a pilot at a keyboard. + +import * as THREE from 'three'; +import { Game } from '../src/game/game.ts'; +import { headlessShell } from '../src/engine/shell.ts'; +import { withoutSaving } from '../src/game/storage.ts'; +import { seedWorld } from '../src/game/rng.ts'; +import { COURSE_KEYS } from '../src/game/bindings.ts'; +import { MASS_LOCK_SHIP } from '../src/constants/torus.ts'; +import { check, dismissBriefing, eq } from './harness.ts'; + +console.log('\nthe ways out of a fight'); + +/** A wanted commander in open space, with a police Viper behind the ship. */ +function chased(seed: number): { g: Game; viper: ReturnType } { + const g = withoutSaving(() => { + seedWorld(seed); + const game = new Game(() => headlessShell()); + dismissBriefing(game); + game.launch(); + return game; + }).value; + withoutSaving(() => { for (let f = 0, at = 0; f < 400; f++) g.step(1 / 60, at += 1 / 60); }); + g.state.world.clearNpcs(); + g.state.player.position.add(new THREE.Vector3(0, 60_000, 0)); + g.state.commander.legalStatus = 2; // a fugitive: the police attack + const behind = new THREE.Vector3(0, 0, 2500).applyQuaternion(g.state.player.quaternion); + const viper = g.state.world.spawn('police', g.state.player.position.clone().add(behind), 1); + return { g, viper }; +} + +function press(g: Game, code: string): void { + g.input.injectPress(code); + withoutSaving(() => g.step(1 / 60, 30)); +} + +{ + const { g, viper } = chased(20_260_930); + withoutSaving(() => g.step(1 / 60, 29)); + const labels = g.hudButtons().courses.map((b) => b.label); + check('with a hostile ship on the scanner, the list offers a run', labels[0]?.startsWith('RUN FOR IT'), + labels.join(' | ')); + eq('...and says the ship outruns a police Viper', labels[0], 'RUN FOR IT — YOU ARE FASTER'); + + press(g, COURSE_KEYS.run); + eq('the run button sets the ship running', g.state.session.course, 'run'); + check('...and the computer does not turn to fight', !g.state.session.ccEngaged); + let torus = false; + let widest = 0; + withoutSaving(() => { + for (let f = 0; f < 60 * 90 && g.state.session.course === 'run'; f++) { + g.step(1 / 60, 31 + f / 60); + if (g.state.session.torusEngaged) torus = true; + widest = Math.max(widest, g.state.player.position.distanceTo(viper.object.position)); + } + }); + check('the range opens past the mass lock', widest > MASS_LOCK_SHIP, `${Math.round(widest)} units`); + check('...where the torus drive takes the ship away', torus); + eq('...and the run ends once no hostile ship is on the scanner', g.state.session.course, null); + eq('...and the console says so', g.state.session.messageText, 'YOU GOT AWAY'); +} + +{ + const { g } = chased(20_260_931); + g.state.session.handFlown = true; // no aim, so the Viper closes as it likes + withoutSaving(() => { for (let f = 0; f < 240; f++) g.step(1 / 60, 29 + f / 60); }); + const offer = g.hudButtons().courses.find((b) => b.label.startsWith('PAY')); + check('a police ship with its guns up raises the bribe, as a button', offer !== undefined, + g.hudButtons().courses.map((b) => b.label).join(' | ')); + eq('...that sends the bribe\'s own key', offer?.code, 'KeyL'); + eq('...and names that key under the words', offer?.hint, 'OR PRESS L'); + // Every offer moves the commander's name, whether the policeman takes the + // money or turns it down (law.ts). So that is what proves the offer. + g.state.commander.credits = 1_000_000; + const before = g.state.commander.disrepute ?? 0; + press(g, offer!.code); + check('...and a press makes the offer', (g.state.commander.disrepute ?? 0) > before, + `said: ${g.state.session.messageText}`); +} diff --git a/test/run.ts b/test/run.ts index 75afe3e6..65d9f297 100644 --- a/test/run.ts +++ b/test/run.ts @@ -79,6 +79,7 @@ import './skip.test.ts'; import './targets.test.ts'; import './aim.test.ts'; import './fight-buttons.test.ts'; +import './run-and-offers.test.ts'; import './world.test.ts'; import './docking.test.ts'; import './docking-computer.test.ts'; From 6b1b99d6f5ea6de499de94cc1f543525443e944e Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Fri, 11 Sep 2026 23:21:04 +0100 Subject: [PATCH 024/100] docs/TODO/206 M6: collect everything, and mine the asteroids COLLECT EVERYTHING flies the ship onto each canister and pod within scanner range, nearest first, and the pilot can stop it with another course. It needs fuel scoops, and the row says so when they are missing. It shows only with a clear scanner. MINE THE ASTEROIDS keeps the nearest rock picked as the target. The computer lines the ship up and the pilot fires, which is the fight of this plan applied to a rock. The course ends when no rock is left within range, and the ore is collected by the other course. 5,804 assertions, from 5,791. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- ...ter-flies-the-fight-and-the-pilot-fires.md | 18 +++ src/constants/CATALOG.md | 41 +++--- src/constants/camera.ts | 4 +- src/constants/course.ts | 14 ++ src/constants/docking.ts | 4 +- src/constants/encounters.ts | 8 +- src/game/bindings.ts | 1 + src/game/cockpit-buttons.ts | 6 +- src/game/course-actions.ts | 3 + src/game/course-pilot.ts | 15 ++- src/game/courses.ts | 22 +++- src/game/flight-instruments.ts | 34 +++++ src/game/targets.ts | 6 +- test/course-pilot.test.ts | 1 + test/courses.test.ts | 1 + test/mine-and-collect.test.ts | 124 ++++++++++++++++++ test/run.ts | 1 + 17 files changed, 273 insertions(+), 30 deletions(-) create mode 100644 test/mine-and-collect.test.ts diff --git a/docs/TODO/206-the-computer-flies-the-fight-and-the-pilot-fires.md b/docs/TODO/206-the-computer-flies-the-fight-and-the-pilot-fires.md index faad21c5..a9ced1ac 100644 --- a/docs/TODO/206-the-computer-flies-the-fight-and-the-pilot-fires.md +++ b/docs/TODO/206-the-computer-flies-the-fight-and-the-pilot-fires.md @@ -272,3 +272,21 @@ Evidence: - **Four older constants at 50 and at 8 took their own rule IDs**, as the constants gate asks of a repeated value. - **The suite has 5,791 assertions,** from 5,774. + +### M6 + +- **COLLECT EVERYTHING flies onto each canister, nearest first.** It shows + only with a clear scanner, because a ship that stops to scoop in a fight is + a target. Without fuel scoops the row says so, and the course does not fly. +- **MINE THE ASTEROIDS is a fight, so the course steps aside.** It keeps the + nearest rock picked as the target. The computer then lines the ship up, and + the pilot fires. When no rock is left within scanner range, the course ends. +- **The ore has to be collected, and a held trigger destroys it.** The test + found that: it kept firing after the rock broke, and the laser shot the ore + adrift. That is the game's own rule, and a pilot meets it too. +- **A rock has no name, and the browser run showed the blank.** A ship with + no name of its own is called what it is, such as ASTEROID. Its row then + says the range alone, because the name and the standing are the same word. +- **Four older constants at 60 took their own rule IDs**, as the constants + gate asks. +- **The suite has 5,804 assertions,** from 5,791. diff --git a/src/constants/CATALOG.md b/src/constants/CATALOG.md index f3290f0f..76b002d9 100644 --- a/src/constants/CATALOG.md +++ b/src/constants/CATALOG.md @@ -2,7 +2,7 @@ -436 exported constants. Regenerate with `npm run generate:constants`; +437 exported constants. Regenerate with `npm run generate:constants`; search names, meanings and values with `npm run constants:find -- ""`. | Domain | Symbol | Literal / expression | Purpose | Rule ID | Source | @@ -28,11 +28,11 @@ search names, meanings and values with `npm run constants:find -- ""`. | brain-flight | BRAIN_RATE_DECAY | 5.2207 | | | [brain-flight.ts:25](./brain-flight.ts#L25) | | brain-flight | DECISION_INTERVAL | 0.1 | How long a brain holds a decision before it takes another: 10 Hz. | flight.brain.decisionInterval | [brain-flight.ts:38](./brain-flight.ts#L38) | | brain-flight | OBS_SPEED_SCALE | 400 | The speed scale that normalizes every observation, in world units a second. | flight.brain.observationSpeed | [brain-flight.ts:52](./brain-flight.ts#L52) | -| camera | CAMERA_FOV | 60 | Vertical field of view, in degrees. | | [camera.ts:10](./camera.ts#L10) | -| camera | CAMERA_NEAR | 1 | Near plane — 1 unit, about a wingtip. | camera.near | [camera.ts:20](./camera.ts#L20) | -| camera | CAMERA_FAR | 1_000_000 | Far plane — a million units. | | [camera.ts:26](./camera.ts#L26) | -| camera | HEADLESS_WIDTH | 1280 | The viewport that a run with no window pretends to have. | | [camera.ts:34](./camera.ts#L34) | -| camera | HEADLESS_HEIGHT | 720 | | | [camera.ts:35](./camera.ts#L35) | +| camera | CAMERA_FOV | 60 | Vertical field of view, in degrees. | camera.fov | [camera.ts:12](./camera.ts#L12) | +| camera | CAMERA_NEAR | 1 | Near plane — 1 unit, about a wingtip. | camera.near | [camera.ts:22](./camera.ts#L22) | +| camera | CAMERA_FAR | 1_000_000 | Far plane — a million units. | | [camera.ts:28](./camera.ts#L28) | +| camera | HEADLESS_WIDTH | 1280 | The viewport that a run with no window pretends to have. | | [camera.ts:36](./camera.ts#L36) | +| camera | HEADLESS_HEIGHT | 720 | | | [camera.ts:37](./camera.ts#L37) | | character | CHARACTER | [ [0, 'Honest'], [10, 'Dubious'], [25, 'Dodgy'], [50, 'Shady'], [80, 'Notorious'], [120, 'Cutthroat'], ] | The character ladder: the disrepute score, lowest first, and the rung that it earns. | | [character.ts:19](./character.ts#L19) | | character | DISREPUTE_HERMIT_KILL | 40 | What each deed adds to disrepute, tuned in play. | character.hermitKill | [character.ts:35](./character.ts#L35) | | character | HERMIT_HIT_LINE | 'ROCK HERMIT HIT — SOMEBODY LIVES IN THAT ROCK' | What the console says on the first hit that lands on a rock hermit. | | [character.ts:52](./character.ts#L52) | @@ -126,6 +126,7 @@ search names, meanings and values with `npm run constants:find -- ""`. | course | SKIP_SPEED | 8 | How much faster the world runs under the fast forward button, as a count of fixed steps in one screen frame (docs/TODO/205 M7). | course.skipSpeed | [course.ts:145](./course.ts#L145) | | course | RUN_CLOSE_MARGIN | 50 | Below this lead in top speed, in world units a second, the run row says the ship is only a little faster (docs/TODO/206 M5). | course.runCloseMargin | [course.ts:159](./course.ts#L159) | | course | COURSE_RUN_REACH | 50_000 | How far ahead the run course aims, in world units, on the line away from the hostile ships (docs/TODO/206 M5). | course.runReach | [course.ts:169](./course.ts#L169) | +| course | COURSE_COLLECT_SPEED | 60 | How fast the collect course flies onto a canister, in world units a second (docs/TODO/206 M6). | course.collectSpeed | [course.ts:183](./course.ts#L183) | | docking | GATE_HALF_WIDTHS | 5 | How far out the approach gate sits, in multiples of the station half-width. | docking.gateHalfWidths | [docking.ts:25](./docking.ts#L25) | | docking | TURN_IN | Math.PI / 4 | How far round from the slot axis an approach turns in, in radians. | | [docking.ts:49](./docking.ts#L49) | | docking | RUN_IN_WIDTHS | GATE_HALF_WIDTHS * 0.6 | Where the approach stops the curve and flies straight, in station half-widths. | | [docking.ts:87](./docking.ts#L87) | @@ -134,26 +135,26 @@ search names, meanings and values with `npm run constants:find -- ""`. | docking | NPC_HULL_BOX_MARGIN | HULL_BOX_MARGIN | The same cube for every NPC. | | [docking.ts:119](./docking.ts#L119) | | docking | SLOT_HALF_ACROSS | 26 | The slot channel, as half-extents ACROSS the slot and ALONG it, in station-local world units. | | [docking.ts:127](./docking.ts#L127) | | docking | SLOT_HALF_ALONG | 62 | | | [docking.ts:128](./docking.ts#L128) | -| docking | SLOT_DEPTH | 60 | How far into the -Z face puts a ship in the channel, in world units. | | [docking.ts:131](./docking.ts#L131) | -| docking | ROLL_TOLERANCE | 0.65 | The wings against the slot's long axis, in radians: how badly you may be rolled and still fit through the letterbox. | | [docking.ts:142](./docking.ts#L142) | +| docking | SLOT_DEPTH | 60 | How far into the -Z face puts a ship in the channel, in world units. * | docking.slotDepth | [docking.ts:133](./docking.ts#L133) | +| docking | ROLL_TOLERANCE | 0.65 | The wings against the slot's long axis, in radians: how badly you may be rolled and still fit through the letterbox. | | [docking.ts:144](./docking.ts#L144) | | docking-computer | DOCK_COMPUTER_RANGE | 3500 | How close to the station the docking computer will take the job, in world units. | | [docking-computer.ts:46](./docking-computer.ts#L46) | | docking-computer | DC_SLOT_MARGIN | 0.30 | How much of the slot's roll tolerance the TURN may spend, as a fraction. | docking.slotMargin | [docking-computer.ts:97](./docking-computer.ts#L97) | | docking-computer | DC_TURN_FADE_ANGLE | 0.10 | The off-nose angle, in radians, over which the TURN's claim on the roll axis ramps in. | docking.turnFadeAngle | [docking-computer.ts:151](./docking-computer.ts#L151) | | docking-computer | DC_ROLL_LEAD | 0.10 | How far ahead IN TIME the roll ask reads the rate it already rolls at, in seconds. | docking.rollLead | [docking-computer.ts:211](./docking-computer.ts#L211) | | docking-computer | DC_PATH_LOOKAHEAD | 1.5 | How far ahead ALONG THE PATH the follower aims, in station half-widths. | docking.pathLookahead | [docking-computer.ts:272](./docking-computer.ts#L272) | | encounters | TRADER_GAP | 100 | The gap between trader arrivals in a system with no economy to speak of. | | [encounters.ts:20](./encounters.ts#L20) | -| encounters | TRADER_GAP_JITTER | 60 | ...and the jitter on top, drawn flat, so the lane never runs to a metronome. | | [encounters.ts:23](./encounters.ts#L23) | -| encounters | TRADER_GAP_BUSY_MAX | 50 | The most that a busy economy can discount off `TRADER_GAP`. | encounters.traderGapBusyMax | [encounters.ts:38](./encounters.ts#L38) | -| encounters | PRODUCTIVITY_PER_SECOND | 1200 | How much 1984 productivity buys one second off that gap. | | [encounters.ts:49](./encounters.ts#L49) | -| encounters | TRADER_GAP_FIRST | 20 | How long after a system's clocks start the first trader may appear. | encounters.traderGapFirst | [encounters.ts:62](./encounters.ts#L62) | -| encounters | TRADER_GAP_FIRST_JITTER | 40 | ...and its jitter, so two arrivals in one system are not the same arrival. * | encounters.traderGapFirstJitter | [encounters.ts:67](./encounters.ts#L67) | -| encounters | PIRATE_WAVE_GAP | 60 | The gap between pirate waves in the most organised system that still breeds them. | | [encounters.ts:75](./encounters.ts#L75) | -| encounters | PIRATE_WAVE_GAP_PER_GOVERNMENT | 40 | ...and how much longer the wait grows for every step up the government ladder. | encounters.pirateWaveGapPerGovernment | [encounters.ts:88](./encounters.ts#L88) | -| encounters | PIRATE_WAVE_GAP_JITTER | 90 | ...and the jitter. | | [encounters.ts:92](./encounters.ts#L92) | -| encounters | LAWLESS_GOVERNMENT | 3 | A government at or below this breeds pirate waves at all. 3 is a dictatorship on the 1984 ladder, so waves stop at communist (4) and above. | encounters.lawlessGovernment | [encounters.ts:104](./encounters.ts#L104) | -| encounters | ANARCHY_GOVERNMENT | 1 | ...and a government at or below THIS sends them two at a time: anarchy (0) and feudal (1). | encounters.anarchyGovernment | [encounters.ts:120](./encounters.ts#L120) | -| encounters | MAX_THARGONS | 2 | How many drones the Thargoids keep in the sky at once, across every mothership. | encounters.maxThargons | [encounters.ts:140](./encounters.ts#L140) | -| encounters | THARGON_REDEPLOY | 5 | Seconds between one drone and the next, and the wait for the first. | encounters.thargonRedeploy | [encounters.ts:155](./encounters.ts#L155) | +| encounters | TRADER_GAP_JITTER | 60 | ...and the jitter on top, drawn flat, so the lane never runs to a metronome. * | encounters.traderGapJitter | [encounters.ts:25](./encounters.ts#L25) | +| encounters | TRADER_GAP_BUSY_MAX | 50 | The most that a busy economy can discount off `TRADER_GAP`. | encounters.traderGapBusyMax | [encounters.ts:40](./encounters.ts#L40) | +| encounters | PRODUCTIVITY_PER_SECOND | 1200 | How much 1984 productivity buys one second off that gap. | | [encounters.ts:51](./encounters.ts#L51) | +| encounters | TRADER_GAP_FIRST | 20 | How long after a system's clocks start the first trader may appear. | encounters.traderGapFirst | [encounters.ts:64](./encounters.ts#L64) | +| encounters | TRADER_GAP_FIRST_JITTER | 40 | ...and its jitter, so two arrivals in one system are not the same arrival. * | encounters.traderGapFirstJitter | [encounters.ts:69](./encounters.ts#L69) | +| encounters | PIRATE_WAVE_GAP | 60 | The gap between pirate waves in the most organised system that still breeds them. | encounters.pirateWaveGap | [encounters.ts:79](./encounters.ts#L79) | +| encounters | PIRATE_WAVE_GAP_PER_GOVERNMENT | 40 | ...and how much longer the wait grows for every step up the government ladder. | encounters.pirateWaveGapPerGovernment | [encounters.ts:92](./encounters.ts#L92) | +| encounters | PIRATE_WAVE_GAP_JITTER | 90 | ...and the jitter. | | [encounters.ts:96](./encounters.ts#L96) | +| encounters | LAWLESS_GOVERNMENT | 3 | A government at or below this breeds pirate waves at all. 3 is a dictatorship on the 1984 ladder, so waves stop at communist (4) and above. | encounters.lawlessGovernment | [encounters.ts:108](./encounters.ts#L108) | +| encounters | ANARCHY_GOVERNMENT | 1 | ...and a government at or below THIS sends them two at a time: anarchy (0) and feudal (1). | encounters.anarchyGovernment | [encounters.ts:124](./encounters.ts#L124) | +| encounters | MAX_THARGONS | 2 | How many drones the Thargoids keep in the sky at once, across every mothership. | encounters.maxThargons | [encounters.ts:144](./encounters.ts#L144) | +| encounters | THARGON_REDEPLOY | 5 | Seconds between one drone and the next, and the wait for the first. | encounters.thargonRedeploy | [encounters.ts:159](./encounters.ts#L159) | | exercise | OPENING_RANGE | 4500 | The opening range for a fight that you are meant to see coming. | exercise.openingRange | [exercise.ts:33](./exercise.ts#L33) | | exercise | AMBUSH_RANGE | 2400 | An ambush opens INSIDE their gun, because that is what an ambush is. | | [exercise.ts:40](./exercise.ts#L40) | | exercise | MIN_OPENING_RANGE | 2 * PASS_FAR | No opening may be closer than this. | | [exercise.ts:49](./exercise.ts#L49) | diff --git a/src/constants/camera.ts b/src/constants/camera.ts index 10e4236d..faed934f 100644 --- a/src/constants/camera.ts +++ b/src/constants/camera.ts @@ -6,7 +6,9 @@ * Vertical field of view, in degrees. It is load-bearing beyond the looks. The * trainer's `IN_VIEW_DEG` arc is argued from this, so a change moves what "the * pilot can see it" means. - */ + * + * @rule camera.fov +*/ export const CAMERA_FOV = 60; /** diff --git a/src/constants/course.ts b/src/constants/course.ts index 40887ecb..a6f28368 100644 --- a/src/constants/course.ts +++ b/src/constants/course.ts @@ -167,3 +167,17 @@ export const RUN_CLOSE_MARGIN = 50; * @domain course */ export const COURSE_RUN_REACH = 50_000; + +/** + * How fast the collect course flies onto a canister, in world units a second + * (docs/TODO/206 M6). + * + * The scoop takes a canister inside `SCOOP_RANGE`, which is 45 units. At this + * speed the ship covers that in more than half a second, so the scoop has + * frames to catch it. A canister drifts, and the course arrives at the speed + * the drift needs rather than at a stop. + * + * @rule course.collectSpeed + * @domain course + */ +export const COURSE_COLLECT_SPEED = 60; diff --git a/src/constants/docking.ts b/src/constants/docking.ts index 9ebfcded..6cfdf67a 100644 --- a/src/constants/docking.ts +++ b/src/constants/docking.ts @@ -127,7 +127,9 @@ export const NPC_HULL_BOX_MARGIN = HULL_BOX_MARGIN; export const SLOT_HALF_ACROSS = 26; export const SLOT_HALF_ALONG = 62; -/** How far into the -Z face puts a ship in the channel, in world units. */ +/** How far into the -Z face puts a ship in the channel, in world units. * + * @rule docking.slotDepth +*/ export const SLOT_DEPTH = 60; /** diff --git a/src/constants/encounters.ts b/src/constants/encounters.ts index b1af1bc5..d7bde30a 100644 --- a/src/constants/encounters.ts +++ b/src/constants/encounters.ts @@ -19,7 +19,9 @@ */ export const TRADER_GAP = 100; -/** ...and the jitter on top, drawn flat, so the lane never runs to a metronome. */ +/** ...and the jitter on top, drawn flat, so the lane never runs to a metronome. * + * @rule encounters.traderGapJitter +*/ export const TRADER_GAP_JITTER = 60; /** @@ -71,7 +73,9 @@ export const TRADER_GAP_FIRST_JITTER = 40; * them. It is also the first wave's countdown when you arrive. It is one number, * because the first wave is the ladder's bottom rung, with no government term and * no jitter. - */ + * + * @rule encounters.pirateWaveGap +*/ export const PIRATE_WAVE_GAP = 60; /** diff --git a/src/game/bindings.ts b/src/game/bindings.ts index 1f9ff239..01bfd155 100644 --- a/src/game/bindings.ts +++ b/src/game/bindings.ts @@ -54,6 +54,7 @@ export const COURSE_KEYS: Readonly> = { hermit: 'VirtCourseHermit', skim: 'VirtCourseSkim', run: 'VirtCourseRun', + collect: 'VirtCourseCollect', }; /** The launch list's row for the galactic chart, where a pilot sets a target. */ diff --git a/src/game/cockpit-buttons.ts b/src/game/cockpit-buttons.ts index 9e3598c7..5be796d9 100644 --- a/src/game/cockpit-buttons.ts +++ b/src/game/cockpit-buttons.ts @@ -74,9 +74,11 @@ export function actionButtonsFor(a: ActionSource): HudButton[] { const t = a.targets; if (t && t.open) { for (const { code, row } of t.rows) { + const reach = row.range <= LASER_RANGE ? 'IN LASER RANGE' : 'OUT OF LASER RANGE'; out.push({ code, label: row.name, lit: row.picked, - hint: `${row.standing} · ${row.range <= LASER_RANGE ? 'IN LASER RANGE' : 'OUT OF LASER RANGE'}`, + // A rock's name IS its standing, so the hint says the range alone. + hint: row.name === row.standing ? reach : `${row.standing} · ${reach}`, ...(row.cost ? { note: row.cost } : {}), }); } @@ -84,7 +86,7 @@ export function actionButtonsFor(a: ActionSource): HudButton[] { } if (t && (t.rows.length > 0 || t.open)) { out.push({ - code: TARGETS_KEY, label: t.open ? 'CLOSE THE TARGETS' : 'TARGETS', + code: TARGETS_KEY, label: t.open ? 'CLOSE THE LIST' : 'TARGETS', hint: t.picked ? `AIMING AT THE ${t.picked.name}` : 'CHOOSE WHAT TO FIGHT', }); } diff --git a/src/game/course-actions.ts b/src/game/course-actions.ts index e26baffc..e9229c55 100644 --- a/src/game/course-actions.ts +++ b/src/game/course-actions.ts @@ -23,6 +23,7 @@ import type { Input } from '../engine/input.ts'; import { COURSE_KEYS, COURSE_SKIP_KEY, COURSE_TOGGLE_KEY } from './bindings.ts'; import { hostilesNear, hostilesOnScanner } from './hostility.ts'; import { SKIP_SPEED } from '../constants/course.ts'; +import { SCANNER_RANGE } from '../constants/console.ts'; /** * What the course buttons show in flight: the list, or the course under way. @@ -202,6 +203,8 @@ export class CourseActions { mission: null, done: new Set(s.session.coursesDone), threat: situation === 'launch' ? null : this.threat(), + loot: situation === 'launch' ? 0 : s.world.cargo.items + .filter((c) => c.object.position.distanceTo(s.player.position) <= SCANNER_RANGE).length, }; } diff --git a/src/game/course-pilot.ts b/src/game/course-pilot.ts index 95c17220..62bb8e8c 100644 --- a/src/game/course-pilot.ts +++ b/src/game/course-pilot.ts @@ -41,7 +41,8 @@ import { DOCK_COMPUTER_RANGE } from '../constants/docking-computer.ts'; import { COURSE_ARRIVE_BRAKE, COURSE_ARRIVE_TOLERANCE, COURSE_DERELICT_STANDOFF, COURSE_HERMIT_SPEED, COURSE_HERMIT_STANDOFF, COURSE_PLANET_CLEARANCE, - COURSE_RUN_REACH, COURSE_SKIM_DISTANCE, COURSE_TORUS_CONE, COURSE_TORUS_DROP, + COURSE_COLLECT_SPEED, COURSE_RUN_REACH, COURSE_SKIM_DISTANCE, COURSE_TORUS_CONE, + COURSE_TORUS_DROP, } from '../constants/course.ts'; /** What the course pilot reads for one frame. A flat view, so a test needs no world. */ @@ -66,6 +67,8 @@ export interface CourseView { readonly tankFull: boolean; /** where the hostile ships on the scanner are, for the run course */ readonly threats: readonly THREE.Vector3[]; + /** where the cargo adrift within scanner range is, nearest first */ + readonly loot: readonly THREE.Vector3[]; /** the docking computer already has the ship */ readonly dcEngaged: boolean; } @@ -127,6 +130,16 @@ export class CoursePilot { return { ...s, done: false }; } case 'run': return v.threats.length === 0 ? ended() : this.run(v, dt); + case 'collect': { + const next = v.loot[0]; + if (next === undefined) return ended(); + // Fly onto it. The scoop takes it aboard inside `SCOOP_RANGE`, and + // the next one is then the nearest (docs/TODO/206 M6). + return { ...this.arrive(v, { target: next, standoff: 0, speed: COURSE_COLLECT_SPEED }, dt), done: false }; + } + // A rock is fought, not flown to: `flight-instruments.ts` picks the next + // one as the target, and the computer's aim lines the ship up on it. + case 'mine': return IDLE; default: return IDLE; } } diff --git a/src/game/courses.ts b/src/game/courses.ts index 8ea71931..927575f8 100644 --- a/src/game/courses.ts +++ b/src/game/courses.ts @@ -36,7 +36,8 @@ import { RUN_CLOSE_MARGIN } from '../constants/course.ts'; /** What the ship can do by itself. */ export type CourseKind = - 'jump' | 'mission' | 'station' | 'derelict' | 'mine' | 'hermit' | 'skim' | 'run'; + 'jump' | 'mission' | 'station' | 'derelict' | 'mine' | 'hermit' | 'skim' | 'run' + | 'collect'; /** * When the list is asked for. At a launch the ship is still on the pad, and @@ -57,6 +58,7 @@ export const COURSE_NAMES: Readonly> = { hermit: 'HEADING TO THE ROCK HERMIT', skim: 'SKIMMING THE STAR FOR FUEL', run: 'RUNNING FOR IT', + collect: 'COLLECTING THE CARGO', }; /** One row of the list. */ @@ -94,6 +96,8 @@ export interface CourseWorld { * hostile ship on the scanner. */ readonly threat: { readonly fastest: number; readonly own: number } | null; + /** how many canisters and capsules drift within scanner range */ + readonly loot: number; } /** @@ -115,6 +119,7 @@ export function courseList(w: CourseWorld): Course[] { w.witchspace ? null : { kind: 'station', what: 'FLY TO THE STATION', why: null } as const, present(w, 'generation', 'derelict') ? { kind: 'derelict', what: 'INVESTIGATE THE DERELICT SHIP', why: null } as const : null, + collectRow(w), mineRow(w, false), present(w, 'hermit', 'hermit') ? { kind: 'hermit', what: 'VISIT THE ROCK HERMIT', why: null } as const : null, @@ -170,6 +175,21 @@ const JUMP_WHY: Readonly> = { alreadyJumping: 'THE JUMP HAS STARTED', }; +/** + * The cargo adrift within scanner range (docs/TODO/206 M6). It shows only + * with a clear scanner, because a ship that stops to scoop in a fight is a + * target. The scoops are what take a canister aboard. Without them a canister + * breaks on the hull (`world-step.ts`), so the row says what the ship needs. + */ +function collectRow(w: CourseWorld): Course | null { + if (w.loot === 0 || w.threat !== null) return null; + return { + kind: 'collect', + what: w.loot === 1 ? 'COLLECT THE CARGO' : 'COLLECT EVERYTHING', + why: w.commander.equipment.scoops ? null : 'NEEDS FUEL SCOOPS', + }; +} + /** * The rocks. The ore needs a mining laser to cut it and fuel scoops to take it * aboard. Without the scoops the ore breaks on the hull (`world-step.ts`), so diff --git a/src/game/flight-instruments.ts b/src/game/flight-instruments.ts index da8194ca..d3a22d69 100644 --- a/src/game/flight-instruments.ts +++ b/src/game/flight-instruments.ts @@ -25,6 +25,8 @@ import { CoursePilot } from './course-pilot.ts'; import type { CourseKind } from './courses.ts'; import { MAX_FUEL } from '../constants/commander.ts'; import { hostilesOnScanner } from './hostility.ts'; +import { pickTarget, pickedTarget } from './targets.ts'; +import { SCANNER_RANGE } from '../constants/console.ts'; /** * What the console says when a course finishes its work. The hermit course @@ -34,6 +36,8 @@ const COURSE_ENDS: Partial> = { derelict: 'ARRIVED AT THE DERELICT SHIP', skim: 'FUEL TANK FULL', run: 'YOU GOT AWAY', + mine: 'NO ROCKS LEFT WITHIN RANGE', + collect: 'EVERYTHING IS ABOARD', }; import { massLocked } from './world-step.ts'; import { boundKey } from '../ui/key-help.ts'; @@ -140,6 +144,12 @@ export class Instruments { } const p = this.state.player; const w = this.state.world; + // The mining course fights the rocks: it picks the next one, and the + // computer's aim lines the ship up on it (docs/TODO/206 M6). + if (s.course === 'mine' && !this.aimAtNextRock()) { + this.endCourse('mine'); + return null; + } const live = (role: string) => w.npcs.find((n) => n.state.alive && n.role === role) ?? null; const derelict = live('generation'); const step = this.coursePilot.step({ @@ -157,6 +167,10 @@ export class Instruments { derelictSpeed: derelict?.state.speed ?? 0, hermitPos: live('hermit')?.object.position ?? null, tankFull: this.state.commander.fuel >= MAX_FUEL, + loot: w.cargo.items + .map((c) => c.object.position) + .filter((at) => at.distanceTo(p.position) <= SCANNER_RANGE) + .sort((a, b) => a.distanceTo(p.position) - b.distanceTo(p.position)), threats: hostilesOnScanner(w.npcs, p.position, this.state.commander.legalStatus, p.position.distanceTo(w.station.position)).map((n) => n.object.position), dcEngaged: s.dcEngaged, @@ -167,6 +181,26 @@ export class Instruments { return step.demand; } + /** + * The mining course keeps a rock picked as the target, so the computer aims + * at it and the pilot fires. + * + * @returns false when no rock is left within scanner range. + */ + private aimAtNextRock(): boolean { + const { player, world } = this.state; + if (pickedTarget(world.npcs)?.role === 'asteroid') return true; + const rocks = world.npcs + .filter((n) => n.state.alive && n.role === 'asteroid' + && n.object.position.distanceTo(player.position) <= SCANNER_RANGE) + .sort((a, b) => a.object.position.distanceTo(player.position) + - b.object.position.distanceTo(player.position)); + if (rocks.length === 0) return false; + pickTarget(world.npcs, rocks[0]); + this.state.session.handFlown = false; + return true; + } + /** * A course finished its work. It leaves the ship, and it leaves the list * for the rest of the visit. The console says what the ship did. diff --git a/src/game/targets.ts b/src/game/targets.ts index 31996357..438e7fc3 100644 --- a/src/game/targets.ts +++ b/src/game/targets.ts @@ -69,12 +69,14 @@ export function targetList(v: TargetView): TargetRow[] { && (n.state.targeted || n.object.position.distanceTo(v.playerPos) <= SCANNER_RANGE)) .map((ship) => { const hostile = isHostileToPlayer(ship, v.legalStatus, v.playerToStation); + const standing = hostile ? 'HOSTILE' : STANDING[ship.role] ?? 'SHIP'; return { row: { ship, - name: ship.object.name.toUpperCase(), + // A rock carries no name of its own, so it is called what it is. + name: (ship.object.name || STANDING[ship.role] || 'SHIP').toUpperCase(), range: ship.object.position.distanceTo(v.playerPos), - standing: hostile ? 'HOSTILE' : STANDING[ship.role] ?? 'SHIP', + standing, cost: costOf(ship.role), picked: ship.state.targeted, }, diff --git a/test/course-pilot.test.ts b/test/course-pilot.test.ts index 4b75006e..7bda531e 100644 --- a/test/course-pilot.test.ts +++ b/test/course-pilot.test.ts @@ -41,6 +41,7 @@ const view = (station: THREE.Vector3, over: Partial = {}): CourseVie hermitPos: null, tankFull: false, threats: [], + loot: [], dcEngaged: false, ...over, }); diff --git a/test/courses.test.ts b/test/courses.test.ts index f4a9dd83..2de5d759 100644 --- a/test/courses.test.ts +++ b/test/courses.test.ts @@ -30,6 +30,7 @@ const world = (over: Partial = {}): CourseWorld => ({ mission: null, done: new Set(), threat: null, + loot: 0, ...over, }); diff --git a/test/mine-and-collect.test.ts b/test/mine-and-collect.test.ts new file mode 100644 index 00000000..e5a09d83 --- /dev/null +++ b/test/mine-and-collect.test.ts @@ -0,0 +1,124 @@ +// Mining and collecting (docs/TODO/206 M6). +// +// Chris's words of 2026-09-11: the same fight works on asteroids, and +// collecting needs fuel scoops. The ship flies round the cargo, and the pilot +// can stop it. So MINE THE ASTEROIDS keeps a rock picked, the computer aims, +// and the pilot fires. COLLECT EVERYTHING then flies onto each canister. + +import * as THREE from 'three'; +import { Game } from '../src/game/game.ts'; +import { headlessShell } from '../src/engine/shell.ts'; +import { withoutSaving } from '../src/game/storage.ts'; +import { seedWorld } from '../src/game/rng.ts'; +import { COURSE_KEYS } from '../src/game/bindings.ts'; +import { pickedTarget } from '../src/game/targets.ts'; +import { keymap } from '../src/engine/keymap.ts'; +import { check, dismissBriefing, eq } from './harness.ts'; + +console.log('\nmining and collecting'); + +/** A commander in open space with scoops, a mining laser, and an empty sky. */ +function outThere(seed: number): Game { + const g = withoutSaving(() => { + seedWorld(seed); + const game = new Game(() => headlessShell()); + dismissBriefing(game); + game.launch(); + return game; + }).value; + withoutSaving(() => { for (let f = 0, at = 0; f < 400; f++) g.step(1 / 60, at += 1 / 60); }); + g.state.world.clearNpcs(); + g.state.world.cargo.clear(); + g.state.player.position.add(new THREE.Vector3(0, 50_000, 0)); + g.state.commander.equipment.scoops = true; + g.state.commander.equipment.miningLaser = true; + return g; +} + +function run(g: Game, frames: number, hold = false): void { + const fire = keymap().fire[0]; + withoutSaving(() => { + for (let f = 0; f < frames; f++) { + if (hold) g.input.press(fire); + g.step(1 / 60, 40 + f / 60); + } + }); + g.input.release(fire); +} + +function press(g: Game, code: string): void { + g.input.injectPress(code); + withoutSaving(() => g.step(1 / 60, 39)); +} + +/** A point in front of the ship. */ +function ahead(g: Game, z: number, x = 0): THREE.Vector3 { + return g.state.player.position.clone() + .add(new THREE.Vector3(x, 0, -z).applyQuaternion(g.state.player.quaternion)); +} + +{ + const g = outThere(20_260_932); + g.state.world.cargo.spawn(ahead(g, 900), 1, [0]); + g.state.world.cargo.spawn(ahead(g, 1500, 400), 1, [0]); + const held = g.state.commander.cargo.reduce((a, b) => a + b, 0); + check('with cargo adrift and a clear scanner, the list offers to collect it', + g.coursePanel()?.rows?.some((c) => c.kind === 'collect' && c.why === null) === true); + + press(g, COURSE_KEYS.collect); + eq('the button sets the ship collecting', g.state.session.course, 'collect'); + withoutSaving(() => { + for (let f = 0; f < 60 * 120 && g.state.session.course === 'collect'; f++) { + g.step(1 / 60, 40 + f / 60); + } + }); + eq('...and every canister is aboard', g.state.world.cargo.items.length, 0); + check('...in the hold', g.state.commander.cargo.reduce((a, b) => a + b, 0) > held); + eq('...and the console says so', g.state.session.messageText, 'EVERYTHING IS ABOARD'); +} + +{ + const g = outThere(20_260_933); + g.state.commander.equipment.scoops = false; + g.state.world.cargo.spawn(ahead(g, 900), 1, [0]); + const row = g.coursePanel()?.rows?.find((c) => c.kind === 'collect'); + eq('with no fuel scoops the row says what the ship needs', row?.why, 'NEEDS FUEL SCOOPS'); +} + +{ + const g = outThere(20_260_934); + const rock = g.state.world.spawn('asteroid', ahead(g, 1200), 1); + press(g, COURSE_KEYS.mine); + run(g, 2); + eq('the mining course picks a rock as the target', pickedTarget(g.state.world.npcs), rock); + check('...and the computer takes the stick to line the ship up', g.state.session.ccEngaged); + // The ship has scoops, and it flies on through what the rock leaves. So + // the ore is counted in the hold rather than in the sky. + const said: string[] = []; + const fire = keymap().fire[0]; + withoutSaving(() => { + for (let f = 0; f < 60 * 40 && g.state.session.course === 'mine'; f++) { + g.input.press(fire); + g.step(1 / 60, 40 + f / 60); + const line = g.state.session.messageText; + if (line && said.at(-1) !== line) said.push(line); + } + }); + g.input.release(fire); + check('...and the pilot\'s trigger breaks it', !rock.state.alive); + check('...which leaves ore adrift', g.state.world.cargo.items.length > 0); + eq('...and with no rock left, the mining course ends', g.state.session.course, null); + check('...and says why', said.includes('NO ROCKS LEFT WITHIN RANGE'), said.join(' | ')); + + // ...and the ore is collected by the other course, which is the pair as a + // player flies it. + const held = g.state.commander.cargo.reduce((a, b) => a + b, 0); + press(g, COURSE_KEYS.collect); + withoutSaving(() => { + for (let f = 0; f < 60 * 120 && g.state.session.course === 'collect'; f++) { + g.step(1 / 60, 90 + f / 60); + } + }); + check('the collect course then takes the ore aboard', + g.state.commander.cargo.reduce((a, b) => a + b, 0) > held); +} diff --git a/test/run.ts b/test/run.ts index 65d9f297..11165450 100644 --- a/test/run.ts +++ b/test/run.ts @@ -80,6 +80,7 @@ import './targets.test.ts'; import './aim.test.ts'; import './fight-buttons.test.ts'; import './run-and-offers.test.ts'; +import './mine-and-collect.test.ts'; import './world.test.ts'; import './docking.test.ts'; import './docking-computer.test.ts'; From b71ead7d23475d6026f0c168c7859a59cece261e Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Fri, 11 Sep 2026 23:26:37 +0100 Subject: [PATCH 025/100] docs/TODO/206 lands: the manual and the briefing teach the fight The briefing's fight page and the manual's Trouble section now teach the buttons: FIRE LASER, TARGETS, ARM A MISSILE, E.C.M. and RUN FOR IT. They say that a missile costs money, that the bought combat computer does the rest, and that a steering key takes the ship back. The briefing's journey test names the buttons in place of the missile keys. 206 lands. The probes ran: ambush-probe survived 40 of 40 episodes, and the other three report as before. None of them flies the Game's own seat, so the measure of this plan is test/aim.test.ts and Chris's verdict. 5,804 assertions, from 5,733. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- docs/TODO/QUEUE.json | 1 - docs/TODO/README.md | 15 ++++++++--- ...ter-flies-the-fight-and-the-pilot-fires.md | 26 +++++++++++++++++++ docs/TODO/completed/README.md | 1 + manual.html | 21 +++++++++++++++ src/ui/briefing.ts | 24 ++++++++++------- test/key-help.test.ts | 8 +++--- 7 files changed, 79 insertions(+), 17 deletions(-) rename docs/TODO/{ => completed}/206-the-computer-flies-the-fight-and-the-pilot-fires.md (91%) diff --git a/docs/TODO/QUEUE.json b/docs/TODO/QUEUE.json index d82fa14b..f1dae90c 100644 --- a/docs/TODO/QUEUE.json +++ b/docs/TODO/QUEUE.json @@ -1,7 +1,6 @@ { "version": 1, "items": [ - 206, 207, 208 ] diff --git a/docs/TODO/README.md b/docs/TODO/README.md index a96af9e3..ba251314 100644 --- a/docs/TODO/README.md +++ b/docs/TODO/README.md @@ -13,9 +13,8 @@ active context: ## Execution queue -1. [206](206-the-computer-flies-the-fight-and-the-pilot-fires.md) — the computer flies the fight, and the pilot fires. -2. [207](207-the-pilot-takes-the-ship-into-the-slot-by-hand.md) — the pilot takes the ship into the slot by hand. -3. [208](208-every-kind-of-mission-has-a-way-to-fly-it.md) — every kind of mission has a way to fly it. +1. [207](207-the-pilot-takes-the-ship-into-the-slot-by-hand.md) — the pilot takes the ship into the slot by hand. +2. [208](208-every-kind-of-mission-has-a-way-to-fly-it.md) — every kind of mission has a way to fly it. **205 TO 208 CAME FROM CHRIS ON 2026-09-11, the day 204 landed.** He flew the touch controls of 204 on a phone, and he could not fly the ship. He @@ -25,7 +24,7 @@ pilot fires the laser, the missiles and the E.C.M. The dock stays a challenge. The missions become part of the flight. 205 also takes out the touch controls of 204. He played four docking concepts the same day, and he picked Match the spin for 207. The plans are written, and the work waits -on his word. **205 landed the same day**, and it is below. +on his word. **205 and 206 landed the same day**, and both are below. **204 CAME FROM CHRIS ON 2026-09-10.** The docked screens and the cockpit fit a phone, and nothing on the flight screen takes a touch. The brainstorm set @@ -297,6 +296,14 @@ it: *"display is good"*. **#23** closed with 134, as #22 did with 127, #18 with ## What landed on 2026-09-11 +**206 — the computer flies the fight, and the pilot fires.** When a ship +attacks, the computer lines you up, and the shooting stays yours. The buttons +are FIRE LASER, ARM A MISSILE, E.C.M., and TARGETS to choose what to fight. The target list +says what the law protects before you shoot it. The bought combat computer +does the rest of the fight, but never spends a missile. RUN FOR IT, the bribe +and the cargo dump are buttons now. Mining is a fight with a rock, and +COLLECT EVERYTHING scoops what is adrift. 5,804 assertions, from 5,733. + **205 — the pilot picks where the ship goes, and the ship flies itself.** The LAUNCH row asks where to go, and a ship with nowhere to go stays on the pad. In flight, buttons over the view show where the ship can go: the diff --git a/docs/TODO/206-the-computer-flies-the-fight-and-the-pilot-fires.md b/docs/TODO/completed/206-the-computer-flies-the-fight-and-the-pilot-fires.md similarity index 91% rename from docs/TODO/206-the-computer-flies-the-fight-and-the-pilot-fires.md rename to docs/TODO/completed/206-the-computer-flies-the-fight-and-the-pilot-fires.md index a9ced1ac..4cd49c48 100644 --- a/docs/TODO/206-the-computer-flies-the-fight-and-the-pilot-fires.md +++ b/docs/TODO/completed/206-the-computer-flies-the-fight-and-the-pilot-fires.md @@ -290,3 +290,29 @@ Evidence: - **Four older constants at 60 took their own rule IDs**, as the constants gate asks. - **The suite has 5,804 assertions,** from 5,791. + +### M7, which the plan did not have: the words for a player + +- **206 changes how a fight reads, so the manual and the briefing say so.** + The briefing's fight page and the manual's Trouble section now teach the + buttons: FIRE LASER, TARGETS, ARM A MISSILE, E.C.M. and RUN FOR IT. They + also say that a missile costs money, and that a steering key takes the ship + back. +- **The briefing's own test pinned the missile keys.** The first journey now + names the buttons instead, as 205 M6 did for the trip. + +## Outcome + +206 landed on 2026-09-11. In a fight the computer lines every pilot's ship up +on the target, and the pilot fires. The target list says what is out there, +what it is, and what the law says about shooting it. A pick sends the computer +after one ship. The bought combat computer fires the laser and the E.C.M. as +well, and never a missile, because a missile costs money. The ways out are +buttons: run, pay the police, dump cargo. Mining is the same fight with a +rock, and COLLECT EVERYTHING takes the cargo aboard. + +The probes ran after the work: `ambush-probe` survived 40 of 40 episodes, +`aim-probe`, `survivability` and `defence-probe` report as before. None of the +four flies the Game's own seat, so none can measure this plan. The measure is +`test/aim.test.ts` and Chris's verdict on whether a fight is fun. The suite +has 5,804 assertions, from 5,733. diff --git a/docs/TODO/completed/README.md b/docs/TODO/completed/README.md index 547490a3..30a0ce72 100644 --- a/docs/TODO/completed/README.md +++ b/docs/TODO/completed/README.md @@ -215,3 +215,4 @@ Supporting records: [Elite-A alignment plan](ELITE-A-COMBAT-PLAN.md), - [x] 202 — [The station menu takes a tap or the cursor](202-the-station-menu-takes-a-tap-or-the-cursor.md) — Chris, 2026-09-10. ⇧R opened the missions when the game missed the Shift keydown. **M1** makes a real key press carry the event's own modifier. **M2** makes every station command a row on a virtual code, with no letter and no shift, nineteen rows in two columns. **M3** and **M4** take the letters out of the briefing, the boot plate, the README and the manual. Every flight key stays. 5,576 assertions. - [x] 203 — [A mission tells the player where to go](203-a-mission-tells-the-player-where-to-go.md) — Chris's playtest, 2026-09-10. The game never sent the machine an arrival or a day, so one job could not complete and no deadline passed. **M1** sends both. **M2** spawns a target inside the scanner, keeps a scan's subject, and puts pirates on the lane. **M3** marks the target on the scanner and the screen. **M4** makes the console speak at every change, in full sentences. **M5** counts a scan while the subject is in view, with no missile. **M6** says how a job plays in the manual. 5,619 assertions. - [x] 205 — [The pilot picks where the ship goes, and the ship flies itself](205-the-pilot-picks-where-the-ship-goes-and-the-ship-flies-itself.md) — Chris, 2026-09-11. **M1** takes out the touch controls of 204. **M2** is the course list, **M3** the pilot that flies it, **M4** the launch list and **M5** the buttons in flight. **M6** is the manual and the briefing, and **M7** is FAST FORWARD. 5,733 assertions. +- [x] 206 — [The computer flies the fight, and the pilot fires](206-the-computer-flies-the-fight-and-the-pilot-fires.md) — Chris, 2026-09-11. **M1** is the target list and the pick. **M2 and M4** give every pilot the aim, and the bought computer the trigger. **M3** is the pilot's buttons. **M5** is the run and the offers. **M6** is mining and collecting. 5,804 assertions. diff --git a/manual.html b/manual.html index 6e8488be..79b02d7d 100644 --- a/manual.html +++ b/manual.html @@ -286,6 +286,27 @@

    Docking

    Trouble

    +

    + When somebody opens fire, the computer takes the stick and lines the + ship up on them. The shooting stays yours. FIRE LASER at the + bottom right fires while you hold it, ARM A MISSILE arms one + and then fires it, and E.C.M. answers a missile coming at + you. TARGETS lists every ship, rock and derelict on the + scanner, and a row sends the computer after that one. It also says + when the law protects a ship, before you shoot it. +

    +

    + A missile costs money, so the computer never fires one for you. Buy + a combat computer and it will do the rest of the fight while + you watch. Press a steering key at any time and you have the ship + back. +

    +

    + If the fight is going badly, the buttons on the left offer the ways + out: RUN FOR IT, which says whether you are faster, and the + offers that fit the moment, such as paying a patrol off or throwing + cargo to a pirate. +

    Pirates
    They want your cargo, and they size you up before committing. A fat diff --git a/src/ui/briefing.ts b/src/ui/briefing.ts index 284d72ba..9102569f 100644 --- a/src/ui/briefing.ts +++ b/src/ui/briefing.ts @@ -111,15 +111,21 @@ export const BRIEFING: { title: string; body: string }[] = [ }, { title: 'A FIGHT', - body: `Sooner or later somebody opens fire. Your laser shoots straight - ahead: put them in the crosshair and hold the trigger — the stick and - trigger depend on your keyboard layout, and ${KEY.help} shows - yours. Lasers overheat; short bursts.

    - ${KEY.armMissile} arms a missile, which locks when a target - crosses your sights; ${KEY.fireMissile} fires it.

    - Kills raise your rating toward Elite. If the fight goes badly, run - — and if the worst happens, death puts you back at the last station you - docked at, without the flight you were on.`, + body: `Sooner or later somebody opens fire. The computer takes the stick + and lines the ship up. The shooting is yours: hold + FIRE LASER at the bottom right, and keep the bursts short, + because lasers overheat. TARGETS above it lists what is out + there, and a row sends the computer after that one.

    + ARM A MISSILE arms one, and it locks when a ship crosses your + sights. Press it again to fire. A missile costs money, so the computer + never spends one for you. E.C.M. destroys a missile coming at + you.

    + Kills raise your rating toward Elite. If the fight goes badly, + RUN FOR IT is on the left, with the offers that fit: pay a patrol + off, or throw cargo to a pirate. Press a steering key at any time and + you fly the ship yourself. If the worst happens, + death puts you back at the last station you docked at, without the + flight you were on.`, }, { title: 'DOCKING', diff --git a/test/key-help.test.ts b/test/key-help.test.ts index 2b9319fe..07deeca9 100644 --- a/test/key-help.test.ts +++ b/test/key-help.test.ts @@ -298,8 +298,7 @@ console.log('\nthe briefing surfaces the whole first journey'); // words, and the two keys that used to carry the trip leave this list. const journey: [ControlMode, Command][] = [ ['docked', 'toggleHelp'], - ['flight', 'armMissile'], ['flight', 'launchMissile'], - ['flight', 'fireEcm'], ['flight', 'jettison1'], + ['flight', 'jettison1'], ['flight', 'toggleDockingComputer'], ]; const text = BRIEFING.map((p) => `${p.title} ${p.body}`).join(' '); @@ -314,7 +313,10 @@ console.log('\nthe briefing surfaces the whole first journey'); unnamed.length === 0, unnamed.join(', ')); check(`every journey command is quoted with its bound key (${journey.length})`, unquoted.length === 0, unquoted.join(', ')); - const buttons = ['JUMP TO', 'FLY TO THE STATION', 'FAST FORWARD']; + // The fight is buttons too since docs/TODO/206, so the briefing names them + // rather than the missile keys and the E.C.M. key. + const buttons = ['JUMP TO', 'FLY TO THE STATION', 'FAST FORWARD', + 'FIRE LASER', 'TARGETS', 'ARM A MISSILE', 'E.C.M.', 'RUN FOR IT']; const untaught = buttons.filter((b) => !text.includes(`${b}`)); check(`...and every button of the trip is named (${buttons.length})`, untaught.length === 0, untaught.join(', ')); From 956a545a17130fba12682225fec62a4d8397405c Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Fri, 11 Sep 2026 23:35:16 +0100 Subject: [PATCH 026/100] docs/TODO/207 M1 and M3: the pilot flies the last stretch, and the slot checks the speed The station course hands the ship over at the docking computer's range when one is fitted, and that computer flies the slot as before. With none fitted, the course flies on to 1,500 units and hands the ship to the pilot. The computer then holds the ship on the slot axis, and the pilot matches the station's spin and the speed. The stretch ends if the ship leaves the approach. The slot now refuses a ship that arrives above SLOT_SPEED_LIMIT, which is 120. dockingOutcome answers roll and speed together, so no caller holds half the rule, and the console says which one refused. The docking computer settles at 110, and the dock probe still docks 504 of 504 approaches with no scrape. 5,807 assertions, from 5,804. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- ...ot-takes-the-ship-into-the-slot-by-hand.md | 25 ++++++++++ src/constants/CATALOG.md | 24 +++++----- src/constants/course.ts | 14 ++++++ src/constants/docking.ts | 21 +++++++++ src/constants/exercise.ts | 4 +- src/constants/separation.ts | 4 +- src/constants/spawn-placement.ts | 4 +- src/constants/station.ts | 6 ++- src/game/course-pilot.ts | 8 +++- src/game/docking.ts | 15 ++++-- src/game/flight-instruments.ts | 44 +++++++++++++++++- src/game/flight.ts | 1 + src/game/session.ts | 7 +++ src/game/state.ts | 1 + src/game/world-step.ts | 46 ++++++++++++++++--- test/arena.test.ts | 4 +- test/constants.test.ts | 6 ++- test/course-pilot.test.ts | 26 ++++++++++- test/docking.test.ts | 2 +- test/hud-model.test.ts | 2 +- test/world.test.ts | 2 +- 21 files changed, 230 insertions(+), 36 deletions(-) diff --git a/docs/TODO/207-the-pilot-takes-the-ship-into-the-slot-by-hand.md b/docs/TODO/207-the-pilot-takes-the-ship-into-the-slot-by-hand.md index 3cb12237..6ebd954f 100644 --- a/docs/TODO/207-the-pilot-takes-the-ship-into-the-slot-by-hand.md +++ b/docs/TODO/207-the-pilot-takes-the-ship-into-the-slot-by-hand.md @@ -148,3 +148,28 @@ Evidence: - A test drives the control of M2 headlessly into a clean dock, and into a bounce for each cause. - Chris docks on his phone. + +## What the milestones found + +### M1 and M3 + +- **The hand-over depends on the ship's kit.** With a docking computer fitted, + the course hands over at that computer's own range, 3,500 units, and it + flies the slot as it does today. Without one, the course flies on to 1,500 + units and hands the ship to the pilot. +- **The pilot's stretch is the docking computer's plan with two sticks given + back.** The computer holds the ship on the slot axis, which is the pitch. + The pilot owns the roll and the throttle. So the ship follows the same curve + to the letterbox, and the last of the manoeuvre is the pilot's. +- **The stretch ends where it began.** A ship outside the docking computer's + range is off the approach. The stretch then ends, and the course list offers + the station again. +- **The slot now checks the speed, and it is one answer.** `dockingOutcome` + takes the speed and returns `tooFast`, beside `slotMiss` and `hull`. A + caller cannot hold half of the rule. The console says which of the three it + was. +- **The docking computer keeps 10 units a second of room.** Its approach + settles at 110 against the limit of 120. The dock probe docked 504 of 504 + approaches with no scrape after the change. +- **Two course tests pinned the free dock of the 205 stopgap.** They fit a + docking computer now, and a new block flies the hand-over to the pilot. diff --git a/src/constants/CATALOG.md b/src/constants/CATALOG.md index 76b002d9..484a427a 100644 --- a/src/constants/CATALOG.md +++ b/src/constants/CATALOG.md @@ -2,7 +2,7 @@ -437 exported constants. Regenerate with `npm run generate:constants`; +439 exported constants. Regenerate with `npm run generate:constants`; search names, meanings and values with `npm run constants:find -- ""`. | Domain | Symbol | Literal / expression | Purpose | Rule ID | Source | @@ -127,6 +127,7 @@ search names, meanings and values with `npm run constants:find -- ""`. | course | RUN_CLOSE_MARGIN | 50 | Below this lead in top speed, in world units a second, the run row says the ship is only a little faster (docs/TODO/206 M5). | course.runCloseMargin | [course.ts:159](./course.ts#L159) | | course | COURSE_RUN_REACH | 50_000 | How far ahead the run course aims, in world units, on the line away from the hostile ships (docs/TODO/206 M5). | course.runReach | [course.ts:169](./course.ts#L169) | | course | COURSE_COLLECT_SPEED | 60 | How fast the collect course flies onto a canister, in world units a second (docs/TODO/206 M6). | course.collectSpeed | [course.ts:183](./course.ts#L183) | +| course | COURSE_DOCK_HANDOVER | 1500 | How far from the station the station course hands the ship to the pilot, in world units (docs/TODO/207 M1). | course.dockHandover | [course.ts:197](./course.ts#L197) | | docking | GATE_HALF_WIDTHS | 5 | How far out the approach gate sits, in multiples of the station half-width. | docking.gateHalfWidths | [docking.ts:25](./docking.ts#L25) | | docking | TURN_IN | Math.PI / 4 | How far round from the slot axis an approach turns in, in radians. | | [docking.ts:49](./docking.ts#L49) | | docking | RUN_IN_WIDTHS | GATE_HALF_WIDTHS * 0.6 | Where the approach stops the curve and flies straight, in station half-widths. | | [docking.ts:87](./docking.ts#L87) | @@ -137,6 +138,7 @@ search names, meanings and values with `npm run constants:find -- ""`. | docking | SLOT_HALF_ALONG | 62 | | | [docking.ts:128](./docking.ts#L128) | | docking | SLOT_DEPTH | 60 | How far into the -Z face puts a ship in the channel, in world units. * | docking.slotDepth | [docking.ts:133](./docking.ts#L133) | | docking | ROLL_TOLERANCE | 0.65 | The wings against the slot's long axis, in radians: how badly you may be rolled and still fit through the letterbox. | | [docking.ts:144](./docking.ts#L144) | +| docking | SLOT_SPEED_LIMIT | 120 | How fast a ship may be going when it reaches the slot, in world units a second (docs/TODO/207 M3). | docking.slotSpeedLimit | [docking.ts:165](./docking.ts#L165) | | docking-computer | DOCK_COMPUTER_RANGE | 3500 | How close to the station the docking computer will take the job, in world units. | | [docking-computer.ts:46](./docking-computer.ts#L46) | | docking-computer | DC_SLOT_MARGIN | 0.30 | How much of the slot's roll tolerance the TURN may spend, as a fraction. | docking.slotMargin | [docking-computer.ts:97](./docking-computer.ts#L97) | | docking-computer | DC_TURN_FADE_ANGLE | 0.10 | The off-nose angle, in radians, over which the TURN's claim on the roll axis ramps in. | docking.turnFadeAngle | [docking-computer.ts:151](./docking-computer.ts#L151) | @@ -162,8 +164,8 @@ search names, meanings and values with `npm run constants:find -- ""`. | exercise | AMBUSH_CONE_DEG | 30 | An ambush spreads wide behind you: 16 to 43 degrees off your tail. | exercise.ambushCone | [exercise.ts:71](./exercise.ts#L71) | | exercise | IN_VIEW_DEG | 20 | How far off the nose still counts as "the pilot can see it". | exercise.inViewDeg | [exercise.ts:82](./exercise.ts#L82) | | exercise | ENTRY_THROTTLE | 0.25 | Where the exercise starts you, as a fraction of the ship's top speed. | | [exercise.ts:85](./exercise.ts#L85) | -| exercise | SCENARIO_TIMEOUT | 120 | Seconds a scenario exercise may run before it times out. | | [exercise.ts:88](./exercise.ts#L88) | -| exercise | NO_AMBIENT_TRAFFIC | 1e9 | How far out the encounter timers are pushed while an exercise runs. | | [exercise.ts:98](./exercise.ts#L98) | +| exercise | SCENARIO_TIMEOUT | 120 | Seconds a scenario exercise may run before it times out. * | exercise.scenarioTimeout | [exercise.ts:90](./exercise.ts#L90) | +| exercise | NO_AMBIENT_TRAFFIC | 1e9 | How far out the encounter timers are pushed while an exercise runs. | | [exercise.ts:100](./exercise.ts#L100) | | extend-arc | EXTEND_ARC_ANGLE | (60 * Math.PI) / 180 | The angle that the run-out holds off the OUTWARD radial, at its tightest. | | [extend-arc.ts:13](./extend-arc.ts#L13) | | extend-arc | CLEAR_RANGE | 340 | How far out the ship gets before it starts to curve at all. | | [extend-arc.ts:22](./extend-arc.ts#L22) | | hermit-market | HERMIT_ORE | new Set(['Minerals', 'Gold', 'Platinum', 'Gem-Stones']) | What a hermit sits on: whatever they dug up. | | [hermit-market.ts:16](./hermit-market.ts#L16) | @@ -336,7 +338,7 @@ search names, meanings and values with `npm run constants:find -- ""`. | saves | MAX_SAVE_NAME | 16 | The longest name a player may type. 16, because that is what the list column holds without a wrap, and what keeps an id short. | saves.maxSaveName | [saves.ts:68](./saves.ts#L68) | | scoop | SCOOP_RANGE | 45 | How close the commander must fly to scoop a drifting object, in world units. | | [scoop.ts:17](./scoop.ts#L17) | | separation | SEPARATION_RANGE | 200 | How near a wingman has to be before a ship cares, in world units. | separation.range | [separation.ts:11](./separation.ts#L11) | -| separation | SEPARATION_PUSH | 120 | How hard a ship that closes bends its aim to avoid a mate, in units of offset. | | [separation.ts:17](./separation.ts#L17) | +| separation | SEPARATION_PUSH | 120 | How hard a ship that closes bends its aim to avoid a mate, in units of offset. | separation.push | [separation.ts:19](./separation.ts#L19) | | shop | FUEL_PRICE | 0.4 | What a refuel costs, in tenths of a credit per tenth of a LY. | shop.fuelPrice | [shop.ts:19](./shop.ts#L19) | | shop | PULSE_LASER_PRICE | 4000 | What a pulse laser costs, wherever it is mounted. | | [shop.ts:27](./shop.ts#L27) | | shop | BEAM_LASER_PRICE | 10000 | The beam laser's price. | | [shop.ts:34](./shop.ts#L34) | @@ -366,17 +368,17 @@ search names, meanings and values with `npm run constants:find -- ""`. | spawn-placement | STATION_DEFENCE_MIN | 1 | The fewest Vipers the station launches after you shoot at something you should not. | spawn.stationDefenceMin | [spawn-placement.ts:260](./spawn-placement.ts#L260) | | spawn-placement | STATION_DEFENCE_SPAN | 2 | ...and the width of that draw: one or two of them. | spawn.stationDefenceSpan | [spawn-placement.ts:271](./spawn-placement.ts#L271) | | spawn-placement | STATION_DEFENCE_STANDOFF | 500 | How far out of the slot the first one launches. | | [spawn-placement.ts:277](./spawn-placement.ts#L277) | -| spawn-placement | STATION_DEFENCE_STACK | 120 | ...and how much further out each one after it starts, so a pair does not arrive inside each other. | | [spawn-placement.ts:283](./spawn-placement.ts#L283) | -| spawn-placement | STATION_DEFENCE_JITTER | 80 | ...and the random nudge on each, so a second launch does not look like the first. | | [spawn-placement.ts:293](./spawn-placement.ts#L293) | -| spawn-placement | TRADER_ARRIVED | 900 | How near the station an arriving trader has to be to start trading. | spawn.traderArrived | [spawn-placement.ts:308](./spawn-placement.ts#L308) | -| spawn-placement | TRADER_JUMP_OUT | 2500 | How near its waypoint a departing trader has to be to jump out. | spawn.traderJumpOut | [spawn-placement.ts:324](./spawn-placement.ts#L324) | -| spawn-placement | SPAWN_PLANET_ALTITUDE | 1000 | The lowest a ship may appear above the planet's surface, measured to the ship's centre, in world units. | spawn.planetAltitude | [spawn-placement.ts:343](./spawn-placement.ts#L343) | +| spawn-placement | STATION_DEFENCE_STACK | 120 | ...and how much further out each one after it starts, so a pair does not arrive inside each other. | spawn.stationDefenceStack | [spawn-placement.ts:285](./spawn-placement.ts#L285) | +| spawn-placement | STATION_DEFENCE_JITTER | 80 | ...and the random nudge on each, so a second launch does not look like the first. | | [spawn-placement.ts:295](./spawn-placement.ts#L295) | +| spawn-placement | TRADER_ARRIVED | 900 | How near the station an arriving trader has to be to start trading. | spawn.traderArrived | [spawn-placement.ts:310](./spawn-placement.ts#L310) | +| spawn-placement | TRADER_JUMP_OUT | 2500 | How near its waypoint a departing trader has to be to jump out. | spawn.traderJumpOut | [spawn-placement.ts:326](./spawn-placement.ts#L326) | +| spawn-placement | SPAWN_PLANET_ALTITUDE | 1000 | The lowest a ship may appear above the planet's surface, measured to the ship's centre, in world units. | spawn.planetAltitude | [spawn-placement.ts:345](./spawn-placement.ts#L345) | | station | STATION_SPIN | 0.26 | How fast the station spins about its slot axis, in radians a second. | | [station.ts:19](./station.ts#L19) | | station | DODO_TECH_LEVEL | 10 | The tech level at which a system's station is the dodecahedral Dodo rather than the Coriolis, in SHOWN one-based units. | | [station.ts:32](./station.ts#L32) | | station | BOUNCE_STANDOFF | 420 | Where a fluffed docking bounces you to. | | [station.ts:48](./station.ts#L48) | | station | LAUNCH_STANDOFF | 450 | How far off the slot you sit when the bay spits you out, in world units. | | [station.ts:51](./station.ts#L51) | -| station | LAUNCH_SPEED | 120 | ...and how fast, in world units a second — a firm push, not a cruise. | | [station.ts:54](./station.ts#L54) | -| station | DOCKED_BACKDROP_DISTANCE | 900 | Where the docked menu parks your ship, along the slot normal, in world units. | station.backdropDistance | [station.ts:63](./station.ts#L63) | +| station | LAUNCH_SPEED | 120 | ...and how fast, in world units a second — a firm push, not a cruise. | station.launchSpeed | [station.ts:58](./station.ts#L58) | +| station | DOCKED_BACKDROP_DISTANCE | 900 | Where the docked menu parks your ship, along the slot normal, in world units. | station.backdropDistance | [station.ts:67](./station.ts#L67) | | sun | SUN_HEAT_START | 110_000 | Closer than this, and the cabin starts to warm. | | [sun.ts:22](./sun.ts#L22) | | sun | SUN_SCOOP_RANGE | 80_000 | Close enough to scoop fuel, if you have the scoops. | | [sun.ts:30](./sun.ts#L30) | | sun | SUN_HEAT_MAX | 26_000 | The bottom of the temperature ramp. | | [sun.ts:38](./sun.ts#L38) | diff --git a/src/constants/course.ts b/src/constants/course.ts index a6f28368..fbefe853 100644 --- a/src/constants/course.ts +++ b/src/constants/course.ts @@ -181,3 +181,17 @@ export const COURSE_RUN_REACH = 50_000; * @domain course */ export const COURSE_COLLECT_SPEED = 60; + +/** + * How far from the station the station course hands the ship to the pilot, + * in world units (docs/TODO/207 M1). + * + * A ship with a docking computer is handed to that computer further out, at + * `DOCK_COMPUTER_RANGE`. A pilot flies the last stretch, and 1,500 units is + * about four seconds at the speed the approach arrives with. The concepts + * page of 2026-09-11 started its trial here, and Chris picked one of them. + * + * @rule course.dockHandover + * @domain course + */ +export const COURSE_DOCK_HANDOVER = 1500; diff --git a/src/constants/docking.ts b/src/constants/docking.ts index 6cfdf67a..24f4439d 100644 --- a/src/constants/docking.ts +++ b/src/constants/docking.ts @@ -142,3 +142,24 @@ export const SLOT_DEPTH = 60; * measure again if this tolerance or the half-widths above ever move. */ export const ROLL_TOLERANCE = 0.65; + +/** + * How fast a ship may be going when it reaches the slot, in world units a + * second (docs/TODO/207 M3). + * + * The slot took any speed at all until now, and the dock was a test of the + * roll alone. A pilot flies the last stretch since 207, so the speed is the + * second half of the manoeuvre. The docking computer settles at 110 on its + * own approach (`planDocking`), so it keeps 10 units a second of room. + * + * `LAUNCH_SPEED` is also 120, and the two rules are independent. That one is + * the push a station gives a ship on the way out. + * + * It belongs here, with the rest of the slot's rules, and not with the flight + * envelopes. The slot decides what it will take, and `dockingOutcome` next + * door is the one reader. + * + * @rule docking.slotSpeedLimit + * @domain docking + */ +export const SLOT_SPEED_LIMIT = 120; diff --git a/src/constants/exercise.ts b/src/constants/exercise.ts index acef4f48..029c3807 100644 --- a/src/constants/exercise.ts +++ b/src/constants/exercise.ts @@ -84,7 +84,9 @@ export const IN_VIEW_DEG = 20; /** Where the exercise starts you, as a fraction of the ship's top speed. */ export const ENTRY_THROTTLE = 0.25; -/** Seconds a scenario exercise may run before it times out. */ +/** Seconds a scenario exercise may run before it times out. * + * @rule exercise.scenarioTimeout +*/ export const SCENARIO_TIMEOUT = 120; /** diff --git a/src/constants/separation.ts b/src/constants/separation.ts index 1e82a531..178410bb 100644 --- a/src/constants/separation.ts +++ b/src/constants/separation.ts @@ -13,5 +13,7 @@ export const SEPARATION_RANGE = 200; /** * How hard a ship that closes bends its aim to avoid a mate, in units of offset. * How close the mate is scales it. It sits a shade above `PASS_MISS_DISTANCE`. - */ + * + * @rule separation.push +*/ export const SEPARATION_PUSH = 120; diff --git a/src/constants/spawn-placement.ts b/src/constants/spawn-placement.ts index 4fcbfca4..1ea751ef 100644 --- a/src/constants/spawn-placement.ts +++ b/src/constants/spawn-placement.ts @@ -279,7 +279,9 @@ export const STATION_DEFENCE_STANDOFF = 500; /** * ...and how much further out each one after it starts, so a pair does not arrive * inside each other. It is three times a Viper's 18.75 contact radius. - */ + * + * @rule spawn.stationDefenceStack +*/ export const STATION_DEFENCE_STACK = 120; /** diff --git a/src/constants/station.ts b/src/constants/station.ts index 2daae854..087edc6f 100644 --- a/src/constants/station.ts +++ b/src/constants/station.ts @@ -50,7 +50,11 @@ export const BOUNCE_STANDOFF = 420; /** How far off the slot you sit when the bay spits you out, in world units. */ export const LAUNCH_STANDOFF = 450; -/** ...and how fast, in world units a second — a firm push, not a cruise. */ +/** + * ...and how fast, in world units a second — a firm push, not a cruise. + * + * @rule station.launchSpeed + */ export const LAUNCH_SPEED = 120; /** diff --git a/src/game/course-pilot.ts b/src/game/course-pilot.ts index 62bb8e8c..ee61c63a 100644 --- a/src/game/course-pilot.ts +++ b/src/game/course-pilot.ts @@ -37,7 +37,6 @@ import { rampFlightRate, type FlightDemand } from '../player.ts'; import { bankToTurn, freshSteerMemory, type SteerMemory } from './pitch-roll-steer.ts'; import type { CourseKind } from './courses.ts'; import { PLAYER_FLIGHT } from '../constants/player-flight.ts'; -import { DOCK_COMPUTER_RANGE } from '../constants/docking-computer.ts'; import { COURSE_ARRIVE_BRAKE, COURSE_ARRIVE_TOLERANCE, COURSE_DERELICT_STANDOFF, COURSE_HERMIT_SPEED, COURSE_HERMIT_STANDOFF, COURSE_PLANET_CLEARANCE, @@ -71,6 +70,11 @@ export interface CourseView { readonly loot: readonly THREE.Vector3[]; /** the docking computer already has the ship */ readonly dcEngaged: boolean; + /** + * How near the station the station course hands the ship over. A fitted + * docking computer takes the job from further out than a pilot does. + */ + readonly handOverRange: number; } /** What the course pilot asks for this frame. */ @@ -166,7 +170,7 @@ export class CoursePilot { */ private toStation(v: CourseView, dt: number): CourseStep { if (v.dcEngaged) return IDLE; - if (v.position.distanceTo(v.stationPos) <= DOCK_COMPUTER_RANGE) { + if (v.position.distanceTo(v.stationPos) <= v.handOverRange) { return { demand: null, torus: false, handOver: true, done: false }; } const aim = clearOfPlanet(v.position, v.stationPos, v.planetPos, v.planetRadius, this.aim); diff --git a/src/game/docking.ts b/src/game/docking.ts index ddb30aa3..43a01760 100644 --- a/src/game/docking.ts +++ b/src/game/docking.ts @@ -32,7 +32,7 @@ import * as THREE from 'three'; import { GATE_HALF_WIDTHS, LINED_UP_LATERAL, HULL_BOX_MARGIN, - SLOT_HALF_ACROSS, SLOT_HALF_ALONG, SLOT_DEPTH, ROLL_TOLERANCE, + SLOT_HALF_ACROSS, SLOT_HALF_ALONG, SLOT_DEPTH, ROLL_TOLERANCE, SLOT_SPEED_LIMIT, } from '../constants/docking.ts'; import { slotNormal } from '../world/slot.ts'; import { dockPath, makeDockPath } from './dock-path.ts'; @@ -229,12 +229,19 @@ export type DockingOutcome = | 'docked' /** in the channel but rolled wrong */ | 'slotMiss' + /** in the channel, lined up, and going too fast to be taken (docs/TODO/207) */ + | 'tooFast' /** flew into the hull */ | 'hull'; /** - * Where a ship is relative to the slot. + * Where a ship is relative to the slot, and whether the slot will take it. * + * The slot asks two things of a ship in the channel: the roll, and the speed + * (docs/TODO/207 M3). It is one answer, so the caller cannot hold half of the + * rule. + * + * @param speed how fast the ship is going, against `SLOT_SPEED_LIMIT` * @param scratch a Vector3 and a Quaternion to work in; this runs every frame. */ export function dockingOutcome( @@ -242,6 +249,7 @@ export function dockingOutcome( quat: THREE.Quaternion, station: THREE.Object3D, dockZ: number, + speed: number, scratch: { v: THREE.Vector3; q: THREE.Quaternion; r: THREE.Vector3 }, ): DockingOutcome { const box = dockZ + HULL_BOX_MARGIN; @@ -256,5 +264,6 @@ export function dockingOutcome( scratch.q.copy(station.quaternion).invert().multiply(quat); const right = scratch.r.set(1, 0, 0).applyQuaternion(scratch.q); - return rollAlignedWithSlot(right.x, right.y) ? 'docked' : 'slotMiss'; + if (!rollAlignedWithSlot(right.x, right.y)) return 'slotMiss'; + return speed > SLOT_SPEED_LIMIT ? 'tooFast' : 'docked'; } diff --git a/src/game/flight-instruments.ts b/src/game/flight-instruments.ts index d3a22d69..3a0d5e46 100644 --- a/src/game/flight-instruments.ts +++ b/src/game/flight-instruments.ts @@ -27,6 +27,8 @@ import { MAX_FUEL } from '../constants/commander.ts'; import { hostilesOnScanner } from './hostility.ts'; import { pickTarget, pickedTarget } from './targets.ts'; import { SCANNER_RANGE } from '../constants/console.ts'; +import { DOCK_COMPUTER_RANGE } from '../constants/docking-computer.ts'; +import { COURSE_DOCK_HANDOVER } from '../constants/course.ts'; /** * What the console says when a course finishes its work. The hermit course @@ -174,13 +176,53 @@ export class Instruments { threats: hostilesOnScanner(w.npcs, p.position, this.state.commander.legalStatus, p.position.distanceTo(w.station.position)).map((n) => n.object.position), dcEngaged: s.dcEngaged, + handOverRange: this.state.commander.equipment.dockingComputer + ? DOCK_COMPUTER_RANGE : COURSE_DOCK_HANDOVER, }, dt); - if (step.handOver) this.applyAutopilot(this.autopilot.handOverToDock()); + if (step.handOver) this.handOver(); if (step.torus !== s.torusEngaged && (!step.torus || !this.massLocked())) this.toggleTorus(); if (step.done) this.endCourse(s.course); return step.demand; } + /** + * The station course reaches the hand-over, and the ship changes hands + * (docs/TODO/207 M1). + * + * With a docking computer fitted, that computer flies the slot, as it does + * today. Without one, the pilot flies the last stretch. The computer holds + * the ship on the slot axis. The pilot matches the station's spin, and the + * speed. + */ + private handOver(): void { + const s = this.state.session; + if (this.state.commander.equipment.dockingComputer) { + this.applyAutopilot(this.autopilot.handOverToDock()); + return; + } + s.dockTrial = true; + s.course = null; + this.coursePilot.reset(); + this.host.showMessage('YOU HAVE THE SLOT — MATCH ITS SPIN AND GO IN SLOWLY', 5); + } + + /** + * The pilot's stretch ends when the ship leaves the docking computer's + * range, which is the width of the whole approach. The course list then + * offers the station again. + * + * @internal — driven by src/game/flight.ts, once per fixed step. + */ + watchDockTrial(): void { + const s = this.state.session; + if (!s.dockTrial) return; + const out = this.state.player.position + .distanceTo(this.state.world.station.position) > DOCK_COMPUTER_RANGE; + if (!out) return; + s.dockTrial = false; + this.host.showMessage('THE STATION IS BEHIND YOU', 3); + } + /** * The mining course keeps a rock picked as the target, so the computer aims * at it and the pilot fires. diff --git a/src/game/flight.ts b/src/game/flight.ts index 70f9f659..19be1b7e 100644 --- a/src/game/flight.ts +++ b/src/game/flight.ts @@ -322,6 +322,7 @@ export class Flight { if (this.input.mouseFlight) this.input.decayMouse(dt); // A fight gives every pilot the computer's aim (docs/TODO/206 M2). this.instruments.autoEngage(); + this.instruments.watchDockTrial(); // A picked course flies when no co-pilot does (docs/TODO/205 M3). The // trigger stays the pilot's, as it does under the co-pilot. if (!this.state.session.ccEngaged) { diff --git a/src/game/session.ts b/src/game/session.ts index 459e7a3c..354256d2 100644 --- a/src/game/session.ts +++ b/src/game/session.ts @@ -104,6 +104,12 @@ export interface SessionState { * decides who flies. */ handFlown: boolean; + /** + * The pilot flies the last of the approach (docs/TODO/207). The computer + * holds the ship on the slot axis, and the pilot matches the station's spin + * and the speed. It is saved, because it decides who flies. + */ + dockTrial: boolean; } /** @@ -114,6 +120,7 @@ export function endVisit(state: SessionState): void { state.course = null; state.coursesDone = []; state.handFlown = false; + state.dockTrial = false; } /** Put a message in canonical state; the HUD only paints these fields. */ diff --git a/src/game/state.ts b/src/game/state.ts index 9afea6ec..39e9f45f 100644 --- a/src/game/state.ts +++ b/src/game/state.ts @@ -159,6 +159,7 @@ export function freshSession(): SessionState { course: null, coursesDone: [], handFlown: false, + dockTrial: false, }; } diff --git a/src/game/world-step.ts b/src/game/world-step.ts index 189f423e..a18ab0d1 100644 --- a/src/game/world-step.ts +++ b/src/game/world-step.ts @@ -50,7 +50,7 @@ import { PIRATE_WAVE_RANGE, PIRATE_WAVE_RANGE_SPAN, THARGON_DEPLOY_RANGE, TRADER_ARRIVAL_RANGE, } from '../constants/spawn-placement.ts'; -import { planDocking, dockingOutcome } from './docking.ts'; +import { planDocking, dockingOutcome, type DockingOutcome } from './docking.ts'; import { dockingSticks } from './docking-sticks.ts'; import { NPC_HULL_BOX_MARGIN } from '../constants/docking.ts'; import { BOUNCE_STANDOFF } from '../constants/station.ts'; @@ -230,6 +230,13 @@ export interface PilotInput { * Holds the state, the missiles and the host — and its own scratch vectors, so * stepping at 60Hz allocates nothing. */ +/** What the console says about a dock that did not take (docs/TODO/207 M3). */ +const SCRAPE_SAID: Partial> = { + slotMiss: 'DOCKING FAILURE — MATCH THE SLOT ROTATION', + tooFast: 'TOO FAST FOR THE SLOT — SLOW DOWN AND TRY AGAIN', + hull: 'COLLISION', +}; + export class WorldStep { private readonly state: GameState; private readonly ordnance: Ordnance; @@ -298,7 +305,8 @@ export class WorldStep { // used to write the quaternion after the fact. So the demand is decided // before the ship flies, rather than applied on top of it. Where it hands // the ship back mid-frame, the pilot's own demand stands, as before. - const dc = session.dcEngaged ? this.dockingComputerStep(dt, pilot, out) : null; + const dc = session.dcEngaged ? this.dockingComputerStep(dt, pilot, out) + : session.dockTrial ? this.dockTrialStep(dt, pilot) : null; player.update(dt, dc ?? pilot.demand); // torus drive @@ -372,6 +380,31 @@ export class WorldStep { }; } + /** + * One frame of the pilot's own stretch of the approach (docs/TODO/207). + * + * The computer holds the ship on the slot axis, which is the pitch. The + * pilot owns the roll and the throttle. The slot asks for those two things: + * the station's spin, and a speed it will take. + * + * It is the docking computer's own plan, with two of its three sticks given + * back. So the ship follows the same curve to the letterbox, and the last + * of the manoeuvre is the pilot's. + */ + private dockTrialStep(dt: number, pilot: PilotInput): FlightDemand { + const { player, world } = this.state; + const plan = planDocking(player.position, world.station, world.stationDockZ, + player.maxSpeed, this.state.dockPlan); + const sticks = dockingSticks(player.quaternion, plan, player.rollRate); + return { + pitchRate: rampFlightRate( + player.pitchRate, sticks.pitch * PLAYER_FLIGHT.maxPitch, sticks.pitch !== 0, dt), + rollRate: pilot.demand.rollRate, + throttle: pilot.demand.throttle, + fire: pilot.demand.fire, + }; + } + /** Everyone else: decisions, despawns, collisions, and who else turns up. */ private stepNpcs(dt: number, out: StepEvent[]): void { const s = this.state; @@ -815,14 +848,14 @@ export class WorldStep { } /** - * Are we down, bounced, or clear? The geometry is docking.ts's; what it - * costs is ours. + * Are we down, bounced, or clear? The rule is docking.ts's; what it costs is + * ours. */ private checkStation(out: StepEvent[]): void { const { player, world } = this.state; const station = world.station; const outcome = dockingOutcome( - player.position, player.quaternion, station, world.stationDockZ, + player.position, player.quaternion, station, world.stationDockZ, player.speed, { v: this.tmp, q: this.tmpQ, r: this.tmp2 }); if (outcome === 'clear') return; if (outcome === 'docked') { @@ -835,8 +868,7 @@ export class WorldStep { player.speed = 0; this.host.applyPlayerDamage( playerImpactDamage(IMPACT.stationScrape), station.position, 'station'); - out.push(say( - outcome === 'slotMiss' ? 'DOCKING FAILURE — MATCH SLOT ROTATION' : 'COLLISION', 3)); + out.push(say(SCRAPE_SAID[outcome] ?? 'COLLISION', 3)); } /** While armed, lock onto whatever enters the sight. Ordnance reports; we say it. */ diff --git a/test/arena.test.ts b/test/arena.test.ts index 4953446e..d3c88db3 100644 --- a/test/arena.test.ts +++ b/test/arena.test.ts @@ -78,7 +78,7 @@ console.log('\ncombat arena'); if (massLocked(state)) locked += 1; if (dockingOutcome(centre, state.player.quaternion, world.station, - world.stationDockZ, scratch) !== 'clear') notClear += 1; + world.stationDockZ, 0, scratch) !== 'clear') notClear += 1; } } @@ -146,7 +146,7 @@ console.log('\ncombat arena'); ships.every((n) => n.object.position.distanceTo(world.station.position) > 20_000)); check('...none of them inside the docking box', ships.every((n) => dockingOutcome(n.object.position, n.object.quaternion, - world.station, world.stationDockZ, scratch) === 'clear')); + world.station, world.stationDockZ, 0, scratch) === 'clear')); // and near enough that the fight starts: `PLAYER_INTEREST_RANGE` is where // an NPC begins to care about the player at all (npc.ts update()). It was // 9,000 written out, in a file that can import the rule. diff --git a/test/constants.test.ts b/test/constants.test.ts index 0bf6612a..93d4628c 100644 --- a/test/constants.test.ts +++ b/test/constants.test.ts @@ -191,9 +191,11 @@ const OUTSIDE: readonly Group[] = [ + ' here). The conversion is done at the call site rather than by adding a' + ' second spelling of amber to the palette. Its `ZERO` scratch vector went' + ' with the docking computer\'s `lookAt` (docs/TODO/126): the autopilot builds' - + ' no orientation of its own any more, so there is nothing to look FROM', + + ' no orientation of its own any more, so there is nothing to look FROM.' + + ' `SCRAPE_SAID` is words rather than a number: what the console says' + + ' about a dock that did not take (docs/TODO/207 M3)', files: { - 'game/world-step.ts': ['WARHEAD_FLASH'], + 'game/world-step.ts': ['WARHEAD_FLASH', 'SCRAPE_SAID'], }, }, diff --git a/test/course-pilot.test.ts b/test/course-pilot.test.ts index 7bda531e..754b1b95 100644 --- a/test/course-pilot.test.ts +++ b/test/course-pilot.test.ts @@ -19,6 +19,7 @@ import { MAX_FUEL } from '../src/constants/commander.ts'; import { SPAWN_PLANET_ALTITUDE } from '../src/constants/spawn-placement.ts'; import { aboveGround } from '../src/game/spawning.ts'; import { DOCK_COMPUTER_RANGE } from '../src/constants/docking-computer.ts'; +import { COURSE_DOCK_HANDOVER } from '../src/constants/course.ts'; import { MASS_LOCK_STATION } from '../src/constants/torus.ts'; import { check, dismissBriefing, eq } from './harness.ts'; @@ -43,6 +44,7 @@ const view = (station: THREE.Vector3, over: Partial = {}): CourseVie threats: [], loot: [], dcEngaged: false, + handOverRange: DOCK_COMPUTER_RANGE, ...over, }); @@ -95,7 +97,11 @@ function arrived(seed: number): Game { } { + // A fitted docking computer flies the slot, as it does today. Without one, + // the course hands the ship to the pilot instead (docs/TODO/207 M1), and + // the block below flies that. const g = arrived(20_260_911); + g.state.commander.equipment.dockingComputer = true; const start = g.state.player.position.distanceTo(g.state.world.station.position); check('the ship starts far outside the station\'s mass lock', start > MASS_LOCK_STATION * 4, `${Math.round(start)} units`); @@ -117,13 +123,30 @@ function arrived(seed: number): Game { } }); check('the course ran the torus on the way in', torusSeen); - check('...it handed over inside the docking computer\'s range, with none fitted', + check('...it handed over inside the docking computer\'s range', handOverAt > 0 && handOverAt <= DOCK_COMPUTER_RANGE + 50, `${Math.round(handOverAt)} units`); check('...and the ship docked inside three minutes, with no hand on the stick', dockedAt > 0 && g.mode === 'docked', `mode ${g.mode}, ${dockedAt.toFixed(1)} s`); eq('...and the dock ends the visit, so no course is left', g.state.session.course, null); } +console.log('\nwith no docking computer, the course hands the slot to the pilot'); +{ + const g = arrived(20_260_935); + g.state.session.course = 'station'; + const dt = 1 / 60; + withoutSaving(() => { + for (let f = 0, at = 0; f < 240 / dt && !g.state.session.dockTrial; f++) g.step(dt, at += dt); + }); + const range = g.state.player.position.distanceTo(g.state.world.station.position); + check('the course flies the ship in and hands it over', g.state.session.dockTrial, + `${Math.round(range)} units out`); + check('...at the hand-over range', Math.abs(range - COURSE_DOCK_HANDOVER) < 200, + `${Math.round(range)} units out`); + eq('...and the course is over, because the ship is the pilot\'s now', + g.state.session.course, null); +} + console.log('\n...and a flight key takes the ship back'); { const g = arrived(20_260_912); @@ -230,6 +253,7 @@ console.log('\nthe star course'); console.log('\nthe station course goes round a planet in its way'); { const g = arrived(20_260_914); + g.state.commander.equipment.dockingComputer = true; const w = g.state.world; // Put the planet square between the ship and the station. const through = w.station.position.clone().sub(w.planetPos).normalize(); diff --git a/test/docking.test.ts b/test/docking.test.ts index bed21354..ba5f55d6 100644 --- a/test/docking.test.ts +++ b/test/docking.test.ts @@ -60,7 +60,7 @@ console.log('\ndocking thresholds'); const quarter = new THREE.Quaternion() .setFromAxisAngle(new THREE.Vector3(0, 0, 1), Math.PI / 2); const at = (x: number, y: number, z: number, q = quarter): DockingOutcome => - dockingOutcome(new THREE.Vector3(x, y, z), q, station, DOCK_Z, scratch); + dockingOutcome(new THREE.Vector3(x, y, z), q, station, DOCK_Z, 0, scratch); const cube = bisect(DOCK_Z, DOCK_Z + 200, (x) => at(x, 0, 0) !== 'clear'); check(`the bounding cube ends at dockZ + HULL_BOX_MARGIN (${cube.toFixed(3)})`, diff --git a/test/hud-model.test.ts b/test/hud-model.test.ts index 3efeb931..0614fdf9 100644 --- a/test/hud-model.test.ts +++ b/test/hud-model.test.ts @@ -191,7 +191,7 @@ console.log('\ndocking port marker'); // refuses. Restore `port` to `inSlot ? 'lined' : 'off'` and this goes red. const rolled = pose(0, ROLL_TOLERANCE + 0.05); const outcome = dockingOutcome( - rolled.pos, rolled.quat, station, DOCK_Z, + rolled.pos, rolled.quat, station, DOCK_Z, 0, { v: new THREE.Vector3(), q: new THREE.Quaternion(), r: new THREE.Vector3() }); const aid = aidAt(0, ROLL_TOLERANCE + 0.05); check('the pose the old marker called LINED UP is the one the slot refuses', diff --git a/test/world.test.ts b/test/world.test.ts index 43bde785..6ee9424c 100644 --- a/test/world.test.ts +++ b/test/world.test.ts @@ -205,7 +205,7 @@ console.log('\ndocking'); const rolledFrom = (off: number) => new THREE.Quaternion() .setFromAxisAngle(new THREE.Vector3(0, 0, 1), Math.PI / 2 + off); const at = (x: number, y: number, z: number, q = quarter) => - dockingOutcome(new THREE.Vector3(x, y, z), q, station, DOCK_Z, scratch); + dockingOutcome(new THREE.Vector3(x, y, z), q, station, DOCK_Z, 0, scratch); check('far away is clear', at(0, 0, 5000) === 'clear'); check('lined up in the slot, rolled with it, is docked', From 3f4568bac095c5360f11532e2253429f9805b8d4 Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Fri, 11 Sep 2026 23:39:36 +0100 Subject: [PATCH 027/100] docs/TODO/207 M2: the roll strip and the throttle buttons fly the slot MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The last stretch shows three controls and no guns: a strip to drag for the roll, and held THRUST and BRAKE buttons for the speed. The strip is a new platform seam beside the click and the held button: it reads how far the pointer is from its middle and reports a stick, and a roll key still beats it. The label over the view says MATCH THE SLOT — GO IN SLOWLY, and the speed bar carries a mark at the fastest the slot will take. 5,820 assertions, from 5,807. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- ...ot-takes-the-ship-into-the-slot-by-hand.md | 15 ++++ play.html | 6 +- src/engine/flight-controls.ts | 6 ++ src/engine/input.ts | 9 ++ src/engine/strip-control.ts | 50 +++++++++++ src/game/bindings.ts | 8 ++ src/game/cockpit-buttons.ts | 20 +++++ src/game/cockpit-view.ts | 6 ++ src/hud/hud-binding.ts | 3 + src/hud/hud-buttons.ts | 13 ++- src/hud/hud.ts | 13 ++- src/style.css | 34 +++++++ test/console-plate.test.ts | 2 +- test/constants.test.ts | 2 +- test/dock-trial.test.ts | 89 +++++++++++++++++++ test/fight-buttons.test.ts | 1 + test/run.ts | 1 + 17 files changed, 271 insertions(+), 7 deletions(-) create mode 100644 src/engine/strip-control.ts create mode 100644 test/dock-trial.test.ts diff --git a/docs/TODO/207-the-pilot-takes-the-ship-into-the-slot-by-hand.md b/docs/TODO/207-the-pilot-takes-the-ship-into-the-slot-by-hand.md index 6ebd954f..02ac62c1 100644 --- a/docs/TODO/207-the-pilot-takes-the-ship-into-the-slot-by-hand.md +++ b/docs/TODO/207-the-pilot-takes-the-ship-into-the-slot-by-hand.md @@ -173,3 +173,18 @@ Evidence: approaches with no scrape after the change. - **Two course tests pinned the free dock of the 205 stopgap.** They fit a docking computer now, and a new block flies the hand-over to the pilot. + +### M2 + +- **The roll strip is a third platform seam**, beside the click and the held + button. `engine/strip-control.ts` reads how far a pointer is from the + strip's middle, and reports a stick between -1 and 1. A roll key beats it, + as a key beats the mouse. +- **The strip moves its own knob.** The painter rebuilds the buttons only when + their words change, and a knob moves every frame a thumb does. +- **The guns wait during the stretch.** The slot asks for two things, so the + pilot's buttons are the strip, THRUST and BRAKE, and nothing else. +- **The speed bar carries the slot's limit as a mark.** It is placed from the + rule itself, so the mark cannot drift from what the slot takes. +- **The label over the view says MATCH THE SLOT — GO IN SLOWLY** while the + stretch runs. diff --git a/play.html b/play.html index 5b577de1..ebd29059 100644 --- a/play.html +++ b/play.html @@ -61,7 +61,11 @@
    -
    + +
    diff --git a/src/engine/flight-controls.ts b/src/engine/flight-controls.ts index e96bbb35..e988fc54 100644 --- a/src/engine/flight-controls.ts +++ b/src/engine/flight-controls.ts @@ -29,6 +29,8 @@ export interface FlightControls { readonly mouseX: number; readonly mouseY: number; readonly mouseFire: boolean; + /** the roll strip's stick, -1 to 1, or null when nothing holds it (docs/TODO/207) */ + readonly rollStick?: number | null; } /** The ramped rates the demand continues from — the ship's own, in practice. */ @@ -61,6 +63,10 @@ export function flightDemand( let rollIn = (c.held(...keys.rollLeft) ? 1 : 0) - (c.held(...keys.rollRight) ? 1 : 0); let pitchIn = (c.held(...keys.pitchUp) ? 1 : 0) - (c.held(...keys.pitchDown) ? 1 : 0); + // The roll strip of a docking (docs/TODO/207 M2): an analogue roll for a + // mouse and a finger. A roll key held beats it, as it beats the mouse. + if (rollIn === 0 && c.rollStick != null) rollIn = -c.rollStick; + // mouse flight: analogue axes, keyboard still overrides when touched if (c.mouseFlight) { if (rollIn === 0) rollIn = -c.mouseX; diff --git a/src/engine/input.ts b/src/engine/input.ts index f227f233..72dbcbfc 100644 --- a/src/engine/input.ts +++ b/src/engine/input.ts @@ -1,5 +1,6 @@ import { CARRY_LIMIT } from '../constants/world-clock.ts'; import { attachHoldButtons } from './hold-buttons.ts'; +import { attachStripControl } from './strip-control.ts'; // Keyboard state with frame-oriented semantics: // - held(codes): live keydown state — every continuous control, the trigger @@ -68,6 +69,12 @@ export class Input { mouseX = 0; mouseY = 0; mouseFire = false; + /** + * The roll strip's stick, -1 to 1, or null when nothing holds it + * (docs/TODO/207 M2). A roll key held beats it, as a speed key beats a + * throttle slider. + */ + rollStick: number | null = null; private readonly canvas: HTMLElement | null; constructor() { @@ -82,6 +89,8 @@ export class Input { this.canvas = document.getElementById('scene'); // The laser button holds its key as a finger holds it (docs/TODO/206 M3). attachHoldButtons(this, document); + // ...and the roll strip of the last stretch of a docking (docs/TODO/207). + attachStripControl(this, document); document.addEventListener('pointerlockchange', () => { this.mouseFlight = document.pointerLockElement === this.canvas; if (!this.mouseFlight) { diff --git a/src/engine/strip-control.ts b/src/engine/strip-control.ts new file mode 100644 index 00000000..a66aa7e0 --- /dev/null +++ b/src/engine/strip-control.ts @@ -0,0 +1,50 @@ +// A strip you drag with a finger or the mouse (docs/TODO/207 M2). +// +// The last stretch of a docking asks for one thing a button cannot give: how +// MUCH roll, held steady. So a `data-strip` element reads the pointer's +// distance from its own middle, and reports it as a stick between -1 and 1. +// The ship then rolls at that share of its rate, exactly as an arrow key +// rolls it at the whole rate. +// +// PLATFORM, like the held buttons next door, and nothing when the page has no +// document. The strip moves its own knob. The painter rebuilds the markup only +// when the words change, and the knob moves every frame a thumb does. + +/** What a strip reports to. */ +export interface StripTarget { + /** the stick, -1 to 1, or null when nothing holds the strip */ + rollStick: number | null; +} + +export function attachStripControl(input: StripTarget, doc: Document): void { + let held: { id: number; el: HTMLElement } | null = null; + + const move = (el: HTMLElement, clientX: number): void => { + const box = el.getBoundingClientRect(); + const half = box.width / 2; + const off = Math.max(-1, Math.min(1, (clientX - (box.left + half)) / half)); + input.rollStick = off; + const knob = el.querySelector('.knob'); + if (knob) knob.style.transform = `translateX(${off * (half - knob.offsetWidth / 2)}px)`; + }; + + doc.addEventListener('pointerdown', (e) => { + const el = (e.target as HTMLElement | null)?.closest?.('[data-strip]') as HTMLElement | null; + if (!el) return; + e.preventDefault(); + held = { id: e.pointerId, el }; + move(el, e.clientX); + }); + doc.addEventListener('pointermove', (e) => { + if (held && e.pointerId === held.id) move(held.el, e.clientX); + }); + const letGo = (e: PointerEvent): void => { + if (!held || e.pointerId !== held.id) return; + const knob = held.el.querySelector('.knob'); + if (knob) knob.style.transform = 'translateX(0)'; + held = null; + input.rollStick = null; + }; + doc.addEventListener('pointerup', letGo); + doc.addEventListener('pointercancel', letGo); +} diff --git a/src/game/bindings.ts b/src/game/bindings.ts index 01bfd155..8dfa3d0a 100644 --- a/src/game/bindings.ts +++ b/src/game/bindings.ts @@ -81,6 +81,14 @@ export const TARGETS_KEY = 'VirtTargets'; export const TARGET_NONE_KEY = 'VirtTargetNone'; export const TARGET_ROW_PREFIX = 'VirtTarget'; +/** + * The roll strip of the last stretch into the slot (docs/TODO/207 M2). It is + * not a key at all: `engine/strip-control.ts` reads the pointer's distance + * from the strip's middle, and reports a stick. The code names the strip in + * the markup, as a button's code names the button. + */ +export const ROLL_STRIP_CODE = 'roll'; + export const GLOBAL_BINDINGS: readonly Binding[] = [ // ? toggles the controls guide (plain / is the classic decelerate key) { key: 'Question', command: 'toggleHelp' }, diff --git a/src/game/cockpit-buttons.ts b/src/game/cockpit-buttons.ts index 5be796d9..2fc64d1b 100644 --- a/src/game/cockpit-buttons.ts +++ b/src/game/cockpit-buttons.ts @@ -61,6 +61,13 @@ export interface ActionSource { readonly ecmKey: string | null; /** a hostile missile is on its way, so the E.C.M. is the button to press */ readonly missileInbound: boolean; + /** the pilot flies the last stretch into the slot (docs/TODO/207 M2) */ + readonly trial: boolean; + /** the keys that open and close the throttle, for the two held buttons */ + readonly accelKey: string | null; + readonly decelKey: string | null; + /** the code the roll strip reports under */ + readonly rollStripCode: string; readonly targets: TargetPanel | null; } @@ -70,6 +77,19 @@ export interface ActionSource { * thumb finds it without a look. */ export function actionButtonsFor(a: ActionSource): HudButton[] { + // The last stretch into the slot asks for two things and nothing else: the + // roll, and the speed (docs/TODO/207 M2). So the pilot's buttons are those + // two while it runs, and the guns wait. + if (a.trial) { + const out: HudButton[] = [{ code: a.rollStripCode, label: 'DRAG TO ROLL', strip: true }]; + if (a.accelKey) { + out.push({ code: a.accelKey, label: 'THRUST', hint: 'HOLD TO SPEED UP', hold: true }); + } + if (a.decelKey) { + out.push({ code: a.decelKey, label: 'BRAKE', hint: 'HOLD TO SLOW DOWN', hold: true }); + } + return out; + } const out: HudButton[] = []; const t = a.targets; if (t && t.open) { diff --git a/src/game/cockpit-view.ts b/src/game/cockpit-view.ts index 2cdbe304..844b1225 100644 --- a/src/game/cockpit-view.ts +++ b/src/game/cockpit-view.ts @@ -39,6 +39,7 @@ import { viewDirection } from './views.ts'; import { keyCodeIfBound, keyIfBound } from '../ui/key-help.ts'; import type { HudButton } from '../hud/hud-buttons.ts'; import type { CoursePanel } from './course-actions.ts'; +import { ROLL_STRIP_CODE } from './bindings.ts'; import { actionButtonsFor, courseButtonsFor, offerButtons } from './cockpit-buttons.ts'; import type { TargetPanel } from './target-actions.ts'; import { keymap } from '../engine/keymap.ts'; @@ -223,6 +224,10 @@ export class CockpitView { launchKey: key('launchMissile'), ecmKey: this.state.commander.equipment.ecm ? key('fireEcm') : null, missileInbound: this.ordnance.missileInbound, + trial: this.state.session.dockTrial, + accelKey: keymap().accel[0] ?? null, + decelKey: keymap().decel[0] ?? null, + rollStripCode: ROLL_STRIP_CODE, targets: this.host.targetPanel(), }); } @@ -312,6 +317,7 @@ export class CockpitView { inFlight: this.host.inFlight(), witchspace: this.state.session.witchspace, assist: this.state.session.ccEngaged, + trial: this.state.session.dockTrial, ecmDetected: this.state.ecmDetectedTimer > 0, messageText: this.state.session.messageText, messageTimer: this.state.session.messageTimer, diff --git a/src/hud/hud-binding.ts b/src/hud/hud-binding.ts index c50ec849..58a69880 100644 --- a/src/hud/hud-binding.ts +++ b/src/hud/hud-binding.ts @@ -57,6 +57,8 @@ export interface HudSources { readonly inFlight: boolean; readonly witchspace: boolean; readonly assist: boolean; + /** the pilot flies the last stretch into the slot (docs/TODO/207) */ + readonly trial: boolean; readonly ecmDetected: boolean; readonly messageText: string; readonly messageTimer: number; @@ -218,6 +220,7 @@ export function buildHudFrame(s: HudSources, scratch: HudScratch): HudFrame { threatMarker, missionMarker, assist: s.assist, + trial: s.trial, armed: s.missileArmed, stationInRange: s.inFlight && !s.witchspace && playerPos.distanceTo(world.station.position) < SCANNER_RANGE, diff --git a/src/hud/hud-buttons.ts b/src/hud/hud-buttons.ts index 869c4b3d..4ee21700 100644 --- a/src/hud/hud-buttons.ts +++ b/src/hud/hud-buttons.ts @@ -27,6 +27,12 @@ export interface HudButton { * does, rather than sending it once (`engine/hold-buttons.ts`). */ readonly hold?: boolean; + /** + * The button is a strip to drag rather than a button to press + * (`engine/strip-control.ts`). It reports how far the pointer is from its + * middle, which is how much roll the last stretch of a docking asks for. + */ + readonly strip?: boolean; } /** Plain text only: a label is words, so the markup cannot carry any. */ @@ -43,11 +49,14 @@ export class ButtonStrip { } paint(buttons: readonly HudButton[]): void { - const html = buttons.map((b) => + const html = buttons.map((b) => (b.strip + ? `
    ` + + `${text(b.label)}
    ` + : `
    ` + `${text(b.label)}${b.note ? `${text(b.note)}` : ''}` - + `${b.hint ? `${text(b.hint)}` : ''}
    `).join(''); + + `${b.hint ? `${text(b.hint)}` : ''}
    `)).join(''); if (html === this.shown) return; this.shown = html; this.el.innerHTML = html; diff --git a/src/hud/hud.ts b/src/hud/hud.ts index a6241159..0663cbf4 100644 --- a/src/hud/hud.ts +++ b/src/hud/hud.ts @@ -9,6 +9,8 @@ import { SCANNER_RANGE, LASER_GAUGE_WARN, CABIN_GAUGE_WARN, } from '../constants/console.ts'; import { HUD } from '../palette.ts'; +import { SLOT_SPEED_LIMIT } from '../constants/docking.ts'; +import { PLAYER_FLIGHT } from '../constants/player-flight.ts'; // The classic console: elliptical 3D scanner (dot + vertical stick per // contact), station compass, gauge bars, and the message line. @@ -152,6 +154,8 @@ export interface HudState { missionMarker: { x: number; y: number; behind: boolean } | null; /** combat computer engaged (shown in the view label slot) */ assist: boolean; + /** the pilot flies the last stretch into the slot (docs/TODO/207) */ + trial: boolean; /** missile armed but not yet locked (yellow pylon) */ armed: boolean; /** console 'S': the space station is within scanner range */ @@ -247,6 +251,11 @@ export class Hud { private readonly invQ = new THREE.Quaternion(); constructor() { + // The mark on the speed bar: the fastest the slot will take, as a share of + // the ship's own top speed (docs/TODO/207 M3). It is placed from the two + // rules rather than written into the page. + byId('g-speed-limit').style.left = + `${(SLOT_SPEED_LIMIT / PLAYER_FLIGHT.maxSpeed) * 100}%`; this.scanner = (byId('scanner') as HTMLCanvasElement).getContext('2d')!; this.reticle = (byId('reticle') as HTMLCanvasElement).getContext('2d')!; this.compass = (byId('compass') as HTMLCanvasElement).getContext('2d')!; @@ -279,8 +288,8 @@ export class Hud { this.altEl.style.width = `${Math.min(100, frame.altitudeFrac * 100)}%`; this.cabinEl.style.width = `${Math.min(100, frame.cabinTemp * 100)}%`; this.cabinEl.style.background = frame.cabinTemp > CABIN_GAUGE_WARN ? RED : ''; - this.viewEl.textContent = frame.assist - ? '◆ THE COMPUTER IS AIMING ◆' : (VIEW_NAMES[frame.view] ?? ''); + this.viewEl.textContent = frame.trial ? '◆ MATCH THE SLOT — GO IN SLOWLY ◆' + : frame.assist ? '◆ THE COMPUTER IS AIMING ◆' : (VIEW_NAMES[frame.view] ?? ''); this.crosshairEl.style.display = frame.hasLaser ? '' : 'none'; this.shipIdEl.textContent = frame.shipId; this.drawEnergy(frame); diff --git a/src/style.css b/src/style.css index 070dda0f..a58a3bd2 100644 --- a/src/style.css +++ b/src/style.css @@ -480,6 +480,40 @@ body.screen-open #courses { visibility: hidden; } #actions .hud-button .note { font-size: 10px; color: var(--hud-amber); letter-spacing: 1px; } #actions .hud-button .hint { font-size: 10px; color: var(--hud-dim); letter-spacing: 1px; } #actions [data-hold] { color: var(--hud-red); border-color: rgba(var(--hud-red-rgb), 0.6); } + +/* + * The roll strip of the last stretch into the slot (docs/TODO/207 M2). It is + * wide and short, and the knob follows the pointer, so a thumb can hold a + * small roll steady. `engine/strip-control.ts` moves the knob. + */ +#actions .hud-strip { + position: relative; + height: 56px; + display: flex; align-items: center; justify-content: center; + border: 1px solid rgba(var(--hud-amber-rgb), 0.55); + background: rgba(var(--hud-amber-rgb), 0.08); + cursor: ew-resize; + user-select: none; -webkit-user-select: none; + touch-action: none; +} +#actions .hud-strip .knob { + position: absolute; + width: 34px; height: 34px; + border: 2px solid var(--hud-amber); + border-radius: 50%; +} +.bar .limit { + position: absolute; + top: -2px; bottom: -2px; + width: 2px; + background: var(--hud-amber); + opacity: 0.85; +} + +#actions .hud-strip .label { + font-size: 10px; letter-spacing: 1px; color: var(--hud-dim); + position: absolute; bottom: 3px; +} body.screen-open #actions { visibility: hidden; } /* diff --git a/test/console-plate.test.ts b/test/console-plate.test.ts index c703e1e4..29922b0c 100644 --- a/test/console-plate.test.ts +++ b/test/console-plate.test.ts @@ -80,7 +80,7 @@ console.log('\nthe console plate goes with its words'); viewDir: V(0, 0, -1), missiles: [], canisters: [], targetLock: null, inFlight: false, exercise: null, - courses: [], actions: [], + courses: [], actions: [], trial: false, messageText, messageTimer, } as unknown as Parameters[0], { diff --git a/test/constants.test.ts b/test/constants.test.ts index 93d4628c..ed3e2c77 100644 --- a/test/constants.test.ts +++ b/test/constants.test.ts @@ -470,7 +470,7 @@ const OUTSIDE: readonly Group[] = [ 'game/bindings.ts': [ 'GLOBAL_BINDINGS', 'FLIGHT_BINDINGS', 'NOT_IN_THE_SIMULATOR', 'BINDINGS', 'WHILE_PAUSED', 'COURSE_KEYS', 'COURSE_CHART_KEY', 'COURSE_TOGGLE_KEY', 'COURSE_SKIP_KEY', - 'TARGETS_KEY', 'TARGET_NONE_KEY', 'TARGET_ROW_PREFIX', + 'TARGETS_KEY', 'TARGET_NONE_KEY', 'TARGET_ROW_PREFIX', 'ROLL_STRIP_CODE', ], 'game/screens/save-transfer.ts': ['NOT_A_SAVE', 'WRONG_VERSION', 'STORE_FULL'], 'engine/keymap.ts': ['LAYOUTS', 'STORAGE_KEY'], diff --git a/test/dock-trial.test.ts b/test/dock-trial.test.ts new file mode 100644 index 00000000..ac33a708 --- /dev/null +++ b/test/dock-trial.test.ts @@ -0,0 +1,89 @@ +// The pilot flies the last stretch into the slot (docs/TODO/207). +// +// Chris picked Match the spin from the four concepts on 2026-09-11. The +// computer holds the ship on the slot axis. The pilot matches the station's +// spin with the roll strip or the roll keys, and the speed with the throttle. +// The slot takes the ship only if both are right. + +import * as THREE from 'three'; +import { actionButtonsFor } from '../src/game/cockpit-buttons.ts'; +import { attachStripControl } from '../src/engine/strip-control.ts'; +import { flightDemand } from '../src/engine/flight-controls.ts'; +import { keymap } from '../src/engine/keymap.ts'; +import { dockingOutcome } from '../src/game/docking.ts'; +import { SLOT_SPEED_LIMIT } from '../src/constants/docking.ts'; +import { PLAYER_FLIGHT } from '../src/constants/player-flight.ts'; +import { check, eq } from './harness.ts'; + +console.log('\nthe last stretch into the slot'); + +// --- the two controls, and nothing else -------------------------------------- +{ + const trial = actionButtonsFor({ + fireKey: 'KeyA', missiles: 3, armed: false, locked: false, armKey: 'KeyT', + launchKey: 'KeyM', ecmKey: 'KeyE', targets: null, missileInbound: false, + trial: true, accelKey: 'Space', decelKey: 'KeyX', rollStripCode: 'roll', + }); + eq('the stretch shows a strip and two held buttons, and no guns', + trial.map((b) => b.label).join(), 'DRAG TO ROLL,THRUST,BRAKE'); + check('the strip is dragged, not pressed', trial[0]?.strip === true); + check('...and the throttle buttons are held', trial[1]?.hold === true && trial[2]?.hold === true); +} + +// --- the strip reports how far from its middle a finger is ------------------- +{ + const listeners: Record void> = {}; + const doc = { addEventListener: (t: string, fn: (e: unknown) => void) => { listeners[t] = fn; } }; + const input = { rollStick: null as number | null }; + attachStripControl(input, doc as unknown as Document); + const knob = { offsetWidth: 34, style: { transform: '' } }; + const strip = { + getBoundingClientRect: () => ({ left: 100, width: 200 }), + querySelector: () => knob, + }; + const at = (x: number) => ({ target: { closest: () => strip }, pointerId: 1, clientX: x, preventDefault: () => {} }); + listeners.pointerdown(at(200)); + eq('a finger in the middle asks for no roll', input.rollStick, 0); + listeners.pointermove(at(300)); + eq('...at the right end, for all of it', input.rollStick, 1); + listeners.pointermove(at(150)); + eq('...and half way to the left, for half', input.rollStick, -0.5); + check('...and the knob follows it', knob.style.transform !== ''); + listeners.pointerup({ pointerId: 1 }); + eq('a finger that lifts lets the roll go', input.rollStick, null); +} + +// --- the strip rolls the ship, and a key still beats it ---------------------- +{ + const controls = { + down: new Set(), + mouseFlight: false, mouseX: 0, mouseY: 0, mouseFire: false, + rollStick: 0.5 as number | null, + held(...codes: string[]): boolean { return codes.some((c) => this.down.has(c)); }, + }; + const rates = { rollRate: 0, pitchRate: 0, speed: 0 }; + const strip = flightDemand(controls, keymap(), rates, 1 / 60); + check('the strip rolls the ship', strip.rollRate < 0); + controls.down.add(keymap().rollLeft[0]); + const key = flightDemand(controls, keymap(), rates, 1 / 60); + check('...and a roll key beats it', key.rollRate > 0); +} + +// --- the slot takes the ship only under the speed limit ---------------------- +{ + // A bare station at the origin, as test/world.test.ts measures the slot in: + // in the channel, with the wings across the slot's long axis. + const station = new THREE.Object3D(); + station.updateMatrixWorld(true); + const DOCK_Z = 160; + const scratch = { v: new THREE.Vector3(), q: new THREE.Quaternion(), r: new THREE.Vector3() }; + const quarter = new THREE.Quaternion() + .setFromAxisAngle(new THREE.Vector3(0, 0, 1), Math.PI / 2); + const inSlot = new THREE.Vector3(0, 0, -(DOCK_Z - 20)); + const outcome = (speed: number) => + dockingOutcome(inSlot, quarter, station, DOCK_Z, speed, scratch); + eq('slow enough, the slot takes the ship', outcome(SLOT_SPEED_LIMIT - 1), 'docked'); + eq('...and one unit over, it does not', outcome(SLOT_SPEED_LIMIT + 1), 'tooFast'); + check('the limit is well under the ship\'s top speed, so it is a real choice', + SLOT_SPEED_LIMIT < PLAYER_FLIGHT.maxSpeed / 2); +} diff --git a/test/fight-buttons.test.ts b/test/fight-buttons.test.ts index 94db722b..e47697d9 100644 --- a/test/fight-buttons.test.ts +++ b/test/fight-buttons.test.ts @@ -21,6 +21,7 @@ console.log('\nthe pilot\'s buttons'); const base = { fireKey: 'KeyA', missiles: 3, armed: false, locked: false, armKey: 'KeyT', launchKey: 'KeyM', ecmKey: null, targets: null, missileInbound: false, + trial: false, accelKey: 'Space', decelKey: 'KeyX', rollStripCode: 'roll', }; { const b = actionButtonsFor(base); diff --git a/test/run.ts b/test/run.ts index 11165450..ce87f4b9 100644 --- a/test/run.ts +++ b/test/run.ts @@ -81,6 +81,7 @@ import './aim.test.ts'; import './fight-buttons.test.ts'; import './run-and-offers.test.ts'; import './mine-and-collect.test.ts'; +import './dock-trial.test.ts'; import './world.test.ts'; import './docking.test.ts'; import './docking-computer.test.ts'; From 7f800511ccd8600abd9af6f0bfdcb10c21e67716 Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Fri, 11 Sep 2026 23:45:59 +0100 Subject: [PATCH 028/100] docs/TODO/207 M4: the guide teaches the last stretch, and the course brakes for it The manual and the briefing now say that the ship flies the approach and hands you the slot, that the roll and the speed are yours, and that a scrape bounces you clear to try again. A docking computer still flies the slot for you. The browser run found three faults. The course list showed during the stretch, and it shows none now. The hand-over came at full speed, so the station course arrives on its own braking plan: measured over 25 systems, the hand-over comes at 224 to 228 units a second with 1,500 units left, which is half a second of braking. The mark on the speed bar is green, so it reads over the amber fill. 5,820 assertions. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- ...ot-takes-the-ship-into-the-slot-by-hand.md | 24 ++++++++++++++++++ manual.html | 25 ++++++++++++------- src/game/course-pilot.ts | 12 +++++++-- src/game/game.ts | 5 +++- src/style.css | 7 +++--- src/ui/briefing.ts | 21 +++++++++------- 6 files changed, 70 insertions(+), 24 deletions(-) diff --git a/docs/TODO/207-the-pilot-takes-the-ship-into-the-slot-by-hand.md b/docs/TODO/207-the-pilot-takes-the-ship-into-the-slot-by-hand.md index 02ac62c1..05a8c1e5 100644 --- a/docs/TODO/207-the-pilot-takes-the-ship-into-the-slot-by-hand.md +++ b/docs/TODO/207-the-pilot-takes-the-ship-into-the-slot-by-hand.md @@ -188,3 +188,27 @@ Evidence: rule itself, so the mark cannot drift from what the slot takes. - **The label over the view says MATCH THE SLOT — GO IN SLOWLY** while the stretch runs. + +### M4, and what the browser run found + +- **The manual and the briefing teach the stretch.** The ship flies the + approach, hands you the slot, and you match the spin and the speed. Both + say that a scrape bounces you clear to try again, and that a docking + computer flies the slot for you. +- **The course list showed during the stretch, and it should not.** The ship + is in the station's mouth, and the only things to fly are the roll and the + speed. The cockpit shows no course buttons while the stretch runs. +- **The hand-over at full speed was unfair, and the course now brakes.** The + station course arrives at the hand-over on the arrival plan, at the slot's + own limit. It was measured over 25 systems with a clear sky. The hand-over + comes at 224 to 228 u/s, about 40 s after the arrival, with 1,500 units + left. That is half a second of braking, and the rest is the roll. +- **The hand-over is a range rather than an arrival.** An arrival also waits + for the speed to settle. A ship a few units a second over it sailed past the + station and into the hull. +- **A fight now stops a trip, and that is the design.** A measurement with the + arrival's traffic left 8 of 20 trips short of the station, because the + computer lines the ship up and nobody fires. A pilot fires, runs or pays. + With a clear sky, 40 of 40 trips reached the hand-over. +- **The speed bar's mark needed to be a different colour.** It is green over + the amber fill, so it reads at any speed. diff --git a/manual.html b/manual.html index 79b02d7d..b30f5b25 100644 --- a/manual.html +++ b/manual.html @@ -263,19 +263,26 @@

    Docking

    with a slot that will not hold still.

      -
    1. Approach the face with the port on it. An amber marker shows where - the port is, with an arrow at the screen edge when it is behind you.
      2. -
    2. Get on the axis, straight out from the port, not off to one side.
      3. +
    3. Choose FLY TO THE STATION. The ship flies the approach and + gets on the axis, straight out from the port. An amber marker shows + where the port is, with an arrow at the screen edge when it is + behind you.
      4. +
    4. Near the port the ship hands you the last stretch, and holds you + on the axis while you fly it.
    5. Roll to match the port's rotation. This is the part people miss. The opening is a letterbox, and your ship has to be the same - way up as it is.
      6. -
    6. Slow down. Then go in. The marker turns green and reads - DOCKING PORT — LINED UP when you have it.
      7. + way up as it is. Drag the strip at the bottom right, or use your + roll keys. +
    7. Then the speed. Hold THRUST or BRAKE until + you are under the mark on the speed bar, and go in. The marker turns + green and reads DOCKING PORT — LINED UP when + you have the roll.

    - Get it wrong and you bounce off the hull with a bang and most of a - shield gone. Get it wrong on a shield that is already down and it - reaches you. + Arrive rolled wrong, or too fast, and you bounce off the hull with a + bang and most of a shield gone. The station puts you back outside, and + you can try again. Get it wrong on a shield that is already down and + it reaches you.

    When you have the money, buy a docking computer. It is the diff --git a/src/game/course-pilot.ts b/src/game/course-pilot.ts index ee61c63a..273802f7 100644 --- a/src/game/course-pilot.ts +++ b/src/game/course-pilot.ts @@ -37,6 +37,7 @@ import { rampFlightRate, type FlightDemand } from '../player.ts'; import { bankToTurn, freshSteerMemory, type SteerMemory } from './pitch-roll-steer.ts'; import type { CourseKind } from './courses.ts'; import { PLAYER_FLIGHT } from '../constants/player-flight.ts'; +import { SLOT_SPEED_LIMIT } from '../constants/docking.ts'; import { COURSE_ARRIVE_BRAKE, COURSE_ARRIVE_TOLERANCE, COURSE_DERELICT_STANDOFF, COURSE_HERMIT_SPEED, COURSE_HERMIT_STANDOFF, COURSE_PLANET_CLEARANCE, @@ -170,11 +171,18 @@ export class CoursePilot { */ private toStation(v: CourseView, dt: number): CourseStep { if (v.dcEngaged) return IDLE; + // It ARRIVES at the hand-over, at the speed the slot will take + // (docs/TODO/207 M1). A ship handed over at full speed has less than four + // seconds to lose 280 units a second. That is no way to meet a pilot. + // The hand-over is a RANGE rather than an arrival. An arrival also asks + // for the speed to settle. A ship a few units a second over it would sail + // past the station while it waited. if (v.position.distanceTo(v.stationPos) <= v.handOverRange) { return { demand: null, torus: false, handOver: true, done: false }; } - const aim = clearOfPlanet(v.position, v.stationPos, v.planetPos, v.planetRadius, this.aim); - return { ...this.pointAt(v, aim, 1, dt), handOver: false, done: false }; + return this.arrive(v, { + target: v.stationPos, standoff: v.handOverRange, speed: SLOT_SPEED_LIMIT, + }, dt); } /** diff --git a/src/game/game.ts b/src/game/game.ts index 33145f67..bb18b184 100644 --- a/src/game/game.ts +++ b/src/game/game.ts @@ -457,8 +457,11 @@ export class Game { // The course buttons, in career flight only. An exercise is a room at // the station, and it has nowhere to go (docs/TODO/205 M5). During a // tunnel the cockpit reads no button, so it shows none. + // It shows none while the pilot flies the slot either. The ship is in + // the station's mouth then. The only things to fly are the roll and the + // speed (docs/TODO/207 M2). coursePanel: () => (this.flight_.inSimulator() || this.tunnel.active - ? null : this.courses_.panel()), + || this.state.session.dockTrial ? null : this.courses_.panel()), // The target buttons, in career flight and in an exercise alike: a // training fight is a real fight (docs/TODO/206 M3). targetPanel: () => (this.tunnel.active ? null : this.targets_.panel()), diff --git a/src/style.css b/src/style.css index a58a3bd2..59b38c28 100644 --- a/src/style.css +++ b/src/style.css @@ -504,10 +504,11 @@ body.screen-open #courses { visibility: hidden; } } .bar .limit { position: absolute; - top: -2px; bottom: -2px; + top: -3px; bottom: -3px; width: 2px; - background: var(--hud-amber); - opacity: 0.85; + z-index: 1; + background: var(--hud-green); + box-shadow: 0 0 6px rgba(var(--hud-green-rgb), 0.9); } #actions .hud-strip .label { diff --git a/src/ui/briefing.ts b/src/ui/briefing.ts index 9102569f..1516f5ee 100644 --- a/src/ui/briefing.ts +++ b/src/ui/briefing.ts @@ -130,15 +130,18 @@ export const BRIEFING: { title: string; body: string }[] = [ { title: 'DOCKING', body: `The hard part, and everybody finds it hard at first.

    - The station rotates, and so does its docking port. An amber marker - shows where the port is, with an arrow at the edge of the screen when it - is behind you.

    - Get onto the axis straight out from the port, then roll until you match - its rotation — the opening is a letterbox and you must be the same way - up as it. Then go in slowly. The marker turns green when you are lined - up.

    - When you can afford one, buy a docking computer and press - ${KEY.dockingComputer}.`, + The station rotates, and so does its docking port. Choose + FLY TO THE STATION and the ship flies the approach for you. Near + the port it hands you the last stretch, and two things are then + yours.

    + The first is the roll: the opening is a letterbox, and you must be + the same way up as it. Drag the strip at the bottom right, or use your + roll keys. The second is the speed: hold THRUST or + BRAKE, and cross the mark on the speed bar before you go in. The + port marker turns green when you are lined up.

    + Get it wrong and you scrape the hull, bounce clear and try again. When + you can afford one, buy a docking computer and press + ${KEY.dockingComputer}: it flies the slot for you.`, }, { title: 'STAYING ALIVE', From fc11b1041f85b0669a46edf0f85514aebae9d450 Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Fri, 11 Sep 2026 23:46:59 +0100 Subject: [PATCH 029/100] docs/TODO/207 lands: the pilot flies the slot, and the slot checks the speed Chris played the four concepts and picked Match the spin. The course flies the approach and hands the pilot the last 1,500 units at the slot's own speed. The computer holds the ship on the axis, and the pilot matches the station's spin and the speed. A ship that arrives rolled wrong or too fast scrapes and bounces clear, and tries again. A docking computer still flies the slot. 5,820 assertions, from 5,804. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- docs/TODO/QUEUE.json | 1 - docs/TODO/README.md | 13 ++++++++++--- ...he-pilot-takes-the-ship-into-the-slot-by-hand.md | 13 +++++++++++++ docs/TODO/completed/README.md | 1 + 4 files changed, 24 insertions(+), 4 deletions(-) rename docs/TODO/{ => completed}/207-the-pilot-takes-the-ship-into-the-slot-by-hand.md (93%) diff --git a/docs/TODO/QUEUE.json b/docs/TODO/QUEUE.json index f1dae90c..d6dfb8cb 100644 --- a/docs/TODO/QUEUE.json +++ b/docs/TODO/QUEUE.json @@ -1,7 +1,6 @@ { "version": 1, "items": [ - 207, 208 ] } diff --git a/docs/TODO/README.md b/docs/TODO/README.md index ba251314..226c8370 100644 --- a/docs/TODO/README.md +++ b/docs/TODO/README.md @@ -13,8 +13,7 @@ active context: ## Execution queue -1. [207](207-the-pilot-takes-the-ship-into-the-slot-by-hand.md) — the pilot takes the ship into the slot by hand. -2. [208](208-every-kind-of-mission-has-a-way-to-fly-it.md) — every kind of mission has a way to fly it. +1. [208](208-every-kind-of-mission-has-a-way-to-fly-it.md) — every kind of mission has a way to fly it. **205 TO 208 CAME FROM CHRIS ON 2026-09-11, the day 204 landed.** He flew the touch controls of 204 on a phone, and he could not fly the ship. He @@ -24,7 +23,7 @@ pilot fires the laser, the missiles and the E.C.M. The dock stays a challenge. The missions become part of the flight. 205 also takes out the touch controls of 204. He played four docking concepts the same day, and he picked Match the spin for 207. The plans are written, and the work waits -on his word. **205 and 206 landed the same day**, and both are below. +on his word. **205, 206 and 207 landed the same day**, and each is below. **204 CAME FROM CHRIS ON 2026-09-10.** The docked screens and the cockpit fit a phone, and nothing on the flight screen takes a touch. The brainstorm set @@ -296,6 +295,14 @@ it: *"display is good"*. **#23** closed with 134, as #22 did with 127, #18 with ## What landed on 2026-09-11 +**207 — the pilot takes the ship into the slot by hand.** Chris played four +docking concepts and picked Match the spin. The course flies the approach and +hands over the last 1,500 units, at the speed the slot takes. The computer +holds the ship on the axis. The pilot matches the station's spin with a roll +strip, and the speed with THRUST and BRAKE. The slot now refuses a ship +that arrives too fast, and a scrape bounces it clear to try again. A docking +computer still flies the slot. 5,820 assertions, from 5,804. + **206 — the computer flies the fight, and the pilot fires.** When a ship attacks, the computer lines you up, and the shooting stays yours. The buttons are FIRE LASER, ARM A MISSILE, E.C.M., and TARGETS to choose what to fight. The target list diff --git a/docs/TODO/207-the-pilot-takes-the-ship-into-the-slot-by-hand.md b/docs/TODO/completed/207-the-pilot-takes-the-ship-into-the-slot-by-hand.md similarity index 93% rename from docs/TODO/207-the-pilot-takes-the-ship-into-the-slot-by-hand.md rename to docs/TODO/completed/207-the-pilot-takes-the-ship-into-the-slot-by-hand.md index 05a8c1e5..bc48f1ec 100644 --- a/docs/TODO/207-the-pilot-takes-the-ship-into-the-slot-by-hand.md +++ b/docs/TODO/completed/207-the-pilot-takes-the-ship-into-the-slot-by-hand.md @@ -212,3 +212,16 @@ Evidence: With a clear sky, 40 of 40 trips reached the hand-over. - **The speed bar's mark needed to be a different colour.** It is green over the amber fill, so it reads at any speed. + +## Outcome + +207 landed on 2026-09-11. The station course flies the approach and hands the +pilot the last 1,500 units, at the speed the slot will take. The computer holds +the ship on the slot axis. The pilot matches the station's spin with the roll +strip or the roll keys, and the speed with THRUST and BRAKE. The slot refuses a +ship that arrives rolled wrong or above 120 units a second, and the console +says which. A scrape bounces the ship clear, and the pilot tries again. + +A docking computer still flies the slot from 3,500 units out, and it skips the +stretch. The dock probe docked 504 of 504 approaches with no scrape under the +new speed rule. The suite has 5,820 assertions, from 5,804. diff --git a/docs/TODO/completed/README.md b/docs/TODO/completed/README.md index 30a0ce72..ca1cde33 100644 --- a/docs/TODO/completed/README.md +++ b/docs/TODO/completed/README.md @@ -216,3 +216,4 @@ Supporting records: [Elite-A alignment plan](ELITE-A-COMBAT-PLAN.md), - [x] 203 — [A mission tells the player where to go](203-a-mission-tells-the-player-where-to-go.md) — Chris's playtest, 2026-09-10. The game never sent the machine an arrival or a day, so one job could not complete and no deadline passed. **M1** sends both. **M2** spawns a target inside the scanner, keeps a scan's subject, and puts pirates on the lane. **M3** marks the target on the scanner and the screen. **M4** makes the console speak at every change, in full sentences. **M5** counts a scan while the subject is in view, with no missile. **M6** says how a job plays in the manual. 5,619 assertions. - [x] 205 — [The pilot picks where the ship goes, and the ship flies itself](205-the-pilot-picks-where-the-ship-goes-and-the-ship-flies-itself.md) — Chris, 2026-09-11. **M1** takes out the touch controls of 204. **M2** is the course list, **M3** the pilot that flies it, **M4** the launch list and **M5** the buttons in flight. **M6** is the manual and the briefing, and **M7** is FAST FORWARD. 5,733 assertions. - [x] 206 — [The computer flies the fight, and the pilot fires](206-the-computer-flies-the-fight-and-the-pilot-fires.md) — Chris, 2026-09-11. **M1** is the target list and the pick. **M2 and M4** give every pilot the aim, and the bought computer the trigger. **M3** is the pilot's buttons. **M5** is the run and the offers. **M6** is mining and collecting. 5,804 assertions. +- [x] 207 — [The pilot takes the ship into the slot by hand](207-the-pilot-takes-the-ship-into-the-slot-by-hand.md) — Chris, 2026-09-11. He played four concepts and picked Match the spin. **M1** hands the last 1,500 units to the pilot. **M2** is the roll strip and the throttle buttons. **M3** is the slot's speed limit. **M4** is the guide. 5,820 assertions. From 762ea97f1a4976e8056df9d8a797af0e6a7147f4 Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Fri, 11 Sep 2026 23:54:44 +0100 Subject: [PATCH 030/100] docs/TODO/208 M1 and M2: a mission is the first button over the view A live job now shows as the first row of the course list, in its own words, and the ship flies it. Five verbs need a course, and four shapes cover them. A hunt picks its ship and the computer's aim flies it, as mining does. A scan holds 1,200 units off and keeps the nose on the ship. An escort flies 600 units off its charge, so the fight comes to the pilot. A recover and a rescue are a scoop. A deliver, a smuggle and an ambush end at the station, which the station course already flies. The test accepts each side job through the mission machine and flies it by its button alone. 5,831 assertions, from 5,820. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- docs/ARCHITECTURE.md | 4 +- ...ery-kind-of-mission-has-a-way-to-fly-it.md | 22 ++++ src/constants/CATALOG.md | 88 ++++++------- src/constants/combat-record.ts | 6 + src/constants/course.ts | 27 ++++ src/constants/encounters.ts | 4 +- src/constants/spawn-placement.ts | 4 +- src/game/course-actions.ts | 5 +- src/game/course-pilot.ts | 22 +++- src/game/flight-instruments.ts | 14 ++ src/game/mission-course.ts | 96 ++++++++++++++ src/missions/queries.ts | 8 +- test/course-pilot.test.ts | 1 + test/mission-courses.test.ts | 121 ++++++++++++++++++ test/run.ts | 1 + 15 files changed, 372 insertions(+), 51 deletions(-) create mode 100644 src/game/mission-course.ts create mode 100644 test/mission-courses.test.ts diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md index 1f5d3b21..a292ec95 100644 --- a/docs/ARCHITECTURE.md +++ b/docs/ARCHITECTURE.md @@ -178,7 +178,9 @@ Two quirks are deliberate: that rule. `target-actions.ts` joins the list to its buttons, and gives each ship a code that names it for as long as it lives. `cockpit-buttons.ts` says what every button over the flight view reads, in - words, and it holds no world (docs/TODO/206 M5). + words, and it holds no world (docs/TODO/206 M5). `game/mission-course.ts` + says what a live mission asks the ship to do here, in four shapes: a fight, + a hold, an escort and a scoop (docs/TODO/208). - `src/game/threat.ts` computes the pirate count, the group tier and the organisation from the visible value and the reputation. `ship-specs.ts` maps a tier to a hull. The campaign simulator calls the same rules. diff --git a/docs/TODO/208-every-kind-of-mission-has-a-way-to-fly-it.md b/docs/TODO/208-every-kind-of-mission-has-a-way-to-fly-it.md index 931d846b..36e1f963 100644 --- a/docs/TODO/208-every-kind-of-mission-has-a-way-to-fly-it.md +++ b/docs/TODO/208-every-kind-of-mission-has-a-way-to-fly-it.md @@ -141,3 +141,25 @@ Evidence: - A test proves that the smuggle path keeps outside 2,600 units of each Viper where such a path exists. - Chris plays the arc of one patron on his phone. + +## What the milestones found + +### M1 and M2 + +- **Five verbs need a course, and three do not.** A deliver, a smuggle and an + ambush all end at the station, and the station course flies there. The + other five get the first row of the list, in the job's own words. The rows + read HUNT THE KRAIT, SCAN THE ANACONDA, ESCORT THE PYTHON, RECOVER THE + CARGO and PICK UP THE SURVIVOR. +- **Four shapes cover those five.** A hunt is a fight, so the course picks the + ship and the computer's aim flies it, exactly as mining does. A scan holds + 1,200 units off and keeps the nose on the ship. An escort flies 600 units + off its charge, inside the ring the escort is judged by, so the fight comes + to the pilot. A recover and a rescue are a scoop. +- **The run leads the list in a hunt, and that is right.** The hunt's own ship + is hostile, so RUN FOR IT sits above the mission row (docs/TODO/206 M5). +- **The whole side-job flight is tested through the machine.** Each job is + accepted through `runMissions`, moved to the system the ship is in, and + flown by its button alone. A side job is on about a third of the worlds' + boards, so the test walks the galaxy until it finds one that offers it. +- **The suite has 5,831 assertions,** from 5,820. diff --git a/src/constants/CATALOG.md b/src/constants/CATALOG.md index 484a427a..49d03612 100644 --- a/src/constants/CATALOG.md +++ b/src/constants/CATALOG.md @@ -2,7 +2,7 @@ -439 exported constants. Regenerate with `npm run generate:constants`; +441 exported constants. Regenerate with `npm run generate:constants`; search names, meanings and values with `npm run constants:find -- ""`. | Domain | Symbol | Literal / expression | Purpose | Rule ID | Source | @@ -84,9 +84,9 @@ search names, meanings and values with `npm run constants:find -- ""`. | combat-record | SAMPLE_HZ | 10 | How often the code samples the geometry, in Hz. | | [combat-record.ts:12](./combat-record.ts#L12) | | combat-record | SIX_CONE | Math.PI / 3 | The rear cone that counts as somebody's six, as a half-angle from directly astern. | | [combat-record.ts:20](./combat-record.ts#L20) | | combat-record | PASS_CLOSE | 400 | What an attack run is, in ranges. | | [combat-record.ts:42](./combat-record.ts#L42) | -| combat-record | PASS_FAR | 600 | | | [combat-record.ts:43](./combat-record.ts#L43) | -| combat-record | SIM_LOG_LIMIT | 20 | How many exercise records the in-memory ring keeps. | combatrecord.simLogLimit | [combat-record.ts:50](./combat-record.ts#L50) | -| combat-record | MAX_SAMPLES | 12_000 | Samples kept before the buffer closes. | record.maxSamples | [combat-record.ts:63](./combat-record.ts#L63) | +| combat-record | PASS_FAR | 600 | ...and the far end of that pair: the range a ship must break back out to for the pass to count. | combatrecord.passFar | [combat-record.ts:49](./combat-record.ts#L49) | +| combat-record | SIM_LOG_LIMIT | 20 | How many exercise records the in-memory ring keeps. | combatrecord.simLogLimit | [combat-record.ts:56](./combat-record.ts#L56) | +| combat-record | MAX_SAMPLES | 12_000 | Samples kept before the buffer closes. | record.maxSamples | [combat-record.ts:69](./combat-record.ts#L69) | | commander | DEFAULT_NAME | 'JAMESON' | The original's own commander, and the default here. | | [commander.ts:10](./commander.ts#L10) | | commander | STARTING_CREDITS | 1000 | The grubstake, in tenths of a credit — the classic 100.0 Cr. | commander.startingCredits | [commander.ts:18](./commander.ts#L18) | | commander | CHEAT_CREDIT_GRANT | 100_000 | What test mode's GRANT CREDITS row hands over per press, in tenths: 10,000 Cr, which is a hundred grubstakes (`game/screens/test-mode.ts`). | | [commander.ts:40](./commander.ts#L40) | @@ -128,6 +128,8 @@ search names, meanings and values with `npm run constants:find -- ""`. | course | COURSE_RUN_REACH | 50_000 | How far ahead the run course aims, in world units, on the line away from the hostile ships (docs/TODO/206 M5). | course.runReach | [course.ts:169](./course.ts#L169) | | course | COURSE_COLLECT_SPEED | 60 | How fast the collect course flies onto a canister, in world units a second (docs/TODO/206 M6). | course.collectSpeed | [course.ts:183](./course.ts#L183) | | course | COURSE_DOCK_HANDOVER | 1500 | How far from the station the station course hands the ship to the pilot, in world units (docs/TODO/207 M1). | course.dockHandover | [course.ts:197](./course.ts#L197) | +| course | COURSE_WATCH_STANDOFF | 1200 | How far from a ship the scan course holds, in world units (docs/TODO/208 M2). | course.watchStandoff | [course.ts:211](./course.ts#L211) | +| course | COURSE_ESCORT_STANDOFF | 600 | How far from its charge the escort course flies, in world units (docs/TODO/208 M2). | course.escortStandoff | [course.ts:224](./course.ts#L224) | | docking | GATE_HALF_WIDTHS | 5 | How far out the approach gate sits, in multiples of the station half-width. | docking.gateHalfWidths | [docking.ts:25](./docking.ts#L25) | | docking | TURN_IN | Math.PI / 4 | How far round from the slot axis an approach turns in, in radians. | | [docking.ts:49](./docking.ts#L49) | | docking | RUN_IN_WIDTHS | GATE_HALF_WIDTHS * 0.6 | Where the approach stops the curve and flies straight, in station half-widths. | | [docking.ts:87](./docking.ts#L87) | @@ -147,16 +149,16 @@ search names, meanings and values with `npm run constants:find -- ""`. | encounters | TRADER_GAP | 100 | The gap between trader arrivals in a system with no economy to speak of. | | [encounters.ts:20](./encounters.ts#L20) | | encounters | TRADER_GAP_JITTER | 60 | ...and the jitter on top, drawn flat, so the lane never runs to a metronome. * | encounters.traderGapJitter | [encounters.ts:25](./encounters.ts#L25) | | encounters | TRADER_GAP_BUSY_MAX | 50 | The most that a busy economy can discount off `TRADER_GAP`. | encounters.traderGapBusyMax | [encounters.ts:40](./encounters.ts#L40) | -| encounters | PRODUCTIVITY_PER_SECOND | 1200 | How much 1984 productivity buys one second off that gap. | | [encounters.ts:51](./encounters.ts#L51) | -| encounters | TRADER_GAP_FIRST | 20 | How long after a system's clocks start the first trader may appear. | encounters.traderGapFirst | [encounters.ts:64](./encounters.ts#L64) | -| encounters | TRADER_GAP_FIRST_JITTER | 40 | ...and its jitter, so two arrivals in one system are not the same arrival. * | encounters.traderGapFirstJitter | [encounters.ts:69](./encounters.ts#L69) | -| encounters | PIRATE_WAVE_GAP | 60 | The gap between pirate waves in the most organised system that still breeds them. | encounters.pirateWaveGap | [encounters.ts:79](./encounters.ts#L79) | -| encounters | PIRATE_WAVE_GAP_PER_GOVERNMENT | 40 | ...and how much longer the wait grows for every step up the government ladder. | encounters.pirateWaveGapPerGovernment | [encounters.ts:92](./encounters.ts#L92) | -| encounters | PIRATE_WAVE_GAP_JITTER | 90 | ...and the jitter. | | [encounters.ts:96](./encounters.ts#L96) | -| encounters | LAWLESS_GOVERNMENT | 3 | A government at or below this breeds pirate waves at all. 3 is a dictatorship on the 1984 ladder, so waves stop at communist (4) and above. | encounters.lawlessGovernment | [encounters.ts:108](./encounters.ts#L108) | -| encounters | ANARCHY_GOVERNMENT | 1 | ...and a government at or below THIS sends them two at a time: anarchy (0) and feudal (1). | encounters.anarchyGovernment | [encounters.ts:124](./encounters.ts#L124) | -| encounters | MAX_THARGONS | 2 | How many drones the Thargoids keep in the sky at once, across every mothership. | encounters.maxThargons | [encounters.ts:144](./encounters.ts#L144) | -| encounters | THARGON_REDEPLOY | 5 | Seconds between one drone and the next, and the wait for the first. | encounters.thargonRedeploy | [encounters.ts:159](./encounters.ts#L159) | +| encounters | PRODUCTIVITY_PER_SECOND | 1200 | How much 1984 productivity buys one second off that gap. | encounters.productivityPerSecond | [encounters.ts:53](./encounters.ts#L53) | +| encounters | TRADER_GAP_FIRST | 20 | How long after a system's clocks start the first trader may appear. | encounters.traderGapFirst | [encounters.ts:66](./encounters.ts#L66) | +| encounters | TRADER_GAP_FIRST_JITTER | 40 | ...and its jitter, so two arrivals in one system are not the same arrival. * | encounters.traderGapFirstJitter | [encounters.ts:71](./encounters.ts#L71) | +| encounters | PIRATE_WAVE_GAP | 60 | The gap between pirate waves in the most organised system that still breeds them. | encounters.pirateWaveGap | [encounters.ts:81](./encounters.ts#L81) | +| encounters | PIRATE_WAVE_GAP_PER_GOVERNMENT | 40 | ...and how much longer the wait grows for every step up the government ladder. | encounters.pirateWaveGapPerGovernment | [encounters.ts:94](./encounters.ts#L94) | +| encounters | PIRATE_WAVE_GAP_JITTER | 90 | ...and the jitter. | | [encounters.ts:98](./encounters.ts#L98) | +| encounters | LAWLESS_GOVERNMENT | 3 | A government at or below this breeds pirate waves at all. 3 is a dictatorship on the 1984 ladder, so waves stop at communist (4) and above. | encounters.lawlessGovernment | [encounters.ts:110](./encounters.ts#L110) | +| encounters | ANARCHY_GOVERNMENT | 1 | ...and a government at or below THIS sends them two at a time: anarchy (0) and feudal (1). | encounters.anarchyGovernment | [encounters.ts:126](./encounters.ts#L126) | +| encounters | MAX_THARGONS | 2 | How many drones the Thargoids keep in the sky at once, across every mothership. | encounters.maxThargons | [encounters.ts:146](./encounters.ts#L146) | +| encounters | THARGON_REDEPLOY | 5 | Seconds between one drone and the next, and the wait for the first. | encounters.thargonRedeploy | [encounters.ts:161](./encounters.ts#L161) | | exercise | OPENING_RANGE | 4500 | The opening range for a fight that you are meant to see coming. | exercise.openingRange | [exercise.ts:33](./exercise.ts#L33) | | exercise | AMBUSH_RANGE | 2400 | An ambush opens INSIDE their gun, because that is what an ambush is. | | [exercise.ts:40](./exercise.ts#L40) | | exercise | MIN_OPENING_RANGE | 2 * PASS_FAR | No opening may be closer than this. | | [exercise.ts:49](./exercise.ts#L49) | @@ -344,35 +346,35 @@ search names, meanings and values with `npm run constants:find -- ""`. | shop | BEAM_LASER_PRICE | 10000 | The beam laser's price. | | [shop.ts:34](./shop.ts#L34) | | shop | EQUIPMENT_CATALOGUE | [ { id: 'missile', name: 'Missile', price: 300, minTL: 1 }, { id: 'largeBay', name: `Large Cargo Bay (${LARGE_BAY_TONNES}t)`, price: 4000, minTL: 1 }, { id: 'ecm', name: 'E.C.M. System', price: 6000, minTL: 2 }, { id: 'rearLaser', name: 'Rear Pulse Laser', price: PULSE_LASER_PRICE, minTL: 3 }, { id: 'leftLaser', name: 'Left Pulse Laser', price: PULSE_LASER_PRICE, minTL: 3 }, { id: 'rightLaser', name: 'Right Pulse Laser', price: PULSE_LASER_PRICE, minTL: 3 }, { id: 'beam', name: 'Beam Laser', price: BEAM_LASER_PRICE, minTL: 4 }, { id: 'scoops', name: 'Fuel Scoops', price: 5250, minTL: 5 }, { id: 'escapePod', name: 'Escape Pod', price: 10000, minTL: 6 }, { id: 'energyBomb', name: 'Energy Bomb', price: 9000, minTL: 7 }, { id: 'energyUnit', name: 'Extra Energy Unit', price: 15000, minTL: 8 }, { id: 'dockingComputer', name: 'Docking Computer', price: 15000, minTL: 9 }, { id: 'miningLaser', name: 'Mining Laser', price: 8000, minTL: 10 }, { id: 'combatComputer', name: 'Combat Computer', price: 20000, minTL: 9 }, { id: 'trumble', name: 'Trumble (adorable, harmless*)', price: 20, minTL: 1 }, { id: 'military', name: 'Military Laser', price: 60000, minTL: 10 }, { id: 'galacticDrive', name: 'Galactic Hyperdrive', price: 50000, minTL: 10 }, ] | The outfitter's shelf, in the order the screen lists it. | | [shop.ts:49](./shop.ts#L49) | | spawn-placement | TRADER_SCATTER | 1800 | How far from the station a trader on its run loiters. | | [spawn-placement.ts:25](./spawn-placement.ts#L25) | -| spawn-placement | POLICE_SCATTER | 1200 | How far off the arrival corridor the police scatter. | | [spawn-placement.ts:33](./spawn-placement.ts#L33) | -| spawn-placement | POLICE_PATROL_RANGE | 18_000 | How far a launch scatters the patrol across the system. | | [spawn-placement.ts:41](./spawn-placement.ts#L41) | -| spawn-placement | ASTEROID_SCATTER | 5000 | How far the rocks scatter round the station. | | [spawn-placement.ts:55](./spawn-placement.ts#L55) | -| spawn-placement | ASTEROID_LANE_SCATTER | SCANNER_RANGE / 1.5 | How far off the arrival corridor each rock sits. | | [spawn-placement.ts:73](./spawn-placement.ts#L73) | -| spawn-placement | HUNTER_SCATTER | 6000 | How far out a bounty hunter starts, at work on the whole system. | spawn.hunterScatter | [spawn-placement.ts:83](./spawn-placement.ts#L83) | -| spawn-placement | HERMIT_SCATTER | 14_000 | How far out the rock hermit hides. | | [spawn-placement.ts:97](./spawn-placement.ts#L97) | -| spawn-placement | CORRIDOR_START | 0.1 | Where along the route from you to the station the nearest pirate can be, as a fraction of that route. | spawn.corridorStart | [spawn-placement.ts:111](./spawn-placement.ts#L111) | -| spawn-placement | CORRIDOR_SPAN | 0.75 | How much of the route the rest are spread across. 0.1 + 0.75 leaves the last 15% clear, which is the approach to the station. | | [spawn-placement.ts:117](./spawn-placement.ts#L117) | -| spawn-placement | PIRATE_SCATTER | 2500 | How far off the corridor's line each pirate sits. | spawn.pirateScatter | [spawn-placement.ts:130](./spawn-placement.ts#L130) | -| spawn-placement | TRADER_ARRIVAL_RANGE | 22_000 | How far out a fresh trader warps in. | | [spawn-placement.ts:137](./spawn-placement.ts#L137) | -| spawn-placement | DEEP_TRADER_RANGE | 12_000 | How far AHEAD OF THE COMMANDER a trader warps in, out in deep space. | spawn.deepTraderRange | [spawn-placement.ts:150](./spawn-placement.ts#L150) | -| spawn-placement | DEEP_TRADER_CONE | Math.asin(MASS_LOCK_SHIP / DEEP_TRADER_RANGE) | The half-angle of the cone it warps into, about the commander's own heading, in RADIANS. 0.5 is about 29 degrees. | spawn.deepTraderCone | [spawn-placement.ts:177](./spawn-placement.ts#L177) | -| spawn-placement | DEEP_TRADER_RUN | 30_000 | How far it runs before it jumps out. | | [spawn-placement.ts:196](./spawn-placement.ts#L196) | -| spawn-placement | PIRATE_WAVE_RANGE | 9000 | How far from the commander a pirate wave warps in. | | [spawn-placement.ts:204](./spawn-placement.ts#L204) | -| spawn-placement | PIRATE_WAVE_RANGE_SPAN | 4000 | ...and how much further out than that they may be. | | [spawn-placement.ts:207](./spawn-placement.ts#L207) | -| spawn-placement | GENERATION_SHIP_RANGE | 14_000 | How far from the commander a generation ship crosses. | | [spawn-placement.ts:213](./spawn-placement.ts#L213) | -| spawn-placement | GENERATION_SHIP_RANGE_SPAN | 8000 | ...and the width of that band. | | [spawn-placement.ts:216](./spawn-placement.ts#L216) | -| spawn-placement | GENERATION_CARGO_SCATTER | 700 | How far from a generation ship its shed cargo drifts. | | [spawn-placement.ts:223](./spawn-placement.ts#L223) | -| spawn-placement | MISSION_TARGET_RANGE | 2500 | How far from the commander a mission's target waits on arrival. | spawn.missionTargetRange | [spawn-placement.ts:238](./spawn-placement.ts#L238) | -| spawn-placement | MISSION_TARGET_RANGE_SPAN | 2000 | ...and the width of that band, so a target sits between 2,500 and 4,500 out. | | [spawn-placement.ts:241](./spawn-placement.ts#L241) | -| spawn-placement | THARGON_DEPLOY_RANGE | 150 | How far from its mother a Thargon drone appears. | | [spawn-placement.ts:247](./spawn-placement.ts#L247) | -| spawn-placement | STATION_DEFENCE_MIN | 1 | The fewest Vipers the station launches after you shoot at something you should not. | spawn.stationDefenceMin | [spawn-placement.ts:260](./spawn-placement.ts#L260) | -| spawn-placement | STATION_DEFENCE_SPAN | 2 | ...and the width of that draw: one or two of them. | spawn.stationDefenceSpan | [spawn-placement.ts:271](./spawn-placement.ts#L271) | -| spawn-placement | STATION_DEFENCE_STANDOFF | 500 | How far out of the slot the first one launches. | | [spawn-placement.ts:277](./spawn-placement.ts#L277) | -| spawn-placement | STATION_DEFENCE_STACK | 120 | ...and how much further out each one after it starts, so a pair does not arrive inside each other. | spawn.stationDefenceStack | [spawn-placement.ts:285](./spawn-placement.ts#L285) | -| spawn-placement | STATION_DEFENCE_JITTER | 80 | ...and the random nudge on each, so a second launch does not look like the first. | | [spawn-placement.ts:295](./spawn-placement.ts#L295) | -| spawn-placement | TRADER_ARRIVED | 900 | How near the station an arriving trader has to be to start trading. | spawn.traderArrived | [spawn-placement.ts:310](./spawn-placement.ts#L310) | -| spawn-placement | TRADER_JUMP_OUT | 2500 | How near its waypoint a departing trader has to be to jump out. | spawn.traderJumpOut | [spawn-placement.ts:326](./spawn-placement.ts#L326) | -| spawn-placement | SPAWN_PLANET_ALTITUDE | 1000 | The lowest a ship may appear above the planet's surface, measured to the ship's centre, in world units. | spawn.planetAltitude | [spawn-placement.ts:345](./spawn-placement.ts#L345) | +| spawn-placement | POLICE_SCATTER | 1200 | How far off the arrival corridor the police scatter. | spawn.policeScatter | [spawn-placement.ts:35](./spawn-placement.ts#L35) | +| spawn-placement | POLICE_PATROL_RANGE | 18_000 | How far a launch scatters the patrol across the system. | | [spawn-placement.ts:43](./spawn-placement.ts#L43) | +| spawn-placement | ASTEROID_SCATTER | 5000 | How far the rocks scatter round the station. | | [spawn-placement.ts:57](./spawn-placement.ts#L57) | +| spawn-placement | ASTEROID_LANE_SCATTER | SCANNER_RANGE / 1.5 | How far off the arrival corridor each rock sits. | | [spawn-placement.ts:75](./spawn-placement.ts#L75) | +| spawn-placement | HUNTER_SCATTER | 6000 | How far out a bounty hunter starts, at work on the whole system. | spawn.hunterScatter | [spawn-placement.ts:85](./spawn-placement.ts#L85) | +| spawn-placement | HERMIT_SCATTER | 14_000 | How far out the rock hermit hides. | | [spawn-placement.ts:99](./spawn-placement.ts#L99) | +| spawn-placement | CORRIDOR_START | 0.1 | Where along the route from you to the station the nearest pirate can be, as a fraction of that route. | spawn.corridorStart | [spawn-placement.ts:113](./spawn-placement.ts#L113) | +| spawn-placement | CORRIDOR_SPAN | 0.75 | How much of the route the rest are spread across. 0.1 + 0.75 leaves the last 15% clear, which is the approach to the station. | | [spawn-placement.ts:119](./spawn-placement.ts#L119) | +| spawn-placement | PIRATE_SCATTER | 2500 | How far off the corridor's line each pirate sits. | spawn.pirateScatter | [spawn-placement.ts:132](./spawn-placement.ts#L132) | +| spawn-placement | TRADER_ARRIVAL_RANGE | 22_000 | How far out a fresh trader warps in. | | [spawn-placement.ts:139](./spawn-placement.ts#L139) | +| spawn-placement | DEEP_TRADER_RANGE | 12_000 | How far AHEAD OF THE COMMANDER a trader warps in, out in deep space. | spawn.deepTraderRange | [spawn-placement.ts:152](./spawn-placement.ts#L152) | +| spawn-placement | DEEP_TRADER_CONE | Math.asin(MASS_LOCK_SHIP / DEEP_TRADER_RANGE) | The half-angle of the cone it warps into, about the commander's own heading, in RADIANS. 0.5 is about 29 degrees. | spawn.deepTraderCone | [spawn-placement.ts:179](./spawn-placement.ts#L179) | +| spawn-placement | DEEP_TRADER_RUN | 30_000 | How far it runs before it jumps out. | | [spawn-placement.ts:198](./spawn-placement.ts#L198) | +| spawn-placement | PIRATE_WAVE_RANGE | 9000 | How far from the commander a pirate wave warps in. | | [spawn-placement.ts:206](./spawn-placement.ts#L206) | +| spawn-placement | PIRATE_WAVE_RANGE_SPAN | 4000 | ...and how much further out than that they may be. | | [spawn-placement.ts:209](./spawn-placement.ts#L209) | +| spawn-placement | GENERATION_SHIP_RANGE | 14_000 | How far from the commander a generation ship crosses. | | [spawn-placement.ts:215](./spawn-placement.ts#L215) | +| spawn-placement | GENERATION_SHIP_RANGE_SPAN | 8000 | ...and the width of that band. | | [spawn-placement.ts:218](./spawn-placement.ts#L218) | +| spawn-placement | GENERATION_CARGO_SCATTER | 700 | How far from a generation ship its shed cargo drifts. | | [spawn-placement.ts:225](./spawn-placement.ts#L225) | +| spawn-placement | MISSION_TARGET_RANGE | 2500 | How far from the commander a mission's target waits on arrival. | spawn.missionTargetRange | [spawn-placement.ts:240](./spawn-placement.ts#L240) | +| spawn-placement | MISSION_TARGET_RANGE_SPAN | 2000 | ...and the width of that band, so a target sits between 2,500 and 4,500 out. | | [spawn-placement.ts:243](./spawn-placement.ts#L243) | +| spawn-placement | THARGON_DEPLOY_RANGE | 150 | How far from its mother a Thargon drone appears. | | [spawn-placement.ts:249](./spawn-placement.ts#L249) | +| spawn-placement | STATION_DEFENCE_MIN | 1 | The fewest Vipers the station launches after you shoot at something you should not. | spawn.stationDefenceMin | [spawn-placement.ts:262](./spawn-placement.ts#L262) | +| spawn-placement | STATION_DEFENCE_SPAN | 2 | ...and the width of that draw: one or two of them. | spawn.stationDefenceSpan | [spawn-placement.ts:273](./spawn-placement.ts#L273) | +| spawn-placement | STATION_DEFENCE_STANDOFF | 500 | How far out of the slot the first one launches. | | [spawn-placement.ts:279](./spawn-placement.ts#L279) | +| spawn-placement | STATION_DEFENCE_STACK | 120 | ...and how much further out each one after it starts, so a pair does not arrive inside each other. | spawn.stationDefenceStack | [spawn-placement.ts:287](./spawn-placement.ts#L287) | +| spawn-placement | STATION_DEFENCE_JITTER | 80 | ...and the random nudge on each, so a second launch does not look like the first. | | [spawn-placement.ts:297](./spawn-placement.ts#L297) | +| spawn-placement | TRADER_ARRIVED | 900 | How near the station an arriving trader has to be to start trading. | spawn.traderArrived | [spawn-placement.ts:312](./spawn-placement.ts#L312) | +| spawn-placement | TRADER_JUMP_OUT | 2500 | How near its waypoint a departing trader has to be to jump out. | spawn.traderJumpOut | [spawn-placement.ts:328](./spawn-placement.ts#L328) | +| spawn-placement | SPAWN_PLANET_ALTITUDE | 1000 | The lowest a ship may appear above the planet's surface, measured to the ship's centre, in world units. | spawn.planetAltitude | [spawn-placement.ts:347](./spawn-placement.ts#L347) | | station | STATION_SPIN | 0.26 | How fast the station spins about its slot axis, in radians a second. | | [station.ts:19](./station.ts#L19) | | station | DODO_TECH_LEVEL | 10 | The tech level at which a system's station is the dodecahedral Dodo rather than the Coriolis, in SHOWN one-based units. | | [station.ts:32](./station.ts#L32) | | station | BOUNCE_STANDOFF | 420 | Where a fluffed docking bounces you to. | | [station.ts:48](./station.ts#L48) | diff --git a/src/constants/combat-record.ts b/src/constants/combat-record.ts index 33c8761d..3c6d6e63 100644 --- a/src/constants/combat-record.ts +++ b/src/constants/combat-record.ts @@ -40,6 +40,12 @@ export const SIX_CONE = Math.PI / 3; * passes at this threshold. */ export const PASS_CLOSE = 400; +/** + * ...and the far end of that pair: the range a ship must break back out to + * for the pass to count. The comment above explains both. + * + * @rule combatrecord.passFar + */ export const PASS_FAR = 600; /** diff --git a/src/constants/course.ts b/src/constants/course.ts index fbefe853..8e901cfc 100644 --- a/src/constants/course.ts +++ b/src/constants/course.ts @@ -195,3 +195,30 @@ export const COURSE_COLLECT_SPEED = 60; * @domain course */ export const COURSE_DOCK_HANDOVER = 1500; + +/** + * How far from a ship the scan course holds, in world units + * (docs/TODO/208 M2). + * + * A scan counts seconds while the ship is inside `SCANNER_RANGE`, which is + * 6,000, and within `WATCH_CONE` of the nose. So the hold sits well inside + * the range, and near enough that the ship fills a useful part of the cone. + * It is far enough out that a trader's own wandering does not shake it off. + * + * @rule course.watchStandoff + * @domain course + */ +export const COURSE_WATCH_STANDOFF = 1200; + +/** + * How far from its charge the escort course flies, in world units + * (docs/TODO/208 M2). + * + * The escort is safe when no hostile ship is within 3,500 units of the + * charge. A pilot who flies this close is inside that ring, and the fight + * comes to the pilot rather than to the charge. + * + * @rule course.escortStandoff + * @domain course + */ +export const COURSE_ESCORT_STANDOFF = 600; diff --git a/src/constants/encounters.ts b/src/constants/encounters.ts index d7bde30a..6ea3fd9c 100644 --- a/src/constants/encounters.ts +++ b/src/constants/encounters.ts @@ -47,7 +47,9 @@ export const TRADER_GAP_BUSY_MAX = 50; * This is therefore the exchange rate between the 1984 figure and a Harmless * clock. It is the only place the two scales meet, and that is why neither can be * re-based without the other. - */ + * + * @rule encounters.productivityPerSecond +*/ export const PRODUCTIVITY_PER_SECOND = 1200; /** diff --git a/src/constants/spawn-placement.ts b/src/constants/spawn-placement.ts index 1ea751ef..4b71402c 100644 --- a/src/constants/spawn-placement.ts +++ b/src/constants/spawn-placement.ts @@ -29,7 +29,9 @@ export const TRADER_SCATTER = 1800; * `PIRATE_SCATTER` plays for a gang. The police patrol the lane rather than guard * the slot, so a fugitive can still reach the slot to pay a fine (game/law.ts, * station.ts). - */ + * + * @rule spawn.policeScatter +*/ export const POLICE_SCATTER = 1200; /** diff --git a/src/game/course-actions.ts b/src/game/course-actions.ts index e9229c55..87c7ced4 100644 --- a/src/game/course-actions.ts +++ b/src/game/course-actions.ts @@ -24,6 +24,7 @@ import { COURSE_KEYS, COURSE_SKIP_KEY, COURSE_TOGGLE_KEY } from './bindings.ts'; import { hostilesNear, hostilesOnScanner } from './hostility.ts'; import { SKIP_SPEED } from '../constants/course.ts'; import { SCANNER_RANGE } from '../constants/console.ts'; +import { missionCourse } from './mission-course.ts'; /** * What the course buttons show in flight: the list, or the course under way. @@ -200,7 +201,9 @@ export class CourseActions { // The sky is cleared while the ship is docked (courses.ts). sky: situation === 'launch' ? [] : s.world.npcs.filter((n) => n.state.alive).map((n) => n.role), - mission: null, + mission: situation === 'launch' ? null + : missionCourse(s.commander.missions, s.commander.systemIndex, + s.world.npcs, s.world.cargo.items)?.what ?? null, done: new Set(s.session.coursesDone), threat: situation === 'launch' ? null : this.threat(), loot: situation === 'launch' ? 0 : s.world.cargo.items diff --git a/src/game/course-pilot.ts b/src/game/course-pilot.ts index 273802f7..bd747f2a 100644 --- a/src/game/course-pilot.ts +++ b/src/game/course-pilot.ts @@ -41,9 +41,10 @@ import { SLOT_SPEED_LIMIT } from '../constants/docking.ts'; import { COURSE_ARRIVE_BRAKE, COURSE_ARRIVE_TOLERANCE, COURSE_DERELICT_STANDOFF, COURSE_HERMIT_SPEED, COURSE_HERMIT_STANDOFF, COURSE_PLANET_CLEARANCE, - COURSE_COLLECT_SPEED, COURSE_RUN_REACH, COURSE_SKIM_DISTANCE, COURSE_TORUS_CONE, - COURSE_TORUS_DROP, + COURSE_COLLECT_SPEED, COURSE_ESCORT_STANDOFF, COURSE_RUN_REACH, COURSE_SKIM_DISTANCE, + COURSE_TORUS_CONE, COURSE_TORUS_DROP, COURSE_WATCH_STANDOFF, } from '../constants/course.ts'; +import type { MissionHow } from './mission-course.ts'; /** What the course pilot reads for one frame. A flat view, so a test needs no world. */ export interface CourseView { @@ -69,6 +70,12 @@ export interface CourseView { readonly threats: readonly THREE.Vector3[]; /** where the cargo adrift within scanner range is, nearest first */ readonly loot: readonly THREE.Vector3[]; + /** + * What the mission asks for here (docs/TODO/208 M1): where its target is, + * how fast it moves, and what the ship does about it. Null when no live leg + * has work in this system. + */ + readonly mission: { readonly at: THREE.Vector3; readonly speed: number; readonly how: MissionHow } | null; /** the docking computer already has the ship */ readonly dcEngaged: boolean; /** @@ -145,6 +152,17 @@ export class CoursePilot { // A rock is fought, not flown to: `flight-instruments.ts` picks the next // one as the target, and the computer's aim lines the ship up on it. case 'mine': return IDLE; + case 'mission': { + const m = v.mission; + if (m === null) return ended(); + // A hunt is a fight: `flight-instruments.ts` picks the ship, and the + // computer's aim flies it, as it does for a rock. + if (m.how === 'fight') return IDLE; + const standoff = m.how === 'hold' ? COURSE_WATCH_STANDOFF + : m.how === 'escort' ? COURSE_ESCORT_STANDOFF : 0; + const speed = m.how === 'scoop' ? COURSE_COLLECT_SPEED : m.speed; + return { ...this.arrive(v, { target: m.at, standoff, speed }, dt), done: false }; + } default: return IDLE; } } diff --git a/src/game/flight-instruments.ts b/src/game/flight-instruments.ts index 3a0d5e46..e4574e40 100644 --- a/src/game/flight-instruments.ts +++ b/src/game/flight-instruments.ts @@ -26,6 +26,7 @@ import type { CourseKind } from './courses.ts'; import { MAX_FUEL } from '../constants/commander.ts'; import { hostilesOnScanner } from './hostility.ts'; import { pickTarget, pickedTarget } from './targets.ts'; +import { missionCourse } from './mission-course.ts'; import { SCANNER_RANGE } from '../constants/console.ts'; import { DOCK_COMPUTER_RANGE } from '../constants/docking-computer.ts'; import { COURSE_DOCK_HANDOVER } from '../constants/course.ts'; @@ -152,6 +153,17 @@ export class Instruments { this.endCourse('mine'); return null; } + // A mission's own work here, and what the ship does about it + // (docs/TODO/208 M1). A hunt is a fight, so the ship it names is picked + // as the target, exactly as a rock is. + const mission = s.course !== 'mission' ? null + : missionCourse(this.state.commander.missions, this.state.commander.systemIndex, + w.npcs, w.cargo.items); + if (mission?.how === 'fight' && mission.ship !== null + && pickedTarget(w.npcs) !== mission.ship) { + pickTarget(w.npcs, mission.ship); + s.handFlown = false; + } const live = (role: string) => w.npcs.find((n) => n.state.alive && n.role === role) ?? null; const derelict = live('generation'); const step = this.coursePilot.step({ @@ -176,6 +188,8 @@ export class Instruments { threats: hostilesOnScanner(w.npcs, p.position, this.state.commander.legalStatus, p.position.distanceTo(w.station.position)).map((n) => n.object.position), dcEngaged: s.dcEngaged, + mission: mission === null ? null + : { at: mission.at, speed: mission.speed, how: mission.how }, handOverRange: this.state.commander.equipment.dockingComputer ? DOCK_COMPUTER_RANGE : COURSE_DOCK_HANDOVER, }, dt); diff --git a/src/game/mission-course.ts b/src/game/mission-course.ts new file mode 100644 index 00000000..449ec59e --- /dev/null +++ b/src/game/mission-course.ts @@ -0,0 +1,96 @@ +// What a mission asks the ship to do here, as a course (docs/TODO/208 M1). +// +// A mission was a line on a screen and a line on the console. It is a button +// over the view now: the first row of the course list, in the words of the +// job. Chris asked for that on 2026-09-11: *"the missions are becoming much +// more important - they need to feel part of the game"*. +// +// It reads the live legs (`missions/queries.ts`) and the sky. It matches the +// leg's tag to the ship or the canister that the world spawned for it +// (`spawning.ts`). What comes back is the words for the row, and what the +// ship must DO about it. +// +// FOUR SHAPES cover the five verbs that need a flight: +// +// - a HUNT is a fight, so the course picks the ship and the aim flies it; +// - a SCAN is a hold: stay near it, and keep the nose on it; +// - an ESCORT flies alongside, and the fight comes to the pilot; +// - a RECOVER and a RESCUE are a scoop. +// +// The other three verbs need no course of their own. A deliver, a smuggle +// and an ambush all end at the station, and the station course flies there. + +import type * as THREE from 'three'; +import type { NpcShip } from './npc.ts'; +import type { Canister } from './cargo.ts'; +import { liveLegs } from '../missions/queries.ts'; +import type { MissionState, Skeleton } from '../missions/model.ts'; +import { SKELETONS } from '../missions/skeletons/index.ts'; + +/** What the ship does about this leg. */ +export type MissionHow = 'fight' | 'hold' | 'escort' | 'scoop'; + +/** The mission's course: its words, what to do, and what to do it to. */ +export interface MissionCourse { + /** the row's words, in the job's own terms */ + readonly what: string; + readonly how: MissionHow; + /** the ship the leg is about, or null when the leg is about a canister */ + readonly ship: NpcShip | null; + readonly at: THREE.Vector3; + /** how fast that target is moving, so a hold and an escort can match it */ + readonly speed: number; +} + +/** + * What this system's live leg asks for, or null when nothing here does. + * + * The first live leg that has work in this system wins. A commander with two + * jobs in one system flies them one at a time. + */ +export function missionCourse( + st: MissionState, + here: number, + npcs: readonly NpcShip[], + items: readonly Canister[], + skeletons: readonly Skeleton[] = SKELETONS, +): MissionCourse | null { + for (const { live, leg } of liveLegs(st, skeletons)) { + if (live.target !== here || live.tag === null) continue; + const ship = npcs.find((n) => n.state.alive && n.state.missionTag === live.tag) ?? null; + const item = items.find((c) => c.missionTag === live.tag) ?? null; + const name = ship?.object.name.toUpperCase() ?? ''; + switch (leg.verb.kind) { + case 'hunt': + if (ship) { + return { what: `HUNT THE ${name}`, how: 'fight', ship, at: ship.object.position, speed: ship.state.speed }; + } + break; + case 'scan': + if (ship) { + return { what: `SCAN THE ${name}`, how: 'hold', ship, at: ship.object.position, speed: ship.state.speed }; + } + break; + case 'escort': + if (ship) { + return { what: `ESCORT THE ${name}`, how: 'escort', ship, at: ship.object.position, speed: ship.state.speed }; + } + break; + case 'recover': + if (item) { + return { what: 'RECOVER THE CARGO', how: 'scoop', ship: null, at: item.object.position, speed: 0 }; + } + break; + case 'rescue': + if (item) { + return { what: 'PICK UP THE SURVIVOR', how: 'scoop', ship: null, at: item.object.position, speed: 0 }; + } + break; + default: + // deliver, smuggle and ambush all end at the station, and the station + // course flies there. + break; + } + } + return null; +} diff --git a/src/missions/queries.ts b/src/missions/queries.ts index 09846673..f4fe48bd 100644 --- a/src/missions/queries.ts +++ b/src/missions/queries.ts @@ -14,8 +14,12 @@ import { verbJob, verbNeedsShip } from './verbs/registry.ts'; import { SKELETONS, skeletonById } from './skeletons/index.ts'; import { fillSlots, legPay, lineSlots } from './text.ts'; -function liveLegs( - st: MissionState, from: readonly Skeleton[], +/** + * Every live mission with the leg it is on. The game asks it too, to know + * what a commander is here to do (docs/TODO/208 M1). + */ +export function liveLegs( + st: MissionState, from: readonly Skeleton[] = SKELETONS, ): { live: LiveMission; leg: Leg }[] { const out: { live: LiveMission; leg: Leg }[] = []; for (const live of st.live) { diff --git a/test/course-pilot.test.ts b/test/course-pilot.test.ts index 754b1b95..91892e6d 100644 --- a/test/course-pilot.test.ts +++ b/test/course-pilot.test.ts @@ -43,6 +43,7 @@ const view = (station: THREE.Vector3, over: Partial = {}): CourseVie tankFull: false, threats: [], loot: [], + mission: null, dcEngaged: false, handOverRange: DOCK_COMPUTER_RANGE, ...over, diff --git a/test/mission-courses.test.ts b/test/mission-courses.test.ts new file mode 100644 index 00000000..a0dc2670 --- /dev/null +++ b/test/mission-courses.test.ts @@ -0,0 +1,121 @@ +// Every kind of mission has a way to fly it (docs/TODO/208 M1 and M2). +// +// Chris asked for this on 2026-09-11: *"the missions are becoming much more +// important - they need to feel part of the game"*. So a live job is the +// first button over the view, in its own words, and the ship flies it. +// +// These fly the real side jobs in a real headless Game. Each one is accepted +// through the mission machine, moved to the system the ship is in, and then +// flown by its button alone. The pilot's own part is the trigger, which the +// hunt holds down. + +import { Game } from '../src/game/game.ts'; +import { headlessShell } from '../src/engine/shell.ts'; +import { withoutSaving } from '../src/game/storage.ts'; +import { seedWorld } from '../src/game/rng.ts'; +import { runMissions } from '../src/game/mission-bridge.ts'; +import { missionCourse } from '../src/game/mission-course.ts'; +import { COURSE_KEYS } from '../src/game/bindings.ts'; +import { keymap } from '../src/engine/keymap.ts'; +import { check, dismissBriefing, eq } from './harness.ts'; + +console.log('\nthe missions, flown by their own button'); + +/** + * A commander at the witchpoint of the system its live job is in, with the + * job's target in the sky and nothing else. + */ +function onTheJob(skeleton: string, seed: number): Game { + const g = withoutSaving(() => { + seedWorld(seed); + const game = new Game(() => headlessShell()); + dismissBriefing(game); + return game; + }).value; + const c = g.state.commander; + c.equipment.scoops = true; + // A side job is on about a third of the worlds' boards (missions/offers.ts). + // So the commander stands where this one is offered. + for (let world = 0; world < 256 && c.missions.live.length === 0; world++) { + c.systemIndex = world; + withoutSaving(() => runMissions(c, { kind: 'accept', skeleton }, g.state.systems, () => 0.5)); + } + const live = c.missions.live[0]; + if (!live) throw new Error(`no world offers ${skeleton}`); + live.target = c.systemIndex; // its work is here, so the arrival spawns it + withoutSaving(() => { g.launch(); }); + withoutSaving(() => { for (let f = 0, at = 0; f < 400; f++) g.step(1 / 60, at += 1 / 60); }); + withoutSaving(() => { g.arriveInSystem(); }); + withoutSaving(() => { for (let f = 0, at = 0; f < 400; f++) g.step(1 / 60, at += 1 / 60); }); + // Only the job's own target stays: no traffic to start a fight of its own. + for (const n of g.state.world.npcs) if (n.state.missionTag === null) n.state.alive = false; + return g; +} + +/** Fly the mission button until `until`, or the seconds run out. */ +function fly(g: Game, seconds: number, until: () => boolean, trigger = false): number { + const fire = keymap().fire[0]; + let flown = 0; + withoutSaving(() => { + g.input.injectPress(COURSE_KEYS.mission); + for (let f = 0; f < seconds * 60; f++) { + if (trigger) g.input.press(fire); + g.step(1 / 60, 100 + f / 60); + flown = f / 60; + if (until() || g.mode === 'dead') break; + } + }); + g.input.release(fire); + return flown; +} + +/** The words the mission's button shows now. */ +const words = (g: Game): string | null => missionCourse( + g.state.commander.missions, g.state.commander.systemIndex, + g.state.world.npcs, g.state.world.cargo.items)?.what ?? null; + +{ + const g = onTheJob('side-hunt', 20_260_940); + check('a hunt names the ship on its button', words(g)?.startsWith('HUNT THE ') === true, `${words(g)}`); + // The hunt's own ship is hostile, so RUN FOR IT leads the list, as + // docs/TODO/206 M5 decided. The mission is the row under it. + check('...and the mission is on the list, under the way out', + g.coursePanel()?.rows?.some((r) => r.kind === 'mission') === true, + g.coursePanel()?.rows?.map((r) => r.kind).join() ?? 'no list'); + const took = fly(g, 240, () => g.state.commander.missions.live.length === 0 + || g.state.commander.missions.live[0]?.leg !== 'hunt', true); + check('...and the ship hunts it down, with the pilot holding the trigger', + g.state.commander.missions.live[0]?.leg !== 'hunt', `after ${took.toFixed(0)}s`); +} + +{ + const g = onTheJob('side-scan', 20_260_941); + check('a scan names the ship on its button', words(g)?.startsWith('SCAN THE ') === true, `${words(g)}`); + const took = fly(g, 300, () => g.state.commander.missions.live[0]?.leg !== 'watch'); + check('...and the ship holds it in view until the scan is done', + g.state.commander.missions.live[0]?.leg !== 'watch', `after ${took.toFixed(0)}s`); +} + +{ + const g = onTheJob('side-recover', 20_260_942); + eq('a recover says what it is', words(g), 'RECOVER THE CARGO'); + const took = fly(g, 240, () => g.state.commander.missions.live[0]?.leg !== 'fetch' + && g.state.commander.missions.live.length > 0); + check('...and the ship scoops the canister', + g.state.commander.missions.live[0]?.leg !== 'fetch', `after ${took.toFixed(0)}s`); +} + +{ + const g = onTheJob('side-rescue', 20_260_943); + eq('a rescue says what it is', words(g), 'PICK UP THE SURVIVOR'); + const took = fly(g, 240, () => (g.state.commander.missions.live[0]?.progress ?? 0) > 0); + check('...and the ship scoops the pod', + (g.state.commander.missions.live[0]?.progress ?? 0) > 0, `after ${took.toFixed(0)}s`); +} + +{ + const g = onTheJob('side-deliver', 20_260_944); + eq('a delivery needs no button of its own, because it ends at the station', words(g), null); + check('...and the station is on the list', + g.coursePanel()?.rows?.some((r) => r.kind === 'station') === true); +} diff --git a/test/run.ts b/test/run.ts index ce87f4b9..7fb863b3 100644 --- a/test/run.ts +++ b/test/run.ts @@ -82,6 +82,7 @@ import './fight-buttons.test.ts'; import './run-and-offers.test.ts'; import './mine-and-collect.test.ts'; import './dock-trial.test.ts'; +import './mission-courses.test.ts'; import './world.test.ts'; import './docking.test.ts'; import './docking-computer.test.ts'; From 61dc6edf12cb401945167a3e886a7332d8771d18 Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Fri, 11 Sep 2026 23:59:32 +0100 Subject: [PATCH 031/100] docs/TODO/208 M3: the scoop rows cannot trap a pilot, and a hunt cannot stall A recover or a rescue row says NEEDS FUEL SCOOPS without them, and the pick refuses, so the course never flies into a canister that would break on the hull. Two faults in the hunt are mended. A tagged ship wrecked by somebody else sends escortLost, which the hunt ignored, so the leg stayed live with no ship left to kill; it ends the hunt now. A tagged ship that leaves while it flees sends fled rather than escaped, which gives the three arcs' own branch its first sender, and stops a side hunt failing when its target runs. 5,835 assertions, from 5,831. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- ...very-kind-of-mission-has-a-way-to-fly-it.md | 16 ++++++++++++++++ src/game/course-actions.ts | 18 +++++++++++++++--- src/game/courses.ts | 9 ++++++--- src/game/world-step.ts | 11 ++++++++--- src/missions/verbs/hunt.ts | 12 +++++++++++- test/courses.test.ts | 12 ++++++++---- test/mission-courses.test.ts | 18 ++++++++++++++++++ test/mission-verbs.test.ts | 6 ++++++ 8 files changed, 88 insertions(+), 14 deletions(-) diff --git a/docs/TODO/208-every-kind-of-mission-has-a-way-to-fly-it.md b/docs/TODO/208-every-kind-of-mission-has-a-way-to-fly-it.md index 36e1f963..4e266609 100644 --- a/docs/TODO/208-every-kind-of-mission-has-a-way-to-fly-it.md +++ b/docs/TODO/208-every-kind-of-mission-has-a-way-to-fly-it.md @@ -163,3 +163,19 @@ Evidence: flown by its button alone. A side job is on about a third of the worlds' boards, so the test walks the galaxy until it finds one that offers it. - **The suite has 5,831 assertions,** from 5,820. + +### M3 + +- **A scoop row says when the ship cannot fly it.** A recover or a rescue + needs fuel scoops. Without them the canister breaks on the hull, and the + leg hears nothing. The row says NEEDS FUEL SCOOPS, and the pick refuses, + so the course never flies into it. +- **A hunted ship wrecked by somebody else ends the hunt.** The world sends + `escortLost` for a tagged ship wrecked with credit to nobody, and the hunt + verb ignored it. The leg stayed live with no ship left in the galaxy to + kill. It takes it as destroyed now. A branch that paid less for another's + kill would be a third outcome, and no skeleton has one. +- **The `fled` trigger has a sender at last.** Three arcs have a branch for a + hunted ship that runs, and nothing ever sent the word. A tagged ship that + leaves while it flees counts as fled. Any other one jumped out, and it + escaped. So a side hunt no longer fails when its target runs. diff --git a/src/game/course-actions.ts b/src/game/course-actions.ts index 87c7ced4..995e5903 100644 --- a/src/game/course-actions.ts +++ b/src/game/course-actions.ts @@ -201,9 +201,7 @@ export class CourseActions { // The sky is cleared while the ship is docked (courses.ts). sky: situation === 'launch' ? [] : s.world.npcs.filter((n) => n.state.alive).map((n) => n.role), - mission: situation === 'launch' ? null - : missionCourse(s.commander.missions, s.commander.systemIndex, - s.world.npcs, s.world.cargo.items)?.what ?? null, + mission: situation === 'launch' ? null : this.missionRow(), done: new Set(s.session.coursesDone), threat: situation === 'launch' ? null : this.threat(), loot: situation === 'launch' ? 0 : s.world.cargo.items @@ -211,6 +209,20 @@ export class CourseActions { }; } + /** + * The live leg's row: its words, and what stops the ship from flying it. A + * scoop needs fuel scoops, and without them the canister breaks on the hull + * (docs/TODO/208 M3). So the row says so, and the pick refuses. + */ + private missionRow(): CourseWorld['mission'] { + const s = this.state(); + const m = missionCourse(s.commander.missions, s.commander.systemIndex, + s.world.npcs, s.world.cargo.items); + if (m === null) return null; + const needsScoops = m.how === 'scoop' && !s.commander.equipment.scoops; + return { what: m.what, why: needsScoops ? 'NEEDS FUEL SCOOPS' : null }; + } + /** The fastest hostile ship on the scanner, against the ship's own speed. */ private threat(): CourseWorld['threat'] { const s = this.state(); diff --git a/src/game/courses.ts b/src/game/courses.ts index 927575f8..2a4f0229 100644 --- a/src/game/courses.ts +++ b/src/game/courses.ts @@ -86,8 +86,11 @@ export interface CourseWorld { readonly witchspace: boolean; /** the role of every ship and rock in the sky. Empty at a launch */ readonly sky: readonly NpcRole[]; - /** the objective's words, when a live leg has its target in this system */ - readonly mission: string | null; + /** + * The live leg's own row, when a leg has work in this system: its words, + * and what stops the ship from flying it (docs/TODO/208). + */ + readonly mission: { readonly what: string; readonly why: string | null } | null; /** the courses this visit already finished, so they leave the list */ readonly done: ReadonlySet; /** @@ -115,7 +118,7 @@ export function courseList(w: CourseWorld): Course[] { return [ runRow(w), w.mission !== null && !w.done.has('mission') - ? { kind: 'mission', what: w.mission, why: null } as const : null, + ? { kind: 'mission', what: w.mission.what, why: w.mission.why } as const : null, w.witchspace ? null : { kind: 'station', what: 'FLY TO THE STATION', why: null } as const, present(w, 'generation', 'derelict') ? { kind: 'derelict', what: 'INVESTIGATE THE DERELICT SHIP', why: null } as const : null, diff --git a/src/game/world-step.ts b/src/game/world-step.ts index a18ab0d1..6c6938a2 100644 --- a/src/game/world-step.ts +++ b/src/game/world-step.ts @@ -454,10 +454,15 @@ export class WorldStep { { count: 10, speed: 120, duration: 0.7 }); } world.despawn(npc); - // A tagged ship that jumped out escaped its hunt. The machine decides - // whether the leg minds (`canEscape`), and says so in this stream. + // A tagged ship that leaves is gone from its leg, and HOW it left + // decides what the leg makes of it (docs/TODO/208 M3). A ship that + // ran from the commander FLED. Any other one jumped out, and escaped. + // Three arcs have a branch for a ship that flees, and nothing sent + // that word until now. The machine says what each costs. if (npc.state.missionTag !== null && !npc.state.docked) { - out.push(...runMissions(s.commander, { kind: 'escaped', tag: npc.state.missionTag })); + out.push(...runMissions(s.commander, { + kind: npc.state.fleeing ? 'fled' : 'escaped', tag: npc.state.missionTag, + })); } continue; } diff --git a/src/missions/verbs/hunt.ts b/src/missions/verbs/hunt.ts index 07fcf61f..a4097280 100644 --- a/src/missions/verbs/hunt.ts +++ b/src/missions/verbs/hunt.ts @@ -3,6 +3,14 @@ // The leg's `tag` is the ship's. A `destroyed` input with another tag is some // other ship, and it means nothing here. That one comparison is what stops a // second hunt from claiming the first hunt's kill. +// +// A HUNTED SHIP CAN DIE WITHOUT THE COMMANDER (docs/TODO/208 M3). A pirate +// takes it, or it flies into a rock. The world sends `escortLost` for a +// tagged ship wrecked with credit to nobody, and the hunt ignored it until +// now. The leg then stayed live with no ship left in the galaxy to kill. The +// ship is gone either way, so the hunt takes it as destroyed. A branch that +// paid less for another's kill would be a third outcome, and no skeleton +// has one. import type { VerbModule } from './verb.ts'; @@ -10,7 +18,9 @@ export const hunt: VerbModule = (ctx, input) => { const verb = ctx.leg.verb; if (verb.kind !== 'hunt') return null; if (!('tag' in input) || input.tag !== ctx.live.tag) return null; - if (input.kind === 'destroyed') return { trigger: 'targetDestroyed' }; + if (input.kind === 'destroyed' || input.kind === 'escortLost') { + return { trigger: 'targetDestroyed' }; + } if (input.kind === 'escaped' && verb.canEscape) return { trigger: 'targetEscaped' }; if (input.kind === 'fled') return { trigger: 'targetFled' }; return null; diff --git a/test/courses.test.ts b/test/courses.test.ts index 2de5d759..cfb54ef5 100644 --- a/test/courses.test.ts +++ b/test/courses.test.ts @@ -43,7 +43,7 @@ const row = (w: CourseWorld, kind: CourseKind) => courseList(w).find((c) => c.ki // --- the order --------------------------------------------------------------- same('in flight, the list runs mission, station, derelict, rocks, hermit, star, jump', - kinds(world({ mission: 'HUNT THE KRAIT' })), + kinds(world({ mission: { what: 'HUNT THE KRAIT', why: null } })), ['mission', 'station', 'derelict', 'mine', 'hermit', 'skim', 'jump']); same('at a launch, the list runs jump, rocks, star', kinds(world({ situation: 'launch', sky: [] })), ['jump', 'mine', 'skim']); @@ -63,10 +63,14 @@ check('a jump under way is not a course to pick', // --- the mission ------------------------------------------------------------- same('a live leg with its target here leads the list, in its own words', - courseList(world({ mission: 'SCAN THE COBRA' }))[0], { kind: 'mission', what: 'SCAN THE COBRA', why: null }); + courseList(world({ mission: { what: 'SCAN THE COBRA', why: null } }))[0], + { kind: 'mission', what: 'SCAN THE COBRA', why: null }); +eq('...and it says when the ship cannot do the job', + row(world({ mission: { what: 'RECOVER THE CARGO', why: 'NEEDS FUEL SCOOPS' } }), 'mission')?.why, + 'NEEDS FUEL SCOOPS'); check('...no leg here, no row', !kinds(world()).includes('mission')); -check('...and a finished one leaves', !kinds(world({ mission: 'X', done: new Set(['mission']) })).includes('mission')); -check('...and no mission row at a launch', !kinds(world({ situation: 'launch', sky: [], mission: 'X' })).includes('mission')); +check('...and a finished one leaves', !kinds(world({ mission: { what: 'X', why: null }, done: new Set(['mission']) })).includes('mission')); +check('...and no mission row at a launch', !kinds(world({ situation: 'launch', sky: [], mission: { what: 'X', why: null } })).includes('mission')); // --- the station ------------------------------------------------------------- check('in flight, the station is a course', kinds(world()).includes('station')); diff --git a/test/mission-courses.test.ts b/test/mission-courses.test.ts index a0dc2670..0312860b 100644 --- a/test/mission-courses.test.ts +++ b/test/mission-courses.test.ts @@ -119,3 +119,21 @@ const words = (g: Game): string | null => missionCourse( check('...and the station is on the list', g.coursePanel()?.rows?.some((r) => r.kind === 'station') === true); } + +console.log('\na hunted ship that runs has fled, not escaped'); +{ + // Before docs/TODO/208 M3 the world sent `escaped` whichever way a tagged + // ship left, and a side hunt fails on that. A ship that ran from the + // commander has fled, and three arcs have a branch for it. + const flown = (fleeing: boolean): string | undefined => { + const g = onTheJob('side-hunt', 20_260_945); + const ship = g.state.world.npcs.find((n) => n.state.missionTag !== null); + if (!ship) throw new Error('the hunt spawned no ship'); + ship.state.fleeing = fleeing; + ship.state.wantsDespawn = true; + withoutSaving(() => g.step(1 / 60, 200)); + return g.state.commander.missions.done['side-hunt']; + }; + eq('a tagged ship that jumps out escapes, and the side hunt fails', flown(false), 'fail'); + eq('...and one that runs has fled, which a side hunt does not answer', flown(true), undefined); +} diff --git a/test/mission-verbs.test.ts b/test/mission-verbs.test.ts index ebada39b..42601288 100644 --- a/test/mission-verbs.test.ts +++ b/test/mission-verbs.test.ts @@ -190,6 +190,12 @@ console.log('\nescort and scan, through the machine'); eq('the side hunt pays on the kill', paid(stepMissions(hst, { kind: 'destroyed', tag: htag }, hctx).effects), SIDE_JOB_PAY.hunt); eq('...and a target that jumps out fails it', stepMissions(hst, { kind: 'escaped', tag: htag }, hctx).state.done[SIDE_HUNT.id], 'fail'); + // A hunted ship can die without the commander: a pirate takes it, or it + // flies into a rock. The world sends `escortLost` for that, and the hunt + // ignored it until docs/TODO/208 M3. The leg then stayed live with no ship + // left to kill. + eq('a target wrecked by somebody else still ends the hunt', + paid(stepMissions(hst, { kind: 'escortLost', tag: htag }, hctx).effects), SIDE_JOB_PAY.hunt); } console.log('\nescort, through a real world step'); From 9ecbe593656419ec7d1899ef4a2c86e98cd1389f Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Sat, 12 Sep 2026 00:02:50 +0100 Subject: [PATCH 032/100] docs/TODO/208 M4: a smuggling run slips past the police SLIP PAST THE POLICE is the smuggling leg's own row. It flies the station course on a line wide of every policeman in the way, at the warning band of 4,400 units, which is outside the 2,600 a policeman reads a hold at. One rule holds both detours now: sidestep aims beside a thing in the way, on the same side as the line, and half as far again. The planet's detour uses it too. A leg with no tagged ship is still a leg, which the first draft of the lookup skipped. 5,841 assertions, from 5,835. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- ...ery-kind-of-mission-has-a-way-to-fly-it.md | 14 +++ src/constants/CATALOG.md | 35 ++++---- src/constants/course.ts | 14 +++ src/game/course-actions.ts | 2 +- src/game/course-pilot.ts | 88 +++++++++++++++---- src/game/flight-instruments.ts | 6 +- src/game/mission-course.ts | 27 ++++-- test/course-pilot.test.ts | 1 + test/mission-courses.test.ts | 38 +++++++- 9 files changed, 180 insertions(+), 45 deletions(-) diff --git a/docs/TODO/208-every-kind-of-mission-has-a-way-to-fly-it.md b/docs/TODO/208-every-kind-of-mission-has-a-way-to-fly-it.md index 4e266609..2bbf5462 100644 --- a/docs/TODO/208-every-kind-of-mission-has-a-way-to-fly-it.md +++ b/docs/TODO/208-every-kind-of-mission-has-a-way-to-fly-it.md @@ -179,3 +179,17 @@ Evidence: hunted ship that runs, and nothing ever sent the word. A tagged ship that leaves while it flees counts as fled. Any other one jumped out, and it escaped. So a side hunt no longer fails when its target runs. + +### M4 + +- **The smuggling run is a course of its own: SLIP PAST THE POLICE.** It flies + the station course on a line wide of every policeman in the way, at the + warning band of 4,400 units. That is outside the 2,600 units a policeman + reads a hold at, with a margin. +- **One rule holds both detours.** `sidestep` aims beside a thing in the way, + on the same side as the line, and half as far again. The planet and the + police both use it, and a target that is itself the nearest point needs no + detour. +- **A leg without a tag is still a leg.** The lookup skipped every leg with no + tagged ship, and a smuggling run has none. It asks for a way past the + police, and nothing in the sky is its own. diff --git a/src/constants/CATALOG.md b/src/constants/CATALOG.md index 49d03612..c540c9cb 100644 --- a/src/constants/CATALOG.md +++ b/src/constants/CATALOG.md @@ -2,7 +2,7 @@ -441 exported constants. Regenerate with `npm run generate:constants`; +442 exported constants. Regenerate with `npm run generate:constants`; search names, meanings and values with `npm run constants:find -- ""`. | Domain | Symbol | Literal / expression | Purpose | Rule ID | Source | @@ -114,22 +114,23 @@ search names, meanings and values with `npm run constants:find -- ""`. | contracts | CONTRACT_RANGE | MAX_FUEL | How far away a contract may send you, in tenths of a light year: exactly as far as a full tank reaches. | | [contracts.ts:27](./contracts.ts#L27) | | contracts | PASSENGER_BERTH_TONNES | 2 | What one passenger costs the hold, in tonnes. | contracts.passengerBerthTonnes | [contracts.ts:51](./contracts.ts#L51) | | contracts | SMUGGLE_DELIVERY_NOTORIETY | 0.06 | How loudly a delivered smuggling run is talked about, per tonne landed. | contracts.smuggleDeliveryNotoriety | [contracts.ts:81](./contracts.ts#L81) | -| course | COURSE_TORUS_CONE | 0.1 | How far off the nose the target may sit, in radians, before the course pilot engages the torus drive. | course.torusCone | [course.ts:31](./course.ts#L31) | -| course | COURSE_TORUS_DROP | TORUS_MULTIPLIER * PLAYER_FLIGHT.maxSpeed * 2.5 | How far from its target the course pilot drops the torus drive, in world units, before an arrival. | | [course.ts:44](./course.ts#L44) | -| course | COURSE_ARRIVE_BRAKE | 0.7 | The share of the ship's thrust that an arrival plans to brake with. | course.arriveBrake | [course.ts:56](./course.ts#L56) | -| course | COURSE_ARRIVE_TOLERANCE | 75 | How near its standoff the ship must be to count as arrived, in world units. | course.arriveTolerance | [course.ts:66](./course.ts#L66) | -| course | COURSE_DERELICT_STANDOFF | GENERATION_CARGO_SCATTER + 400 | Where the derelict course stops, as a distance from the generation ship's centre, in world units. | | [course.ts:79](./course.ts#L79) | -| course | COURSE_HERMIT_STANDOFF | 240 | Where the hermit course stops, as a distance from the rock's centre, in world units. | course.hermitStandoff | [course.ts:92](./course.ts#L92) | -| course | COURSE_SKIM_DISTANCE | 65_000 | The hold distance of the skim course, from the centre of the star, in world units. | course.skimDistance | [course.ts:107](./course.ts#L107) | -| course | COURSE_PLANET_CLEARANCE | MASS_LOCK_PLANET_ALTITUDE * 1.25 | How high above the planet's surface a course keeps its line, in world units. | | [course.ts:119](./course.ts#L119) | -| course | COURSE_HERMIT_SPEED | HERMIT_DOCK_SPEED / 2 | The speed at which the hermit course arrives, in world units a second. | | [course.ts:129](./course.ts#L129) | -| course | SKIP_SPEED | 8 | How much faster the world runs under the fast forward button, as a count of fixed steps in one screen frame (docs/TODO/205 M7). | course.skipSpeed | [course.ts:145](./course.ts#L145) | -| course | RUN_CLOSE_MARGIN | 50 | Below this lead in top speed, in world units a second, the run row says the ship is only a little faster (docs/TODO/206 M5). | course.runCloseMargin | [course.ts:159](./course.ts#L159) | -| course | COURSE_RUN_REACH | 50_000 | How far ahead the run course aims, in world units, on the line away from the hostile ships (docs/TODO/206 M5). | course.runReach | [course.ts:169](./course.ts#L169) | -| course | COURSE_COLLECT_SPEED | 60 | How fast the collect course flies onto a canister, in world units a second (docs/TODO/206 M6). | course.collectSpeed | [course.ts:183](./course.ts#L183) | -| course | COURSE_DOCK_HANDOVER | 1500 | How far from the station the station course hands the ship to the pilot, in world units (docs/TODO/207 M1). | course.dockHandover | [course.ts:197](./course.ts#L197) | -| course | COURSE_WATCH_STANDOFF | 1200 | How far from a ship the scan course holds, in world units (docs/TODO/208 M2). | course.watchStandoff | [course.ts:211](./course.ts#L211) | -| course | COURSE_ESCORT_STANDOFF | 600 | How far from its charge the escort course flies, in world units (docs/TODO/208 M2). | course.escortStandoff | [course.ts:224](./course.ts#L224) | +| course | COURSE_TORUS_CONE | 0.1 | How far off the nose the target may sit, in radians, before the course pilot engages the torus drive. | course.torusCone | [course.ts:32](./course.ts#L32) | +| course | COURSE_TORUS_DROP | TORUS_MULTIPLIER * PLAYER_FLIGHT.maxSpeed * 2.5 | How far from its target the course pilot drops the torus drive, in world units, before an arrival. | | [course.ts:45](./course.ts#L45) | +| course | COURSE_ARRIVE_BRAKE | 0.7 | The share of the ship's thrust that an arrival plans to brake with. | course.arriveBrake | [course.ts:57](./course.ts#L57) | +| course | COURSE_ARRIVE_TOLERANCE | 75 | How near its standoff the ship must be to count as arrived, in world units. | course.arriveTolerance | [course.ts:67](./course.ts#L67) | +| course | COURSE_DERELICT_STANDOFF | GENERATION_CARGO_SCATTER + 400 | Where the derelict course stops, as a distance from the generation ship's centre, in world units. | | [course.ts:80](./course.ts#L80) | +| course | COURSE_HERMIT_STANDOFF | 240 | Where the hermit course stops, as a distance from the rock's centre, in world units. | course.hermitStandoff | [course.ts:93](./course.ts#L93) | +| course | COURSE_SKIM_DISTANCE | 65_000 | The hold distance of the skim course, from the centre of the star, in world units. | course.skimDistance | [course.ts:108](./course.ts#L108) | +| course | COURSE_PLANET_CLEARANCE | MASS_LOCK_PLANET_ALTITUDE * 1.25 | How high above the planet's surface a course keeps its line, in world units. | | [course.ts:120](./course.ts#L120) | +| course | COURSE_HERMIT_SPEED | HERMIT_DOCK_SPEED / 2 | The speed at which the hermit course arrives, in world units a second. | | [course.ts:130](./course.ts#L130) | +| course | SKIP_SPEED | 8 | How much faster the world runs under the fast forward button, as a count of fixed steps in one screen frame (docs/TODO/205 M7). | course.skipSpeed | [course.ts:146](./course.ts#L146) | +| course | RUN_CLOSE_MARGIN | 50 | Below this lead in top speed, in world units a second, the run row says the ship is only a little faster (docs/TODO/206 M5). | course.runCloseMargin | [course.ts:160](./course.ts#L160) | +| course | COURSE_RUN_REACH | 50_000 | How far ahead the run course aims, in world units, on the line away from the hostile ships (docs/TODO/206 M5). | course.runReach | [course.ts:170](./course.ts#L170) | +| course | COURSE_COLLECT_SPEED | 60 | How fast the collect course flies onto a canister, in world units a second (docs/TODO/206 M6). | course.collectSpeed | [course.ts:184](./course.ts#L184) | +| course | COURSE_DOCK_HANDOVER | 1500 | How far from the station the station course hands the ship to the pilot, in world units (docs/TODO/207 M1). | course.dockHandover | [course.ts:198](./course.ts#L198) | +| course | COURSE_WATCH_STANDOFF | 1200 | How far from a ship the scan course holds, in world units (docs/TODO/208 M2). | course.watchStandoff | [course.ts:212](./course.ts#L212) | +| course | COURSE_ESCORT_STANDOFF | 600 | How far from its charge the escort course flies, in world units (docs/TODO/208 M2). | course.escortStandoff | [course.ts:225](./course.ts#L225) | +| course | COURSE_POLICE_CLEARANCE | SCAN_WARN_RANGE | How wide of a police ship the smuggling course flies, in world units (docs/TODO/208 M4). | | [course.ts:238](./course.ts#L238) | | docking | GATE_HALF_WIDTHS | 5 | How far out the approach gate sits, in multiples of the station half-width. | docking.gateHalfWidths | [docking.ts:25](./docking.ts#L25) | | docking | TURN_IN | Math.PI / 4 | How far round from the slot axis an approach turns in, in radians. | | [docking.ts:49](./docking.ts#L49) | | docking | RUN_IN_WIDTHS | GATE_HALF_WIDTHS * 0.6 | Where the approach stops the curve and flies straight, in station half-widths. | | [docking.ts:87](./docking.ts#L87) | diff --git a/src/constants/course.ts b/src/constants/course.ts index 8e901cfc..e47782e5 100644 --- a/src/constants/course.ts +++ b/src/constants/course.ts @@ -7,6 +7,7 @@ import { HERMIT_DOCK_SPEED } from './hermit-market.ts'; import { PLAYER_FLIGHT } from './player-flight.ts'; import { MASS_LOCK_PLANET_ALTITUDE, TORUS_MULTIPLIER } from './torus.ts'; import { GENERATION_CARGO_SCATTER } from './spawn-placement.ts'; +import { SCAN_WARN_RANGE } from './law.ts'; /** * How far off the nose the target may sit, in radians, before the course @@ -222,3 +223,16 @@ export const COURSE_WATCH_STANDOFF = 1200; * @domain course */ export const COURSE_ESCORT_STANDOFF = 600; + +/** + * How wide of a police ship the smuggling course flies, in world units + * (docs/TODO/208 M4). + * + * A policeman reads a hold inside `SCAN_RANGE`, which is 2,600 units. This is + * the warning band, `SCAN_WARN_RANGE`, so the course keeps a margin outside + * the range that would end the job. It is the same rule from the other side, + * so the two cannot drift apart. + * + * @domain course + */ +export const COURSE_POLICE_CLEARANCE = SCAN_WARN_RANGE; diff --git a/src/game/course-actions.ts b/src/game/course-actions.ts index 995e5903..c62719ea 100644 --- a/src/game/course-actions.ts +++ b/src/game/course-actions.ts @@ -217,7 +217,7 @@ export class CourseActions { private missionRow(): CourseWorld['mission'] { const s = this.state(); const m = missionCourse(s.commander.missions, s.commander.systemIndex, - s.world.npcs, s.world.cargo.items); + s.world.npcs, s.world.cargo.items, s.world.station.position); if (m === null) return null; const needsScoops = m.how === 'scoop' && !s.commander.equipment.scoops; return { what: m.what, why: needsScoops ? 'NEEDS FUEL SCOOPS' : null }; diff --git a/src/game/course-pilot.ts b/src/game/course-pilot.ts index bd747f2a..3f4ac3a8 100644 --- a/src/game/course-pilot.ts +++ b/src/game/course-pilot.ts @@ -42,7 +42,7 @@ import { COURSE_ARRIVE_BRAKE, COURSE_ARRIVE_TOLERANCE, COURSE_DERELICT_STANDOFF, COURSE_HERMIT_SPEED, COURSE_HERMIT_STANDOFF, COURSE_PLANET_CLEARANCE, COURSE_COLLECT_SPEED, COURSE_ESCORT_STANDOFF, COURSE_RUN_REACH, COURSE_SKIM_DISTANCE, - COURSE_TORUS_CONE, COURSE_TORUS_DROP, COURSE_WATCH_STANDOFF, + COURSE_POLICE_CLEARANCE, COURSE_TORUS_CONE, COURSE_TORUS_DROP, COURSE_WATCH_STANDOFF, } from '../constants/course.ts'; import type { MissionHow } from './mission-course.ts'; @@ -68,6 +68,8 @@ export interface CourseView { readonly tankFull: boolean; /** where the hostile ships on the scanner are, for the run course */ readonly threats: readonly THREE.Vector3[]; + /** where the police ships within scanner range are, for the smuggling course */ + readonly police: readonly THREE.Vector3[]; /** where the cargo adrift within scanner range is, nearest first */ readonly loot: readonly THREE.Vector3[]; /** @@ -118,6 +120,7 @@ export class CoursePilot { private readonly fwd = new THREE.Vector3(); private readonly aim = new THREE.Vector3(); private readonly away = new THREE.Vector3(); + private readonly wideOf = new THREE.Vector3(); /** Forget the bank, for a new course. */ reset(): void { this.mem = freshSteerMemory(); } @@ -158,6 +161,9 @@ export class CoursePilot { // A hunt is a fight: `flight-instruments.ts` picks the ship, and the // computer's aim flies it, as it does for a rock. if (m.how === 'fight') return IDLE; + // A slip is the station course on a line wide of the police + // (docs/TODO/208 M4). It hands the ship over as that course does. + if (m.how === 'slip') return this.toStation(v, dt, m.at); const standoff = m.how === 'hold' ? COURSE_WATCH_STANDOFF : m.how === 'escort' ? COURSE_ESCORT_STANDOFF : 0; const speed = m.how === 'scoop' ? COURSE_COLLECT_SPEED : m.speed; @@ -187,7 +193,7 @@ export class CoursePilot { * the docking computer's range, hand over. The docking computer then flies * the approach and the slot, and this course asks for nothing more. */ - private toStation(v: CourseView, dt: number): CourseStep { + private toStation(v: CourseView, dt: number, wide?: THREE.Vector3): CourseStep { if (v.dcEngaged) return IDLE; // It ARRIVES at the hand-over, at the speed the slot will take // (docs/TODO/207 M1). A ship handed over at full speed has less than four @@ -198,8 +204,11 @@ export class CoursePilot { if (v.position.distanceTo(v.stationPos) <= v.handOverRange) { return { demand: null, torus: false, handOver: true, done: false }; } + // A smuggling run keeps wide of the police on the way in (M4 of 208). + const aim = wide === undefined ? v.stationPos + : clearOfPolice(v.position, v.stationPos, v.police, this.wideOf); return this.arrive(v, { - target: v.stationPos, standoff: v.handOverRange, speed: SLOT_SPEED_LIMIT, + target: aim, standoff: aim === v.stationPos ? v.handOverRange : 0, speed: SLOT_SPEED_LIMIT, }, dt); } @@ -270,12 +279,61 @@ const seg = new THREE.Vector3(); const off = new THREE.Vector3(); /** - * Where to aim, so that the line to the target clears the planet. + * Where to aim, so that the line to the target clears the planet + * (docs/TODO/205 M3). The clearance is the planet's own radius plus + * `COURSE_PLANET_CLEARANCE`, which is above the height the planet holds the + * torus drive down at. * - * It finds the nearest point of the line to the planet's centre. That point - * can be below `COURSE_PLANET_CLEARANCE`. Then it aims beside the planet, on - * the same side as the line, and half as high again. The line from there - * clears the planet, and the ship then turns onto the target. + * @returns `out`, holding the point to aim at. + */ +export function clearOfPlanet( + from: THREE.Vector3, to: THREE.Vector3, planet: THREE.Vector3, radius: number, + out: THREE.Vector3, +): THREE.Vector3 { + return sidestep(from, to, planet, radius + COURSE_PLANET_CLEARANCE, out); +} + +/** + * Where to aim, so that the line to the target keeps clear of the police + * (docs/TODO/208 M4). + * + * A police ship reads a hold inside `SCAN_RANGE`, which is 2,600 units, and + * the smuggling course must not be read. It aims wide of the nearest + * policeman in the way, at `COURSE_POLICE_CLEARANCE`, which is the warning + * band. The line from there is clear, and the ship then turns onto the + * target. Where no wide line exists, it takes the widest it can find. + */ +export function clearOfPolice( + from: THREE.Vector3, to: THREE.Vector3, police: readonly THREE.Vector3[], + out: THREE.Vector3, +): THREE.Vector3 { + let worst: { at: THREE.Vector3; miss: number } | null = null; + for (const at of police) { + const miss = distanceToSegment(from, to, at); + if (miss >= COURSE_POLICE_CLEARANCE) continue; + if (worst === null || miss < worst.miss) worst = { at, miss }; + } + return worst === null ? out.copy(to) + : sidestep(from, to, worst.at, COURSE_POLICE_CLEARANCE, out); +} + +/** How near the line from `from` to `to` passes `at`. */ +function distanceToSegment( + from: THREE.Vector3, to: THREE.Vector3, at: THREE.Vector3, +): number { + seg.subVectors(to, from); + const len2 = seg.lengthSq(); + const t = len2 > 0 ? Math.max(0, Math.min(1, off.subVectors(at, from).dot(seg) / len2)) : 0; + // The nearest point is the target itself: nothing is between. + if (t >= 1) return Infinity; + return off.copy(from).addScaledVector(seg, t).sub(at).length(); +} + +/** + * Where to aim, so that the line keeps `clear` units from one thing in the + * way. It aims beside that thing, on the same side as the line, and half as + * far again. The line from there is clear, and the ship then turns onto the + * target. * * A target that is itself the nearest point needs no detour. docs/TODO/205 M3 * found a hermit low over the planet. The line to it always counted as @@ -283,24 +341,20 @@ const off = new THREE.Vector3(); * * @returns `out`, holding the point to aim at. */ -export function clearOfPlanet( - from: THREE.Vector3, to: THREE.Vector3, planet: THREE.Vector3, radius: number, +function sidestep( + from: THREE.Vector3, to: THREE.Vector3, at: THREE.Vector3, clear: number, out: THREE.Vector3, ): THREE.Vector3 { seg.subVectors(to, from); const len2 = seg.lengthSq(); - const t = len2 > 0 ? Math.max(0, Math.min(1, off.subVectors(planet, from).dot(seg) / len2)) : 0; - // The nearest point is the target itself: the planet is not between. A - // target low over the planet is still reached, because the last of the - // line runs down to it rather than through the planet. + const t = len2 > 0 ? Math.max(0, Math.min(1, off.subVectors(at, from).dot(seg) / len2)) : 0; if (t >= 1) return out.copy(to); - off.copy(from).addScaledVector(seg, t).sub(planet); - const clear = radius + COURSE_PLANET_CLEARANCE; + off.copy(from).addScaledVector(seg, t).sub(at); if (off.length() >= clear) return out.copy(to); // A line through the centre has no side. Any direction square to it will do. if (off.lengthSq() < 1e-6) { off.set(seg.y, -seg.x, 0); if (off.lengthSq() < 1e-6) off.set(0, seg.z, -seg.y); } - return out.copy(planet).addScaledVector(off.normalize(), radius + COURSE_PLANET_CLEARANCE * 1.5); + return out.copy(at).addScaledVector(off.normalize(), clear * 1.5); } diff --git a/src/game/flight-instruments.ts b/src/game/flight-instruments.ts index e4574e40..99e55c86 100644 --- a/src/game/flight-instruments.ts +++ b/src/game/flight-instruments.ts @@ -158,7 +158,7 @@ export class Instruments { // as the target, exactly as a rock is. const mission = s.course !== 'mission' ? null : missionCourse(this.state.commander.missions, this.state.commander.systemIndex, - w.npcs, w.cargo.items); + w.npcs, w.cargo.items, w.station.position); if (mission?.how === 'fight' && mission.ship !== null && pickedTarget(w.npcs) !== mission.ship) { pickTarget(w.npcs, mission.ship); @@ -181,6 +181,10 @@ export class Instruments { derelictSpeed: derelict?.state.speed ?? 0, hermitPos: live('hermit')?.object.position ?? null, tankFull: this.state.commander.fuel >= MAX_FUEL, + police: w.npcs + .filter((n) => n.state.alive && n.role === 'police' + && n.object.position.distanceTo(p.position) <= SCANNER_RANGE * 2) + .map((n) => n.object.position), loot: w.cargo.items .map((c) => c.object.position) .filter((at) => at.distanceTo(p.position) <= SCANNER_RANGE) diff --git a/src/game/mission-course.ts b/src/game/mission-course.ts index 449ec59e..0ea45892 100644 --- a/src/game/mission-course.ts +++ b/src/game/mission-course.ts @@ -15,10 +15,11 @@ // - a HUNT is a fight, so the course picks the ship and the aim flies it; // - a SCAN is a hold: stay near it, and keep the nose on it; // - an ESCORT flies alongside, and the fight comes to the pilot; -// - a RECOVER and a RESCUE are a scoop. +// - a RECOVER and a RESCUE are a scoop; +// - a SMUGGLE is a slip: the station, on a line wide of every policeman. // -// The other three verbs need no course of their own. A deliver, a smuggle -// and an ambush all end at the station, and the station course flies there. +// A deliver and an ambush need no course of their own. Both end at the +// station, and the station course flies there. import type * as THREE from 'three'; import type { NpcShip } from './npc.ts'; @@ -28,7 +29,7 @@ import type { MissionState, Skeleton } from '../missions/model.ts'; import { SKELETONS } from '../missions/skeletons/index.ts'; /** What the ship does about this leg. */ -export type MissionHow = 'fight' | 'hold' | 'escort' | 'scoop'; +export type MissionHow = 'fight' | 'hold' | 'escort' | 'scoop' | 'slip'; /** The mission's course: its words, what to do, and what to do it to. */ export interface MissionCourse { @@ -53,12 +54,18 @@ export function missionCourse( here: number, npcs: readonly NpcShip[], items: readonly Canister[], + stationPos: THREE.Vector3, skeletons: readonly Skeleton[] = SKELETONS, ): MissionCourse | null { for (const { live, leg } of liveLegs(st, skeletons)) { - if (live.target !== here || live.tag === null) continue; - const ship = npcs.find((n) => n.state.alive && n.state.missionTag === live.tag) ?? null; - const item = items.find((c) => c.missionTag === live.tag) ?? null; + if (live.target !== here) continue; + // A smuggling run has no tagged thing in the sky: what it asks for is a + // way past the police. Every other course below needs its target, and a + // leg with no tag has none. + const ship = live.tag === null ? null + : npcs.find((n) => n.state.alive && n.state.missionTag === live.tag) ?? null; + const item = live.tag === null ? null + : items.find((c) => c.missionTag === live.tag) ?? null; const name = ship?.object.name.toUpperCase() ?? ''; switch (leg.verb.kind) { case 'hunt': @@ -86,8 +93,12 @@ export function missionCourse( return { what: 'PICK UP THE SURVIVOR', how: 'scoop', ship: null, at: item.object.position, speed: 0 }; } break; + case 'smuggle': + return { + what: 'SLIP PAST THE POLICE', how: 'slip', ship: null, at: stationPos, speed: 0, + }; default: - // deliver, smuggle and ambush all end at the station, and the station + // A deliver and an ambush both end at the station, and the station // course flies there. break; } diff --git a/test/course-pilot.test.ts b/test/course-pilot.test.ts index 91892e6d..552c2612 100644 --- a/test/course-pilot.test.ts +++ b/test/course-pilot.test.ts @@ -43,6 +43,7 @@ const view = (station: THREE.Vector3, over: Partial = {}): CourseVie tankFull: false, threats: [], loot: [], + police: [], mission: null, dcEngaged: false, handOverRange: DOCK_COMPUTER_RANGE, diff --git a/test/mission-courses.test.ts b/test/mission-courses.test.ts index 0312860b..dfd02a6a 100644 --- a/test/mission-courses.test.ts +++ b/test/mission-courses.test.ts @@ -9,12 +9,16 @@ // flown by its button alone. The pilot's own part is the trigger, which the // hunt holds down. +import * as THREE from 'three'; import { Game } from '../src/game/game.ts'; import { headlessShell } from '../src/engine/shell.ts'; import { withoutSaving } from '../src/game/storage.ts'; import { seedWorld } from '../src/game/rng.ts'; import { runMissions } from '../src/game/mission-bridge.ts'; import { missionCourse } from '../src/game/mission-course.ts'; +import { clearOfPolice } from '../src/game/course-pilot.ts'; +import { SCAN_RANGE } from '../src/constants/law.ts'; +import { COURSE_POLICE_CLEARANCE } from '../src/constants/course.ts'; import { COURSE_KEYS } from '../src/game/bindings.ts'; import { keymap } from '../src/engine/keymap.ts'; import { check, dismissBriefing, eq } from './harness.ts'; @@ -72,7 +76,7 @@ function fly(g: Game, seconds: number, until: () => boolean, trigger = false): n /** The words the mission's button shows now. */ const words = (g: Game): string | null => missionCourse( g.state.commander.missions, g.state.commander.systemIndex, - g.state.world.npcs, g.state.world.cargo.items)?.what ?? null; + g.state.world.npcs, g.state.world.cargo.items, g.state.world.station.position)?.what ?? null; { const g = onTheJob('side-hunt', 20_260_940); @@ -137,3 +141,35 @@ console.log('\na hunted ship that runs has fled, not escaped'); eq('a tagged ship that jumps out escapes, and the side hunt fails', flown(false), 'fail'); eq('...and one that runs has fled, which a side hunt does not answer', flown(true), undefined); } + +console.log('\na smuggling run keeps wide of the police'); +{ + const from = new THREE.Vector3(0, 0, 0); + const to = new THREE.Vector3(0, 0, -20_000); + const out = new THREE.Vector3(); + const onTheLine = new THREE.Vector3(0, 0, -10_000); + clearOfPolice(from, to, [onTheLine], out); + const miss = out.distanceTo(onTheLine); + check('a policeman on the line pushes the aim wide of him', out.z !== to.z); + check('...by more than he can read a hold at', miss > SCAN_RANGE, `${Math.round(miss)} units`); + check('...and outside his warning band too', miss >= COURSE_POLICE_CLEARANCE, + `${Math.round(miss)} units`); + clearOfPolice(from, to, [new THREE.Vector3(30_000, 0, -10_000)], out); + check('a policeman well off the line changes nothing', out.equals(to)); +} + +{ + const g = onTheJob('side-smuggle', 20_260_946); + eq('a smuggling run says what it is', words(g), 'SLIP PAST THE POLICE'); + // A policeman square in the way, half way to the station. + const station = g.state.world.station.position; + const half = g.state.player.position.clone().lerp(station, 0.5); + const cop = g.state.world.spawn('police', half, 3); + let nearest = Infinity; + fly(g, 200, () => { + nearest = Math.min(nearest, g.state.player.position.distanceTo(cop.object.position)); + return g.state.player.position.distanceTo(station) < 4000; + }); + check('...and the ship goes round a policeman in the way', nearest > SCAN_RANGE, + `${Math.round(nearest)} units at the nearest`); +} From 2b349e691d2df9bd628eee2d00af18d06f8d26b3 Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Sat, 12 Sep 2026 00:06:15 +0100 Subject: [PATCH 033/100] docs/TODO/208 M5: a derelict tells what the scan finds The derelict course ends beside the hull, and the console says what is there: a cold reactor, a breach along the spine, bays emptied from the inside. The words are read off the world's own seed, so a derelict tells the same story on every visit and two worlds tell different ones. No draw from the world's stream moves. 5,845 assertions, from 5,841. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- docs/ARCHITECTURE.md | 7 +++- ...ery-kind-of-mission-has-a-way-to-fly-it.md | 11 +++++ src/game/derelict.ts | 41 +++++++++++++++++++ src/game/flight-instruments.ts | 10 +++-- test/constants.test.ts | 2 + test/course-pilot.test.ts | 16 ++++++++ 6 files changed, 82 insertions(+), 5 deletions(-) create mode 100644 src/game/derelict.ts diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md index a292ec95..d6877994 100644 --- a/docs/ARCHITECTURE.md +++ b/docs/ARCHITECTURE.md @@ -179,8 +179,11 @@ Two quirks are deliberate: ship a code that names it for as long as it lives. `cockpit-buttons.ts` says what every button over the flight view reads, in words, and it holds no world (docs/TODO/206 M5). `game/mission-course.ts` - says what a live mission asks the ship to do here, in four shapes: a fight, - a hold, an escort and a scoop (docs/TODO/208). + says what a live mission asks the ship to do here (docs/TODO/208). There + are five shapes: a fight, a hold, an escort, a scoop, and a slip past the + police. + `game/derelict.ts` says what a scan of a derelict reports, read off the + world's own seed. - `src/game/threat.ts` computes the pirate count, the group tier and the organisation from the visible value and the reputation. `ship-specs.ts` maps a tier to a hull. The campaign simulator calls the same rules. diff --git a/docs/TODO/208-every-kind-of-mission-has-a-way-to-fly-it.md b/docs/TODO/208-every-kind-of-mission-has-a-way-to-fly-it.md index 2bbf5462..f29b685e 100644 --- a/docs/TODO/208-every-kind-of-mission-has-a-way-to-fly-it.md +++ b/docs/TODO/208-every-kind-of-mission-has-a-way-to-fly-it.md @@ -193,3 +193,14 @@ Evidence: - **A leg without a tag is still a leg.** The lookup skipped every leg with no tagged ship, and a smuggling run has none. It asks for a way past the police, and nothing in the sky is its own. + +### M5 + +- **A derelict says what is there, in the world's own words.** The scan's + report is read off the world's seed rather than drawn. So a derelict tells + the same story on every visit, and two worlds tell different ones. A draw + would move every seeded outcome after it. +- **The cargo beside it is the collect course's, which 206 M6 already flies.** +- **`flight.ts` was one line over its ceiling for an hour.** The instruments + hold the state, so they read the world themselves rather than ask the + flight half for it. diff --git a/src/game/derelict.ts b/src/game/derelict.ts new file mode 100644 index 00000000..3be67e44 --- /dev/null +++ b/src/game/derelict.ts @@ -0,0 +1,41 @@ +// What the scan finds when a ship reaches a derelict (docs/TODO/208 M5). +// +// A generation ship crosses on 8% of arrivals. It said one line and offered +// nothing else. The derelict course now flies to it, so the arrival is a +// place a player chose to go, and it says what is there. +// +// THE WORDS COME FROM THE SEED, and no draw from the world's stream. The same +// derelict at the same world tells the same story on every visit, and two +// worlds tell different ones. A draw would move every seeded outcome after +// it, which is `game/rng.ts`'s rule. +// +// They are the encounter's words, so they live beside the game rather than in +// a mission. A mission that wants a derelict can still use one: 208's plan +// leaves that to a later arc. + +import type { StarSystem } from '../galaxy/galaxy.ts'; + +/** + * What a scan of the hull reports. One line, in the game's voice, and no + * fiction beyond what a scan can see. + */ +const REPORTS: readonly string[] = [ + 'THE DRUM STOPPED TURNING LONG AGO. THE CROP DECKS ARE BARE ROCK.', + 'A HULL BREACH RUNS THE LENGTH OF THE SPINE. NOTHING INSIDE HOLDS AIR.', + 'THE REACTOR IS COLD. THE COLONY LIVED AND DIED ON STORED POWER.', + 'EVERY LOCK STANDS OPEN. WHOEVER LEFT, LEFT IN ORDER.', + 'THE BEACON STILL TRANSMITS A COURSE THIS SHIP CANNOT FLY.', + 'THE CARGO BAYS WERE EMPTIED FROM INSIDE. SOMEBODY PACKED.', + 'THE NAME ON THE BOW IS WORN AWAY. THE REGISTRY IS OLDER THAN THE CHARTS.', + 'A RESCUE CUT THROUGH THE FORWARD FRAMES. IT CAME TOO LATE TO MATTER.', +]; + +/** + * The derelict's report at this world. It is the same on every visit, because + * it is read off the world's own seed rather than drawn. + */ +export function derelictReport(system: StarSystem): string { + const seed = system.seed; + const at = Math.abs(seed[0] + seed[1] * 7 + system.index) % REPORTS.length; + return REPORTS[at] as string; +} diff --git a/src/game/flight-instruments.ts b/src/game/flight-instruments.ts index 99e55c86..776c6c8d 100644 --- a/src/game/flight-instruments.ts +++ b/src/game/flight-instruments.ts @@ -26,6 +26,8 @@ import type { CourseKind } from './courses.ts'; import { MAX_FUEL } from '../constants/commander.ts'; import { hostilesOnScanner } from './hostility.ts'; import { pickTarget, pickedTarget } from './targets.ts'; +import { derelictReport } from './derelict.ts'; +import type { StarSystem } from '../galaxy/galaxy.ts'; import { missionCourse } from './mission-course.ts'; import { SCANNER_RANGE } from '../constants/console.ts'; import { DOCK_COMPUTER_RANGE } from '../constants/docking-computer.ts'; @@ -36,7 +38,6 @@ import { COURSE_DOCK_HANDOVER } from '../constants/course.ts'; * says nothing, because the hermit's own trade screen opens on arrival. */ const COURSE_ENDS: Partial> = { - derelict: 'ARRIVED AT THE DERELICT SHIP', skim: 'FUEL TANK FULL', run: 'YOU GOT AWAY', mine: 'NO ROCKS LEFT WITHIN RANGE', @@ -270,8 +271,11 @@ export class Instruments { s.course = null; if (!s.coursesDone.includes(kind)) s.coursesDone.push(kind); this.coursePilot.reset(); - const said = COURSE_ENDS[kind]; - if (said) this.host.showMessage(said, 3); + // The derelict's own words, read off the world's seed (docs/TODO/208 M5). + const said = kind === 'derelict' + ? derelictReport(this.state.systems[this.state.commander.systemIndex] as StarSystem) + : COURSE_ENDS[kind]; + if (said) this.host.showMessage(said, 6); } /** diff --git a/test/constants.test.ts b/test/constants.test.ts index ed3e2c77..d4a00b97 100644 --- a/test/constants.test.ts +++ b/test/constants.test.ts @@ -414,6 +414,8 @@ const OUTSIDE: readonly Group[] = [ 'game/course-actions.ts': ['KINDS'], // what each role is called on the target list (docs/TODO/206 M1) 'game/targets.ts': ['STANDING'], + // what a derelict's scan reports, read off the world's seed (docs/TODO/208 M5) + 'game/derelict.ts': ['REPORTS'], }, }, diff --git a/test/course-pilot.test.ts b/test/course-pilot.test.ts index 552c2612..3ba65802 100644 --- a/test/course-pilot.test.ts +++ b/test/course-pilot.test.ts @@ -18,6 +18,8 @@ import { CABIN_TEMP_FATAL } from '../src/constants/sun.ts'; import { MAX_FUEL } from '../src/constants/commander.ts'; import { SPAWN_PLANET_ALTITUDE } from '../src/constants/spawn-placement.ts'; import { aboveGround } from '../src/game/spawning.ts'; +import { derelictReport } from '../src/game/derelict.ts'; +import { generateGalaxy } from '../src/galaxy/galaxy.ts'; import { DOCK_COMPUTER_RANGE } from '../src/constants/docking-computer.ts'; import { COURSE_DOCK_HANDOVER } from '../src/constants/course.ts'; import { MASS_LOCK_STATION } from '../src/constants/torus.ts'; @@ -222,6 +224,20 @@ console.log('\nthe derelict course'); check('...at the derelict\'s own drift', Math.abs(g.state.player.speed - gen.state.speed) < 10, `${g.state.player.speed.toFixed(1)} u/s against ${gen.state.speed.toFixed(1)}`); check('...and the course is done for the visit', g.state.session.coursesDone.includes('derelict')); + check('...and the scan says what is there, in the world\'s own words', + g.state.session.messageText.length > 20, `said: ${g.state.session.messageText}`); +} + +console.log('\nwhat a derelict\'s scan reports'); +{ + // The words come off the world's seed, so a derelict tells the same story + // on every visit, and two worlds tell different ones (docs/TODO/208 M5). + const systems = generateGalaxy(1); + const twice = [derelictReport(systems[7]), derelictReport(systems[7])]; + eq('the same world reports the same thing twice', twice[0], twice[1]); + const said = new Set(systems.map((sys) => derelictReport(sys))); + check('...and the galaxy tells more than one story', said.size > 3, `${said.size} of them`); + check('...each of them a sentence', [...said].every((line) => line.endsWith('.'))); } console.log('\nthe hermit course'); From 7d3acfc85d08366db8052184c51323eb39d0c1f8 Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Sat, 12 Sep 2026 00:08:05 +0100 Subject: [PATCH 034/100] docs/TODO/208 lands: every kind of mission has a way to fly it A live job is the first button over the view, in the job's own words, and the ship flies it. A hunt picks its ship for the computer's aim. A scan holds the ship off and keeps the nose on it. An escort flies alongside. A recover and a rescue scoop. A smuggling run goes wide of the police. A delivery and an ambush end at the station. Three faults the review found are mended, and a derelict tells what the scan finds. The manual says how a job is flown. ambush-probe survived 40 of 40 episodes. The queue is empty. 5,845 assertions, from 5,835. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- docs/TODO/QUEUE.json | 4 +-- docs/TODO/README.md | 15 +++++++++-- ...ery-kind-of-mission-has-a-way-to-fly-it.md | 25 +++++++++++++++++++ docs/TODO/completed/README.md | 1 + manual.html | 10 +++++++- 5 files changed, 49 insertions(+), 6 deletions(-) rename docs/TODO/{ => completed}/208-every-kind-of-mission-has-a-way-to-fly-it.md (89%) diff --git a/docs/TODO/QUEUE.json b/docs/TODO/QUEUE.json index d6dfb8cb..189020e1 100644 --- a/docs/TODO/QUEUE.json +++ b/docs/TODO/QUEUE.json @@ -1,6 +1,4 @@ { "version": 1, - "items": [ - 208 - ] + "items": [] } diff --git a/docs/TODO/README.md b/docs/TODO/README.md index 226c8370..d5d546ca 100644 --- a/docs/TODO/README.md +++ b/docs/TODO/README.md @@ -13,7 +13,7 @@ active context: ## Execution queue -1. [208](208-every-kind-of-mission-has-a-way-to-fly-it.md) — every kind of mission has a way to fly it. +The queue is empty. **205 TO 208 CAME FROM CHRIS ON 2026-09-11, the day 204 landed.** He flew the touch controls of 204 on a phone, and he could not fly the ship. He @@ -23,7 +23,8 @@ pilot fires the laser, the missiles and the E.C.M. The dock stays a challenge. The missions become part of the flight. 205 also takes out the touch controls of 204. He played four docking concepts the same day, and he picked Match the spin for 207. The plans are written, and the work waits -on his word. **205, 206 and 207 landed the same day**, and each is below. +on his word. **205, 206 and 207 landed the same day, and 208 the day after**. +Each is below. **204 CAME FROM CHRIS ON 2026-09-10.** The docked screens and the cockpit fit a phone, and nothing on the flight screen takes a touch. The brainstorm set @@ -293,6 +294,16 @@ headphones. **#24** closed on 2026-08-12 with it: *"display is good"*. **#23** closed with 134, as #22 did with 127, #18 with 121, #20 with 122 and #21 with 123. +## What landed on 2026-09-12 + +**208 — every kind of mission has a way to fly it.** A live job is the first +button over the view, in the job's own words, and the ship flies it. The rows +read HUNT, SCAN, ESCORT, RECOVER, PICK UP and SLIP PAST THE POLICE. A delivery +and an ambush end at the station. The work mended three faults. A scoop row +trapped a pilot with no fuel scoops. A hunt stayed live when somebody else +killed its ship. A `fled` branch in three arcs had no sender. A derelict now +tells what the scan finds. 5,845 assertions, from 5,835. + ## What landed on 2026-09-11 **207 — the pilot takes the ship into the slot by hand.** Chris played four diff --git a/docs/TODO/208-every-kind-of-mission-has-a-way-to-fly-it.md b/docs/TODO/completed/208-every-kind-of-mission-has-a-way-to-fly-it.md similarity index 89% rename from docs/TODO/208-every-kind-of-mission-has-a-way-to-fly-it.md rename to docs/TODO/completed/208-every-kind-of-mission-has-a-way-to-fly-it.md index f29b685e..722426a7 100644 --- a/docs/TODO/208-every-kind-of-mission-has-a-way-to-fly-it.md +++ b/docs/TODO/completed/208-every-kind-of-mission-has-a-way-to-fly-it.md @@ -204,3 +204,28 @@ Evidence: - **`flight.ts` was one line over its ceiling for an hour.** The instruments hold the state, so they read the world themselves rather than ask the flight half for it. + +### The manual + +- **The manual says how a job is flown now.** A job is the first button over + the view, in its own words, and a delivery is the station button. + +## Outcome + +208 landed on 2026-09-12. A live job is the first row of the course list, in +the job's own words, and the ship flies it. A hunt picks its ship, and the +computer's aim lines the ship up while the pilot fires. A scan holds the +ship 1,200 units off and keeps the nose on it. An escort flies 600 units off +its charge. A recover and a rescue scoop. A smuggling run flies the station +course wide of every policeman. A delivery and an ambush end at the station, +which the station course already flies. + +The work mended three faults the review found. A scoop row says NEEDS FUEL +SCOOPS and refuses, so no course flies into a canister that would break on +the hull. A hunted ship wrecked by somebody else ends the hunt rather than +leaving the leg live for ever. A tagged ship that runs sends `fled`, which +three arcs have waited for a branch on. A derelict now tells what the scan +finds, in the world's own words. + +`ambush-probe` survived 40 of 40 episodes after the work. The suite has 5,845 +assertions, from 5,835. diff --git a/docs/TODO/completed/README.md b/docs/TODO/completed/README.md index ca1cde33..887b5b4b 100644 --- a/docs/TODO/completed/README.md +++ b/docs/TODO/completed/README.md @@ -217,3 +217,4 @@ Supporting records: [Elite-A alignment plan](ELITE-A-COMBAT-PLAN.md), - [x] 205 — [The pilot picks where the ship goes, and the ship flies itself](205-the-pilot-picks-where-the-ship-goes-and-the-ship-flies-itself.md) — Chris, 2026-09-11. **M1** takes out the touch controls of 204. **M2** is the course list, **M3** the pilot that flies it, **M4** the launch list and **M5** the buttons in flight. **M6** is the manual and the briefing, and **M7** is FAST FORWARD. 5,733 assertions. - [x] 206 — [The computer flies the fight, and the pilot fires](206-the-computer-flies-the-fight-and-the-pilot-fires.md) — Chris, 2026-09-11. **M1** is the target list and the pick. **M2 and M4** give every pilot the aim, and the bought computer the trigger. **M3** is the pilot's buttons. **M5** is the run and the offers. **M6** is mining and collecting. 5,804 assertions. - [x] 207 — [The pilot takes the ship into the slot by hand](207-the-pilot-takes-the-ship-into-the-slot-by-hand.md) — Chris, 2026-09-11. He played four concepts and picked Match the spin. **M1** hands the last 1,500 units to the pilot. **M2** is the roll strip and the throttle buttons. **M3** is the slot's speed limit. **M4** is the guide. 5,820 assertions. +- [x] 208 — [Every kind of mission has a way to fly it](208-every-kind-of-mission-has-a-way-to-fly-it.md) — Chris, 2026-09-12. **M1 and M2** give each verb a course, in the job's own words. **M3** mends the scoop trap and two faults in the hunt. **M4** is the smuggling run wide of the police. **M5** is what a derelict's scan reports. 5,845 assertions. diff --git a/manual.html b/manual.html index b30f5b25..9a09c456 100644 --- a/manual.html +++ b/manual.html @@ -398,7 +398,15 @@

    Missions

    the route drawn.

    - How a job plays. The MISSIONS screen shows the job you hold, + How a job plays. When you jump into the world a job names, the + job is the first button in the list over the view, in its own words: + HUNT THE KRAIT, SCAN THE ANACONDA, ESCORT THE PYTHON, RECOVER THE + CARGO, PICK UP THE SURVIVOR, or SLIP PAST THE POLICE. Choose it and + the ship flies the job. A delivery ends at the station, so + FLY TO THE STATION is the button for it. +

    +

    + The MISSIONS screen shows the job you hold, the briefing, and the order you are on now. The world you must go to has an amber diamond on both charts. When you jump in, the console tells you what you are there for and where the target is: how far, From 6d4ade4df7a27ac8d090bbee6a8a6131ce4bc0c0 Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Sat, 12 Sep 2026 04:31:42 +0100 Subject: [PATCH 035/100] The destination is picked on the local chart, not the galactic one Chris: "The local chart should be used for setting a destination, not the galactic chart." The local chart shows what the tank can reach, which is the question a destination answers. The launch list's row opens it, the button in flight opens it, and the jump row's reason says CHOOSE A SYSTEM ON THE LOCAL CHART FIRST. The galactic chart keeps its own key and its own row on the station menu. 5,846 assertions, from 5,845. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- ...-where-the-ship-goes-and-the-ship-flies-itself.md | 9 +++++++++ src/game/cockpit-buttons.ts | 2 +- src/game/cockpit-view.ts | 2 +- src/game/courses.ts | 2 +- src/game/screens/courses.ts | 7 +++++-- src/ui/screens-courses.ts | 2 +- test/course-buttons.test.ts | 12 +++++++++++- test/course-launch.test.ts | 5 +++-- test/courses.test.ts | 2 +- 9 files changed, 33 insertions(+), 10 deletions(-) diff --git a/docs/TODO/completed/205-the-pilot-picks-where-the-ship-goes-and-the-ship-flies-itself.md b/docs/TODO/completed/205-the-pilot-picks-where-the-ship-goes-and-the-ship-flies-itself.md index 888e37d3..c6ff84e9 100644 --- a/docs/TODO/completed/205-the-pilot-picks-where-the-ship-goes-and-the-ship-flies-itself.md +++ b/docs/TODO/completed/205-the-pilot-picks-where-the-ship-goes-and-the-ship-flies-itself.md @@ -469,3 +469,12 @@ The measurements: the station course docked 50 of 50 trips, with a median of 20 of 20, 20 of 20 and 40 of 40 times. The dock probe docked 504 of 504 approaches with no scrape. The suite has 5,733 assertions, from 5,619 before 204. + +## After it landed + +**The chart row is the LOCAL chart** (Chris, 2026-09-12: *"The local chart +should be used for setting a destination, not the galactic chart."*). The +launch list's row, the button in flight, and the jump row's reason all name +it now. The local chart shows what the tank can reach, which is the question +a destination answers. The galactic chart is the wider view, and it keeps its +own key and its own row on the station menu. diff --git a/src/game/cockpit-buttons.ts b/src/game/cockpit-buttons.ts index 2fc64d1b..35431208 100644 --- a/src/game/cockpit-buttons.ts +++ b/src/game/cockpit-buttons.ts @@ -43,7 +43,7 @@ export function courseButtonsFor(p: CoursePanel, chart: string | null): HudButto const out: HudButton[] = p.rows.map((c) => ({ code: COURSE_KEYS[c.kind], label: c.what, ...(c.why === null ? {} : { note: c.why }), })); - if (chart) out.push({ code: chart, label: 'GALACTIC CHART' }); + if (chart) out.push({ code: chart, label: 'LOCAL CHART' }); if (p.current !== null) out.push({ code: COURSE_TOGGLE_KEY, label: 'CLOSE' }); return out; } diff --git a/src/game/cockpit-view.ts b/src/game/cockpit-view.ts index 844b1225..63ede2dd 100644 --- a/src/game/cockpit-view.ts +++ b/src/game/cockpit-view.ts @@ -238,7 +238,7 @@ export class CockpitView { if (!panel) return []; const mode = this.host.controlMode(); return [ - ...courseButtonsFor(panel, mode ? keyCodeIfBound(mode, 'openChart') : null), + ...courseButtonsFor(panel, mode ? keyCodeIfBound(mode, 'openLocalChart') : null), ...(mode ? offerButtons(this.offers(), mode) : []), ]; } diff --git a/src/game/courses.ts b/src/game/courses.ts index 2a4f0229..88227086 100644 --- a/src/game/courses.ts +++ b/src/game/courses.ts @@ -173,7 +173,7 @@ function jumpRow(w: CourseWorld, launch: boolean): Course | null { * own shorter refusal, `refusalMessage` in `hyperspace.ts`. */ const JUMP_WHY: Readonly> = { - noTarget: 'CHOOSE A SYSTEM ON THE GALACTIC CHART FIRST', + noTarget: 'CHOOSE A SYSTEM ON THE LOCAL CHART FIRST', noFuel: 'NOT ENOUGH FUEL TO GET THERE', alreadyJumping: 'THE JUMP HAS STARTED', }; diff --git a/src/game/screens/courses.ts b/src/game/screens/courses.ts index 49e8bb02..0cfeeba0 100644 --- a/src/game/screens/courses.ts +++ b/src/game/screens/courses.ts @@ -3,7 +3,7 @@ // The station menu's LAUNCH row opens it. Each row is one course from // `courses.ts`, and a pick leaves the station on it. A row the ship cannot fly // says why, and a pick of it refuses. So a ship with no target and no work -// cannot leave. The last row opens the galactic chart, where the pilot sets a +// cannot leave. The last row opens the local chart, where the pilot sets a // target, and ESC from the chart comes back here. // // The screen decides nothing itself. `course-actions.ts` applies a pick, the @@ -49,7 +49,10 @@ export class CoursesScreen implements Screen { return 'stay'; } } - if (i.pressed(COURSE_CHART_KEY)) return { open: 'chart' }; + // The LOCAL chart, because it shows what the tank can reach (Chris, + // 2026-09-12). The galactic chart is the wider view, and a destination + // is picked from the short one. + if (i.pressed(COURSE_CHART_KEY)) return { open: 'local' }; if (i.pressed('Escape')) return 'back'; return 'stay'; } diff --git a/src/ui/screens-courses.ts b/src/ui/screens-courses.ts index 56b93a2a..2a82da99 100644 --- a/src/ui/screens-courses.ts +++ b/src/ui/screens-courses.ts @@ -28,7 +28,7 @@ export function renderLaunchCourses(rows: readonly CourseRow[], chartCode: strin

    ${rows.map(line).join('\n ')} -
    GALACTIC CHART — PICK A SYSTEM TO JUMP TO
    +
    LOCAL CHART — PICK A SYSTEM TO JUMP TO
    TAP A ROW · ↑ ↓ SELECT · ENTER CHOOSE · ESC STAY DOCKED
    diff --git a/test/course-buttons.test.ts b/test/course-buttons.test.ts index 20625bfe..14e64927 100644 --- a/test/course-buttons.test.ts +++ b/test/course-buttons.test.ts @@ -10,6 +10,7 @@ import { withoutSaving } from '../src/game/storage.ts'; import { seedWorld } from '../src/game/rng.ts'; import { COURSE_KEYS, COURSE_TOGGLE_KEY } from '../src/game/bindings.ts'; import { courseButtonsFor } from '../src/game/cockpit-buttons.ts'; +import { keyCodeIfBound } from '../src/ui/key-help.ts'; import { check, dismissBriefing, eq } from './harness.ts'; console.log('\nthe course buttons in flight'); @@ -61,7 +62,7 @@ function press(g: Game, code: string): void { press(g, COURSE_TOGGLE_KEY); check('that button opens the list again over the course', (g.coursePanel()?.rows?.length ?? 0) > 0); check('...and the list ends with a button that closes it', - courseButtonsFor(g.coursePanel()!, 'KeyG').at(-1)?.label === 'CLOSE'); + courseButtonsFor(g.coursePanel()!, 'KeyN').at(-1)?.label === 'CLOSE'); g.state.commander.equipment.scoops = true; g.state.commander.fuel = 10; @@ -70,6 +71,15 @@ function press(g: Game, code: string): void { eq('...and folds the list away again', g.coursePanel()?.rows ?? null, null); } +{ + // The chart button opens the LOCAL chart, which shows what the tank can + // reach (Chris, 2026-09-12). + const g = arrived(); + const chart = g.hudButtons().courses.find((b) => b.label === 'LOCAL CHART'); + eq('the list carries a button for the local chart', chart?.code, + keyCodeIfBound('flight', 'openLocalChart')); +} + { const g = arrived(); press(g, COURSE_KEYS.mine); diff --git a/test/course-launch.test.ts b/test/course-launch.test.ts index f6531460..ebfea258 100644 --- a/test/course-launch.test.ts +++ b/test/course-launch.test.ts @@ -48,10 +48,11 @@ function reachable(g: Game): number { press(g, COURSE_KEYS.jump); eq('a jump with no target refuses, and the ship stays on the pad', g.mode, 'courses'); eq('...and the console says what to do', g.state.session.messageText, - 'CHOOSE A SYSTEM ON THE GALACTIC CHART FIRST'); + 'CHOOSE A SYSTEM ON THE LOCAL CHART FIRST'); press(g, COURSE_CHART_KEY); - eq('the chart row opens the galactic chart', g.mode, 'chart'); + eq('the chart row opens the local chart, which shows what the tank reaches', + g.mode, 'local'); press(g, 'Escape'); eq('...and ESC from the chart comes back to the list', g.mode, 'courses'); diff --git a/test/courses.test.ts b/test/courses.test.ts index cfb54ef5..ad04e03c 100644 --- a/test/courses.test.ts +++ b/test/courses.test.ts @@ -53,7 +53,7 @@ same('a jump with fuel names the target and is free to fly', row(world(), 'jump'), { kind: 'jump', what: 'JUMP TO LAVE', why: null }); eq('at a launch, a chart with no target still shows the jump, with the reason', row(world({ situation: 'launch', sky: [], jump: { ok: false, reason: 'noTarget' }, targetName: null }), 'jump')?.why, - 'CHOOSE A SYSTEM ON THE GALACTIC CHART FIRST'); + 'CHOOSE A SYSTEM ON THE LOCAL CHART FIRST'); check('...and in flight, a chart with no target shows no jump', !kinds(world({ jump: { ok: false, reason: 'noTarget' }, targetName: null })).includes('jump')); eq('a jump the tank cannot cover shows, and says so', From 5a41552c2d2abb9842f709ad87c576e88bd06353 Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Sat, 12 Sep 2026 05:09:47 +0100 Subject: [PATCH 036/100] docs/TODO/209: the torus drive says what stopped it MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Chris flew a trip to the station. He reported no mass lock on neutral traders. The rule did fire: a trader on the line dropped the drive at 4,457 units. Two things hid it. The message named nothing. It said "MASS LOCK — TORUS DISENGAGED", so a trader read the same as the planet. `massLockCause()` now names the nearest thing that holds the drive down, and `massLocked()` is a wrapper over it. The name comes from `targets.ts`, so one ship reads the same on the target list and in the message. The drive is also off for most of a trip. Of 26 trader passes inside the lock radius over 20 trips, only 7 dropped a running drive. So a neutral trader that comes close is announced one time (`close-pass.ts`). It never stops the ship: the pilot chose the course, and the line only says that the chance is there. A line for every neutral ship gave a median of 6 per trip. A trader only, outside the station's own lock, gives a median of 1. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- docs/ARCHITECTURE.md | 4 +- .../209-the-drive-says-what-stopped-it.md | 121 ++++++++++++++++++ docs/TODO/completed/README.md | 1 + manual.html | 11 +- src/constants/CATALOG.md | 3 +- src/constants/torus.ts | 17 +++ src/game/close-pass.ts | 69 ++++++++++ src/game/flight-instruments.ts | 10 +- src/game/npc-state.ts | 9 +- src/game/targets.ts | 23 +++- src/game/world-step.ts | 44 +++++-- test/close-pass.test.ts | 95 ++++++++++++++ test/run.ts | 1 + test/world-step.test.ts | 25 +++- 14 files changed, 413 insertions(+), 20 deletions(-) create mode 100644 docs/TODO/completed/209-the-drive-says-what-stopped-it.md create mode 100644 src/game/close-pass.ts create mode 100644 test/close-pass.test.ts diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md index d6877994..8b39bf90 100644 --- a/docs/ARCHITECTURE.md +++ b/docs/ARCHITECTURE.md @@ -176,7 +176,9 @@ Two quirks are deliberate: pick (docs/TODO/206). The pick is one flag on the picked ship's own state, so a save carries it. It sits on top of `threat-lock.ts`, and never changes that rule. `target-actions.ts` joins the list to its buttons, and gives each - ship a code that names it for as long as it lives. + ship a code that names it for as long as it lives. `close-pass.ts` names a + neutral trader that comes close, one time, so the pilot knows the chance is + there (docs/TODO/209). It never stops the ship. `cockpit-buttons.ts` says what every button over the flight view reads, in words, and it holds no world (docs/TODO/206 M5). `game/mission-course.ts` says what a live mission asks the ship to do here (docs/TODO/208). There diff --git a/docs/TODO/completed/209-the-drive-says-what-stopped-it.md b/docs/TODO/completed/209-the-drive-says-what-stopped-it.md new file mode 100644 index 00000000..13bbb6c2 --- /dev/null +++ b/docs/TODO/completed/209-the-drive-says-what-stopped-it.md @@ -0,0 +1,121 @@ +# 209 — The torus drive says what stopped it + +**Kind:** bug · **Severity:** medium · **Size:** small · **Depends on:** 205 · +**Blocks:** nothing · **GitHub:** none + +## Where we are + +**Chris flew a trip to the station and reported a fault** (2026-09-12: +*"Jumping to the station did not seem to mass lock on neutral traders."*). + +**The rule does fire.** `massLocked()` in `game/world-step.ts` drops the torus +drive within 4,500 units of any live ship that is not a rock. A measurement of +2026-09-12 put a stationary trader on the line to the station. The drive +dropped at 4,457 units. Over 20 trips, a trader was inside the lock radius at +9 of 36 stops. + +**Two things hid it from the pilot.** The first is the message. It said `MASS +LOCK — TORUS DISENGAGED`, which names nothing. A pilot cannot tell a trader +from a rock hermit from the planet. + +The second is the drive itself. The drive is off for about 240 seconds of a +290 second trip. The course brakes towards the station with the drive off, and +that is where the traffic is. So of 26 trader passes inside the lock radius +over 20 trips, only 7 dropped a running drive. The other 19 were silent. + +**Chris wants a neutral ship to be a chance, not an event.** His words in the +design document of 2026-09-11: *"When anything is in range we should show a +list of objects that can be engaged - these can be outright hostiles or neutral +ships that we want to pirate."* The target list of 206 already holds every ship +in scanner range. The pilot had no reason to open it. + +## What to do + +**M1 — the drop names what stopped the drive.** + +1. Add `massLockCause(state)` to `game/world-step.ts`. It returns the player's + own words for the nearest thing that holds the drive down, or null. +2. Make `massLocked(state)` a wrapper over it, so the rule keeps one home. +3. Change the drop message to `TORUS DRIVE OFF — IS TOO CLOSE`. +4. Change the flight key refusal the same way. It said `MASS LOCKED`. +5. Name a ship with `shipName()`, which `game/targets.ts` owns. The list and + the message must not use two words for one ship. + +**M2 — a neutral trader that comes close says so.** + +1. Add `game/close-pass.ts`. It returns one line for each trader that comes + inside `MASS_LOCK_SHIP` and was not announced yet. +2. Hold the flag on the ship, as the target pick is held (`NpcState`). +3. Clear the flag past `CLOSE_PASS_CLEAR`, so a wobble across the radius does + not repeat the line. +4. Push the lines from `stepNpcs`, which is the orchestrator (invariant 15). +5. Say it in the manual. + +## Decisions already made + +- **A neutral ship must not stop the ship.** The pilot chose the course. The + line tells the pilot that the chance is there. Chris's rule of 2026-09-11: + the pilot owns the target choice. +- **The line names a trader, and no other role.** A hostile ship announces + itself, by its guns and by the condition light. The law's ships are a risk + rather than a chance. A line that invites an attack on a Viper beside the + station is bad advice. +- **Nothing speaks inside the station's mass lock.** The pilot is on the + approach there, and the traffic is thick. + +## Open questions + +None. + +## Watch out for + +- **The count of lines.** A line for each pass would be noise. Measure it. +- **`massLocked` has three readers**: the flight keys, the step and the + harnesses through `window.__game`. The wrapper keeps all three. + +## Verification + +1. `test/world-step.test.ts` pins the named cause for the station, the planet, + a trader and a clear sky. +2. `test/close-pass.test.ts` pins one line for each approach, the roles that + get none, and the flag that clears. +3. A probe over 20 trips to the station counts the lines a trip shows. + +## What the milestones found + +**M1 — the lock did fire, and it said nothing useful.** Three measurements of +2026-09-12, before any change: + +| measurement | result | +| --- | --- | +| a stationary trader on the line to the station | the drive dropped at 4,457 units | +| traders inside the lock radius at a stop, over 20 trips | 9 of 36 stops | +| trader passes inside the lock radius, over 20 trips | 26 | +| ...of those, passes that dropped a running drive | 7 | + +So 19 of 26 passes were silent, because the drive was already off. The drive +runs for about 50 seconds of a 290 second trip. + +**The name comes from `targets.ts`.** `shipName()` and `shipArticle()` moved +out of `targetList()`, so one ship reads the same on the list and in the +message. A message said `A OPHIDIAN` before the article rule existed. + +**M2 — the first shape was too loud.** A line for every neutral ship inside +the radius gave a median of 6 lines per trip, and a maximum of 10. The law's +ships were half of them, beside the station. The rule now names a trader +only, and it says nothing inside the station's mass lock. That is a median of +1 line per trip, and a maximum of 3, over the same 20 trips. + +**A ship the pilot already chose gets no line.** `test/law.test.ts` caught it: +the commander shot a trader, and the console answered with an invitation to +attack it. The rule now skips a ship that carries the target pick, and one the +commander already shot at. + +## Outcome + +Landed on 2026-09-12. `npm run check` passes, with 5,871 assertions. + +- The torus drive names what stopped it, in the player's words. +- The flight key refusal names it too. +- A neutral trader that comes close is announced one time. +- The manual says both. diff --git a/docs/TODO/completed/README.md b/docs/TODO/completed/README.md index 887b5b4b..124fed36 100644 --- a/docs/TODO/completed/README.md +++ b/docs/TODO/completed/README.md @@ -218,3 +218,4 @@ Supporting records: [Elite-A alignment plan](ELITE-A-COMBAT-PLAN.md), - [x] 206 — [The computer flies the fight, and the pilot fires](206-the-computer-flies-the-fight-and-the-pilot-fires.md) — Chris, 2026-09-11. **M1** is the target list and the pick. **M2 and M4** give every pilot the aim, and the bought computer the trigger. **M3** is the pilot's buttons. **M5** is the run and the offers. **M6** is mining and collecting. 5,804 assertions. - [x] 207 — [The pilot takes the ship into the slot by hand](207-the-pilot-takes-the-ship-into-the-slot-by-hand.md) — Chris, 2026-09-11. He played four concepts and picked Match the spin. **M1** hands the last 1,500 units to the pilot. **M2** is the roll strip and the throttle buttons. **M3** is the slot's speed limit. **M4** is the guide. 5,820 assertions. - [x] 208 — [Every kind of mission has a way to fly it](208-every-kind-of-mission-has-a-way-to-fly-it.md) — Chris, 2026-09-12. **M1 and M2** give each verb a course, in the job's own words. **M3** mends the scoop trap and two faults in the hunt. **M4** is the smuggling run wide of the police. **M5** is what a derelict's scan reports. 5,845 assertions. +- [x] 209 — [The torus drive says what stopped it](209-the-drive-says-what-stopped-it.md) — Chris, 2026-09-12. He flew to the station and saw no mass lock on a neutral trader. The rule did fire. **M1** makes the drop name what stopped the drive, because "MASS LOCK" named nothing. **M2** announces a neutral trader that comes close, one time, because the drive is off for most of a trip. 5,871 assertions. diff --git a/manual.html b/manual.html index 9a09c456..b46db3e8 100644 --- a/manual.html +++ b/manual.html @@ -250,8 +250,15 @@

    Hyperspace & the Charts

    journey in is part of the game. Choose FLY TO THE STATION and the ship takes you in on the torus drive (J if you fly by hand). It disengages near anything with mass: a planet, a station, or - somebody who wants your cargo. When the space around you is clear - again, the ship starts the drive again by itself. + somebody who wants your cargo. The console tells you which one it was. + When the space around you is clear again, the ship starts the drive + again by itself. +

    +

    + You will pass other traders on the way in. The console names one when + it comes close. They are carrying cargo, and nothing stops you taking + it: choose TARGETS, pick the ship, and open fire. The law takes + a dim view, so make sure nobody is watching.

    diff --git a/src/constants/CATALOG.md b/src/constants/CATALOG.md index c540c9cb..9a397129 100644 --- a/src/constants/CATALOG.md +++ b/src/constants/CATALOG.md @@ -2,7 +2,7 @@ -442 exported constants. Regenerate with `npm run generate:constants`; +443 exported constants. Regenerate with `npm run generate:constants`; search names, meanings and values with `npm run constants:find -- ""`. | Domain | Symbol | Literal / expression | Purpose | Rule ID | Source | @@ -421,6 +421,7 @@ search names, meanings and values with `npm run constants:find -- ""`. | torus | MASS_LOCK_STATION | 5000 | How near the station holds the drive down. | | [torus.ts:31](./torus.ts#L31) | | torus | MASS_LOCK_PLANET_ALTITUDE | 4000 | ...and how near the planet, as an ALTITUDE above the surface. | | [torus.ts:39](./torus.ts#L39) | | torus | MASS_LOCK_SHIP | 4500 | ...and how near another ship — any live one that is not a rock. | torus.massLockShip | [torus.ts:48](./torus.ts#L48) | +| torus | CLOSE_PASS_CLEAR | 6750 | How far a ship must open back out before it can be announced a second time (game/close-pass.ts). | torus.closePassClear | [torus.ts:65](./torus.ts#L65) | | trumbles | TRUMBLE_PURGE_TEMP | 0.55 | The cabin heat that drives them out. | | [trumbles.ts:12](./trumbles.ts#L12) | | trumbles | BREED_INTERVAL | 20 | Seconds between broods. | trumbles.breedInterval | [trumbles.ts:20](./trumbles.ts#L20) | | trumbles | BREED_RATE | 1.6 | They multiply by this, plus one, every brood. | | [trumbles.ts:23](./trumbles.ts#L23) | diff --git a/src/constants/torus.ts b/src/constants/torus.ts index fb207057..6d657965 100644 --- a/src/constants/torus.ts +++ b/src/constants/torus.ts @@ -46,3 +46,20 @@ export const MASS_LOCK_PLANET_ALTITUDE = 4000; * @rule torus.massLockShip */ export const MASS_LOCK_SHIP = 4500; + +/** + * How far a ship must open back out before it can be announced a second time + * (game/close-pass.ts). A ship that comes inside `MASS_LOCK_SHIP` is named + * one time. A single line would repeat on every wobble across the radius. + * + * It is 1.5 times the lock radius. The hysteresis is 2,250 units, which is + * over 5 seconds of flight at the ordinary top speed. A pair of ships that + * hold station together therefore says nothing more. + * + * It lives here, beside `MASS_LOCK_SHIP`, because it is measured from that + * radius. A move would split one pair of numbers over two files. + * + * @rule torus.closePassClear + * @domain torus + */ +export const CLOSE_PASS_CLEAR = 6750; diff --git a/src/game/close-pass.ts b/src/game/close-pass.ts new file mode 100644 index 00000000..d3918fa9 --- /dev/null +++ b/src/game/close-pass.ts @@ -0,0 +1,69 @@ +// Who came close, and was not announced yet (docs/TODO/209). +// +// Chris flew a trip to the station and reported that a neutral trader did not +// stop the ship. The mass lock rule did fire when the torus drive ran. It did +// nothing when the drive was already off, and the drive is off for most of a +// trip. So a trader could pass at 1,000 units and say nothing at all. +// +// His own words about the sky, of 2026-09-11: "When anything is in range we +// should show a list of objects that can be engaged - these can be outright +// hostiles or neutral ships that we want to pirate." The target list already +// holds every ship in scanner range. The pilot had no reason to open it. +// +// THIS FILE ONLY SPEAKS. It never stops the ship, and it never picks a target. +// A neutral ship must not interrupt a course, because the pilot chose that +// course. The line tells the pilot that the chance is there. +// +// IT NAMES A TRADER, AND NOTHING ELSE. A hostile ship announces itself: it +// shoots, it raises the condition light, and the course offers a way out. The +// law's ships are a risk rather than a chance. A line that invites an attack +// on a Viper beside the station is bad advice. A trader is the ship +// Chris named, and a trader carries the cargo. +// +// It also says nothing inside the station's own mass lock. The pilot is on +// the approach there, and traffic is thick. +// +// THE FLAG IS ON THE SHIP, as the target pick is (`targets.ts`). A ship has no +// stable id, and its state is saved with it. The flag clears when the ship +// opens back out past `CLOSE_PASS_CLEAR`, so a second approach speaks again. + +import type * as THREE from 'three'; +import type { NpcShip } from './npc.ts'; +import { isHostileToPlayer } from './hostility.ts'; +import { shipArticle } from './targets.ts'; +import { CLOSE_PASS_CLEAR, MASS_LOCK_SHIP, MASS_LOCK_STATION } from '../constants/torus.ts'; + +/** Everything the rule reads. */ +export interface CloseView { + readonly npcs: readonly NpcShip[]; + readonly playerPos: THREE.Vector3; + readonly legalStatus: number; + /** how far the commander is from the station, for the truce */ + readonly playerToStation: number; +} + +/** + * The lines to show for the ships that came close since the last step. + * + * It sets `announcedClose` on each ship it names. It clears the flag on a ship + * that opened back out. + */ +export function closePassLines(v: CloseView): string[] { + const out: string[] = []; + if (v.playerToStation < MASS_LOCK_STATION) return out; + for (const npc of v.npcs) { + if (npc.role !== 'trader') continue; + const range = npc.object.position.distanceTo(v.playerPos); + if (range > CLOSE_PASS_CLEAR) { npc.state.announcedClose = false; continue; } + if (range > MASS_LOCK_SHIP) continue; + if (!npc.state.alive || npc.state.docked) continue; + if (npc.state.announcedClose) continue; + if (isHostileToPlayer(npc, v.legalStatus, v.playerToStation)) continue; + // A ship the pilot already picked, or already shot at, is not an offer. + // The pilot made the choice. The line would be an answer to nobody. + if (npc.state.targeted || npc.state.provokedByPlayer) continue; + npc.state.announcedClose = true; + out.push(`${shipArticle(npc)} IS CLOSE — OPEN TARGETS TO ATTACK IT`); + } + return out; +} diff --git a/src/game/flight-instruments.ts b/src/game/flight-instruments.ts index 776c6c8d..b73be4ff 100644 --- a/src/game/flight-instruments.ts +++ b/src/game/flight-instruments.ts @@ -43,7 +43,7 @@ const COURSE_ENDS: Partial> = { mine: 'NO ROCKS LEFT WITHIN RANGE', collect: 'EVERYTHING IS ABOARD', }; -import { massLocked } from './world-step.ts'; +import { massLocked, massLockCause } from './world-step.ts'; import { boundKey } from '../ui/key-help.ts'; import { defenceBrain } from './brains.ts'; import { defenceBrainNameFor } from './brain-names.ts'; @@ -327,8 +327,12 @@ export class Instruments { } toggleTorus(): void { - if (this.massLocked()) { - this.host.showMessage('MASS LOCKED', 2); + // The refusal names what holds the drive down, as the drop does + // (docs/TODO/209). The message said "MASS LOCKED" before. A pilot cannot + // tell from those two words that a trader stopped the drive. + const cause = massLockCause(this.state); + if (cause !== null) { + this.host.showMessage(`${cause} IS TOO CLOSE FOR THE TORUS DRIVE`, 2); sfx.refused(); return; } diff --git a/src/game/npc-state.ts b/src/game/npc-state.ts index 62a939fd..a0d4e0d2 100644 --- a/src/game/npc-state.ts +++ b/src/game/npc-state.ts @@ -119,6 +119,13 @@ export interface NpcState { * computer flies at. */ targeted: boolean; + /** + * This ship was already named as a close pass (docs/TODO/209). A neutral + * ship inside the mass lock radius is announced one time, so the pilot can + * pirate it. `close-pass.ts` owns the rule. It is saved, so a reload does + * not repeat the line. + */ + announcedClose: boolean; /** seconds under the scanner lock so far: a scan leg's clock */ observed: number; /** the escort or the scan verdict was sent once; it is never sent again */ @@ -268,7 +275,7 @@ export function freshNpcState(maxEnergy: number): NpcState { tumbleAxis: randomDirection(new THREE.Vector3()), energy: maxEnergy, regenCarry: 0, alive: true, provoked: false, provokedByPlayer: false, missiles: 0, - missionTag: null, targeted: false, observed: 0, missionReported: false, fleeing: false, attackPhase: 'closing', underFire: 0, flownBy: 'none', + missionTag: null, targeted: false, announcedClose: false, observed: 0, missionReported: false, fleeing: false, attackPhase: 'closing', underFire: 0, flownBy: 'none', extendRange: EXTEND_RANGE_MAX, passSide: 1, passesMade: 0, tactic: 'run', tacticClock: 0, dryFor: 0, tradeTimer: 0, diff --git a/src/game/targets.ts b/src/game/targets.ts index 438e7fc3..b38bdbfd 100644 --- a/src/game/targets.ts +++ b/src/game/targets.ts @@ -73,8 +73,7 @@ export function targetList(v: TargetView): TargetRow[] { return { row: { ship, - // A rock carries no name of its own, so it is called what it is. - name: (ship.object.name || STANDING[ship.role] || 'SHIP').toUpperCase(), + name: shipName(ship), range: ship.object.position.distanceTo(v.playerPos), standing, cost: costOf(ship.role), @@ -98,6 +97,26 @@ function costOf(role: string): string | null { return null; } +/** + * What the player calls one ship. A rock carries no name of its own, so it + * is called what it is. + * + * The mass lock message also names a ship (docs/TODO/209). It calls this, + * so the list and the message cannot use two different words for one ship. + */ +export function shipName(ship: NpcShip): string { + return (ship.object.name || STANDING[ship.role] || 'SHIP').toUpperCase(); +} + +/** + * ...and the same name with its article, where the words make a sentence. + * The mass lock and the close pass both need one (docs/TODO/209). + */ +export function shipArticle(ship: NpcShip): string { + const name = shipName(ship); + return `${'AEIOU'.includes(name[0]) ? 'AN' : 'A'} ${name}`; +} + /** The ship the pilot picked, if it still lives. */ export function pickedTarget(npcs: readonly NpcShip[]): NpcShip | null { return npcs.find((n) => n.state.targeted && n.state.alive) ?? null; diff --git a/src/game/world-step.ts b/src/game/world-step.ts index 6c6938a2..423a8ee6 100644 --- a/src/game/world-step.ts +++ b/src/game/world-step.ts @@ -43,6 +43,8 @@ import { CHARACTER_LINE_SECONDS, DISREPUTE_CAUGHT } from '../constants/character import { queueMessage } from './session.ts'; import { playerVsNpcs, npcVsNpcs, npcsVsStation } from './collisions.ts'; import { assignNpcTargets } from './npc-targeting.ts'; +import { shipArticle } from './targets.ts'; +import { closePassLines } from './close-pass.ts'; import { stepEncounters } from './encounters.ts'; import { spawnArrivingTrader, spawnPassingTrader } from './spawning.ts'; import { STATION_TRUCE } from '../constants/law.ts'; @@ -96,22 +98,36 @@ import { AUTOSAVE_INTERVAL } from '../constants/saves.ts'; const WARHEAD_FLASH = rgb24(HUD.amber); /** - * Anything close enough to hold the torus drive down. + * WHAT is close enough to hold the torus drive down, in the player's words, + * or null for a clear sky (docs/TODO/209). + * + * The lock said only that it happened. Chris flew the trip in. He could not tell + * that a neutral trader stopped the drive. So the lock names what + * stopped it, and the console line carries the name. * * A free function over the state, so the flight keys and the step share one * rule and `window.__game.massLocked()` keeps working for the harnesses. The * three radii live together in constants/torus.ts, beside the drive they cut. */ -export function massLocked(state: GameState): boolean { +export function massLockCause(state: GameState): string | null { const { player, world } = state; - if (player.position.distanceTo(world.station.position) < MASS_LOCK_STATION) return true; + if (player.position.distanceTo(world.station.position) < MASS_LOCK_STATION) return 'THE STATION'; if (player.position.distanceTo(world.planetPos) - world.planetRadius - < MASS_LOCK_PLANET_ALTITUDE) return true; + < MASS_LOCK_PLANET_ALTITUDE) return 'THE PLANET'; + // A ship comes with its article, because the message reads as a sentence. + let nearest: { name: string; range: number } | null = null; for (const npc of world.npcs) { - if (npc.state.alive && npc.role !== 'asteroid' && - npc.object.position.distanceTo(player.position) < MASS_LOCK_SHIP) return true; + if (!npc.state.alive || npc.role === 'asteroid') continue; + const range = npc.object.position.distanceTo(player.position); + if (range >= MASS_LOCK_SHIP) continue; + if (nearest === null || range < nearest.range) nearest = { name: shipArticle(npc), range }; } - return false; + return nearest?.name ?? null; +} + +/** Is anything close enough to hold the torus drive down? */ +export function massLocked(state: GameState): boolean { + return massLockCause(state) !== null; } /** @@ -311,9 +327,10 @@ export class WorldStep { // torus drive if (session.torusEngaged) { - if (this.massLocked()) { + const cause = massLockCause(this.state); + if (cause !== null) { session.torusEngaged = false; - out.push(say('MASS LOCK — TORUS DISENGAGED', 3)); + out.push(say(`TORUS DRIVE OFF — ${cause} IS TOO CLOSE`, 3)); out.push(heard('torusDropped')); } else { // ONE LESS THAN THE MULTIPLIER. `player.update()` above already flew @@ -416,6 +433,15 @@ export class WorldStep { // the same frame. const playerToStation = player.position.distanceTo(world.station.position); + // A neutral ship that comes close says so, one time (docs/TODO/209). The + // mass lock only spoke with the torus drive running, and the drive is off + // for most of a trip. The rule is `close-pass.ts`, and this pushes what it + // decided (invariant 15). + for (const line of closePassLines({ + npcs: world.npcs, playerPos: player.position, + legalStatus: s.commander.legalStatus, playerToStation, + })) out.push(say(line, 4)); + // periodic NPC-vs-NPC targeting: pirates prey on traders, the law hunts pirates session.npcTargetTimer -= dt; if (session.npcTargetTimer <= 0) { diff --git a/test/close-pass.test.ts b/test/close-pass.test.ts new file mode 100644 index 00000000..7a2ae2e0 --- /dev/null +++ b/test/close-pass.test.ts @@ -0,0 +1,95 @@ +// A neutral trader that comes close says so, one time (docs/TODO/209). +// +// Chris flew a trip to the station. He reported that a neutral trader did not +// mass lock him. The lock did fire when the torus drive ran. The drive is off +// for most of a trip, so most passes said nothing at all. +// +// A real World with ships placed by hand, as `test/targets.test.ts` does. + +import * as THREE from 'three'; +import { World } from '../src/game/world.ts'; +import { seedWorld } from '../src/game/rng.ts'; +import { generateGalaxy } from '../src/galaxy/galaxy.ts'; +import { closePassLines } from '../src/game/close-pass.ts'; +import { CLOSE_PASS_CLEAR, MASS_LOCK_SHIP, MASS_LOCK_STATION } from '../src/constants/torus.ts'; +import { check, eq } from './harness.ts'; + +console.log('\nthe close pass'); + +seedWorld(20_260_912); +const world = new World(); +world.build(generateGalaxy(1)[7]); +world.clearNpcs(); +// Far from the station, so the truce holds nobody back. +const here = world.station.position.clone().add(new THREE.Vector3(0, 0, 60_000)); +const at = (d: number) => here.clone().add(new THREE.Vector3(d, 0, 0)); +const trader = world.spawn('trader', at(MASS_LOCK_SHIP - 500), 1); +world.spawn('pirate', at(1000), 2); +const rock = world.spawn('asteroid', at(300), 3); +const far = world.spawn('trader', at(MASS_LOCK_SHIP + 500), 4); + +const lines = (toStation = 60_000): string[] => closePassLines({ + npcs: world.npcs, playerPos: here, legalStatus: 0, playerToStation: toStation, +}); + +const first = lines(); +eq('one line, for the one trader inside the lock radius', first.length, 1); +check('...and it names the ship', first[0].includes(trader.object.name.toUpperCase())); +check('...and it says what to do with it', first[0].includes('TARGETS')); +check('the pirate gets no line, because it announces itself, and it is not a trader', + world.npcs.some((n) => n.role === 'pirate') && first.length === 1); +check('...the rock gets none either', rock.role === 'asteroid' && first.length === 1); +check('...and a trader beyond the radius waits its turn', + !first.join().includes(far.object.name.toUpperCase())); + +eq('the same trader says nothing a second time', lines().length, 0); +far.object.position.copy(at(MASS_LOCK_SHIP - 100)); +eq('...and the second trader speaks when it arrives', lines().length, 1); + +// The flag clears only when the ship opens back out, so a wobble across the +// radius does not repeat the line. +trader.object.position.copy(at(MASS_LOCK_SHIP + 100)); +eq('a ship just outside the radius stays quiet, and keeps its flag', lines().length, 0); +trader.object.position.copy(at(MASS_LOCK_SHIP - 100)); +eq('...so a step back inside says nothing', lines().length, 0); +trader.object.position.copy(at(CLOSE_PASS_CLEAR + 100)); +eq('...but a ship that really left lets go of the flag', lines().length, 0); +check('...and the flag is down', !trader.state.announcedClose); +trader.object.position.copy(at(MASS_LOCK_SHIP - 100)); +eq('...so a second approach speaks again', lines().length, 1); + +// The approach to the station is thick with traffic, and the pilot is busy. +for (const n of world.npcs) n.state.announcedClose = false; +eq('inside the station mass lock, nothing speaks', lines(MASS_LOCK_STATION - 1).length, 0); + +world.clearNpcs(); +const dead = world.spawn('trader', at(1200), 5); +dead.state.alive = false; +const docked = world.spawn('trader', at(1300), 6); +docked.state.docked = true; +eq('a wreck is not a chance to pirate, and neither is a docked ship', lines().length, 0); + +// A trader that the commander shot at is still a trader. `isHostileToPlayer` +// owns who attacks the commander, and this file restates none of that rule. +// It silences the pirate above. It says nothing about a trader. +world.clearNpcs(); +const shot = world.spawn('trader', at(1400), 7); +shot.state.provokedByPlayer = true; +eq('a trader you already shot at is a fight you started, not an offer', lines().length, 0); +world.clearNpcs(); +const picked = world.spawn('trader', at(1400), 8); +picked.state.targeted = true; +eq('...and the ship the pilot picked needs no invitation either', lines().length, 0); +world.clearNpcs(); +world.spawn('trader', at(1400), 9); +eq('...where a trader nobody touched does speak (the control)', lines().length, 1); +// The article is `shipArticle` in targets.ts, so the list and the line cannot +// disagree about one ship. A message that said "A OPHIDIAN" read as a fault. +world.clearNpcs(); +const vowel = world.spawn('trader', at(1400), 10); +vowel.object.name = 'Ophidian'; +check('a name that starts with a vowel takes AN', lines()[0].startsWith('AN OPHIDIAN')); +world.clearNpcs(); +const cons = world.spawn('trader', at(1400), 11); +cons.object.name = 'Boa'; +check('...and every other name takes A', lines()[0].startsWith('A BOA')); diff --git a/test/run.ts b/test/run.ts index 7fb863b3..0355a7ca 100644 --- a/test/run.ts +++ b/test/run.ts @@ -77,6 +77,7 @@ import './course-launch.test.ts'; import './course-buttons.test.ts'; import './skip.test.ts'; import './targets.test.ts'; +import './close-pass.test.ts'; import './aim.test.ts'; import './fight-buttons.test.ts'; import './run-and-offers.test.ts'; diff --git a/test/world-step.test.ts b/test/world-step.test.ts index d0c7827c..d343ef9a 100644 --- a/test/world-step.test.ts +++ b/test/world-step.test.ts @@ -28,6 +28,7 @@ import { World } from '../src/game/world.ts'; import { WorldStep, massLocked, + massLockCause, type StepEvent, type StepHost, } from '../src/game/world-step.ts'; @@ -285,7 +286,7 @@ console.log('\nheadless world step'); .add(new THREE.Vector3(0, 0, MASS_LOCK_STATION * 0.6)); // inside the mass lock const events = fly(run, 1); check('a mass lock returns a message instead of calling a HUD', - events.some((e) => e.kind === 'message' && e.text.startsWith('MASS LOCK'))); + events.some((e) => e.kind === 'message' && e.text.startsWith('TORUS DRIVE OFF'))); // ...and the same for the noise it makes. The step reached straight into // the audio singleton for this one until sounds became events too. check('...and the named sound with it, rather than reaching for an AudioContext', @@ -863,6 +864,28 @@ console.log('\nheadless world step'); MASS_LOCK_PLANET_ALTITUDE > PLANET_CRASH_ALTITUDE * 10); } + // ...AND THE LOCK NAMES WHAT HOLDS THE DRIVE DOWN (docs/TODO/209). + // + // Chris flew a trip to the station and reported no mass lock on a neutral + // trader. The rule did fire. The message did not say which ship stopped the + // drive, so the stop looked like nothing at all. + { + const run = arrival(4251); + const DEEP = new THREE.Vector3(1e7, 1e7, 1e7); + run.state.player.position.copy(run.state.world.station.position); + check('the lock names the station', massLockCause(run.state) === 'THE STATION'); + run.state.player.position.copy(run.state.world.planetPos) + .add(new THREE.Vector3(0, 0, run.state.world.planetRadius + 10)); + check('...and the planet', massLockCause(run.state) === 'THE PLANET'); + run.state.player.position.copy(DEEP); + check('...and a clear sky holds nothing', massLockCause(run.state) === null); + const trader = run.state.world.spawn('trader', DEEP.clone().add(new THREE.Vector3(0, 0, 10)), 0); + const name = massLockCause(run.state); + check(`...and a neutral trader by its own name (measured ${String(name)})`, + name === `A ${trader.object.name.toUpperCase()}` && trader.object.name !== ''); + check('...and `massLocked` stays the same rule', massLocked(run.state)); + } + // THE TORUS IS EIGHT TIMES ORDINARY FLIGHT, and the step adds seven of them // because `player.update()` has already flown the first. // From d3d033c4eca3ddb5af548bd0cfd1155628631d28 Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Sat, 12 Sep 2026 10:19:10 +0100 Subject: [PATCH 037/100] docs/TODO/210: the ship does not roll all the way there Chris flew a course and reported that the ship rotates all the way to its target. He is right, and the measurement is large: a median trip to the station cost 41 full turns of roll with traffic, and 7.8 with a clear sky. The steering (`bankToTurn`) gates the pitch by the cosine of the roll error. That soft gate leaves a little pitch at a wide bank. Near the nose it is enough to hold a cone, because a bearing turns by `pitch / theta`. A trace caught the equilibrium: 0.25 rad/s of roll held against 0.0087 of pitch, at a fixed 0.035 off the nose, for ever. `bankToTurn` takes a hard roll gate now. Above that roll error it asks for no pitch at all, so the roll alone turns the bearing, the bank arrives, and the pitch then closes the angle. The course pilot passes 0.05 radians, with a 0.02 deadzone at the nose. Every combat caller passes none and is untouched: its targets manoeuvre, and a pitch held still costs time on the gun. With a clear sky the trip is the same trip: 20 of 20 reach the hand-over, at the same time and the same speed. The roll fell from 7.8 full turns to 0.2. With traffic the median fell from 41 to 1.3, and what is left is all in a fight, under the combat computer. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- ...he-ship-does-not-roll-all-the-way-there.md | 94 +++++++++++++++++++ docs/TODO/completed/README.md | 1 + src/constants/CATALOG.md | 36 +++---- src/constants/course.ts | 51 ++++++++++ src/game/course-pilot.ts | 9 +- src/game/pitch-roll-steer.ts | 27 +++++- test/course-pilot.test.ts | 24 +++++ test/pitch-roll-steer.test.ts | 25 +++++ 8 files changed, 247 insertions(+), 20 deletions(-) create mode 100644 docs/TODO/completed/210-the-ship-does-not-roll-all-the-way-there.md diff --git a/docs/TODO/completed/210-the-ship-does-not-roll-all-the-way-there.md b/docs/TODO/completed/210-the-ship-does-not-roll-all-the-way-there.md new file mode 100644 index 00000000..9d6defc2 --- /dev/null +++ b/docs/TODO/completed/210-the-ship-does-not-roll-all-the-way-there.md @@ -0,0 +1,94 @@ +# 210 — The ship does not roll all the way there + +**Kind:** bug · **Severity:** high · **Size:** small · **Depends on:** 205 · +**Blocks:** nothing · **GitHub:** none + +## Where we are + +**Chris flew a course and reported a fault** (2026-09-12: *"There is something +a bit annoying - we seem to be constantly rotating when heading towards +something. I don't remember this happening with the combat computer."*). + +**He is right, and the measurement is large.** A trip to the station cost 41 +full turns of roll on a median run with traffic, and 7.8 with a clear sky. The +roll moved in 92% of the samples. + +**The steering is `bankToTurn`** (`game/pitch-roll-steer.ts`). The ship has no +yaw axis. To point the nose it rolls the target onto the vertical plane, then +pitches up to it. The pitch is gated by the cosine of the roll error, so the +ship pulls once the bank is nearly there. + +**The soft gate leaves a cone.** A trace of 2026-09-12 caught the equilibrium. +The ship rolled at 0.25 radians a second. The pitch that the soft gate still +allowed was 0.0087. The nose then circled the target at a fixed 0.035 radians +off, for ever, because a bearing turns by `pitch / theta`. Near the nose that +ratio is huge, and the two rates cancel exactly. + +**The combat computer never shows it**, which is why Chris does not remember +it. It passes the gun's own hit cone as a null band. That cone is wide up +close, and the computer holds the sticks still inside it. + +## What to do + +**M1 — the course pilot gets a hard roll gate.** + +1. Add a `rollGate` parameter to `bankToTurn`. Above that roll error it asks + for no pitch at all. The default is 0, which keeps every combat caller + exactly as it is. +2. Add `COURSE_ROLL_GATE` (0.05 radians) and `COURSE_AIM_DEADZONE` (0.02 + radians) to `constants/course.ts`. The course pilot passes both. +3. Pin the gate in `test/pitch-roll-steer.test.ts`. +4. Pin the whole trip in `test/course-pilot.test.ts`: less than one full turn + of roll from the witchpoint to the hand-over. + +## Decisions already made + +- **The fight keeps the law it has.** Its targets manoeuvre. A pitch held + still while the roll catches up is time off the gun. The probes that tune + the fight are `aim-probe`, `defence-probe` and `survivability`. + +## Open questions + +- **Should the fight take the gate too?** A measurement of 2026-09-12 shows + that all the roll left on a trip with traffic happens under the combat + computer, in a fight. Chris did not report it, and a dogfight rolls for real + reasons. This is his call. + +## Watch out for + +- **The gate must not cost an arrival.** Measure the trips that reach the + hand-over, the time and the speed. +- **A tighter gate costs time in a big turn**, because the roll must finish + first. + +## Verification + +1. The count of full turns over a trip, before and after. +2. Trips that reach the hand-over, with the time and the speed at hand-over. +3. The new test fails with the gate set to zero. + +## What the milestones found + +**The numbers, over 20 trips with a clear sky:** + +| | before | after | +| --- | --- | --- | +| full turns of roll, p50 | 7.8 | 0.2 | +| trips that reach the hand-over | 20 of 20 | 20 of 20 | +| seconds to the hand-over, p50 | 39.5 | 39.4 | +| speed at the hand-over, p50 | 227.7 | 227.7 | + +**And with traffic, over 10 trips:** the median fell from 41 full turns to 1.3. +The roll that is left is all in a fight, under the combat computer. A split of +the same runs put 39.2 of 39.3 turns there, and 0.1 on the course. + +**The gate is what fixes it, not the deadzone.** A sweep of the deadzone alone +gave 37.7 turns at 0.02 radians, 34.7 at 0.05 and 44.1 at 0.08. The hard gate +gave 5.5 turns at 0.2 radians, 2.9 at 0.1 and 1.3 at 0.05. + +**The test fails without it.** With `COURSE_ROLL_GATE` set to zero, the trip +test reports 7.38 turns against a limit of one. + +## Outcome + +Landed on 2026-09-12. `npm run check` passes. diff --git a/docs/TODO/completed/README.md b/docs/TODO/completed/README.md index 124fed36..07ee16be 100644 --- a/docs/TODO/completed/README.md +++ b/docs/TODO/completed/README.md @@ -219,3 +219,4 @@ Supporting records: [Elite-A alignment plan](ELITE-A-COMBAT-PLAN.md), - [x] 207 — [The pilot takes the ship into the slot by hand](207-the-pilot-takes-the-ship-into-the-slot-by-hand.md) — Chris, 2026-09-11. He played four concepts and picked Match the spin. **M1** hands the last 1,500 units to the pilot. **M2** is the roll strip and the throttle buttons. **M3** is the slot's speed limit. **M4** is the guide. 5,820 assertions. - [x] 208 — [Every kind of mission has a way to fly it](208-every-kind-of-mission-has-a-way-to-fly-it.md) — Chris, 2026-09-12. **M1 and M2** give each verb a course, in the job's own words. **M3** mends the scoop trap and two faults in the hunt. **M4** is the smuggling run wide of the police. **M5** is what a derelict's scan reports. 5,845 assertions. - [x] 209 — [The torus drive says what stopped it](209-the-drive-says-what-stopped-it.md) — Chris, 2026-09-12. He flew to the station and saw no mass lock on a neutral trader. The rule did fire. **M1** makes the drop name what stopped the drive, because "MASS LOCK" named nothing. **M2** announces a neutral trader that comes close, one time, because the drive is off for most of a trip. 5,871 assertions. +- [x] 210 — [The ship does not roll all the way there](210-the-ship-does-not-roll-all-the-way-there.md) — Chris, 2026-09-12. He flew a course and saw the ship rotate all the way to its target. The steering held a cone: the nose circled the target, and the roll never stopped. **M1** gives the course pilot a hard roll gate, which holds the pitch still until the bank arrives. A median trip fell from 41 full turns of roll to 1.3. The fight keeps the law it has. 5,877 assertions. diff --git a/src/constants/CATALOG.md b/src/constants/CATALOG.md index 9a397129..aabbaffb 100644 --- a/src/constants/CATALOG.md +++ b/src/constants/CATALOG.md @@ -2,7 +2,7 @@ -443 exported constants. Regenerate with `npm run generate:constants`; +445 exported constants. Regenerate with `npm run generate:constants`; search names, meanings and values with `npm run constants:find -- ""`. | Domain | Symbol | Literal / expression | Purpose | Rule ID | Source | @@ -115,22 +115,24 @@ search names, meanings and values with `npm run constants:find -- ""`. | contracts | PASSENGER_BERTH_TONNES | 2 | What one passenger costs the hold, in tonnes. | contracts.passengerBerthTonnes | [contracts.ts:51](./contracts.ts#L51) | | contracts | SMUGGLE_DELIVERY_NOTORIETY | 0.06 | How loudly a delivered smuggling run is talked about, per tonne landed. | contracts.smuggleDeliveryNotoriety | [contracts.ts:81](./contracts.ts#L81) | | course | COURSE_TORUS_CONE | 0.1 | How far off the nose the target may sit, in radians, before the course pilot engages the torus drive. | course.torusCone | [course.ts:32](./course.ts#L32) | -| course | COURSE_TORUS_DROP | TORUS_MULTIPLIER * PLAYER_FLIGHT.maxSpeed * 2.5 | How far from its target the course pilot drops the torus drive, in world units, before an arrival. | | [course.ts:45](./course.ts#L45) | -| course | COURSE_ARRIVE_BRAKE | 0.7 | The share of the ship's thrust that an arrival plans to brake with. | course.arriveBrake | [course.ts:57](./course.ts#L57) | -| course | COURSE_ARRIVE_TOLERANCE | 75 | How near its standoff the ship must be to count as arrived, in world units. | course.arriveTolerance | [course.ts:67](./course.ts#L67) | -| course | COURSE_DERELICT_STANDOFF | GENERATION_CARGO_SCATTER + 400 | Where the derelict course stops, as a distance from the generation ship's centre, in world units. | | [course.ts:80](./course.ts#L80) | -| course | COURSE_HERMIT_STANDOFF | 240 | Where the hermit course stops, as a distance from the rock's centre, in world units. | course.hermitStandoff | [course.ts:93](./course.ts#L93) | -| course | COURSE_SKIM_DISTANCE | 65_000 | The hold distance of the skim course, from the centre of the star, in world units. | course.skimDistance | [course.ts:108](./course.ts#L108) | -| course | COURSE_PLANET_CLEARANCE | MASS_LOCK_PLANET_ALTITUDE * 1.25 | How high above the planet's surface a course keeps its line, in world units. | | [course.ts:120](./course.ts#L120) | -| course | COURSE_HERMIT_SPEED | HERMIT_DOCK_SPEED / 2 | The speed at which the hermit course arrives, in world units a second. | | [course.ts:130](./course.ts#L130) | -| course | SKIP_SPEED | 8 | How much faster the world runs under the fast forward button, as a count of fixed steps in one screen frame (docs/TODO/205 M7). | course.skipSpeed | [course.ts:146](./course.ts#L146) | -| course | RUN_CLOSE_MARGIN | 50 | Below this lead in top speed, in world units a second, the run row says the ship is only a little faster (docs/TODO/206 M5). | course.runCloseMargin | [course.ts:160](./course.ts#L160) | -| course | COURSE_RUN_REACH | 50_000 | How far ahead the run course aims, in world units, on the line away from the hostile ships (docs/TODO/206 M5). | course.runReach | [course.ts:170](./course.ts#L170) | -| course | COURSE_COLLECT_SPEED | 60 | How fast the collect course flies onto a canister, in world units a second (docs/TODO/206 M6). | course.collectSpeed | [course.ts:184](./course.ts#L184) | -| course | COURSE_DOCK_HANDOVER | 1500 | How far from the station the station course hands the ship to the pilot, in world units (docs/TODO/207 M1). | course.dockHandover | [course.ts:198](./course.ts#L198) | -| course | COURSE_WATCH_STANDOFF | 1200 | How far from a ship the scan course holds, in world units (docs/TODO/208 M2). | course.watchStandoff | [course.ts:212](./course.ts#L212) | -| course | COURSE_ESCORT_STANDOFF | 600 | How far from its charge the escort course flies, in world units (docs/TODO/208 M2). | course.escortStandoff | [course.ts:225](./course.ts#L225) | -| course | COURSE_POLICE_CLEARANCE | SCAN_WARN_RANGE | How wide of a police ship the smuggling course flies, in world units (docs/TODO/208 M4). | | [course.ts:238](./course.ts#L238) | +| course | COURSE_AIM_DEADZONE | 0.02 | How near the nose a course counts its target as straight ahead, in radians. | | [course.ts:56](./course.ts#L56) | +| course | COURSE_ROLL_GATE | 0.05 | How near its bank a course pilot must be before it pulls the nose, in radians. | | [course.ts:83](./course.ts#L83) | +| course | COURSE_TORUS_DROP | TORUS_MULTIPLIER * PLAYER_FLIGHT.maxSpeed * 2.5 | How far from its target the course pilot drops the torus drive, in world units, before an arrival. | | [course.ts:96](./course.ts#L96) | +| course | COURSE_ARRIVE_BRAKE | 0.7 | The share of the ship's thrust that an arrival plans to brake with. | course.arriveBrake | [course.ts:108](./course.ts#L108) | +| course | COURSE_ARRIVE_TOLERANCE | 75 | How near its standoff the ship must be to count as arrived, in world units. | course.arriveTolerance | [course.ts:118](./course.ts#L118) | +| course | COURSE_DERELICT_STANDOFF | GENERATION_CARGO_SCATTER + 400 | Where the derelict course stops, as a distance from the generation ship's centre, in world units. | | [course.ts:131](./course.ts#L131) | +| course | COURSE_HERMIT_STANDOFF | 240 | Where the hermit course stops, as a distance from the rock's centre, in world units. | course.hermitStandoff | [course.ts:144](./course.ts#L144) | +| course | COURSE_SKIM_DISTANCE | 65_000 | The hold distance of the skim course, from the centre of the star, in world units. | course.skimDistance | [course.ts:159](./course.ts#L159) | +| course | COURSE_PLANET_CLEARANCE | MASS_LOCK_PLANET_ALTITUDE * 1.25 | How high above the planet's surface a course keeps its line, in world units. | | [course.ts:171](./course.ts#L171) | +| course | COURSE_HERMIT_SPEED | HERMIT_DOCK_SPEED / 2 | The speed at which the hermit course arrives, in world units a second. | | [course.ts:181](./course.ts#L181) | +| course | SKIP_SPEED | 8 | How much faster the world runs under the fast forward button, as a count of fixed steps in one screen frame (docs/TODO/205 M7). | course.skipSpeed | [course.ts:197](./course.ts#L197) | +| course | RUN_CLOSE_MARGIN | 50 | Below this lead in top speed, in world units a second, the run row says the ship is only a little faster (docs/TODO/206 M5). | course.runCloseMargin | [course.ts:211](./course.ts#L211) | +| course | COURSE_RUN_REACH | 50_000 | How far ahead the run course aims, in world units, on the line away from the hostile ships (docs/TODO/206 M5). | course.runReach | [course.ts:221](./course.ts#L221) | +| course | COURSE_COLLECT_SPEED | 60 | How fast the collect course flies onto a canister, in world units a second (docs/TODO/206 M6). | course.collectSpeed | [course.ts:235](./course.ts#L235) | +| course | COURSE_DOCK_HANDOVER | 1500 | How far from the station the station course hands the ship to the pilot, in world units (docs/TODO/207 M1). | course.dockHandover | [course.ts:249](./course.ts#L249) | +| course | COURSE_WATCH_STANDOFF | 1200 | How far from a ship the scan course holds, in world units (docs/TODO/208 M2). | course.watchStandoff | [course.ts:263](./course.ts#L263) | +| course | COURSE_ESCORT_STANDOFF | 600 | How far from its charge the escort course flies, in world units (docs/TODO/208 M2). | course.escortStandoff | [course.ts:276](./course.ts#L276) | +| course | COURSE_POLICE_CLEARANCE | SCAN_WARN_RANGE | How wide of a police ship the smuggling course flies, in world units (docs/TODO/208 M4). | | [course.ts:289](./course.ts#L289) | | docking | GATE_HALF_WIDTHS | 5 | How far out the approach gate sits, in multiples of the station half-width. | docking.gateHalfWidths | [docking.ts:25](./docking.ts#L25) | | docking | TURN_IN | Math.PI / 4 | How far round from the slot axis an approach turns in, in radians. | | [docking.ts:49](./docking.ts#L49) | | docking | RUN_IN_WIDTHS | GATE_HALF_WIDTHS * 0.6 | Where the approach stops the curve and flies straight, in station half-widths. | | [docking.ts:87](./docking.ts#L87) | diff --git a/src/constants/course.ts b/src/constants/course.ts index e47782e5..6c341bf2 100644 --- a/src/constants/course.ts +++ b/src/constants/course.ts @@ -31,6 +31,57 @@ import { SCAN_WARN_RANGE } from './law.ts'; */ export const COURSE_TORUS_CONE = 0.1; +/** + * How near the nose a course counts its target as straight ahead, in radians. + * Inside this cone the course pilot asks for no pitch and no roll. + * + * THE SHIP ROLLED ALL THE WAY TO THE STATION WITHOUT IT (Chris, 2026-09-12: + * *"we seem to be constantly rotating when heading towards something"*). The + * steering is `bankToTurn` (game/pitch-roll-steer.ts). Its roll ask is a + * BEARING: how far round the clock the target sits from the vertical. That + * bearing stays large for a target a hair off the nose, and the roll fade has + * a floor. So the course rolled for ever to chase the last fraction of a + * degree. A measurement of 2026-09-12 counted 41 full turns on a median trip + * to the station, with the roll moving in 92% of the samples. + * + * The combat computer never had the fault. It passes the gun's own hit cone, + * which is wide up close, and it holds the sticks still inside it. + * + * 0.02 radians is 1.1 degrees. At the hand-over range of 1,500 units it is 30 + * units off the line, which the last of the approach closes. It is a fifth of + * `COURSE_TORUS_CONE`, so the drive stays engaged inside it. + * + * @domain course + */ +export const COURSE_AIM_DEADZONE = 0.02; + +/** + * How near its bank a course pilot must be before it pulls the nose, in + * radians. Above this angle the steering asks for no pitch at all. + * + * IT IS WHAT STOPS THE SHIP ROLLING ALL THE WAY THERE. `bankToTurn` gates the + * pitch by the cosine of the roll error, which still leaves a little pitch at + * a wide bank. Near the nose that little is enough to hold a cone: the nose + * circles the target, and the angle never closes. The comment on `bankToTurn` + * (game/pitch-roll-steer.ts) holds the measurement. + * + * 0.05 radians is 2.9 degrees. A sweep of 2026-09-12 over 6 trips to the + * station measured the median count of full turns on the way: + * + * | gate | full turns | + * | --- | --- | + * | none | 41 | + * | 0.2 | 5.5 | + * | 0.1 | 2.9 | + * | 0.05 | 1.3 | + * + * A tighter gate costs a little time in a big turn, because the roll must + * finish first. The roll is the faster axis, so the cost is small. + * + * @domain course + */ +export const COURSE_ROLL_GATE = 0.05; + /** * How far from its target the course pilot drops the torus drive, in world * units, before an arrival. diff --git a/src/game/course-pilot.ts b/src/game/course-pilot.ts index 3f4ac3a8..ccab044b 100644 --- a/src/game/course-pilot.ts +++ b/src/game/course-pilot.ts @@ -39,7 +39,7 @@ import type { CourseKind } from './courses.ts'; import { PLAYER_FLIGHT } from '../constants/player-flight.ts'; import { SLOT_SPEED_LIMIT } from '../constants/docking.ts'; import { - COURSE_ARRIVE_BRAKE, COURSE_ARRIVE_TOLERANCE, COURSE_DERELICT_STANDOFF, + COURSE_AIM_DEADZONE, COURSE_ROLL_GATE, COURSE_ARRIVE_BRAKE, COURSE_ARRIVE_TOLERANCE, COURSE_DERELICT_STANDOFF, COURSE_HERMIT_SPEED, COURSE_HERMIT_STANDOFF, COURSE_PLANET_CLEARANCE, COURSE_COLLECT_SPEED, COURSE_ESCORT_STANDOFF, COURSE_RUN_REACH, COURSE_SKIM_DISTANCE, COURSE_POLICE_CLEARANCE, COURSE_TORUS_CONE, COURSE_TORUS_DROP, COURSE_WATCH_STANDOFF, @@ -239,7 +239,12 @@ export class CoursePilot { v: CourseView, point: THREE.Vector3, throttle: number, dt: number, ): { demand: FlightDemand; torus: boolean } { this.dir.subVectors(point, v.position); - const stick = bankToTurn(v.quaternion, this.dir, this.mem); + // TWO NUMBERS KEEP THE SHIP FROM ROLLING ALL THE WAY THERE. The deadzone + // holds the sticks still inside 1.1 degrees of the nose. The roll gate + // holds the pitch still until the bank arrives, which is what stops the + // nose from circling the target. See both constants. + const stick = bankToTurn( + v.quaternion, this.dir, this.mem, COURSE_AIM_DEADZONE, COURSE_ROLL_GATE); this.fwd.set(0, 0, -1).applyQuaternion(v.quaternion); return { demand: { diff --git a/src/game/pitch-roll-steer.ts b/src/game/pitch-roll-steer.ts index 7be1ba20..ebfd129e 100644 --- a/src/game/pitch-roll-steer.ts +++ b/src/game/pitch-roll-steer.ts @@ -87,6 +87,27 @@ function wrap(a: number): number { * target. It is the caller's gun cone, which is WIDE up close, because a near * target subtends a wide angle. Inside it the controller asks for NOTHING. * + * `rollGate` is the angle inside which the BANK counts as finished. Above it + * this asks for no pitch at all. Zero keeps the soft gate alone, which is the + * `cos` of the roll error, and every combat caller passes zero. + * + * THE SOFT GATE ALONE CAN CONE (Chris, 2026-09-12: *"we seem to be constantly + * rotating when heading towards something"*). A target a hair off the nose + * makes the bearing very sensitive to pitch, because the bearing turns by + * `pitch / theta`. The ship then finds an equilibrium. It rolls at a steady + * rate. The small pitch that the soft gate still allows turns the bearing back + * at the same rate. The nose circles the target for ever, and + * `theta` never closes. A trace of 2026-09-12 caught it: 0.25 radians a second + * of roll held against 0.0087 of pitch, at a fixed 0.035 off the nose. + * + * A hard gate breaks the equilibrium. With no pitch, the roll alone turns the + * bearing, the bank arrives, and the pitch then closes the angle. On a course + * to the station it took a median trip from 41 full turns to 1.3. + * + * The combat computer must NOT take it. Its target manoeuvres, and a pitch + * held still while the roll catches up is time off the gun. It also never sees + * the fault, because it stops steering inside its own wide gun cone. + * * That is the seasickness fix. A target that already fills the gun still has a * bearing, and that bearing swings as it drifts a hair off centre. A bank to * chase the last degree chatters the roll axis for a correction the gun does @@ -101,6 +122,7 @@ function wrap(a: number): number { */ export function bankToTurn( quat: THREE.Quaternion, dir: THREE.Vector3, mem: SteerMemory, nullBand = 0, + rollGate = 0, ): StickCommand { if (dir.lengthSq() < 1e-12) return { pitch: 0, roll: 0 }; dirNorm.copy(dir).normalize(); @@ -173,7 +195,10 @@ export function bankToTurn( const pitchSat = localZ > 0 ? STEER_PITCH_SATURATION + (STEER_SATURATION - STEER_PITCH_SATURATION) * (1 - localZ) : STEER_SATURATION; - const pitch = Math.max(-1, Math.min(1, theta / pitchSat)) + // `rollGate` HOLDS THE PITCH STILL UNTIL THE BANK ARRIVES. It is 0 for the + // combat computer, which keeps the soft `cos` gate alone. See the parameter. + const pitch = rollGate > 0 && Math.abs(rollErr) > rollGate ? 0 + : Math.max(-1, Math.min(1, theta / pitchSat)) * mem.side * Math.max(0, Math.cos(rollErr)); return { pitch, roll }; diff --git a/test/course-pilot.test.ts b/test/course-pilot.test.ts index 3ba65802..6988f944 100644 --- a/test/course-pilot.test.ts +++ b/test/course-pilot.test.ts @@ -151,6 +151,30 @@ console.log('\nwith no docking computer, the course hands the slot to the pilot' g.state.session.course, null); } +// THE SHIP MUST NOT ROLL ALL THE WAY THERE (docs/TODO/210). +// +// Chris, 2026-09-12: *"we seem to be constantly rotating when heading towards +// something"*. The steering held a cone: the nose circled the target at a +// fixed angle, and the roll never stopped. The measurement is the total roll +// over a whole trip, in full turns. It was 7.8 turns with a clear sky. +console.log('\nthe course does not roll the ship all the way there'); +{ + const g = arrived(20_260_935); + g.state.session.course = 'station'; + const dt = 1 / 60; + let rolled = 0; + withoutSaving(() => { + for (let f = 0, at = 0; f < 240 / dt && !g.state.session.dockTrial; f++) { + g.step(dt, at += dt); + rolled += Math.abs(g.state.player.rollRate) * dt; + } + }); + const turns = rolled / (2 * Math.PI); + check('the whole trip to the station costs less than one full turn of roll', + turns < 1, `${turns.toFixed(2)} turns`); + check('...and the ship still arrives', g.state.session.dockTrial); +} + console.log('\n...and a flight key takes the ship back'); { const g = arrived(20_260_912); diff --git a/test/pitch-roll-steer.test.ts b/test/pitch-roll-steer.test.ts index 2fb51867..8657a4fc 100644 --- a/test/pitch-roll-steer.test.ts +++ b/test/pitch-roll-steer.test.ts @@ -224,3 +224,28 @@ const WITHIN_A_GUN_CONE = 0.05; // ~2.9 degrees check('a target dead abeam asks for no pitch at all', pitchOnto(level, right) === 0); } + +// THE ROLL GATE: no pitch until the bank arrives (docs/TODO/210). +// +// The soft gate is the cosine of the roll error, and it leaves a little pitch +// at a wide bank. Near the nose that little is enough to hold a cone: the nose +// circles the target for ever. The course pilot passes a hard gate. Every +// combat caller passes none, and keeps the soft gate alone. +console.log('\nthe roll gate holds the pitch until the bank arrives'); +{ + const level = new THREE.Quaternion(); + // A target a little off the nose, and off to the side, so the bank is wide. + const off = new THREE.Vector3(Math.sin(0.04), 0.0005, -Math.cos(0.04)).normalize(); + const soft = bankToTurn(level, off, freshSteerMemory()); + check(`with no gate, a wide bank still asks for pitch (${soft.pitch.toFixed(5)})`, + Math.abs(soft.pitch) > 0); + const hard = bankToTurn(level, off, freshSteerMemory(), 0, 0.05); + check('with the gate, it asks for none', hard.pitch === 0); + check('...and it still asks for the same roll', Math.abs(hard.roll - soft.roll) < 1e-12); + + // Once the bank arrives, the gate lets go, and the pitch pulls the nose up. + const above = new THREE.Vector3(0, Math.sin(0.04), -Math.cos(0.04)); + const pulled = bankToTurn(level, above, freshSteerMemory(), 0, 0.05); + check(`a target above the nose, with the bank made, pitches (${pulled.pitch.toFixed(4)})`, + pulled.pitch > 0); +} From d85efd8f7f15b80fbbd6e42bbb01c0035f070de5 Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Sat, 12 Sep 2026 10:31:54 +0100 Subject: [PATCH 038/100] docs/TODO/211: the ship stops short of the rock Chris picked a rock and the ship flew on into it. A trace of a picked rock 53,000 units out showed the whole fault: the ship flew in at 397 units a second, braked to 4.3, and then coasted the last 500 units into the hull over two minutes. The cause is the speed deadband. `FlightDemand.throttle` is only a sign, so a band of 6 units stops the throttle flipping every frame. Inside the standoff the wanted speed is zero, and a ship coasting at 4.3 sat inside the band, so nothing braked it. The band holds a speed the ship is asked to keep, and zero is not one, so a wanted speed of zero now brakes. The standoff was also held to the target's CENTRE. A rock is 54 units across the radius and the generation ship is 340, so the commander stopped 160 units off the derelict's hull. The throttle measures the range from the hull now. The gun keeps the true distance, because a shot travels to the hull by itself. A picked rock now stops at 554 units from the centre of a 54 unit rock, at rest, and holds it. The derelict holds 838 units from the centre of its 340 unit hull, matching its own drift. The fight is unchanged: a target that moves asks for a speed above zero at any useful range. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- .../211-the-ship-stops-short-of-the-rock.md | 93 +++++++++++++++++++ docs/TODO/completed/README.md | 1 + src/game/scripted-co-pilot.ts | 15 ++- test/mine-and-collect.test.ts | 26 ++++++ test/scripted-co-pilot.test.ts | 57 ++++++++++++ 5 files changed, 191 insertions(+), 1 deletion(-) create mode 100644 docs/TODO/completed/211-the-ship-stops-short-of-the-rock.md diff --git a/docs/TODO/completed/211-the-ship-stops-short-of-the-rock.md b/docs/TODO/completed/211-the-ship-stops-short-of-the-rock.md new file mode 100644 index 00000000..ff3644d7 --- /dev/null +++ b/docs/TODO/completed/211-the-ship-stops-short-of-the-rock.md @@ -0,0 +1,93 @@ +# 211 — The ship stops short of the rock + +**Kind:** bug · **Severity:** high · **Size:** small · **Depends on:** 206 · +**Blocks:** nothing · **GitHub:** none + +## Where we are + +**Chris flew at a rock and reported a fault** (2026-09-12: *"when targeting +asteroids or the derelict. We fly towards - and just keep flying towards until +we hit it. We should probably stop when we are within a certain range."*). + +**A picked target is flown by the co-pilot** (`game/scripted-co-pilot.ts`). It +holds `PURSUIT_RANGE`, which is 500 units. Beyond it the ship closes. Inside +it the ship drops back. A rock and the derelict are on the target list, as +Chris asked in 206, so the same pilot flies at both. + +**The standoff did not hold.** A trace of 2026-09-12 followed a picked rock +53,000 units out: + +| time | range | speed | +| --- | --- | --- | +| 0 s | 53,074 | 254 | +| 130 s | 1,559 | 397 | +| 140 s | 481 | 4.3 | +| 230 s | 101 | 4.3 | + +**The cause is the speed deadband.** `FlightDemand.throttle` is only a sign, +so a deadband of 6 units stops the throttle from a flip on every frame. Inside +the standoff the wanted speed is zero. A ship that coasts at 4.3 is inside the +band, so the throttle asked for nothing, and the drift went on to the hull. + +**The second fault is the frame of reference.** The range is held to the +target's CENTRE. A rock is 54 units across the radius, and the generation ship +is 340. So the commander stopped 160 units off the derelict's hull. + +## What to do + +**M1 — a stop is a stop.** + +1. In `pursuitThrottle`, brake when the wanted speed is zero. The deadband + then holds a speed, and never a drift. +2. Measure the standoff from the hull. Pass `dist - radius` to the throttle. + The gun keeps the true distance, because a shot travels to the hull by + itself. +3. Pin both in `test/scripted-co-pilot.test.ts`. +4. Fly the whole game in `test/mine-and-collect.test.ts`: pick a rock, wait 90 + seconds, and check the gap. Wait another minute, and check that the gap is + still there. + +## Decisions already made + +- **The stop is the range the co-pilot already holds.** `PURSUIT_RANGE` is + inside the laser's reach and outside the break-off range. A second number + for a rock would be a second rule with no reason. + +## Open questions + +None. + +## Watch out for + +- **The fight must not change.** A fighting target moves, so it asks for a + wanted speed above zero at any useful range. The brake only fires where the + ship is asked to stop. +- **The hull standoff moves a fighter's range too**, by its own radius, which + is 25 to 62 units on the shipped hulls. + +## Verification + +1. The trace, flown again: the range at rest, and the range one minute later. +2. `test/scripted-co-pilot.test.ts` on the throttle rule itself. +3. The whole suite, which holds the fight. + +## What the milestones found + +**The rock, flown again with the fix:** the ship stops at 554 units from the +centre of a 54 unit rock. Its speed is 0.0 units a second. It holds that range +for the rest of the run. + +**The derelict:** the commander holds 838 units from the centre of the 340 +unit hull, which is 500 units of clear space. It matches the hulk's own drift +of 25 units a second, as it did before. + +**The test fails without the fix.** With the brake removed, the whole-game +test reports 2.7 units a second and a loss of 160 units of range in one +minute. + +**The fight is unchanged.** The suite holds it at 5,886 assertions, including +the co-pilot's gun cone, its range and its break-off. + +## Outcome + +Landed on 2026-09-12. `npm run check` passes. diff --git a/docs/TODO/completed/README.md b/docs/TODO/completed/README.md index 07ee16be..80b193fe 100644 --- a/docs/TODO/completed/README.md +++ b/docs/TODO/completed/README.md @@ -220,3 +220,4 @@ Supporting records: [Elite-A alignment plan](ELITE-A-COMBAT-PLAN.md), - [x] 208 — [Every kind of mission has a way to fly it](208-every-kind-of-mission-has-a-way-to-fly-it.md) — Chris, 2026-09-12. **M1 and M2** give each verb a course, in the job's own words. **M3** mends the scoop trap and two faults in the hunt. **M4** is the smuggling run wide of the police. **M5** is what a derelict's scan reports. 5,845 assertions. - [x] 209 — [The torus drive says what stopped it](209-the-drive-says-what-stopped-it.md) — Chris, 2026-09-12. He flew to the station and saw no mass lock on a neutral trader. The rule did fire. **M1** makes the drop name what stopped the drive, because "MASS LOCK" named nothing. **M2** announces a neutral trader that comes close, one time, because the drive is off for most of a trip. 5,871 assertions. - [x] 210 — [The ship does not roll all the way there](210-the-ship-does-not-roll-all-the-way-there.md) — Chris, 2026-09-12. He flew a course and saw the ship rotate all the way to its target. The steering held a cone: the nose circled the target, and the roll never stopped. **M1** gives the course pilot a hard roll gate, which holds the pitch still until the bank arrives. A median trip fell from 41 full turns of roll to 1.3. The fight keeps the law it has. 5,877 assertions. +- [x] 211 — [The ship stops short of the rock](211-the-ship-stops-short-of-the-rock.md) — Chris, 2026-09-12. He picked a rock and the ship flew on into it. The speed deadband held a drift as well as a speed, and the standoff was measured to the target's centre. **M1** brakes to a stop inside the standoff, and measures that range from the hull. A picked rock now holds 500 units of clear space. 5,886 assertions. diff --git a/src/game/scripted-co-pilot.ts b/src/game/scripted-co-pilot.ts index 67aede10..6f2fa155 100644 --- a/src/game/scripted-co-pilot.ts +++ b/src/game/scripted-co-pilot.ts @@ -166,7 +166,13 @@ export class ScriptedCoPilot { demand: { pitchRate: this.pitchRate, rollRate: this.rollRate, - throttle: this.pursuitThrottle(player.speed, threat.state.speed, dist, facing), + // THE STANDOFF IS MEASURED FROM THE HULL (docs/TODO/211). A rock is + // 54 units across the radius, and the derelict is 340. A range held + // to the centre put the commander 160 units off the derelict's hull, + // which reads as a ram in the window. The gun below keeps the true + // distance, because a shot travels to the hull by itself. + throttle: this.pursuitThrottle( + player.speed, threat.state.speed, dist - threat.radius, facing), // the trigger only when the shot would count: the player gun's own cone // and range (gunnery.ts). The laser's heat and cooldown pace it from // there, which is what makes this a marksman rather than a sprayer @@ -191,6 +197,13 @@ export class ScriptedCoPilot { ): number { const want = pursuitSpeed(targetSpeed, dist, facing, PLAYER_FLIGHT.maxSpeed); const diff = want - ownSpeed; + // A STOP IS A STOP (docs/TODO/211). The deadband holds a speed steady, and + // it must not hold a drift. A target that sits still asks for a wanted + // speed of zero inside the standoff. The commander then coasted in at up + // to 6 units a second. A rock 500 units away took two minutes to arrive at + // the hull (Chris, 2026-09-12). The band applies to a speed the ship is + // asked to HOLD, and zero is not one. + if (want === 0) return ownSpeed > 0 ? -1 : 0; return Math.abs(diff) < PURSUIT_SPEED_DEADBAND ? 0 : Math.sign(diff); } } diff --git a/test/mine-and-collect.test.ts b/test/mine-and-collect.test.ts index e5a09d83..a4a3d38e 100644 --- a/test/mine-and-collect.test.ts +++ b/test/mine-and-collect.test.ts @@ -122,3 +122,29 @@ function ahead(g: Game, z: number, x = 0): THREE.Vector3 { check('the collect course then takes the ore aboard', g.state.commander.cargo.reduce((a, b) => a + b, 0) > held); } + +// --- THE SHIP STOPS AT THE ROCK, IT DOES NOT DRIFT INTO IT (docs/TODO/211) -- +// +// Chris, 2026-09-12: *"when targeting asteroids or the derelict. We fly +// towards - and just keep flying towards until we hit it."* A trace of a +// picked rock 53,000 units out showed the whole fault: the ship flew in at +// 397 units a second, braked to 4.3, and then coasted the last 500 units into +// the hull over two minutes. This flies the real game and watches the gap. +console.log('\nthe ship stops short of a picked rock'); +{ + const g = outThere(20_260_941); + const rock = g.state.world.spawn('asteroid', ahead(g, 3000), 7); + press(g, COURSE_KEYS.mine); + eq('the mining course picks the rock', pickedTarget(g.state.world.npcs), rock); + run(g, 60 * 90); + const gap = g.state.player.position.distanceTo(rock.object.position) - rock.radius; + check('the ship holds off the rock rather than arrive at it', + rock.state.alive && gap > 100, `${gap.toFixed(0)} units of clear space`); + check('...and it is stopped, not still closing', + g.state.player.speed < 1, `${g.state.player.speed.toFixed(1)} units a second`); + const then = g.state.player.position.distanceTo(rock.object.position); + run(g, 60 * 60); + const now = g.state.player.position.distanceTo(rock.object.position); + check('...and a minute later it is still there', Math.abs(now - then) < 10, + `${(now - then).toFixed(1)} units in a minute`); +} diff --git a/test/scripted-co-pilot.test.ts b/test/scripted-co-pilot.test.ts index a92613fa..0245a28a 100644 --- a/test/scripted-co-pilot.test.ts +++ b/test/scripted-co-pilot.test.ts @@ -20,6 +20,7 @@ import { defenceBrain } from '../src/game/brains.ts'; import { freshState } from '../src/game/state.ts'; import { newCommander } from '../src/game/commander.ts'; import { seedWorld } from '../src/game/rng.ts'; +import { PURSUIT_RANGE } from '../src/constants/combat-computer.ts'; import { check, eq } from './harness.ts'; console.log('\nscripted combat computer'); @@ -175,3 +176,59 @@ console.log('\nscripted combat computer'); finalDist < LASER_RANGE); } } + +// --- IT STOPS AT THE STANDOFF, AND IT STOPS DEAD (docs/TODO/211) ------------ +// +// Chris, 2026-09-12: *"when targeting asteroids or the derelict. We fly +// towards - and just keep flying towards until we hit it. We should probably +// stop when we are within a certain range."* +// +// Two faults, one report. The deadband held a DRIFT as well as a speed, so a +// ship inside the standoff coasted on at up to 6 units a second. A trace of a +// picked rock closed 400 units in a minute, and went on to the hull. And the +// range was held to the target's CENTRE, which put the commander 160 units +// off the derelict's 340 unit hull. +console.log('\nthe co-pilot stops at the standoff'); +{ + seedWorld(4243); + const state = freshState(newCommander()); + state.world.build(state.systems[state.commander.systemIndex]); + state.world.clearNpcs(); + state.player.position.set(0, 0, 0); + state.player.quaternion.identity(); + const legal = state.commander.legalStatus; + + // A rock that sits still, inside the standoff, with the ship drifting on. + const rock = state.world.spawn('asteroid', new THREE.Vector3(0, 0, -400), 1); + state.player.speed = 4; + const cp = new ScriptedCoPilot(); + const drift = cp.step(1 / 60, state.player, state.world.npcs, legal, false, null, Infinity, rock); + check('inside the standoff, a drift is braked rather than held', + drift.kind === 'fly' && drift.demand.throttle === -1); + + state.player.speed = 0; + const stopped = new ScriptedCoPilot() + .step(1 / 60, state.player, state.world.npcs, legal, false, null, Infinity, rock); + check('...and a ship already stopped asks for nothing', + stopped.kind === 'fly' && stopped.demand.throttle === 0); + + // Outside the standoff it still closes. + rock.object.position.set(0, 0, -3000); + const far = new ScriptedCoPilot() + .step(1 / 60, state.player, state.world.npcs, legal, false, null, Infinity, rock); + check('outside it, the ship still closes', far.kind === 'fly' && far.demand.throttle === 1); + + // The standoff clears the HULL, so a big target is not approached as a + // small one. The rock's own radius is what the range adds. + rock.object.position.set(0, 0, -(PURSUIT_RANGE + rock.radius - 50)); + state.player.speed = 4; + const inside = new ScriptedCoPilot() + .step(1 / 60, state.player, state.world.npcs, legal, false, null, Infinity, rock); + check('a target 50 units inside the hull standoff is too close', + inside.kind === 'fly' && inside.demand.throttle === -1); + rock.object.position.set(0, 0, -(PURSUIT_RANGE + rock.radius + 200)); + const outside = new ScriptedCoPilot() + .step(1 / 60, state.player, state.world.npcs, legal, false, null, Infinity, rock); + check('...and 200 units outside it is not', outside.kind === 'fly' + && outside.demand.throttle === 1); +} From 2760fe92958f04736da7f5d97b8b8f8a0d0dc444 Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Sat, 12 Sep 2026 11:19:15 +0100 Subject: [PATCH 039/100] docs/TODO/212: the computer lines up, and the pilot plays the slot Chris flew 207's docking on a phone and it did not work. The touch input was fine. His diagnosis was right: "lining up is not actually very accurate until the last few moments. So we aren't actually flying straight and rolling can send you off away from the slot." Measured: the pilot took the ship at 1,494 units, 407 to 886 units off the slot axis, at 224 units a second. The slot channel is 26 units across the half-width. One stick has two jobs, because the ship has no yaw axis: a roll is how it aims, and the slot wants that same roll for the wings. The pilot held the roll, the computer held only the pitch, so every roll turned the computer's own correction. An ideal pilot docked 0 times in 4. The same pilot with no roll at all docked 2 times in 4. So the stretch is two stages now, which is the shape Chris asked for: "we actually get lined up by the computer and then hand off to a 'mini' docking game. Something that is completely on rails." The computer lines the ship up with both sticks. The console reads LINING UP, and the pilot has no controls. The rails then take the ship 645 units out at 107 units a second, which is about six seconds of game. They hold the line and point the ship down it, so the pilot cannot miss the hole. The roll and the throttle are the pilot's, and they are the whole game. A scrape lets the rails go, and the computer lines the ship up again. An ideal pilot now docks 8 times in 8. A pilot who never touches the strip docks 3 times in 8, which is luck: the slot fits either way up, so it is lined up about two turns in five. `game/dock-rails.ts` is the one file in the game that moves the commander's ship other than by flying it, and `test/docking.test.ts` names it. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- docs/ARCHITECTURE.md | 6 +- ...r-lines-up-and-the-pilot-plays-the-slot.md | 112 ++++++++++++++++++ docs/TODO/completed/README.md | 1 + manual.html | 8 +- src/constants/CATALOG.md | 43 +++---- src/constants/docking.ts | 46 +++++++ src/constants/law.ts | 8 ++ src/constants/ordnance.ts | 2 + src/game/cockpit-buttons.ts | 7 ++ src/game/cockpit-view.ts | 2 + src/game/dock-rails.ts | 67 +++++++++++ src/game/docking.ts | 7 ++ src/game/flight-instruments.ts | 12 +- src/game/session.ts | 7 ++ src/game/state.ts | 1 + src/game/world-step.ts | 72 +++++++---- src/hud/hud-binding.ts | 2 + src/hud/hud.ts | 7 +- test/dock-trial.test.ts | 90 +++++++++++++- test/docking.test.ts | 27 ++++- test/fight-buttons.test.ts | 2 +- 21 files changed, 474 insertions(+), 55 deletions(-) create mode 100644 docs/TODO/completed/212-the-computer-lines-up-and-the-pilot-plays-the-slot.md create mode 100644 src/game/dock-rails.ts diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md index 8b39bf90..6941c6d1 100644 --- a/docs/ARCHITECTURE.md +++ b/docs/ARCHITECTURE.md @@ -44,7 +44,11 @@ rules. This file is a map. `course-pilot.ts` flies the picked course, one frame at a time, and it reports a `FlightDemand`. `flight-instruments.ts` throws the switches that a course asks for: the torus drive, the hand-over to the docking computer, and - the end of the course. `course-actions.ts` joins the list to the Game: it + the end of the course. A commander with no docking computer gets the docking + mini game instead (docs/TODO/212). The computer lines the ship up first. + `dock-rails.ts` then holds the ship on the slot axis, and the pilot matches + the slot and the speed. It is the one file that moves the commander's ship + other than by flying it. `course-actions.ts` joins the list to the Game: it builds the flat view, and it applies a pick. At the station, the LAUNCH row opens `screens/courses.ts`, and a pick leaves on the course. In flight, the list is a set of buttons over the view, and not a screen, because the flight diff --git a/docs/TODO/completed/212-the-computer-lines-up-and-the-pilot-plays-the-slot.md b/docs/TODO/completed/212-the-computer-lines-up-and-the-pilot-plays-the-slot.md new file mode 100644 index 00000000..af8ac81b --- /dev/null +++ b/docs/TODO/completed/212-the-computer-lines-up-and-the-pilot-plays-the-slot.md @@ -0,0 +1,112 @@ +# 212 — The computer lines up, and the pilot plays the slot + +**Kind:** bug · **Severity:** high · **Size:** medium · **Depends on:** 207 · +**Blocks:** nothing · **GitHub:** none + +## Where we are + +**Chris flew 207's docking on a phone and it failed** (2026-09-12: *"I'm +testing on mobile. The docking does not seem to work at all."*). The touch +input was not the fault. His own diagnosis, the same day: *"lining up is not +actually very accurate until the last few moments. So we aren't actually flying +straight and rolling can send you off away from the slot. We may need a +different solution."* + +**He is right, and the numbers are large.** A measurement of 2026-09-12 flew +the station course headless, then took over with an ideal pilot: + +| at the hand-over | value | +| --- | --- | +| range to the station | 1,494 units | +| speed | 224 to 228 units a second | +| distance off the slot axis | 407 to 886 units | + +The slot channel is 26 units across the half-width. So the pilot took the ship +hundreds of units off the line, at twice the speed the slot accepts. + +**One stick has two jobs, and that is the root of it.** The ship has no yaw +axis, so a roll is how it aims. The slot wants that same roll for something +else: the wings lined up with the letterbox. `docking-sticks.ts` reconciles the +two for the docking computer. 207's split could not, because the pilot held the +roll and the computer held only the pitch. Every roll the pilot made turned the +computer's correction into a new direction. + +**Measured over four seeds, the same approach, two pilots:** + +| pilot | docked | +| --- | --- | +| matches the spin, and brakes | 0 of 4 | +| brakes only, and never rolls | 2 of 4 | + +**Chris asked for a different shape** (2026-09-12): *"I'm wondering if we +actually get lined up by the computer and then hand off to a 'mini' docking +game. Something that is completely on rails."* + +## What to do + +**M1 — the pilot's stretch becomes two stages.** + +1. The computer lines the ship up, with both sticks, exactly as the docking + computer does. The pilot sees LINING UP, and has no controls. +2. The rails then take the ship. They hold it on the slot axis and point it + down the axis. The pilot has the roll and the throttle, and nothing else. +3. The slot's own test is unchanged: the wings inside `ROLL_TOLERANCE`, and the + speed under `SLOT_SPEED_LIMIT`. +4. A scrape lets the rails go, so the computer lines the ship up for another + go. That is the retry Chris asked for on 2026-09-11. + +**M2 — the rails are their own module**, `game/dock-rails.ts`. It is the one +file in the game that moves the commander's ship other than by flying it. +`test/docking.test.ts` scans for that, and it names the file. + +## Decisions already made + +- **The computer does the lining up.** Chris asked for it in those words. +- **The pilot keeps the roll and the speed.** Match the spin was his choice of + 2026-09-11, and the rails are what make it possible. +- **The rails pull, and never snap.** A snap is a teleport. + +## Open questions + +None. + +## Watch out for + +- **The game must not be over before it starts.** If the rails take the ship + 200 units out, the pilot has two seconds and nothing to do. +- **`world-step.ts` must not turn the ship by hand.** That rule is docs/TODO/126 + and `test/docking.test.ts` holds it. + +## Verification + +1. The whole game, flown headless: the course, the lining up, the rails, and a + pilot's hand on the strip. +2. The control: a pilot who never touches the strip. +3. The length of the mini game, in seconds and in units. + +## What the milestones found + +**The rails take the ship 645 units out, at 107 units a second.** That is about +six seconds of mini game. The station turns 1.6 radians in that time, and the +slot is 1.3 radians wide, so the pilot must follow the spin rather than wait. + +**The measurements, over eight seeds:** + +| pilot | docked | +| --- | --- | +| matches the slot | 8 of 8 | +| never touches the strip | 3 of 8 | + +The three are luck rather than skill. The slot fits either way up, so it is +lined up about two turns in five. + +**The retry works.** A pilot who fluffs the slot scrapes, and the computer +lines the ship up again. Two of six seeds docked on the second go. + +**The rails start with 210 to 240 units of error, and they close it.** The +first frame moves the ship 7 units across the line. The error is gone in about +two seconds, well before the mouth. + +## Outcome + +Landed on 2026-09-12. `npm run check` passes. diff --git a/docs/TODO/completed/README.md b/docs/TODO/completed/README.md index 80b193fe..6dc55826 100644 --- a/docs/TODO/completed/README.md +++ b/docs/TODO/completed/README.md @@ -221,3 +221,4 @@ Supporting records: [Elite-A alignment plan](ELITE-A-COMBAT-PLAN.md), - [x] 209 — [The torus drive says what stopped it](209-the-drive-says-what-stopped-it.md) — Chris, 2026-09-12. He flew to the station and saw no mass lock on a neutral trader. The rule did fire. **M1** makes the drop name what stopped the drive, because "MASS LOCK" named nothing. **M2** announces a neutral trader that comes close, one time, because the drive is off for most of a trip. 5,871 assertions. - [x] 210 — [The ship does not roll all the way there](210-the-ship-does-not-roll-all-the-way-there.md) — Chris, 2026-09-12. He flew a course and saw the ship rotate all the way to its target. The steering held a cone: the nose circled the target, and the roll never stopped. **M1** gives the course pilot a hard roll gate, which holds the pitch still until the bank arrives. A median trip fell from 41 full turns of roll to 1.3. The fight keeps the law it has. 5,877 assertions. - [x] 211 — [The ship stops short of the rock](211-the-ship-stops-short-of-the-rock.md) — Chris, 2026-09-12. He picked a rock and the ship flew on into it. The speed deadband held a drift as well as a speed, and the standoff was measured to the target's centre. **M1** brakes to a stop inside the standoff, and measures that range from the hull. A picked rock now holds 500 units of clear space. 5,886 assertions. +- [x] 212 — [The computer lines up, and the pilot plays the slot](212-the-computer-lines-up-and-the-pilot-plays-the-slot.md) — Chris, 2026-09-12. He flew 207's docking on a phone and it did not work. The pilot took the ship 407 to 886 units off the slot axis, and a roll to match the spin turned the computer's own correction. **M1** makes the stretch two stages: the computer lines the ship up, then the rails hold the line while the pilot matches the slot and the speed. **M2** puts the rails in `game/dock-rails.ts`. An ideal pilot went from 0 of 4 to 8 of 8. 5,891 assertions. diff --git a/manual.html b/manual.html index b46db3e8..16fe08a7 100644 --- a/manual.html +++ b/manual.html @@ -274,8 +274,12 @@

    Docking

    gets on the axis, straight out from the port. An amber marker shows where the port is, with an arrow at the screen edge when it is behind you. -
  • Near the port the ship hands you the last stretch, and holds you - on the axis while you fly it.
    • +
  • The console reads LINING UP while the computer puts the + ship on the axis. There is nothing to do yet.
    • +
  • When it is lined up, the slot is yours. The ship stays on the + line by itself from there, so you cannot miss the hole. Two things + are left to you, and they are the whole of it: the roll, and the + speed.
  • Roll to match the port's rotation. This is the part people miss. The opening is a letterbox, and your ship has to be the same way up as it is. Drag the strip at the bottom right, or use your diff --git a/src/constants/CATALOG.md b/src/constants/CATALOG.md index aabbaffb..0b3790e5 100644 --- a/src/constants/CATALOG.md +++ b/src/constants/CATALOG.md @@ -2,7 +2,7 @@ -445 exported constants. Regenerate with `npm run generate:constants`; +448 exported constants. Regenerate with `npm run generate:constants`; search names, meanings and values with `npm run constants:find -- ""`. | Domain | Symbol | Literal / expression | Purpose | Rule ID | Source | @@ -144,6 +144,9 @@ search names, meanings and values with `npm run constants:find -- ""`. | docking | SLOT_DEPTH | 60 | How far into the -Z face puts a ship in the channel, in world units. * | docking.slotDepth | [docking.ts:133](./docking.ts#L133) | | docking | ROLL_TOLERANCE | 0.65 | The wings against the slot's long axis, in radians: how badly you may be rolled and still fit through the letterbox. | | [docking.ts:144](./docking.ts#L144) | | docking | SLOT_SPEED_LIMIT | 120 | How fast a ship may be going when it reaches the slot, in world units a second (docs/TODO/207 M3). | docking.slotSpeedLimit | [docking.ts:165](./docking.ts#L165) | +| docking | RAILS_LATERAL | 250 | How far off the slot axis the ship may be when the rails take it, in world units (docs/TODO/212). | docking.railsLateral | [docking.ts:187](./docking.ts#L187) | +| docking | RAILS_RANGE | 900 | How far out the rails take the ship, in world units (docs/TODO/212). | docking.railsRange | [docking.ts:199](./docking.ts#L199) | +| docking | RAILS_PULL | 2 | How hard the rails pull the ship onto the axis, per second (docs/TODO/212). | docking.railsPull | [docking.ts:211](./docking.ts#L211) | | docking-computer | DOCK_COMPUTER_RANGE | 3500 | How close to the station the docking computer will take the job, in world units. | | [docking-computer.ts:46](./docking-computer.ts#L46) | | docking-computer | DC_SLOT_MARGIN | 0.30 | How much of the slot's roll tolerance the TURN may spend, as a fraction. | docking.slotMargin | [docking-computer.ts:97](./docking-computer.ts#L97) | | docking-computer | DC_TURN_FADE_ANGLE | 0.10 | The off-nose angle, in radians, over which the TURN's claim on the roll axis ramps in. | docking.turnFadeAngle | [docking-computer.ts:151](./docking-computer.ts#L151) | @@ -213,18 +216,18 @@ search names, meanings and values with `npm run constants:find -- ""`. | law | FUGITIVE | 2 | The top rung: every police ship in the galaxy hunts a Fugitive. | law.fugitive | [law.ts:66](./law.ts#L66) | | law | STATION_TRUCE | 7000 | How close to the station the commander must be for the truce to hold. | law.stationTruce | [law.ts:94](./law.ts#L94) | | law | CONTRABAND | [3, 6, 10] | The commodity indices that the Galactic Government defines as illegal: slaves, narcotics and firearms. | | [law.ts:102](./law.ts#L102) | -| law | OFFENDER_FINE | 250 | The fine for a dock with a record, capped at what you can actually pay. | | [law.ts:108](./law.ts#L108) | -| law | FUGITIVE_FINE | 750 | | | [law.ts:109](./law.ts#L109) | -| law | KILLS_PER_RUNG | 5 | Pirate kills that take a legal record down one rung. | law.killsPerRung | [law.ts:140](./law.ts#L140) | -| law | DEFENCE_RANGE | 9000 | Misbehave within this range of the station slot, and the Vipers launch. | | [law.ts:148](./law.ts#L148) | -| law | SCAN_RANGE | 2600 | How close a police ship must be to scan your hold. | | [law.ts:151](./law.ts#L151) | -| law | SCAN_WARN_RANGE | 4400 | A police ship this close is about to be able to read your hold, and the console says so while it stays there. | | [law.ts:171](./law.ts#L171) | -| law | SCAN_WARN_REPEAT | 2 | Seconds between repeats of that warning, while a patrol stays in the band. | law.scanWarnRepeat | [law.ts:188](./law.ts#L188) | -| law | BRIBE_SHARE | 0.5 | What a policeman charges to not read your hold: this share of what the contraband aboard is worth at market. | law.bribeShare | [law.ts:217](./law.ts#L217) | -| law | BRIBE_FLOOR | 500 | ...but never less than this, so a light run is not a free pass. 50 Cr, in tenths of a credit (invariant 8). | law.bribeFloor | [law.ts:237](./law.ts#L237) | -| law | PATROL_BRIBE_FINES | 4 | What a police ship that already shoots at you charges to break off, as a multiple of the fine for the rung you are on. | law.patrolBribeFines | [law.ts:261](./law.ts#L261) | -| law | BRIBE_REFUSED | 0.35 | How often an HONEST commander's offer is refused and reported. | law.bribeRefused | [law.ts:293](./law.ts#L293) | -| law | SCAN_LINE_SECONDS | 4 | How long the scan's own line holds the console, and therefore how long the verdict that explains it waits behind it. | law.scanLineSeconds | [law.ts:308](./law.ts#L308) | +| law | OFFENDER_FINE | 250 | The fine for a dock with a record, capped at what you can actually pay. | law.offenderFine | [law.ts:110](./law.ts#L110) | +| law | FUGITIVE_FINE | 750 | ...and the fine for a fugitive, which is three times as much. | law.fugitiveFine | [law.ts:117](./law.ts#L117) | +| law | KILLS_PER_RUNG | 5 | Pirate kills that take a legal record down one rung. | law.killsPerRung | [law.ts:148](./law.ts#L148) | +| law | DEFENCE_RANGE | 9000 | Misbehave within this range of the station slot, and the Vipers launch. | | [law.ts:156](./law.ts#L156) | +| law | SCAN_RANGE | 2600 | How close a police ship must be to scan your hold. | | [law.ts:159](./law.ts#L159) | +| law | SCAN_WARN_RANGE | 4400 | A police ship this close is about to be able to read your hold, and the console says so while it stays there. | | [law.ts:179](./law.ts#L179) | +| law | SCAN_WARN_REPEAT | 2 | Seconds between repeats of that warning, while a patrol stays in the band. | law.scanWarnRepeat | [law.ts:196](./law.ts#L196) | +| law | BRIBE_SHARE | 0.5 | What a policeman charges to not read your hold: this share of what the contraband aboard is worth at market. | law.bribeShare | [law.ts:225](./law.ts#L225) | +| law | BRIBE_FLOOR | 500 | ...but never less than this, so a light run is not a free pass. 50 Cr, in tenths of a credit (invariant 8). | law.bribeFloor | [law.ts:245](./law.ts#L245) | +| law | PATROL_BRIBE_FINES | 4 | What a police ship that already shoots at you charges to break off, as a multiple of the fine for the rung you are on. | law.patrolBribeFines | [law.ts:269](./law.ts#L269) | +| law | BRIBE_REFUSED | 0.35 | How often an HONEST commander's offer is refused and reported. | law.bribeRefused | [law.ts:301](./law.ts#L301) | +| law | SCAN_LINE_SECONDS | 4 | How long the scan's own line holds the console, and therefore how long the verdict that explains it waits behind it. | law.scanLineSeconds | [law.ts:316](./law.ts#L316) | | living-galaxy | PRESSURE_DECAY | 0.12 | How fast price pressure decays back toward the 1984 baseline, per day. | | [living-galaxy.ts:9](./living-galaxy.ts#L9) | | living-galaxy | HEAT_DECAY | 0.06 | How fast talk about the player dies down, per day. | living.heatDecay | [living-galaxy.ts:24](./living-galaxy.ts#L24) | | living-galaxy | DANGER_DECAY | 0.015 | How fast a system's reputation for piracy fades, per day. | | [living-galaxy.ts:32](./living-galaxy.ts#L32) | @@ -289,13 +292,13 @@ search names, meanings and values with `npm run constants:find -- ""`. | ordnance | MISSILE_MAX_RANGE | 3200 | The far edge of the seeker's envelope. | | [ordnance.ts:42](./ordnance.ts#L42) | | ordnance | MISSILE_LAST_STAND_HULL | 0.4 | The hull fraction below which a ship stops saving its missiles for later. | ordnance.missileLastStandHull | [ordnance.ts:53](./ordnance.ts#L53) | | ordnance | MISSILE_LAST_STAND_GATE | Math.PI / 2 | ...and it launches on a bearing rather than on a firing line. | | [ordnance.ts:58](./ordnance.ts#L58) | -| ordnance | MISSILE_LAST_STAND_MIN_RANGE | 250 | Desperation widens the envelope INWARD, but not all the way. | | [ordnance.ts:64](./ordnance.ts#L64) | -| ordnance | MISSILE_RELOAD | 2 | Gap between launches, so a Python does not empty both rails in one frame. | ordnance.missileReload | [ordnance.ts:73](./ordnance.ts#L73) | -| ordnance | MISSILE_COMMIT_PASSES | 2 | How many passes a ship makes before it accepts that this is not going its way. | ordnance.missileCommitPasses | [ordnance.ts:85](./ordnance.ts#L85) | -| ordnance | ECM_RANGE | 2800 | A target with an E.C.M. fries an incoming missile inside this. | | [ordnance.ts:90](./ordnance.ts#L90) | -| ordnance | ECM_RATE | 0.45 | ...at this chance per second. | | [ordnance.ts:92](./ordnance.ts#L92) | -| ordnance | ECM_ENERGY_COST | ENERGY_BANK_POINTS | A shot of the E.C.M. costs one bank of energy. | | [ordnance.ts:98](./ordnance.ts#L98) | -| ordnance | ENERGY_BOMB_RANGE | 8000 | The energy bomb reaches this far. | | [ordnance.ts:101](./ordnance.ts#L101) | +| ordnance | MISSILE_LAST_STAND_MIN_RANGE | 250 | Desperation widens the envelope INWARD, but not all the way. | ordnance.missileLastStandMinRange | [ordnance.ts:66](./ordnance.ts#L66) | +| ordnance | MISSILE_RELOAD | 2 | Gap between launches, so a Python does not empty both rails in one frame. | ordnance.missileReload | [ordnance.ts:75](./ordnance.ts#L75) | +| ordnance | MISSILE_COMMIT_PASSES | 2 | How many passes a ship makes before it accepts that this is not going its way. | ordnance.missileCommitPasses | [ordnance.ts:87](./ordnance.ts#L87) | +| ordnance | ECM_RANGE | 2800 | A target with an E.C.M. fries an incoming missile inside this. | | [ordnance.ts:92](./ordnance.ts#L92) | +| ordnance | ECM_RATE | 0.45 | ...at this chance per second. | | [ordnance.ts:94](./ordnance.ts#L94) | +| ordnance | ECM_ENERGY_COST | ENERGY_BANK_POINTS | A shot of the E.C.M. costs one bank of energy. | | [ordnance.ts:100](./ordnance.ts#L100) | +| ordnance | ENERGY_BOMB_RANGE | 8000 | The energy bomb reaches this far. | | [ordnance.ts:103](./ordnance.ts#L103) | | pass-aim | PASS_MISS_DISTANCE | 110 | How far to the SIDE of its target a ship aims its attack run. 110 clears the largest pirate hull, plus the commander's radius, twice over. | | [pass-aim.ts:13](./pass-aim.ts#L13) | | pass-aim | MAX_LEAD_SECONDS | 0.5 | The furthest ahead of a target that a ship will aim, in seconds. | | [pass-aim.ts:21](./pass-aim.ts#L21) | | pass-aim | MAX_MISS_STRETCH | 3 | The most that geometry may stretch the aim, in multiples of the intended pass. | passaim.maxMissStretch | [pass-aim.ts:31](./pass-aim.ts#L31) | diff --git a/src/constants/docking.ts b/src/constants/docking.ts index 24f4439d..6b377ffe 100644 --- a/src/constants/docking.ts +++ b/src/constants/docking.ts @@ -163,3 +163,49 @@ export const ROLL_TOLERANCE = 0.65; * @domain docking */ export const SLOT_SPEED_LIMIT = 120; + +/** + * How far off the slot axis the ship may be when the rails take it, in world + * units (docs/TODO/212). + * + * THE PILOT USED TO GET THE SHIP AT 1,500 UNITS, AND IT WAS NOT LINED UP. A + * measurement of 2026-09-12 put the hand-over 407 to 886 units off the axis, + * at 224 units a second. The slot channel is 26 units across the half-width. + * So the computer still had the whole of the lining up to do, with the pitch + * alone, because the pilot owned the roll. An ideal pilot docked 0 times in 4. + * + * IT IS A SANITY BOUND, NOT THE LINE ITSELF. The rails close the last of the + * error themselves, and that is their job. The docking computer reaches its + * last leg 610 units out, with 220 units of error. The error is down to 18 + * units by 280 units out. To wait for the small number would leave the pilot + * two seconds of game. So the rails take the ship at the start of the last leg, + * and they pull it onto the line while it flies in. + * + * @rule docking.railsLateral + * @domain docking + */ +export const RAILS_LATERAL = 250; + +/** + * How far out the rails take the ship, in world units (docs/TODO/212). + * + * It is the length of the mini game. At the slot's speed limit of 120 units a + * second, 900 units is about seven seconds. The station turns a half circle in + * 12 seconds, so the pilot sees the slot come round at least once. + * + * @rule docking.railsRange + * @domain docking + */ +export const RAILS_RANGE = 900; + +/** + * How hard the rails pull the ship onto the axis, per second (docs/TODO/212). + * + * The worst error the rails take is about 220 units. At 2 a second the first + * frame moves the ship 7 units sideways, and the error is gone in about two + * seconds. A hard snap would look like a teleport. + * + * @rule docking.railsPull + * @domain docking + */ +export const RAILS_PULL = 2; diff --git a/src/constants/law.ts b/src/constants/law.ts index e79887fe..5c4fbc48 100644 --- a/src/constants/law.ts +++ b/src/constants/law.ts @@ -104,8 +104,16 @@ export const CONTRABAND: readonly number[] = [3, 6, 10]; /** * The fine for a dock with a record, capped at what you can actually pay. They * are in tenths of a credit (invariant 8), so these are 25 Cr and 75 Cr. + * + * @rule law.offenderFine */ export const OFFENDER_FINE = 250; +/** + * ...and the fine for a fugitive, which is three times as much. The comment + * above covers both. + * + * @rule law.fugitiveFine + */ export const FUGITIVE_FINE = 750; /** diff --git a/src/constants/ordnance.ts b/src/constants/ordnance.ts index bc1c5550..30dd249e 100644 --- a/src/constants/ordnance.ts +++ b/src/constants/ordnance.ts @@ -60,6 +60,8 @@ export const MISSILE_LAST_STAND_GATE = Math.PI / 2; * Desperation widens the envelope INWARD, but not all the way. Inside this, the * missile arrives before the player can reach the E.C.M. or turn, and a weapon * you cannot dodge is not a fight. + * + * @rule ordnance.missileLastStandMinRange */ export const MISSILE_LAST_STAND_MIN_RANGE = 250; /** diff --git a/src/game/cockpit-buttons.ts b/src/game/cockpit-buttons.ts index 35431208..653d4b76 100644 --- a/src/game/cockpit-buttons.ts +++ b/src/game/cockpit-buttons.ts @@ -63,6 +63,8 @@ export interface ActionSource { readonly missileInbound: boolean; /** the pilot flies the last stretch into the slot (docs/TODO/207 M2) */ readonly trial: boolean; + /** ...and the rails have it, so the mini game is on (docs/TODO/212) */ + readonly rails: boolean; /** the keys that open and close the throttle, for the two held buttons */ readonly accelKey: string | null; readonly decelKey: string | null; @@ -80,6 +82,11 @@ export function actionButtonsFor(a: ActionSource): HudButton[] { // The last stretch into the slot asks for two things and nothing else: the // roll, and the speed (docs/TODO/207 M2). So the pilot's buttons are those // two while it runs, and the guns wait. + if (a.trial && !a.rails) { + // The computer is lining the ship up, and the pilot has nothing to do yet + // (docs/TODO/212). A strip that did nothing would be a lie. + return [{ code: 'dock-lining-up', label: 'LINING UP', hint: 'STAND BY FOR THE SLOT' }]; + } if (a.trial) { const out: HudButton[] = [{ code: a.rollStripCode, label: 'DRAG TO ROLL', strip: true }]; if (a.accelKey) { diff --git a/src/game/cockpit-view.ts b/src/game/cockpit-view.ts index 63ede2dd..fb5c76bc 100644 --- a/src/game/cockpit-view.ts +++ b/src/game/cockpit-view.ts @@ -225,6 +225,7 @@ export class CockpitView { ecmKey: this.state.commander.equipment.ecm ? key('fireEcm') : null, missileInbound: this.ordnance.missileInbound, trial: this.state.session.dockTrial, + rails: this.state.session.dockRails, accelKey: keymap().accel[0] ?? null, decelKey: keymap().decel[0] ?? null, rollStripCode: ROLL_STRIP_CODE, @@ -318,6 +319,7 @@ export class CockpitView { witchspace: this.state.session.witchspace, assist: this.state.session.ccEngaged, trial: this.state.session.dockTrial, + rails: this.state.session.dockRails, ecmDetected: this.state.ecmDetectedTimer > 0, messageText: this.state.session.messageText, messageTimer: this.state.session.messageTimer, diff --git a/src/game/dock-rails.ts b/src/game/dock-rails.ts new file mode 100644 index 00000000..9e310252 --- /dev/null +++ b/src/game/dock-rails.ts @@ -0,0 +1,67 @@ +// The rails that hold the ship on the slot axis (docs/TODO/212). +// +// Chris flew the pilot's stretch of 207 on a phone and it did not work. His +// words of 2026-09-12: *"lining up is not actually very accurate until the +// last few moments. So we aren't actually flying straight and rolling can send +// you off away from the slot."* He asked for a mini game instead: *"I'm +// wondering if we actually get lined up by the computer and then hand off to a +// 'mini' docking game. Something that is completely on rails."* +// +// THE FAULT WAS ONE STICK WITH TWO JOBS. The ship has no yaw axis, so a roll +// is how it aims. The slot wants that same roll for something else: the wings +// lined up with the letterbox. The docking computer reconciles the two +// (`docking-sticks.ts`). The pilot's stretch could not, because the pilot held +// the roll and the computer held only the pitch. A measurement of 2026-09-12 +// put the hand-over 407 to 886 units off the axis, and an ideal pilot docked 0 +// times in 4. With no roll at all, the same pilot docked 2 times in 4. +// +// SO THE RAILS HOLD THE LINE, AND THE PILOT HOLDS THE SPIN. This file is the +// one place in the game that moves the commander's ship other than by flying +// it. `test/docking.test.ts` scans for that, and it names this file. +// +// IT IS NOT A TELEPORT. Both corrections are eased. The nose turns by the +// SHORTEST rotation onto the axis, which carries no twist about the nose. So +// the pilot's own roll is untouched, and the roll is what the slot measures. + +import * as THREE from 'three'; +import type { PlayerShip } from '../player.ts'; +import type { DockPlan } from './docking.ts'; +import { slotNormal } from '../world/slot.ts'; +import { RAILS_LATERAL, RAILS_PULL, RAILS_RANGE, SLOT_SPEED_LIMIT } from '../constants/docking.ts'; + +const _out = new THREE.Vector3(); +const _rel = new THREE.Vector3(); +const _fwd = new THREE.Vector3(); +const _turn = new THREE.Quaternion(); + +/** + * Is the ship lined up well enough for the rails to take it? + * + * Four conditions, and each one matters. The plan must be on its last leg. + * The ship must be on the axis, inside `RAILS_LATERAL`. It must be slow enough + * for the slot already, so the mini game starts from a speed that can dock. + * `RAILS_RANGE` then keeps the game short. + */ +export function railsReady(plan: DockPlan, speed: number): boolean { + return plan.phase === 'run' && plan.lateral < RAILS_LATERAL + && speed <= SLOT_SPEED_LIMIT && plan.along < RAILS_RANGE; +} + +/** + * One frame on the rails. It runs AFTER `PlayerShip.update`, so it corrects + * the frame the ship just flew. + * + * @param dt the length of the frame, in seconds + */ +export function holdOnRails(player: PlayerShip, station: THREE.Object3D, dt: number): void { + const outward = slotNormal(station, _out); + const rel = _rel.copy(player.position).sub(station.position); + const along = rel.dot(outward); + // `rel` becomes the part of the offset that lies ACROSS the axis, once the + // part along the axis is taken out of it. + rel.addScaledVector(outward, -along); + player.position.addScaledVector(rel, -Math.min(1, RAILS_PULL * dt)); + const fwd = player.getForward(_fwd); + _turn.setFromUnitVectors(fwd, outward.multiplyScalar(-1)); + player.quaternion.premultiply(_turn).normalize(); +} diff --git a/src/game/docking.ts b/src/game/docking.ts index 43a01760..f791e659 100644 --- a/src/game/docking.ts +++ b/src/game/docking.ts @@ -55,6 +55,11 @@ export interface DockPlan { arrived: boolean; /** distance off the slot axis, for HUD and tests */ lateral: number; + /** + * How far along the slot axis the ship is, in front of the station. It is + * negative behind it. The rails read it (docs/TODO/212). + */ + along: number; /** * The plane this ship turns in, held across frames. `dock-path.ts` reads and * writes it. It is saved state, like the phase: a ship restored mid-approach @@ -91,6 +96,7 @@ export function planDocking( // perpendicular distance from the axis const lateral = _rel.addScaledVector(_slotN, -along).length(); out.lateral = lateral; + out.along = along; // The station's local X, and not its Y. `lookAt(heading, up)` puts the ship's // RIGHT perpendicular to the up-hint. The wings must lie along the slot's // LONG axis, which is the station's local Y (see the header). The Y put every @@ -172,6 +178,7 @@ export function planDocking( /** A fresh plan object to hand to `planDocking` each frame. */ export function makeDockPlan(): DockPlan { return { + along: 0, heading: new THREE.Vector3(0, 0, -1), up: new THREE.Vector3(0, 1, 0), speed: 0, diff --git a/src/game/flight-instruments.ts b/src/game/flight-instruments.ts index b73be4ff..49b9515a 100644 --- a/src/game/flight-instruments.ts +++ b/src/game/flight-instruments.ts @@ -206,12 +206,12 @@ export class Instruments { /** * The station course reaches the hand-over, and the ship changes hands - * (docs/TODO/207 M1). + * (docs/TODO/207 M1, in the shape docs/TODO/212 gave it). * * With a docking computer fitted, that computer flies the slot, as it does - * today. Without one, the pilot flies the last stretch. The computer holds - * the ship on the slot axis. The pilot matches the station's spin, and the - * speed. + * today. Without one, the pilot's own stretch begins. The computer lines the + * ship up first. The rails then take the ship, and the pilot matches the + * station's spin and the speed. */ private handOver(): void { const s = this.state.session; @@ -220,9 +220,10 @@ export class Instruments { return; } s.dockTrial = true; + s.dockRails = false; s.course = null; this.coursePilot.reset(); - this.host.showMessage('YOU HAVE THE SLOT — MATCH ITS SPIN AND GO IN SLOWLY', 5); + this.host.showMessage('THE COMPUTER IS LINING THE SHIP UP — STAND BY', 4); } /** @@ -239,6 +240,7 @@ export class Instruments { .distanceTo(this.state.world.station.position) > DOCK_COMPUTER_RANGE; if (!out) return; s.dockTrial = false; + s.dockRails = false; this.host.showMessage('THE STATION IS BEHIND YOU', 3); } diff --git a/src/game/session.ts b/src/game/session.ts index 354256d2..4e1955eb 100644 --- a/src/game/session.ts +++ b/src/game/session.ts @@ -110,6 +110,12 @@ export interface SessionState { * and the speed. It is saved, because it decides who flies. */ dockTrial: boolean; + /** + * The ship is on the rails, and the pilot flies the mini game + * (docs/TODO/212). It is the second half of `dockTrial`. The first half is + * the computer's, and it lines the ship up. It is saved, as `dockTrial` is. + */ + dockRails: boolean; } /** @@ -121,6 +127,7 @@ export function endVisit(state: SessionState): void { state.coursesDone = []; state.handFlown = false; state.dockTrial = false; + state.dockRails = false; } /** Put a message in canonical state; the HUD only paints these fields. */ diff --git a/src/game/state.ts b/src/game/state.ts index 39e9f45f..e82de7cb 100644 --- a/src/game/state.ts +++ b/src/game/state.ts @@ -160,6 +160,7 @@ export function freshSession(): SessionState { coursesDone: [], handFlown: false, dockTrial: false, + dockRails: false, }; } diff --git a/src/game/world-step.ts b/src/game/world-step.ts index 423a8ee6..b9563ed8 100644 --- a/src/game/world-step.ts +++ b/src/game/world-step.ts @@ -52,7 +52,10 @@ import { PIRATE_WAVE_RANGE, PIRATE_WAVE_RANGE_SPAN, THARGON_DEPLOY_RANGE, TRADER_ARRIVAL_RANGE, } from '../constants/spawn-placement.ts'; -import { planDocking, dockingOutcome, type DockingOutcome } from './docking.ts'; +import { + planDocking, dockingOutcome, type DockPlan, type DockingOutcome, +} from './docking.ts'; +import { holdOnRails, railsReady } from './dock-rails.ts'; import { dockingSticks } from './docking-sticks.ts'; import { NPC_HULL_BOX_MARGIN } from '../constants/docking.ts'; import { BOUNCE_STANDOFF } from '../constants/station.ts'; @@ -322,8 +325,10 @@ export class WorldStep { // before the ship flies, rather than applied on top of it. Where it hands // the ship back mid-frame, the pilot's own demand stands, as before. const dc = session.dcEngaged ? this.dockingComputerStep(dt, pilot, out) - : session.dockTrial ? this.dockTrialStep(dt, pilot) : null; + : session.dockTrial ? this.dockTrialStep(dt, pilot, out) : null; player.update(dt, dc ?? pilot.demand); + // The rails correct the frame the ship just flew (docs/TODO/212). + if (session.dockRails) holdOnRails(player, world.station, dt); // torus drive if (session.torusEngaged) { @@ -367,15 +372,32 @@ export class WorldStep { private dockingComputerStep( dt: number, pilot: PilotInput, out: StepEvent[], ): FlightDemand | null { - const { player, session, world } = this.state; + const { session } = this.state; if (pilot.handsOn) { session.dcEngaged = false; out.push({ kind: 'dockingMusic', on: false }); out.push(say('MANUAL OVERRIDE', 2)); return null; } - const plan = planDocking(player.position, world.station, world.stationDockZ, - player.maxSpeed, this.state.dockPlan); + return this.dockingDemand(dt, pilot, this.dockingPlan()); + } + + /** The approach the computer is flying this frame. */ + private dockingPlan(): DockPlan { + const s = this.state; + return planDocking(s.player.position, s.world.station, s.world.stationDockZ, + s.player.maxSpeed, s.dockPlan); + } + + /** + * What the docking computer asks of the ship this frame: both sticks, and + * the plan's own speed. + * + * The pilot's stretch shares it (docs/TODO/212). The computer lines the ship + * up there too, and it hands over only when the ship is ON the axis. + */ + private dockingDemand(dt: number, pilot: PilotInput, plan: DockPlan): FlightDemand { + const { player } = this.state; const sticks = dockingSticks(player.quaternion, plan, player.rollRate); // Bang-bang on the throttle, with a deadband of one frame's thrust. A // demand can only ask for full ahead, full astern or coast, because that is @@ -398,30 +420,38 @@ export class WorldStep { } /** - * One frame of the pilot's own stretch of the approach (docs/TODO/207). + * One frame of the pilot's own stretch of the approach (docs/TODO/207, and + * docs/TODO/212 for its shape). * - * The computer holds the ship on the slot axis, which is the pitch. The - * pilot owns the roll and the throttle. The slot asks for those two things: - * the station's spin, and a speed it will take. + * IT IS TWO STAGES. The computer lines the ship up first, with both sticks, + * exactly as the docking computer does. Then the rails take the ship, and + * the pilot plays the mini game: match the slot, and go in slowly. * - * It is the docking computer's own plan, with two of its three sticks given - * back. So the ship follows the same curve to the letterbox, and the last - * of the manoeuvre is the pilot's. + * Chris asked for that on 2026-09-12: *"I'm wondering if we actually get + * lined up by the computer and then hand off to a 'mini' docking game. + * Something that is completely on rails."* One stick cannot hold a line and + * match a spin at the same time. The rails hold the line, so the stick is + * free for the spin. */ - private dockTrialStep(dt: number, pilot: PilotInput): FlightDemand { - const { player, world } = this.state; - const plan = planDocking(player.position, world.station, world.stationDockZ, - player.maxSpeed, this.state.dockPlan); - const sticks = dockingSticks(player.quaternion, plan, player.rollRate); + private dockTrialStep(dt: number, pilot: PilotInput, out: StepEvent[]): FlightDemand { + const { player, session } = this.state; + const plan = this.dockingPlan(); + if (!session.dockRails) { + if (!railsReady(plan, player.speed)) return this.dockingDemand(dt, pilot, plan); + session.dockRails = true; + out.push(say('THE SLOT IS YOURS — MATCH IT, AND GO IN SLOWLY', 4)); + } + // ON THE RAILS. The pitch is nobody's: `holdOnRails` owns the line. The + // roll and the throttle are the pilot's, and they are the whole game. return { - pitchRate: rampFlightRate( - player.pitchRate, sticks.pitch * PLAYER_FLIGHT.maxPitch, sticks.pitch !== 0, dt), + pitchRate: rampFlightRate(player.pitchRate, 0, false, dt), rollRate: pilot.demand.rollRate, throttle: pilot.demand.throttle, fire: pilot.demand.fire, }; } + /** Everyone else: decisions, despawns, collisions, and who else turns up. */ private stepNpcs(dt: number, out: StepEvent[]): void { const s = this.state; @@ -893,7 +923,9 @@ export class WorldStep { this.host.dock(); return; } - // hit the hull, or fluffed the slot + // hit the hull, or fluffed the slot. The rails let go, so the computer + // lines the ship up again for another go (docs/TODO/212). + this.state.session.dockRails = false; const away = this.tmp2.copy(player.position).sub(station.position).normalize(); player.position.copy(station.position).addScaledVector(away, BOUNCE_STANDOFF); player.speed = 0; diff --git a/src/hud/hud-binding.ts b/src/hud/hud-binding.ts index 58a69880..0f414aee 100644 --- a/src/hud/hud-binding.ts +++ b/src/hud/hud-binding.ts @@ -59,6 +59,7 @@ export interface HudSources { readonly assist: boolean; /** the pilot flies the last stretch into the slot (docs/TODO/207) */ readonly trial: boolean; + readonly rails: boolean; readonly ecmDetected: boolean; readonly messageText: string; readonly messageTimer: number; @@ -221,6 +222,7 @@ export function buildHudFrame(s: HudSources, scratch: HudScratch): HudFrame { missionMarker, assist: s.assist, trial: s.trial, + rails: s.rails, armed: s.missileArmed, stationInRange: s.inFlight && !s.witchspace && playerPos.distanceTo(world.station.position) < SCANNER_RANGE, diff --git a/src/hud/hud.ts b/src/hud/hud.ts index 0663cbf4..5cb9e021 100644 --- a/src/hud/hud.ts +++ b/src/hud/hud.ts @@ -156,6 +156,8 @@ export interface HudState { assist: boolean; /** the pilot flies the last stretch into the slot (docs/TODO/207) */ trial: boolean; + /** ...and the rails have it, so the mini game is on (docs/TODO/212) */ + rails: boolean; /** missile armed but not yet locked (yellow pylon) */ armed: boolean; /** console 'S': the space station is within scanner range */ @@ -288,8 +290,9 @@ export class Hud { this.altEl.style.width = `${Math.min(100, frame.altitudeFrac * 100)}%`; this.cabinEl.style.width = `${Math.min(100, frame.cabinTemp * 100)}%`; this.cabinEl.style.background = frame.cabinTemp > CABIN_GAUGE_WARN ? RED : ''; - this.viewEl.textContent = frame.trial ? '◆ MATCH THE SLOT — GO IN SLOWLY ◆' - : frame.assist ? '◆ THE COMPUTER IS AIMING ◆' : (VIEW_NAMES[frame.view] ?? ''); + this.viewEl.textContent = frame.rails ? '◆ MATCH THE SLOT — GO IN SLOWLY ◆' + : frame.trial ? '◆ THE COMPUTER IS LINING THE SHIP UP ◆' + : frame.assist ? '◆ THE COMPUTER IS AIMING ◆' : (VIEW_NAMES[frame.view] ?? ''); this.crosshairEl.style.display = frame.hasLaser ? '' : 'none'; this.shipIdEl.textContent = frame.shipId; this.drawEnergy(frame); diff --git a/test/dock-trial.test.ts b/test/dock-trial.test.ts index ac33a708..6a1e8ca1 100644 --- a/test/dock-trial.test.ts +++ b/test/dock-trial.test.ts @@ -13,7 +13,12 @@ import { keymap } from '../src/engine/keymap.ts'; import { dockingOutcome } from '../src/game/docking.ts'; import { SLOT_SPEED_LIMIT } from '../src/constants/docking.ts'; import { PLAYER_FLIGHT } from '../src/constants/player-flight.ts'; -import { check, eq } from './harness.ts'; +import { Game } from '../src/game/game.ts'; +import { headlessShell } from '../src/engine/shell.ts'; +import { withoutSaving } from '../src/game/storage.ts'; +import { seedWorld } from '../src/game/rng.ts'; +import { SLOT_HALF_ACROSS } from '../src/constants/docking.ts'; +import { check, dismissBriefing, eq } from './harness.ts'; console.log('\nthe last stretch into the slot'); @@ -22,10 +27,19 @@ console.log('\nthe last stretch into the slot'); const trial = actionButtonsFor({ fireKey: 'KeyA', missiles: 3, armed: false, locked: false, armKey: 'KeyT', launchKey: 'KeyM', ecmKey: 'KeyE', targets: null, missileInbound: false, - trial: true, accelKey: 'Space', decelKey: 'KeyX', rollStripCode: 'roll', + trial: true, rails: true, accelKey: 'Space', decelKey: 'KeyX', rollStripCode: 'roll', }); eq('the stretch shows a strip and two held buttons, and no guns', trial.map((b) => b.label).join(), 'DRAG TO ROLL,THRUST,BRAKE'); + // ...and before the rails take it, the pilot has nothing to do yet + // (docs/TODO/212). A strip that did nothing would be a lie. + const lining = actionButtonsFor({ + fireKey: 'KeyA', missiles: 3, armed: false, locked: false, armKey: 'KeyT', + launchKey: 'KeyM', ecmKey: 'KeyE', targets: null, missileInbound: false, + trial: true, rails: false, accelKey: 'Space', decelKey: 'KeyX', rollStripCode: 'roll', + }); + eq('while the computer lines up, the pilot sees one word and no controls', + lining.map((b) => b.label).join(), 'LINING UP'); check('the strip is dragged, not pressed', trial[0]?.strip === true); check('...and the throttle buttons are held', trial[1]?.hold === true && trial[2]?.hold === true); } @@ -87,3 +101,75 @@ console.log('\nthe last stretch into the slot'); check('the limit is well under the ship\'s top speed, so it is a real choice', SLOT_SPEED_LIMIT < PLAYER_FLIGHT.maxSpeed / 2); } + +// --- THE MINI GAME: THE COMPUTER LINES UP, THE RAILS HOLD THE LINE ---------- +// +// Chris flew 207's stretch on a phone (2026-09-12): *"The docking does not +// seem to work at all... lining up is not actually very accurate until the +// last few moments. So we aren't actually flying straight and rolling can send +// you off away from the slot."* He asked for the shape this pins: *"we +// actually get lined up by the computer and then hand off to a 'mini' docking +// game. Something that is completely on rails."* +// +// The whole game, flown headless: the course, the computer's lining up, and +// then the rails with a pilot's hand on the strip. +console.log('\nthe docking mini game'); +{ + /** A commander at the witchpoint with the station course picked. */ + const arrive = (seed: number): Game => { + const g = withoutSaving(() => { + seedWorld(seed); + const game = new Game(() => headlessShell()); + dismissBriefing(game); + game.launch(); + game.arriveInSystem(); + return game; + }).value; + g.state.world.clearNpcs(); + g.state.session.course = 'station'; + return g; + }; + + /** + * Fly to the rails, then hold the strip as a pilot does. + * + * @param match whether the pilot matches the slot. A pilot who does nothing + * is the control: the slot is only there to meet about two turns in five. + */ + const fly = (g: Game, match: boolean): { rails: boolean; docked: boolean; lateral: number } => { + const dt = 1 / 60; + const q = new THREE.Quaternion(); + const right = new THREE.Vector3(); + let rails = false; + let lateral = Infinity; + withoutSaving(() => { + for (let f = 0, at = 0; f < 200 / dt; f++) { + const st = g.state.world.station; + if (g.state.session.dockRails) { + rails = true; + const local = g.state.player.position.clone(); + st.worldToLocal(local); + lateral = Math.min(lateral, Math.hypot(local.x, local.y)); + if (match) { + q.copy(st.quaternion).invert().multiply(g.state.player.quaternion); + right.set(1, 0, 0).applyQuaternion(q); + // The slot fits either way up, so the error wraps at a quarter + // turn rather than a half. + const err = Math.atan2(right.x, right.y); + g.input.rollStick = Math.max(-1, Math.min(1, + Math.atan2(Math.sin(2 * err), Math.cos(2 * err)) / 2 * 4)); + } + } + g.step(dt, at += dt); + if (g.mode !== 'flight') break; + } + }); + return { rails, docked: g.mode === 'docked', lateral }; + }; + + const run = fly(arrive(20_260_951), true); + check('the rails take the ship', run.rails); + check('...and a pilot who matches the slot docks', run.docked); + check('...having been held on the line, inside the channel', + run.lateral < SLOT_HALF_ACROSS, `${run.lateral.toFixed(0)} units off the axis`); +} diff --git a/test/docking.test.ts b/test/docking.test.ts index ba5f55d6..3f70f876 100644 --- a/test/docking.test.ts +++ b/test/docking.test.ts @@ -16,7 +16,7 @@ // slotMiss, hull) is test/world.test.ts's docking section; this file is about // WHERE the edges are. -import { readFileSync } from 'node:fs'; +import { readFileSync, readdirSync } from 'node:fs'; import * as THREE from 'three'; import { dockingOutcome, planDocking, makeDockPlan, type DockingOutcome, @@ -35,7 +35,7 @@ import { newCommander } from '../src/game/commander.ts'; import { seedWorld } from '../src/game/rng.ts'; import { slotNormal } from '../src/world/slot.ts'; import type { DamageSource } from '../src/game/combat.ts'; -import { check } from './harness.ts'; +import { check, eq } from './harness.ts'; /** The edge between `inside(lo)` and `!inside(hi)`, to a millionth of a unit. */ function bisect(lo: number, hi: number, inside: (x: number) => boolean): number { @@ -271,6 +271,29 @@ function makeRun() { !READ_ONLY_QUATERNION.includes('rotateTowards')); } +// ...AND ONE FILE IN THE WHOLE GAME MAY MOVE THE SHIP ANOTHER WAY +// (docs/TODO/212). The rails of the docking mini game hold the ship on the +// slot axis, and that is not flying. Chris asked for exactly that. The rule +// above is about STEERING, so it stays. This says where the exception lives, +// because a reader of the rule above would otherwise believe there is none. +{ + const dir = new URL('../src/game/', import.meta.url); + const writers = readdirSync(dir) + .filter((name) => name.endsWith('.ts')) + .filter((name) => { + const src = readFileSync(new URL(name, dir), 'utf8') + .replace(/^\s*(\/\/|\*|\/\*).*$/gm, ''); + return [...src.matchAll(/player\.quaternion\s*\.\s*([a-zA-Z]+)/g)] + .some((m) => !READ_ONLY_QUATERNION.includes(m[1])); + }); + // The other three PLACE the ship rather than fly it: a new game and a + // respawn (game.ts), a restored save (persistence.ts), and the setup of one + // training exercise (combat-sim.ts). A fourth name here is a new hand on the + // ship, and it must answer for itself. + eq('dock-rails.ts is the only file in game/ that turns the ship WHILE it flies', + writers.join(', '), 'combat-sim.ts, dock-rails.ts, game.ts, persistence.ts'); +} + // --- what a fluffed slot does to you, through the same step ------------------ { diff --git a/test/fight-buttons.test.ts b/test/fight-buttons.test.ts index e47697d9..14558537 100644 --- a/test/fight-buttons.test.ts +++ b/test/fight-buttons.test.ts @@ -21,7 +21,7 @@ console.log('\nthe pilot\'s buttons'); const base = { fireKey: 'KeyA', missiles: 3, armed: false, locked: false, armKey: 'KeyT', launchKey: 'KeyM', ecmKey: null, targets: null, missileInbound: false, - trial: false, accelKey: 'Space', decelKey: 'KeyX', rollStripCode: 'roll', + trial: false, rails: false, accelKey: 'Space', decelKey: 'KeyX', rollStripCode: 'roll', }; { const b = actionButtonsFor(base); From 40ae5468cc8ddce1ef13ca8247bec8bcef72d115 Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Sat, 12 Sep 2026 12:33:45 +0100 Subject: [PATCH 040/100] docs/TODO/212: the ship stops on the line, and the pilot thrusts in Chris flew the mini game: "That works - but it's a bit too easy I think. Maybe reducing the speed to nothing so the user has to thrust forward would be good." He is right. The rails took the ship at 107 units a second, so the speed was already made and a hand on the roll was the whole game. The computer brakes the ship to a halt now, 632 units out on the slot axis, and the pilot flies the whole run in. Measured over the same seeds: thrusts in and matches the slot 6 of 6 docked, first go thrusts in and never matches scrapes, 2 or 3 goes, 1 of 8 died touches nothing waits there, and never docks So nothing docks by accident any more. The console reads THRUST IN, AND MATCH THE SLOT, and the manual says the ship waits for you. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- ...r-lines-up-and-the-pilot-plays-the-slot.md | 15 +++++++++ docs/TODO/completed/README.md | 2 +- manual.html | 10 +++--- src/constants/CATALOG.md | 3 +- src/constants/docking.ts | 14 +++++++++ src/game/cockpit-buttons.ts | 2 +- src/game/dock-rails.ts | 30 +++++++++++++----- src/game/world-step.ts | 11 +++++-- src/hud/hud.ts | 2 +- test/dock-trial.test.ts | 31 ++++++++++++++++--- 10 files changed, 97 insertions(+), 23 deletions(-) diff --git a/docs/TODO/completed/212-the-computer-lines-up-and-the-pilot-plays-the-slot.md b/docs/TODO/completed/212-the-computer-lines-up-and-the-pilot-plays-the-slot.md index af8ac81b..7c422531 100644 --- a/docs/TODO/completed/212-the-computer-lines-up-and-the-pilot-plays-the-slot.md +++ b/docs/TODO/completed/212-the-computer-lines-up-and-the-pilot-plays-the-slot.md @@ -107,6 +107,21 @@ lines the ship up again. Two of six seeds docked on the second go. first frame moves the ship 7 units across the line. The error is gone in about two seconds, well before the mouth. +**IT WAS TOO EASY AT FIRST.** Chris flew it (2026-09-12): *"That works - but +it's a bit too easy I think. Maybe reducing the speed to nothing so the user +has to thrust forward would be good."* The rails took the ship at 107 units a +second, so the speed was already made, and a hand on the roll was the whole +game. The computer brakes the ship to a halt now. It stops 632 units out, on +the line, and the pilot flies the whole run in. + +**The three pilots, measured again over the same seeds:** + +| pilot | result | +| --- | --- | +| thrusts in and matches the slot | 6 of 6 docked, first go | +| thrusts in and never matches | scrapes, and takes 2 or 3 goes. One of 8 died | +| touches nothing | waits there for ever, and never docks | + ## Outcome Landed on 2026-09-12. `npm run check` passes. diff --git a/docs/TODO/completed/README.md b/docs/TODO/completed/README.md index 6dc55826..f6986efe 100644 --- a/docs/TODO/completed/README.md +++ b/docs/TODO/completed/README.md @@ -221,4 +221,4 @@ Supporting records: [Elite-A alignment plan](ELITE-A-COMBAT-PLAN.md), - [x] 209 — [The torus drive says what stopped it](209-the-drive-says-what-stopped-it.md) — Chris, 2026-09-12. He flew to the station and saw no mass lock on a neutral trader. The rule did fire. **M1** makes the drop name what stopped the drive, because "MASS LOCK" named nothing. **M2** announces a neutral trader that comes close, one time, because the drive is off for most of a trip. 5,871 assertions. - [x] 210 — [The ship does not roll all the way there](210-the-ship-does-not-roll-all-the-way-there.md) — Chris, 2026-09-12. He flew a course and saw the ship rotate all the way to its target. The steering held a cone: the nose circled the target, and the roll never stopped. **M1** gives the course pilot a hard roll gate, which holds the pitch still until the bank arrives. A median trip fell from 41 full turns of roll to 1.3. The fight keeps the law it has. 5,877 assertions. - [x] 211 — [The ship stops short of the rock](211-the-ship-stops-short-of-the-rock.md) — Chris, 2026-09-12. He picked a rock and the ship flew on into it. The speed deadband held a drift as well as a speed, and the standoff was measured to the target's centre. **M1** brakes to a stop inside the standoff, and measures that range from the hull. A picked rock now holds 500 units of clear space. 5,886 assertions. -- [x] 212 — [The computer lines up, and the pilot plays the slot](212-the-computer-lines-up-and-the-pilot-plays-the-slot.md) — Chris, 2026-09-12. He flew 207's docking on a phone and it did not work. The pilot took the ship 407 to 886 units off the slot axis, and a roll to match the spin turned the computer's own correction. **M1** makes the stretch two stages: the computer lines the ship up, then the rails hold the line while the pilot matches the slot and the speed. **M2** puts the rails in `game/dock-rails.ts`. An ideal pilot went from 0 of 4 to 8 of 8. 5,891 assertions. +- [x] 212 — [The computer lines up, and the pilot plays the slot](212-the-computer-lines-up-and-the-pilot-plays-the-slot.md) — Chris, 2026-09-12. He flew 207's docking on a phone and it did not work. The pilot took the ship 407 to 886 units off the slot axis, and a roll to match the spin turned the computer's own correction. **M1** makes the stretch two stages: the computer lines the ship up, then the rails hold the line while the pilot matches the slot and the speed. **M2** puts the rails in `game/dock-rails.ts`. The computer stops the ship on the line, so the pilot thrusts the whole run in. An ideal pilot went from 0 of 4 to 6 of 6, and a pilot who touches nothing never docks. 5,893 assertions. diff --git a/manual.html b/manual.html index 16fe08a7..120476ed 100644 --- a/manual.html +++ b/manual.html @@ -276,10 +276,12 @@

    Docking

    behind you.
  • The console reads LINING UP while the computer puts the ship on the axis. There is nothing to do yet.
    • -
  • When it is lined up, the slot is yours. The ship stays on the - line by itself from there, so you cannot miss the hole. Two things - are left to you, and they are the whole of it: the roll, and the - speed.
    • +
  • The ship comes to a stop on the line, and the slot is yours. It + stays on the line by itself from there, so you cannot miss the + hole. Two things are left to you, and they are the whole of it: the + roll, and the speed.
    • +
  • Nothing happens until you thrust. You can sit there as + long as you like and watch the port turn.
  • Roll to match the port's rotation. This is the part people miss. The opening is a letterbox, and your ship has to be the same way up as it is. Drag the strip at the bottom right, or use your diff --git a/src/constants/CATALOG.md b/src/constants/CATALOG.md index 0b3790e5..40d6909e 100644 --- a/src/constants/CATALOG.md +++ b/src/constants/CATALOG.md @@ -2,7 +2,7 @@ -448 exported constants. Regenerate with `npm run generate:constants`; +449 exported constants. Regenerate with `npm run generate:constants`; search names, meanings and values with `npm run constants:find -- ""`. | Domain | Symbol | Literal / expression | Purpose | Rule ID | Source | @@ -147,6 +147,7 @@ search names, meanings and values with `npm run constants:find -- ""`. | docking | RAILS_LATERAL | 250 | How far off the slot axis the ship may be when the rails take it, in world units (docs/TODO/212). | docking.railsLateral | [docking.ts:187](./docking.ts#L187) | | docking | RAILS_RANGE | 900 | How far out the rails take the ship, in world units (docs/TODO/212). | docking.railsRange | [docking.ts:199](./docking.ts#L199) | | docking | RAILS_PULL | 2 | How hard the rails pull the ship onto the axis, per second (docs/TODO/212). | docking.railsPull | [docking.ts:211](./docking.ts#L211) | +| docking | RAILS_STOPPED | 2 | The speed under which the ship counts as stopped, in world units a second (docs/TODO/212). | docking.railsStopped | [docking.ts:225](./docking.ts#L225) | | docking-computer | DOCK_COMPUTER_RANGE | 3500 | How close to the station the docking computer will take the job, in world units. | | [docking-computer.ts:46](./docking-computer.ts#L46) | | docking-computer | DC_SLOT_MARGIN | 0.30 | How much of the slot's roll tolerance the TURN may spend, as a fraction. | docking.slotMargin | [docking-computer.ts:97](./docking-computer.ts#L97) | | docking-computer | DC_TURN_FADE_ANGLE | 0.10 | The off-nose angle, in radians, over which the TURN's claim on the roll axis ramps in. | docking.turnFadeAngle | [docking-computer.ts:151](./docking-computer.ts#L151) | diff --git a/src/constants/docking.ts b/src/constants/docking.ts index 6b377ffe..248610d6 100644 --- a/src/constants/docking.ts +++ b/src/constants/docking.ts @@ -209,3 +209,17 @@ export const RAILS_RANGE = 900; * @domain docking */ export const RAILS_PULL = 2; + +/** + * The speed under which the ship counts as stopped, in world units a second + * (docs/TODO/212). + * + * The computer brakes the ship to a halt on the slot axis, and the rails then + * take it. The pilot thrusts in from there. A ship thrusts at 220 units a + * second per second, so 2 is under a hundredth of a second of thrust. It is a + * band rather than a zero, because the brake is a sign and not a gain. + * + * @rule docking.railsStopped + * @domain docking + */ +export const RAILS_STOPPED = 2; diff --git a/src/game/cockpit-buttons.ts b/src/game/cockpit-buttons.ts index 653d4b76..7ccc280f 100644 --- a/src/game/cockpit-buttons.ts +++ b/src/game/cockpit-buttons.ts @@ -90,7 +90,7 @@ export function actionButtonsFor(a: ActionSource): HudButton[] { if (a.trial) { const out: HudButton[] = [{ code: a.rollStripCode, label: 'DRAG TO ROLL', strip: true }]; if (a.accelKey) { - out.push({ code: a.accelKey, label: 'THRUST', hint: 'HOLD TO SPEED UP', hold: true }); + out.push({ code: a.accelKey, label: 'THRUST', hint: 'HOLD TO GO IN', hold: true }); } if (a.decelKey) { out.push({ code: a.decelKey, label: 'BRAKE', hint: 'HOLD TO SLOW DOWN', hold: true }); diff --git a/src/game/dock-rails.ts b/src/game/dock-rails.ts index 9e310252..dcc1f267 100644 --- a/src/game/dock-rails.ts +++ b/src/game/dock-rails.ts @@ -27,7 +27,9 @@ import * as THREE from 'three'; import type { PlayerShip } from '../player.ts'; import type { DockPlan } from './docking.ts'; import { slotNormal } from '../world/slot.ts'; -import { RAILS_LATERAL, RAILS_PULL, RAILS_RANGE, SLOT_SPEED_LIMIT } from '../constants/docking.ts'; +import { + RAILS_LATERAL, RAILS_PULL, RAILS_RANGE, RAILS_STOPPED, +} from '../constants/docking.ts'; const _out = new THREE.Vector3(); const _rel = new THREE.Vector3(); @@ -35,16 +37,28 @@ const _fwd = new THREE.Vector3(); const _turn = new THREE.Quaternion(); /** - * Is the ship lined up well enough for the rails to take it? + * Is the ship at the place where the computer stops it? * - * Four conditions, and each one matters. The plan must be on its last leg. - * The ship must be on the axis, inside `RAILS_LATERAL`. It must be slow enough - * for the slot already, so the mini game starts from a speed that can dock. - * `RAILS_RANGE` then keeps the game short. + * Three conditions, and each one matters. The plan must be on its last leg. + * The ship must be on the axis, inside `RAILS_LATERAL`. `RAILS_RANGE` then + * keeps the game short. */ -export function railsReady(plan: DockPlan, speed: number): boolean { +export function railsReached(plan: DockPlan): boolean { return plan.phase === 'run' && plan.lateral < RAILS_LATERAL - && speed <= SLOT_SPEED_LIMIT && plan.along < RAILS_RANGE; + && plan.along < RAILS_RANGE; +} + +/** + * Is the ship stopped, so the rails can take it? + * + * THE COMPUTER BRINGS THE SHIP TO A HALT FIRST (Chris, 2026-09-12: *"it's a + * bit too easy I think. Maybe reducing the speed to nothing so the user has to + * thrust forward would be good."*). The pilot then owns the whole run in, from + * a standing start. A ship that arrives with the speed already made needs only + * a hand on the roll. + */ +export function stopped(speed: number): boolean { + return speed <= RAILS_STOPPED; } /** diff --git a/src/game/world-step.ts b/src/game/world-step.ts index b9563ed8..d5350593 100644 --- a/src/game/world-step.ts +++ b/src/game/world-step.ts @@ -55,7 +55,7 @@ import { import { planDocking, dockingOutcome, type DockPlan, type DockingOutcome, } from './docking.ts'; -import { holdOnRails, railsReady } from './dock-rails.ts'; +import { holdOnRails, railsReached, stopped } from './dock-rails.ts'; import { dockingSticks } from './docking-sticks.ts'; import { NPC_HULL_BOX_MARGIN } from '../constants/docking.ts'; import { BOUNCE_STANDOFF } from '../constants/station.ts'; @@ -437,9 +437,14 @@ export class WorldStep { const { player, session } = this.state; const plan = this.dockingPlan(); if (!session.dockRails) { - if (!railsReady(plan, player.speed)) return this.dockingDemand(dt, pilot, plan); + if (!railsReached(plan)) return this.dockingDemand(dt, pilot, plan); + // On the axis, and the computer stops the ship there. The pilot then + // flies the whole run in (docs/TODO/212). + if (!stopped(player.speed)) { + return { ...this.dockingDemand(dt, pilot, plan), throttle: -1 }; + } session.dockRails = true; - out.push(say('THE SLOT IS YOURS — MATCH IT, AND GO IN SLOWLY', 4)); + out.push(say('THE SLOT IS YOURS — THRUST IN, AND MATCH ITS SPIN', 5)); } // ON THE RAILS. The pitch is nobody's: `holdOnRails` owns the line. The // roll and the throttle are the pilot's, and they are the whole game. diff --git a/src/hud/hud.ts b/src/hud/hud.ts index 5cb9e021..86e26a7c 100644 --- a/src/hud/hud.ts +++ b/src/hud/hud.ts @@ -290,7 +290,7 @@ export class Hud { this.altEl.style.width = `${Math.min(100, frame.altitudeFrac * 100)}%`; this.cabinEl.style.width = `${Math.min(100, frame.cabinTemp * 100)}%`; this.cabinEl.style.background = frame.cabinTemp > CABIN_GAUGE_WARN ? RED : ''; - this.viewEl.textContent = frame.rails ? '◆ MATCH THE SLOT — GO IN SLOWLY ◆' + this.viewEl.textContent = frame.rails ? '◆ THRUST IN, AND MATCH THE SLOT ◆' : frame.trial ? '◆ THE COMPUTER IS LINING THE SHIP UP ◆' : frame.assist ? '◆ THE COMPUTER IS AIMING ◆' : (VIEW_NAMES[frame.view] ?? ''); this.crosshairEl.style.display = frame.hasLaser ? '' : 'none'; diff --git a/test/dock-trial.test.ts b/test/dock-trial.test.ts index 6a1e8ca1..de9ea7ef 100644 --- a/test/dock-trial.test.ts +++ b/test/dock-trial.test.ts @@ -17,7 +17,7 @@ import { Game } from '../src/game/game.ts'; import { headlessShell } from '../src/engine/shell.ts'; import { withoutSaving } from '../src/game/storage.ts'; import { seedWorld } from '../src/game/rng.ts'; -import { SLOT_HALF_ACROSS } from '../src/constants/docking.ts'; +import { RAILS_STOPPED, SLOT_HALF_ACROSS } from '../src/constants/docking.ts'; import { check, dismissBriefing, eq } from './harness.ts'; console.log('\nthe last stretch into the slot'); @@ -136,20 +136,35 @@ console.log('\nthe docking mini game'); * @param match whether the pilot matches the slot. A pilot who does nothing * is the control: the slot is only there to meet about two turns in five. */ - const fly = (g: Game, match: boolean): { rails: boolean; docked: boolean; lateral: number } => { + const fly = (g: Game, match: boolean, hands = true): { + rails: boolean; docked: boolean; lateral: number; handedOver: number; + } => { const dt = 1 / 60; const q = new THREE.Quaternion(); const right = new THREE.Vector3(); + const thrust = keymap().accel[0] ?? ''; + const brake = keymap().decel[0] ?? ''; let rails = false; let lateral = Infinity; + let handedOver = -1; withoutSaving(() => { for (let f = 0, at = 0; f < 200 / dt; f++) { const st = g.state.world.station; if (g.state.session.dockRails) { + if (!rails) handedOver = g.state.player.speed; rails = true; const local = g.state.player.position.clone(); st.worldToLocal(local); lateral = Math.min(lateral, Math.hypot(local.x, local.y)); + // The ship is stopped when the rails take it, so the pilot thrusts + // the whole way in, and holds the speed the slot will take. + if (!hands) { + // the control: no hand on anything + } else if (g.state.player.speed < SLOT_SPEED_LIMIT * 0.6) { + g.input.press(thrust); g.input.release(brake); + } else { + g.input.release(thrust); g.input.press(brake); + } if (match) { q.copy(st.quaternion).invert().multiply(g.state.player.quaternion); right.set(1, 0, 0).applyQuaternion(q); @@ -164,12 +179,20 @@ console.log('\nthe docking mini game'); if (g.mode !== 'flight') break; } }); - return { rails, docked: g.mode === 'docked', lateral }; + return { rails, docked: g.mode === 'docked', lateral, handedOver }; }; const run = fly(arrive(20_260_951), true); check('the rails take the ship', run.rails); - check('...and a pilot who matches the slot docks', run.docked); + check('...with the ship stopped, so the pilot flies the whole run in', + run.handedOver <= RAILS_STOPPED, `${run.handedOver.toFixed(1)} units a second`); + check('...and a pilot who thrusts in and matches the slot docks', run.docked); check('...having been held on the line, inside the channel', run.lateral < SLOT_HALF_ACROSS, `${run.lateral.toFixed(0)} units off the axis`); + + // The control: hands off entirely. The ship stops on the axis and stays + // there, so nobody docks by accident (docs/TODO/212). Chris asked for that + // on 2026-09-12: the pilot must thrust in. + const idle = fly(arrive(20_260_951), false, false); + check('a pilot who touches nothing waits there, and never docks', !idle.docked); } From 31dafed13cf48d439ba720fb67d3b67b3f011a06 Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Sat, 12 Sep 2026 16:08:33 +0100 Subject: [PATCH 041/100] The co-pilot aims ahead of a ship, and it stops chasing one that circles Chris flew it and reported two faults. The combat computer struggles to lock onto a fast ship that circles the commander. It also oscillates when it chases a ship that weaves. The pitch rate is not the limit. A probe of the control law measured the bearing rate of every one of those targets between 0.24 and 0.79 radians a second, against a pitch cap of 1.45. The nose can always out-turn the bearing. The co-pilot read where the target IS, and it never read where the target goes. Two rules answer it, and each needs the other. 1. The aim leads the target. The gun is hitscan and needs no lead, but the NOSE takes time to swing. The lead is the swing that is LEFT, so it falls to zero as the nose arrives. A FIXED lead measured worse than no lead at all. 2. The throttle matches how fast the target RECEDES, not how fast it flies. A ship that circles you holds its range, so the commander now turns like a turret instead of flying past it. The lead takes `velocityOf`, which is the rule the pirates lead their shots with and the HUD draws its lead marker from. Its ceiling is the attack run's `MAX_LEAD_SECONDS`, which is the same rule with one home. Measured over 40 scripted targets, at real pirate speeds and a real pirate radius. The share of frames with the target inside the gun cone rose from 27.5% to 46.7%. The lead alone scores 41.7%, and the radial throttle alone scores 31.2%. Roll rate against a close circler falls from 1.08 to 0.78 radians a second, which is the oscillation Chris saw. The probe is not the game. It flies scripted targets rather than pirate brains, and it does not shoot. A 13-target sample and a 40-target sample disagreed about the radial throttle. Re-measure on the exercise wave harness before any retune. Four tests pin the pair, and each one fails when its rule is broken. The circling regression scores 5% on the old law and 29% on this one. Co-Authored-By: Claude Fable 5.1 Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- src/constants/CATALOG.md | 9 +- src/constants/combat-computer.ts | 51 +++++++++++ src/constants/pass-aim.ts | 11 +++ src/game/scripted-co-pilot.ts | 81 +++++++++++++---- test/scripted-co-pilot.test.ts | 146 +++++++++++++++++++++++++++++++ 5 files changed, 275 insertions(+), 23 deletions(-) diff --git a/src/constants/CATALOG.md b/src/constants/CATALOG.md index 40d6909e..470640e0 100644 --- a/src/constants/CATALOG.md +++ b/src/constants/CATALOG.md @@ -2,7 +2,7 @@ -449 exported constants. Regenerate with `npm run generate:constants`; +450 exported constants. Regenerate with `npm run generate:constants`; search names, meanings and values with `npm run constants:find -- ""`. | Domain | Symbol | Literal / expression | Purpose | Rule ID | Source | @@ -81,6 +81,7 @@ search names, meanings and values with `npm run constants:find -- ""`. | combat-computer | PURSUIT_HOLD_CONE | 1.85 | | | [combat-computer.ts:179](./combat-computer.ts#L179) | | combat-computer | ENGAGED_CONE | 0.6 | The nose-to-target angle, in radians, within which the co-pilot counts itself ENGAGED and will not switch targets. | | [combat-computer.ts:188](./combat-computer.ts#L188) | | combat-computer | TARGET_DIST_WEIGHT | 800 | How many world units of range weigh as much as one radian of off-nose turn. | copilot.targetDistWeight | [combat-computer.ts:206](./combat-computer.ts#L206) | +| combat-computer | PURSUIT_LEAD_GAIN | 2.0 | How many SECONDS the co-pilot aims ahead of a target, per radian that its nose still has to swing. | copilot.leadGain | [combat-computer.ts:257](./combat-computer.ts#L257) | | combat-record | SAMPLE_HZ | 10 | How often the code samples the geometry, in Hz. | | [combat-record.ts:12](./combat-record.ts#L12) | | combat-record | SIX_CONE | Math.PI / 3 | The rear cone that counts as somebody's six, as a half-angle from directly astern. | | [combat-record.ts:20](./combat-record.ts#L20) | | combat-record | PASS_CLOSE | 400 | What an attack run is, in ranges. | | [combat-record.ts:42](./combat-record.ts#L42) | @@ -300,9 +301,9 @@ search names, meanings and values with `npm run constants:find -- ""`. | ordnance | ECM_RATE | 0.45 | ...at this chance per second. | | [ordnance.ts:94](./ordnance.ts#L94) | | ordnance | ECM_ENERGY_COST | ENERGY_BANK_POINTS | A shot of the E.C.M. costs one bank of energy. | | [ordnance.ts:100](./ordnance.ts#L100) | | ordnance | ENERGY_BOMB_RANGE | 8000 | The energy bomb reaches this far. | | [ordnance.ts:103](./ordnance.ts#L103) | -| pass-aim | PASS_MISS_DISTANCE | 110 | How far to the SIDE of its target a ship aims its attack run. 110 clears the largest pirate hull, plus the commander's radius, twice over. | | [pass-aim.ts:13](./pass-aim.ts#L13) | -| pass-aim | MAX_LEAD_SECONDS | 0.5 | The furthest ahead of a target that a ship will aim, in seconds. | | [pass-aim.ts:21](./pass-aim.ts#L21) | -| pass-aim | MAX_MISS_STRETCH | 3 | The most that geometry may stretch the aim, in multiples of the intended pass. | passaim.maxMissStretch | [pass-aim.ts:31](./pass-aim.ts#L31) | +| pass-aim | PASS_MISS_DISTANCE | 110 | How far to the SIDE of its target a ship aims its attack run. 110 clears the largest pirate hull, plus the commander's radius, twice over. | | [pass-aim.ts:18](./pass-aim.ts#L18) | +| pass-aim | MAX_LEAD_SECONDS | 0.5 | The furthest ahead of a target that a ship will aim, in seconds. | | [pass-aim.ts:32](./pass-aim.ts#L32) | +| pass-aim | MAX_MISS_STRETCH | 3 | The most that geometry may stretch the aim, in multiples of the intended pass. | passaim.maxMissStretch | [pass-aim.ts:42](./pass-aim.ts#L42) | | planet | WITCHPOINT_RADII | 16 | How far out of the planet you drop from witch-space, in planet radii. | planet.witchpointRadii | [planet.ts:15](./planet.ts#L15) | | planet | PLANET_CRASH_ALTITUDE | 80 | The altitude above the surface at which the ship is destroyed. | | [planet.ts:24](./planet.ts#L24) | | player-flight | PLAYER_FLIGHT | { maxSpeed: 400, accel: 220, maxRoll: 2.5, maxPitch: 1.45, rateRamp: 4.1396, rateDecay: 13.3886, } as const | The player's flight envelope, in one place that a harness can read. | flight.player.maxSpeed
    flight.player.rateRamp | [player-flight.ts:21](./player-flight.ts#L21) | diff --git a/src/constants/combat-computer.ts b/src/constants/combat-computer.ts index ebd105c9..32e48cd4 100644 --- a/src/constants/combat-computer.ts +++ b/src/constants/combat-computer.ts @@ -204,3 +204,54 @@ export const ENGAGED_CONE = 0.6; * @rule copilot.targetDistWeight */ export const TARGET_DIST_WEIGHT = 800; + +/** + * How many SECONDS the co-pilot aims ahead of a target, per radian that its nose + * still has to swing. It is a gain, in seconds per radian. + * + * The CAP on it is `MAX_LEAD_SECONDS` (constants/pass-aim.ts), which the attack + * run already owns. That is one rule, not two. Each is the furthest ahead a ship + * aims, and the same pitch rate bounds each. A target dead astern asks for about + * pi radians of swing. This gain alone turns that into six seconds of lead. That + * aim point is nowhere near the fight. + * + * WHY A LEAD AT ALL, when the laser is hitscan. The gun needs none. The NOSE + * does. A swing takes time. The target moves while the swing runs. So an aim at + * where the target IS puts the nose where the target WAS. This lead cancels the + * swing time. It is lead for the ship, not for the shot. + * + * WHY IT SHRINKS WITH THE ERROR. A FIXED lead was measured first, and it is + * WORSE THAN NO LEAD AT ALL. A fixed lead is only right while the nose lags. + * Once the nose catches up, the lead becomes a standing miss. The nose parks + * ahead of the target and waits. The aim point then runs on again each frame. A + * lead set by the REMAINING swing falls to zero as the nose arrives. So it never + * does that. + * + * The measurement is a probe of this control law and of `player.ts`'s flight + * model. It flies 40 scripted targets, at real pirate speeds and at a real + * pirate radius. Each number below is the share of frames with the target inside + * the gun cone. + * + * 27.5% is the pursuit before this rule. + * 24.2% is a fixed 0.30 second lead. + * 21.1% is a fixed 0.30 second lead, with the radial throttle. + * 31.2% is the radial throttle alone. + * 41.7% is this lead alone. + * 46.7% is this lead, with the radial throttle. + * + * WHY 2.0. It is a plateau with a hole beside it. On a 13-target probe at 2.0 a + * fast, close circler scored 86%, and at 3.0 the same target scored 23%, while + * every other target held. Sweep this on the exercise wave harness before you + * move it. A 13-target sample and a 40-target sample disagreed about the radial + * throttle's worth, so a small sample is not enough to retune on. + * + * THE HOME IS THIS FILE, and the owner check disagrees. It reads the words + * "rule" and "bounded" above and reaches for the law domain. This is a feel + * setting of the SCRIPTED co-pilot. It sits in the `PURSUIT_*` block that the + * header of this file gives to that pilot. Nothing legal reads it, and no brain + * flies through it. + * + * @rule copilot.leadGain + * @domain combat-computer + */ +export const PURSUIT_LEAD_GAIN = 2.0; diff --git a/src/constants/pass-aim.ts b/src/constants/pass-aim.ts index 89a6e8aa..7a0971f7 100644 --- a/src/constants/pass-aim.ts +++ b/src/constants/pass-aim.ts @@ -3,6 +3,11 @@ // An attack run has to pass beside where the target WILL BE, on a line it has // room to get onto. These three numbers say how far beside, and how far ahead. // `game/pass-aim.ts` turns them into a heading. +// +// `MAX_LEAD_SECONDS` has a SECOND reader, and it is not an attack run. The +// scripted co-pilot caps its own lead with it (`game/scripted-co-pilot.ts`). +// The two lead for different reasons and take the same ceiling, which the +// comment on the constant states. /** * How far to the SIDE of its target a ship aims its attack run. 110 clears the @@ -17,6 +22,12 @@ export const PASS_MISS_DISTANCE = 110; * pitches at 1.45 rad/s, so half a second is already 41 degrees of heading * change. That is enough lead to matter, and it does not extrapolate a stale * straight line. + * + * TWO PILOTS TAKE IT, for two different reasons, and the ceiling is the same + * one. The attack run leads to predict a MERGE (`game/pass-aim.ts`). The + * scripted co-pilot leads to cancel the time its own NOSE takes to swing + * (`PURSUIT_LEAD_GAIN`). Both are "how far ahead a ship may aim", and both are + * bounded by that same pitch rate. It stays one rule with one home. */ export const MAX_LEAD_SECONDS = 0.5; diff --git a/src/game/scripted-co-pilot.ts b/src/game/scripted-co-pilot.ts index 6f2fa155..ddf5cf95 100644 --- a/src/game/scripted-co-pilot.ts +++ b/src/game/scripted-co-pilot.ts @@ -3,15 +3,25 @@ // A person gets on the opponent's six and shoots it up. She hauls the throttle // back to swing the nose round, so that she stays on a target that crosses her. // -// That is pure pursuit. Point the nose AT the target: the laser is hitscan, so -// there is no lead, and you aim where the target is. The line then curves you -// onto its tail as it turns and runs. A throttle holds a gun-range standoff -// behind it, and comes off hard when the nose has a long way to swing. +// That is pursuit. The aim line curves you onto its tail as it turns and runs. +// A throttle holds a gun-range standoff behind it, and comes off hard when the +// nose has a long way to swing. +// +// It aims a little AHEAD of the target, and the gun is not the reason. The laser +// is hitscan, so the SHOT needs no lead. The NOSE needs one. A swing takes time. +// The target moves while the swing runs. So an aim at where the target IS puts +// the nose where the target WAS. The swing that is LEFT sets the lead. The lead +// falls to zero as the nose arrives (`PURSUIT_LEAD_GAIN`). +// +// The throttle matches the target's RADIAL speed rather than its whole speed. A +// ship that circles you barely recedes, so the commander stops and turns like a +// turret. A ship that runs recedes at its full speed, so the commander chases. // // It flies `pursuit.ts` rather than the attack run. The pirates fly their own // pursuit: hold the six, then break into a fast pass when faced (npc.ts // `pursue`). That is a separate ship and a separate decision. The two share -// `pursuitSpeed`, so they cannot drift. +// `pursuitSpeed`, so the standoff rule cannot drift. They hand it a different +// speed to match, and `pursuitThrottle` below says why. // // It DECIDES and reports, like every module here. What comes back is a // `FlightDemand` — ramped pitch and roll rates, a throttle, a trigger — and one @@ -33,13 +43,16 @@ import { hitCone } from './gunnery.ts'; import { autopilotEcm } from './ordnance.ts'; import { bankToTurn, freshSteerMemory, type SteerMemory } from './pitch-roll-steer.ts'; import { pursuitSpeed } from './pursuit.ts'; +import { velocityOf } from './flight-maths.ts'; import { rampFlightRate, type FlightDemand } from '../player.ts'; import { LASER_RANGE } from '../constants/player-gun.ts'; import { UNDER_FIRE_SECONDS } from '../constants/attack-run.ts'; import { THREAT_RANGE, PURSUIT_SPEED_DEADBAND, ENGAGED_CONE, TARGET_DIST_WEIGHT, + PURSUIT_LEAD_GAIN, } from '../constants/combat-computer.ts'; import { PLAYER_FLIGHT } from '../constants/player-flight.ts'; +import { MAX_LEAD_SECONDS } from '../constants/pass-aim.ts'; import type { V3 } from '../ai-training/observation.ts'; export type CoPilotStep = @@ -63,6 +76,9 @@ export class ScriptedCoPilot { private readonly lock = new ThreatLock(); private readonly toThreat = new THREE.Vector3(); private readonly nose = new THREE.Vector3(); + /** where the target goes, and where the nose is sent — see `step` */ + private readonly threatVel = new THREE.Vector3(); + private readonly aim = new THREE.Vector3(); /** ramped turn rates, so the co-pilot's turn continues smoothly frame to frame */ private pitchRate = 0; private rollRate = 0; @@ -143,23 +159,43 @@ export class ScriptedCoPilot { // no bank to centre a target that is already inside it. const cone = hitCone(threat.radius, dist); - // PURE PURSUIT: bank-to-turn straight at where the target IS. The gun is - // hitscan, so there is nothing to lead. An aim AT the target rather than - // ahead of it is what walks the nose onto the six as the target turns and - // runs. It ramps through the commander's own envelope (PLAYER_FLIGHT), so - // the co-pilot flies your ship as your hands would. + // How far off the nose the target is. The steer, the throttle and the + // trigger all read it. It is taken before the Game integrates the demand, + // so one frame's turn of about 0.02 rad is not in it. + this.toThreat.copy(targetPos).sub(player.position); + const facing = this.nose.set(0, 0, -1).applyQuaternion(player.quaternion) + .angleTo(this.toThreat); + + // Where the target goes. `velocityOf` is the nose-and-thrust rule that the + // pirates lead their shots with, and that the HUD's lead marker draws. One + // rule, so the aid and the co-pilot cannot come to disagree. + velocityOf(threat.object.quaternion, threat.state.speed, this.threatVel); + + // PURSUIT, aimed at where the nose can ARRIVE. See the module header for why + // a hitscan gun still wants a lead. The lead is the swing that is LEFT times + // `PURSUIT_LEAD_GAIN`, capped, so it falls to zero as the nose closes. A + // fixed lead instead fights the radial throttle below, and it measured worse + // than no lead at all. The ceiling is the attack run's `MAX_LEAD_SECONDS`, + // which is the same rule: how far ahead a ship may aim. + this.aim.copy(targetPos).addScaledVector( + this.threatVel, Math.min(MAX_LEAD_SECONDS, PURSUIT_LEAD_GAIN * facing)); + // It ramps through the commander's own envelope (PLAYER_FLIGHT), so the + // co-pilot flies your ship as your hands would. const cmd = bankToTurn(player.quaternion, - this.toThreat.copy(targetPos).sub(player.position), this.steerMem, cone); + this.aim.sub(player.position), this.steerMem, cone); this.pitchRate = rampFlightRate( this.pitchRate, cmd.pitch * PLAYER_FLIGHT.maxPitch, cmd.pitch !== 0, dt); this.rollRate = rampFlightRate( this.rollRate, cmd.roll * PLAYER_FLIGHT.maxRoll, cmd.roll !== 0, dt); - // How far off the nose the target is. It is taken AFTER this frame's ramp - // is decided, and before the Game integrates it. One frame's turn is - // ~0.02 rad, which neither the throttle nor the fire cone can see. - const facing = this.nose.set(0, 0, -1).applyQuaternion(player.quaternion) - .angleTo(this.toThreat.copy(targetPos).sub(player.position)); + // How fast the target RECEDES, which is the speed that holds a standoff. Its + // whole speed is the wrong number. A ship that circles you holds its range + // while it flies at 300. A chase at 300 then carries the commander past it. + // Negative means it closes, and the standoff term alone answers that. + // + // It leaves `toThreat` a UNIT vector. That is the last read of it in this + // step. Copy it again before you use it as a distance below this line. + const recede = Math.max(0, this.threatVel.dot(this.toThreat.normalize())); return { kind: 'fly', @@ -172,7 +208,7 @@ export class ScriptedCoPilot { // which reads as a ram in the window. The gun below keeps the true // distance, because a shot travels to the hull by itself. throttle: this.pursuitThrottle( - player.speed, threat.state.speed, dist - threat.radius, facing), + player.speed, recede, dist - threat.radius, facing), // the trigger only when the shot would count: the player gun's own cone // and range (gunnery.ts). The laser's heat and cooldown pace it from // there, which is what makes this a marksman rather than a sprayer @@ -191,11 +227,18 @@ export class ScriptedCoPilot { * shares it, so the two cannot drift. This turns that speed into the * throttle SIGN that `FlightDemand` wants. A deadband makes it coast at the * held speed rather than pump around it. + * + * WHICH speed to match is the CALLER's to choose, and the two callers choose + * differently. The pirate matches its target's whole speed. This one matches + * how fast the target RECEDES, so a target that circles is met with a stop + * rather than with a chase. See `step`. + * + * @param recede how fast the target opens the range, in world units a second. */ private pursuitThrottle( - ownSpeed: number, targetSpeed: number, dist: number, facing: number, + ownSpeed: number, recede: number, dist: number, facing: number, ): number { - const want = pursuitSpeed(targetSpeed, dist, facing, PLAYER_FLIGHT.maxSpeed); + const want = pursuitSpeed(recede, dist, facing, PLAYER_FLIGHT.maxSpeed); const diff = want - ownSpeed; // A STOP IS A STOP (docs/TODO/211). The deadband holds a speed steady, and // it must not hold a drift. A target that sits still asks for a wanted diff --git a/test/scripted-co-pilot.test.ts b/test/scripted-co-pilot.test.ts index 0245a28a..06de8600 100644 --- a/test/scripted-co-pilot.test.ts +++ b/test/scripted-co-pilot.test.ts @@ -232,3 +232,149 @@ console.log('\nthe co-pilot stops at the standoff'); check('...and 200 units outside it is not', outside.kind === 'fly' && outside.demand.throttle === 1); } + +// --- IT LEADS THE NOSE, AND IT MATCHES THE RADIAL SPEED -------------------- +// +// Chris, 2026-09-12: *"it can struggle to lock onto fast moving ships that are +// circling us"*, and *"I also see it oscillating quite a bit when chasing +// weaving ships"*. +// +// Two rules answer it, and they only work together. The aim leads the target by +// the swing the nose has LEFT (`PURSUIT_LEAD_GAIN`). The throttle matches how +// fast the target RECEDES rather than how fast it flies. +// +// A probe of the control law over 40 scripted targets measured the pair, at real +// pirate speeds and a real pirate radius. The pursuit before them held a target +// inside the gun cone 27.5% of the time. The radial throttle alone scored 31.2%, +// the lead alone scored 41.7%, and the two together scored 46.7%. A FIXED lead +// scored 24.2%, which is worse than no lead: it parks the nose ahead of a target +// the throttle just let it catch. See `PURSUIT_LEAD_GAIN` for the whole table. +console.log('\nthe co-pilot leads the nose and matches the radial speed'); +{ + seedWorld(4244); + const state = freshState(newCommander()); + state.world.build(state.systems[state.commander.systemIndex]); + state.world.clearNpcs(); + state.player.position.set(0, 0, 0); + state.player.quaternion.identity(); + const legal = state.commander.legalStatus; + const UP = new THREE.Vector3(0, 1, 0); + const look = new THREE.Matrix4(); + const ahead = new THREE.Vector3(); + /** Point a ship's nose along `dir`, which is what `velocityOf` reads. */ + const face = (npc: { object: { position: THREE.Vector3; quaternion: THREE.Quaternion } }, + dir: THREE.Vector3): void => { + look.lookAt(npc.object.position, ahead.copy(npc.object.position).add(dir), UP); + npc.object.quaternion.setFromRotationMatrix(look); + }; + + // THE THROTTLE READS THE RECEDING SPEED. Both targets sit dead ahead at the + // standoff and fly at 300. One crosses, so it holds its range and the + // commander must hold station. One runs, so the commander must chase. + const mark = state.world.spawn('pirate', new THREE.Vector3(0, 0, -600), 1); + mark.object.position.set(0, 0, -(PURSUIT_RANGE + mark.radius)); + mark.state.speed = 300; + state.player.speed = 0; + + face(mark, new THREE.Vector3(1, 0, 0)); + const crossing = new ScriptedCoPilot() + .step(1 / 60, state.player, state.world.npcs, legal, false, null, Infinity, mark); + check('a target that only crosses holds its range, so the ship asks for no thrust', + crossing.kind === 'fly' && crossing.demand.throttle === 0); + + face(mark, new THREE.Vector3(0, 0, -1)); + const running = new ScriptedCoPilot() + .step(1 / 60, state.player, state.world.npcs, legal, false, null, Infinity, mark); + check('...and one that runs at the same speed is chased', + running.kind === 'fly' && running.demand.throttle === 1); + + // THE LEAD IS FOR THE NOSE, AND THE GUN CONE IS WHERE IT SHOWS. Inside the + // cone the steering asks for nothing, because a target that already fills the + // gun needs no bank (`pitch-roll-steer.ts`). A target that CROSSES is about to + // leave that cone, and the lead is what keeps the ship turning with it. + // + // This is also why the lead must shrink. A target inside the cone and NOT + // moving is aimed AT, so the co-pilot still goes quiet on it. A fixed lead + // would hold a turn against a target that is already on the gun. + while (state.world.npcs.length > 1) state.world.npcs.pop(); + const near = state.world.spawn('pirate', new THREE.Vector3(0, 0, -800), 1); + const turnFor = (speed: number): number => { + // just inside the gun cone, which the unled pursuit treats as arrived + const off = hitCone(near.radius, 800) * 0.8; + near.object.position.set(Math.sin(off) * 800, 0, -Math.cos(off) * 800); + near.state.speed = speed; + face(near, new THREE.Vector3(1, 0, 0)); + state.player.quaternion.identity(); + state.player.speed = 0; + const s = new ScriptedCoPilot() + .step(1 / 60, state.player, state.world.npcs, legal, false, null, Infinity, near); + if (s.kind !== 'fly') throw new Error('should be flying a live threat'); + return Math.hypot(s.demand.pitchRate, s.demand.rollRate); + }; + eq('a still target inside the gun cone asks for no turn at all', turnFor(0), 0); + check('...but one that crosses at 300 keeps the ship turning with it', + turnFor(300) > 0); +} + +// --- IT HOLDS A SHIP THAT CIRCLES, WHICH THE UNLED PURSUIT COULD NOT -------- +// +// The regression that pins the pair above. A pirate orbits the commander at 400 +// units and 300 units a second, which is a bearing rate of 0.75 radians a +// second. The nose can turn at 1.45, so the rate was never the limit. The unled +// pursuit still held it on the gun 51% of the time, because it aimed where the +// target WAS and it chased a ship that was not running. +console.log('\nthe co-pilot holds a ship that circles it'); +{ + const ORBIT = 400; + const SPEED = 300; + const RATE = SPEED / ORBIT; + + /** Fly the orbit for `seconds`, and report the share of the late window on the gun. */ + const orbitRun = (seconds: number): number => { + seedWorld(4245); + const state = freshState(newCommander()); + state.world.build(state.systems[state.commander.systemIndex]); + state.world.clearNpcs(); + state.player.position.set(0, 0, 0); + state.player.quaternion.identity(); + state.player.speed = 200; + const legal = state.commander.legalStatus; + const pirate = state.world.spawn('pirate', new THREE.Vector3(ORBIT, 0, 0), 1); + pirate.state.speed = SPEED; + const cp = new ScriptedCoPilot(); + const look = new THREE.Matrix4(); + const up = new THREE.Vector3(0, 1, 0); + const ahead = new THREE.Vector3(); + const nose = new THREE.Vector3(); + const to = new THREE.Vector3(); + let held = 0; + let late = 0; + for (let i = 0; i < 60 * seconds; i++) { + const t = i / 60; + pirate.object.position.set(Math.cos(RATE * t) * ORBIT, 0, Math.sin(RATE * t) * ORBIT); + // its nose along the orbit, which is the velocity `velocityOf` returns + ahead.set(-Math.sin(RATE * t), 0, Math.cos(RATE * t)).multiplyScalar(SPEED); + look.lookAt(pirate.object.position, ahead.add(pirate.object.position), up); + pirate.object.quaternion.setFromRotationMatrix(look); + const s = cp.step(1 / 60, state.player, state.world.npcs, legal, + false, null, Infinity, pirate); + if (s.kind !== 'fly') throw new Error('should be flying a live threat'); + state.player.update(1 / 60, s.demand); + if (i > 60 * 10) { + late += 1; + nose.set(0, 0, -1).applyQuaternion(state.player.quaternion); + to.copy(pirate.object.position).sub(state.player.position); + if (nose.angleTo(to) < hitCone(pirate.radius, to.length())) held += 1; + } + } + return held / late; + }; + + // TWO SAMPLE SIZES, because one share of one window is not a measurement. The + // unled pursuit scores about 5% of either window, so the floor is not tight. + const short = orbitRun(30); + const long = orbitRun(60); + check(`it keeps a circling ship inside the gun cone over 30s (${(short * 100).toFixed(0)}%)`, + short > 0.20); + check(`...and over 60s (${(long * 100).toFixed(0)}%)`, long > 0.20); +} From 109676c340552ca61e8514ee5e1c3169bc5efe2c Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Sat, 12 Sep 2026 16:24:16 +0100 Subject: [PATCH 042/100] The computer finishes the line-up before the pilot gets the slot Chris flew it and reported the fault. The console says the computer is lining the ship up, and then the rails take the ship before it is lined up. Two faults, one report, and a trace of the shipped approach measured both. 1. The hand-over never asked which way the ship points. `railsReached` asks for the last leg, `RAILS_LATERAL` and `RAILS_RANGE`. The ship was 69.7 degrees off the slot axis on the frame the rails took it. 2. The rails then turned it straight inside ONE frame. The comment on `dock-rails.ts` claimed both of its corrections were eased. Only the position was. The rotation went on in full. The computer cannot close that last turn itself, and this is the part that took the measurement to find. `dockingSticks` pitches onto the heading, and a pitch cannot fix a sideways error. It got away with that while the ship flew, because the motion sweeps the pitch plane round. The brake stops the ship first, so the sweep stops, and the nose stalls at 68.4 degrees for ever. So the rails make the turn, and the pilot waits on it. `RAILS_TURN` eases the rotation as `RAILS_PULL` always eased the position. `SessionState.dockHold` is the stretch where the rails hold the ship and the computer still owns it. The buttons and the console read LINING UP through all of it, because they read `dockRails`, which now waits for `RAILS_CONE`. Measured on the shipped approach. The nose was 69.7 degrees off at the hand-over, in one frame. It is now 10 degrees off, and no frame turns it more than a few. The extra wait is about half a second. `npm run dock-probe` is unchanged at 504 of 504 docked, median 16.4 seconds, 0 scrapes. That path is the bought docking computer, which does not use the rails. Three tests pin it, and each one fails when its rule is broken. The one-frame test reports the old 69.7 degrees when the ease is taken out. Co-Authored-By: Claude Fable 5.1 Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- docs/ARCHITECTURE.md | 10 +++-- src/constants/CATALOG.md | 6 ++- src/constants/docking.ts | 41 +++++++++++++++++++ src/game/dock-rails.ts | 40 ++++++++++++++++--- src/game/flight-instruments.ts | 2 + src/game/session.ts | 14 +++++++ src/game/state.ts | 1 + src/game/world-step.ts | 24 ++++++++++-- test/dock-trial.test.ts | 72 +++++++++++++++++++++++++++++++++- 9 files changed, 195 insertions(+), 15 deletions(-) diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md index 6941c6d1..8c6bfd0c 100644 --- a/docs/ARCHITECTURE.md +++ b/docs/ARCHITECTURE.md @@ -45,10 +45,12 @@ rules. This file is a map. reports a `FlightDemand`. `flight-instruments.ts` throws the switches that a course asks for: the torus drive, the hand-over to the docking computer, and the end of the course. A commander with no docking computer gets the docking - mini game instead (docs/TODO/212). The computer lines the ship up first. - `dock-rails.ts` then holds the ship on the slot axis, and the pilot matches - the slot and the speed. It is the one file that moves the commander's ship - other than by flying it. `course-actions.ts` joins the list to the Game: it + mini game instead (docs/TODO/212). The computer flies the ship to the slot + axis and stops it there. `dock-rails.ts` then holds the ship on that axis, and + the pilot matches the slot and the speed. It is the one file that moves the + commander's ship other than by flying it. It also makes the last turn onto the + axis, because the computer cannot. A docking pitch cannot fix a sideways + error, and the ship is stopped by then. The pilot waits on that turn. `course-actions.ts` joins the list to the Game: it builds the flat view, and it applies a pick. At the station, the LAUNCH row opens `screens/courses.ts`, and a pick leaves on the course. In flight, the list is a set of buttons over the view, and not a screen, because the flight diff --git a/src/constants/CATALOG.md b/src/constants/CATALOG.md index 470640e0..9b5fdf21 100644 --- a/src/constants/CATALOG.md +++ b/src/constants/CATALOG.md @@ -2,7 +2,7 @@ -450 exported constants. Regenerate with `npm run generate:constants`; +452 exported constants. Regenerate with `npm run generate:constants`; search names, meanings and values with `npm run constants:find -- ""`. | Domain | Symbol | Literal / expression | Purpose | Rule ID | Source | @@ -148,7 +148,9 @@ search names, meanings and values with `npm run constants:find -- ""`. | docking | RAILS_LATERAL | 250 | How far off the slot axis the ship may be when the rails take it, in world units (docs/TODO/212). | docking.railsLateral | [docking.ts:187](./docking.ts#L187) | | docking | RAILS_RANGE | 900 | How far out the rails take the ship, in world units (docs/TODO/212). | docking.railsRange | [docking.ts:199](./docking.ts#L199) | | docking | RAILS_PULL | 2 | How hard the rails pull the ship onto the axis, per second (docs/TODO/212). | docking.railsPull | [docking.ts:211](./docking.ts#L211) | -| docking | RAILS_STOPPED | 2 | The speed under which the ship counts as stopped, in world units a second (docs/TODO/212). | docking.railsStopped | [docking.ts:225](./docking.ts#L225) | +| docking | RAILS_CONE | 0.18 | How far off the slot axis the ship's NOSE may point when the PILOT is given the slot, in radians. | docking.railsCone | [docking.ts:235](./docking.ts#L235) | +| docking | RAILS_TURN | 3 | How hard the rails turn the nose onto the axis, per second. | docking.railsTurn | [docking.ts:252](./docking.ts#L252) | +| docking | RAILS_STOPPED | 2 | The speed under which the ship counts as stopped, in world units a second (docs/TODO/212). | docking.railsStopped | [docking.ts:266](./docking.ts#L266) | | docking-computer | DOCK_COMPUTER_RANGE | 3500 | How close to the station the docking computer will take the job, in world units. | | [docking-computer.ts:46](./docking-computer.ts#L46) | | docking-computer | DC_SLOT_MARGIN | 0.30 | How much of the slot's roll tolerance the TURN may spend, as a fraction. | docking.slotMargin | [docking-computer.ts:97](./docking-computer.ts#L97) | | docking-computer | DC_TURN_FADE_ANGLE | 0.10 | The off-nose angle, in radians, over which the TURN's claim on the roll axis ramps in. | docking.turnFadeAngle | [docking-computer.ts:151](./docking-computer.ts#L151) | diff --git a/src/constants/docking.ts b/src/constants/docking.ts index 248610d6..9b27ec5f 100644 --- a/src/constants/docking.ts +++ b/src/constants/docking.ts @@ -210,6 +210,47 @@ export const RAILS_RANGE = 900; */ export const RAILS_PULL = 2; +/** + * How far off the slot axis the ship's NOSE may point when the PILOT is given + * the slot, in radians. + * + * THE HAND-OVER USED TO IGNORE THE NOSE ALTOGETHER (Chris, 2026-09-12: *"we + * jump to the on rails version before it's actually lined up"*). `railsReached` + * asked for the last leg, `RAILS_LATERAL` and `RAILS_RANGE`. None of those three + * says which way the ship points. A trace of the shipped approach put the nose + * 69.7 degrees off the axis on the frame the rails took it. + * + * THE COMPUTER CANNOT CLOSE THAT LAST TURN, and `SessionState.dockHold` states + * why. So the rails close it, at `RAILS_TURN`, while the pilot still reads + * LINING UP. This is the angle at which the pilot is given the ship. + * + * 0.18 rad is about 10 degrees. The rails take the measured 70 degrees down to + * it in about half a second, so the wait is short. It is a band rather than a + * zero, because the rails hold the line from there on. To wait for zero is to + * wait for ever. + * + * @rule docking.railsCone + * @domain docking + */ +export const RAILS_CONE = 0.18; + +/** + * How hard the rails turn the nose onto the axis, per second. + * + * It is `RAILS_PULL` for the rotation, and it exists for the same reason. The + * position was always eased. The rotation was not: it went on in full, every + * frame, so any error left at the hand-over went in one frame. The module + * comment on `game/dock-rails.ts` claimed both were eased, and only one was. + * + * 3 a second turns the measured 70 degrees of error down to `RAILS_CONE` in + * about half a second. It is faster than `RAILS_PULL`, because the pilot waits + * on this turn and does not wait on the line. + * + * @rule docking.railsTurn + * @domain docking + */ +export const RAILS_TURN = 3; + /** * The speed under which the ship counts as stopped, in world units a second * (docs/TODO/212). diff --git a/src/game/dock-rails.ts b/src/game/dock-rails.ts index dcc1f267..310dfb90 100644 --- a/src/game/dock-rails.ts +++ b/src/game/dock-rails.ts @@ -19,22 +19,33 @@ // one place in the game that moves the commander's ship other than by flying // it. `test/docking.test.ts` scans for that, and it names this file. // -// IT IS NOT A TELEPORT. Both corrections are eased. The nose turns by the -// SHORTEST rotation onto the axis, which carries no twist about the nose. So -// the pilot's own roll is untouched, and the roll is what the slot measures. +// IT IS NOT A TELEPORT, AND THE ROTATION USED TO BE ONE. This comment claimed +// that both corrections were eased. The position was. The rotation went on in +// full, every frame, so whatever error the hand-over left went in ONE frame. +// Chris flew it on 2026-09-12: *"we jump to the on rails version before it's +// actually lined up"*. A trace put that jump at 69.7 degrees. +// +// Two things answer it. `railsAligned` holds the hand-over until the nose is +// near the axis, so the error is small before the rails see it. `RAILS_TURN` +// then eases what is left, as `RAILS_PULL` always eased the position. +// +// The nose turns by the SHORTEST rotation onto the axis, which carries no twist +// about the nose. An ease along that same arc adds none either. So the pilot's +// own roll is untouched, and the roll is what the slot measures. import * as THREE from 'three'; import type { PlayerShip } from '../player.ts'; import type { DockPlan } from './docking.ts'; import { slotNormal } from '../world/slot.ts'; import { - RAILS_LATERAL, RAILS_PULL, RAILS_RANGE, RAILS_STOPPED, + RAILS_CONE, RAILS_LATERAL, RAILS_PULL, RAILS_RANGE, RAILS_STOPPED, RAILS_TURN, } from '../constants/docking.ts'; const _out = new THREE.Vector3(); const _rel = new THREE.Vector3(); const _fwd = new THREE.Vector3(); const _turn = new THREE.Quaternion(); +const _ease = new THREE.Quaternion(); /** * Is the ship at the place where the computer stops it? @@ -48,6 +59,21 @@ export function railsReached(plan: DockPlan): boolean { && plan.along < RAILS_RANGE; } +/** + * Is the nose near enough the slot axis for the rails to take the ship? + * + * THE THIRD QUESTION THE HAND-OVER NEVER ASKED. `railsReached` above is about + * WHERE the ship is. This is about WHICH WAY IT POINTS, and without it the + * rails turned the ship up to 69.7 degrees in one frame. See `RAILS_CONE`. + * + * It measures against the slot axis, which is the same line `holdOnRails` + * corrects onto. The gate and the correction cannot come to disagree. + */ +export function railsAligned(player: PlayerShip, station: THREE.Object3D): boolean { + const inward = slotNormal(station, _out).multiplyScalar(-1); + return player.getForward(_fwd).angleTo(inward) < RAILS_CONE; +} + /** * Is the ship stopped, so the rails can take it? * @@ -77,5 +103,9 @@ export function holdOnRails(player: PlayerShip, station: THREE.Object3D, dt: num player.position.addScaledVector(rel, -Math.min(1, RAILS_PULL * dt)); const fwd = player.getForward(_fwd); _turn.setFromUnitVectors(fwd, outward.multiplyScalar(-1)); - player.quaternion.premultiply(_turn).normalize(); + // ...and EASE it, as the position above is eased. A slerp from no rotation + // along that same shortest arc keeps the arc's axis, so it still adds no + // twist about the nose. The pilot's roll stays the pilot's. + _ease.identity().slerp(_turn, Math.min(1, RAILS_TURN * dt)); + player.quaternion.premultiply(_ease).normalize(); } diff --git a/src/game/flight-instruments.ts b/src/game/flight-instruments.ts index 49b9515a..67fc042f 100644 --- a/src/game/flight-instruments.ts +++ b/src/game/flight-instruments.ts @@ -221,6 +221,7 @@ export class Instruments { } s.dockTrial = true; s.dockRails = false; + s.dockHold = false; s.course = null; this.coursePilot.reset(); this.host.showMessage('THE COMPUTER IS LINING THE SHIP UP — STAND BY', 4); @@ -241,6 +242,7 @@ export class Instruments { if (!out) return; s.dockTrial = false; s.dockRails = false; + s.dockHold = false; this.host.showMessage('THE STATION IS BEHIND YOU', 3); } diff --git a/src/game/session.ts b/src/game/session.ts index 4e1955eb..eb2ec665 100644 --- a/src/game/session.ts +++ b/src/game/session.ts @@ -116,6 +116,19 @@ export interface SessionState { * the computer's, and it lines the ship up. It is saved, as `dockTrial` is. */ dockRails: boolean; + /** + * The rails hold the ship while the COMPUTER finishes the line-up + * (docs/TODO/212). It sits between the two halves of `dockTrial`, and it is + * saved as they are. + * + * The computer cannot make this last turn itself. `dockingSticks` pitches + * onto the heading, and a pitch cannot fix a sideways error. It got away with + * that while the ship flew, because the motion sweeps the pitch plane round. + * The ship is stopped by this point, so the sweep stops too, and the nose + * stalls up to 69.7 degrees off the axis (Chris, 2026-09-12). So the rails + * take the turn, and `dockRails` waits for `railsAligned`. + */ + dockHold: boolean; } /** @@ -128,6 +141,7 @@ export function endVisit(state: SessionState): void { state.handFlown = false; state.dockTrial = false; state.dockRails = false; + state.dockHold = false; } /** Put a message in canonical state; the HUD only paints these fields. */ diff --git a/src/game/state.ts b/src/game/state.ts index e82de7cb..f10f758c 100644 --- a/src/game/state.ts +++ b/src/game/state.ts @@ -161,6 +161,7 @@ export function freshSession(): SessionState { handFlown: false, dockTrial: false, dockRails: false, + dockHold: false, }; } diff --git a/src/game/world-step.ts b/src/game/world-step.ts index d5350593..2fb8255c 100644 --- a/src/game/world-step.ts +++ b/src/game/world-step.ts @@ -55,7 +55,7 @@ import { import { planDocking, dockingOutcome, type DockPlan, type DockingOutcome, } from './docking.ts'; -import { holdOnRails, railsReached, stopped } from './dock-rails.ts'; +import { holdOnRails, railsAligned, railsReached, stopped } from './dock-rails.ts'; import { dockingSticks } from './docking-sticks.ts'; import { NPC_HULL_BOX_MARGIN } from '../constants/docking.ts'; import { BOUNCE_STANDOFF } from '../constants/station.ts'; @@ -327,8 +327,10 @@ export class WorldStep { const dc = session.dcEngaged ? this.dockingComputerStep(dt, pilot, out) : session.dockTrial ? this.dockTrialStep(dt, pilot, out) : null; player.update(dt, dc ?? pilot.demand); - // The rails correct the frame the ship just flew (docs/TODO/212). - if (session.dockRails) holdOnRails(player, world.station, dt); + // The rails correct the frame the ship just flew (docs/TODO/212). They run + // for the computer's last turn as well as for the pilot's game, because the + // computer cannot make that turn itself. See `SessionState.dockHold`. + if (session.dockRails || session.dockHold) holdOnRails(player, world.station, dt); // torus drive if (session.torusEngaged) { @@ -443,7 +445,23 @@ export class WorldStep { if (!stopped(player.speed)) { return { ...this.dockingDemand(dt, pilot, plan), throttle: -1 }; } + // STOPPED IS NOT LINED UP. The brake used to end the line-up, and the + // ship was still up to 69.7 degrees off the axis (Chris, 2026-09-12: + // *"we jump to the on rails version before it's actually lined up"*). + // The rails take that last turn, eased, while the pilot waits. The + // buttons and the message still read LINING UP, because `dockRails` is + // what they read. + session.dockHold = true; + if (!railsAligned(player, this.state.world.station)) { + return { + pitchRate: rampFlightRate(player.pitchRate, 0, false, dt), + rollRate: rampFlightRate(player.rollRate, 0, false, dt), + throttle: 0, + fire: pilot.demand.fire, + }; + } session.dockRails = true; + session.dockHold = false; out.push(say('THE SLOT IS YOURS — THRUST IN, AND MATCH ITS SPIN', 5)); } // ON THE RAILS. The pitch is nobody's: `holdOnRails` owns the line. The diff --git a/test/dock-trial.test.ts b/test/dock-trial.test.ts index de9ea7ef..33e760f6 100644 --- a/test/dock-trial.test.ts +++ b/test/dock-trial.test.ts @@ -17,7 +17,8 @@ import { Game } from '../src/game/game.ts'; import { headlessShell } from '../src/engine/shell.ts'; import { withoutSaving } from '../src/game/storage.ts'; import { seedWorld } from '../src/game/rng.ts'; -import { RAILS_STOPPED, SLOT_HALF_ACROSS } from '../src/constants/docking.ts'; +import { RAILS_CONE, RAILS_STOPPED, SLOT_HALF_ACROSS } from '../src/constants/docking.ts'; +import { slotNormal } from '../src/world/slot.ts'; import { check, dismissBriefing, eq } from './harness.ts'; console.log('\nthe last stretch into the slot'); @@ -196,3 +197,72 @@ console.log('\nthe docking mini game'); const idle = fly(arrive(20_260_951), false, false); check('a pilot who touches nothing waits there, and never docks', !idle.docked); } + +// --- THE HAND-OVER WAITS FOR THE NOSE, AND THE TURN IS EASED --------------- +// +// Chris, 2026-09-12: *"When docking - we get 'The computer is lining up...' and +// it starts doing it's job, but we jump to the on rails version before it's +// actually lined up."* +// +// Two faults, one report. `railsReached` asked where the ship was and never +// which way it pointed, so the rails took it 69.7 degrees off the slot axis. +// `holdOnRails` then turned it straight inside ONE frame, although the comment +// on that file claimed both of its corrections were eased. Only the position +// was. +// +// The computer cannot make that last turn itself, and `SessionState.dockHold` +// says why. So the rails make it, eased, while the pilot still reads LINING UP. +console.log('\nthe computer finishes the line-up before the pilot gets the slot'); +{ + const g = withoutSaving(() => { + seedWorld(20_260_951); + const game = new Game(() => headlessShell()); + dismissBriefing(game); + game.launch(); + game.arriveInSystem(); + return game; + }).value; + g.state.world.clearNpcs(); + g.state.session.course = 'station'; + + const dt = 1 / 60; + const out = new THREE.Vector3(); + const fwd = new THREE.Vector3(); + const noseOff = (): number => { + slotNormal(g.state.world.station, out).multiplyScalar(-1); + return g.state.player.getForward(fwd).angleTo(out); + }; + + let atHandover = -1; + let worstJump = 0; + let heldFrames = 0; + let pilotBeforeHold = false; + withoutSaving(() => { + let last = noseOff(); + for (let f = 0, at = 0; f < 120 / dt; f++) { + const wasRails = g.state.session.dockRails; + g.step(dt, at += dt); + const now = noseOff(); + // the biggest one-frame turn of the nose, over the whole approach + if (Math.abs(now - last) > worstJump) worstJump = Math.abs(now - last); + last = now; + if (g.state.session.dockHold) heldFrames += 1; + if (g.state.session.dockRails && !g.state.session.dockHold && heldFrames === 0) { + pilotBeforeHold = true; + } + if (!wasRails && g.state.session.dockRails) { atHandover = now; break; } + if (g.mode !== 'flight') break; + } + }); + + check('the rails take the ship only once its nose is near the slot axis', + atHandover >= 0 && atHandover < RAILS_CONE, + `${(atHandover * 180 / Math.PI).toFixed(1)} degrees off, against a cone of ` + + `${(RAILS_CONE * 180 / Math.PI).toFixed(1)}`); + // The old code turned the ship 69.7 degrees in the hand-over frame. + check('...and no single frame turns the nose more than 10 degrees', + worstJump < 10 * Math.PI / 180, + `worst one-frame turn ${(worstJump * 180 / Math.PI).toFixed(1)} degrees`); + check('...having held the ship on the rails first, with the pilot still waiting', + heldFrames > 0 && !pilotBeforeHold, `${heldFrames} frames of LINING UP on the rails`); +} From 6d5dbdbb22edaa685c5cc60cd918fe4eb46bd86b Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Sat, 12 Sep 2026 16:30:35 +0100 Subject: [PATCH 043/100] The docking computer flies the last turn onto the slot axis Chris flew 109676c and called it: *"It's still a little too fast - there's a jerk to bring the station into alignment. The docking computer should be doing this for us?"* He is right on both counts, and he set the shape: the computer flies the ship to the right distance from the station and to a nose that faces the port. It hands over from there, to a pilot or to the bought computer. 109676c gave that last turn to the rails. The rails are the one thing in the game that moves the commander's ship other than by flying it, so the turn was a correction rather than a manoeuvre, and it read as one. THE COMPUTER CAN FLY IT, and the earlier note that it could not was wrong about the cause. `dockingSticks` cannot: it spends the roll on the letterbox, and a pitch alone cannot answer a sideways error once the ship is stopped and the pitch plane stops sweeping. But `bankToTurn` is the law for pointing a yaw-less ship, and the slot has no claim on the roll until the pilot holds the ship. So the computer's last turn uses that law, with both sticks, through the commander's own envelope. `DockPlan.steer` holds which vertical that turn banks through. It sits beside `swing` for the same reason, and it is saved in the same walk. The `dockHold` session flag of 109676c is gone, because nothing needs it now. Measured on the shipped approach, from 70.2 degrees off the axis: worst turn in one frame 69.7 deg before 109676c, 10.0 with the rails, 1.5 now nose at the hand-over 69.7 deg before, 7.3 now, against a cone of 10.3 the turn itself about a second, at the hull's own pitch and roll `npm run dock-probe` is unchanged at 504 of 504 docked, median 16.4 seconds, 0 scrapes. The bought docking computer flies its own approach and does not come through here. Three tests pin it, and each one fails when its rule is broken. A pitch-only turn never hands over at all, which is the stall this replaced. Co-Authored-By: Claude Fable 5.1 Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- docs/ARCHITECTURE.md | 11 +++++----- src/constants/CATALOG.md | 6 +++--- src/constants/docking.ts | 20 +++++++++--------- src/game/dock-rails.ts | 14 +++++++------ src/game/docking.ts | 15 ++++++++++++++ src/game/flight-instruments.ts | 2 -- src/game/session.ts | 14 ------------- src/game/state.ts | 1 - src/game/world-step.ts | 37 ++++++++++++++++++++++------------ test/dock-trial.test.ts | 30 ++++++++++++++++----------- 10 files changed, 85 insertions(+), 65 deletions(-) diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md index 8c6bfd0c..1bf0c7c9 100644 --- a/docs/ARCHITECTURE.md +++ b/docs/ARCHITECTURE.md @@ -45,12 +45,13 @@ rules. This file is a map. reports a `FlightDemand`. `flight-instruments.ts` throws the switches that a course asks for: the torus drive, the hand-over to the docking computer, and the end of the course. A commander with no docking computer gets the docking - mini game instead (docs/TODO/212). The computer flies the ship to the slot - axis and stops it there. `dock-rails.ts` then holds the ship on that axis, and + mini game instead (docs/TODO/212). The computer flies the ship to the right + distance from the station, stops it, and turns it to face the port. Only then + does it hand over. A commander who bought the docking computer is flown the + whole way in instead. `dock-rails.ts` holds the ship on the slot axis while the pilot matches the slot and the speed. It is the one file that moves the - commander's ship other than by flying it. It also makes the last turn onto the - axis, because the computer cannot. A docking pitch cannot fix a sideways - error, and the ship is stopped by then. The pilot waits on that turn. `course-actions.ts` joins the list to the Game: it + commander's ship other than by flying it, and it only ever takes up a residue. + The last turn is flown, with `bankToTurn` and both sticks. `course-actions.ts` joins the list to the Game: it builds the flat view, and it applies a pick. At the station, the LAUNCH row opens `screens/courses.ts`, and a pick leaves on the course. In flight, the list is a set of buttons over the view, and not a screen, because the flight diff --git a/src/constants/CATALOG.md b/src/constants/CATALOG.md index 9b5fdf21..99cb139d 100644 --- a/src/constants/CATALOG.md +++ b/src/constants/CATALOG.md @@ -148,9 +148,9 @@ search names, meanings and values with `npm run constants:find -- ""`. | docking | RAILS_LATERAL | 250 | How far off the slot axis the ship may be when the rails take it, in world units (docs/TODO/212). | docking.railsLateral | [docking.ts:187](./docking.ts#L187) | | docking | RAILS_RANGE | 900 | How far out the rails take the ship, in world units (docs/TODO/212). | docking.railsRange | [docking.ts:199](./docking.ts#L199) | | docking | RAILS_PULL | 2 | How hard the rails pull the ship onto the axis, per second (docs/TODO/212). | docking.railsPull | [docking.ts:211](./docking.ts#L211) | -| docking | RAILS_CONE | 0.18 | How far off the slot axis the ship's NOSE may point when the PILOT is given the slot, in radians. | docking.railsCone | [docking.ts:235](./docking.ts#L235) | -| docking | RAILS_TURN | 3 | How hard the rails turn the nose onto the axis, per second. | docking.railsTurn | [docking.ts:252](./docking.ts#L252) | -| docking | RAILS_STOPPED | 2 | The speed under which the ship counts as stopped, in world units a second (docs/TODO/212). | docking.railsStopped | [docking.ts:266](./docking.ts#L266) | +| docking | RAILS_CONE | 0.18 | How far off the slot axis the ship's NOSE may point when the PILOT is given the slot, in radians. | docking.railsCone | [docking.ts:237](./docking.ts#L237) | +| docking | RAILS_TURN | 3 | How hard the rails turn the nose onto the axis, per second. | docking.railsTurn | [docking.ts:254](./docking.ts#L254) | +| docking | RAILS_STOPPED | 2 | The speed under which the ship counts as stopped, in world units a second (docs/TODO/212). | docking.railsStopped | [docking.ts:268](./docking.ts#L268) | | docking-computer | DOCK_COMPUTER_RANGE | 3500 | How close to the station the docking computer will take the job, in world units. | | [docking-computer.ts:46](./docking-computer.ts#L46) | | docking-computer | DC_SLOT_MARGIN | 0.30 | How much of the slot's roll tolerance the TURN may spend, as a fraction. | docking.slotMargin | [docking-computer.ts:97](./docking-computer.ts#L97) | | docking-computer | DC_TURN_FADE_ANGLE | 0.10 | The off-nose angle, in radians, over which the TURN's claim on the roll axis ramps in. | docking.turnFadeAngle | [docking-computer.ts:151](./docking-computer.ts#L151) | diff --git a/src/constants/docking.ts b/src/constants/docking.ts index 9b27ec5f..cb7c050d 100644 --- a/src/constants/docking.ts +++ b/src/constants/docking.ts @@ -220,12 +220,14 @@ export const RAILS_PULL = 2; * says which way the ship points. A trace of the shipped approach put the nose * 69.7 degrees off the axis on the frame the rails took it. * - * THE COMPUTER CANNOT CLOSE THAT LAST TURN, and `SessionState.dockHold` states - * why. So the rails close it, at `RAILS_TURN`, while the pilot still reads - * LINING UP. This is the angle at which the pilot is given the ship. - * - * 0.18 rad is about 10 degrees. The rails take the measured 70 degrees down to - * it in about half a second, so the wait is short. It is a band rather than a + * THE COMPUTER FLIES THE SHIP TO THIS ANGLE. It is the pointing half of the + * hand-over, and `RAILS_RANGE` is the distance half. The ship is stopped by + * then, so `world-step.ts` steers the last turn with `bankToTurn` rather than + * `dockingSticks`. That law spends the roll on the letterbox and pitches onto + * the heading, and a pitch alone cannot answer a sideways error from a stop. + * + * 0.18 rad is about 10 degrees. The measured turn from 70 degrees takes about a + * second, at the hull's own pitch and roll rates. It is a band rather than a * zero, because the rails hold the line from there on. To wait for zero is to * wait for ever. * @@ -242,9 +244,9 @@ export const RAILS_CONE = 0.18; * frame, so any error left at the hand-over went in one frame. The module * comment on `game/dock-rails.ts` claimed both were eased, and only one was. * - * 3 a second turns the measured 70 degrees of error down to `RAILS_CONE` in - * about half a second. It is faster than `RAILS_PULL`, because the pilot waits - * on this turn and does not wait on the line. + * 3 a second clears what `RAILS_CONE` lets through, which is about 7 degrees + * measured, in under a second. The computer flies the big turn, so this only + * ever answers the residue, and the station's own drift under it. * * @rule docking.railsTurn * @domain docking diff --git a/src/game/dock-rails.ts b/src/game/dock-rails.ts index 310dfb90..cad7ba6d 100644 --- a/src/game/dock-rails.ts +++ b/src/game/dock-rails.ts @@ -25,8 +25,9 @@ // Chris flew it on 2026-09-12: *"we jump to the on rails version before it's // actually lined up"*. A trace put that jump at 69.7 degrees. // -// Two things answer it. `railsAligned` holds the hand-over until the nose is -// near the axis, so the error is small before the rails see it. `RAILS_TURN` +// Two things answer it. `railsAligned` holds the hand-over until the ship is +// the right distance out AND pointed at the port. The COMPUTER flies it to +// both, with its own sticks, so the error the rails see is small. `RAILS_TURN` // then eases what is left, as `RAILS_PULL` always eased the position. // // The nose turns by the SHORTEST rotation onto the axis, which carries no twist @@ -60,14 +61,15 @@ export function railsReached(plan: DockPlan): boolean { } /** - * Is the nose near enough the slot axis for the rails to take the ship? + * Is the nose near enough the slot axis to give the ship to the pilot? * - * THE THIRD QUESTION THE HAND-OVER NEVER ASKED. `railsReached` above is about + * THE SECOND QUESTION THE HAND-OVER NEVER ASKED. `railsReached` above is about * WHERE the ship is. This is about WHICH WAY IT POINTS, and without it the * rails turned the ship up to 69.7 degrees in one frame. See `RAILS_CONE`. * - * It measures against the slot axis, which is the same line `holdOnRails` - * corrects onto. The gate and the correction cannot come to disagree. + * Two readers, one line. `world-step.ts` flies the computer's last turn until + * this is true. `holdOnRails` below corrects onto the same axis afterward. So + * the gate and the correction cannot come to disagree. */ export function railsAligned(player: PlayerShip, station: THREE.Object3D): boolean { const inward = slotNormal(station, _out).multiplyScalar(-1); diff --git a/src/game/docking.ts b/src/game/docking.ts index f791e659..ff54927a 100644 --- a/src/game/docking.ts +++ b/src/game/docking.ts @@ -36,6 +36,7 @@ import { } from '../constants/docking.ts'; import { slotNormal } from '../world/slot.ts'; import { dockPath, makeDockPath } from './dock-path.ts'; +import { freshSteerMemory, type SteerMemory } from './pitch-roll-steer.ts'; export type DockPhase = /** still on the turn — the path decides where the ship goes */ @@ -66,6 +67,19 @@ export interface DockPlan { * carries on the way round it already took. */ swing: THREE.Vector3; + /** + * Which vertical the LAST turn onto the axis banks through + * (`pitch-roll-steer.ts`). It is held across frames for the reason `swing` + * above is, and it is saved in the same walk. + * + * `dockingSticks` does not read it. That law spends the roll on the letterbox + * and pitches onto the heading, so it cannot answer a sideways error at all. + * It never had to while the ship flew, because the motion sweeps the pitch + * plane round. The computer makes its last turn from a STOP, so nothing + * sweeps. `bankToTurn` is the law that points a yaw-less ship from there + * (world-step.ts, docs/TODO/212). + */ + steer: SteerMemory; } const _rel = new THREE.Vector3(); @@ -182,6 +196,7 @@ export function makeDockPlan(): DockPlan { heading: new THREE.Vector3(0, 0, -1), up: new THREE.Vector3(0, 1, 0), speed: 0, + steer: freshSteerMemory(), phase: 'gate', arrived: false, lateral: 0, diff --git a/src/game/flight-instruments.ts b/src/game/flight-instruments.ts index 67fc042f..49b9515a 100644 --- a/src/game/flight-instruments.ts +++ b/src/game/flight-instruments.ts @@ -221,7 +221,6 @@ export class Instruments { } s.dockTrial = true; s.dockRails = false; - s.dockHold = false; s.course = null; this.coursePilot.reset(); this.host.showMessage('THE COMPUTER IS LINING THE SHIP UP — STAND BY', 4); @@ -242,7 +241,6 @@ export class Instruments { if (!out) return; s.dockTrial = false; s.dockRails = false; - s.dockHold = false; this.host.showMessage('THE STATION IS BEHIND YOU', 3); } diff --git a/src/game/session.ts b/src/game/session.ts index eb2ec665..4e1955eb 100644 --- a/src/game/session.ts +++ b/src/game/session.ts @@ -116,19 +116,6 @@ export interface SessionState { * the computer's, and it lines the ship up. It is saved, as `dockTrial` is. */ dockRails: boolean; - /** - * The rails hold the ship while the COMPUTER finishes the line-up - * (docs/TODO/212). It sits between the two halves of `dockTrial`, and it is - * saved as they are. - * - * The computer cannot make this last turn itself. `dockingSticks` pitches - * onto the heading, and a pitch cannot fix a sideways error. It got away with - * that while the ship flew, because the motion sweeps the pitch plane round. - * The ship is stopped by this point, so the sweep stops too, and the nose - * stalls up to 69.7 degrees off the axis (Chris, 2026-09-12). So the rails - * take the turn, and `dockRails` waits for `railsAligned`. - */ - dockHold: boolean; } /** @@ -141,7 +128,6 @@ export function endVisit(state: SessionState): void { state.handFlown = false; state.dockTrial = false; state.dockRails = false; - state.dockHold = false; } /** Put a message in canonical state; the HUD only paints these fields. */ diff --git a/src/game/state.ts b/src/game/state.ts index f10f758c..e82de7cb 100644 --- a/src/game/state.ts +++ b/src/game/state.ts @@ -161,7 +161,6 @@ export function freshSession(): SessionState { handFlown: false, dockTrial: false, dockRails: false, - dockHold: false, }; } diff --git a/src/game/world-step.ts b/src/game/world-step.ts index 2fb8255c..2e7939d3 100644 --- a/src/game/world-step.ts +++ b/src/game/world-step.ts @@ -56,6 +56,8 @@ import { planDocking, dockingOutcome, type DockPlan, type DockingOutcome, } from './docking.ts'; import { holdOnRails, railsAligned, railsReached, stopped } from './dock-rails.ts'; +import { bankToTurn } from './pitch-roll-steer.ts'; +import { slotNormal } from '../world/slot.ts'; import { dockingSticks } from './docking-sticks.ts'; import { NPC_HULL_BOX_MARGIN } from '../constants/docking.ts'; import { BOUNCE_STANDOFF } from '../constants/station.ts'; @@ -270,6 +272,8 @@ export class WorldStep { private readonly fire: FireWorld; private readonly tmp = new THREE.Vector3(); + /** the slot axis the computer's last turn points down — see `dockTrialStep` */ + private readonly dockAxis = new THREE.Vector3(); private readonly tmp2 = new THREE.Vector3(); private readonly tmpQ = new THREE.Quaternion(); /** scratch for collisions.ts, so a per-frame call allocates nothing */ @@ -327,10 +331,8 @@ export class WorldStep { const dc = session.dcEngaged ? this.dockingComputerStep(dt, pilot, out) : session.dockTrial ? this.dockTrialStep(dt, pilot, out) : null; player.update(dt, dc ?? pilot.demand); - // The rails correct the frame the ship just flew (docs/TODO/212). They run - // for the computer's last turn as well as for the pilot's game, because the - // computer cannot make that turn itself. See `SessionState.dockHold`. - if (session.dockRails || session.dockHold) holdOnRails(player, world.station, dt); + // The rails correct the frame the ship just flew (docs/TODO/212). + if (session.dockRails) holdOnRails(player, world.station, dt); // torus drive if (session.torusEngaged) { @@ -436,7 +438,7 @@ export class WorldStep { * free for the spin. */ private dockTrialStep(dt: number, pilot: PilotInput, out: StepEvent[]): FlightDemand { - const { player, session } = this.state; + const { player, session, world } = this.state; const plan = this.dockingPlan(); if (!session.dockRails) { if (!railsReached(plan)) return this.dockingDemand(dt, pilot, plan); @@ -448,20 +450,29 @@ export class WorldStep { // STOPPED IS NOT LINED UP. The brake used to end the line-up, and the // ship was still up to 69.7 degrees off the axis (Chris, 2026-09-12: // *"we jump to the on rails version before it's actually lined up"*). - // The rails take that last turn, eased, while the pilot waits. The - // buttons and the message still read LINING UP, because `dockRails` is - // what they read. - session.dockHold = true; - if (!railsAligned(player, this.state.world.station)) { + // + // THE COMPUTER FLIES THIS LAST TURN, with both sticks, through the + // commander's own envelope. The nose comes round at the rate the hull + // turns. The HUD needles read it. Nothing moves the ship other than by + // flying it. + // + // `bankToTurn` is the law, rather than `dockingSticks`. That one spends + // the roll on the letterbox, and it pitches onto the heading. A pitch + // alone cannot answer a sideways error from a stop. The slot has no claim + // on the roll yet, because the pilot does not hold the ship. + if (!railsAligned(player, world.station)) { + const axis = slotNormal(world.station, this.dockAxis).multiplyScalar(-1); + const cmd = bankToTurn(player.quaternion, axis, this.state.dockPlan.steer); return { - pitchRate: rampFlightRate(player.pitchRate, 0, false, dt), - rollRate: rampFlightRate(player.rollRate, 0, false, dt), + pitchRate: rampFlightRate( + player.pitchRate, cmd.pitch * PLAYER_FLIGHT.maxPitch, cmd.pitch !== 0, dt), + rollRate: rampFlightRate( + player.rollRate, cmd.roll * PLAYER_FLIGHT.maxRoll, cmd.roll !== 0, dt), throttle: 0, fire: pilot.demand.fire, }; } session.dockRails = true; - session.dockHold = false; out.push(say('THE SLOT IS YOURS — THRUST IN, AND MATCH ITS SPIN', 5)); } // ON THE RAILS. The pitch is nobody's: `holdOnRails` owns the line. The diff --git a/test/dock-trial.test.ts b/test/dock-trial.test.ts index 33e760f6..c8b2d37c 100644 --- a/test/dock-trial.test.ts +++ b/test/dock-trial.test.ts @@ -235,8 +235,8 @@ console.log('\nthe computer finishes the line-up before the pilot gets the slot' let atHandover = -1; let worstJump = 0; - let heldFrames = 0; - let pilotBeforeHold = false; + let noseAtStop = -1; + let stoppedFrames = 0; withoutSaving(() => { let last = noseOff(); for (let f = 0, at = 0; f < 120 / dt; f++) { @@ -246,23 +246,29 @@ console.log('\nthe computer finishes the line-up before the pilot gets the slot' // the biggest one-frame turn of the nose, over the whole approach if (Math.abs(now - last) > worstJump) worstJump = Math.abs(now - last); last = now; - if (g.state.session.dockHold) heldFrames += 1; - if (g.state.session.dockRails && !g.state.session.dockHold && heldFrames === 0) { - pilotBeforeHold = true; + // the computer's last stretch: stopped, and the pilot has nothing yet + if (!g.state.session.dockRails && g.state.player.speed <= RAILS_STOPPED) { + if (noseAtStop < 0) noseAtStop = now; + stoppedFrames += 1; } if (!wasRails && g.state.session.dockRails) { atHandover = now; break; } if (g.mode !== 'flight') break; } }); - check('the rails take the ship only once its nose is near the slot axis', + check('the pilot is given the slot only once the nose is on the axis', atHandover >= 0 && atHandover < RAILS_CONE, - `${(atHandover * 180 / Math.PI).toFixed(1)} degrees off, against a cone of ` - + `${(RAILS_CONE * 180 / Math.PI).toFixed(1)}`); + atHandover < 0 ? 'it never handed over at all' + : `${(atHandover * 180 / Math.PI).toFixed(1)} degrees off, against a cone of ` + + `${(RAILS_CONE * 180 / Math.PI).toFixed(1)}`); // The old code turned the ship 69.7 degrees in the hand-over frame. - check('...and no single frame turns the nose more than 10 degrees', - worstJump < 10 * Math.PI / 180, + check('...and no single frame turns the nose more than 3 degrees', + worstJump < 3 * Math.PI / 180, `worst one-frame turn ${(worstJump * 180 / Math.PI).toFixed(1)} degrees`); - check('...having held the ship on the rails first, with the pilot still waiting', - heldFrames > 0 && !pilotBeforeHold, `${heldFrames} frames of LINING UP on the rails`); + // The computer flies this turn. It does not teleport it, and it does not + // hand the ship over half way round. + check('...and the computer flew it there itself, from a stop', + stoppedFrames > 0 && noseAtStop > RAILS_CONE, + `${stoppedFrames} frames of LINING UP, from ` + + `${(noseAtStop * 180 / Math.PI).toFixed(1)} degrees off`); } From cb248f6da33e9d593df5a9694eefc0fe94f64b62 Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Sat, 12 Sep 2026 16:37:00 +0100 Subject: [PATCH 044/100] Every commander gets the same line-up, and the cone is five times tighter Chris asked for two things on 2026-09-12. *"I think we should merge both paths?"*, and *"we should tighten up the criteria - at the moment we can be lined up with quite a wide angle difference."* ONE LINE-UP, WHOEVER TAKES THE SHIP IN. The station course used to ask who flies the slot BEFORE the line-up, in `Instruments.handOver`. A commander with a docking computer fitted went straight to it and never saw a line-up at all. Measured, that computer took the ship 147 degrees off the slot axis. Now the course hands every commander to the same stretch. The computer flies the ship to the right distance, stops it, and turns the nose onto the axis. `world-step.ts` then asks the one question. A fitted docking computer takes the ship in from there. A commander with none gets the rails and the mini game. `autopilot.ts`'s `handOverToDock` still engages the computer from the pilot's own key, and that path is unchanged. The two never had two line-ups to merge. Both already flew `planDocking` through `dockingDemand`, end to end. What differed was where the course asked the question, and it asked too early. THE CONE IS 0.03 RAD, ABOUT 1.7 DEGREES. It was 0.18 rad, about 10. A trace of the turn with the gate as good as open measured the whole curve. The nose falls from 68 degrees to 1.8 in one second. It rings once, and it settles near 1.2 degrees by two seconds. Below that it creeps: 1.2 degrees to 0.6 takes eight more seconds. So the new cone sits just above the crawl. Measured over six approach geometries: nose at the hand-over 0.73 to 1.70 degrees, from 7.3 before the turn itself 1.0 to 3.6 seconds worst turn in one frame 1.3 degrees A fitted computer now takes the ship at 1.1 to 2.0 degrees off, and docks about five seconds later, on all six. `npm run dock-probe` is unchanged at 504 of 504 docked, median 16.4 seconds, 0 scrapes. It engages `dcEngaged` directly, so it measures the flying and not the hand-over. The four new tests cover the hand-over, and each fails when its rule is broken. Co-Authored-By: Claude Fable 5.1 Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- docs/ARCHITECTURE.md | 11 +++---- src/constants/CATALOG.md | 6 ++-- src/constants/docking.ts | 24 ++++++++++------ src/game/flight-instruments.ts | 17 +++++------ src/game/world-step.ts | 16 +++++++++++ test/dock-trial.test.ts | 52 ++++++++++++++++++++++++++++++++++ 6 files changed, 102 insertions(+), 24 deletions(-) diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md index 1bf0c7c9..ecf5cf6d 100644 --- a/docs/ARCHITECTURE.md +++ b/docs/ARCHITECTURE.md @@ -45,11 +45,12 @@ rules. This file is a map. reports a `FlightDemand`. `flight-instruments.ts` throws the switches that a course asks for: the torus drive, the hand-over to the docking computer, and the end of the course. A commander with no docking computer gets the docking - mini game instead (docs/TODO/212). The computer flies the ship to the right - distance from the station, stops it, and turns it to face the port. Only then - does it hand over. A commander who bought the docking computer is flown the - whole way in instead. `dock-rails.ts` holds the ship on the slot axis while - the pilot matches the slot and the speed. It is the one file that moves the + mini game (docs/TODO/212). EVERY commander gets the same line-up first. The + computer flies the ship to the right distance from the station, stops it, and + turns it to face the port. `world-step.ts` then asks the one question: a + fitted docking computer takes the ship in, and a commander with none gets the + rails and the game. `dock-rails.ts` holds the ship on the slot axis while the + pilot matches the slot and the speed. It is the one file that moves the commander's ship other than by flying it, and it only ever takes up a residue. The last turn is flown, with `bankToTurn` and both sticks. `course-actions.ts` joins the list to the Game: it builds the flat view, and it applies a pick. At the station, the LAUNCH row diff --git a/src/constants/CATALOG.md b/src/constants/CATALOG.md index 99cb139d..f6bd69e0 100644 --- a/src/constants/CATALOG.md +++ b/src/constants/CATALOG.md @@ -148,9 +148,9 @@ search names, meanings and values with `npm run constants:find -- ""`. | docking | RAILS_LATERAL | 250 | How far off the slot axis the ship may be when the rails take it, in world units (docs/TODO/212). | docking.railsLateral | [docking.ts:187](./docking.ts#L187) | | docking | RAILS_RANGE | 900 | How far out the rails take the ship, in world units (docs/TODO/212). | docking.railsRange | [docking.ts:199](./docking.ts#L199) | | docking | RAILS_PULL | 2 | How hard the rails pull the ship onto the axis, per second (docs/TODO/212). | docking.railsPull | [docking.ts:211](./docking.ts#L211) | -| docking | RAILS_CONE | 0.18 | How far off the slot axis the ship's NOSE may point when the PILOT is given the slot, in radians. | docking.railsCone | [docking.ts:237](./docking.ts#L237) | -| docking | RAILS_TURN | 3 | How hard the rails turn the nose onto the axis, per second. | docking.railsTurn | [docking.ts:254](./docking.ts#L254) | -| docking | RAILS_STOPPED | 2 | The speed under which the ship counts as stopped, in world units a second (docs/TODO/212). | docking.railsStopped | [docking.ts:268](./docking.ts#L268) | +| docking | RAILS_CONE | 0.03 | How far off the slot axis the ship's NOSE may point when the PILOT is given the slot, in radians. | docking.railsCone | [docking.ts:245](./docking.ts#L245) | +| docking | RAILS_TURN | 3 | How hard the rails turn the nose onto the axis, per second. | docking.railsTurn | [docking.ts:262](./docking.ts#L262) | +| docking | RAILS_STOPPED | 2 | The speed under which the ship counts as stopped, in world units a second (docs/TODO/212). | docking.railsStopped | [docking.ts:276](./docking.ts#L276) | | docking-computer | DOCK_COMPUTER_RANGE | 3500 | How close to the station the docking computer will take the job, in world units. | | [docking-computer.ts:46](./docking-computer.ts#L46) | | docking-computer | DC_SLOT_MARGIN | 0.30 | How much of the slot's roll tolerance the TURN may spend, as a fraction. | docking.slotMargin | [docking-computer.ts:97](./docking-computer.ts#L97) | | docking-computer | DC_TURN_FADE_ANGLE | 0.10 | The off-nose angle, in radians, over which the TURN's claim on the roll axis ramps in. | docking.turnFadeAngle | [docking-computer.ts:151](./docking-computer.ts#L151) | diff --git a/src/constants/docking.ts b/src/constants/docking.ts index cb7c050d..bb168978 100644 --- a/src/constants/docking.ts +++ b/src/constants/docking.ts @@ -226,15 +226,23 @@ export const RAILS_PULL = 2; * `dockingSticks`. That law spends the roll on the letterbox and pitches onto * the heading, and a pitch alone cannot answer a sideways error from a stop. * - * 0.18 rad is about 10 degrees. The measured turn from 70 degrees takes about a - * second, at the hull's own pitch and roll rates. It is a band rather than a - * zero, because the rails hold the line from there on. To wait for zero is to - * wait for ever. + * 0.03 rad is about 1.7 degrees. It was 0.18 rad, about 10 degrees, and Chris + * called that too wide on 2026-09-12. + * + * IT SITS JUST ABOVE THE CRAWL. A trace of the turn with the gate as good as + * open measured the whole curve. The nose falls from 68 degrees to 1.8 in one + * second. It rings once, and it settles near 1.2 degrees by two seconds. Below + * that it creeps: 1.2 degrees to 0.6 takes eight more seconds, because the + * steering saturates and the roll fades. So a cone under about 1 degree buys + * fractions of a degree for whole seconds of wait. + * + * It is a band rather than a zero, because the rails hold the line from there + * on. To wait for zero is to wait for ever. * * @rule docking.railsCone * @domain docking */ -export const RAILS_CONE = 0.18; +export const RAILS_CONE = 0.03; /** * How hard the rails turn the nose onto the axis, per second. @@ -244,9 +252,9 @@ export const RAILS_CONE = 0.18; * frame, so any error left at the hand-over went in one frame. The module * comment on `game/dock-rails.ts` claimed both were eased, and only one was. * - * 3 a second clears what `RAILS_CONE` lets through, which is about 7 degrees - * measured, in under a second. The computer flies the big turn, so this only - * ever answers the residue, and the station's own drift under it. + * 3 a second clears what `RAILS_CONE` lets through, which is under 2 degrees, + * in a fraction of a second. The computer flies the big turn, so this only ever + * answers the residue, and the station's own drift under it. * * @rule docking.railsTurn * @domain docking diff --git a/src/game/flight-instruments.ts b/src/game/flight-instruments.ts index 49b9515a..3d873f1a 100644 --- a/src/game/flight-instruments.ts +++ b/src/game/flight-instruments.ts @@ -208,17 +208,18 @@ export class Instruments { * The station course reaches the hand-over, and the ship changes hands * (docs/TODO/207 M1, in the shape docs/TODO/212 gave it). * - * With a docking computer fitted, that computer flies the slot, as it does - * today. Without one, the pilot's own stretch begins. The computer lines the - * ship up first. The rails then take the ship, and the pilot matches the - * station's spin and the speed. + * ONE LINE-UP, WHOEVER FLIES THE SLOT (Chris, 2026-09-12: *"I think we should + * merge both paths?"*). The computer flies the ship to the right distance and + * turns it to face the port, and it does that for every commander. Only then + * does it ask who takes the ship in. A fitted docking computer takes it. A + * commander with none gets the rails and the mini game. `world-step.ts`'s + * `dockTrialStep` is where that one question is asked. + * + * It used to branch HERE instead, so a fitted computer flew the whole + * approach on its own and never showed a line-up at all. */ private handOver(): void { const s = this.state.session; - if (this.state.commander.equipment.dockingComputer) { - this.applyAutopilot(this.autopilot.handOverToDock()); - return; - } s.dockTrial = true; s.dockRails = false; s.course = null; diff --git a/src/game/world-step.ts b/src/game/world-step.ts index 2e7939d3..09fb62fa 100644 --- a/src/game/world-step.ts +++ b/src/game/world-step.ts @@ -472,6 +472,22 @@ export class WorldStep { fire: pilot.demand.fire, }; } + // LINED UP. Now, and only now, the question of who takes it in. + // + // A fitted docking computer takes it, and this is the one place that + // hand-over is decided (docs/TODO/212). `autopilot.ts`'s + // `handOverToDock` still engages it from the pilot's own key. That one + // resets the plan phase, which is right from cold. It would be wrong from + // here, because the run latch is already earned and the ship is on the + // axis. + if (this.state.commander.equipment.dockingComputer) { + session.dockTrial = false; + session.dcEngaged = true; + out.push(say('DOCKING COMPUTER ENGAGED', 2)); + out.push({ kind: 'sound', name: 'dockingComputerEngaged' }); + out.push({ kind: 'dockingMusic', on: true }); + return this.dockingDemand(dt, pilot, plan); + } session.dockRails = true; out.push(say('THE SLOT IS YOURS — THRUST IN, AND MATCH ITS SPIN', 5)); } diff --git a/test/dock-trial.test.ts b/test/dock-trial.test.ts index c8b2d37c..f549af1e 100644 --- a/test/dock-trial.test.ts +++ b/test/dock-trial.test.ts @@ -272,3 +272,55 @@ console.log('\nthe computer finishes the line-up before the pilot gets the slot' `${stoppedFrames} frames of LINING UP, from ` + `${(noseAtStop * 180 / Math.PI).toFixed(1)} degrees off`); } + +// --- ONE LINE-UP, WHOEVER TAKES THE SHIP IN -------------------------------- +// +// Chris, 2026-09-12: *"I think we should merge both paths?"* +// +// The course used to ask who flies the slot BEFORE the line-up. A commander +// with a docking computer fitted was handed straight to it, and never saw a +// line-up at all. Now every commander gets the same one: the computer flies to +// the right distance, stops, and turns the nose onto the axis. Only then does +// it ask who takes the ship in. +console.log('\na fitted docking computer takes the ship after the same line-up'); +{ + const g = withoutSaving(() => { + seedWorld(20_260_951); + const game = new Game(() => headlessShell()); + dismissBriefing(game); + game.launch(); + game.arriveInSystem(); + return game; + }).value; + g.state.commander.equipment.dockingComputer = true; + g.state.world.clearNpcs(); + g.state.session.course = 'station'; + + const dt = 1 / 60; + const out = new THREE.Vector3(); + const fwd = new THREE.Vector3(); + let noseAtEngage = -1; + let sawTrial = false; + let railsTaken = false; + withoutSaving(() => { + for (let f = 0, at = 0; f < 300 / dt; f++) { + const was = g.state.session.dcEngaged; + if (g.state.session.dockTrial && !was) sawTrial = true; + g.step(dt, at += dt); + if (g.state.session.dockRails) railsTaken = true; + if (!was && g.state.session.dcEngaged) { + slotNormal(g.state.world.station, out).multiplyScalar(-1); + noseAtEngage = g.state.player.getForward(fwd).angleTo(out); + } + if (g.mode !== 'flight') break; + } + }); + + check('a fitted computer still goes through the line-up first', sawTrial); + check('...and takes the ship only once its nose is on the axis', + noseAtEngage >= 0 && noseAtEngage < RAILS_CONE, + noseAtEngage < 0 ? 'it never took the ship' + : `${(noseAtEngage * 180 / Math.PI).toFixed(2)} degrees off`); + check('...never through the pilot\'s rails, which it has no use for', !railsTaken); + check('...and it flies the ship in from there', g.mode === 'docked'); +} From 5abc8798602ebce66dd05b534592a89c9595c863 Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Sat, 12 Sep 2026 16:52:14 +0100 Subject: [PATCH 045/100] A course can be stopped, and a fight stops it for you Chris, 2026-09-12: *"I think the fly to the station is a bit confusing. I think you should be able to click it to disengage it, and when it should also be disengaged by combat or other events."* And the principle behind it: *"anything that breaks the journey should let you reconsider what you are doing - at the moment you are stuck on a course."* THE LIT BUTTON STOPS THE COURSE. It used to open the course list over the running course, and close it again. A lit button reads as ON, so a tap now turns it off. The list then shows by itself, because it always does with no course. `COURSE_TOGGLE_KEY` is `COURSE_STOP_KEY`, and `CourseActions.opened` is gone with the CLOSE button it drew. A HOSTILE SHIP DROPS THE COURSE. `flight.ts` asks the co-pilot before the course, so the course already flew nothing while the aim fought. It took the ship back the moment the last pirate died, and the button said the ship was heading somewhere all along. Three things the shape of that turns on, and each cost a measurement: - A HOSTILE SHIP is the test, not whether the computer took the stick. A picked rock takes it too, and the first rule ended every mine run at the first rock. - EVERY FRAME, not the frame the fight starts. A pilot can pick a course mid-fight, and the computer already holds the stick by then. - With no co-pilot, `ccEngaged` stays false and the course flies on. The LIVE BRAINS row set to NONE leaves the course the only pilot there is, and fast forward is then what a hostile ship stops. THE COURSE LEFT `flight-instruments.ts`, to `flight-course.ts`. The additions put that file at 417 lines, over the ceiling `tools/sizes.mjs` calls a detector. The course was the switch with a machine of its own, so it is the split the detector found. 417 lines becomes 225 and 274. The course reaches the DRIVE switch back through a host, rather than holding a second copy of the mass-lock rule. Six tests cover it, over three files. Two old ones pinned the behaviour this replaces, and they now pin the new one: a fight no longer leaves a course to fly nothing, and fast forward goes with the course rather than outliving it. Co-Authored-By: Claude Fable 5.1 Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- docs/ARCHITECTURE.md | 3 + src/game/bindings.ts | 13 +- src/game/cockpit-buttons.ts | 5 +- src/game/course-actions.ts | 24 ++- src/game/flight-course.ts | 274 +++++++++++++++++++++++++++++++++ src/game/flight-instruments.ts | 213 +++++-------------------- src/game/flight.ts | 4 +- src/game/game.ts | 1 + test/aim.test.ts | 24 ++- test/constants.test.ts | 4 +- test/course-buttons.test.ts | 53 ++++++- test/skip.test.ts | 24 ++- 12 files changed, 429 insertions(+), 213 deletions(-) create mode 100644 src/game/flight-course.ts diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md index ecf5cf6d..f4dd5633 100644 --- a/docs/ARCHITECTURE.md +++ b/docs/ARCHITECTURE.md @@ -82,6 +82,9 @@ rules. This file is a map. - `flight-weapons.ts` — what the ship spends, and what it takes. Laser fire is here. - `flight-instruments.ts` — the switches that change who flies the ship. + - `flight-course.ts` — the course at the controls. Three things end it. The + work is done, or the pilot taps the lit button, or a hostile ship turns up. + It left `flight-instruments.ts` on 2026-09-12. A step that ends in a dock, a jump, a tow or a death reports that end to `game.ts`. The orchestrator then decides what the game becomes. diff --git a/src/game/bindings.ts b/src/game/bindings.ts index 8dfa3d0a..d0b145ce 100644 --- a/src/game/bindings.ts +++ b/src/game/bindings.ts @@ -61,11 +61,16 @@ export const COURSE_KEYS: Readonly> = { export const COURSE_CHART_KEY = 'VirtCourseChart'; /** - * The button in flight that opens the course list over a course, and closes - * it (docs/TODO/205 M5). It has no key: Chris, 2026-09-11, *"We don't need to - * use the keyboard. We have mouse and touch."* + * The button in flight that STOPS the course under way (docs/TODO/205 M5). It + * has no key: Chris, 2026-09-11, *"We don't need to use the keyboard. We have + * mouse and touch."* + * + * It used to open the course list over a running course, and close it again. + * Chris called that confusing on 2026-09-12: *"I think you should be able to + * click it to disengage it."* A lit button reads as ON, so a tap turns it off. + * The list then shows by itself, because it always does with no course. */ -export const COURSE_TOGGLE_KEY = 'VirtCourseToggle'; +export const COURSE_STOP_KEY = 'VirtCourseStop'; /** The fast forward button in flight (docs/TODO/205 M7). It has no key either. */ export const COURSE_SKIP_KEY = 'VirtCourseSkip'; diff --git a/src/game/cockpit-buttons.ts b/src/game/cockpit-buttons.ts index 7ccc280f..c118915c 100644 --- a/src/game/cockpit-buttons.ts +++ b/src/game/cockpit-buttons.ts @@ -22,7 +22,7 @@ import type { Prompt } from './prompts.ts'; import type { ControlMode } from './controls.ts'; import { COURSE_NAMES } from './courses.ts'; import { - COURSE_KEYS, COURSE_SKIP_KEY, COURSE_TOGGLE_KEY, TARGET_NONE_KEY, TARGETS_KEY, + COURSE_KEYS, COURSE_SKIP_KEY, COURSE_STOP_KEY, TARGET_NONE_KEY, TARGETS_KEY, } from './bindings.ts'; import { keyCodeIfBound, keyIfBound } from '../ui/key-help.ts'; import { SKIP_SPEED } from '../constants/course.ts'; @@ -36,7 +36,7 @@ import { LASER_RANGE } from '../constants/player-gun.ts'; export function courseButtonsFor(p: CoursePanel, chart: string | null): HudButton[] { if (p.rows === null) { return p.current === null ? [] : [ - { code: COURSE_TOGGLE_KEY, label: COURSE_NAMES[p.current], lit: true, hint: 'CHOOSE SOMEWHERE ELSE' }, + { code: COURSE_STOP_KEY, label: COURSE_NAMES[p.current], lit: true, hint: 'TAP TO STOP' }, skipButton(p), ].filter((b): b is HudButton => b !== null); } @@ -44,7 +44,6 @@ export function courseButtonsFor(p: CoursePanel, chart: string | null): HudButto code: COURSE_KEYS[c.kind], label: c.what, ...(c.why === null ? {} : { note: c.why }), })); if (chart) out.push({ code: chart, label: 'LOCAL CHART' }); - if (p.current !== null) out.push({ code: COURSE_TOGGLE_KEY, label: 'CLOSE' }); return out; } diff --git a/src/game/course-actions.ts b/src/game/course-actions.ts index c62719ea..c700bc87 100644 --- a/src/game/course-actions.ts +++ b/src/game/course-actions.ts @@ -20,7 +20,7 @@ import { courseList, type Course, type CourseKind, type CourseSituation, type Co import type { checkJump } from './hyperspace.ts'; import type { GameState } from './state.ts'; import type { Input } from '../engine/input.ts'; -import { COURSE_KEYS, COURSE_SKIP_KEY, COURSE_TOGGLE_KEY } from './bindings.ts'; +import { COURSE_KEYS, COURSE_SKIP_KEY, COURSE_STOP_KEY } from './bindings.ts'; import { hostilesNear, hostilesOnScanner } from './hostility.ts'; import { SKIP_SPEED } from '../constants/course.ts'; import { SCANNER_RANGE } from '../constants/console.ts'; @@ -54,18 +54,15 @@ export interface CourseHost { closeScreens(): void; showMessage(text: string, seconds: number): void; refused(): void; + /** the STOP button: drop the course under way, and let go of the ship */ + stopCourse(): void; } export class CourseActions { private readonly state: () => GameState; private readonly host: CourseHost; /** - * The pilot opened the list while a course flies. It is what the buttons - * show, and never what the ship does, so no save carries it. - */ - private opened = false; - /** - * The fast forward button is on (docs/TODO/205 M7). Like `opened`, it is + * The fast forward button is on (docs/TODO/205 M7). Like the list itself, it is * how fast time passes for the player, and never what the world does. So no * save carries it, and a restore starts at normal speed. */ @@ -83,7 +80,7 @@ export class CourseActions { panel(): CoursePanel { const current = this.state().session.course; return { - rows: current === null || this.opened ? this.list('flight') : null, + rows: current === null ? this.list('flight') : null, current, skip: current === null ? null : { on: this.skipping, block: this.skipBlock() }, }; @@ -131,14 +128,15 @@ export class CourseActions { /** * A course button was pressed in flight. The codes are `COURSE_KEYS` and - * `COURSE_TOGGLE_KEY`. The buttons are their only sender, so no key table + * `COURSE_STOP_KEY`. The buttons are their only sender, so no key table * spends a letter on them. A screen reads its own codes in the same way * (invariant 13). */ read(i: Input): void { - // The button that opens the list over a course, and closes it. - if (i.pressed(COURSE_TOGGLE_KEY)) { - this.opened = !this.opened; + // The lit button that stops the course under way. The list then shows by + // itself, because it always does with no course. + if (i.pressed(COURSE_STOP_KEY)) { + this.host.stopCourse(); return; } // The fast forward button. A second press stops it. @@ -151,7 +149,7 @@ export class CourseActions { } for (const kind of KINDS) { if (i.pressed(COURSE_KEYS[kind])) { - if (this.pick(kind, 'flight')) this.opened = false; + this.pick(kind, 'flight'); return; } } diff --git a/src/game/flight-course.ts b/src/game/flight-course.ts new file mode 100644 index 00000000..65ed6eeb --- /dev/null +++ b/src/game/flight-course.ts @@ -0,0 +1,274 @@ +// The COURSE at the controls: the one the pilot picked, and how it ends. +// +// Split from `flight-instruments.ts` on 2026-09-12, when that file passed the +// 400-line ceiling `tools/sizes.mjs` calls a detector. That file held six +// switches. The course was the one with a machine of its own. It holds a frame +// of flight, three ways to end, and the two hand-overs it throws on the way. +// +// ONE RESPONSIBILITY: who the course is, while it is flying, and what ends it. +// Three things end a course, and each is a different actor: +// +// - the WORK is done, or the pilot takes the stick (`course`, `endCourse`); +// - the PILOT taps the lit button (`stopCourse`); +// - a HOSTILE SHIP turns up, and the computer takes the stick (`dropForFight`). +// +// `course-pilot.ts` decides where the ship goes. `courses.ts` decides which +// courses the situation allows. This holds the course while it flies, and it +// says what happened. +// +// It throws two switches that are NOT its own: the torus drive, and the +// hand-over to the docking computer. The drive belongs to +// `flight-instruments.ts`, so it reaches it through `CourseHost` rather than +// holding a second copy of the rule. + +import { CoursePilot } from './course-pilot.ts'; +import type { CourseKind } from './courses.ts'; +import { MAX_FUEL } from '../constants/commander.ts'; +import { hostilesNear, hostilesOnScanner } from './hostility.ts'; +import { pickTarget, pickedTarget } from './targets.ts'; +import { derelictReport } from './derelict.ts'; +import type { StarSystem } from '../galaxy/galaxy.ts'; +import { missionCourse } from './mission-course.ts'; +import { SCANNER_RANGE } from '../constants/console.ts'; +import { DOCK_COMPUTER_RANGE } from '../constants/docking-computer.ts'; +import { COURSE_DOCK_HANDOVER } from '../constants/course.ts'; +import type { FlightDemand } from '../player.ts'; +import type { GameState } from './state.ts'; + +/** + * What the console says when a course finishes its work. The hermit course + * says nothing, because the hermit's own trade screen opens on arrival. + */ +const COURSE_ENDS: Partial> = { + skim: 'FUEL TANK FULL', + run: 'YOU GOT AWAY', + mine: 'NO ROCKS LEFT WITHIN RANGE', + collect: 'EVERYTHING IS ABOARD', +}; + +/** The console, and the drive switch that belongs to the instruments. */ +export interface CourseSwitchHost { + showMessage(text: string, seconds: number): void; + /** a message event, said or queued as it asks */ + sayEvent(e: { text: string; seconds: number; queued?: boolean }): void; + /** the drive's own rule — `flight-instruments.ts` holds it */ + massLocked(): boolean; + /** ...and its switch, which a course throws on a long leg */ + toggleTorus(): void; +} + +export class FlightCourse { + private readonly state: GameState; + private readonly coursePilot = new CoursePilot(); + private readonly host: CourseSwitchHost; + + constructor(state: GameState, host: CourseSwitchHost) { + this.state = state; + this.host = host; + } + + /** + * The course the pilot picked, flown for one frame, or null for none + * (docs/TODO/205 M3). + * + * `course-pilot.ts` decides. This throws the two switches that a step asks + * for: the torus drive, and the hand-over to the docking computer. A flight + * key suspends the course, as it drops the two computers. The course list + * then offers the course again (Chris, 2026-09-11: *"keep the keys"*). + */ + course(dt: number, handsOn: boolean): FlightDemand | null { + const s = this.state.session; + if (s.course === null) return null; + if (handsOn) { + s.course = null; + s.handFlown = true; + this.coursePilot.reset(); + this.host.showMessage('MANUAL CONTROL — AUTOPILOT OFF', 2); + return null; + } + const p = this.state.player; + const w = this.state.world; + // The mining course fights the rocks: it picks the next one, and the + // computer's aim lines the ship up on it (docs/TODO/206 M6). + if (s.course === 'mine' && !this.aimAtNextRock()) { + this.endCourse('mine'); + return null; + } + // A mission's own work here, and what the ship does about it + // (docs/TODO/208 M1). A hunt is a fight, so the ship it names is picked + // as the target, exactly as a rock is. + const mission = s.course !== 'mission' ? null + : missionCourse(this.state.commander.missions, this.state.commander.systemIndex, + w.npcs, w.cargo.items, w.station.position); + if (mission?.how === 'fight' && mission.ship !== null + && pickedTarget(w.npcs) !== mission.ship) { + pickTarget(w.npcs, mission.ship); + s.handFlown = false; + } + const live = (role: string) => w.npcs.find((n) => n.state.alive && n.role === role) ?? null; + const derelict = live('generation'); + const step = this.coursePilot.step({ + course: s.course, + position: p.position, + quaternion: p.quaternion, + pitchRate: p.pitchRate, + rollRate: p.rollRate, + speed: p.speed, + stationPos: w.station.position, + planetPos: w.planetPos, + planetRadius: w.planetRadius, + sunPos: w.sunPos, + derelictPos: derelict?.object.position ?? null, + derelictSpeed: derelict?.state.speed ?? 0, + hermitPos: live('hermit')?.object.position ?? null, + tankFull: this.state.commander.fuel >= MAX_FUEL, + police: w.npcs + .filter((n) => n.state.alive && n.role === 'police' + && n.object.position.distanceTo(p.position) <= SCANNER_RANGE * 2) + .map((n) => n.object.position), + loot: w.cargo.items + .map((c) => c.object.position) + .filter((at) => at.distanceTo(p.position) <= SCANNER_RANGE) + .sort((a, b) => a.distanceTo(p.position) - b.distanceTo(p.position)), + threats: hostilesOnScanner(w.npcs, p.position, this.state.commander.legalStatus, + p.position.distanceTo(w.station.position)).map((n) => n.object.position), + dcEngaged: s.dcEngaged, + mission: mission === null ? null + : { at: mission.at, speed: mission.speed, how: mission.how }, + handOverRange: this.state.commander.equipment.dockingComputer + ? DOCK_COMPUTER_RANGE : COURSE_DOCK_HANDOVER, + }, dt); + if (step.handOver) this.handOver(); + if (step.torus !== s.torusEngaged && (!step.torus || !this.host.massLocked())) { + this.host.toggleTorus(); + } + if (step.done) this.endCourse(s.course); + return step.demand; + } + + /** + * The pilot tapped the lit course button, so the course stops + * (docs/TODO/205 M5). The list shows again by itself. + * + * It does NOT set `handFlown`, and a flight key does. A key means the pilot + * wants the stick. This means only that the ship goes nowhere in particular. + */ + stopCourse(): void { + const s = this.state.session; + if (s.course === null) return; + s.course = null; + this.coursePilot.reset(); + this.host.showMessage('COURSE OFF — CHOOSE WHERE TO GO', 3); + } + + /** + * A hostile ship turned up, and the combat computer took the stick. The + * course goes with it (Chris, 2026-09-12: *"it should also be disengaged by + * combat or other events"*, and *"anything that breaks the journey should let + * you reconsider what you are doing"*). + * + * `flight.ts` asks the co-pilot before the course. So the course already flew + * nothing while it waited. It then took the ship back the moment the fight + * ended, and the button said the ship was heading somewhere all along. + * + * Three things the shape of it turns on: + * + * - A HOSTILE SHIP is the test, not whether the computer took the stick. A + * picked rock takes it too, and to drop on that would end every mine run + * at the first rock. + * - EVERY FRAME, not the frame the fight starts. A pilot can pick a course + * mid-fight, and an edge test would miss it. + * - With no co-pilot, `ccEngaged` stays false and the course flies on. The + * LIVE BRAINS row set to NONE leaves the course the only pilot there is. + * + * @internal — driven by `flight-instruments.ts`, once per fixed step. + */ + dropForFight(): void { + const s = this.state; + if (!s.session.ccEngaged || s.session.course === null) return; + if (!hostilesNear(s.world.npcs, s.player.position, s.commander.legalStatus, + s.player.position.distanceTo(s.world.station.position))) return; + s.session.course = null; + this.coursePilot.reset(); + // QUEUED, not said. The torus drive drops in the same frame, on the same + // ship being close, and a said line would take the console off that cause. + this.host.sayEvent({ text: 'HOSTILE SHIP — COURSE OFF', seconds: 3, queued: true }); + } + + /** + * The pilot's stretch ends when the ship leaves the docking computer's + * range, which is the width of the whole approach. The course list then + * offers the station again. + * + * @internal — driven by src/game/flight.ts, once per fixed step. + */ + watchDockTrial(): void { + const s = this.state.session; + if (!s.dockTrial) return; + const out = this.state.player.position + .distanceTo(this.state.world.station.position) > DOCK_COMPUTER_RANGE; + if (!out) return; + s.dockTrial = false; + s.dockRails = false; + this.host.showMessage('THE STATION IS BEHIND YOU', 3); + } + + /** + * The station course reaches the hand-over, and the ship changes hands + * (docs/TODO/207 M1, in the shape docs/TODO/212 gave it). + * + * ONE LINE-UP, WHOEVER FLIES THE SLOT (Chris, 2026-09-12: *"I think we should + * merge both paths?"*). The computer flies the ship to the right distance and + * turns it to face the port, and it does that for every commander. Only then + * does it ask who takes the ship in. A fitted docking computer takes it. A + * commander with none gets the rails and the mini game. `world-step.ts`'s + * `dockTrialStep` is where that one question is asked. + * + * It used to branch HERE instead, so a fitted computer flew the whole + * approach on its own and never showed a line-up at all. + */ + private handOver(): void { + const s = this.state.session; + s.dockTrial = true; + s.dockRails = false; + s.course = null; + this.coursePilot.reset(); + this.host.showMessage('THE COMPUTER IS LINING THE SHIP UP — STAND BY', 4); + } + + /** + * The mining course keeps a rock picked as the target, so the computer aims + * at it and the pilot fires. + * + * @returns false when no rock is left within scanner range. + */ + private aimAtNextRock(): boolean { + const { player, world } = this.state; + if (pickedTarget(world.npcs)?.role === 'asteroid') return true; + const rocks = world.npcs + .filter((n) => n.state.alive && n.role === 'asteroid' + && n.object.position.distanceTo(player.position) <= SCANNER_RANGE) + .sort((a, b) => a.object.position.distanceTo(player.position) + - b.object.position.distanceTo(player.position)); + if (rocks.length === 0) return false; + pickTarget(world.npcs, rocks[0]); + this.state.session.handFlown = false; + return true; + } + + /** + * A course finished its work. It leaves the ship, and it leaves the list + * for the rest of the visit. The console says what the ship did. + */ + private endCourse(kind: CourseKind): void { + const s = this.state.session; + s.course = null; + if (!s.coursesDone.includes(kind)) s.coursesDone.push(kind); + this.coursePilot.reset(); + // The derelict's own words, read off the world's seed (docs/TODO/208 M5). + const said = kind === 'derelict' + ? derelictReport(this.state.systems[this.state.commander.systemIndex] as StarSystem) + : COURSE_ENDS[kind]; + if (said) this.host.showMessage(said, 6); + } +} diff --git a/src/game/flight-instruments.ts b/src/game/flight-instruments.ts index 3d873f1a..a2e59851 100644 --- a/src/game/flight-instruments.ts +++ b/src/game/flight-instruments.ts @@ -5,10 +5,9 @@ // `tools/sizes.mjs` calls its 400-line ceiling a detector rather than // a rule, and this is what it detected. // -// ONE RESPONSIBILITY: the instruments a pilot switches on. Six of them: +// ONE RESPONSIBILITY: the instruments a pilot switches on. Five of them: // // - the two computers that fly the ship for her; -// - the course she picked, which flies the ship too (docs/TODO/205); // - the drive that crosses the system; // - the mouse she flies with; // - the view she flies by. @@ -16,33 +15,18 @@ // Every one is a switch that changes who or what is at the controls. Not one of // them decides anything about the world. // +// THE COURSE LEFT ON 2026-09-12, to `flight-course.ts`, and it took the file +// back under the 400-line ceiling. The course has a machine of its own: a frame +// of flight, three ways to end, and two hand-overs. `courses` below holds it, +// and it reaches the DRIVE switch back through a host. +// // `autopilot.ts` owns what a computer does with the stick. `world-step.ts` owns // what a mass lock IS. This file holds the switch, and says what happened. import { sfx } from '../audio.ts'; import { Autopilot, type AutopilotEvent } from './autopilot.ts'; -import { CoursePilot } from './course-pilot.ts'; -import type { CourseKind } from './courses.ts'; -import { MAX_FUEL } from '../constants/commander.ts'; -import { hostilesOnScanner } from './hostility.ts'; -import { pickTarget, pickedTarget } from './targets.ts'; -import { derelictReport } from './derelict.ts'; -import type { StarSystem } from '../galaxy/galaxy.ts'; -import { missionCourse } from './mission-course.ts'; -import { SCANNER_RANGE } from '../constants/console.ts'; -import { DOCK_COMPUTER_RANGE } from '../constants/docking-computer.ts'; -import { COURSE_DOCK_HANDOVER } from '../constants/course.ts'; +import { FlightCourse } from './flight-course.ts'; -/** - * What the console says when a course finishes its work. The hermit course - * says nothing, because the hermit's own trade screen opens on arrival. - */ -const COURSE_ENDS: Partial> = { - skim: 'FUEL TANK FULL', - run: 'YOU GOT AWAY', - mine: 'NO ROCKS LEFT WITHIN RANGE', - collect: 'EVERYTHING IS ABOARD', -}; import { massLocked, massLockCause } from './world-step.ts'; import { boundKey } from '../ui/key-help.ts'; import { defenceBrain } from './brains.ts'; @@ -92,7 +76,12 @@ export class Instruments { */ private readonly autopilot: Autopilot; /** the seat that flies a picked course (docs/TODO/205 M3) */ - private readonly coursePilot = new CoursePilot(); + /** + * The course at the controls, split out on 2026-09-12 — see + * `flight-course.ts`. It is public because `flight.ts` flies it and + * `game.ts` stops it, exactly as they reach these switches. + */ + readonly courses: FlightCourse; private readonly host: InstrumentHost; constructor( @@ -104,6 +93,14 @@ export class Instruments { this.ordnance = ordnance; this.host = host; this.autopilot = new Autopilot(state, combatComputer); + // The course reaches the DRIVE switch through here, rather than holding a + // second copy of the mass-lock rule (`flight-course.ts`). + this.courses = new FlightCourse(state, { + showMessage: (text, seconds) => host.showMessage(text, seconds), + sayEvent: (e) => host.sayEvent(e), + massLocked: () => this.massLocked(), + toggleTorus: () => this.toggleTorus(), + }); } /** @@ -128,165 +125,27 @@ export class Instruments { } /** - * The course the pilot picked, flown for one frame, or null for none - * (docs/TODO/205 M3). - * - * `course-pilot.ts` decides. This throws the two switches that a step asks - * for: the torus drive, and the hand-over to the docking computer. A flight - * key suspends the course, as it drops the two computers. The course list - * then offers the course again (Chris, 2026-09-11: *"keep the keys"*). - */ - course(dt: number, handsOn: boolean): FlightDemand | null { - const s = this.state.session; - if (s.course === null) return null; - if (handsOn) { - s.course = null; - s.handFlown = true; - this.coursePilot.reset(); - this.host.showMessage('MANUAL CONTROL — AUTOPILOT OFF', 2); - return null; - } - const p = this.state.player; - const w = this.state.world; - // The mining course fights the rocks: it picks the next one, and the - // computer's aim lines the ship up on it (docs/TODO/206 M6). - if (s.course === 'mine' && !this.aimAtNextRock()) { - this.endCourse('mine'); - return null; - } - // A mission's own work here, and what the ship does about it - // (docs/TODO/208 M1). A hunt is a fight, so the ship it names is picked - // as the target, exactly as a rock is. - const mission = s.course !== 'mission' ? null - : missionCourse(this.state.commander.missions, this.state.commander.systemIndex, - w.npcs, w.cargo.items, w.station.position); - if (mission?.how === 'fight' && mission.ship !== null - && pickedTarget(w.npcs) !== mission.ship) { - pickTarget(w.npcs, mission.ship); - s.handFlown = false; - } - const live = (role: string) => w.npcs.find((n) => n.state.alive && n.role === role) ?? null; - const derelict = live('generation'); - const step = this.coursePilot.step({ - course: s.course, - position: p.position, - quaternion: p.quaternion, - pitchRate: p.pitchRate, - rollRate: p.rollRate, - speed: p.speed, - stationPos: w.station.position, - planetPos: w.planetPos, - planetRadius: w.planetRadius, - sunPos: w.sunPos, - derelictPos: derelict?.object.position ?? null, - derelictSpeed: derelict?.state.speed ?? 0, - hermitPos: live('hermit')?.object.position ?? null, - tankFull: this.state.commander.fuel >= MAX_FUEL, - police: w.npcs - .filter((n) => n.state.alive && n.role === 'police' - && n.object.position.distanceTo(p.position) <= SCANNER_RANGE * 2) - .map((n) => n.object.position), - loot: w.cargo.items - .map((c) => c.object.position) - .filter((at) => at.distanceTo(p.position) <= SCANNER_RANGE) - .sort((a, b) => a.distanceTo(p.position) - b.distanceTo(p.position)), - threats: hostilesOnScanner(w.npcs, p.position, this.state.commander.legalStatus, - p.position.distanceTo(w.station.position)).map((n) => n.object.position), - dcEngaged: s.dcEngaged, - mission: mission === null ? null - : { at: mission.at, speed: mission.speed, how: mission.how }, - handOverRange: this.state.commander.equipment.dockingComputer - ? DOCK_COMPUTER_RANGE : COURSE_DOCK_HANDOVER, - }, dt); - if (step.handOver) this.handOver(); - if (step.torus !== s.torusEngaged && (!step.torus || !this.massLocked())) this.toggleTorus(); - if (step.done) this.endCourse(s.course); - return step.demand; - } - - /** - * The station course reaches the hand-over, and the ship changes hands - * (docs/TODO/207 M1, in the shape docs/TODO/212 gave it). - * - * ONE LINE-UP, WHOEVER FLIES THE SLOT (Chris, 2026-09-12: *"I think we should - * merge both paths?"*). The computer flies the ship to the right distance and - * turns it to face the port, and it does that for every commander. Only then - * does it ask who takes the ship in. A fitted docking computer takes it. A - * commander with none gets the rails and the mini game. `world-step.ts`'s - * `dockTrialStep` is where that one question is asked. + * A fight starts, and the computer takes the stick, unless the pilot flies + * by hand (docs/TODO/206 M2). `autopilot.ts` decides. * - * It used to branch HERE instead, so a fitted computer flew the whole - * approach on its own and never showed a line-up at all. - */ - private handOver(): void { - const s = this.state.session; - s.dockTrial = true; - s.dockRails = false; - s.course = null; - this.coursePilot.reset(); - this.host.showMessage('THE COMPUTER IS LINING THE SHIP UP — STAND BY', 4); - } - - /** - * The pilot's stretch ends when the ship leaves the docking computer's - * range, which is the width of the whole approach. The course list then - * offers the station again. + * A COURSE UNDER WAY IS DROPPED WITH IT (Chris, 2026-09-12: *"it should also + * be disengaged by combat or other events"*). Dropping it is the consequence, + * and a consequence is the orchestrator's (invariant 15). The whole of the + * reasoning is `flight-course.ts`'s `dropForFight`. * - * @internal — driven by src/game/flight.ts, once per fixed step. - */ - watchDockTrial(): void { - const s = this.state.session; - if (!s.dockTrial) return; - const out = this.state.player.position - .distanceTo(this.state.world.station.position) > DOCK_COMPUTER_RANGE; - if (!out) return; - s.dockTrial = false; - s.dockRails = false; - this.host.showMessage('THE STATION IS BEHIND YOU', 3); - } - - /** - * The mining course keeps a rock picked as the target, so the computer aims - * at it and the pilot fires. + * Three things the shape of it turns on: * - * @returns false when no rock is left within scanner range. - */ - private aimAtNextRock(): boolean { - const { player, world } = this.state; - if (pickedTarget(world.npcs)?.role === 'asteroid') return true; - const rocks = world.npcs - .filter((n) => n.state.alive && n.role === 'asteroid' - && n.object.position.distanceTo(player.position) <= SCANNER_RANGE) - .sort((a, b) => a.object.position.distanceTo(player.position) - - b.object.position.distanceTo(player.position)); - if (rocks.length === 0) return false; - pickTarget(world.npcs, rocks[0]); - this.state.session.handFlown = false; - return true; - } - - /** - * A course finished its work. It leaves the ship, and it leaves the list - * for the rest of the visit. The console says what the ship did. - */ - private endCourse(kind: CourseKind): void { - const s = this.state.session; - s.course = null; - if (!s.coursesDone.includes(kind)) s.coursesDone.push(kind); - this.coursePilot.reset(); - // The derelict's own words, read off the world's seed (docs/TODO/208 M5). - const said = kind === 'derelict' - ? derelictReport(this.state.systems[this.state.commander.systemIndex] as StarSystem) - : COURSE_ENDS[kind]; - if (said) this.host.showMessage(said, 6); - } - - /** - * A fight starts, and the computer takes the stick, unless the pilot flies - * by hand (docs/TODO/206 M2). `autopilot.ts` decides. + * - A HOSTILE SHIP is the test, not the computer's own. A picked rock also + * takes the stick, and to drop on that would end every mine run at the + * first rock. + * - EVERY FRAME, not the frame the fight starts. A pilot can pick a course + * mid-fight, and an edge test would miss it. + * - With no co-pilot, `ccEngaged` stays false and the course flies on. The + * LIVE BRAINS row set to NONE leaves the course the only pilot there is. */ autoEngage(): void { this.applyAutopilot(this.autopilot.autoEngage()); + this.courses.dropForFight(); } /** A hit worth a break: the co-pilot keeps its own record diff --git a/src/game/flight.ts b/src/game/flight.ts index 19be1b7e..e2dfe7fb 100644 --- a/src/game/flight.ts +++ b/src/game/flight.ts @@ -322,11 +322,11 @@ export class Flight { if (this.input.mouseFlight) this.input.decayMouse(dt); // A fight gives every pilot the computer's aim (docs/TODO/206 M2). this.instruments.autoEngage(); - this.instruments.watchDockTrial(); + this.instruments.courses.watchDockTrial(); // A picked course flies when no co-pilot does (docs/TODO/205 M3). The // trigger stays the pilot's, as it does under the co-pilot. if (!this.state.session.ccEngaged) { - const course = this.instruments.course(dt, this.handsOn()); + const course = this.instruments.courses.course(dt, this.handsOn()); return course ? { ...course, fire: hands.fire } : hands; } // WHICH co-pilot is the brain selection's answer. Under the shipped diff --git a/src/game/game.ts b/src/game/game.ts index bb18b184..617c4226 100644 --- a/src/game/game.ts +++ b/src/game/game.ts @@ -386,6 +386,7 @@ export class Game { closeScreens: () => this.screens.exit(), showMessage: (text, seconds) => this.showMessage(text, seconds), refused: () => sfx.refused(), + stopCourse: () => this.flight_.switches.courses.stopCourse(), } satisfies CourseHost); /** The target list's buttons, and the pick applied (docs/TODO/206 M3). */ diff --git a/test/aim.test.ts b/test/aim.test.ts index e3d4d037..49d34c1b 100644 --- a/test/aim.test.ts +++ b/test/aim.test.ts @@ -113,15 +113,31 @@ function beside(g: Game, role: 'pirate' | 'trader', x: number, seed: number): Np check('a pick hands the stick back, and the aim starts again', g.state.session.ccEngaged); } +// A FIGHT DROPS THE COURSE (Chris, 2026-09-12: *"it should also be disengaged +// by combat or other events"*, and *"anything that breaks the journey should +// let you reconsider what you are doing - at the moment you are stuck on a +// course"*). +// +// The aim already won the stick, because `flight.ts` asks the co-pilot before +// the course. So the course flew nothing while it waited, the button said the +// ship was heading somewhere, and the course took the ship back the moment the +// last pirate died. Now the fight ends it, and the list comes back. { const g = open(20_260_928); g.state.session.course = 'station'; const pirate = beside(g, 'pirate', 1400, 6); run(g, 30); - check('a fight on a course: the aim flies, and the course waits', g.state.session.ccEngaged - && g.state.session.course === 'station'); + check('a fight on a course: the aim flies, and the course is dropped', + g.state.session.ccEngaged && g.state.session.course === null); pirate.state.alive = false; run(g, 5); - check('...and when the area is clear, the course flies on', !g.state.session.ccEngaged - && g.state.session.course === 'station'); + check('...and a clear area leaves the pilot to choose again, not back on it', + !g.state.session.ccEngaged && g.state.session.course === null); + + // ...and a course picked while the fight runs goes the same way. The stick is + // already the computer's, so an edge test on the fight starting would miss it. + g.state.session.course = 'station'; + beside(g, 'pirate', 1400, 6); + run(g, 30); + check('a course picked mid-fight is dropped too', g.state.session.course === null); } diff --git a/test/constants.test.ts b/test/constants.test.ts index d4a00b97..813e4b0f 100644 --- a/test/constants.test.ts +++ b/test/constants.test.ts @@ -409,7 +409,7 @@ const OUTSIDE: readonly Group[] = [ + ' when the ship cannot jump, beside the rule that raises them (M5).' + ' KINDS is the list of courses, read off the codes that name them', files: { - 'game/flight-instruments.ts': ['COURSE_ENDS'], + 'game/flight-course.ts': ['COURSE_ENDS'], 'game/courses.ts': ['COURSE_NAMES', 'JUMP_WHY'], 'game/course-actions.ts': ['KINDS'], // what each role is called on the target list (docs/TODO/206 M1) @@ -471,7 +471,7 @@ const OUTSIDE: readonly Group[] = [ // ...and the codes a course row sends, on both of its surfaces (docs/TODO/205 M4) 'game/bindings.ts': [ 'GLOBAL_BINDINGS', 'FLIGHT_BINDINGS', 'NOT_IN_THE_SIMULATOR', 'BINDINGS', - 'WHILE_PAUSED', 'COURSE_KEYS', 'COURSE_CHART_KEY', 'COURSE_TOGGLE_KEY', 'COURSE_SKIP_KEY', + 'WHILE_PAUSED', 'COURSE_KEYS', 'COURSE_CHART_KEY', 'COURSE_STOP_KEY', 'COURSE_SKIP_KEY', 'TARGETS_KEY', 'TARGET_NONE_KEY', 'TARGET_ROW_PREFIX', 'ROLL_STRIP_CODE', ], 'game/screens/save-transfer.ts': ['NOT_A_SAVE', 'WRONG_VERSION', 'STORE_FULL'], diff --git a/test/course-buttons.test.ts b/test/course-buttons.test.ts index 14e64927..b98bdbb8 100644 --- a/test/course-buttons.test.ts +++ b/test/course-buttons.test.ts @@ -4,11 +4,12 @@ // flight world stops under a screen. Each button sends its code as a menu row // does. These press the codes in a real headless Game, as a click would. +import * as THREE from 'three'; import { Game } from '../src/game/game.ts'; import { headlessShell } from '../src/engine/shell.ts'; import { withoutSaving } from '../src/game/storage.ts'; import { seedWorld } from '../src/game/rng.ts'; -import { COURSE_KEYS, COURSE_TOGGLE_KEY } from '../src/game/bindings.ts'; +import { COURSE_KEYS, COURSE_STOP_KEY } from '../src/game/bindings.ts'; import { courseButtonsFor } from '../src/game/cockpit-buttons.ts'; import { keyCodeIfBound } from '../src/ui/key-help.ts'; import { check, dismissBriefing, eq } from './harness.ts'; @@ -59,15 +60,21 @@ function press(g: Game, code: string): void { eq('...leaving a button that says what the ship is doing, and fast forward', courseButtonsFor(g.coursePanel()!, null).map((b) => b.label).join(), 'HEADING TO THE STATION,FAST FORWARD'); - press(g, COURSE_TOGGLE_KEY); - check('that button opens the list again over the course', (g.coursePanel()?.rows?.length ?? 0) > 0); - check('...and the list ends with a button that closes it', - courseButtonsFor(g.coursePanel()!, 'KeyN').at(-1)?.label === 'CLOSE'); + // A LIT BUTTON READS AS ON, SO A TAP TURNS IT OFF (Chris, 2026-09-12: *"I + // think you should be able to click it to disengage it"*). It used to open + // the list over the running course instead. + eq('...and that button offers to stop the course', + courseButtonsFor(g.coursePanel()!, null)[0]?.hint, 'TAP TO STOP'); + press(g, COURSE_STOP_KEY); + eq('pressing it stops the course', g.state.session.course, null); + eq('...and the console says so', g.state.session.messageText, + 'COURSE OFF — CHOOSE WHERE TO GO'); + check('...and the list shows again by itself', (g.coursePanel()?.rows?.length ?? 0) > 0); g.state.commander.equipment.scoops = true; g.state.commander.fuel = 10; press(g, COURSE_KEYS.skim); - eq('another button changes the course', g.state.session.course, 'skim'); + eq('another button picks a new course', g.state.session.course, 'skim'); eq('...and folds the list away again', g.coursePanel()?.rows ?? null, null); } @@ -109,3 +116,37 @@ function press(g: Game, code: string): void { eq('an exercise shows no course buttons', g.coursePanel(), null); g.endExercise(); } + +// --- A FIGHT DROPS THE COURSE ---------------------------------------------- +// +// Chris, 2026-09-12: *"it should also be disengaged by combat or other +// events"*. The combat computer already won the stick, because `flight.ts` +// asks it before the course. So the course sat there flying nothing, and it +// took the ship back the moment the fight ended. The button meanwhile said the +// ship was heading somewhere. +{ + const g = arrived(); + press(g, COURSE_KEYS.station); + eq('a course is under way', g.state.session.course, 'station'); + + // a pirate close enough for the condition light to call it a fight + g.state.world.spawn('pirate', + g.state.player.position.clone().add(new THREE.Vector3(0, 0, -900)), 1); + // The console shows one line at a time, and the torus drive drops in the same + // frame, so collect what it said rather than read the last of it. + const said: string[] = []; + withoutSaving(() => { + for (let f = 0, at = 1; f < 240; f++) { + g.step(1 / 60, at += 1 / 60); + const line = g.state.session.messageText; + if (line && said.at(-1) !== line) said.push(line); + } + }); + + check('a fight takes the stick', g.state.session.ccEngaged); + eq('...and the course is dropped with it', g.state.session.course, null); + check('...and the console says why', said.includes('HOSTILE SHIP — COURSE OFF'), + said.join(' / ')); + check('...so the list shows again, rather than a course that flies nothing', + (g.coursePanel()?.rows?.length ?? 0) > 0); +} diff --git a/test/skip.test.ts b/test/skip.test.ts index 12704709..00bd0e2b 100644 --- a/test/skip.test.ts +++ b/test/skip.test.ts @@ -98,6 +98,9 @@ function world(g: Game): string { eq('a flight key takes the ship, and fast forward stops with the course', g.coursePanel()?.skip ?? null, null); } +// A HOSTILE SHIP NOW ENDS THE COURSE ITSELF, and fast forward goes with it +// (Chris, 2026-09-12). The button used to stay, over a course that flew +// nothing while the aim fought. { const g = onCourse(20_260_921); for (const s of g.state.world.npcs) if (s.role === 'pirate' || s.role === 'hunter') s.state.alive = false; @@ -107,8 +110,25 @@ function world(g: Game): string { g.state.player.position.clone().add(new THREE.Vector3(0, 0, -1500)), 7); pirate.state.provokedByPlayer = true; run(g, 2, 7); - eq('a hostile ship nearby stops fast forward by itself', g.coursePanel()?.skip?.on, false); - eq('...and the console says why', g.state.session.messageText, 'HOSTILE SHIP NEARBY — BACK TO NORMAL SPEED'); + eq('a hostile ship nearby ends the course', g.state.session.course, null); + eq('...so there is no fast forward button left to press', g.coursePanel()?.skip ?? null, null); +} + +// ...and with NO co-pilot, the course is the only pilot there is, so it flies +// on through the fight. Fast forward is what stops, and it says why. +{ + const g = onCourse(20_260_921); + for (const s of g.state.world.npcs) if (s.role === 'pirate' || s.role === 'hunter') s.state.alive = false; + g.state.brains = { ...g.state.brains, scripted: true }; + press(g, COURSE_SKIP_KEY); + const pirate = g.state.world.spawn('pirate', + g.state.player.position.clone().add(new THREE.Vector3(0, 0, -1500)), 7); + pirate.state.provokedByPlayer = true; + run(g, 2, 7); + eq('with no co-pilot the course flies on', g.state.session.course, 'station'); + eq('...and a hostile ship nearby stops fast forward by itself', g.coursePanel()?.skip?.on, false); + eq('...and the console says why', g.state.session.messageText, + 'HOSTILE SHIP NEARBY — BACK TO NORMAL SPEED'); press(g, COURSE_SKIP_KEY); eq('...and with the hostile ship still there, the button refuses', g.coursePanel()?.skip?.on, false); From cea5f3ca2665f476769d9d1251e22247da3d5cf8 Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Sat, 12 Sep 2026 20:11:10 +0100 Subject: [PATCH 046/100] The slot is hard for a hand, and kind to a bought computer Chris, 2026-09-12: *"I think we should tighten it for the mini game - docking is supposed to be hard. But we can 'cheat' for the docking computer and give it more leeway."* THE MEASUREMENT THAT PROMPTED IT. A probe flew the mini game 20 times, at a different slot angle each time. A pilot who matched the spin docked 20 times, first go. A pilot who never touched the roll ALSO docked 20 times, after one scrape. The skill saved a shield. It was not what got the ship in. The slot took a roll 37 degrees out, which is 41% of every angle it presents. SO THE ONE TOLERANCE IS NOW TWO, and the caller says which. `ROLL_TOLERANCE` is the hand's, and it is 0.24 rad, about 13.75 degrees. `COMPUTER_ROLL_TOLERANCE` is 0.65, which is what both used to be. They have separate rule ids and they must not be fused: one is a difficulty setting, and the other is the equipment's licence. `dockingOutcome` takes the figure rather than reading one, and the default is the HARD one, so a caller that forgets is strict rather than lax. `world-step.ts` picks on `dcEngaged`. The HUD's alignment aid picks the same way, so the green light still means the dock test would pass. `docking-sticks.ts` aims the computer's wings at the computer's own figure. THE CHEAT IS NOT A COURTESY. `npm run dock-probe` reports the computer arriving up to 13.8 degrees off the slot's long axis, which is outside the hand's 13.75. The shared constant at that figure cost 2 scrapes over 504 approaches. With the two split it is back to 504 of 504, median 16.4 seconds, no scrapes. What the mini game is worth now, over the same 20 approaches: matches the spin 20 of 20, first go, no scrape ignores the roll 16 of 20, and 4 died of repeated scrapes Three tests pin it, and each fails when its rule is broken. The old 0.65 in the hand's place leaves a lazy pilot unscathed, which is the fault this fixes. Co-Authored-By: Claude Fable 5.1 Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- src/constants/CATALOG.md | 19 +++++++------- src/constants/docking.ts | 49 ++++++++++++++++++++++++++++++----- src/game/cockpit-view.ts | 1 + src/game/docking-sticks.ts | 6 +++-- src/game/docking.ts | 16 +++++++++--- src/game/world-step.ts | 12 ++++++--- src/hud/hud-binding.ts | 6 ++++- src/hud/hud-model.ts | 4 ++- test/dock-trial.test.ts | 20 +++++++++++++- test/docking-computer.test.ts | 8 +++--- test/hud-model.test.ts | 2 +- test/world.test.ts | 17 +++++++++++- train/dock-probe.ts | 6 ++--- 13 files changed, 130 insertions(+), 36 deletions(-) diff --git a/src/constants/CATALOG.md b/src/constants/CATALOG.md index f6bd69e0..3cdddbb0 100644 --- a/src/constants/CATALOG.md +++ b/src/constants/CATALOG.md @@ -2,7 +2,7 @@ -452 exported constants. Regenerate with `npm run generate:constants`; +453 exported constants. Regenerate with `npm run generate:constants`; search names, meanings and values with `npm run constants:find -- ""`. | Domain | Symbol | Literal / expression | Purpose | Rule ID | Source | @@ -143,14 +143,15 @@ search names, meanings and values with `npm run constants:find -- ""`. | docking | SLOT_HALF_ACROSS | 26 | The slot channel, as half-extents ACROSS the slot and ALONG it, in station-local world units. | | [docking.ts:127](./docking.ts#L127) | | docking | SLOT_HALF_ALONG | 62 | | | [docking.ts:128](./docking.ts#L128) | | docking | SLOT_DEPTH | 60 | How far into the -Z face puts a ship in the channel, in world units. * | docking.slotDepth | [docking.ts:133](./docking.ts#L133) | -| docking | ROLL_TOLERANCE | 0.65 | The wings against the slot's long axis, in radians: how badly you may be rolled and still fit through the letterbox. | | [docking.ts:144](./docking.ts#L144) | -| docking | SLOT_SPEED_LIMIT | 120 | How fast a ship may be going when it reaches the slot, in world units a second (docs/TODO/207 M3). | docking.slotSpeedLimit | [docking.ts:165](./docking.ts#L165) | -| docking | RAILS_LATERAL | 250 | How far off the slot axis the ship may be when the rails take it, in world units (docs/TODO/212). | docking.railsLateral | [docking.ts:187](./docking.ts#L187) | -| docking | RAILS_RANGE | 900 | How far out the rails take the ship, in world units (docs/TODO/212). | docking.railsRange | [docking.ts:199](./docking.ts#L199) | -| docking | RAILS_PULL | 2 | How hard the rails pull the ship onto the axis, per second (docs/TODO/212). | docking.railsPull | [docking.ts:211](./docking.ts#L211) | -| docking | RAILS_CONE | 0.03 | How far off the slot axis the ship's NOSE may point when the PILOT is given the slot, in radians. | docking.railsCone | [docking.ts:245](./docking.ts#L245) | -| docking | RAILS_TURN | 3 | How hard the rails turn the nose onto the axis, per second. | docking.railsTurn | [docking.ts:262](./docking.ts#L262) | -| docking | RAILS_STOPPED | 2 | The speed under which the ship counts as stopped, in world units a second (docs/TODO/212). | docking.railsStopped | [docking.ts:276](./docking.ts#L276) | +| docking | ROLL_TOLERANCE | 0.24 | The wings against the slot's long axis, in radians, FOR A HAND ON THE STICK. | docking.rollTolerance | [docking.ts:153](./docking.ts#L153) | +| docking | COMPUTER_ROLL_TOLERANCE | 0.65 | ...and the same angle for a BOUGHT DOCKING COMPUTER, which is wider. | docking.computerRollTolerance | [docking.ts:179](./docking.ts#L179) | +| docking | SLOT_SPEED_LIMIT | 120 | How fast a ship may be going when it reaches the slot, in world units a second (docs/TODO/207 M3). | docking.slotSpeedLimit | [docking.ts:200](./docking.ts#L200) | +| docking | RAILS_LATERAL | 250 | How far off the slot axis the ship may be when the rails take it, in world units (docs/TODO/212). | docking.railsLateral | [docking.ts:222](./docking.ts#L222) | +| docking | RAILS_RANGE | 900 | How far out the rails take the ship, in world units (docs/TODO/212). | docking.railsRange | [docking.ts:234](./docking.ts#L234) | +| docking | RAILS_PULL | 2 | How hard the rails pull the ship onto the axis, per second (docs/TODO/212). | docking.railsPull | [docking.ts:246](./docking.ts#L246) | +| docking | RAILS_CONE | 0.03 | How far off the slot axis the ship's NOSE may point when the PILOT is given the slot, in radians. | docking.railsCone | [docking.ts:280](./docking.ts#L280) | +| docking | RAILS_TURN | 3 | How hard the rails turn the nose onto the axis, per second. | docking.railsTurn | [docking.ts:297](./docking.ts#L297) | +| docking | RAILS_STOPPED | 2 | The speed under which the ship counts as stopped, in world units a second (docs/TODO/212). | docking.railsStopped | [docking.ts:311](./docking.ts#L311) | | docking-computer | DOCK_COMPUTER_RANGE | 3500 | How close to the station the docking computer will take the job, in world units. | | [docking-computer.ts:46](./docking-computer.ts#L46) | | docking-computer | DC_SLOT_MARGIN | 0.30 | How much of the slot's roll tolerance the TURN may spend, as a fraction. | docking.slotMargin | [docking-computer.ts:97](./docking-computer.ts#L97) | | docking-computer | DC_TURN_FADE_ANGLE | 0.10 | The off-nose angle, in radians, over which the TURN's claim on the roll axis ramps in. | docking.turnFadeAngle | [docking-computer.ts:151](./docking-computer.ts#L151) | diff --git a/src/constants/docking.ts b/src/constants/docking.ts index bb168978..bebe1a08 100644 --- a/src/constants/docking.ts +++ b/src/constants/docking.ts @@ -133,15 +133,50 @@ export const SLOT_HALF_ALONG = 62; export const SLOT_DEPTH = 60; /** - * The wings against the slot's long axis, in radians: how badly you may be rolled - * and still fit through the letterbox. It is a quarter turn's tolerance either - * side, and it is symmetric, so a ship upside down in the slot still fits. + * The wings against the slot's long axis, in radians, FOR A HAND ON THE STICK. + * It is how badly you may be rolled and still fit through the letterbox. It is + * symmetric, so a ship upside down in the slot still fits. + * + * DOCKING IS SUPPOSED TO BE HARD (Chris, 2026-09-12). It was 0.65, about 37 + * degrees, which is 41% of every angle the slot can present. A probe of the + * mini game flew it 20 times, at a different slot angle each time. A pilot who + * matched the spin docked 20 times, first go. A pilot who never touched the + * roll ALSO docked 20 times, after one scrape. The skill saved a shield. It was + * not what got the ship in. + * + * What the whole channel is worth, measured at 0.65: over a uniform sample of + * approach offsets and rolls, the fraction that docks is 6.68%. That is the + * number to measure again if this tolerance or the half-widths above ever move. + * + * @rule docking.rollTolerance + */ +export const ROLL_TOLERANCE = 0.24; + +/** + * ...and the same angle for a BOUGHT DOCKING COMPUTER, which is wider. + * + * It is a deliberate cheat (Chris, 2026-09-12: *"we can 'cheat' for the docking + * computer and give it more leeway"*). The computer is what a commander buys to + * stop docking being hard, so the slot is kinder to it than to a hand. + * + * 0.65 is what BOTH used to be, so this is the old rule under its own name and + * the hand's is the one that moved. + * + * THE COMPUTER CANNOT MEET THE HAND'S FIGURE. `npm run dock-probe` reports it + * arriving up to 13.8 degrees off the slot's long axis. `ROLL_TOLERANCE` at + * 0.24 rad is 13.75 degrees, so the worst approach falls outside it. Measured, + * the shared constant at that figure cost 2 scrapes over 504 approaches. + * + * A commander who paid for the computer should not lose a shield to that. So + * the licence is wide, and the hand's is not. With the two split, the probe is + * back to 504 of 504 with no scrape. + * + * It has its own rule id, and the two must not be fused. One is a difficulty + * setting. The other is the equipment's licence. * - * What the whole channel is worth, measured: over a uniform sample of approach - * offsets and rolls, the fraction that docks is 6.68%. That is the number to - * measure again if this tolerance or the half-widths above ever move. + * @rule docking.computerRollTolerance */ -export const ROLL_TOLERANCE = 0.65; +export const COMPUTER_ROLL_TOLERANCE = 0.65; /** * How fast a ship may be going when it reaches the slot, in world units a diff --git a/src/game/cockpit-view.ts b/src/game/cockpit-view.ts index fb5c76bc..c37011c3 100644 --- a/src/game/cockpit-view.ts +++ b/src/game/cockpit-view.ts @@ -318,6 +318,7 @@ export class CockpitView { inFlight: this.host.inFlight(), witchspace: this.state.session.witchspace, assist: this.state.session.ccEngaged, + dockingComputer: this.state.session.dcEngaged, trial: this.state.session.dockTrial, rails: this.state.session.dockRails, ecmDetected: this.state.ecmDetectedTimer > 0, diff --git a/src/game/docking-sticks.ts b/src/game/docking-sticks.ts index f7c442e9..d7dd684d 100644 --- a/src/game/docking-sticks.ts +++ b/src/game/docking-sticks.ts @@ -19,7 +19,9 @@ import * as THREE from 'three'; -import { LINED_UP_LATERAL, SLOT_HALF_ACROSS, ROLL_TOLERANCE } from '../constants/docking.ts'; +import { + LINED_UP_LATERAL, SLOT_HALF_ACROSS, COMPUTER_ROLL_TOLERANCE, +} from '../constants/docking.ts'; import { DC_SLOT_MARGIN, DC_TURN_FADE_ANGLE, DC_ROLL_LEAD, } from '../constants/docking-computer.ts'; @@ -118,7 +120,7 @@ export function dockingSticks( // last correction and nothing else (docs/TODO/137, `DC_SLOT_MARGIN`). const onAxis = Math.max(0, Math.min(1, (LINED_UP_LATERAL - plan.lateral) / (LINED_UP_LATERAL - SLOT_HALF_ACROSS))); - const budget = Math.PI / 2 + (ROLL_TOLERANCE * DC_SLOT_MARGIN - Math.PI / 2) * onAxis; + const budget = Math.PI / 2 + (COMPUTER_ROLL_TOLERANCE * DC_SLOT_MARGIN - Math.PI / 2) * onAxis; // The attitude the SLOT asks for, but only once the approach COMMITS to the // letterbox. A slot 1,500 units away on a hull that turns has no opinion // worth the flight. To track it out there is a roll that never stops. A ship in a diff --git a/src/game/docking.ts b/src/game/docking.ts index ff54927a..c642db25 100644 --- a/src/game/docking.ts +++ b/src/game/docking.ts @@ -235,8 +235,10 @@ export function inSlotChannel(localX: number, localY: number): boolean { * the angle away from it. Both magnitudes are absolute: a ship upside down in * the slot still fits through it. */ -export function rollAlignedWithSlot(rightX: number, rightY: number): boolean { - return slotRollOffset(rightX, rightY) < ROLL_TOLERANCE; +export function rollAlignedWithSlot( + rightX: number, rightY: number, tolerance: number = ROLL_TOLERANCE, +): boolean { + return slotRollOffset(rightX, rightY) < tolerance; } /** How far off the slot's long axis the wings are, in radians. */ @@ -273,6 +275,14 @@ export function dockingOutcome( dockZ: number, speed: number, scratch: { v: THREE.Vector3; q: THREE.Quaternion; r: THREE.Vector3 }, + /** + * How far the wings may be off the slot's long axis, in radians. The CALLER + * says, because it depends on who holds the stick: `ROLL_TOLERANCE` for a + * hand, and the wider `COMPUTER_ROLL_TOLERANCE` for a bought docking + * computer. The default is the hard one, so a caller that forgets is strict + * rather than lax. + */ + rollTolerance: number = ROLL_TOLERANCE, ): DockingOutcome { const box = dockZ + HULL_BOX_MARGIN; const local = scratch.v.copy(pos); @@ -286,6 +296,6 @@ export function dockingOutcome( scratch.q.copy(station.quaternion).invert().multiply(quat); const right = scratch.r.set(1, 0, 0).applyQuaternion(scratch.q); - if (!rollAlignedWithSlot(right.x, right.y)) return 'slotMiss'; + if (!rollAlignedWithSlot(right.x, right.y, rollTolerance)) return 'slotMiss'; return speed > SLOT_SPEED_LIMIT ? 'tooFast' : 'docked'; } diff --git a/src/game/world-step.ts b/src/game/world-step.ts index 09fb62fa..6f4ba4f0 100644 --- a/src/game/world-step.ts +++ b/src/game/world-step.ts @@ -59,7 +59,9 @@ import { holdOnRails, railsAligned, railsReached, stopped } from './dock-rails.t import { bankToTurn } from './pitch-roll-steer.ts'; import { slotNormal } from '../world/slot.ts'; import { dockingSticks } from './docking-sticks.ts'; -import { NPC_HULL_BOX_MARGIN } from '../constants/docking.ts'; +import { + NPC_HULL_BOX_MARGIN, COMPUTER_ROLL_TOLERANCE, ROLL_TOLERANCE, +} from '../constants/docking.ts'; import { BOUNCE_STANDOFF } from '../constants/station.ts'; import { regenerate, updateCabinTemp, scoopFuel, energyLow } from './systems.ts'; import { SUN_KILL_DIST } from '../constants/sun.ts'; @@ -963,11 +965,15 @@ export class WorldStep { * ours. */ private checkStation(out: StepEvent[]): void { - const { player, world } = this.state; + const { player, world, session } = this.state; const station = world.station; + // WHICH TOLERANCE depends on who holds the stick. A bought docking computer + // gets the wider one, and that is the point of buying it + // (`COMPUTER_ROLL_TOLERANCE`). A hand gets the hard one. const outcome = dockingOutcome( player.position, player.quaternion, station, world.stationDockZ, player.speed, - { v: this.tmp, q: this.tmpQ, r: this.tmp2 }); + { v: this.tmp, q: this.tmpQ, r: this.tmp2 }, + session.dcEngaged ? COMPUTER_ROLL_TOLERANCE : ROLL_TOLERANCE); if (outcome === 'clear') return; if (outcome === 'docked') { this.host.dock(); diff --git a/src/hud/hud-binding.ts b/src/hud/hud-binding.ts index 0f414aee..cd50a8b5 100644 --- a/src/hud/hud-binding.ts +++ b/src/hud/hud-binding.ts @@ -30,6 +30,7 @@ import type { World } from '../game/world.ts'; import type { Missile } from '../game/ordnance.ts'; import type { Canister } from '../game/cargo.ts'; import { MAX_FUEL } from '../constants/commander.ts'; +import { COMPUTER_ROLL_TOLERANCE, ROLL_TOLERANCE } from '../constants/docking.ts'; import { SCANNER_RANGE, SUNSKIM_COMPASS_RANGE, STATION_COMPASS_RADII, } from '../constants/console.ts'; @@ -57,6 +58,8 @@ export interface HudSources { readonly inFlight: boolean; readonly witchspace: boolean; readonly assist: boolean; + /** a bought docking computer holds the stick, so the slot is kinder to it */ + readonly dockingComputer: boolean; /** the pilot flies the last stretch into the slot (docs/TODO/207) */ readonly trial: boolean; readonly rails: boolean; @@ -140,7 +143,8 @@ export function buildHudFrame(s: HudSources, scratch: HudScratch): HudFrame { if (s.inFlight && !s.witchspace) { ({ dockAid, slotMarker } = dockingAid( world.station, world.stationDockZ, playerPos, s.playerQuat, s.playerForward, - s.camera, { a: scratch.a, b: scratch.b, q: scratch.q })); + s.camera, { a: scratch.a, b: scratch.b, q: scratch.q }, + s.dockingComputer ? COMPUTER_ROLL_TOLERANCE : ROLL_TOLERANCE)); } // The tags of the things live missions sent the player for, so the scanner diff --git a/src/hud/hud-model.ts b/src/hud/hud-model.ts index c06c60d5..5ee90a28 100644 --- a/src/hud/hud-model.ts +++ b/src/hud/hud-model.ts @@ -191,6 +191,8 @@ export function dockingAid( playerForward: THREE.Vector3, camera: THREE.Camera, scratch: { a: THREE.Vector3; b: THREE.Vector3; q: THREE.Quaternion }, + /** the slot's roll tolerance for whoever holds the stick — see `dockingOutcome` */ + rollTolerance: number, ): { dockAid: HudState['dockAid']; slotMarker: HudState['slotMarker'] } { const none = { dockAid: null, slotMarker: null }; const dist = playerPos.distanceTo(station.position); @@ -215,7 +217,7 @@ export function dockingAid( // channel and the roll tolerance. So the aid and the dock test could // disagree, and once the letterbox turned upright they did. const inSlot = inSlotChannel(local.x, local.y); - const rollOk = rollAlignedWithSlot(right.x, right.y); + const rollOk = rollAlignedWithSlot(right.x, right.y, rollTolerance); return { slotMarker, dockAid: { diff --git a/test/dock-trial.test.ts b/test/dock-trial.test.ts index f549af1e..da32b88c 100644 --- a/test/dock-trial.test.ts +++ b/test/dock-trial.test.ts @@ -139,6 +139,7 @@ console.log('\nthe docking mini game'); */ const fly = (g: Game, match: boolean, hands = true): { rails: boolean; docked: boolean; lateral: number; handedOver: number; + scrapes: number; } => { const dt = 1 / 60; const q = new THREE.Quaternion(); @@ -148,6 +149,8 @@ console.log('\nthe docking mini game'); let rails = false; let lateral = Infinity; let handedOver = -1; + let scrapes = 0; + let wasRails = false; withoutSaving(() => { for (let f = 0, at = 0; f < 200 / dt; f++) { const st = g.state.world.station; @@ -176,11 +179,15 @@ console.log('\nthe docking mini game'); Math.atan2(Math.sin(2 * err), Math.cos(2 * err)) / 2 * 4)); } } + const held = g.state.session.dockRails; g.step(dt, at += dt); + // The rails let go on a scrape, and only on a scrape, while in flight. + if (wasRails && !g.state.session.dockRails && g.mode === 'flight') scrapes += 1; + wasRails = held; if (g.mode !== 'flight') break; } }); - return { rails, docked: g.mode === 'docked', lateral, handedOver }; + return { rails, docked: g.mode === 'docked', lateral, handedOver, scrapes }; }; const run = fly(arrive(20_260_951), true); @@ -191,6 +198,17 @@ console.log('\nthe docking mini game'); check('...having been held on the line, inside the channel', run.lateral < SLOT_HALF_ACROSS, `${run.lateral.toFixed(0)} units off the axis`); + check('...first time, with no scrape at all', run.scrapes === 0); + + // THE SPIN IS THE GAME, and it was not (Chris, 2026-09-12: *"I think we're + // still too easy on the docking"*). A probe of 20 approaches found that a + // pilot who never touched the roll docked every time, after one scrape. The + // slot took a roll 37 degrees out, which is 41% of every angle it presents. + // `ROLL_TOLERANCE` is now 0.24, and a bought computer keeps the old 0.65. + const lazy = fly(arrive(20_260_951), false); + check('a pilot who thrusts in but ignores the spin is bounced off', + lazy.scrapes > 0, `${lazy.scrapes} scrape(s)`); + // The control: hands off entirely. The ship stops on the axis and stays // there, so nobody docks by accident (docs/TODO/212). Chris asked for that // on 2026-09-12: the pilot must thrust in. diff --git a/test/docking-computer.test.ts b/test/docking-computer.test.ts index dc069b51..68f31e93 100644 --- a/test/docking-computer.test.ts +++ b/test/docking-computer.test.ts @@ -28,7 +28,7 @@ import { PLAYER_FLIGHT } from '../src/constants/player-flight.ts'; import { DC_TURN_FADE_ANGLE, DC_SLOT_MARGIN, DC_ROLL_LEAD, } from '../src/constants/docking-computer.ts'; -import { ROLL_TOLERANCE } from '../src/constants/docking.ts'; +import { COMPUTER_ROLL_TOLERANCE } from '../src/constants/docking.ts'; import { STEER_SATURATION } from '../src/constants/combat-computer.ts'; import { rollErrorTo } from '../src/game/pitch-roll-steer.ts'; import { check } from './harness.ts'; @@ -128,7 +128,7 @@ console.log('\nthe docking computer near its own heading'); // the fade is the only thing holding it back and not some other clamp. check(`...and outside it spends the budget DC_SLOT_MARGIN allows (${ outside.toFixed(4)})`, - near(Math.abs(outside), ROLL_TOLERANCE * DC_SLOT_MARGIN / STEER_SATURATION, 1e-6)); + near(Math.abs(outside), COMPUTER_ROLL_TOLERANCE * DC_SLOT_MARGIN / STEER_SATURATION, 1e-6)); } // The GATE phase hands the whole axis to the turn: a slot on a spinning hull @@ -145,10 +145,10 @@ console.log('\nthe docking computer near its own heading'); const q = new THREE.Quaternion().setFromRotationMatrix( new THREE.Matrix4().lookAt(new THREE.Vector3(), plan.heading, plan.up)); q.multiply(new THREE.Quaternion() - .setFromAxisAngle(new THREE.Vector3(0, 0, 1), ROLL_TOLERANCE * 2)); + .setFromAxisAngle(new THREE.Vector3(0, 0, 1), COMPUTER_ROLL_TOLERANCE * 2)); const s = dockingSticks(q, plan, AT_REST); check(`...so with the nose on the gate heading it holds the wings still (${ - s.roll.toFixed(6)}), rolled ${(ROLL_TOLERANCE * 2).toFixed(2)} off the slot`, + s.roll.toFixed(6)}), rolled ${(COMPUTER_ROLL_TOLERANCE * 2).toFixed(2)} off the slot`, Math.abs(s.roll) < 1e-6); } } diff --git a/test/hud-model.test.ts b/test/hud-model.test.ts index 0614fdf9..2bd62fcc 100644 --- a/test/hud-model.test.ts +++ b/test/hud-model.test.ts @@ -172,7 +172,7 @@ console.log('\ndocking port marker'); const aidAt = (x: number, off: number) => { const p = pose(x, off); return dockingAid( - station, DOCK_Z, p.pos, p.quat, p.forward, camera, scratch).dockAid; + station, DOCK_Z, p.pos, p.quat, p.forward, camera, scratch, ROLL_TOLERANCE).dockAid; }; const straight = aidAt(0, 0); diff --git a/test/world.test.ts b/test/world.test.ts index 6ee9424c..a9c80367 100644 --- a/test/world.test.ts +++ b/test/world.test.ts @@ -6,7 +6,7 @@ import * as THREE from 'three'; import { dockingOutcome } from '../src/game/docking.ts'; -import { ROLL_TOLERANCE } from '../src/constants/docking.ts'; +import { COMPUTER_ROLL_TOLERANCE, ROLL_TOLERANCE } from '../src/constants/docking.ts'; import { freshTimers, stepEncounters } from '../src/game/encounters.ts'; import { planPopulation, policeFor } from '../src/game/population.ts'; import { World } from '../src/game/world.ts'; @@ -227,6 +227,21 @@ console.log('\ndocking'); at(0, 0, -(DOCK_Z - 20), rolledFrom(-(ROLL_TOLERANCE - 0.05))) === 'docked' && at(0, 0, -(DOCK_Z - 20), rolledFrom(-(ROLL_TOLERANCE + 0.05))) === 'slotMiss'); } + { + // A BOUGHT DOCKING COMPUTER GETS A WIDER SLOT, and that is the point of + // buying it (Chris, 2026-09-12: *"docking is supposed to be hard. But we + // can 'cheat' for the docking computer and give it more leeway"*). The + // caller says which tolerance to use, so the two cannot be confused. + const roll = (ROLL_TOLERANCE + COMPUTER_ROLL_TOLERANCE) / 2; + const byHand = dockingOutcome(new THREE.Vector3(0, 0, -(DOCK_Z - 20)), + rolledFrom(roll), station, DOCK_Z, 0, scratch, ROLL_TOLERANCE); + const byComputer = dockingOutcome(new THREE.Vector3(0, 0, -(DOCK_Z - 20)), + rolledFrom(roll), station, DOCK_Z, 0, scratch, COMPUTER_ROLL_TOLERANCE); + check('a roll between the two tolerances is a miss for a hand', byHand === 'slotMiss'); + check('...and a dock for the bought computer', byComputer === 'docked'); + check('...so the computer is the wider of the two', + COMPUTER_ROLL_TOLERANCE > ROLL_TOLERANCE); + } } // --- who is hunting whom, across a reload ----------------------------------- diff --git a/train/dock-probe.ts b/train/dock-probe.ts index ea9dfc7b..4f7833a9 100644 --- a/train/dock-probe.ts +++ b/train/dock-probe.ts @@ -111,7 +111,7 @@ import { WorldStep, type StepHost } from '../src/game/world-step.ts'; import { Ordnance } from '../src/game/ordnance.ts'; import { seedWorld } from '../src/game/rng.ts'; import { slotRollOffset } from '../src/game/docking.ts'; -import { ROLL_TOLERANCE } from '../src/constants/docking.ts'; +import { COMPUTER_ROLL_TOLERANCE } from '../src/constants/docking.ts'; /** Hands off the stick: the autopilot is the only pilot in these runs. */ const COAST = { rollRate: 0, pitchRate: 0, throttle: 0, fire: false }; @@ -178,7 +178,7 @@ interface Run { /** * ...and how far off the slot's LONG AXIS the wings still were, in degrees — * the other half of going through a letterbox, and the half the whole roll - * axis exists for (`rollAlignedWithSlot`). `ROLL_TOLERANCE` is what fits; + * axis exists for (`rollAlignedWithSlot`). `COMPUTER_ROLL_TOLERANCE` is what fits; * this is what the autopilot actually arrives with. */ entryRoll: number; @@ -381,7 +381,7 @@ console.log(`roll reversals: median ${median(rolls)} · worst ${worst(rolls)}` console.log(`still pointing this far off the slot axis going in: median ${ median(entries).toFixed(1)}° · worst ${worst(entries).toFixed(1)}°`); console.log(`...and this far off its long axis, against ${ - (ROLL_TOLERANCE * 180 / Math.PI).toFixed(0)}° of tolerance: median ${ + (COMPUTER_ROLL_TOLERANCE * 180 / Math.PI).toFixed(0)}° of tolerance: median ${ median(rolls2).toFixed(1)}° · worst ${worst(rolls2).toFixed(1)}°`); console.log(`the plan's own heading jumps: median ${median(jumps).toFixed(1)}°` + ` · worst ${worst(jumps).toFixed(1)}° in one frame` From 152459bb26264df6e6d86d3191793eea7c11beae Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Sat, 12 Sep 2026 20:26:25 +0100 Subject: [PATCH 047/100] The record: a review of the combat computer, and its probes The review of 2026-09-12 and the artifacts it was measured with. It is a record of what somebody measured, so it is committed as written. The code that answers it cites this file by name, and a cited document has to exist. Its probes reproduce byte for byte against revision 5abc879. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- docs/COMBAT-COMPUTER-REVIEW.md | 143 ++++++ .../integration-probe.mjs | 160 +++++++ .../integration-results.jsonl | 8 + .../measurements.jsonl | 426 ++++++++++++++++++ .../combat-computer-2026-09-12/probe.mjs | 142 ++++++ 5 files changed, 879 insertions(+) create mode 100644 docs/COMBAT-COMPUTER-REVIEW.md create mode 100644 docs/reviews/combat-computer-2026-09-12/integration-probe.mjs create mode 100644 docs/reviews/combat-computer-2026-09-12/integration-results.jsonl create mode 100644 docs/reviews/combat-computer-2026-09-12/measurements.jsonl create mode 100644 docs/reviews/combat-computer-2026-09-12/probe.mjs diff --git a/docs/COMBAT-COMPUTER-REVIEW.md b/docs/COMBAT-COMPUTER-REVIEW.md new file mode 100644 index 00000000..9c877207 --- /dev/null +++ b/docs/COMBAT-COMPUTER-REVIEW.md @@ -0,0 +1,143 @@ +# The combat computer acquires targets but loses its aim + +Review date: 12 September 2026. Source revision: `5abc879`. + +The main weakness is sustained tracking. The computer often acquires a target within three seconds, then rolls around it without a useful shot. This happens with one selected target, so target switching cannot explain it. + +The best first improvement is to control when pitch starts during a bank. An isolated experiment raised average tracking from **53.9% to 98.1%** across 54 additional orbit cases. Those figures describe prescribed target paths, not full combat or win rates. No production code changed during this review. + +## Scope and measurement + +The shipped pilot is [`ScriptedCoPilot`](../src/game/scripted-co-pilot.ts). The trained controller in [`combat-computer.ts`](../src/game/combat-computer.ts) is dormant. + +The tracking probe uses the real player flight model, the shipped controller, and a pirate with radius 15. The player starts at speed 200. The target follows a prescribed path. Its position, orientation, and speed agree with that path. + +Each run holds the same target throughout. This isolates steering from target selection. **Time on the gun** means the target is inside both `hitCone(radius, distance)` and `LASER_RANGE`, after the player moves. The first ten seconds are excluded from this measure. A tracking gap is consecutive time without that firing geometry. + +The first grid contains 18 orbits and three straight or weaving paths. Runs last 30 and 60 seconds. The separate validation grid contains 54 orbits with different radii, speeds, and starting phases. Those runs last 45 and 90 seconds. These are deterministic grids, not estimates of encounter frequency. + +## 1. High priority: stop the persistent roll around a target + +**Evidence:** [`scripted-co-pilot.ts:184`](../src/game/scripted-co-pilot.ts#L184), [`pitch-roll-steer.ts:176`](../src/game/pitch-roll-steer.ts#L176), [`pitch-roll-steer.ts:200`](../src/game/pitch-roll-steer.ts#L200). + +The co-pilot permits pitch before its bank aligns with the target. The steering rule reduces pitch by the cosine of the bank error. It does not stop pitch completely. Pitch can then move the target's bearing while roll tries to catch that bearing. The resulting motion can circle the target indefinitely. + +The module already describes this failure for the course pilot. Its comment at [`pitch-roll-steer.ts:107`](../src/game/pitch-roll-steer.ts#L107) says combat never encounters it. The measurements contradict that claim. + +These are the shipped controller's results. Orbit radius describes the target's path around a fixed centre, not its distance from the moving player. + +| Target path | Time on gun, 30-second run | Time on gun, 60-second run | Longest gap in the 60-second run | +| --- | ---: | ---: | ---: | +| Horizontal orbit, radius 400, speed 300 | 28.5% | 32.2% | 3.70 s | +| Vertical orbit, radius 400, speed 300 | 100.0% | 100.0% | 0.00 s | +| Tilted orbit, radius 800, speed 300 | 17.6% | 17.3% | 1.60 s | +| Straight crossing, speed 150 | 34.5% | 13.8% | 42.88 s | +| Weaving away | 7.5% | 7.5% | 3.67 s | +| Straight away, speed 280 | 100.0% | 100.0% | 0.00 s | + +Every case remains inside laser range throughout its measurement window. The vertical orbit requires pitch without roll and tracks well. Horizontal and tilted paths expose the coupled steering failure. + +The straight-crossing case first enters firing geometry at 1.98 seconds. Later, it settles around 10.9 degrees off target. It accumulates 10.7 full turns of absolute roll travel per minute. This is a persistent miss after successful acquisition. + +**Recommended change:** evaluate the existing hard bank gate for the combat pilot. The experiment passes `0.1` radians, about 5.7 degrees, as `bankToTurn`'s final argument. This withholds the pitch request until the bank error falls below that threshold. The current rate ramp still applies. + +The experiment changes only that argument. Lead, throttle, flight limits, and the gun cone retain their shipped values. + +| Measurement | Shipped controller | Hard bank gate | +| --- | ---: | ---: | +| Initial grid mean, 30-second runs | 68.9% | 98.3% | +| Initial grid mean, 60-second runs | 64.9% | 97.7% | +| Separate grid mean, 45-second runs | 56.7% | 98.1% | +| Separate grid mean, 90-second runs | 53.9% | 98.1% | +| Separate grid worst case, 90-second runs | 3.8% | 81.3% | + +No case in the separate grid lost more than one percentage point of tracking. However, the longest initial acquisition increased from 4.90 to 5.47 seconds. The candidate also retains a 9.97-second gap in the original straight-crossing case. + +Treat `0.1` as a promising candidate, not a final calibrated value. Check neighbouring thresholds, more initial orientations, and actual NPC fights before release. Include target changes and close passes. Preserve the player's pitch-and-roll flight model. + +## 2. High priority: make tracking tests reject weak tracking + +**Evidence:** [`scripted-co-pilot.test.ts:157`](../test/scripted-co-pilot.test.ts#L157), [`scripted-co-pilot.test.ts:373`](../test/scripted-co-pilot.test.ts#L373). + +The existing circling test accepts anything above **20%** time inside the gun cone. It passes at roughly 29% and 32%. That threshold protects an earlier improvement but accepts poor tracking today. + +The straight-crossing test has two further weaknesses: + +- It moves the target sideways without aligning its quaternion with that motion. The controller derives velocity from that quaternion, so its predicted motion differs from the test path. +- It measures a fixed `0.1`-radian angle instead of the actual gun cone. +- It stops after 20 seconds. The corrected 60-second probe exposes a sustained miss that a short run can conceal. + +**Recommended change:** make target position, orientation, and speed consistent in every motion fixture. Measure actual firing geometry, acquisition time, longest tracking gap, and roll travel separately. Include horizontal, vertical, and tilted paths. Set acceptance limits per case after validating the controller change. A high average must not hide a case that loses the target for 40 seconds. + +## 3. Medium priority: refine lead after the bank problem is fixed + +**Evidence:** [`scripted-co-pilot.ts:180`](../src/game/scripted-co-pilot.ts#L180). + +The aim point uses target velocity multiplied by the remaining angle and `PURSUIT_LEAD_GAIN`. The lead depends on heading error, but not on whether the target flies straight or turns. + +Removing lead globally is a poor remedy. In the fast horizontal orbit, the shipped controller falls from 32.2% to 4.1% tracking without lead. Reducing the gain to `0.5` also performs poorly across the first grid. + +After the hard gate, the tradeoff becomes clearer: + +| 60-second case | Gate with current lead | Gate without lead | +| --- | ---: | ---: | +| Fast horizontal orbit | 90.0% | 46.8% | +| Straight crossing | 74.3% | 98.7% | +| Weaving away | 99.7% | 87.0% | + +**Recommended change:** keep the current lead for the first bank-control experiment. Then investigate a separate rule for settled pursuit of a straight target. Target angular motion and relative velocity are useful candidate inputs. These are follow-up hypotheses; this review does not establish a final lead rule. + +## 4. Medium priority: make target commitment reflect progress + +**Evidence:** [`scripted-co-pilot.ts:143`](../src/game/scripted-co-pilot.ts#L143), [`threat-lock.ts:75`](../src/game/threat-lock.ts#L75). + +The computer treats a target within `ENGAGED_CONE`, about 34 degrees, as an attack in progress. That condition blocks a target switch. It checks neither gun range nor recent firing geometry. + +A controller-level reproduction holds a target 3,000 units away and 23 degrees off the nose. A second hostile sits 500 units directly ahead. After ten seconds, the existing lock still refuses the easy shot. A fresh controller chooses it. This reproduction holds geometry fixed to test the selection rule alone. + +**Recommended change:** expose the held target and the reason it remains selected in probe output. After correcting steering, measure whether a timed lack of progress should release the commitment. Retain the existing hold time and switching margin unless the measurements justify a change. Frequent target switching would introduce another tracking failure. + +## 5. Medium priority: preserve the correct controller state at handover + +**Evidence:** [`scripted-co-pilot.ts:83`](../src/game/scripted-co-pilot.ts#L83), [`scripted-co-pilot.ts:103`](../src/game/scripted-co-pilot.ts#L103), [`persistence.ts:141`](../src/game/persistence.ts#L141). + +Three state defects affect tracking after an interruption: + +- Manual override returns without clearing the stored turn rates. In a headless Game, the player stops rolling during manual flight. Re-engagement restores an old roll at **−1.13 rad/s**, despite a target directly ahead. +- `reset()` leaves `steerMem.side` unchanged. A reset controller can choose the opposite bank from a fresh controller at identical geometry. +- Persistence saves the dormant trained controller, not the scripted controller's rates or steering memory. A fresh Game restores the player's saved roll correctly, then replaces it on the next step. The reproduction changes a continued **−1.48 rad/s** roll to **−0.17 rad/s**. + +**Recommended change:** define one handover contract. Seed a resumed controller from the player's current rates. Clear engagement-specific steering memory when an engagement ends. Save the scripted controller state required to resume a turn. Test continued flight after restore, not just equality immediately after restore. + +## Other confirmed findings + +These are separate from the tracking recommendation: + +- **Automatic fire can use the wrong mount.** A rear-view command leaves combat steering engaged. The computer aims at a front pirate but fires the rear laser. In a one-frame Game reproduction, it hits a trader behind the player and changes legal status to Offender. Pass an explicit mount with the automatic shot request, or suppress that request outside its intended view. See [`flight.ts:351`](../src/game/flight.ts#L351) and [`combat-player.ts:34`](../src/game/combat-player.ts#L34). +- **Automatic fire does not check the first object the shot will hit.** A trader between the player and a pirate takes the automatic shot. The reproduction again changes legal status to Offender. Use the shared shot trace before authorizing an automatic shot. Preserve explicitly selected targets and the human trigger's own behavior. See [`scripted-co-pilot.ts:215`](../src/game/scripted-co-pilot.ts#L215) and [`shot.ts`](../src/game/shot.ts). +- **Missile defence ends when no ship target remains.** With a hostile missile still inbound, `combatSteer` reports `AREA CLEAR` and requests no E.C.M. Evaluate the missile response independently of whether steering has a ship target. See [`scripted-co-pilot.ts:151`](../src/game/scripted-co-pilot.ts#L151) and [`autopilot.ts:270`](../src/game/autopilot.ts#L270). + +## Evidence and reproduction + +The focused existing suite passed **87 assertions**. It covers the scripted co-pilot, steering, targets, threat lock, and aim integration. + +The review artifacts contain the independent experiments: + +- [Tracking probe](reviews/combat-computer-2026-09-12/probe.mjs) +- [426 tracking measurements](reviews/combat-computer-2026-09-12/measurements.jsonl), including lead-removal and reduced-lead experiments +- [State, selection, and firing reproductions](reviews/combat-computer-2026-09-12/integration-probe.mjs) +- [Integration results](reviews/combat-computer-2026-09-12/integration-results.jsonl) + +Run these from the repository root: + +```sh +node --experimental-strip-types --no-warnings docs/reviews/combat-computer-2026-09-12/probe.mjs +node --experimental-strip-types --no-warnings docs/reviews/combat-computer-2026-09-12/probe.mjs --hard-gate +node --experimental-strip-types --no-warnings docs/reviews/combat-computer-2026-09-12/probe.mjs --holdout +node --experimental-strip-types --no-warnings docs/reviews/combat-computer-2026-09-12/probe.mjs --holdout --hard-gate +node --experimental-strip-types --no-warnings docs/reviews/combat-computer-2026-09-12/integration-probe.mjs +``` + +The hard-gate option creates a temporary controller module and removes it after import. It does not modify the game's source. The checked-in probe reproduced the original baseline and separate candidate results byte for byte. + +The probes measure control geometry without shots, damage, or an opponent that reacts to the player. They establish a steering defect and a strong candidate improvement. Actual combat balance and cockpit feel still require validation when that improvement is implemented. diff --git a/docs/reviews/combat-computer-2026-09-12/integration-probe.mjs b/docs/reviews/combat-computer-2026-09-12/integration-probe.mjs new file mode 100644 index 00000000..2ca283a3 --- /dev/null +++ b/docs/reviews/combat-computer-2026-09-12/integration-probe.mjs @@ -0,0 +1,160 @@ +// Review reproductions for target commitment, controller state, and automatic fire. +// Every Game operation runs inside withoutSaving(). Production code is unchanged. +import * as THREE from 'three'; +import { Game } from '../../../src/game/game.ts'; +import { headlessShell } from '../../../src/engine/shell.ts'; +import { withoutSaving } from '../../../src/game/storage.ts'; +import { seedWorld } from '../../../src/game/rng.ts'; +import { pickTarget } from '../../../src/game/targets.ts'; +import { ScriptedCoPilot } from '../../../src/game/scripted-co-pilot.ts'; +import { CombatComputer } from '../../../src/game/combat-computer.ts'; +import { Autopilot } from '../../../src/game/autopilot.ts'; +import { Ordnance } from '../../../src/game/ordnance.ts'; +import { dismissBriefing } from '../../../test/harness.ts'; + +const dt = 1 / 60; +const output = (name, values) => console.log(JSON.stringify({ name, ...values })); +function open() { + seedWorld(20260912); + const g = new Game(() => headlessShell()); + dismissBriefing(g); + g.launch(); + for (let f = 0; f < 400; f++) g.step(dt, f * dt); + g.state.world.clearNpcs(); + g.state.player.position.set(0, 40000, 0); + g.state.player.quaternion.identity(); + g.state.player.speed = 0; + g.state.player.pitchRate = 0; + g.state.player.rollRate = 0; + Object.assign(g.state.session, { + ccEngaged: false, dcEngaged: false, dockTrial: false, dockRails: false, + handFlown: false, torusEngaged: false, course: null, view: 0, + }); + return g; +} +function spawn(g, role, x, z, seed = 1) { + const n = g.state.world.spawn(role, new THREE.Vector3(x, 40000, z), seed); + n.state.speed = 0; + return n; +} +function run(g, frames) { for (let f = 0; f < frames; f++) g.step(dt, 20 + f * dt); } + +withoutSaving(() => { + // The public view-change command while the automatic trigger has a front target. + { + const g = open(); + Object.assign(g.state.commander.equipment, { combatComputer: true, rearLaser: true }); + const pirate = spawn(g, 'pirate', 0, -1000); + const trader = spawn(g, 'trader', 0, 1000, 2); + g.state.session.ccEngaged = true; + g.input.injectPress('Digit2'); + run(g, 1); + output('rear_view_autofire', { + view: g.state.session.view, engaged: g.state.session.ccEngaged, + laserTemp: g.state.sys.laserTemp, legalStatus: g.state.commander.legalStatus, + traderProvoked: trader.state.provokedByPlayer, + pirateProvoked: pirate.state.provokedByPlayer, + }); + } + // A lawful ship obstructs the target, with the correct front mount selected. + { + const g = open(); + g.state.commander.equipment.combatComputer = true; + const pirate = spawn(g, 'pirate', 0, -1500); + const trader = spawn(g, 'trader', 0, -700, 2); + run(g, 1); + output('obstructed_autofire', { + laserTemp: g.state.sys.laserTemp, legalStatus: g.state.commander.legalStatus, + traderProvoked: trader.state.provokedByPlayer, + pirateProvoked: pirate.state.provokedByPlayer, + }); + } + // A saved in-progress turn versus its first step in a fresh game instance. + { + const g = open(); + const rock = spawn(g, 'asteroid', 1600, -1200); + pickTarget(g.state.world.npcs, rock); + run(g, 12); + const snap = g.captureSnapshot(); + run(g, 1); + const continued = g.captureSnapshot().player; + const fresh = open(); + fresh.restoreSnapshot(structuredClone(snap)); + const roundTripSame = JSON.stringify(fresh.captureSnapshot().player) === JSON.stringify(snap.player); + run(fresh, 1); + const restored = fresh.captureSnapshot().player; + output('save_mid_turn', { saved: snap.player, savedComputer: snap.combatComputer, + roundTripSame, continued, restored, + orientationDifference: new THREE.Quaternion(...continued.quat).angleTo(new THREE.Quaternion(...restored.quat)), + }); + } + // An inbound missile survives its launcher, so there is no ship to target. + { + const g = open(); + Object.assign(g.state.commander.equipment, { combatComputer: true, ecm: true }); + g.state.session.ccEngaged = true; + const ordnance = new Ordnance(g.state.world); + ordnance.launchHostile(g.state.player.position.clone().add(new THREE.Vector3(0, 0, -1000))); + const auto = new Autopilot(g.state, new CombatComputer()); + const result = auto.combatSteer(dt, false, ordnance.hostileMissilePos); + output('missile_without_ship', { inbound: ordnance.missileInbound, + ecm: result.ecm, engaged: g.state.session.ccEngaged, events: result.events }); + } + // Manual override and re-engagement retain the old turn rates. + { + const g = open(); + const rock = spawn(g, 'asteroid', 1600, -1200); + const cp = new ScriptedCoPilot(); + let last; + for (let i = 0; i < 30; i++) last = cp.step(dt, g.state.player, [rock], 0, false, null, Infinity, rock); + cp.step(dt, g.state.player, [rock], 0, true, null, Infinity, rock); + rock.object.position.set(0, 40000, -1000); + const resumed = cp.step(dt, g.state.player, [rock], 0, false, null, Infinity, rock); + const fresh = new ScriptedCoPilot().step(dt, g.state.player, [rock], 0, false, null, Infinity, rock); + output('reenage_after_manual_override', { oldDemand: last.demand, resumed: resumed.demand, fresh: fresh.demand }); + } + // reset() also leaves the sticky steering side from the previous engagement. + { + const g = open(); + const rock = spawn(g, 'asteroid', 0, -1000); + rock.object.position.y = 39000; + const cp = new ScriptedCoPilot(); + cp.step(dt, g.state.player, [rock], 0, false, null, Infinity, rock); + cp.reset(); + rock.object.position.set(1000, 40000, -1000); + const reset = cp.step(dt, g.state.player, [rock], 0, false, null, Infinity, rock); + const fresh = new ScriptedCoPilot().step(dt, g.state.player, [rock], 0, false, null, Infinity, rock); + output('reset_retains_steering_side', { reset: reset.demand, fresh: fresh.demand }); + } + // Public Game input: a manual pause lets the real ship stop its roll. + { + const g = open(); + const rock = spawn(g, 'asteroid', 1600, -1200); + pickTarget(g.state.world.npcs, rock); + run(g, 12); + const oldRoll = g.state.player.rollRate; + g.input.press('ArrowUp'); + run(g, 1); + g.input.release('ArrowUp'); + run(g, 180); + rock.object.position.copy(g.state.player.position).addScaledVector(g.state.player.getForward(new THREE.Vector3()), 1000); + g.state.player.speed = 0; + const before = g.state.player.rollRate; + g.state.session.handFlown = false; + run(g, 1); + output('game_reengagement', { oldRoll, before, after: g.state.player.rollRate }); + } + // The automatic lock veto needs no firing solution or recent progress. + { + const g = open(); + const a = spawn(g, 'pirate', 3000 * Math.sin(.4), -3000 * Math.cos(.4)); + const b = spawn(g, 'pirate', 0, -500, 2); + const cp = new ScriptedCoPilot(); + cp.step(dt, g.state.player, [a], 0, false, null); + let result; + for (let f = 0; f < 600; f++) result = cp.step(dt, g.state.player, [a,b], 0, false, null); + const fresh = new ScriptedCoPilot().step(dt, g.state.player, [a,b], 0, false, null); + output('commit_without_gun_solution', { seconds: 10, heldOriginal: cp.lock.held === a, + heldFire: result.demand.fire, freshFire: fresh.demand.fire }); + } +}); diff --git a/docs/reviews/combat-computer-2026-09-12/integration-results.jsonl b/docs/reviews/combat-computer-2026-09-12/integration-results.jsonl new file mode 100644 index 00000000..84a670cb --- /dev/null +++ b/docs/reviews/combat-computer-2026-09-12/integration-results.jsonl @@ -0,0 +1,8 @@ +{"name":"rear_view_autofire","view":1,"engaged":true,"laserTemp":0.06333333333333334,"legalStatus":1,"traderProvoked":true,"pirateProvoked":false} +{"name":"obstructed_autofire","laserTemp":0.06333333333333334,"legalStatus":1,"traderProvoked":true,"pirateProvoked":false} +{"name":"save_mid_turn","saved":{"pos":[0.0006983733735677464,40000.006687334244,-4.766658652631075],"quat":[0.0017085295533655355,-0.00006898670940893003,-0.0856751049233923,0.996321661193796],"speed":43.99999999999999,"pitchRate":0.05471639936873287,"rollRate":-1.4076069681169112},"savedComputer":{"pitch":0,"roll":0,"timer":0,"control":null},"roundTripSame":true,"continued":{"pos":[0.0012139822213510032,40000.010256999616,-5.561094909951504],"quat":[0.0022676317393247798,-0.00010286733648966472,-0.09795979856614058,0.9951877838526191],"speed":47.66666666666666,"pitchRate":0.06732970254606363,"rollRate":-1.4804336411255932},"restored":{"pos":[0.001077508095081397,40000.0095946651,-5.56109768678839],"quat":[0.0018436180576337038,-0.00007841092720803403,-0.08705880104950238,0.9962014656102487],"speed":47.66666666666666,"pitchRate":0.01626108672110719,"rollRate":-0.1666677443079756},"orientationDifference":0.02191263417248067} +{"name":"missile_without_ship","inbound":true,"ecm":false,"engaged":false,"events":[{"kind":"message","text":"AREA CLEAR","seconds":3}]} +{"name":"reenage_after_manual_override","oldDemand":{"pitchRate":7.758100849483098e-17,"rollRate":-2.1844724465368413,"throttle":1,"fire":false},"resumed":{"pitchRate":0,"rollRate":-1.7475783381680894,"throttle":1,"fire":true},"fresh":{"pitchRate":0,"rollRate":0,"throttle":1,"fire":true}} +{"name":"reset_retains_steering_side","reset":{"pitchRate":-5.919164468048283e-18,"rollRate":0.1666677443079756,"throttle":1,"fire":false},"fresh":{"pitchRate":5.919164468048283e-18,"rollRate":-0.1666677443079756,"throttle":1,"fire":false}} +{"name":"game_reengagement","oldRoll":-1.4076069681169112,"before":0,"after":-1.1260858199586763} +{"name":"commit_without_gun_solution","seconds":10,"heldOriginal":true,"heldFire":false,"freshFire":true} diff --git a/docs/reviews/combat-computer-2026-09-12/measurements.jsonl b/docs/reviews/combat-computer-2026-09-12/measurements.jsonl new file mode 100644 index 00000000..372df66b --- /dev/null +++ b/docs/reviews/combat-computer-2026-09-12/measurements.jsonl @@ -0,0 +1,426 @@ +{"grid":"initial","variant":"baseline","name":"horizontal-r400-v150","seconds":30,"radius":15,"firstLock":"2.42","onGun":100,"requestFire":100,"inRange":100,"medianError":1.91,"p95Error":2.05,"longestGap":0,"medianDistance":383,"minHullGap":296.1,"rollsPerMinute":0.1,"rollReversals":0,"pitchReversals":0,"maxRoll":0.073} +{"grid":"initial","variant":"baseline","name":"horizontal-r400-v300","seconds":30,"radius":15,"firstLock":"3.28","onGun":28.5,"requestFire":29.1,"inRange":100,"medianError":6.22,"p95Error":17.97,"longestGap":3.7,"medianDistance":422,"minHullGap":296.1,"rollsPerMinute":8.94,"rollReversals":20,"pitchReversals":0,"maxRoll":2.01} +{"grid":"initial","variant":"baseline","name":"horizontal-r800-v150","seconds":30,"radius":15,"firstLock":"2.23","onGun":100,"requestFire":100,"inRange":100,"medianError":2.37,"p95Error":2.48,"longestGap":0,"medianDistance":516,"minHullGap":493.3,"rollsPerMinute":0.15,"rollReversals":0,"pitchReversals":0,"maxRoll":0.098} +{"grid":"initial","variant":"baseline","name":"horizontal-r800-v300","seconds":30,"radius":15,"firstLock":"2.65","onGun":81,"requestFire":81.4,"inRange":100,"medianError":1.98,"p95Error":7.51,"longestGap":1.38,"medianDistance":512,"minHullGap":492.8,"rollsPerMinute":4.21,"rollReversals":15,"pitchReversals":0,"maxRoll":1.244} +{"grid":"initial","variant":"baseline","name":"horizontal-r1600-v150","seconds":30,"radius":15,"firstLock":"2.05","onGun":100,"requestFire":100,"inRange":100,"medianError":2.87,"p95Error":2.98,"longestGap":0,"medianDistance":515,"minHullGap":492.5,"rollsPerMinute":0.27,"rollReversals":0,"pitchReversals":0,"maxRoll":0.119} +{"grid":"initial","variant":"baseline","name":"horizontal-r1600-v300","seconds":30,"radius":15,"firstLock":"2.22","onGun":72.3,"requestFire":72.5,"inRange":100,"medianError":2.72,"p95Error":10.83,"longestGap":2.52,"medianDistance":512,"minHullGap":492,"rollsPerMinute":4.31,"rollReversals":8,"pitchReversals":1,"maxRoll":1.644} +{"grid":"initial","variant":"baseline","name":"vertical-r400-v150","seconds":30,"radius":15,"firstLock":"1.87","onGun":100,"requestFire":100,"inRange":100,"medianError":1.92,"p95Error":2.05,"longestGap":0,"medianDistance":383,"minHullGap":298,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"baseline","name":"vertical-r400-v300","seconds":30,"radius":15,"firstLock":"2.58","onGun":100,"requestFire":100,"inRange":100,"medianError":1.04,"p95Error":1.29,"longestGap":0,"medianDistance":425,"minHullGap":298,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"baseline","name":"vertical-r800-v150","seconds":30,"radius":15,"firstLock":"1.67","onGun":100,"requestFire":100,"inRange":100,"medianError":2.37,"p95Error":2.49,"longestGap":0,"medianDistance":516,"minHullGap":493.3,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"baseline","name":"vertical-r800-v300","seconds":30,"radius":15,"firstLock":"2.03","onGun":100,"requestFire":100,"inRange":100,"medianError":1.74,"p95Error":1.9,"longestGap":0,"medianDistance":509,"minHullGap":493,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"baseline","name":"vertical-r1600-v150","seconds":30,"radius":15,"firstLock":"1.52","onGun":100,"requestFire":100,"inRange":100,"medianError":2.87,"p95Error":2.98,"longestGap":0,"medianDistance":515,"minHullGap":492.5,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"baseline","name":"vertical-r1600-v300","seconds":30,"radius":15,"firstLock":"1.65","onGun":100,"requestFire":100,"inRange":100,"medianError":2.49,"p95Error":2.58,"longestGap":0,"medianDistance":513,"minHullGap":497.2,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"baseline","name":"tilted-r400-v150","seconds":30,"radius":15,"firstLock":"2.10","onGun":97.2,"requestFire":97.5,"inRange":100,"medianError":1.99,"p95Error":3.51,"longestGap":0.52,"medianDistance":392,"minHullGap":333.2,"rollsPerMinute":2.16,"rollReversals":9,"pitchReversals":0,"maxRoll":1.182} +{"grid":"initial","variant":"baseline","name":"tilted-r400-v300","seconds":30,"radius":15,"firstLock":"2.40","onGun":33.1,"requestFire":31.9,"inRange":100,"medianError":5.39,"p95Error":10.92,"longestGap":1.5,"medianDistance":418,"minHullGap":335.9,"rollsPerMinute":9.12,"rollReversals":20,"pitchReversals":0,"maxRoll":2.232} +{"grid":"initial","variant":"baseline","name":"tilted-r800-v150","seconds":30,"radius":15,"firstLock":"2.07","onGun":19.8,"requestFire":19.8,"inRange":100,"medianError":8.44,"p95Error":11.79,"longestGap":2.45,"medianDistance":517,"minHullGap":496.7,"rollsPerMinute":9.81,"rollReversals":5,"pitchReversals":1,"maxRoll":1.803} +{"grid":"initial","variant":"baseline","name":"tilted-r800-v300","seconds":30,"radius":15,"firstLock":"2.23","onGun":17.6,"requestFire":17.4,"inRange":100,"medianError":8.43,"p95Error":13.04,"longestGap":1.58,"medianDistance":516,"minHullGap":496.7,"rollsPerMinute":9.53,"rollReversals":11,"pitchReversals":0,"maxRoll":2.099} +{"grid":"initial","variant":"baseline","name":"tilted-r1600-v150","seconds":30,"radius":15,"firstLock":"2.32","onGun":33.9,"requestFire":34.1,"inRange":100,"medianError":5.21,"p95Error":10.26,"longestGap":3.57,"medianDistance":517,"minHullGap":498.7,"rollsPerMinute":7.57,"rollReversals":3,"pitchReversals":4,"maxRoll":1.527} +{"grid":"initial","variant":"baseline","name":"tilted-r1600-v300","seconds":30,"radius":15,"firstLock":"2.40","onGun":22.1,"requestFire":22.2,"inRange":100,"medianError":8.01,"p95Error":12.24,"longestGap":2.5,"medianDistance":515,"minHullGap":494.4,"rollsPerMinute":9.13,"rollReversals":1,"pitchReversals":6,"maxRoll":1.991} +{"grid":"initial","variant":"baseline","name":"straight-crossing","seconds":30,"radius":15,"firstLock":"1.98","onGun":34.5,"requestFire":34.1,"inRange":100,"medianError":4.57,"p95Error":10.76,"longestGap":12.88,"medianDistance":516,"minHullGap":292.1,"rollsPerMinute":7.31,"rollReversals":1,"pitchReversals":0,"maxRoll":1.35} +{"grid":"initial","variant":"baseline","name":"weaving-away","seconds":30,"radius":15,"firstLock":"0.00","onGun":7.5,"requestFire":7,"inRange":100,"medianError":9.37,"p95Error":12.26,"longestGap":3.67,"medianDistance":516,"minHullGap":497.9,"rollsPerMinute":11.42,"rollReversals":5,"pitchReversals":0,"maxRoll":1.892} +{"grid":"initial","variant":"baseline","name":"straight-away","seconds":30,"radius":15,"firstLock":"0.00","onGun":100,"requestFire":100,"inRange":100,"medianError":0,"p95Error":0,"longestGap":0,"medianDistance":510,"minHullGap":490,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"baseline","name":"horizontal-r400-v150","seconds":60,"radius":15,"firstLock":"2.42","onGun":100,"requestFire":100,"inRange":100,"medianError":1.92,"p95Error":2.07,"longestGap":0,"medianDistance":411,"minHullGap":296.1,"rollsPerMinute":0.06,"rollReversals":0,"pitchReversals":0,"maxRoll":0.073} +{"grid":"initial","variant":"baseline","name":"horizontal-r400-v300","seconds":60,"radius":15,"firstLock":"3.28","onGun":32.2,"requestFire":31.2,"inRange":100,"medianError":5.55,"p95Error":16.7,"longestGap":3.7,"medianDistance":409,"minHullGap":296.1,"rollsPerMinute":8.62,"rollReversals":50,"pitchReversals":0,"maxRoll":2.061} +{"grid":"initial","variant":"baseline","name":"horizontal-r800-v150","seconds":60,"radius":15,"firstLock":"2.23","onGun":100,"requestFire":100,"inRange":100,"medianError":2.4,"p95Error":2.51,"longestGap":0,"medianDistance":511,"minHullGap":493.2,"rollsPerMinute":0.07,"rollReversals":0,"pitchReversals":0,"maxRoll":0.098} +{"grid":"initial","variant":"baseline","name":"horizontal-r800-v300","seconds":60,"radius":15,"firstLock":"2.65","onGun":42.6,"requestFire":42.8,"inRange":100,"medianError":5.07,"p95Error":12.96,"longestGap":1.6,"medianDistance":514,"minHullGap":492.8,"rollsPerMinute":7.44,"rollReversals":31,"pitchReversals":0,"maxRoll":2.058} +{"grid":"initial","variant":"baseline","name":"horizontal-r1600-v150","seconds":60,"radius":15,"firstLock":"2.05","onGun":100,"requestFire":100,"inRange":100,"medianError":2.92,"p95Error":3,"longestGap":0,"medianDistance":513,"minHullGap":492.3,"rollsPerMinute":0.25,"rollReversals":0,"pitchReversals":0,"maxRoll":0.119} +{"grid":"initial","variant":"baseline","name":"horizontal-r1600-v300","seconds":60,"radius":15,"firstLock":"2.22","onGun":40.8,"requestFire":40.8,"inRange":100,"medianError":5.03,"p95Error":12.03,"longestGap":2.52,"medianDistance":514,"minHullGap":492,"rollsPerMinute":7.51,"rollReversals":8,"pitchReversals":10,"maxRoll":1.729} +{"grid":"initial","variant":"baseline","name":"vertical-r400-v150","seconds":60,"radius":15,"firstLock":"1.87","onGun":100,"requestFire":100,"inRange":100,"medianError":1.92,"p95Error":2.06,"longestGap":0,"medianDistance":410,"minHullGap":298,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"baseline","name":"vertical-r400-v300","seconds":60,"radius":15,"firstLock":"2.58","onGun":100,"requestFire":100,"inRange":100,"medianError":1.03,"p95Error":1.28,"longestGap":0,"medianDistance":409,"minHullGap":298,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"baseline","name":"vertical-r800-v150","seconds":60,"radius":15,"firstLock":"1.67","onGun":100,"requestFire":100,"inRange":100,"medianError":2.4,"p95Error":2.51,"longestGap":0,"medianDistance":511,"minHullGap":493.2,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"baseline","name":"vertical-r800-v300","seconds":60,"radius":15,"firstLock":"2.03","onGun":100,"requestFire":100,"inRange":100,"medianError":1.74,"p95Error":1.91,"longestGap":0,"medianDistance":509,"minHullGap":493,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"baseline","name":"vertical-r1600-v150","seconds":60,"radius":15,"firstLock":"1.52","onGun":100,"requestFire":100,"inRange":100,"medianError":2.9,"p95Error":3,"longestGap":0,"medianDistance":513,"minHullGap":492.3,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"baseline","name":"vertical-r1600-v300","seconds":60,"radius":15,"firstLock":"1.65","onGun":100,"requestFire":100,"inRange":100,"medianError":2.49,"p95Error":2.58,"longestGap":0,"medianDistance":515,"minHullGap":496,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"baseline","name":"tilted-r400-v150","seconds":60,"radius":15,"firstLock":"2.10","onGun":98.9,"requestFire":99,"inRange":100,"medianError":1.95,"p95Error":2.7,"longestGap":0.52,"medianDistance":410,"minHullGap":333.2,"rollsPerMinute":1.21,"rollReversals":9,"pitchReversals":0,"maxRoll":1.182} +{"grid":"initial","variant":"baseline","name":"tilted-r400-v300","seconds":60,"radius":15,"firstLock":"2.40","onGun":28.3,"requestFire":27,"inRange":100,"medianError":5.79,"p95Error":16.52,"longestGap":5.02,"medianDistance":409,"minHullGap":335.9,"rollsPerMinute":9.42,"rollReversals":49,"pitchReversals":0,"maxRoll":2.314} +{"grid":"initial","variant":"baseline","name":"tilted-r800-v150","seconds":60,"radius":15,"firstLock":"2.07","onGun":20.2,"requestFire":20.2,"inRange":100,"medianError":8.38,"p95Error":11.73,"longestGap":2.48,"medianDistance":518,"minHullGap":496.7,"rollsPerMinute":9.7,"rollReversals":8,"pitchReversals":8,"maxRoll":1.803} +{"grid":"initial","variant":"baseline","name":"tilted-r800-v300","seconds":60,"radius":15,"firstLock":"2.23","onGun":17.3,"requestFire":17.2,"inRange":100,"medianError":8.52,"p95Error":13.08,"longestGap":1.6,"medianDistance":515,"minHullGap":496.4,"rollsPerMinute":9.62,"rollReversals":27,"pitchReversals":0,"maxRoll":2.099} +{"grid":"initial","variant":"baseline","name":"tilted-r1600-v150","seconds":60,"radius":15,"firstLock":"2.32","onGun":40.5,"requestFire":40.8,"inRange":100,"medianError":4.24,"p95Error":9.2,"longestGap":3.57,"medianDistance":516,"minHullGap":494.9,"rollsPerMinute":6.87,"rollReversals":11,"pitchReversals":6,"maxRoll":1.527} +{"grid":"initial","variant":"baseline","name":"tilted-r1600-v300","seconds":60,"radius":15,"firstLock":"2.40","onGun":20.3,"requestFire":20.3,"inRange":100,"medianError":8.43,"p95Error":12.09,"longestGap":2.5,"medianDistance":515,"minHullGap":493.9,"rollsPerMinute":9.5,"rollReversals":1,"pitchReversals":15,"maxRoll":1.991} +{"grid":"initial","variant":"baseline","name":"straight-crossing","seconds":60,"radius":15,"firstLock":"1.98","onGun":13.8,"requestFire":13.6,"inRange":100,"medianError":10.9,"p95Error":10.98,"longestGap":42.88,"medianDistance":516,"minHullGap":292.1,"rollsPerMinute":10.7,"rollReversals":1,"pitchReversals":0,"maxRoll":1.364} +{"grid":"initial","variant":"baseline","name":"weaving-away","seconds":60,"radius":15,"firstLock":"0.00","onGun":7.5,"requestFire":7.1,"inRange":100,"medianError":9.39,"p95Error":12.27,"longestGap":3.67,"medianDistance":516,"minHullGap":497.9,"rollsPerMinute":11.38,"rollReversals":13,"pitchReversals":0,"maxRoll":1.892} +{"grid":"initial","variant":"baseline","name":"straight-away","seconds":60,"radius":15,"firstLock":"0.00","onGun":100,"requestFire":100,"inRange":100,"medianError":0,"p95Error":0,"longestGap":0,"medianDistance":510,"minHullGap":490,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"hard-gate","name":"horizontal-r400-v150","seconds":30,"radius":15,"firstLock":"3.48","onGun":100,"requestFire":100,"inRange":100,"medianError":1.91,"p95Error":2.05,"longestGap":0,"medianDistance":383,"minHullGap":295.8,"rollsPerMinute":0.01,"rollReversals":0,"pitchReversals":0,"maxRoll":0.005} +{"grid":"initial","variant":"hard-gate","name":"horizontal-r400-v300","seconds":30,"radius":15,"firstLock":"4.92","onGun":91.9,"requestFire":84.8,"inRange":100,"medianError":1.63,"p95Error":4.34,"longestGap":0.27,"medianDistance":422,"minHullGap":295.8,"rollsPerMinute":1.57,"rollReversals":26,"pitchReversals":0,"maxRoll":0.309} +{"grid":"initial","variant":"hard-gate","name":"horizontal-r800-v150","seconds":30,"radius":15,"firstLock":"3.18","onGun":100,"requestFire":100,"inRange":100,"medianError":2.37,"p95Error":2.48,"longestGap":0,"medianDistance":516,"minHullGap":493.5,"rollsPerMinute":0.02,"rollReversals":0,"pitchReversals":0,"maxRoll":0.013} +{"grid":"initial","variant":"hard-gate","name":"horizontal-r800-v300","seconds":30,"radius":15,"firstLock":"3.72","onGun":100,"requestFire":100,"inRange":100,"medianError":1.73,"p95Error":1.89,"longestGap":0,"medianDistance":511,"minHullGap":492.9,"rollsPerMinute":0.44,"rollReversals":5,"pitchReversals":0,"maxRoll":0.194} +{"grid":"initial","variant":"hard-gate","name":"horizontal-r1600-v150","seconds":30,"radius":15,"firstLock":"2.98","onGun":100,"requestFire":100,"inRange":100,"medianError":2.86,"p95Error":2.98,"longestGap":0,"medianDistance":515,"minHullGap":492.5,"rollsPerMinute":0.04,"rollReversals":0,"pitchReversals":0,"maxRoll":0.022} +{"grid":"initial","variant":"hard-gate","name":"horizontal-r1600-v300","seconds":30,"radius":15,"firstLock":"3.20","onGun":100,"requestFire":100,"inRange":100,"medianError":2.48,"p95Error":2.58,"longestGap":0,"medianDistance":513,"minHullGap":497.2,"rollsPerMinute":0.29,"rollReversals":1,"pitchReversals":0,"maxRoll":0.15} +{"grid":"initial","variant":"hard-gate","name":"vertical-r400-v150","seconds":30,"radius":15,"firstLock":"1.87","onGun":100,"requestFire":100,"inRange":100,"medianError":1.92,"p95Error":2.05,"longestGap":0,"medianDistance":383,"minHullGap":298,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"hard-gate","name":"vertical-r400-v300","seconds":30,"radius":15,"firstLock":"2.58","onGun":100,"requestFire":100,"inRange":100,"medianError":1.04,"p95Error":1.29,"longestGap":0,"medianDistance":425,"minHullGap":298,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"hard-gate","name":"vertical-r800-v150","seconds":30,"radius":15,"firstLock":"1.67","onGun":100,"requestFire":100,"inRange":100,"medianError":2.37,"p95Error":2.49,"longestGap":0,"medianDistance":516,"minHullGap":493.3,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"hard-gate","name":"vertical-r800-v300","seconds":30,"radius":15,"firstLock":"2.03","onGun":100,"requestFire":100,"inRange":100,"medianError":1.74,"p95Error":1.9,"longestGap":0,"medianDistance":509,"minHullGap":493,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"hard-gate","name":"vertical-r1600-v150","seconds":30,"radius":15,"firstLock":"1.52","onGun":100,"requestFire":100,"inRange":100,"medianError":2.87,"p95Error":2.98,"longestGap":0,"medianDistance":515,"minHullGap":492.5,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"hard-gate","name":"vertical-r1600-v300","seconds":30,"radius":15,"firstLock":"1.65","onGun":100,"requestFire":100,"inRange":100,"medianError":2.49,"p95Error":2.58,"longestGap":0,"medianDistance":513,"minHullGap":497.2,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"hard-gate","name":"tilted-r400-v150","seconds":30,"radius":15,"firstLock":"3.20","onGun":100,"requestFire":100,"inRange":100,"medianError":1.91,"p95Error":2.06,"longestGap":0,"medianDistance":391,"minHullGap":327.8,"rollsPerMinute":0.56,"rollReversals":0,"pitchReversals":0,"maxRoll":0.108} +{"grid":"initial","variant":"hard-gate","name":"tilted-r400-v300","seconds":30,"radius":15,"firstLock":"5.13","onGun":87.2,"requestFire":80.8,"inRange":100,"medianError":1.27,"p95Error":5.02,"longestGap":0.53,"medianDistance":418,"minHullGap":327.9,"rollsPerMinute":1.55,"rollReversals":21,"pitchReversals":0,"maxRoll":0.386} +{"grid":"initial","variant":"hard-gate","name":"tilted-r800-v150","seconds":30,"radius":15,"firstLock":"3.02","onGun":100,"requestFire":100,"inRange":100,"medianError":2.36,"p95Error":2.47,"longestGap":0,"medianDistance":516,"minHullGap":493.5,"rollsPerMinute":0.09,"rollReversals":0,"pitchReversals":0,"maxRoll":0.069} +{"grid":"initial","variant":"hard-gate","name":"tilted-r800-v300","seconds":30,"radius":15,"firstLock":"3.83","onGun":100,"requestFire":100,"inRange":100,"medianError":1.76,"p95Error":1.99,"longestGap":0,"medianDistance":510,"minHullGap":493.1,"rollsPerMinute":0.85,"rollReversals":19,"pitchReversals":0,"maxRoll":0.279} +{"grid":"initial","variant":"hard-gate","name":"tilted-r1600-v150","seconds":30,"radius":15,"firstLock":"2.92","onGun":100,"requestFire":100,"inRange":100,"medianError":2.86,"p95Error":2.98,"longestGap":0,"medianDistance":515,"minHullGap":492.5,"rollsPerMinute":0.09,"rollReversals":0,"pitchReversals":0,"maxRoll":0.049} +{"grid":"initial","variant":"hard-gate","name":"tilted-r1600-v300","seconds":30,"radius":15,"firstLock":"3.05","onGun":100,"requestFire":100,"inRange":100,"medianError":2.49,"p95Error":2.59,"longestGap":0,"medianDistance":513,"minHullGap":497.2,"rollsPerMinute":0.37,"rollReversals":4,"pitchReversals":0,"maxRoll":0.195} +{"grid":"initial","variant":"hard-gate","name":"straight-crossing","seconds":30,"radius":15,"firstLock":"2.22","onGun":85.7,"requestFire":86.2,"inRange":100,"medianError":3.35,"p95Error":3.58,"longestGap":1.32,"medianDistance":514,"minHullGap":247.8,"rollsPerMinute":0.02,"rollReversals":0,"pitchReversals":0,"maxRoll":0.158} +{"grid":"initial","variant":"hard-gate","name":"weaving-away","seconds":30,"radius":15,"firstLock":"0.00","onGun":99.6,"requestFire":99.2,"inRange":100,"medianError":1.89,"p95Error":3.22,"longestGap":0.08,"medianDistance":512,"minHullGap":494.5,"rollsPerMinute":0.68,"rollReversals":15,"pitchReversals":5,"maxRoll":0.301} +{"grid":"initial","variant":"hard-gate","name":"straight-away","seconds":30,"radius":15,"firstLock":"0.00","onGun":100,"requestFire":100,"inRange":100,"medianError":0,"p95Error":0,"longestGap":0,"medianDistance":510,"minHullGap":490,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"hard-gate","name":"horizontal-r400-v150","seconds":60,"radius":15,"firstLock":"3.48","onGun":100,"requestFire":100,"inRange":100,"medianError":1.92,"p95Error":2.06,"longestGap":0,"medianDistance":411,"minHullGap":295.8,"rollsPerMinute":0.01,"rollReversals":0,"pitchReversals":0,"maxRoll":0.005} +{"grid":"initial","variant":"hard-gate","name":"horizontal-r400-v300","seconds":60,"radius":15,"firstLock":"4.92","onGun":90,"requestFire":81,"inRange":100,"medianError":1.68,"p95Error":4.58,"longestGap":0.33,"medianDistance":409,"minHullGap":295.8,"rollsPerMinute":1.57,"rollReversals":66,"pitchReversals":0,"maxRoll":0.309} +{"grid":"initial","variant":"hard-gate","name":"horizontal-r800-v150","seconds":60,"radius":15,"firstLock":"3.18","onGun":100,"requestFire":100,"inRange":100,"medianError":2.4,"p95Error":2.51,"longestGap":0,"medianDistance":511,"minHullGap":493.2,"rollsPerMinute":0.02,"rollReversals":0,"pitchReversals":0,"maxRoll":0.013} +{"grid":"initial","variant":"hard-gate","name":"horizontal-r800-v300","seconds":60,"radius":15,"firstLock":"3.72","onGun":100,"requestFire":100,"inRange":100,"medianError":1.75,"p95Error":1.96,"longestGap":0,"medianDistance":509,"minHullGap":492.9,"rollsPerMinute":0.67,"rollReversals":34,"pitchReversals":0,"maxRoll":0.249} +{"grid":"initial","variant":"hard-gate","name":"horizontal-r1600-v150","seconds":60,"radius":15,"firstLock":"2.98","onGun":100,"requestFire":100,"inRange":100,"medianError":2.9,"p95Error":3,"longestGap":0,"medianDistance":513,"minHullGap":492.3,"rollsPerMinute":0.04,"rollReversals":0,"pitchReversals":0,"maxRoll":0.022} +{"grid":"initial","variant":"hard-gate","name":"horizontal-r1600-v300","seconds":60,"radius":15,"firstLock":"3.20","onGun":100,"requestFire":100,"inRange":100,"medianError":2.49,"p95Error":2.59,"longestGap":0,"medianDistance":515,"minHullGap":497.2,"rollsPerMinute":0.36,"rollReversals":15,"pitchReversals":0,"maxRoll":0.183} +{"grid":"initial","variant":"hard-gate","name":"vertical-r400-v150","seconds":60,"radius":15,"firstLock":"1.87","onGun":100,"requestFire":100,"inRange":100,"medianError":1.92,"p95Error":2.06,"longestGap":0,"medianDistance":410,"minHullGap":298,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"hard-gate","name":"vertical-r400-v300","seconds":60,"radius":15,"firstLock":"2.58","onGun":100,"requestFire":100,"inRange":100,"medianError":1.03,"p95Error":1.28,"longestGap":0,"medianDistance":409,"minHullGap":298,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"hard-gate","name":"vertical-r800-v150","seconds":60,"radius":15,"firstLock":"1.67","onGun":100,"requestFire":100,"inRange":100,"medianError":2.4,"p95Error":2.51,"longestGap":0,"medianDistance":511,"minHullGap":493.2,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"hard-gate","name":"vertical-r800-v300","seconds":60,"radius":15,"firstLock":"2.03","onGun":100,"requestFire":100,"inRange":100,"medianError":1.74,"p95Error":1.91,"longestGap":0,"medianDistance":509,"minHullGap":493,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"hard-gate","name":"vertical-r1600-v150","seconds":60,"radius":15,"firstLock":"1.52","onGun":100,"requestFire":100,"inRange":100,"medianError":2.9,"p95Error":3,"longestGap":0,"medianDistance":513,"minHullGap":492.3,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"hard-gate","name":"vertical-r1600-v300","seconds":60,"radius":15,"firstLock":"1.65","onGun":100,"requestFire":100,"inRange":100,"medianError":2.49,"p95Error":2.58,"longestGap":0,"medianDistance":515,"minHullGap":496,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"hard-gate","name":"tilted-r400-v150","seconds":60,"radius":15,"firstLock":"3.20","onGun":100,"requestFire":100,"inRange":100,"medianError":1.92,"p95Error":2.06,"longestGap":0,"medianDistance":410,"minHullGap":327.8,"rollsPerMinute":0.55,"rollReversals":0,"pitchReversals":0,"maxRoll":0.108} +{"grid":"initial","variant":"hard-gate","name":"tilted-r400-v300","seconds":60,"radius":15,"firstLock":"5.13","onGun":88.1,"requestFire":82.2,"inRange":100,"medianError":1.28,"p95Error":5.13,"longestGap":0.53,"medianDistance":409,"minHullGap":327.9,"rollsPerMinute":1.56,"rollReversals":47,"pitchReversals":0,"maxRoll":0.392} +{"grid":"initial","variant":"hard-gate","name":"tilted-r800-v150","seconds":60,"radius":15,"firstLock":"3.02","onGun":100,"requestFire":100,"inRange":100,"medianError":2.4,"p95Error":2.51,"longestGap":0,"medianDistance":511,"minHullGap":493.2,"rollsPerMinute":0.04,"rollReversals":0,"pitchReversals":0,"maxRoll":0.069} +{"grid":"initial","variant":"hard-gate","name":"tilted-r800-v300","seconds":60,"radius":15,"firstLock":"3.83","onGun":100,"requestFire":100,"inRange":100,"medianError":1.77,"p95Error":2.01,"longestGap":0,"medianDistance":510,"minHullGap":493.1,"rollsPerMinute":0.85,"rollReversals":48,"pitchReversals":0,"maxRoll":0.279} +{"grid":"initial","variant":"hard-gate","name":"tilted-r1600-v150","seconds":60,"radius":15,"firstLock":"2.92","onGun":100,"requestFire":100,"inRange":100,"medianError":2.9,"p95Error":3,"longestGap":0,"medianDistance":513,"minHullGap":492.3,"rollsPerMinute":0.07,"rollReversals":0,"pitchReversals":0,"maxRoll":0.049} +{"grid":"initial","variant":"hard-gate","name":"tilted-r1600-v300","seconds":60,"radius":15,"firstLock":"3.05","onGun":100,"requestFire":100,"inRange":100,"medianError":2.49,"p95Error":2.59,"longestGap":0,"medianDistance":515,"minHullGap":497.2,"rollsPerMinute":0.38,"rollReversals":18,"pitchReversals":0,"maxRoll":0.195} +{"grid":"initial","variant":"hard-gate","name":"straight-crossing","seconds":60,"radius":15,"firstLock":"2.22","onGun":74.3,"requestFire":76.2,"inRange":100,"medianError":3.45,"p95Error":3.62,"longestGap":9.97,"medianDistance":513,"minHullGap":247.8,"rollsPerMinute":0.01,"rollReversals":0,"pitchReversals":0,"maxRoll":0.158} +{"grid":"initial","variant":"hard-gate","name":"weaving-away","seconds":60,"radius":15,"firstLock":"0.00","onGun":99.7,"requestFire":99.3,"inRange":100,"medianError":1.8,"p95Error":3.23,"longestGap":0.08,"medianDistance":512,"minHullGap":494.5,"rollsPerMinute":0.6,"rollReversals":35,"pitchReversals":12,"maxRoll":0.301} +{"grid":"initial","variant":"hard-gate","name":"straight-away","seconds":60,"radius":15,"firstLock":"0.00","onGun":100,"requestFire":100,"inRange":100,"medianError":0,"p95Error":0,"longestGap":0,"medianDistance":510,"minHullGap":490,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"no-lead","name":"horizontal-r400-v150","seconds":30,"radius":15,"firstLock":"2.43","onGun":100,"requestFire":42.5,"inRange":100,"medianError":3.67,"p95Error":4.12,"longestGap":0,"medianDistance":383,"minHullGap":296.1,"rollsPerMinute":0.13,"rollReversals":0,"pitchReversals":0,"maxRoll":0.082} +{"grid":"initial","variant":"no-lead","name":"horizontal-r400-v300","seconds":30,"radius":15,"firstLock":"3.32","onGun":10.2,"requestFire":1.8,"inRange":100,"medianError":13.99,"p95Error":20.1,"longestGap":16.35,"medianDistance":422,"minHullGap":296.1,"rollsPerMinute":11.6,"rollReversals":18,"pitchReversals":0,"maxRoll":2.303} +{"grid":"initial","variant":"no-lead","name":"horizontal-r800-v150","seconds":30,"radius":15,"firstLock":"2.23","onGun":100,"requestFire":59.5,"inRange":100,"medianError":3.31,"p95Error":3.4,"longestGap":0,"medianDistance":516,"minHullGap":498.5,"rollsPerMinute":0.19,"rollReversals":0,"pitchReversals":0,"maxRoll":0.127} +{"grid":"initial","variant":"no-lead","name":"horizontal-r800-v300","seconds":30,"radius":15,"firstLock":"2.67","onGun":26.9,"requestFire":19.9,"inRange":100,"medianError":5.9,"p95Error":14.07,"longestGap":1.43,"medianDistance":516,"minHullGap":498.8,"rollsPerMinute":8.68,"rollReversals":12,"pitchReversals":0,"maxRoll":1.706} +{"grid":"initial","variant":"no-lead","name":"horizontal-r1600-v150","seconds":30,"radius":15,"firstLock":"2.05","onGun":100,"requestFire":75.1,"inRange":100,"medianError":3.38,"p95Error":3.46,"longestGap":0,"medianDistance":513,"minHullGap":494.6,"rollsPerMinute":0.3,"rollReversals":0,"pitchReversals":0,"maxRoll":0.143} +{"grid":"initial","variant":"no-lead","name":"horizontal-r1600-v300","seconds":30,"radius":15,"firstLock":"2.22","onGun":40.1,"requestFire":28.3,"inRange":100,"medianError":4.24,"p95Error":13.16,"longestGap":2.42,"medianDistance":513,"minHullGap":493.3,"rollsPerMinute":7.51,"rollReversals":5,"pitchReversals":3,"maxRoll":1.637} +{"grid":"initial","variant":"no-lead","name":"vertical-r400-v150","seconds":30,"radius":15,"firstLock":"1.87","onGun":100,"requestFire":42.6,"inRange":100,"medianError":3.67,"p95Error":4.13,"longestGap":0,"medianDistance":383,"minHullGap":298,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"no-lead","name":"vertical-r400-v300","seconds":30,"radius":15,"firstLock":"2.58","onGun":99.9,"requestFire":19.3,"inRange":100,"medianError":3.32,"p95Error":3.8,"longestGap":0.02,"medianDistance":425,"minHullGap":298,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"no-lead","name":"vertical-r800-v150","seconds":30,"radius":15,"firstLock":"1.67","onGun":100,"requestFire":59.6,"inRange":100,"medianError":3.31,"p95Error":3.4,"longestGap":0,"medianDistance":516,"minHullGap":498.6,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"no-lead","name":"vertical-r800-v300","seconds":30,"radius":15,"firstLock":"2.03","onGun":100,"requestFire":38.3,"inRange":100,"medianError":3.19,"p95Error":3.3,"longestGap":0,"medianDistance":513,"minHullGap":497.1,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"no-lead","name":"vertical-r1600-v150","seconds":30,"radius":15,"firstLock":"1.52","onGun":100,"requestFire":75.3,"inRange":100,"medianError":3.38,"p95Error":3.46,"longestGap":0,"medianDistance":512,"minHullGap":494.6,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"no-lead","name":"vertical-r1600-v300","seconds":30,"radius":15,"firstLock":"1.65","onGun":100,"requestFire":60.6,"inRange":100,"medianError":3.34,"p95Error":3.43,"longestGap":0,"medianDistance":512,"minHullGap":491.9,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"no-lead","name":"tilted-r400-v150","seconds":30,"radius":15,"firstLock":"2.23","onGun":100,"requestFire":41.9,"inRange":100,"medianError":3.63,"p95Error":3.97,"longestGap":0,"medianDistance":392,"minHullGap":331.1,"rollsPerMinute":1.35,"rollReversals":8,"pitchReversals":0,"maxRoll":0.652} +{"grid":"initial","variant":"no-lead","name":"tilted-r400-v300","seconds":30,"radius":15,"firstLock":"2.80","onGun":3.3,"requestFire":1.7,"inRange":100,"medianError":12.22,"p95Error":20.46,"longestGap":10.58,"medianDistance":419,"minHullGap":331.8,"rollsPerMinute":11.06,"rollReversals":18,"pitchReversals":0,"maxRoll":2.303} +{"grid":"initial","variant":"no-lead","name":"tilted-r800-v150","seconds":30,"radius":15,"firstLock":"2.10","onGun":62.1,"requestFire":37,"inRange":100,"medianError":3.4,"p95Error":4.41,"longestGap":0.8,"medianDistance":517,"minHullGap":494.4,"rollsPerMinute":5.25,"rollReversals":10,"pitchReversals":0,"maxRoll":1.229} +{"grid":"initial","variant":"no-lead","name":"tilted-r800-v300","seconds":30,"radius":15,"firstLock":"3.02","onGun":22.1,"requestFire":21.6,"inRange":100,"medianError":8.09,"p95Error":14.61,"longestGap":1.42,"medianDistance":517,"minHullGap":499.1,"rollsPerMinute":9.46,"rollReversals":12,"pitchReversals":0,"maxRoll":1.747} +{"grid":"initial","variant":"no-lead","name":"tilted-r1600-v150","seconds":30,"radius":15,"firstLock":"1.98","onGun":35.9,"requestFire":34.2,"inRange":100,"medianError":4.68,"p95Error":9.31,"longestGap":2.88,"medianDistance":515,"minHullGap":495,"rollsPerMinute":7.3,"rollReversals":3,"pitchReversals":3,"maxRoll":1.313} +{"grid":"initial","variant":"no-lead","name":"tilted-r1600-v300","seconds":30,"radius":15,"firstLock":"2.10","onGun":21.3,"requestFire":21.5,"inRange":100,"medianError":7.27,"p95Error":13.36,"longestGap":2.45,"medianDistance":516,"minHullGap":496.2,"rollsPerMinute":9.55,"rollReversals":1,"pitchReversals":6,"maxRoll":1.852} +{"grid":"initial","variant":"no-lead","name":"straight-crossing","seconds":30,"radius":15,"firstLock":"1.85","onGun":45.3,"requestFire":44.1,"inRange":100,"medianError":3.51,"p95Error":10.73,"longestGap":10.12,"medianDistance":515,"minHullGap":294.7,"rollsPerMinute":6.07,"rollReversals":1,"pitchReversals":0,"maxRoll":1.369} +{"grid":"initial","variant":"no-lead","name":"weaving-away","seconds":30,"radius":15,"firstLock":"0.00","onGun":18.8,"requestFire":16.6,"inRange":100,"medianError":7.56,"p95Error":16.38,"longestGap":5.02,"medianDistance":516,"minHullGap":495.9,"rollsPerMinute":9.84,"rollReversals":7,"pitchReversals":2,"maxRoll":2.431} +{"grid":"initial","variant":"no-lead","name":"straight-away","seconds":30,"radius":15,"firstLock":"0.00","onGun":100,"requestFire":100,"inRange":100,"medianError":0,"p95Error":0,"longestGap":0,"medianDistance":510,"minHullGap":490,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"no-lead","name":"horizontal-r400-v150","seconds":60,"radius":15,"firstLock":"2.43","onGun":100,"requestFire":43.2,"inRange":100,"medianError":3.56,"p95Error":4.1,"longestGap":0,"medianDistance":411,"minHullGap":296.1,"rollsPerMinute":0.07,"rollReversals":0,"pitchReversals":0,"maxRoll":0.082} +{"grid":"initial","variant":"no-lead","name":"horizontal-r400-v300","seconds":60,"radius":15,"firstLock":"3.32","onGun":4.1,"requestFire":0.7,"inRange":100,"medianError":15.53,"p95Error":20.21,"longestGap":46.35,"medianDistance":409,"minHullGap":296.1,"rollsPerMinute":12.41,"rollReversals":46,"pitchReversals":0,"maxRoll":2.303} +{"grid":"initial","variant":"no-lead","name":"horizontal-r800-v150","seconds":60,"radius":15,"firstLock":"2.23","onGun":100,"requestFire":60.4,"inRange":100,"medianError":3.31,"p95Error":3.4,"longestGap":0,"medianDistance":515,"minHullGap":494.9,"rollsPerMinute":0.09,"rollReversals":0,"pitchReversals":0,"maxRoll":0.127} +{"grid":"initial","variant":"no-lead","name":"horizontal-r800-v300","seconds":60,"radius":15,"firstLock":"2.67","onGun":24,"requestFire":20.8,"inRange":100,"medianError":7.62,"p95Error":14.63,"longestGap":1.43,"medianDistance":516,"minHullGap":498.7,"rollsPerMinute":9.46,"rollReversals":28,"pitchReversals":0,"maxRoll":1.749} +{"grid":"initial","variant":"no-lead","name":"horizontal-r1600-v150","seconds":60,"radius":15,"firstLock":"2.05","onGun":100,"requestFire":76.4,"inRange":100,"medianError":3.4,"p95Error":3.47,"longestGap":0,"medianDistance":509,"minHullGap":494.4,"rollsPerMinute":0.29,"rollReversals":0,"pitchReversals":0,"maxRoll":0.143} +{"grid":"initial","variant":"no-lead","name":"horizontal-r1600-v300","seconds":60,"radius":15,"firstLock":"2.22","onGun":28.2,"requestFire":23.5,"inRange":100,"medianError":6.17,"p95Error":13.19,"longestGap":2.45,"medianDistance":515,"minHullGap":493.3,"rollsPerMinute":8.8,"rollReversals":5,"pitchReversals":13,"maxRoll":1.637} +{"grid":"initial","variant":"no-lead","name":"vertical-r400-v150","seconds":60,"radius":15,"firstLock":"1.87","onGun":100,"requestFire":43.2,"inRange":100,"medianError":3.56,"p95Error":4.1,"longestGap":0,"medianDistance":410,"minHullGap":298,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"no-lead","name":"vertical-r400-v300","seconds":60,"radius":15,"firstLock":"2.58","onGun":99.6,"requestFire":19,"inRange":100,"medianError":3.36,"p95Error":3.93,"longestGap":0.08,"medianDistance":409,"minHullGap":298,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"no-lead","name":"vertical-r800-v150","seconds":60,"radius":15,"firstLock":"1.67","onGun":100,"requestFire":60.4,"inRange":100,"medianError":3.32,"p95Error":3.41,"longestGap":0,"medianDistance":515,"minHullGap":494.9,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"no-lead","name":"vertical-r800-v300","seconds":60,"radius":15,"firstLock":"2.03","onGun":100,"requestFire":38.4,"inRange":100,"medianError":3.19,"p95Error":3.3,"longestGap":0,"medianDistance":514,"minHullGap":497.1,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"no-lead","name":"vertical-r1600-v150","seconds":60,"radius":15,"firstLock":"1.52","onGun":100,"requestFire":76.8,"inRange":100,"medianError":3.39,"p95Error":3.49,"longestGap":0,"medianDistance":510,"minHullGap":494.5,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"no-lead","name":"vertical-r1600-v300","seconds":60,"radius":15,"firstLock":"1.65","onGun":100,"requestFire":60.8,"inRange":100,"medianError":3.34,"p95Error":3.43,"longestGap":0,"medianDistance":512,"minHullGap":491.9,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"no-lead","name":"tilted-r400-v150","seconds":60,"radius":15,"firstLock":"2.23","onGun":100,"requestFire":42.7,"inRange":100,"medianError":3.56,"p95Error":3.92,"longestGap":0,"medianDistance":410,"minHullGap":331.1,"rollsPerMinute":0.88,"rollReversals":8,"pitchReversals":0,"maxRoll":0.652} +{"grid":"initial","variant":"no-lead","name":"tilted-r400-v300","seconds":60,"radius":15,"firstLock":"2.80","onGun":1.7,"requestFire":0.7,"inRange":100,"medianError":13.27,"p95Error":21.2,"longestGap":21.6,"medianDistance":409,"minHullGap":331.8,"rollsPerMinute":11.43,"rollReversals":46,"pitchReversals":0,"maxRoll":2.303} +{"grid":"initial","variant":"no-lead","name":"tilted-r800-v150","seconds":60,"radius":15,"firstLock":"2.10","onGun":59.6,"requestFire":36.4,"inRange":100,"medianError":3.41,"p95Error":4.62,"longestGap":0.97,"medianDistance":515,"minHullGap":494,"rollsPerMinute":5.46,"rollReversals":24,"pitchReversals":0,"maxRoll":1.238} +{"grid":"initial","variant":"no-lead","name":"tilted-r800-v300","seconds":60,"radius":15,"firstLock":"3.02","onGun":21.3,"requestFire":20.7,"inRange":100,"medianError":8.74,"p95Error":14.76,"longestGap":1.42,"medianDistance":517,"minHullGap":499.1,"rollsPerMinute":9.82,"rollReversals":28,"pitchReversals":0,"maxRoll":1.758} +{"grid":"initial","variant":"no-lead","name":"tilted-r1600-v150","seconds":60,"radius":15,"firstLock":"1.98","onGun":36.6,"requestFire":34.1,"inRange":100,"medianError":4.58,"p95Error":8.72,"longestGap":3.18,"medianDistance":514,"minHullGap":494.6,"rollsPerMinute":7.28,"rollReversals":6,"pitchReversals":8,"maxRoll":1.313} +{"grid":"initial","variant":"no-lead","name":"tilted-r1600-v300","seconds":60,"radius":15,"firstLock":"2.10","onGun":20.7,"requestFire":20.8,"inRange":100,"medianError":7.28,"p95Error":13.22,"longestGap":2.45,"medianDistance":516,"minHullGap":496.1,"rollsPerMinute":9.62,"rollReversals":1,"pitchReversals":16,"maxRoll":1.852} +{"grid":"initial","variant":"no-lead","name":"straight-crossing","seconds":60,"radius":15,"firstLock":"1.85","onGun":18.1,"requestFire":17.6,"inRange":100,"medianError":11.24,"p95Error":11.33,"longestGap":40.12,"medianDistance":516,"minHullGap":294.7,"rollsPerMinute":10.49,"rollReversals":1,"pitchReversals":0,"maxRoll":1.413} +{"grid":"initial","variant":"no-lead","name":"weaving-away","seconds":60,"radius":15,"firstLock":"0.00","onGun":14.8,"requestFire":13,"inRange":100,"medianError":6.97,"p95Error":15.96,"longestGap":5.02,"medianDistance":515,"minHullGap":495.9,"rollsPerMinute":10.14,"rollReversals":18,"pitchReversals":4,"maxRoll":2.431} +{"grid":"initial","variant":"no-lead","name":"straight-away","seconds":60,"radius":15,"firstLock":"0.00","onGun":100,"requestFire":100,"inRange":100,"medianError":0,"p95Error":0,"longestGap":0,"medianDistance":510,"minHullGap":490,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"low-lead","name":"horizontal-r400-v150","seconds":30,"radius":15,"firstLock":"2.42","onGun":100,"requestFire":100,"inRange":100,"medianError":3.02,"p95Error":3.28,"longestGap":0,"medianDistance":383,"minHullGap":296.1,"rollsPerMinute":0.14,"rollReversals":0,"pitchReversals":0,"maxRoll":0.096} +{"grid":"initial","variant":"low-lead","name":"horizontal-r400-v300","seconds":30,"radius":15,"firstLock":"3.28","onGun":6.9,"requestFire":5.1,"inRange":100,"medianError":10.23,"p95Error":17.54,"longestGap":14.12,"medianDistance":422,"minHullGap":296.1,"rollsPerMinute":11.73,"rollReversals":18,"pitchReversals":0,"maxRoll":2.321} +{"grid":"initial","variant":"low-lead","name":"horizontal-r800-v150","seconds":30,"radius":15,"firstLock":"2.22","onGun":100,"requestFire":100,"inRange":100,"medianError":3.02,"p95Error":3.11,"longestGap":0,"medianDistance":516,"minHullGap":497.4,"rollsPerMinute":0.2,"rollReversals":1,"pitchReversals":0,"maxRoll":0.123} +{"grid":"initial","variant":"low-lead","name":"horizontal-r800-v300","seconds":30,"radius":15,"firstLock":"2.65","onGun":30.4,"requestFire":29.7,"inRange":100,"medianError":5.76,"p95Error":14.5,"longestGap":1.5,"medianDistance":516,"minHullGap":498.1,"rollsPerMinute":9.15,"rollReversals":11,"pitchReversals":0,"maxRoll":1.922} +{"grid":"initial","variant":"low-lead","name":"horizontal-r1600-v150","seconds":30,"radius":15,"firstLock":"2.05","onGun":100,"requestFire":100,"inRange":100,"medianError":3.23,"p95Error":3.33,"longestGap":0,"medianDistance":512,"minHullGap":493.4,"rollsPerMinute":0.25,"rollReversals":0,"pitchReversals":0,"maxRoll":0.108} +{"grid":"initial","variant":"low-lead","name":"horizontal-r1600-v300","seconds":30,"radius":15,"firstLock":"2.22","onGun":42.1,"requestFire":41,"inRange":100,"medianError":4.27,"p95Error":13.23,"longestGap":2.45,"medianDistance":513,"minHullGap":493,"rollsPerMinute":7.63,"rollReversals":5,"pitchReversals":3,"maxRoll":1.827} +{"grid":"initial","variant":"low-lead","name":"vertical-r400-v150","seconds":30,"radius":15,"firstLock":"1.87","onGun":100,"requestFire":100,"inRange":100,"medianError":3.01,"p95Error":3.27,"longestGap":0,"medianDistance":383,"minHullGap":298,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"low-lead","name":"vertical-r400-v300","seconds":30,"radius":15,"firstLock":"2.58","onGun":100,"requestFire":100,"inRange":100,"medianError":2.28,"p95Error":2.66,"longestGap":0,"medianDistance":425,"minHullGap":298,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"low-lead","name":"vertical-r800-v150","seconds":30,"radius":15,"firstLock":"1.67","onGun":100,"requestFire":100,"inRange":100,"medianError":3.02,"p95Error":3.11,"longestGap":0,"medianDistance":515,"minHullGap":497.4,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"low-lead","name":"vertical-r800-v300","seconds":30,"radius":15,"firstLock":"2.03","onGun":100,"requestFire":100,"inRange":100,"medianError":2.67,"p95Error":2.77,"longestGap":0,"medianDistance":509,"minHullGap":491.3,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"low-lead","name":"vertical-r1600-v150","seconds":30,"radius":15,"firstLock":"1.52","onGun":100,"requestFire":100,"inRange":100,"medianError":3.24,"p95Error":3.33,"longestGap":0,"medianDistance":512,"minHullGap":493.5,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"low-lead","name":"vertical-r1600-v300","seconds":30,"radius":15,"firstLock":"1.65","onGun":100,"requestFire":100,"inRange":100,"medianError":3.08,"p95Error":3.17,"longestGap":0,"medianDistance":513,"minHullGap":492.3,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"low-lead","name":"tilted-r400-v150","seconds":30,"radius":15,"firstLock":"2.08","onGun":98.1,"requestFire":97.8,"inRange":100,"medianError":3.04,"p95Error":3.79,"longestGap":0.38,"medianDistance":392,"minHullGap":333.2,"rollsPerMinute":2.51,"rollReversals":11,"pitchReversals":0,"maxRoll":1.188} +{"grid":"initial","variant":"low-lead","name":"tilted-r400-v300","seconds":30,"radius":15,"firstLock":"2.40","onGun":8.7,"requestFire":6.7,"inRange":100,"medianError":10.48,"p95Error":17.99,"longestGap":2.22,"medianDistance":418,"minHullGap":335.9,"rollsPerMinute":11.78,"rollReversals":18,"pitchReversals":0,"maxRoll":2.336} +{"grid":"initial","variant":"low-lead","name":"tilted-r800-v150","seconds":30,"radius":15,"firstLock":"2.05","onGun":27.4,"requestFire":25.4,"inRange":100,"medianError":6.11,"p95Error":11.58,"longestGap":2.28,"medianDistance":517,"minHullGap":498.7,"rollsPerMinute":8.57,"rollReversals":8,"pitchReversals":0,"maxRoll":1.581} +{"grid":"initial","variant":"low-lead","name":"tilted-r800-v300","seconds":30,"radius":15,"firstLock":"2.23","onGun":20.7,"requestFire":21.4,"inRange":100,"medianError":8.64,"p95Error":14.65,"longestGap":1.47,"medianDistance":518,"minHullGap":498,"rollsPerMinute":10.25,"rollReversals":11,"pitchReversals":0,"maxRoll":1.903} +{"grid":"initial","variant":"low-lead","name":"tilted-r1600-v150","seconds":30,"radius":15,"firstLock":"1.97","onGun":36.4,"requestFire":36.4,"inRange":100,"medianError":4.86,"p95Error":9.48,"longestGap":3.07,"medianDistance":517,"minHullGap":495.2,"rollsPerMinute":7.38,"rollReversals":2,"pitchReversals":4,"maxRoll":1.352} +{"grid":"initial","variant":"low-lead","name":"tilted-r1600-v300","seconds":30,"radius":15,"firstLock":"2.03","onGun":21,"requestFire":20.5,"inRange":100,"medianError":7.52,"p95Error":13.04,"longestGap":2.5,"medianDistance":516,"minHullGap":494.9,"rollsPerMinute":9.57,"rollReversals":1,"pitchReversals":6,"maxRoll":1.905} +{"grid":"initial","variant":"low-lead","name":"straight-crossing","seconds":30,"radius":15,"firstLock":"1.87","onGun":34.7,"requestFire":33.7,"inRange":100,"medianError":4.55,"p95Error":11.12,"longestGap":12.87,"medianDistance":516,"minHullGap":293.9,"rollsPerMinute":7.42,"rollReversals":1,"pitchReversals":0,"maxRoll":1.393} +{"grid":"initial","variant":"low-lead","name":"weaving-away","seconds":30,"radius":15,"firstLock":"0.00","onGun":10.5,"requestFire":10.2,"inRange":100,"medianError":8.08,"p95Error":13.68,"longestGap":3.63,"medianDistance":516,"minHullGap":496.2,"rollsPerMinute":11.11,"rollReversals":5,"pitchReversals":0,"maxRoll":1.985} +{"grid":"initial","variant":"low-lead","name":"straight-away","seconds":30,"radius":15,"firstLock":"0.00","onGun":100,"requestFire":100,"inRange":100,"medianError":0,"p95Error":0,"longestGap":0,"medianDistance":510,"minHullGap":490,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"low-lead","name":"horizontal-r400-v150","seconds":60,"radius":15,"firstLock":"2.42","onGun":100,"requestFire":100,"inRange":100,"medianError":2.98,"p95Error":3.26,"longestGap":0,"medianDistance":411,"minHullGap":296.1,"rollsPerMinute":0.07,"rollReversals":0,"pitchReversals":0,"maxRoll":0.096} +{"grid":"initial","variant":"low-lead","name":"horizontal-r400-v300","seconds":60,"radius":15,"firstLock":"3.28","onGun":3.8,"requestFire":2.6,"inRange":100,"medianError":11.94,"p95Error":17.65,"longestGap":14.12,"medianDistance":409,"minHullGap":296.1,"rollsPerMinute":12.41,"rollReversals":46,"pitchReversals":0,"maxRoll":2.321} +{"grid":"initial","variant":"low-lead","name":"horizontal-r800-v150","seconds":60,"radius":15,"firstLock":"2.22","onGun":100,"requestFire":100,"inRange":100,"medianError":3.02,"p95Error":3.12,"longestGap":0,"medianDistance":517,"minHullGap":497.4,"rollsPerMinute":0.09,"rollReversals":1,"pitchReversals":0,"maxRoll":0.123} +{"grid":"initial","variant":"low-lead","name":"horizontal-r800-v300","seconds":60,"radius":15,"firstLock":"2.65","onGun":24.1,"requestFire":24.3,"inRange":100,"medianError":7.39,"p95Error":14.58,"longestGap":1.5,"medianDistance":517,"minHullGap":498.1,"rollsPerMinute":9.86,"rollReversals":28,"pitchReversals":0,"maxRoll":1.922} +{"grid":"initial","variant":"low-lead","name":"horizontal-r1600-v150","seconds":60,"radius":15,"firstLock":"2.05","onGun":100,"requestFire":100,"inRange":100,"medianError":3.26,"p95Error":3.35,"longestGap":0,"medianDistance":510,"minHullGap":492.1,"rollsPerMinute":0.25,"rollReversals":0,"pitchReversals":0,"maxRoll":0.108} +{"grid":"initial","variant":"low-lead","name":"horizontal-r1600-v300","seconds":60,"radius":15,"firstLock":"2.22","onGun":28.6,"requestFire":28,"inRange":100,"medianError":6.31,"p95Error":12.6,"longestGap":2.48,"medianDistance":514,"minHullGap":493,"rollsPerMinute":8.89,"rollReversals":5,"pitchReversals":13,"maxRoll":1.827} +{"grid":"initial","variant":"low-lead","name":"vertical-r400-v150","seconds":60,"radius":15,"firstLock":"1.87","onGun":100,"requestFire":100,"inRange":100,"medianError":2.97,"p95Error":3.27,"longestGap":0,"medianDistance":410,"minHullGap":298,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"low-lead","name":"vertical-r400-v300","seconds":60,"radius":15,"firstLock":"2.58","onGun":100,"requestFire":100,"inRange":100,"medianError":2.3,"p95Error":2.68,"longestGap":0,"medianDistance":409,"minHullGap":298,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"low-lead","name":"vertical-r800-v150","seconds":60,"radius":15,"firstLock":"1.67","onGun":100,"requestFire":100,"inRange":100,"medianError":3.02,"p95Error":3.12,"longestGap":0,"medianDistance":517,"minHullGap":497.4,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"low-lead","name":"vertical-r800-v300","seconds":60,"radius":15,"firstLock":"2.03","onGun":100,"requestFire":100,"inRange":100,"medianError":2.67,"p95Error":2.8,"longestGap":0,"medianDistance":507,"minHullGap":491.3,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"low-lead","name":"vertical-r1600-v150","seconds":60,"radius":15,"firstLock":"1.52","onGun":100,"requestFire":100,"inRange":100,"medianError":3.25,"p95Error":3.36,"longestGap":0,"medianDistance":509,"minHullGap":492.1,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"low-lead","name":"vertical-r1600-v300","seconds":60,"radius":15,"firstLock":"1.65","onGun":100,"requestFire":100,"inRange":100,"medianError":3.08,"p95Error":3.17,"longestGap":0,"medianDistance":512,"minHullGap":492.3,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"low-lead","name":"tilted-r400-v150","seconds":60,"radius":15,"firstLock":"2.08","onGun":99.2,"requestFire":99.1,"inRange":100,"medianError":2.98,"p95Error":3.39,"longestGap":0.38,"medianDistance":410,"minHullGap":333.2,"rollsPerMinute":1.35,"rollReversals":11,"pitchReversals":0,"maxRoll":1.188} +{"grid":"initial","variant":"low-lead","name":"tilted-r400-v300","seconds":60,"radius":15,"firstLock":"2.40","onGun":11.3,"requestFire":8.9,"inRange":100,"medianError":9.47,"p95Error":17.9,"longestGap":4.07,"medianDistance":409,"minHullGap":335.9,"rollsPerMinute":11.3,"rollReversals":45,"pitchReversals":0,"maxRoll":2.336} +{"grid":"initial","variant":"low-lead","name":"tilted-r800-v150","seconds":60,"radius":15,"firstLock":"2.05","onGun":24.4,"requestFire":23.6,"inRange":100,"medianError":6.82,"p95Error":12.34,"longestGap":2.35,"medianDistance":514,"minHullGap":495,"rollsPerMinute":9.07,"rollReversals":18,"pitchReversals":0,"maxRoll":1.595} +{"grid":"initial","variant":"low-lead","name":"tilted-r800-v300","seconds":60,"radius":15,"firstLock":"2.23","onGun":20,"requestFire":20.7,"inRange":100,"medianError":8.74,"p95Error":14.62,"longestGap":1.47,"medianDistance":518,"minHullGap":498,"rollsPerMinute":10.32,"rollReversals":27,"pitchReversals":0,"maxRoll":1.903} +{"grid":"initial","variant":"low-lead","name":"tilted-r1600-v150","seconds":60,"radius":15,"firstLock":"1.97","onGun":38.3,"requestFire":38,"inRange":100,"medianError":4.48,"p95Error":8.83,"longestGap":3.15,"medianDistance":516,"minHullGap":494.9,"rollsPerMinute":7.16,"rollReversals":7,"pitchReversals":7,"maxRoll":1.352} +{"grid":"initial","variant":"low-lead","name":"tilted-r1600-v300","seconds":60,"radius":15,"firstLock":"2.03","onGun":20.2,"requestFire":19.8,"inRange":100,"medianError":7.53,"p95Error":12.67,"longestGap":2.5,"medianDistance":515,"minHullGap":494.5,"rollsPerMinute":9.62,"rollReversals":1,"pitchReversals":16,"maxRoll":1.905} +{"grid":"initial","variant":"low-lead","name":"straight-crossing","seconds":60,"radius":15,"firstLock":"1.87","onGun":13.9,"requestFire":13.5,"inRange":100,"medianError":11.15,"p95Error":11.23,"longestGap":42.87,"medianDistance":516,"minHullGap":293.9,"rollsPerMinute":10.95,"rollReversals":1,"pitchReversals":0,"maxRoll":1.4} +{"grid":"initial","variant":"low-lead","name":"weaving-away","seconds":60,"radius":15,"firstLock":"0.00","onGun":15.8,"requestFire":15.4,"inRange":100,"medianError":7.92,"p95Error":13.85,"longestGap":3.63,"medianDistance":516,"minHullGap":495.4,"rollsPerMinute":10.47,"rollReversals":17,"pitchReversals":4,"maxRoll":2.262} +{"grid":"initial","variant":"low-lead","name":"straight-away","seconds":60,"radius":15,"firstLock":"0.00","onGun":100,"requestFire":100,"inRange":100,"medianError":0,"p95Error":0,"longestGap":0,"medianDistance":510,"minHullGap":490,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"no-lead-hard-gate","name":"horizontal-r400-v150","seconds":30,"radius":15,"firstLock":"3.48","onGun":100,"requestFire":42.5,"inRange":100,"medianError":3.67,"p95Error":4.14,"longestGap":0,"medianDistance":383,"minHullGap":295.8,"rollsPerMinute":0.02,"rollReversals":0,"pitchReversals":0,"maxRoll":0.006} +{"grid":"initial","variant":"no-lead-hard-gate","name":"horizontal-r400-v300","seconds":30,"radius":15,"firstLock":"4.95","onGun":61.1,"requestFire":15.1,"inRange":100,"medianError":3.63,"p95Error":8.85,"longestGap":1.22,"medianDistance":422,"minHullGap":295.8,"rollsPerMinute":1.01,"rollReversals":22,"pitchReversals":0,"maxRoll":0.275} +{"grid":"initial","variant":"no-lead-hard-gate","name":"horizontal-r800-v150","seconds":30,"radius":15,"firstLock":"3.18","onGun":100,"requestFire":59.4,"inRange":100,"medianError":3.31,"p95Error":3.39,"longestGap":0,"medianDistance":516,"minHullGap":498.5,"rollsPerMinute":0.03,"rollReversals":0,"pitchReversals":0,"maxRoll":0.015} +{"grid":"initial","variant":"no-lead-hard-gate","name":"horizontal-r800-v300","seconds":30,"radius":15,"firstLock":"3.72","onGun":93.2,"requestFire":34.6,"inRange":100,"medianError":3.2,"p95Error":3.55,"longestGap":0.25,"medianDistance":514,"minHullGap":497.3,"rollsPerMinute":0.8,"rollReversals":18,"pitchReversals":0,"maxRoll":0.26} +{"grid":"initial","variant":"no-lead-hard-gate","name":"horizontal-r1600-v150","seconds":30,"radius":15,"firstLock":"2.98","onGun":100,"requestFire":74.6,"inRange":100,"medianError":3.39,"p95Error":3.46,"longestGap":0,"medianDistance":513,"minHullGap":494.7,"rollsPerMinute":0.05,"rollReversals":0,"pitchReversals":0,"maxRoll":0.021} +{"grid":"initial","variant":"no-lead-hard-gate","name":"horizontal-r1600-v300","seconds":30,"radius":15,"firstLock":"3.20","onGun":99.5,"requestFire":58.5,"inRange":100,"medianError":3.33,"p95Error":3.44,"longestGap":0.05,"medianDistance":513,"minHullGap":491.9,"rollsPerMinute":0.36,"rollReversals":4,"pitchReversals":0,"maxRoll":0.191} +{"grid":"initial","variant":"no-lead-hard-gate","name":"vertical-r400-v150","seconds":30,"radius":15,"firstLock":"1.87","onGun":100,"requestFire":42.6,"inRange":100,"medianError":3.67,"p95Error":4.13,"longestGap":0,"medianDistance":383,"minHullGap":298,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"no-lead-hard-gate","name":"vertical-r400-v300","seconds":30,"radius":15,"firstLock":"2.58","onGun":99.9,"requestFire":19.3,"inRange":100,"medianError":3.32,"p95Error":3.8,"longestGap":0.02,"medianDistance":425,"minHullGap":298,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"no-lead-hard-gate","name":"vertical-r800-v150","seconds":30,"radius":15,"firstLock":"1.67","onGun":100,"requestFire":59.6,"inRange":100,"medianError":3.31,"p95Error":3.4,"longestGap":0,"medianDistance":516,"minHullGap":498.6,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"no-lead-hard-gate","name":"vertical-r800-v300","seconds":30,"radius":15,"firstLock":"2.03","onGun":100,"requestFire":38.3,"inRange":100,"medianError":3.19,"p95Error":3.3,"longestGap":0,"medianDistance":513,"minHullGap":497.1,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"no-lead-hard-gate","name":"vertical-r1600-v150","seconds":30,"radius":15,"firstLock":"1.52","onGun":100,"requestFire":75.3,"inRange":100,"medianError":3.38,"p95Error":3.46,"longestGap":0,"medianDistance":512,"minHullGap":494.6,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"no-lead-hard-gate","name":"vertical-r1600-v300","seconds":30,"radius":15,"firstLock":"1.65","onGun":100,"requestFire":60.6,"inRange":100,"medianError":3.34,"p95Error":3.43,"longestGap":0,"medianDistance":512,"minHullGap":491.9,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"no-lead-hard-gate","name":"tilted-r400-v150","seconds":30,"radius":15,"firstLock":"4.13","onGun":100,"requestFire":42.6,"inRange":100,"medianError":3.63,"p95Error":3.94,"longestGap":0,"medianDistance":391,"minHullGap":327.8,"rollsPerMinute":0.57,"rollReversals":0,"pitchReversals":0,"maxRoll":0.12} +{"grid":"initial","variant":"no-lead-hard-gate","name":"tilted-r400-v300","seconds":30,"radius":15,"firstLock":"4.70","onGun":69.1,"requestFire":14.9,"inRange":100,"medianError":3.49,"p95Error":6.68,"longestGap":0.53,"medianDistance":419,"minHullGap":327.8,"rollsPerMinute":1.23,"rollReversals":4,"pitchReversals":0,"maxRoll":0.319} +{"grid":"initial","variant":"no-lead-hard-gate","name":"tilted-r800-v150","seconds":30,"radius":15,"firstLock":"4.15","onGun":100,"requestFire":59.3,"inRange":100,"medianError":3.31,"p95Error":3.39,"longestGap":0,"medianDistance":516,"minHullGap":498.5,"rollsPerMinute":0.07,"rollReversals":0,"pitchReversals":0,"maxRoll":0.051} +{"grid":"initial","variant":"no-lead-hard-gate","name":"tilted-r800-v300","seconds":30,"radius":15,"firstLock":"4.33","onGun":93,"requestFire":34.4,"inRange":100,"medianError":3.21,"p95Error":3.57,"longestGap":0.18,"medianDistance":514,"minHullGap":497.2,"rollsPerMinute":0.82,"rollReversals":19,"pitchReversals":0,"maxRoll":0.274} +{"grid":"initial","variant":"no-lead-hard-gate","name":"tilted-r1600-v150","seconds":30,"radius":15,"firstLock":"4.12","onGun":100,"requestFire":74.5,"inRange":100,"medianError":3.38,"p95Error":3.46,"longestGap":0,"medianDistance":513,"minHullGap":494.7,"rollsPerMinute":0.1,"rollReversals":0,"pitchReversals":0,"maxRoll":0.075} +{"grid":"initial","variant":"no-lead-hard-gate","name":"tilted-r1600-v300","seconds":30,"radius":15,"firstLock":"4.28","onGun":99.6,"requestFire":59.2,"inRange":100,"medianError":3.33,"p95Error":3.43,"longestGap":0.05,"medianDistance":513,"minHullGap":492,"rollsPerMinute":0.32,"rollReversals":3,"pitchReversals":0,"maxRoll":0.175} +{"grid":"initial","variant":"no-lead-hard-gate","name":"straight-crossing","seconds":30,"radius":15,"firstLock":"2.22","onGun":98.3,"requestFire":95.2,"inRange":100,"medianError":3.38,"p95Error":3.49,"longestGap":0.1,"medianDistance":515,"minHullGap":248,"rollsPerMinute":0.01,"rollReversals":0,"pitchReversals":0,"maxRoll":0.02} +{"grid":"initial","variant":"no-lead-hard-gate","name":"weaving-away","seconds":30,"radius":15,"firstLock":"0.00","onGun":86.6,"requestFire":51.7,"inRange":100,"medianError":3.22,"p95Error":4.12,"longestGap":0.28,"medianDistance":512,"minHullGap":494.6,"rollsPerMinute":0.61,"rollReversals":15,"pitchReversals":5,"maxRoll":0.265} +{"grid":"initial","variant":"no-lead-hard-gate","name":"straight-away","seconds":30,"radius":15,"firstLock":"0.00","onGun":100,"requestFire":100,"inRange":100,"medianError":0,"p95Error":0,"longestGap":0,"medianDistance":510,"minHullGap":490,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"no-lead-hard-gate","name":"horizontal-r400-v150","seconds":60,"radius":15,"firstLock":"3.48","onGun":100,"requestFire":43.1,"inRange":100,"medianError":3.56,"p95Error":4.1,"longestGap":0,"medianDistance":411,"minHullGap":295.8,"rollsPerMinute":0.01,"rollReversals":0,"pitchReversals":0,"maxRoll":0.006} +{"grid":"initial","variant":"no-lead-hard-gate","name":"horizontal-r400-v300","seconds":60,"radius":15,"firstLock":"4.95","onGun":46.8,"requestFire":12.7,"inRange":100,"medianError":4.04,"p95Error":9.32,"longestGap":1.28,"medianDistance":409,"minHullGap":295.8,"rollsPerMinute":1.2,"rollReversals":64,"pitchReversals":0,"maxRoll":0.282} +{"grid":"initial","variant":"no-lead-hard-gate","name":"horizontal-r800-v150","seconds":60,"radius":15,"firstLock":"3.18","onGun":100,"requestFire":60.3,"inRange":100,"medianError":3.31,"p95Error":3.4,"longestGap":0,"medianDistance":515,"minHullGap":494.9,"rollsPerMinute":0.02,"rollReversals":0,"pitchReversals":0,"maxRoll":0.015} +{"grid":"initial","variant":"no-lead-hard-gate","name":"horizontal-r800-v300","seconds":60,"radius":15,"firstLock":"3.72","onGun":92.8,"requestFire":34.7,"inRange":100,"medianError":3.21,"p95Error":3.58,"longestGap":0.25,"medianDistance":514,"minHullGap":497.3,"rollsPerMinute":0.81,"rollReversals":46,"pitchReversals":0,"maxRoll":0.26} +{"grid":"initial","variant":"no-lead-hard-gate","name":"horizontal-r1600-v150","seconds":60,"radius":15,"firstLock":"2.98","onGun":100,"requestFire":76.4,"inRange":100,"medianError":3.4,"p95Error":3.48,"longestGap":0,"medianDistance":510,"minHullGap":494.6,"rollsPerMinute":0.05,"rollReversals":0,"pitchReversals":0,"maxRoll":0.021} +{"grid":"initial","variant":"no-lead-hard-gate","name":"horizontal-r1600-v300","seconds":60,"radius":15,"firstLock":"3.20","onGun":98.6,"requestFire":58.4,"inRange":100,"medianError":3.34,"p95Error":3.45,"longestGap":0.1,"medianDistance":512,"minHullGap":491.9,"rollsPerMinute":0.4,"rollReversals":19,"pitchReversals":0,"maxRoll":0.191} +{"grid":"initial","variant":"no-lead-hard-gate","name":"vertical-r400-v150","seconds":60,"radius":15,"firstLock":"1.87","onGun":100,"requestFire":43.2,"inRange":100,"medianError":3.56,"p95Error":4.1,"longestGap":0,"medianDistance":410,"minHullGap":298,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"no-lead-hard-gate","name":"vertical-r400-v300","seconds":60,"radius":15,"firstLock":"2.58","onGun":99.6,"requestFire":19,"inRange":100,"medianError":3.36,"p95Error":3.93,"longestGap":0.08,"medianDistance":409,"minHullGap":298,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"no-lead-hard-gate","name":"vertical-r800-v150","seconds":60,"radius":15,"firstLock":"1.67","onGun":100,"requestFire":60.4,"inRange":100,"medianError":3.32,"p95Error":3.41,"longestGap":0,"medianDistance":515,"minHullGap":494.9,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"no-lead-hard-gate","name":"vertical-r800-v300","seconds":60,"radius":15,"firstLock":"2.03","onGun":100,"requestFire":38.4,"inRange":100,"medianError":3.19,"p95Error":3.3,"longestGap":0,"medianDistance":514,"minHullGap":497.1,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"no-lead-hard-gate","name":"vertical-r1600-v150","seconds":60,"radius":15,"firstLock":"1.52","onGun":100,"requestFire":76.8,"inRange":100,"medianError":3.39,"p95Error":3.49,"longestGap":0,"medianDistance":510,"minHullGap":494.5,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"no-lead-hard-gate","name":"vertical-r1600-v300","seconds":60,"radius":15,"firstLock":"1.65","onGun":100,"requestFire":60.8,"inRange":100,"medianError":3.34,"p95Error":3.43,"longestGap":0,"medianDistance":512,"minHullGap":491.9,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"initial","variant":"no-lead-hard-gate","name":"tilted-r400-v150","seconds":60,"radius":15,"firstLock":"4.13","onGun":100,"requestFire":43,"inRange":100,"medianError":3.57,"p95Error":3.92,"longestGap":0,"medianDistance":410,"minHullGap":327.8,"rollsPerMinute":0.56,"rollReversals":0,"pitchReversals":0,"maxRoll":0.12} +{"grid":"initial","variant":"no-lead-hard-gate","name":"tilted-r400-v300","seconds":60,"radius":15,"firstLock":"4.70","onGun":71.5,"requestFire":15.2,"inRange":100,"medianError":3.51,"p95Error":6.37,"longestGap":0.67,"medianDistance":409,"minHullGap":327.8,"rollsPerMinute":1.2,"rollReversals":4,"pitchReversals":0,"maxRoll":0.319} +{"grid":"initial","variant":"no-lead-hard-gate","name":"tilted-r800-v150","seconds":60,"radius":15,"firstLock":"4.15","onGun":100,"requestFire":60.3,"inRange":100,"medianError":3.31,"p95Error":3.4,"longestGap":0,"medianDistance":515,"minHullGap":494.9,"rollsPerMinute":0.04,"rollReversals":0,"pitchReversals":0,"maxRoll":0.051} +{"grid":"initial","variant":"no-lead-hard-gate","name":"tilted-r800-v300","seconds":60,"radius":15,"firstLock":"4.33","onGun":92.3,"requestFire":34.6,"inRange":100,"medianError":3.21,"p95Error":3.59,"longestGap":0.18,"medianDistance":514,"minHullGap":497.2,"rollsPerMinute":0.82,"rollReversals":47,"pitchReversals":0,"maxRoll":0.274} +{"grid":"initial","variant":"no-lead-hard-gate","name":"tilted-r1600-v150","seconds":60,"radius":15,"firstLock":"4.12","onGun":100,"requestFire":76.4,"inRange":100,"medianError":3.39,"p95Error":3.48,"longestGap":0,"medianDistance":510,"minHullGap":494.5,"rollsPerMinute":0.08,"rollReversals":0,"pitchReversals":0,"maxRoll":0.075} +{"grid":"initial","variant":"no-lead-hard-gate","name":"tilted-r1600-v300","seconds":60,"radius":15,"firstLock":"4.28","onGun":98.8,"requestFire":58.9,"inRange":100,"medianError":3.34,"p95Error":3.44,"longestGap":0.1,"medianDistance":512,"minHullGap":491.9,"rollsPerMinute":0.37,"rollReversals":17,"pitchReversals":0,"maxRoll":0.184} +{"grid":"initial","variant":"no-lead-hard-gate","name":"straight-crossing","seconds":60,"radius":15,"firstLock":"2.22","onGun":98.7,"requestFire":98.1,"inRange":100,"medianError":3.37,"p95Error":3.5,"longestGap":0.3,"medianDistance":513,"minHullGap":248,"rollsPerMinute":0.01,"rollReversals":0,"pitchReversals":0,"maxRoll":0.02} +{"grid":"initial","variant":"no-lead-hard-gate","name":"weaving-away","seconds":60,"radius":15,"firstLock":"0.00","onGun":87,"requestFire":51.6,"inRange":100,"medianError":3.22,"p95Error":4.03,"longestGap":0.28,"medianDistance":512,"minHullGap":494.6,"rollsPerMinute":0.61,"rollReversals":37,"pitchReversals":12,"maxRoll":0.265} +{"grid":"initial","variant":"no-lead-hard-gate","name":"straight-away","seconds":60,"radius":15,"firstLock":"0.00","onGun":100,"requestFire":100,"inRange":100,"medianError":0,"p95Error":0,"longestGap":0,"medianDistance":510,"minHullGap":490,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"baseline","name":"horizontal-r600-v200-phase0.7","seconds":45,"radius":15,"firstLock":"2.97","onGun":100,"requestFire":100,"inRange":100,"medianError":1.81,"p95Error":1.91,"longestGap":0,"medianDistance":515,"minHullGap":495.1,"rollsPerMinute":0.27,"rollReversals":6,"pitchReversals":0,"maxRoll":0.174} +{"grid":"holdout","variant":"baseline","name":"horizontal-r600-v200-phase2.1","seconds":45,"radius":15,"firstLock":"2.13","onGun":100,"requestFire":100,"inRange":100,"medianError":1.79,"p95Error":1.91,"longestGap":0,"medianDistance":517,"minHullGap":456.8,"rollsPerMinute":0.41,"rollReversals":8,"pitchReversals":0,"maxRoll":0.323} +{"grid":"holdout","variant":"baseline","name":"horizontal-r600-v200-phase4.2","seconds":45,"radius":15,"firstLock":"1.48","onGun":24.1,"requestFire":24,"inRange":100,"medianError":7.13,"p95Error":11.54,"longestGap":1.7,"medianDistance":517,"minHullGap":495.9,"rollsPerMinute":8.25,"rollReversals":17,"pitchReversals":0,"maxRoll":1.796} +{"grid":"holdout","variant":"baseline","name":"horizontal-r600-v350-phase0.7","seconds":45,"radius":15,"firstLock":"3.53","onGun":25.6,"requestFire":23.2,"inRange":100,"medianError":6.2,"p95Error":10.17,"longestGap":1.22,"medianDistance":516,"minHullGap":496.4,"rollsPerMinute":6.89,"rollReversals":25,"pitchReversals":0,"maxRoll":1.488} +{"grid":"holdout","variant":"baseline","name":"horizontal-r600-v350-phase2.1","seconds":45,"radius":15,"firstLock":"2.03","onGun":26,"requestFire":22.6,"inRange":100,"medianError":6.27,"p95Error":10.15,"longestGap":1.23,"medianDistance":516,"minHullGap":461.3,"rollsPerMinute":6.94,"rollReversals":25,"pitchReversals":0,"maxRoll":1.487} +{"grid":"holdout","variant":"baseline","name":"horizontal-r600-v350-phase4.2","seconds":45,"radius":15,"firstLock":"0.80","onGun":18.7,"requestFire":19,"inRange":100,"medianError":7.71,"p95Error":12.42,"longestGap":1.13,"medianDistance":517,"minHullGap":495.8,"rollsPerMinute":11.39,"rollReversals":27,"pitchReversals":0,"maxRoll":2.303} +{"grid":"holdout","variant":"baseline","name":"horizontal-r1200-v200-phase0.7","seconds":45,"radius":15,"firstLock":"2.67","onGun":100,"requestFire":100,"inRange":100,"medianError":2.54,"p95Error":2.63,"longestGap":0,"medianDistance":512,"minHullGap":491.7,"rollsPerMinute":0.33,"rollReversals":3,"pitchReversals":0,"maxRoll":0.154} +{"grid":"holdout","variant":"baseline","name":"horizontal-r1200-v200-phase2.1","seconds":45,"radius":15,"firstLock":"2.32","onGun":100,"requestFire":100,"inRange":100,"medianError":2.54,"p95Error":2.63,"longestGap":0,"medianDistance":512,"minHullGap":491.8,"rollsPerMinute":0.46,"rollReversals":6,"pitchReversals":0,"maxRoll":0.271} +{"grid":"holdout","variant":"baseline","name":"horizontal-r1200-v200-phase4.2","seconds":45,"radius":15,"firstLock":"2.57","onGun":23,"requestFire":23,"inRange":100,"medianError":7.11,"p95Error":11.67,"longestGap":2.7,"medianDistance":514,"minHullGap":495.5,"rollsPerMinute":8.92,"rollReversals":2,"pitchReversals":9,"maxRoll":1.694} +{"grid":"holdout","variant":"baseline","name":"horizontal-r1200-v350-phase0.7","seconds":45,"radius":15,"firstLock":"2.93","onGun":24.2,"requestFire":23.7,"inRange":100,"medianError":7.27,"p95Error":17.44,"longestGap":1.92,"medianDistance":515,"minHullGap":495,"rollsPerMinute":9.92,"rollReversals":12,"pitchReversals":5,"maxRoll":2.442} +{"grid":"holdout","variant":"baseline","name":"horizontal-r1200-v350-phase2.1","seconds":45,"radius":15,"firstLock":"2.17","onGun":21.2,"requestFire":20.5,"inRange":100,"medianError":7.96,"p95Error":17.7,"longestGap":1.88,"medianDistance":516,"minHullGap":495.1,"rollsPerMinute":10.11,"rollReversals":11,"pitchReversals":6,"maxRoll":2.452} +{"grid":"holdout","variant":"baseline","name":"horizontal-r1200-v350-phase4.2","seconds":45,"radius":15,"firstLock":"1.92","onGun":22,"requestFire":21.2,"inRange":100,"medianError":7.87,"p95Error":17.68,"longestGap":1.9,"medianDistance":515,"minHullGap":495.1,"rollsPerMinute":10.2,"rollReversals":12,"pitchReversals":5,"maxRoll":2.449} +{"grid":"holdout","variant":"baseline","name":"horizontal-r2400-v200-phase0.7","seconds":45,"radius":15,"firstLock":"2.53","onGun":100,"requestFire":100,"inRange":100,"medianError":3,"p95Error":3.12,"longestGap":0,"medianDistance":515,"minHullGap":493.6,"rollsPerMinute":0.54,"rollReversals":8,"pitchReversals":0,"maxRoll":0.224} +{"grid":"holdout","variant":"baseline","name":"horizontal-r2400-v200-phase2.1","seconds":45,"radius":15,"firstLock":"2.47","onGun":100,"requestFire":100,"inRange":100,"medianError":3.02,"p95Error":3.18,"longestGap":0,"medianDistance":515,"minHullGap":493.7,"rollsPerMinute":0.6,"rollReversals":8,"pitchReversals":0,"maxRoll":0.238} +{"grid":"holdout","variant":"baseline","name":"horizontal-r2400-v200-phase4.2","seconds":45,"radius":15,"firstLock":"3.80","onGun":13.9,"requestFire":13.9,"inRange":100,"medianError":8.57,"p95Error":12.56,"longestGap":24.28,"medianDistance":516,"minHullGap":494.3,"rollsPerMinute":11.13,"rollReversals":3,"pitchReversals":2,"maxRoll":1.776} +{"grid":"holdout","variant":"baseline","name":"horizontal-r2400-v350-phase0.7","seconds":45,"radius":15,"firstLock":"2.63","onGun":30.5,"requestFire":30.6,"inRange":100,"medianError":6.2,"p95Error":12.55,"longestGap":5.18,"medianDistance":513,"minHullGap":492.2,"rollsPerMinute":8.1,"rollReversals":13,"pitchReversals":4,"maxRoll":1.793} +{"grid":"holdout","variant":"baseline","name":"horizontal-r2400-v350-phase2.1","seconds":45,"radius":15,"firstLock":"2.38","onGun":19.9,"requestFire":20.1,"inRange":100,"medianError":6.84,"p95Error":12.99,"longestGap":4.7,"medianDistance":515,"minHullGap":494,"rollsPerMinute":8.95,"rollReversals":12,"pitchReversals":7,"maxRoll":1.806} +{"grid":"holdout","variant":"baseline","name":"horizontal-r2400-v350-phase4.2","seconds":45,"radius":15,"firstLock":"3.42","onGun":18.8,"requestFire":18.9,"inRange":100,"medianError":7.01,"p95Error":12.85,"longestGap":4.82,"medianDistance":515,"minHullGap":492.2,"rollsPerMinute":9.18,"rollReversals":11,"pitchReversals":7,"maxRoll":1.779} +{"grid":"holdout","variant":"baseline","name":"vertical-r600-v200-phase0.7","seconds":45,"radius":15,"firstLock":"2.43","onGun":100,"requestFire":100,"inRange":100,"medianError":1.82,"p95Error":1.91,"longestGap":0,"medianDistance":515,"minHullGap":494.9,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"baseline","name":"vertical-r600-v200-phase2.1","seconds":45,"radius":15,"firstLock":"1.77","onGun":100,"requestFire":100,"inRange":100,"medianError":1.78,"p95Error":1.91,"longestGap":0,"medianDistance":517,"minHullGap":464.7,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"baseline","name":"vertical-r600-v200-phase4.2","seconds":45,"radius":15,"firstLock":"0.55","onGun":100,"requestFire":100,"inRange":100,"medianError":1.82,"p95Error":1.9,"longestGap":0,"medianDistance":517,"minHullGap":496.3,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"baseline","name":"vertical-r600-v350-phase0.7","seconds":45,"radius":15,"firstLock":"3.10","onGun":100,"requestFire":100,"inRange":100,"medianError":1.13,"p95Error":1.46,"longestGap":0,"medianDistance":514,"minHullGap":496.1,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"baseline","name":"vertical-r600-v350-phase2.1","seconds":45,"radius":15,"firstLock":"1.70","onGun":100,"requestFire":100,"inRange":100,"medianError":1.22,"p95Error":1.48,"longestGap":0,"medianDistance":516,"minHullGap":469,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"baseline","name":"vertical-r600-v350-phase4.2","seconds":45,"radius":15,"firstLock":"0.57","onGun":100,"requestFire":100,"inRange":100,"medianError":1.14,"p95Error":1.46,"longestGap":0,"medianDistance":514,"minHullGap":496.1,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"baseline","name":"vertical-r1200-v200-phase0.7","seconds":45,"radius":15,"firstLock":"2.17","onGun":100,"requestFire":100,"inRange":100,"medianError":2.54,"p95Error":2.62,"longestGap":0,"medianDistance":512,"minHullGap":491.7,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"baseline","name":"vertical-r1200-v200-phase2.1","seconds":45,"radius":15,"firstLock":"1.92","onGun":100,"requestFire":100,"inRange":100,"medianError":2.53,"p95Error":2.62,"longestGap":0,"medianDistance":512,"minHullGap":491.7,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"baseline","name":"vertical-r1200-v200-phase4.2","seconds":45,"radius":15,"firstLock":"0.48","onGun":100,"requestFire":100,"inRange":100,"medianError":2.54,"p95Error":2.62,"longestGap":0,"medianDistance":512,"minHullGap":491.7,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"baseline","name":"vertical-r1200-v350-phase0.7","seconds":45,"radius":15,"firstLock":"2.42","onGun":100,"requestFire":100,"inRange":100,"medianError":2.06,"p95Error":2.17,"longestGap":0,"medianDistance":514,"minHullGap":492,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"baseline","name":"vertical-r1200-v350-phase2.1","seconds":45,"radius":15,"firstLock":"1.78","onGun":100,"requestFire":100,"inRange":100,"medianError":2.06,"p95Error":2.17,"longestGap":0,"medianDistance":514,"minHullGap":492,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"baseline","name":"vertical-r1200-v350-phase4.2","seconds":45,"radius":15,"firstLock":"0.48","onGun":100,"requestFire":100,"inRange":100,"medianError":2.07,"p95Error":2.17,"longestGap":0,"medianDistance":514,"minHullGap":492,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"baseline","name":"vertical-r2400-v200-phase0.7","seconds":45,"radius":15,"firstLock":"2.03","onGun":100,"requestFire":100,"inRange":100,"medianError":3.02,"p95Error":3.09,"longestGap":0,"medianDistance":514,"minHullGap":493.6,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"baseline","name":"vertical-r2400-v200-phase2.1","seconds":45,"radius":15,"firstLock":"2.03","onGun":100,"requestFire":100,"inRange":100,"medianError":3.02,"p95Error":3.08,"longestGap":0,"medianDistance":515,"minHullGap":493.6,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"baseline","name":"vertical-r2400-v200-phase4.2","seconds":45,"radius":15,"firstLock":"0.53","onGun":100,"requestFire":100,"inRange":100,"medianError":3.02,"p95Error":3.09,"longestGap":0,"medianDistance":514,"minHullGap":493.6,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"baseline","name":"vertical-r2400-v350-phase0.7","seconds":45,"radius":15,"firstLock":"2.13","onGun":100,"requestFire":100,"inRange":100,"medianError":2.75,"p95Error":2.83,"longestGap":0,"medianDistance":510,"minHullGap":490.1,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"baseline","name":"vertical-r2400-v350-phase2.1","seconds":45,"radius":15,"firstLock":"1.95","onGun":100,"requestFire":100,"inRange":100,"medianError":2.75,"p95Error":2.83,"longestGap":0,"medianDistance":510,"minHullGap":490.1,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"baseline","name":"vertical-r2400-v350-phase4.2","seconds":45,"radius":15,"firstLock":"0.50","onGun":100,"requestFire":100,"inRange":100,"medianError":2.76,"p95Error":2.83,"longestGap":0,"medianDistance":510,"minHullGap":490,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"baseline","name":"tilted-r600-v200-phase0.7","seconds":45,"radius":15,"firstLock":"2.10","onGun":19,"requestFire":18.3,"inRange":100,"medianError":8.57,"p95Error":11.71,"longestGap":1.7,"medianDistance":518,"minHullGap":496.1,"rollsPerMinute":8.85,"rollReversals":16,"pitchReversals":0,"maxRoll":1.779} +{"grid":"holdout","variant":"baseline","name":"tilted-r600-v200-phase2.1","seconds":45,"radius":15,"firstLock":"1.83","onGun":24.8,"requestFire":25,"inRange":100,"medianError":6.95,"p95Error":11.18,"longestGap":1.7,"medianDistance":517,"minHullGap":497.5,"rollsPerMinute":8.02,"rollReversals":18,"pitchReversals":0,"maxRoll":1.765} +{"grid":"holdout","variant":"baseline","name":"tilted-r600-v200-phase4.2","seconds":45,"radius":15,"firstLock":"0.83","onGun":23.7,"requestFire":23.8,"inRange":100,"medianError":7.17,"p95Error":11.47,"longestGap":1.7,"medianDistance":517,"minHullGap":494.9,"rollsPerMinute":8.2,"rollReversals":17,"pitchReversals":0,"maxRoll":1.778} +{"grid":"holdout","variant":"baseline","name":"tilted-r600-v350-phase0.7","seconds":45,"radius":15,"firstLock":"2.32","onGun":24.4,"requestFire":21.2,"inRange":100,"medianError":6.45,"p95Error":10.2,"longestGap":1.22,"medianDistance":517,"minHullGap":497.4,"rollsPerMinute":6.97,"rollReversals":25,"pitchReversals":0,"maxRoll":1.413} +{"grid":"holdout","variant":"baseline","name":"tilted-r600-v350-phase2.1","seconds":45,"radius":15,"firstLock":"1.80","onGun":25.2,"requestFire":21.4,"inRange":100,"medianError":6.28,"p95Error":10.21,"longestGap":1.22,"medianDistance":517,"minHullGap":497.8,"rollsPerMinute":6.89,"rollReversals":25,"pitchReversals":0,"maxRoll":1.374} +{"grid":"holdout","variant":"baseline","name":"tilted-r600-v350-phase4.2","seconds":45,"radius":15,"firstLock":"0.83","onGun":19.9,"requestFire":21.1,"inRange":100,"medianError":7.93,"p95Error":12.61,"longestGap":1.03,"medianDistance":517,"minHullGap":497,"rollsPerMinute":12.32,"rollReversals":28,"pitchReversals":0,"maxRoll":2.303} +{"grid":"holdout","variant":"baseline","name":"tilted-r1200-v200-phase0.7","seconds":45,"radius":15,"firstLock":"2.03","onGun":22.1,"requestFire":21.9,"inRange":100,"medianError":7.89,"p95Error":11.18,"longestGap":2.6,"medianDistance":517,"minHullGap":495.5,"rollsPerMinute":9.16,"rollReversals":0,"pitchReversals":10,"maxRoll":1.934} +{"grid":"holdout","variant":"baseline","name":"tilted-r1200-v200-phase2.1","seconds":45,"radius":15,"firstLock":"1.88","onGun":22.2,"requestFire":22.2,"inRange":100,"medianError":7.72,"p95Error":11.57,"longestGap":2.65,"medianDistance":515,"minHullGap":495.5,"rollsPerMinute":9.1,"rollReversals":1,"pitchReversals":10,"maxRoll":1.897} +{"grid":"holdout","variant":"baseline","name":"tilted-r1200-v200-phase4.2","seconds":45,"radius":15,"firstLock":"0.92","onGun":21.9,"requestFire":21.7,"inRange":100,"medianError":7.97,"p95Error":11.36,"longestGap":2.62,"medianDistance":515,"minHullGap":494.8,"rollsPerMinute":9.16,"rollReversals":0,"pitchReversals":10,"maxRoll":1.858} +{"grid":"holdout","variant":"baseline","name":"tilted-r1200-v350-phase0.7","seconds":45,"radius":15,"firstLock":"2.12","onGun":20.7,"requestFire":20.1,"inRange":100,"medianError":8.03,"p95Error":18.03,"longestGap":1.9,"medianDistance":515,"minHullGap":495.1,"rollsPerMinute":10.44,"rollReversals":11,"pitchReversals":5,"maxRoll":2.453} +{"grid":"holdout","variant":"baseline","name":"tilted-r1200-v350-phase2.1","seconds":45,"radius":15,"firstLock":"1.87","onGun":20.2,"requestFire":19.9,"inRange":100,"medianError":8.23,"p95Error":16.59,"longestGap":2,"medianDistance":516,"minHullGap":495.1,"rollsPerMinute":10.25,"rollReversals":13,"pitchReversals":3,"maxRoll":2.448} +{"grid":"holdout","variant":"baseline","name":"tilted-r1200-v350-phase4.2","seconds":45,"radius":15,"firstLock":"0.87","onGun":19.4,"requestFire":19.7,"inRange":100,"medianError":8.83,"p95Error":16.33,"longestGap":2,"medianDistance":516,"minHullGap":496.2,"rollsPerMinute":10.5,"rollReversals":16,"pitchReversals":0,"maxRoll":2.386} +{"grid":"holdout","variant":"baseline","name":"tilted-r2400-v200-phase0.7","seconds":45,"radius":15,"firstLock":"2.35","onGun":8.7,"requestFire":8.7,"inRange":100,"medianError":9.31,"p95Error":12.58,"longestGap":25.4,"medianDistance":517,"minHullGap":498,"rollsPerMinute":11.59,"rollReversals":3,"pitchReversals":1,"maxRoll":1.763} +{"grid":"holdout","variant":"baseline","name":"tilted-r2400-v200-phase2.1","seconds":45,"radius":15,"firstLock":"1.93","onGun":14.9,"requestFire":14.9,"inRange":100,"medianError":8.08,"p95Error":12.37,"longestGap":19.75,"medianDistance":517,"minHullGap":492.9,"rollsPerMinute":10.56,"rollReversals":5,"pitchReversals":3,"maxRoll":1.762} +{"grid":"holdout","variant":"baseline","name":"tilted-r2400-v200-phase4.2","seconds":45,"radius":15,"firstLock":"3.58","onGun":41.4,"requestFire":41.6,"inRange":100,"medianError":4.22,"p95Error":8.05,"longestGap":3.23,"medianDistance":513,"minHullGap":492.9,"rollsPerMinute":6.82,"rollReversals":6,"pitchReversals":7,"maxRoll":1.765} +{"grid":"holdout","variant":"baseline","name":"tilted-r2400-v350-phase0.7","seconds":45,"radius":15,"firstLock":"4.90","onGun":20.7,"requestFire":20.8,"inRange":100,"medianError":6.99,"p95Error":12.7,"longestGap":4.83,"medianDistance":515,"minHullGap":493,"rollsPerMinute":9.05,"rollReversals":11,"pitchReversals":8,"maxRoll":2.294} +{"grid":"holdout","variant":"baseline","name":"tilted-r2400-v350-phase2.1","seconds":45,"radius":15,"firstLock":"4.58","onGun":21.4,"requestFire":21.4,"inRange":100,"medianError":6.49,"p95Error":12.35,"longestGap":4.7,"medianDistance":514,"minHullGap":493.9,"rollsPerMinute":8.78,"rollReversals":10,"pitchReversals":9,"maxRoll":2.386} +{"grid":"holdout","variant":"baseline","name":"tilted-r2400-v350-phase4.2","seconds":45,"radius":15,"firstLock":"3.42","onGun":21,"requestFire":21.2,"inRange":100,"medianError":6.76,"p95Error":12.43,"longestGap":4.53,"medianDistance":516,"minHullGap":494.2,"rollsPerMinute":8.87,"rollReversals":10,"pitchReversals":9,"maxRoll":1.714} +{"grid":"holdout","variant":"baseline","name":"horizontal-r600-v200-phase0.7","seconds":90,"radius":15,"firstLock":"2.97","onGun":100,"requestFire":100,"inRange":100,"medianError":1.83,"p95Error":1.9,"longestGap":0,"medianDistance":514,"minHullGap":495.1,"rollsPerMinute":0.13,"rollReversals":6,"pitchReversals":0,"maxRoll":0.174} +{"grid":"holdout","variant":"baseline","name":"horizontal-r600-v200-phase2.1","seconds":90,"radius":15,"firstLock":"2.13","onGun":100,"requestFire":100,"inRange":100,"medianError":1.83,"p95Error":1.9,"longestGap":0,"medianDistance":517,"minHullGap":456.8,"rollsPerMinute":0.19,"rollReversals":8,"pitchReversals":0,"maxRoll":0.323} +{"grid":"holdout","variant":"baseline","name":"horizontal-r600-v200-phase4.2","seconds":90,"radius":15,"firstLock":"1.48","onGun":21.3,"requestFire":21,"inRange":100,"medianError":7.67,"p95Error":11.73,"longestGap":1.7,"medianDistance":518,"minHullGap":495.9,"rollsPerMinute":8.64,"rollReversals":39,"pitchReversals":0,"maxRoll":1.796} +{"grid":"holdout","variant":"baseline","name":"horizontal-r600-v350-phase0.7","seconds":90,"radius":15,"firstLock":"3.53","onGun":21.4,"requestFire":20.4,"inRange":100,"medianError":7.05,"p95Error":11.95,"longestGap":1.23,"medianDistance":517,"minHullGap":496.4,"rollsPerMinute":9.17,"rollReversals":59,"pitchReversals":0,"maxRoll":2.297} +{"grid":"holdout","variant":"baseline","name":"horizontal-r600-v350-phase2.1","seconds":90,"radius":15,"firstLock":"2.03","onGun":22.1,"requestFire":20.6,"inRange":100,"medianError":7.03,"p95Error":12.21,"longestGap":1.23,"medianDistance":516,"minHullGap":461.3,"rollsPerMinute":9.21,"rollReversals":60,"pitchReversals":0,"maxRoll":2.302} +{"grid":"holdout","variant":"baseline","name":"horizontal-r600-v350-phase4.2","seconds":90,"radius":15,"firstLock":"0.80","onGun":19.5,"requestFire":20.3,"inRange":100,"medianError":7.86,"p95Error":12.71,"longestGap":1.13,"medianDistance":517,"minHullGap":495.8,"rollsPerMinute":12.01,"rollReversals":63,"pitchReversals":0,"maxRoll":2.303} +{"grid":"holdout","variant":"baseline","name":"horizontal-r1200-v200-phase0.7","seconds":90,"radius":15,"firstLock":"2.67","onGun":100,"requestFire":100,"inRange":100,"medianError":2.55,"p95Error":2.63,"longestGap":0,"medianDistance":511,"minHullGap":491.7,"rollsPerMinute":0.2,"rollReversals":3,"pitchReversals":0,"maxRoll":0.154} +{"grid":"holdout","variant":"baseline","name":"horizontal-r1200-v200-phase2.1","seconds":90,"radius":15,"firstLock":"2.32","onGun":100,"requestFire":100,"inRange":100,"medianError":2.55,"p95Error":2.63,"longestGap":0,"medianDistance":511,"minHullGap":491.7,"rollsPerMinute":0.28,"rollReversals":6,"pitchReversals":0,"maxRoll":0.271} +{"grid":"holdout","variant":"baseline","name":"horizontal-r1200-v200-phase4.2","seconds":90,"radius":15,"firstLock":"2.57","onGun":22.4,"requestFire":22.4,"inRange":100,"medianError":7.49,"p95Error":11.61,"longestGap":2.7,"medianDistance":514,"minHullGap":495.5,"rollsPerMinute":8.99,"rollReversals":2,"pitchReversals":22,"maxRoll":1.694} +{"grid":"holdout","variant":"baseline","name":"horizontal-r1200-v350-phase0.7","seconds":90,"radius":15,"firstLock":"2.93","onGun":22.3,"requestFire":21.8,"inRange":100,"medianError":7.64,"p95Error":17.65,"longestGap":1.92,"medianDistance":515,"minHullGap":495,"rollsPerMinute":10.17,"rollReversals":26,"pitchReversals":12,"maxRoll":2.446} +{"grid":"holdout","variant":"baseline","name":"horizontal-r1200-v350-phase2.1","seconds":90,"radius":15,"firstLock":"2.17","onGun":20.6,"requestFire":20.4,"inRange":100,"medianError":8.29,"p95Error":16.68,"longestGap":2,"medianDistance":516,"minHullGap":495.1,"rollsPerMinute":10.32,"rollReversals":32,"pitchReversals":6,"maxRoll":2.452} +{"grid":"holdout","variant":"baseline","name":"horizontal-r1200-v350-phase4.2","seconds":90,"radius":15,"firstLock":"1.92","onGun":21.4,"requestFire":20.8,"inRange":100,"medianError":7.96,"p95Error":17.68,"longestGap":1.92,"medianDistance":515,"minHullGap":495.1,"rollsPerMinute":10.29,"rollReversals":26,"pitchReversals":12,"maxRoll":2.449} +{"grid":"holdout","variant":"baseline","name":"horizontal-r2400-v200-phase0.7","seconds":90,"radius":15,"firstLock":"2.53","onGun":66.6,"requestFire":66.6,"inRange":100,"medianError":3.08,"p95Error":10.7,"longestGap":12.27,"medianDistance":514,"minHullGap":492.5,"rollsPerMinute":4.31,"rollReversals":14,"pitchReversals":4,"maxRoll":1.76} +{"grid":"holdout","variant":"baseline","name":"horizontal-r2400-v200-phase2.1","seconds":90,"radius":15,"firstLock":"2.47","onGun":55.9,"requestFire":56,"inRange":100,"medianError":3.17,"p95Error":12.22,"longestGap":31.15,"medianDistance":515,"minHullGap":493.7,"rollsPerMinute":5.9,"rollReversals":11,"pitchReversals":1,"maxRoll":1.762} +{"grid":"holdout","variant":"baseline","name":"horizontal-r2400-v200-phase4.2","seconds":90,"radius":15,"firstLock":"3.80","onGun":6.1,"requestFire":6.1,"inRange":100,"medianError":9.95,"p95Error":12.7,"longestGap":69.28,"medianDistance":517,"minHullGap":494.3,"rollsPerMinute":12.36,"rollReversals":3,"pitchReversals":2,"maxRoll":1.776} +{"grid":"holdout","variant":"baseline","name":"horizontal-r2400-v350-phase0.7","seconds":90,"radius":15,"firstLock":"2.63","onGun":26.5,"requestFire":26.6,"inRange":100,"medianError":6.23,"p95Error":12.42,"longestGap":5.18,"medianDistance":514,"minHullGap":492.2,"rollsPerMinute":8.37,"rollReversals":30,"pitchReversals":13,"maxRoll":1.793} +{"grid":"holdout","variant":"baseline","name":"horizontal-r2400-v350-phase2.1","seconds":90,"radius":15,"firstLock":"2.38","onGun":20,"requestFire":20.2,"inRange":100,"medianError":6.73,"p95Error":12.82,"longestGap":4.97,"medianDistance":515,"minHullGap":494,"rollsPerMinute":8.92,"rollReversals":30,"pitchReversals":16,"maxRoll":1.806} +{"grid":"holdout","variant":"baseline","name":"horizontal-r2400-v350-phase4.2","seconds":90,"radius":15,"firstLock":"3.42","onGun":22.3,"requestFire":22.4,"inRange":100,"medianError":6.33,"p95Error":12.42,"longestGap":5.12,"medianDistance":514,"minHullGap":491.9,"rollsPerMinute":8.7,"rollReversals":30,"pitchReversals":14,"maxRoll":1.779} +{"grid":"holdout","variant":"baseline","name":"vertical-r600-v200-phase0.7","seconds":90,"radius":15,"firstLock":"2.43","onGun":100,"requestFire":100,"inRange":100,"medianError":1.83,"p95Error":1.91,"longestGap":0,"medianDistance":514,"minHullGap":494.9,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"baseline","name":"vertical-r600-v200-phase2.1","seconds":90,"radius":15,"firstLock":"1.77","onGun":100,"requestFire":100,"inRange":100,"medianError":1.83,"p95Error":1.9,"longestGap":0,"medianDistance":517,"minHullGap":464.7,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"baseline","name":"vertical-r600-v200-phase4.2","seconds":90,"radius":15,"firstLock":"0.55","onGun":100,"requestFire":100,"inRange":100,"medianError":1.83,"p95Error":1.9,"longestGap":0,"medianDistance":517,"minHullGap":496.3,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"baseline","name":"vertical-r600-v350-phase0.7","seconds":90,"radius":15,"firstLock":"3.10","onGun":100,"requestFire":100,"inRange":100,"medianError":1.2,"p95Error":1.48,"longestGap":0,"medianDistance":514,"minHullGap":496.1,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"baseline","name":"vertical-r600-v350-phase2.1","seconds":90,"radius":15,"firstLock":"1.70","onGun":100,"requestFire":100,"inRange":100,"medianError":1.23,"p95Error":1.48,"longestGap":0,"medianDistance":516,"minHullGap":469,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"baseline","name":"vertical-r600-v350-phase4.2","seconds":90,"radius":15,"firstLock":"0.57","onGun":100,"requestFire":100,"inRange":100,"medianError":1.23,"p95Error":1.48,"longestGap":0,"medianDistance":514,"minHullGap":496.1,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"baseline","name":"vertical-r1200-v200-phase0.7","seconds":90,"radius":15,"firstLock":"2.17","onGun":100,"requestFire":100,"inRange":100,"medianError":2.55,"p95Error":2.63,"longestGap":0,"medianDistance":511,"minHullGap":491.7,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"baseline","name":"vertical-r1200-v200-phase2.1","seconds":90,"radius":15,"firstLock":"1.92","onGun":100,"requestFire":100,"inRange":100,"medianError":2.54,"p95Error":2.62,"longestGap":0,"medianDistance":511,"minHullGap":491.7,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"baseline","name":"vertical-r1200-v200-phase4.2","seconds":90,"radius":15,"firstLock":"0.48","onGun":100,"requestFire":100,"inRange":100,"medianError":2.55,"p95Error":2.63,"longestGap":0,"medianDistance":511,"minHullGap":491.7,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"baseline","name":"vertical-r1200-v350-phase0.7","seconds":90,"radius":15,"firstLock":"2.42","onGun":100,"requestFire":100,"inRange":100,"medianError":2.07,"p95Error":2.17,"longestGap":0,"medianDistance":514,"minHullGap":492,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"baseline","name":"vertical-r1200-v350-phase2.1","seconds":90,"radius":15,"firstLock":"1.78","onGun":100,"requestFire":100,"inRange":100,"medianError":2.07,"p95Error":2.17,"longestGap":0,"medianDistance":514,"minHullGap":492,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"baseline","name":"vertical-r1200-v350-phase4.2","seconds":90,"radius":15,"firstLock":"0.48","onGun":100,"requestFire":100,"inRange":100,"medianError":2.07,"p95Error":2.17,"longestGap":0,"medianDistance":514,"minHullGap":492,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"baseline","name":"vertical-r2400-v200-phase0.7","seconds":90,"radius":15,"firstLock":"2.03","onGun":100,"requestFire":100,"inRange":100,"medianError":3.03,"p95Error":3.09,"longestGap":0,"medianDistance":513,"minHullGap":493.6,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"baseline","name":"vertical-r2400-v200-phase2.1","seconds":90,"radius":15,"firstLock":"2.03","onGun":100,"requestFire":100,"inRange":100,"medianError":3.03,"p95Error":3.09,"longestGap":0,"medianDistance":513,"minHullGap":493.6,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"baseline","name":"vertical-r2400-v200-phase4.2","seconds":90,"radius":15,"firstLock":"0.53","onGun":100,"requestFire":100,"inRange":100,"medianError":3.04,"p95Error":3.09,"longestGap":0,"medianDistance":513,"minHullGap":493.6,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"baseline","name":"vertical-r2400-v350-phase0.7","seconds":90,"radius":15,"firstLock":"2.13","onGun":100,"requestFire":100,"inRange":100,"medianError":2.76,"p95Error":2.83,"longestGap":0,"medianDistance":509,"minHullGap":490.1,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"baseline","name":"vertical-r2400-v350-phase2.1","seconds":90,"radius":15,"firstLock":"1.95","onGun":100,"requestFire":100,"inRange":100,"medianError":2.76,"p95Error":2.83,"longestGap":0,"medianDistance":510,"minHullGap":490.1,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"baseline","name":"vertical-r2400-v350-phase4.2","seconds":90,"radius":15,"firstLock":"0.50","onGun":100,"requestFire":100,"inRange":100,"medianError":2.76,"p95Error":2.83,"longestGap":0,"medianDistance":510,"minHullGap":490,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"baseline","name":"tilted-r600-v200-phase0.7","seconds":90,"radius":15,"firstLock":"2.10","onGun":19.1,"requestFire":18.6,"inRange":100,"medianError":8.57,"p95Error":11.76,"longestGap":1.7,"medianDistance":515,"minHullGap":495.8,"rollsPerMinute":8.89,"rollReversals":38,"pitchReversals":0,"maxRoll":1.795} +{"grid":"holdout","variant":"baseline","name":"tilted-r600-v200-phase2.1","seconds":90,"radius":15,"firstLock":"1.83","onGun":21.5,"requestFire":21.5,"inRange":100,"medianError":7.58,"p95Error":11.7,"longestGap":1.7,"medianDistance":518,"minHullGap":497.5,"rollsPerMinute":8.5,"rollReversals":40,"pitchReversals":0,"maxRoll":1.788} +{"grid":"holdout","variant":"baseline","name":"tilted-r600-v200-phase4.2","seconds":90,"radius":15,"firstLock":"0.83","onGun":21,"requestFire":20.8,"inRange":100,"medianError":7.76,"p95Error":11.74,"longestGap":1.7,"medianDistance":515,"minHullGap":494.9,"rollsPerMinute":8.64,"rollReversals":39,"pitchReversals":0,"maxRoll":1.793} +{"grid":"holdout","variant":"baseline","name":"tilted-r600-v350-phase0.7","seconds":90,"radius":15,"firstLock":"2.32","onGun":21,"requestFire":19.3,"inRange":100,"medianError":7.11,"p95Error":11.89,"longestGap":1.23,"medianDistance":517,"minHullGap":497.4,"rollsPerMinute":8.97,"rollReversals":58,"pitchReversals":0,"maxRoll":2.302} +{"grid":"holdout","variant":"baseline","name":"tilted-r600-v350-phase2.1","seconds":90,"radius":15,"firstLock":"1.80","onGun":21.7,"requestFire":20.1,"inRange":100,"medianError":7.08,"p95Error":12.27,"longestGap":1.22,"medianDistance":516,"minHullGap":497.1,"rollsPerMinute":9.26,"rollReversals":59,"pitchReversals":0,"maxRoll":2.303} +{"grid":"holdout","variant":"baseline","name":"tilted-r600-v350-phase4.2","seconds":90,"radius":15,"firstLock":"0.83","onGun":20.1,"requestFire":21.2,"inRange":100,"medianError":7.98,"p95Error":12.77,"longestGap":1.05,"medianDistance":516,"minHullGap":497,"rollsPerMinute":12.37,"rollReversals":64,"pitchReversals":0,"maxRoll":2.305} +{"grid":"holdout","variant":"baseline","name":"tilted-r1200-v200-phase0.7","seconds":90,"radius":15,"firstLock":"2.03","onGun":21.6,"requestFire":21.4,"inRange":100,"medianError":7.92,"p95Error":11.2,"longestGap":2.63,"medianDistance":515,"minHullGap":495.4,"rollsPerMinute":9.16,"rollReversals":0,"pitchReversals":24,"maxRoll":1.934} +{"grid":"holdout","variant":"baseline","name":"tilted-r1200-v200-phase2.1","seconds":90,"radius":15,"firstLock":"1.88","onGun":22.2,"requestFire":22.2,"inRange":100,"medianError":7.77,"p95Error":11.52,"longestGap":2.67,"medianDistance":514,"minHullGap":495.5,"rollsPerMinute":9.05,"rollReversals":1,"pitchReversals":24,"maxRoll":1.897} +{"grid":"holdout","variant":"baseline","name":"tilted-r1200-v200-phase4.2","seconds":90,"radius":15,"firstLock":"0.92","onGun":22.3,"requestFire":22.1,"inRange":100,"medianError":7.79,"p95Error":11.34,"longestGap":2.65,"medianDistance":515,"minHullGap":494.8,"rollsPerMinute":9.05,"rollReversals":0,"pitchReversals":24,"maxRoll":1.858} +{"grid":"holdout","variant":"baseline","name":"tilted-r1200-v350-phase0.7","seconds":90,"radius":15,"firstLock":"2.12","onGun":21.2,"requestFire":20.6,"inRange":100,"medianError":7.96,"p95Error":17.9,"longestGap":1.9,"medianDistance":515,"minHullGap":495.1,"rollsPerMinute":10.31,"rollReversals":26,"pitchReversals":12,"maxRoll":2.453} +{"grid":"holdout","variant":"baseline","name":"tilted-r1200-v350-phase2.1","seconds":90,"radius":15,"firstLock":"1.87","onGun":19.8,"requestFire":19.7,"inRange":100,"medianError":8.51,"p95Error":16.51,"longestGap":2,"medianDistance":516,"minHullGap":495.1,"rollsPerMinute":10.43,"rollReversals":34,"pitchReversals":3,"maxRoll":2.448} +{"grid":"holdout","variant":"baseline","name":"tilted-r1200-v350-phase4.2","seconds":90,"radius":15,"firstLock":"0.87","onGun":19.2,"requestFire":19.3,"inRange":100,"medianError":8.84,"p95Error":16.36,"longestGap":2,"medianDistance":516,"minHullGap":496.2,"rollsPerMinute":10.48,"rollReversals":37,"pitchReversals":0,"maxRoll":2.386} +{"grid":"holdout","variant":"baseline","name":"tilted-r2400-v200-phase0.7","seconds":90,"radius":15,"firstLock":"2.35","onGun":3.8,"requestFire":3.8,"inRange":100,"medianError":10.08,"p95Error":12.7,"longestGap":70.4,"medianDistance":517,"minHullGap":498,"rollsPerMinute":12.56,"rollReversals":3,"pitchReversals":1,"maxRoll":1.763} +{"grid":"holdout","variant":"baseline","name":"tilted-r2400-v200-phase2.1","seconds":90,"radius":15,"firstLock":"1.93","onGun":6.5,"requestFire":6.5,"inRange":100,"medianError":9.67,"p95Error":12.68,"longestGap":64.75,"medianDistance":517,"minHullGap":492.9,"rollsPerMinute":12.11,"rollReversals":5,"pitchReversals":3,"maxRoll":1.762} +{"grid":"holdout","variant":"baseline","name":"tilted-r2400-v200-phase4.2","seconds":90,"radius":15,"firstLock":"3.58","onGun":18.1,"requestFire":18.2,"inRange":100,"medianError":8.16,"p95Error":12.51,"longestGap":45.03,"medianDistance":515,"minHullGap":492.9,"rollsPerMinute":10.36,"rollReversals":6,"pitchReversals":7,"maxRoll":1.765} +{"grid":"holdout","variant":"baseline","name":"tilted-r2400-v350-phase0.7","seconds":90,"radius":15,"firstLock":"4.90","onGun":21.5,"requestFire":21.6,"inRange":100,"medianError":6.59,"p95Error":12.4,"longestGap":4.88,"medianDistance":515,"minHullGap":491.9,"rollsPerMinute":8.81,"rollReversals":27,"pitchReversals":18,"maxRoll":2.294} +{"grid":"holdout","variant":"baseline","name":"tilted-r2400-v350-phase2.1","seconds":90,"radius":15,"firstLock":"4.58","onGun":21.5,"requestFire":21.6,"inRange":100,"medianError":6.69,"p95Error":12.28,"longestGap":4.7,"medianDistance":515,"minHullGap":492.9,"rollsPerMinute":8.85,"rollReversals":18,"pitchReversals":21,"maxRoll":2.386} +{"grid":"holdout","variant":"baseline","name":"tilted-r2400-v350-phase4.2","seconds":90,"radius":15,"firstLock":"3.42","onGun":21.5,"requestFire":21.7,"inRange":100,"medianError":6.61,"p95Error":12.3,"longestGap":5.08,"medianDistance":515,"minHullGap":492.5,"rollsPerMinute":8.82,"rollReversals":27,"pitchReversals":17,"maxRoll":1.748} +{"grid":"holdout","variant":"hard-gate","name":"horizontal-r600-v200-phase0.7","seconds":45,"radius":15,"firstLock":"4.02","onGun":100,"requestFire":100,"inRange":100,"medianError":1.82,"p95Error":1.91,"longestGap":0,"medianDistance":516,"minHullGap":494.9,"rollsPerMinute":0.03,"rollReversals":0,"pitchReversals":0,"maxRoll":0.021} +{"grid":"holdout","variant":"hard-gate","name":"horizontal-r600-v200-phase2.1","seconds":45,"radius":15,"firstLock":"2.85","onGun":100,"requestFire":100,"inRange":100,"medianError":1.8,"p95Error":1.91,"longestGap":0,"medianDistance":517,"minHullGap":437,"rollsPerMinute":0.04,"rollReversals":0,"pitchReversals":0,"maxRoll":0.027} +{"grid":"holdout","variant":"hard-gate","name":"horizontal-r600-v200-phase4.2","seconds":45,"radius":15,"firstLock":"1.38","onGun":100,"requestFire":100,"inRange":100,"medianError":1.81,"p95Error":1.92,"longestGap":0,"medianDistance":517,"minHullGap":495.8,"rollsPerMinute":0.11,"rollReversals":0,"pitchReversals":0,"maxRoll":0.092} +{"grid":"holdout","variant":"hard-gate","name":"horizontal-r600-v350-phase0.7","seconds":45,"radius":15,"firstLock":"4.17","onGun":86,"requestFire":78,"inRange":100,"medianError":1.78,"p95Error":4.49,"longestGap":0.3,"medianDistance":516,"minHullGap":497.8,"rollsPerMinute":1.66,"rollReversals":43,"pitchReversals":0,"maxRoll":0.318} +{"grid":"holdout","variant":"hard-gate","name":"horizontal-r600-v350-phase2.1","seconds":45,"radius":15,"firstLock":"2.65","onGun":84.5,"requestFire":75.3,"inRange":100,"medianError":1.81,"p95Error":4.48,"longestGap":0.3,"medianDistance":514,"minHullGap":452.9,"rollsPerMinute":1.65,"rollReversals":43,"pitchReversals":0,"maxRoll":0.311} +{"grid":"holdout","variant":"hard-gate","name":"horizontal-r600-v350-phase4.2","seconds":45,"radius":15,"firstLock":"0.80","onGun":83.5,"requestFire":73.8,"inRange":100,"medianError":1.86,"p95Error":4.41,"longestGap":0.3,"medianDistance":515,"minHullGap":495.8,"rollsPerMinute":1.67,"rollReversals":43,"pitchReversals":0,"maxRoll":0.314} +{"grid":"holdout","variant":"hard-gate","name":"horizontal-r1200-v200-phase0.7","seconds":45,"radius":15,"firstLock":"3.63","onGun":100,"requestFire":100,"inRange":100,"medianError":2.54,"p95Error":2.62,"longestGap":0,"medianDistance":512,"minHullGap":491.7,"rollsPerMinute":0.03,"rollReversals":0,"pitchReversals":0,"maxRoll":0.01} +{"grid":"holdout","variant":"hard-gate","name":"horizontal-r1200-v200-phase2.1","seconds":45,"radius":15,"firstLock":"3.12","onGun":100,"requestFire":100,"inRange":100,"medianError":2.53,"p95Error":2.61,"longestGap":0,"medianDistance":515,"minHullGap":480.4,"rollsPerMinute":0.03,"rollReversals":0,"pitchReversals":0,"maxRoll":0.014} +{"grid":"holdout","variant":"hard-gate","name":"horizontal-r1200-v200-phase4.2","seconds":45,"radius":15,"firstLock":"1.80","onGun":100,"requestFire":100,"inRange":100,"medianError":2.54,"p95Error":2.62,"longestGap":0,"medianDistance":512,"minHullGap":491.7,"rollsPerMinute":0.11,"rollReversals":0,"pitchReversals":0,"maxRoll":0.053} +{"grid":"holdout","variant":"hard-gate","name":"horizontal-r1200-v350-phase0.7","seconds":45,"radius":15,"firstLock":"3.98","onGun":100,"requestFire":100,"inRange":100,"medianError":2.06,"p95Error":2.2,"longestGap":0,"medianDistance":514,"minHullGap":492,"rollsPerMinute":0.47,"rollReversals":14,"pitchReversals":0,"maxRoll":0.232} +{"grid":"holdout","variant":"hard-gate","name":"horizontal-r1200-v350-phase2.1","seconds":45,"radius":15,"firstLock":"2.92","onGun":100,"requestFire":100,"inRange":100,"medianError":2.07,"p95Error":2.25,"longestGap":0,"medianDistance":514,"minHullGap":492,"rollsPerMinute":0.66,"rollReversals":26,"pitchReversals":0,"maxRoll":0.234} +{"grid":"holdout","variant":"hard-gate","name":"horizontal-r1200-v350-phase4.2","seconds":45,"radius":15,"firstLock":"1.55","onGun":100,"requestFire":100,"inRange":100,"medianError":2.08,"p95Error":2.28,"longestGap":0,"medianDistance":514,"minHullGap":491.9,"rollsPerMinute":0.67,"rollReversals":26,"pitchReversals":0,"maxRoll":0.245} +{"grid":"holdout","variant":"hard-gate","name":"horizontal-r2400-v200-phase0.7","seconds":45,"radius":15,"firstLock":"3.45","onGun":100,"requestFire":100,"inRange":100,"medianError":3,"p95Error":3.08,"longestGap":0,"medianDistance":515,"minHullGap":493.6,"rollsPerMinute":0.02,"rollReversals":0,"pitchReversals":0,"maxRoll":0.014} +{"grid":"holdout","variant":"hard-gate","name":"horizontal-r2400-v200-phase2.1","seconds":45,"radius":15,"firstLock":"3.32","onGun":100,"requestFire":100,"inRange":100,"medianError":3.01,"p95Error":3.08,"longestGap":0,"medianDistance":515,"minHullGap":493.6,"rollsPerMinute":0.05,"rollReversals":0,"pitchReversals":0,"maxRoll":0.026} +{"grid":"holdout","variant":"hard-gate","name":"horizontal-r2400-v200-phase4.2","seconds":45,"radius":15,"firstLock":"2.32","onGun":100,"requestFire":100,"inRange":100,"medianError":3.02,"p95Error":3.09,"longestGap":0,"medianDistance":514,"minHullGap":493.6,"rollsPerMinute":0.19,"rollReversals":4,"pitchReversals":0,"maxRoll":0.17} +{"grid":"holdout","variant":"hard-gate","name":"horizontal-r2400-v350-phase0.7","seconds":45,"radius":15,"firstLock":"3.60","onGun":100,"requestFire":100,"inRange":100,"medianError":2.74,"p95Error":2.85,"longestGap":0,"medianDistance":510,"minHullGap":490.1,"rollsPerMinute":0.28,"rollReversals":8,"pitchReversals":0,"maxRoll":0.227} +{"grid":"holdout","variant":"hard-gate","name":"horizontal-r2400-v350-phase2.1","seconds":45,"radius":15,"firstLock":"3.20","onGun":100,"requestFire":100,"inRange":100,"medianError":2.75,"p95Error":2.87,"longestGap":0,"medianDistance":510,"minHullGap":490.1,"rollsPerMinute":0.38,"rollReversals":14,"pitchReversals":0,"maxRoll":0.214} +{"grid":"holdout","variant":"hard-gate","name":"horizontal-r2400-v350-phase4.2","seconds":45,"radius":15,"firstLock":"1.78","onGun":100,"requestFire":100,"inRange":100,"medianError":2.75,"p95Error":2.88,"longestGap":0,"medianDistance":510,"minHullGap":490.1,"rollsPerMinute":0.37,"rollReversals":13,"pitchReversals":0,"maxRoll":0.221} +{"grid":"holdout","variant":"hard-gate","name":"vertical-r600-v200-phase0.7","seconds":45,"radius":15,"firstLock":"2.43","onGun":100,"requestFire":100,"inRange":100,"medianError":1.82,"p95Error":1.91,"longestGap":0,"medianDistance":515,"minHullGap":494.9,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"hard-gate","name":"vertical-r600-v200-phase2.1","seconds":45,"radius":15,"firstLock":"1.77","onGun":100,"requestFire":100,"inRange":100,"medianError":1.78,"p95Error":1.91,"longestGap":0,"medianDistance":517,"minHullGap":464.7,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"hard-gate","name":"vertical-r600-v200-phase4.2","seconds":45,"radius":15,"firstLock":"0.55","onGun":100,"requestFire":100,"inRange":100,"medianError":1.82,"p95Error":1.9,"longestGap":0,"medianDistance":517,"minHullGap":496.3,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"hard-gate","name":"vertical-r600-v350-phase0.7","seconds":45,"radius":15,"firstLock":"3.10","onGun":100,"requestFire":100,"inRange":100,"medianError":1.13,"p95Error":1.46,"longestGap":0,"medianDistance":514,"minHullGap":496.1,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"hard-gate","name":"vertical-r600-v350-phase2.1","seconds":45,"radius":15,"firstLock":"1.70","onGun":100,"requestFire":100,"inRange":100,"medianError":1.22,"p95Error":1.48,"longestGap":0,"medianDistance":516,"minHullGap":469,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"hard-gate","name":"vertical-r600-v350-phase4.2","seconds":45,"radius":15,"firstLock":"0.57","onGun":100,"requestFire":100,"inRange":100,"medianError":1.14,"p95Error":1.46,"longestGap":0,"medianDistance":514,"minHullGap":496.1,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"hard-gate","name":"vertical-r1200-v200-phase0.7","seconds":45,"radius":15,"firstLock":"2.17","onGun":100,"requestFire":100,"inRange":100,"medianError":2.54,"p95Error":2.62,"longestGap":0,"medianDistance":512,"minHullGap":491.7,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"hard-gate","name":"vertical-r1200-v200-phase2.1","seconds":45,"radius":15,"firstLock":"1.92","onGun":100,"requestFire":100,"inRange":100,"medianError":2.53,"p95Error":2.62,"longestGap":0,"medianDistance":512,"minHullGap":491.7,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"hard-gate","name":"vertical-r1200-v200-phase4.2","seconds":45,"radius":15,"firstLock":"0.48","onGun":100,"requestFire":100,"inRange":100,"medianError":2.54,"p95Error":2.62,"longestGap":0,"medianDistance":512,"minHullGap":491.7,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"hard-gate","name":"vertical-r1200-v350-phase0.7","seconds":45,"radius":15,"firstLock":"2.42","onGun":100,"requestFire":100,"inRange":100,"medianError":2.06,"p95Error":2.17,"longestGap":0,"medianDistance":514,"minHullGap":492,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"hard-gate","name":"vertical-r1200-v350-phase2.1","seconds":45,"radius":15,"firstLock":"1.78","onGun":100,"requestFire":100,"inRange":100,"medianError":2.06,"p95Error":2.17,"longestGap":0,"medianDistance":514,"minHullGap":492,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"hard-gate","name":"vertical-r1200-v350-phase4.2","seconds":45,"radius":15,"firstLock":"0.48","onGun":100,"requestFire":100,"inRange":100,"medianError":2.07,"p95Error":2.17,"longestGap":0,"medianDistance":514,"minHullGap":492,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"hard-gate","name":"vertical-r2400-v200-phase0.7","seconds":45,"radius":15,"firstLock":"2.03","onGun":100,"requestFire":100,"inRange":100,"medianError":3.02,"p95Error":3.09,"longestGap":0,"medianDistance":514,"minHullGap":493.6,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"hard-gate","name":"vertical-r2400-v200-phase2.1","seconds":45,"radius":15,"firstLock":"2.03","onGun":100,"requestFire":100,"inRange":100,"medianError":3.02,"p95Error":3.08,"longestGap":0,"medianDistance":515,"minHullGap":493.6,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"hard-gate","name":"vertical-r2400-v200-phase4.2","seconds":45,"radius":15,"firstLock":"0.53","onGun":100,"requestFire":100,"inRange":100,"medianError":3.02,"p95Error":3.09,"longestGap":0,"medianDistance":514,"minHullGap":493.6,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"hard-gate","name":"vertical-r2400-v350-phase0.7","seconds":45,"radius":15,"firstLock":"2.13","onGun":100,"requestFire":100,"inRange":100,"medianError":2.75,"p95Error":2.83,"longestGap":0,"medianDistance":510,"minHullGap":490.1,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"hard-gate","name":"vertical-r2400-v350-phase2.1","seconds":45,"radius":15,"firstLock":"1.95","onGun":100,"requestFire":100,"inRange":100,"medianError":2.75,"p95Error":2.83,"longestGap":0,"medianDistance":510,"minHullGap":490.1,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"hard-gate","name":"vertical-r2400-v350-phase4.2","seconds":45,"radius":15,"firstLock":"0.50","onGun":100,"requestFire":100,"inRange":100,"medianError":2.76,"p95Error":2.83,"longestGap":0,"medianDistance":510,"minHullGap":490,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"hard-gate","name":"tilted-r600-v200-phase0.7","seconds":45,"radius":15,"firstLock":"3.73","onGun":100,"requestFire":100,"inRange":100,"medianError":1.82,"p95Error":1.93,"longestGap":0,"medianDistance":515,"minHullGap":495.1,"rollsPerMinute":0.13,"rollReversals":0,"pitchReversals":0,"maxRoll":0.169} +{"grid":"holdout","variant":"hard-gate","name":"tilted-r600-v200-phase2.1","seconds":45,"radius":15,"firstLock":"4.08","onGun":100,"requestFire":100,"inRange":100,"medianError":1.8,"p95Error":1.91,"longestGap":0,"medianDistance":517,"minHullGap":484.1,"rollsPerMinute":0.15,"rollReversals":0,"pitchReversals":0,"maxRoll":0.212} +{"grid":"holdout","variant":"hard-gate","name":"tilted-r600-v200-phase4.2","seconds":45,"radius":15,"firstLock":"2.62","onGun":100,"requestFire":100,"inRange":100,"medianError":1.81,"p95Error":1.93,"longestGap":0,"medianDistance":515,"minHullGap":495.1,"rollsPerMinute":0.13,"rollReversals":0,"pitchReversals":0,"maxRoll":0.104} +{"grid":"holdout","variant":"hard-gate","name":"tilted-r600-v350-phase0.7","seconds":45,"radius":15,"firstLock":"4.72","onGun":81.7,"requestFire":74.7,"inRange":100,"medianError":1.75,"p95Error":4.91,"longestGap":0.3,"medianDistance":514,"minHullGap":493.6,"rollsPerMinute":1.63,"rollReversals":41,"pitchReversals":0,"maxRoll":0.31} +{"grid":"holdout","variant":"hard-gate","name":"tilted-r600-v350-phase2.1","seconds":45,"radius":15,"firstLock":"4.60","onGun":79.7,"requestFire":71.7,"inRange":100,"medianError":1.87,"p95Error":4.76,"longestGap":0.35,"medianDistance":516,"minHullGap":488.5,"rollsPerMinute":1.72,"rollReversals":42,"pitchReversals":0,"maxRoll":0.311} +{"grid":"holdout","variant":"hard-gate","name":"tilted-r600-v350-phase4.2","seconds":45,"radius":15,"firstLock":"2.72","onGun":80.1,"requestFire":71.3,"inRange":100,"medianError":1.88,"p95Error":4.84,"longestGap":0.3,"medianDistance":513,"minHullGap":494.4,"rollsPerMinute":1.71,"rollReversals":42,"pitchReversals":0,"maxRoll":0.314} +{"grid":"holdout","variant":"hard-gate","name":"tilted-r1200-v200-phase0.7","seconds":45,"radius":15,"firstLock":"3.03","onGun":100,"requestFire":100,"inRange":100,"medianError":2.54,"p95Error":2.63,"longestGap":0,"medianDistance":512,"minHullGap":491.7,"rollsPerMinute":0.09,"rollReversals":0,"pitchReversals":0,"maxRoll":0.068} +{"grid":"holdout","variant":"hard-gate","name":"tilted-r1200-v200-phase2.1","seconds":45,"radius":15,"firstLock":"4.13","onGun":100,"requestFire":100,"inRange":100,"medianError":2.53,"p95Error":2.62,"longestGap":0,"medianDistance":512,"minHullGap":491.7,"rollsPerMinute":0.1,"rollReversals":0,"pitchReversals":0,"maxRoll":0.081} +{"grid":"holdout","variant":"hard-gate","name":"tilted-r1200-v200-phase4.2","seconds":45,"radius":15,"firstLock":"2.87","onGun":100,"requestFire":100,"inRange":100,"medianError":2.54,"p95Error":2.63,"longestGap":0,"medianDistance":512,"minHullGap":491.7,"rollsPerMinute":0.06,"rollReversals":0,"pitchReversals":0,"maxRoll":0.055} +{"grid":"holdout","variant":"hard-gate","name":"tilted-r1200-v350-phase0.7","seconds":45,"radius":15,"firstLock":"3.78","onGun":100,"requestFire":100,"inRange":100,"medianError":2.06,"p95Error":2.17,"longestGap":0,"medianDistance":514,"minHullGap":492,"rollsPerMinute":0.21,"rollReversals":2,"pitchReversals":0,"maxRoll":0.116} +{"grid":"holdout","variant":"hard-gate","name":"tilted-r1200-v350-phase2.1","seconds":45,"radius":15,"firstLock":"4.33","onGun":100,"requestFire":100,"inRange":100,"medianError":2.07,"p95Error":2.23,"longestGap":0,"medianDistance":514,"minHullGap":492,"rollsPerMinute":0.52,"rollReversals":16,"pitchReversals":0,"maxRoll":0.233} +{"grid":"holdout","variant":"hard-gate","name":"tilted-r1200-v350-phase4.2","seconds":45,"radius":15,"firstLock":"3.37","onGun":100,"requestFire":100,"inRange":100,"medianError":2.07,"p95Error":2.24,"longestGap":0,"medianDistance":514,"minHullGap":492,"rollsPerMinute":0.63,"rollReversals":25,"pitchReversals":0,"maxRoll":0.239} +{"grid":"holdout","variant":"hard-gate","name":"tilted-r2400-v200-phase0.7","seconds":45,"radius":15,"firstLock":"2.98","onGun":100,"requestFire":100,"inRange":100,"medianError":3.01,"p95Error":3.09,"longestGap":0,"medianDistance":515,"minHullGap":493.6,"rollsPerMinute":0.15,"rollReversals":2,"pitchReversals":0,"maxRoll":0.16} +{"grid":"holdout","variant":"hard-gate","name":"tilted-r2400-v200-phase2.1","seconds":45,"radius":15,"firstLock":"2.72","onGun":100,"requestFire":100,"inRange":100,"medianError":3.02,"p95Error":3.09,"longestGap":0,"medianDistance":515,"minHullGap":493.5,"rollsPerMinute":0.12,"rollReversals":0,"pitchReversals":0,"maxRoll":0.157} +{"grid":"holdout","variant":"hard-gate","name":"tilted-r2400-v200-phase4.2","seconds":45,"radius":15,"firstLock":"1.85","onGun":100,"requestFire":100,"inRange":100,"medianError":3.02,"p95Error":3.09,"longestGap":0,"medianDistance":514,"minHullGap":493.6,"rollsPerMinute":0.18,"rollReversals":3,"pitchReversals":0,"maxRoll":0.17} +{"grid":"holdout","variant":"hard-gate","name":"tilted-r2400-v350-phase0.7","seconds":45,"radius":15,"firstLock":"5.47","onGun":100,"requestFire":100,"inRange":100,"medianError":2.75,"p95Error":2.86,"longestGap":0,"medianDistance":510,"minHullGap":490.1,"rollsPerMinute":0.37,"rollReversals":10,"pitchReversals":0,"maxRoll":0.263} +{"grid":"holdout","variant":"hard-gate","name":"tilted-r2400-v350-phase2.1","seconds":45,"radius":15,"firstLock":"4.55","onGun":100,"requestFire":100,"inRange":100,"medianError":2.76,"p95Error":2.86,"longestGap":0,"medianDistance":510,"minHullGap":490.1,"rollsPerMinute":0.34,"rollReversals":10,"pitchReversals":0,"maxRoll":0.211} +{"grid":"holdout","variant":"hard-gate","name":"tilted-r2400-v350-phase4.2","seconds":45,"radius":15,"firstLock":"1.87","onGun":100,"requestFire":100,"inRange":100,"medianError":2.75,"p95Error":2.88,"longestGap":0,"medianDistance":510,"minHullGap":490.1,"rollsPerMinute":0.36,"rollReversals":12,"pitchReversals":0,"maxRoll":0.228} +{"grid":"holdout","variant":"hard-gate","name":"horizontal-r600-v200-phase0.7","seconds":90,"radius":15,"firstLock":"4.02","onGun":100,"requestFire":100,"inRange":100,"medianError":1.83,"p95Error":1.91,"longestGap":0,"medianDistance":514,"minHullGap":494.9,"rollsPerMinute":0.03,"rollReversals":0,"pitchReversals":0,"maxRoll":0.021} +{"grid":"holdout","variant":"hard-gate","name":"horizontal-r600-v200-phase2.1","seconds":90,"radius":15,"firstLock":"2.85","onGun":100,"requestFire":100,"inRange":100,"medianError":1.82,"p95Error":1.9,"longestGap":0,"medianDistance":517,"minHullGap":437,"rollsPerMinute":0.02,"rollReversals":0,"pitchReversals":0,"maxRoll":0.027} +{"grid":"holdout","variant":"hard-gate","name":"horizontal-r600-v200-phase4.2","seconds":90,"radius":15,"firstLock":"1.38","onGun":100,"requestFire":100,"inRange":100,"medianError":1.83,"p95Error":1.9,"longestGap":0,"medianDistance":517,"minHullGap":495.8,"rollsPerMinute":0.06,"rollReversals":0,"pitchReversals":0,"maxRoll":0.092} +{"grid":"holdout","variant":"hard-gate","name":"horizontal-r600-v350-phase0.7","seconds":90,"radius":15,"firstLock":"4.17","onGun":84.2,"requestFire":75.6,"inRange":100,"medianError":1.8,"p95Error":4.53,"longestGap":0.32,"medianDistance":514,"minHullGap":493.4,"rollsPerMinute":1.65,"rollReversals":98,"pitchReversals":0,"maxRoll":0.318} +{"grid":"holdout","variant":"hard-gate","name":"horizontal-r600-v350-phase2.1","seconds":90,"radius":15,"firstLock":"2.65","onGun":82,"requestFire":73.2,"inRange":100,"medianError":1.85,"p95Error":4.68,"longestGap":0.33,"medianDistance":515,"minHullGap":452.9,"rollsPerMinute":1.69,"rollReversals":97,"pitchReversals":0,"maxRoll":0.317} +{"grid":"holdout","variant":"hard-gate","name":"horizontal-r600-v350-phase4.2","seconds":90,"radius":15,"firstLock":"0.80","onGun":84.1,"requestFire":75.1,"inRange":100,"medianError":1.83,"p95Error":4.46,"longestGap":0.33,"medianDistance":514,"minHullGap":493.2,"rollsPerMinute":1.67,"rollReversals":99,"pitchReversals":0,"maxRoll":0.322} +{"grid":"holdout","variant":"hard-gate","name":"horizontal-r1200-v200-phase0.7","seconds":90,"radius":15,"firstLock":"3.63","onGun":100,"requestFire":100,"inRange":100,"medianError":2.55,"p95Error":2.63,"longestGap":0,"medianDistance":511,"minHullGap":491.7,"rollsPerMinute":0.02,"rollReversals":0,"pitchReversals":0,"maxRoll":0.01} +{"grid":"holdout","variant":"hard-gate","name":"horizontal-r1200-v200-phase2.1","seconds":90,"radius":15,"firstLock":"3.12","onGun":100,"requestFire":100,"inRange":100,"medianError":2.54,"p95Error":2.62,"longestGap":0,"medianDistance":514,"minHullGap":480.4,"rollsPerMinute":0.03,"rollReversals":0,"pitchReversals":0,"maxRoll":0.014} +{"grid":"holdout","variant":"hard-gate","name":"horizontal-r1200-v200-phase4.2","seconds":90,"radius":15,"firstLock":"1.80","onGun":100,"requestFire":100,"inRange":100,"medianError":2.55,"p95Error":2.63,"longestGap":0,"medianDistance":511,"minHullGap":491.7,"rollsPerMinute":0.07,"rollReversals":0,"pitchReversals":0,"maxRoll":0.053} +{"grid":"holdout","variant":"hard-gate","name":"horizontal-r1200-v350-phase0.7","seconds":90,"radius":15,"firstLock":"3.98","onGun":100,"requestFire":100,"inRange":100,"medianError":2.07,"p95Error":2.23,"longestGap":0,"medianDistance":514,"minHullGap":492,"rollsPerMinute":0.57,"rollReversals":48,"pitchReversals":0,"maxRoll":0.242} +{"grid":"holdout","variant":"hard-gate","name":"horizontal-r1200-v350-phase2.1","seconds":90,"radius":15,"firstLock":"2.92","onGun":100,"requestFire":100,"inRange":100,"medianError":2.08,"p95Error":2.27,"longestGap":0,"medianDistance":514,"minHullGap":491.9,"rollsPerMinute":0.66,"rollReversals":60,"pitchReversals":0,"maxRoll":0.244} +{"grid":"holdout","variant":"hard-gate","name":"horizontal-r1200-v350-phase4.2","seconds":90,"radius":15,"firstLock":"1.55","onGun":100,"requestFire":100,"inRange":100,"medianError":2.08,"p95Error":2.28,"longestGap":0,"medianDistance":513,"minHullGap":491.9,"rollsPerMinute":0.66,"rollReversals":60,"pitchReversals":0,"maxRoll":0.245} +{"grid":"holdout","variant":"hard-gate","name":"horizontal-r2400-v200-phase0.7","seconds":90,"radius":15,"firstLock":"3.45","onGun":100,"requestFire":100,"inRange":100,"medianError":3.03,"p95Error":3.09,"longestGap":0,"medianDistance":513,"minHullGap":493.6,"rollsPerMinute":0.09,"rollReversals":3,"pitchReversals":0,"maxRoll":0.159} +{"grid":"holdout","variant":"hard-gate","name":"horizontal-r2400-v200-phase2.1","seconds":90,"radius":15,"firstLock":"3.32","onGun":100,"requestFire":100,"inRange":100,"medianError":3.03,"p95Error":3.09,"longestGap":0,"medianDistance":514,"minHullGap":493.6,"rollsPerMinute":0.12,"rollReversals":6,"pitchReversals":0,"maxRoll":0.174} +{"grid":"holdout","variant":"hard-gate","name":"horizontal-r2400-v200-phase4.2","seconds":90,"radius":15,"firstLock":"2.32","onGun":100,"requestFire":100,"inRange":100,"medianError":3.03,"p95Error":3.1,"longestGap":0,"medianDistance":513,"minHullGap":493.6,"rollsPerMinute":0.2,"rollReversals":14,"pitchReversals":0,"maxRoll":0.173} +{"grid":"holdout","variant":"hard-gate","name":"horizontal-r2400-v350-phase0.7","seconds":90,"radius":15,"firstLock":"3.60","onGun":100,"requestFire":100,"inRange":100,"medianError":2.76,"p95Error":2.87,"longestGap":0,"medianDistance":510,"minHullGap":490,"rollsPerMinute":0.33,"rollReversals":25,"pitchReversals":0,"maxRoll":0.227} +{"grid":"holdout","variant":"hard-gate","name":"horizontal-r2400-v350-phase2.1","seconds":90,"radius":15,"firstLock":"3.20","onGun":100,"requestFire":100,"inRange":100,"medianError":2.76,"p95Error":2.88,"longestGap":0,"medianDistance":510,"minHullGap":490.1,"rollsPerMinute":0.37,"rollReversals":32,"pitchReversals":0,"maxRoll":0.223} +{"grid":"holdout","variant":"hard-gate","name":"horizontal-r2400-v350-phase4.2","seconds":90,"radius":15,"firstLock":"1.78","onGun":100,"requestFire":100,"inRange":100,"medianError":2.76,"p95Error":2.88,"longestGap":0,"medianDistance":509,"minHullGap":490.1,"rollsPerMinute":0.37,"rollReversals":31,"pitchReversals":0,"maxRoll":0.242} +{"grid":"holdout","variant":"hard-gate","name":"vertical-r600-v200-phase0.7","seconds":90,"radius":15,"firstLock":"2.43","onGun":100,"requestFire":100,"inRange":100,"medianError":1.83,"p95Error":1.91,"longestGap":0,"medianDistance":514,"minHullGap":494.9,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"hard-gate","name":"vertical-r600-v200-phase2.1","seconds":90,"radius":15,"firstLock":"1.77","onGun":100,"requestFire":100,"inRange":100,"medianError":1.83,"p95Error":1.9,"longestGap":0,"medianDistance":517,"minHullGap":464.7,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"hard-gate","name":"vertical-r600-v200-phase4.2","seconds":90,"radius":15,"firstLock":"0.55","onGun":100,"requestFire":100,"inRange":100,"medianError":1.83,"p95Error":1.9,"longestGap":0,"medianDistance":517,"minHullGap":496.3,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"hard-gate","name":"vertical-r600-v350-phase0.7","seconds":90,"radius":15,"firstLock":"3.10","onGun":100,"requestFire":100,"inRange":100,"medianError":1.2,"p95Error":1.48,"longestGap":0,"medianDistance":514,"minHullGap":496.1,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"hard-gate","name":"vertical-r600-v350-phase2.1","seconds":90,"radius":15,"firstLock":"1.70","onGun":100,"requestFire":100,"inRange":100,"medianError":1.23,"p95Error":1.48,"longestGap":0,"medianDistance":516,"minHullGap":469,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"hard-gate","name":"vertical-r600-v350-phase4.2","seconds":90,"radius":15,"firstLock":"0.57","onGun":100,"requestFire":100,"inRange":100,"medianError":1.23,"p95Error":1.48,"longestGap":0,"medianDistance":514,"minHullGap":496.1,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"hard-gate","name":"vertical-r1200-v200-phase0.7","seconds":90,"radius":15,"firstLock":"2.17","onGun":100,"requestFire":100,"inRange":100,"medianError":2.55,"p95Error":2.63,"longestGap":0,"medianDistance":511,"minHullGap":491.7,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"hard-gate","name":"vertical-r1200-v200-phase2.1","seconds":90,"radius":15,"firstLock":"1.92","onGun":100,"requestFire":100,"inRange":100,"medianError":2.54,"p95Error":2.62,"longestGap":0,"medianDistance":511,"minHullGap":491.7,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"hard-gate","name":"vertical-r1200-v200-phase4.2","seconds":90,"radius":15,"firstLock":"0.48","onGun":100,"requestFire":100,"inRange":100,"medianError":2.55,"p95Error":2.63,"longestGap":0,"medianDistance":511,"minHullGap":491.7,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"hard-gate","name":"vertical-r1200-v350-phase0.7","seconds":90,"radius":15,"firstLock":"2.42","onGun":100,"requestFire":100,"inRange":100,"medianError":2.07,"p95Error":2.17,"longestGap":0,"medianDistance":514,"minHullGap":492,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"hard-gate","name":"vertical-r1200-v350-phase2.1","seconds":90,"radius":15,"firstLock":"1.78","onGun":100,"requestFire":100,"inRange":100,"medianError":2.07,"p95Error":2.17,"longestGap":0,"medianDistance":514,"minHullGap":492,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"hard-gate","name":"vertical-r1200-v350-phase4.2","seconds":90,"radius":15,"firstLock":"0.48","onGun":100,"requestFire":100,"inRange":100,"medianError":2.07,"p95Error":2.17,"longestGap":0,"medianDistance":514,"minHullGap":492,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"hard-gate","name":"vertical-r2400-v200-phase0.7","seconds":90,"radius":15,"firstLock":"2.03","onGun":100,"requestFire":100,"inRange":100,"medianError":3.03,"p95Error":3.09,"longestGap":0,"medianDistance":513,"minHullGap":493.6,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"hard-gate","name":"vertical-r2400-v200-phase2.1","seconds":90,"radius":15,"firstLock":"2.03","onGun":100,"requestFire":100,"inRange":100,"medianError":3.03,"p95Error":3.09,"longestGap":0,"medianDistance":513,"minHullGap":493.6,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"hard-gate","name":"vertical-r2400-v200-phase4.2","seconds":90,"radius":15,"firstLock":"0.53","onGun":100,"requestFire":100,"inRange":100,"medianError":3.04,"p95Error":3.09,"longestGap":0,"medianDistance":513,"minHullGap":493.6,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"hard-gate","name":"vertical-r2400-v350-phase0.7","seconds":90,"radius":15,"firstLock":"2.13","onGun":100,"requestFire":100,"inRange":100,"medianError":2.76,"p95Error":2.83,"longestGap":0,"medianDistance":509,"minHullGap":490.1,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"hard-gate","name":"vertical-r2400-v350-phase2.1","seconds":90,"radius":15,"firstLock":"1.95","onGun":100,"requestFire":100,"inRange":100,"medianError":2.76,"p95Error":2.83,"longestGap":0,"medianDistance":510,"minHullGap":490.1,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"hard-gate","name":"vertical-r2400-v350-phase4.2","seconds":90,"radius":15,"firstLock":"0.50","onGun":100,"requestFire":100,"inRange":100,"medianError":2.76,"p95Error":2.83,"longestGap":0,"medianDistance":510,"minHullGap":490,"rollsPerMinute":0,"rollReversals":0,"pitchReversals":0,"maxRoll":0} +{"grid":"holdout","variant":"hard-gate","name":"tilted-r600-v200-phase0.7","seconds":90,"radius":15,"firstLock":"3.73","onGun":100,"requestFire":100,"inRange":100,"medianError":1.83,"p95Error":1.9,"longestGap":0,"medianDistance":514,"minHullGap":495.1,"rollsPerMinute":0.06,"rollReversals":0,"pitchReversals":0,"maxRoll":0.169} +{"grid":"holdout","variant":"hard-gate","name":"tilted-r600-v200-phase2.1","seconds":90,"radius":15,"firstLock":"4.08","onGun":100,"requestFire":100,"inRange":100,"medianError":1.82,"p95Error":1.9,"longestGap":0,"medianDistance":517,"minHullGap":484.1,"rollsPerMinute":0.07,"rollReversals":0,"pitchReversals":0,"maxRoll":0.212} +{"grid":"holdout","variant":"hard-gate","name":"tilted-r600-v200-phase4.2","seconds":90,"radius":15,"firstLock":"2.62","onGun":100,"requestFire":100,"inRange":100,"medianError":1.83,"p95Error":1.9,"longestGap":0,"medianDistance":514,"minHullGap":495.1,"rollsPerMinute":0.06,"rollReversals":0,"pitchReversals":0,"maxRoll":0.104} +{"grid":"holdout","variant":"hard-gate","name":"tilted-r600-v350-phase0.7","seconds":90,"radius":15,"firstLock":"4.72","onGun":85,"requestFire":76.6,"inRange":100,"medianError":1.77,"p95Error":4.56,"longestGap":0.3,"medianDistance":512,"minHullGap":493.6,"rollsPerMinute":1.64,"rollReversals":97,"pitchReversals":0,"maxRoll":0.315} +{"grid":"holdout","variant":"hard-gate","name":"tilted-r600-v350-phase2.1","seconds":90,"radius":15,"firstLock":"4.60","onGun":81.3,"requestFire":73.3,"inRange":100,"medianError":1.85,"p95Error":4.72,"longestGap":0.35,"medianDistance":515,"minHullGap":488.5,"rollsPerMinute":1.7,"rollReversals":98,"pitchReversals":0,"maxRoll":0.316} +{"grid":"holdout","variant":"hard-gate","name":"tilted-r600-v350-phase4.2","seconds":90,"radius":15,"firstLock":"2.72","onGun":81.3,"requestFire":72.9,"inRange":100,"medianError":1.89,"p95Error":4.79,"longestGap":0.33,"medianDistance":513,"minHullGap":494.4,"rollsPerMinute":1.7,"rollReversals":97,"pitchReversals":0,"maxRoll":0.32} +{"grid":"holdout","variant":"hard-gate","name":"tilted-r1200-v200-phase0.7","seconds":90,"radius":15,"firstLock":"3.03","onGun":100,"requestFire":100,"inRange":100,"medianError":2.55,"p95Error":2.63,"longestGap":0,"medianDistance":511,"minHullGap":491.7,"rollsPerMinute":0.06,"rollReversals":0,"pitchReversals":0,"maxRoll":0.068} +{"grid":"holdout","variant":"hard-gate","name":"tilted-r1200-v200-phase2.1","seconds":90,"radius":15,"firstLock":"4.13","onGun":100,"requestFire":100,"inRange":100,"medianError":2.55,"p95Error":2.63,"longestGap":0,"medianDistance":511,"minHullGap":491.7,"rollsPerMinute":0.06,"rollReversals":0,"pitchReversals":0,"maxRoll":0.081} +{"grid":"holdout","variant":"hard-gate","name":"tilted-r1200-v200-phase4.2","seconds":90,"radius":15,"firstLock":"2.87","onGun":100,"requestFire":100,"inRange":100,"medianError":2.55,"p95Error":2.63,"longestGap":0,"medianDistance":511,"minHullGap":491.7,"rollsPerMinute":0.04,"rollReversals":0,"pitchReversals":0,"maxRoll":0.055} +{"grid":"holdout","variant":"hard-gate","name":"tilted-r1200-v350-phase0.7","seconds":90,"radius":15,"firstLock":"3.78","onGun":100,"requestFire":100,"inRange":100,"medianError":2.07,"p95Error":2.21,"longestGap":0,"medianDistance":514,"minHullGap":491.9,"rollsPerMinute":0.46,"rollReversals":36,"pitchReversals":0,"maxRoll":0.238} +{"grid":"holdout","variant":"hard-gate","name":"tilted-r1200-v350-phase2.1","seconds":90,"radius":15,"firstLock":"4.33","onGun":100,"requestFire":100,"inRange":100,"medianError":2.08,"p95Error":2.27,"longestGap":0,"medianDistance":513,"minHullGap":491.9,"rollsPerMinute":0.6,"rollReversals":50,"pitchReversals":0,"maxRoll":0.246} +{"grid":"holdout","variant":"hard-gate","name":"tilted-r1200-v350-phase4.2","seconds":90,"radius":15,"firstLock":"3.37","onGun":100,"requestFire":100,"inRange":100,"medianError":2.08,"p95Error":2.25,"longestGap":0,"medianDistance":513,"minHullGap":492,"rollsPerMinute":0.64,"rollReversals":59,"pitchReversals":0,"maxRoll":0.239} +{"grid":"holdout","variant":"hard-gate","name":"tilted-r2400-v200-phase0.7","seconds":90,"radius":15,"firstLock":"2.98","onGun":100,"requestFire":100,"inRange":100,"medianError":3.03,"p95Error":3.1,"longestGap":0,"medianDistance":513,"minHullGap":493.6,"rollsPerMinute":0.18,"rollReversals":12,"pitchReversals":0,"maxRoll":0.174} +{"grid":"holdout","variant":"hard-gate","name":"tilted-r2400-v200-phase2.1","seconds":90,"radius":15,"firstLock":"2.72","onGun":100,"requestFire":100,"inRange":100,"medianError":3.03,"p95Error":3.09,"longestGap":0,"medianDistance":513,"minHullGap":493.5,"rollsPerMinute":0.17,"rollReversals":10,"pitchReversals":0,"maxRoll":0.16} +{"grid":"holdout","variant":"hard-gate","name":"tilted-r2400-v200-phase4.2","seconds":90,"radius":15,"firstLock":"1.85","onGun":100,"requestFire":100,"inRange":100,"medianError":3.03,"p95Error":3.1,"longestGap":0,"medianDistance":513,"minHullGap":493.6,"rollsPerMinute":0.19,"rollReversals":13,"pitchReversals":0,"maxRoll":0.182} +{"grid":"holdout","variant":"hard-gate","name":"tilted-r2400-v350-phase0.7","seconds":90,"radius":15,"firstLock":"5.47","onGun":100,"requestFire":100,"inRange":100,"medianError":2.76,"p95Error":2.87,"longestGap":0,"medianDistance":509,"minHullGap":490.1,"rollsPerMinute":0.37,"rollReversals":28,"pitchReversals":0,"maxRoll":0.263} +{"grid":"holdout","variant":"hard-gate","name":"tilted-r2400-v350-phase2.1","seconds":90,"radius":15,"firstLock":"4.55","onGun":100,"requestFire":100,"inRange":100,"medianError":2.76,"p95Error":2.87,"longestGap":0,"medianDistance":510,"minHullGap":490.1,"rollsPerMinute":0.36,"rollReversals":28,"pitchReversals":0,"maxRoll":0.239} +{"grid":"holdout","variant":"hard-gate","name":"tilted-r2400-v350-phase4.2","seconds":90,"radius":15,"firstLock":"1.87","onGun":100,"requestFire":100,"inRange":100,"medianError":2.76,"p95Error":2.89,"longestGap":0,"medianDistance":510,"minHullGap":490.1,"rollsPerMinute":0.37,"rollReversals":30,"pitchReversals":0,"maxRoll":0.228} diff --git a/docs/reviews/combat-computer-2026-09-12/probe.mjs b/docs/reviews/combat-computer-2026-09-12/probe.mjs new file mode 100644 index 00000000..78dfb23d --- /dev/null +++ b/docs/reviews/combat-computer-2026-09-12/probe.mjs @@ -0,0 +1,142 @@ +// Review experiment: move one pirate along a known path and fly the real player. +// Usage from the repository root: +// node --experimental-strip-types --no-warnings docs/reviews/combat-computer-2026-09-12/probe.mjs +// Add --holdout for the independent orbit grid; add --hard-gate for the candidate. +// It prints JSON lines. It runs no career, shots, damage, saves or browser code. +// The target stays selected to isolate tracking from target-switch decisions. +// Orbit radius describes the path around the origin, not the player's distance. +// The first ten seconds are excluded from sustained-tracking measurements. +// rollsPerMinute counts absolute roll travel, including changes of direction. +// firstLock is the first valid firing angle and range; it is not a sustained lock. +import * as THREE from 'three'; +import { readFileSync, writeFileSync, mkdtempSync, rmSync } from 'node:fs'; +import { tmpdir } from 'node:os'; +import { join } from 'node:path'; +import { pathToFileURL } from 'node:url'; +import { PlayerShip } from '../../../src/player.ts'; +import { NpcShip } from '../../../src/game/npc.ts'; +// The variant changes only the co-pilot call's optional roll gate. The shared +// steering rule, flight model, lead, throttle and gun cone stay as shipped. +const sourceUrl = new URL('../../../src/game/scripted-co-pilot.ts', import.meta.url); +const hardGate = process.argv.includes('--hard-gate'); +let moduleUrl = sourceUrl.href; +let temporary; +if (hardGate) { + let source = readFileSync(sourceUrl, 'utf8'); + const before = 'this.aim.sub(player.position), this.steerMem, cone)'; + if (source.split(before).length !== 2) throw Error('The controller changed; review the experiment before reuse.'); + source = source.replace(before, 'this.aim.sub(player.position), this.steerMem, cone, 0.1)'); + source = source.replace(/from '([^']+)'/g, (whole, name) => { + if (name === 'three') return `from '${import.meta.resolve('three')}'`; + return name.startsWith('.') ? `from '${new URL(name, sourceUrl).href}'` : whole; + }); + temporary = mkdtempSync(join(tmpdir(), 'harmless-combat-review-')); + const path = join(temporary, 'scripted-co-pilot.ts'); + writeFileSync(path, source); + moduleUrl = pathToFileURL(path).href; +} +const { ScriptedCoPilot } = await import(moduleUrl); +if (temporary) rmSync(temporary, { recursive: true }); +import { hitCone } from '../../../src/game/gunnery.ts'; +import { LASER_RANGE } from '../../../src/constants/player-gun.ts'; +import { seedWorld } from '../../../src/game/rng.ts'; + +const dt = 1 / 60; +const up = new THREE.Vector3(0, 1, 0); +function run(name, path, seconds, pilotClass = ScriptedCoPilot, initialSpeed = 200) { + seedWorld(20260912); + const player = new PlayerShip(new THREE.Vector3(), new THREE.Vector3(0, 0, -1)); + player.speed = initialSpeed; + const target = new NpcShip('pirate', new THREE.Vector3(0, 0, -1000), 1); + const cp = new pilotClass(); + const velocity = new THREE.Vector3(); + const forward = new THREE.Vector3(); + const to = new THREE.Vector3(); + const ahead = new THREE.Vector3(); + const look = new THREE.Matrix4(); + const errors = []; + const distances = []; + let firstLock = null, onGun = 0, askFire = 0, inRange = 0, n = 0; + let gap = 0, longestGap = 0, rollTravel = 0, rollReversals = 0, pitchReversals = 0; + let lastRoll = 0, lastPitch = 0, maxRoll = 0; + let minGap = Infinity; + for (let i = 0; i < seconds * 60; i++) { + const t = i * dt; + path(t, target.object.position, velocity); + target.state.speed = velocity.length(); + look.lookAt(target.object.position, ahead.copy(target.object.position).add(velocity), up); + target.object.quaternion.setFromRotationMatrix(look); + const step = cp.step(dt, player, [target], 0, false, null, Infinity, target); + if (step.kind !== 'fly') throw Error('lost target'); + player.update(dt, step.demand); + to.copy(target.object.position).sub(player.position); + forward.set(0, 0, -1).applyQuaternion(player.quaternion); + const distance = to.length(); + const error = forward.angleTo(to); + const hit = error < hitCone(target.radius, distance) && distance <= LASER_RANGE; + if (hit && firstLock === null) firstLock = t; + minGap = Math.min(minGap, distance - target.radius); + if (t <= 10) continue; + n++; + if (hit) { onGun++; gap = 0; } else { gap += dt; longestGap = Math.max(longestGap, gap); } + if (distance <= LASER_RANGE) inRange++; + if (step.demand.fire) askFire++; + errors.push(error * 180 / Math.PI); + distances.push(distance); + rollTravel += Math.abs(step.demand.rollRate) * dt; + maxRoll = Math.max(maxRoll, Math.abs(step.demand.rollRate)); + const r = Math.abs(step.demand.rollRate) > 0.1 ? Math.sign(step.demand.rollRate) : 0; + const p = Math.abs(step.demand.pitchRate) > 0.1 ? Math.sign(step.demand.pitchRate) : 0; + if (r && lastRoll && r !== lastRoll) rollReversals++; + if (p && lastPitch && p !== lastPitch) pitchReversals++; + if (r) lastRoll = r; + if (p) lastPitch = p; + } + errors.sort((a,b) => a-b); + distances.sort((a,b) => a-b); + const pct = (v) => +(100 * v / n).toFixed(1); + const result = { name, seconds, radius: target.radius, firstLock: firstLock?.toFixed(2), + onGun: pct(onGun), requestFire: pct(askFire), inRange: pct(inRange), + medianError: +errors[Math.floor(n / 2)].toFixed(2), p95Error: +errors[Math.floor(n * .95)].toFixed(2), + longestGap: +longestGap.toFixed(2), medianDistance: +distances[Math.floor(n / 2)].toFixed(0), + minHullGap: +minGap.toFixed(1), rollsPerMinute: +(rollTravel / (2 * Math.PI) / (n * dt) * 60).toFixed(2), + rollReversals, pitchReversals, maxRoll: +maxRoll.toFixed(3), + }; + console.log(JSON.stringify(result)); + return result; +} +const orbit = (radius, speed, plane, phase = 0) => (t, position, velocity) => { + const a = t * speed / radius + phase; + const x = Math.cos(a) * radius, y = Math.sin(a) * radius; + const vx = -Math.sin(a) * speed, vy = Math.cos(a) * speed; + if (plane === 'horizontal') { position.set(x, 0, y); velocity.set(vx, 0, vy); } + if (plane === 'vertical') { position.set(0, x, y); velocity.set(0, vx, vy); } + if (plane === 'tilted') { position.set(x, y / Math.SQRT2, y / Math.SQRT2); velocity.set(vx, vy / Math.SQRT2, vy / Math.SQRT2); } +}; + +for (const seconds of process.argv.includes('--holdout') ? [] : [30, 60]) { + for (const plane of ['horizontal', 'vertical', 'tilted']) { + for (const radius of [400, 800, 1600]) { + for (const speed of [150, 300]) run(`${plane}-r${radius}-v${speed}`, orbit(radius, speed, plane), seconds); + } + } + run('straight-crossing', (t, p, v) => { p.set(-900 + 150 * t, 0, -700); v.set(150, 0, 0); }, seconds); + run('weaving-away', (t, p, v) => { p.set(350 * Math.sin(.8 * t), 0, -1200 - 180 * t); v.set(280 * Math.cos(.8 * t), 0, -180); }, seconds); + run('straight-away', (t, p, v) => { p.set(0, 0, -1800 - 280 * t); v.set(0, 0, -280); }, seconds); +} + +if (process.argv.includes('--holdout')) { + for (const seconds of [45, 90]) { + for (const plane of ['horizontal', 'vertical', 'tilted']) { + for (const radius of [600, 1200, 2400]) { + for (const speed of [200, 350]) { + for (const phase of [.7, 2.1, 4.2]) { + run(`${plane}-r${radius}-v${speed}-phase${phase}`, orbit(radius, speed, plane, phase), seconds); + } + } + } + } + } +} + +export { run, orbit }; From 7caca667305a8436fb78a770b9ee230e40fc5423 Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Sat, 12 Sep 2026 20:26:25 +0100 Subject: [PATCH 048/100] The co-pilot banks before it pulls, and the tracking tests say so MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Review recommendations 1 and 2 (docs/COMBAT-COMPUTER-REVIEW.md). The computer acquired a target within about three seconds, then rolled around it without a useful shot. THE CAUSE. `bankToTurn` scales pitch by the cosine of the bank error, and that never reaches zero. The residue moves the target's bearing while the roll chases the same bearing, so the nose can circle the target for ever. A vertical orbit needs pitch alone and tracked 100%. The horizontal and tilted orbits need both axes, and they fell to 17%. `pitch-roll-steer.ts` already held the answer, behind the `rollGate` argument the course pilot passes. Its comment said the combat computer must NOT take it, on two grounds: a manoeuvring target cannot afford a pitch held still, and the wide gun cone hides the fault. The review measured both false, and that comment is repaired. `COMBAT_ROLL_GATE` IS 0.27 RAD, and three measures chose it. Two are the review's own probe, over 21 prescribed paths and a separate grid of 54 orbits. The third is new: `npm run combat-aim` flies 72 combat exercises against real pirate brains with real guns, which is the check the review's closing words ask for. | gate | 21 paths, 60s | 54 orbits, 90s | 72 fights | | 0 | 64.9%, 7.5% | 53.9%, 3.8% | 39.5% | | 0.27 | 98.3%, 88.5% | 97.6%, 77.2% | 57.5% | The second figure of each pair is the worst case. The full sweep is beside the constant. Tracking is flat from 0.08 to 0.3 and falls away by 0.4, and the fights plateau from 0.2. So 0.27 is the middle of a plateau, not a peak, and the exact figure inside that band is not load-bearing. Acquisition is what it costs: the worst first lock over the 21 paths went from 3.28 to 3.87 seconds. THE TESTS NOW REJECT WEAK TRACKING. Two old ones went. One accepted 20% of frames inside the gun cone and passed at 29%. The other measured a fixed 0.1 rad rather than the real cone, ran 20 seconds, and flew a target sideways with its nose pointed elsewhere — and the co-pilot reads that nose for the velocity it leads on. `test/co-pilot-tracking.test.ts` replaces both. One path gives position, orientation and speed. It measures four things per case, because a high average hides a target lost for 40 seconds: time on the gun, acquisition, the longest gap, and roll travel. Six paths, and the limits are per case. With the gate at zero, four of the six fail, at 32%, 17%, 14% and 8%. Those are the review's own figures for the same paths. The two that pass are the two it said track well. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- package.json | 1 + src/constants/CATALOG.md | 7 +- src/constants/combat-computer.ts | 52 ++++++++++ src/game/pitch-roll-steer.ts | 13 ++- src/game/scripted-co-pilot.ts | 9 +- test/co-pilot-tracking.test.ts | 162 +++++++++++++++++++++++++++++++ test/run.ts | 1 + test/scripted-co-pilot.test.ts | 105 -------------------- train/combat-aim.ts | 91 +++++++++++++++++ 9 files changed, 327 insertions(+), 114 deletions(-) create mode 100644 test/co-pilot-tracking.test.ts create mode 100644 train/combat-aim.ts diff --git a/package.json b/package.json index 6ba24c50..a09b1982 100644 --- a/package.json +++ b/package.json @@ -37,6 +37,7 @@ "elite-a": "npm run generate:elite-a -- --check && node --experimental-strip-types --no-warnings test/elite-a.ts", "campaign": "node --experimental-strip-types --no-warnings test/campaign.ts", "survivability": "node --experimental-strip-types --no-warnings train/survivability.ts", + "combat-aim": "node --experimental-strip-types --no-warnings train/combat-aim.ts", "flight-probe": "node --experimental-strip-types --no-warnings train/flight-probe.ts", "aim-probe": "node --experimental-strip-types --no-warnings train/aim-probe.ts", "ram-probe": "node --experimental-strip-types --no-warnings train/ram-probe.ts", diff --git a/src/constants/CATALOG.md b/src/constants/CATALOG.md index 3cdddbb0..bdee32ae 100644 --- a/src/constants/CATALOG.md +++ b/src/constants/CATALOG.md @@ -2,7 +2,7 @@ -453 exported constants. Regenerate with `npm run generate:constants`; +454 exported constants. Regenerate with `npm run generate:constants`; search names, meanings and values with `npm run constants:find -- ""`. | Domain | Symbol | Literal / expression | Purpose | Rule ID | Source | @@ -80,8 +80,9 @@ search names, meanings and values with `npm run constants:find -- ""`. | combat-computer | PURSUIT_SLASH_CONE | 1.3 | A pursuit PIRATE switches flight models on where it sits in the commander's arc. | | [combat-computer.ts:178](./combat-computer.ts#L178) | | combat-computer | PURSUIT_HOLD_CONE | 1.85 | | | [combat-computer.ts:179](./combat-computer.ts#L179) | | combat-computer | ENGAGED_CONE | 0.6 | The nose-to-target angle, in radians, within which the co-pilot counts itself ENGAGED and will not switch targets. | | [combat-computer.ts:188](./combat-computer.ts#L188) | -| combat-computer | TARGET_DIST_WEIGHT | 800 | How many world units of range weigh as much as one radian of off-nose turn. | copilot.targetDistWeight | [combat-computer.ts:206](./combat-computer.ts#L206) | -| combat-computer | PURSUIT_LEAD_GAIN | 2.0 | How many SECONDS the co-pilot aims ahead of a target, per radian that its nose still has to swing. | copilot.leadGain | [combat-computer.ts:257](./combat-computer.ts#L257) | +| combat-computer | COMBAT_ROLL_GATE | 0.27 | How near its bank the co-pilot must be before it pulls the nose, in radians. | copilot.rollGate | [combat-computer.ts:240](./combat-computer.ts#L240) | +| combat-computer | TARGET_DIST_WEIGHT | 800 | How many world units of range weigh as much as one radian of off-nose turn. | copilot.targetDistWeight | [combat-computer.ts:258](./combat-computer.ts#L258) | +| combat-computer | PURSUIT_LEAD_GAIN | 2.0 | How many SECONDS the co-pilot aims ahead of a target, per radian that its nose still has to swing. | copilot.leadGain | [combat-computer.ts:309](./combat-computer.ts#L309) | | combat-record | SAMPLE_HZ | 10 | How often the code samples the geometry, in Hz. | | [combat-record.ts:12](./combat-record.ts#L12) | | combat-record | SIX_CONE | Math.PI / 3 | The rear cone that counts as somebody's six, as a half-angle from directly astern. | | [combat-record.ts:20](./combat-record.ts#L20) | | combat-record | PASS_CLOSE | 400 | What an attack run is, in ranges. | | [combat-record.ts:42](./combat-record.ts#L42) | diff --git a/src/constants/combat-computer.ts b/src/constants/combat-computer.ts index 32e48cd4..d61cc98d 100644 --- a/src/constants/combat-computer.ts +++ b/src/constants/combat-computer.ts @@ -187,6 +187,58 @@ export const PURSUIT_HOLD_CONE = 1.85; */ export const ENGAGED_CONE = 0.6; +/** + * How near its bank the co-pilot must be before it pulls the nose, in radians. + * Above it, `bankToTurn` asks for NO pitch at all. + * + * IT WAS ZERO, AND THE COMMENT SAID IT HAD TO BE. `pitch-roll-steer.ts` held + * that the combat computer must not take the hard gate. A pitch held still + * while the roll catches up is time off the gun, it said, and the wide gun cone + * hid the fault anyway. A review of 2026-09-12 measured both claims false + * (`docs/COMBAT-COMPUTER-REVIEW.md`). + * + * WHAT THE SOFT GATE COSTS. Pitch scaled by the cosine of the bank error never + * reaches zero. That pitch moves the target's bearing while the roll chases the + * same bearing, so the nose can circle the target for ever. A vertical orbit + * needs no roll, and it tracked 100%. The horizontal and tilted orbits need + * both axes, and they fell to 17%. + * + * THREE MEASURES CHOSE THE VALUE, and the review's own probe is two of them. It + * flies the shipped controller and the real flight model against prescribed + * paths. Time on the gun means inside `hitCone` and `LASER_RANGE`, after the + * first ten seconds. The third is 72 exercises against real pirate brains, with + * real shots. Its figure is the share of engaged frames with a live hostile + * inside the gun cone. + * + * | gate | 21 paths, 60s | 54 orbits, 90s | 72 fights | + * | 0 | 64.9%, 7.5% | 53.9%, 3.8% | 39.5% | + * | 0.15 | 98.5%, 87.6% | 98.0%, 80.2% | 55.4% | + * | 0.20 | 98.5%, 87.8% | 97.9%, 79.2% | 58.9% | + * | 0.27 | 98.3%, 88.5% | 97.6%, 77.2% | 57.5% | + * | 0.30 | 98.7%, 90.8% | 97.7%, 78.2% | 57.8% | + * | 0.40 | 98.4%, 84.4% | 97.1%, 72.4% | 60.2% | + * + * The second figure in each pair is the worst case, not the mean. + * + * WHY 0.27. It is the middle of a plateau rather than a peak. The prescribed + * paths hold about 98% from 0.08 to 0.3, and they fall away by 0.4. The fights + * rise to about 58% by 0.2 and stay there. Any value from 0.2 to 0.3 measures + * the same, so the exact figure inside that band is not load-bearing. It is + * about 15 degrees, against the course pilot's `COURSE_ROLL_GATE` of 0.05. A + * course has one fixed heading to reach. This one chases a heading that moves. + * + * WHAT IT COSTS. Acquisition is slower, because the nose waits for the bank. + * The worst first lock over the 21 paths went from 3.28 to 3.87 seconds. A gate + * of 0.08 pushed the same figure to 8.02 seconds, which is why the band is not + * tighter. + * + * It is a feel setting, and no brain flies through it. The prescribed paths + * carry no shots, no damage, and no opponent that fights back. + * + * @rule copilot.rollGate + */ +export const COMBAT_ROLL_GATE = 0.27; + /** * How many world units of range weigh as much as one radian of off-nose turn. * The co-pilot ranks targets by how easy they are to lock diff --git a/src/game/pitch-roll-steer.ts b/src/game/pitch-roll-steer.ts index ebfd129e..19cd6620 100644 --- a/src/game/pitch-roll-steer.ts +++ b/src/game/pitch-roll-steer.ts @@ -89,7 +89,9 @@ function wrap(a: number): number { * * `rollGate` is the angle inside which the BANK counts as finished. Above it * this asks for no pitch at all. Zero keeps the soft gate alone, which is the - * `cos` of the roll error, and every combat caller passes zero. + * `cos` of the roll error. The course pilot passes `COURSE_ROLL_GATE`, and the + * combat co-pilot passes `COMBAT_ROLL_GATE`. The docking computer does not come + * through here at all. * * THE SOFT GATE ALONE CAN CONE (Chris, 2026-09-12: *"we seem to be constantly * rotating when heading towards something"*). A target a hair off the nose @@ -104,9 +106,12 @@ function wrap(a: number): number { * bearing, the bank arrives, and the pitch then closes the angle. On a course * to the station it took a median trip from 41 full turns to 1.3. * - * The combat computer must NOT take it. Its target manoeuvres, and a pitch - * held still while the roll catches up is time off the gun. It also never sees - * the fault, because it stops steering inside its own wide gun cone. + * THE COMBAT COMPUTER TAKES IT TOO, and this comment said the opposite until + * 2026-09-12. It held that a target which manoeuvres cannot afford a pitch held + * still, and that the wide gun cone hid the fault anyway. A review measured + * both claims false. The co-pilot circled a horizontal orbit at 17% time on the + * gun, and the gate took the same grid to 98%. `COMBAT_ROLL_GATE` is its value, + * and the whole measurement is beside it. * * That is the seasickness fix. A target that already fills the gun still has a * bearing, and that bearing swings as it drifts a hair off centre. A bank to diff --git a/src/game/scripted-co-pilot.ts b/src/game/scripted-co-pilot.ts index ddf5cf95..7f0d94d2 100644 --- a/src/game/scripted-co-pilot.ts +++ b/src/game/scripted-co-pilot.ts @@ -49,7 +49,7 @@ import { LASER_RANGE } from '../constants/player-gun.ts'; import { UNDER_FIRE_SECONDS } from '../constants/attack-run.ts'; import { THREAT_RANGE, PURSUIT_SPEED_DEADBAND, ENGAGED_CONE, TARGET_DIST_WEIGHT, - PURSUIT_LEAD_GAIN, + PURSUIT_LEAD_GAIN, COMBAT_ROLL_GATE, } from '../constants/combat-computer.ts'; import { PLAYER_FLIGHT } from '../constants/player-flight.ts'; import { MAX_LEAD_SECONDS } from '../constants/pass-aim.ts'; @@ -179,10 +179,15 @@ export class ScriptedCoPilot { // which is the same rule: how far ahead a ship may aim. this.aim.copy(targetPos).addScaledVector( this.threatVel, Math.min(MAX_LEAD_SECONDS, PURSUIT_LEAD_GAIN * facing)); + // BANK FIRST, THEN PULL. `COMBAT_ROLL_GATE` holds the pitch still until the + // roll arrives. Without it the pitch moves the target's bearing. The roll + // then chases that same bearing, and the nose circles the target instead of + // closing on it. See the constant for what that cost, measured. + // // It ramps through the commander's own envelope (PLAYER_FLIGHT), so the // co-pilot flies your ship as your hands would. const cmd = bankToTurn(player.quaternion, - this.aim.sub(player.position), this.steerMem, cone); + this.aim.sub(player.position), this.steerMem, cone, COMBAT_ROLL_GATE); this.pitchRate = rampFlightRate( this.pitchRate, cmd.pitch * PLAYER_FLIGHT.maxPitch, cmd.pitch !== 0, dt); this.rollRate = rampFlightRate( diff --git a/test/co-pilot-tracking.test.ts b/test/co-pilot-tracking.test.ts new file mode 100644 index 00000000..f554ba82 --- /dev/null +++ b/test/co-pilot-tracking.test.ts @@ -0,0 +1,162 @@ +// TRACKING: does the co-pilot's nose stay on a target that moves? +// +// Split from `scripted-co-pilot.test.ts` on 2026-09-12, when that file passed +// the 400-line ceiling. It is a different question from the one next door. +// That file pins the co-pilot's CONTRACT: what it engages, when it asks for the +// trigger, when it answers a warhead, and when it hands back. This one flies +// the controller against prescribed target paths and measures the GEOMETRY. +// +// The review of 2026-09-12 is the reason it exists in this shape +// (`docs/COMBAT-COMPUTER-REVIEW.md`). Its own probe is the model for the four +// measures, and `npm run combat-aim` is the third check, in real fights. + +import * as THREE from 'three'; +import { ScriptedCoPilot } from '../src/game/scripted-co-pilot.ts'; +import { hitCone } from '../src/game/gunnery.ts'; +import { LASER_RANGE } from '../src/constants/player-gun.ts'; +import { freshState } from '../src/game/state.ts'; +import { newCommander } from '../src/game/commander.ts'; +import { seedWorld } from '../src/game/rng.ts'; +import { check } from './harness.ts'; + +// --- TRACKING: DOES THE NOSE STAY ON A TARGET THAT MOVES? ------------------ +// +// This replaces two weaker tests, on the review of 2026-09-12 +// (`docs/COMBAT-COMPUTER-REVIEW.md`). One accepted 20% of frames inside the gun +// cone and passed at 29%. The other measured a fixed 0.1 rad rather than the +// real cone, ran 20 seconds, and flew a target sideways while its nose pointed +// somewhere else. The co-pilot reads that nose for the target's velocity, so +// the fixture asked for a lead it then called wrong. +// +// The rules this fixture keeps: +// +// - Position, orientation and speed all come from ONE path. A fixture that +// disagrees with itself measures nothing. +// - The gun cone is `hitCone`, the gun's own. A fixed angle is not the test +// the trigger applies. +// - Four numbers, not one. A high average hides a target lost for 40 seconds, +// so the longest gap is its own limit. Acquisition and roll travel are the +// two costs a tracking gain can be paid for with. +// - Horizontal, vertical and tilted paths. A vertical orbit needs pitch +// alone and always tracked well. The coupled axes are where it broke. +console.log('\nthe co-pilot tracks a target that moves'); +{ + const DT = 1 / 60; + const UP = new THREE.Vector3(0, 1, 0); + + interface Track { + onGun: number; firstLock: number | null; longestGap: number; rollTurns: number; + } + /** + * Fly `path` for `seconds` and report the four measures. + * + * @param path writes the target's position and velocity at time t. + */ + const track = (path: (t: number, pos: THREE.Vector3, vel: THREE.Vector3) => void, + seconds: number): Track => { + seedWorld(4245); + const st = freshState(newCommander()); + st.world.build(st.systems[st.commander.systemIndex]); + st.world.clearNpcs(); + st.player.position.set(0, 0, 0); + st.player.quaternion.identity(); + st.player.speed = 200; + const pirate = st.world.spawn('pirate', new THREE.Vector3(0, 0, -1000), 1); + const cp = new ScriptedCoPilot(); + const pos = new THREE.Vector3(); + const vel = new THREE.Vector3(); + const look = new THREE.Matrix4(); + const ahead = new THREE.Vector3(); + const nose = new THREE.Vector3(); + const to = new THREE.Vector3(); + let onGun = 0; let late = 0; let rollTravel = 0; + let firstLock: number | null = null; + let gap = 0; let longestGap = 0; + for (let i = 0; i < seconds / DT; i++) { + const t = i * DT; + path(t, pos, vel); + pirate.object.position.copy(pos); + pirate.state.speed = vel.length(); + // ONE path: the nose points along the velocity the same path gives, which + // is what `velocityOf` reads back out of it. + if (pirate.state.speed > 1e-6) { + look.lookAt(pos, ahead.copy(pos).add(vel), UP); + pirate.object.quaternion.setFromRotationMatrix(look); + } + const step = cp.step(DT, st.player, st.world.npcs, st.commander.legalStatus, + false, null, Infinity, pirate); + if (step.kind !== 'fly') throw new Error('should be flying a live threat'); + st.player.update(DT, step.demand); + rollTravel += Math.abs(step.demand.rollRate) * DT; + + nose.set(0, 0, -1).applyQuaternion(st.player.quaternion); + to.copy(pirate.object.position).sub(st.player.position); + const lock = nose.angleTo(to) < hitCone(pirate.radius, to.length()) + && to.length() <= LASER_RANGE; + if (lock && firstLock === null) firstLock = t; + // the gap, and the window, both skip the first ten seconds of the swing on + if (t >= 10) { + late += 1; + if (lock) { onGun += 1; gap = 0; } else { gap += DT; longestGap = Math.max(longestGap, gap); } + } + } + return { + onGun: onGun / late, + firstLock, + longestGap, + rollTurns: rollTravel / (2 * Math.PI) / (seconds / 60), + }; + }; + + /** An orbit of a fixed centre, in one of the three planes. */ + const orbit = (radius: number, speed: number, plane: 'horizontal' | 'vertical' | 'tilted') => + (t: number, pos: THREE.Vector3, vel: THREE.Vector3): void => { + const a = (speed / radius) * t; + const x = Math.cos(a) * radius; const y = Math.sin(a) * radius; + const vx = -Math.sin(a) * speed; const vy = Math.cos(a) * speed; + if (plane === 'horizontal') { pos.set(x, 0, y); vel.set(vx, 0, vy); return; } + if (plane === 'vertical') { pos.set(0, x, y); vel.set(0, vx, vy); return; } + pos.set(x, y / Math.SQRT2, y / Math.SQRT2); + vel.set(vx, vy / Math.SQRT2, vy / Math.SQRT2); + }; + + // The limits are per case, and each one has room under the measured figure. + // The UNGATED controller is in the last column, so no limit here is vacuous: + // it fails every coupled case. See `COMBAT_ROLL_GATE`. + const CASES: { + name: string; seconds: number; minOnGun: number; maxLock: number; + maxGap: number; maxTurns: number; + path: (t: number, p: THREE.Vector3, v: THREE.Vector3) => void; + }[] = [ + { name: 'a horizontal orbit, 400 units at 300', seconds: 60, minOnGun: 0.80, + maxLock: 5, maxGap: 3, maxTurns: 6, path: orbit(400, 300, 'horizontal') }, + { name: 'a vertical orbit, 400 units at 300', seconds: 60, minOnGun: 0.95, + maxLock: 5, maxGap: 1, maxTurns: 1, path: orbit(400, 300, 'vertical') }, + { name: 'a tilted orbit, 800 units at 300', seconds: 60, minOnGun: 0.90, + maxLock: 5, maxGap: 2, maxTurns: 3, path: orbit(800, 300, 'tilted') }, + { name: 'a target crossing the front at 150', seconds: 60, minOnGun: 0.60, + maxLock: 5, maxGap: 12, maxTurns: 3, + path: (t, p, v) => { p.set(-900 + 150 * t, 0, -700); v.set(150, 0, 0); } }, + { name: 'a target weaving away', seconds: 60, minOnGun: 0.90, + maxLock: 5, maxGap: 2, maxTurns: 3, + path: (t, p, v) => { + p.set(350 * Math.sin(0.8 * t), 0, -1200 - 180 * t); + v.set(280 * Math.cos(0.8 * t), 0, -180); + } }, + { name: 'a target running straight away', seconds: 60, minOnGun: 0.99, + maxLock: 1, maxGap: 0.5, maxTurns: 0.5, + path: (t, p, v) => { p.set(0, 0, -1800 - 280 * t); v.set(0, 0, -280); } }, + ]; + + for (const c of CASES) { + const r = track(c.path, c.seconds); + const said = `${(r.onGun * 100).toFixed(0)}% on the gun, ` + + `lock ${r.firstLock === null ? 'never' : r.firstLock.toFixed(2) + 's'}, ` + + `worst gap ${r.longestGap.toFixed(2)}s, ${r.rollTurns.toFixed(1)} turns a minute`; + check(`it tracks ${c.name} (${said})`, + r.onGun >= c.minOnGun + && r.firstLock !== null && r.firstLock <= c.maxLock + && r.longestGap <= c.maxGap + && r.rollTurns <= c.maxTurns, said); + } +} diff --git a/test/run.ts b/test/run.ts index 0355a7ca..55b0b1a4 100644 --- a/test/run.ts +++ b/test/run.ts @@ -128,6 +128,7 @@ import './separation.test.ts'; import './tactics.test.ts'; import './tactic-choice.test.ts'; import './scripted-co-pilot.test.ts'; +import './co-pilot-tracking.test.ts'; import './pitch-roll-steer.test.ts'; import './pursuit.test.ts'; import './human-shape.test.ts'; diff --git a/test/scripted-co-pilot.test.ts b/test/scripted-co-pilot.test.ts index 06de8600..12e85ecd 100644 --- a/test/scripted-co-pilot.test.ts +++ b/test/scripted-co-pilot.test.ts @@ -133,48 +133,6 @@ console.log('\nscripted combat computer'); held === ahead && held !== abeam); } - // --- it PURSUES: get on a crossing target's six and hold it ----------------- - // The failure this replaced: the co-pilot flew the pirates' attack run, whose - // pass phase steers nowhere on purpose, so a target crossing close up was - // lost — "it lines up, shoots, then doesn't follow" (Chris, flying it). A - // pursuit dogfighter keeps the nose on it. This flies a target straight - // across the front, through the very `PlayerShip.update` the Game applies, and - // asserts the co-pilot ends up pointing near it and closed to gun range — - // which the attack run could not do. - { - const flier = new ScriptedCoPilot(); - while (state.world.npcs.length) state.world.npcs.pop(); - state.player.position.set(0, 0, 0); - state.player.quaternion.identity(); - state.world.spawn('pirate', new THREE.Vector3(-900, 0, -700), 1); - const target = state.world.npcs[state.world.npcs.length - 1]; - target.state.speed = 150; - const nose = new THREE.Vector3(); - const to = new THREE.Vector3(); - let onTargetLate = 0; - let lateFrames = 0; - const SECONDS = 20; - for (let i = 0; i < 60 * SECONDS; i++) { - // straight across the front, from left to right, a few hundred units ahead - target.object.position.set(-900 + (i / 60) * 150, 0, -700); - const s = flier.step(1 / 60, state.player, state.world.npcs, legal, false, null); - if (s.kind !== 'fly') throw new Error('should be flying a live threat'); - state.player.update(1 / 60, s.demand); - // measure only the second half, after it has had time to swing round - if (i > 60 * (SECONDS / 2)) { - lateFrames += 1; - nose.set(0, 0, -1).applyQuaternion(state.player.quaternion); - to.copy(target.object.position).sub(state.player.position); - if (nose.angleTo(to) < 0.1) onTargetLate += 1; // within ~6 degrees - } - } - const held = onTargetLate / lateFrames; - check(`it holds a crossing target near the nose (${(held * 100).toFixed(0)}% of the late window)`, - held > 0.6); - const finalDist = target.object.position.distanceTo(state.player.position); - check(`...and closes to gun range, not off in the distance (${finalDist.toFixed(0)} units)`, - finalDist < LASER_RANGE); - } } // --- IT STOPS AT THE STANDOFF, AND IT STOPS DEAD (docs/TODO/211) ------------ @@ -315,66 +273,3 @@ console.log('\nthe co-pilot leads the nose and matches the radial speed'); check('...but one that crosses at 300 keeps the ship turning with it', turnFor(300) > 0); } - -// --- IT HOLDS A SHIP THAT CIRCLES, WHICH THE UNLED PURSUIT COULD NOT -------- -// -// The regression that pins the pair above. A pirate orbits the commander at 400 -// units and 300 units a second, which is a bearing rate of 0.75 radians a -// second. The nose can turn at 1.45, so the rate was never the limit. The unled -// pursuit still held it on the gun 51% of the time, because it aimed where the -// target WAS and it chased a ship that was not running. -console.log('\nthe co-pilot holds a ship that circles it'); -{ - const ORBIT = 400; - const SPEED = 300; - const RATE = SPEED / ORBIT; - - /** Fly the orbit for `seconds`, and report the share of the late window on the gun. */ - const orbitRun = (seconds: number): number => { - seedWorld(4245); - const state = freshState(newCommander()); - state.world.build(state.systems[state.commander.systemIndex]); - state.world.clearNpcs(); - state.player.position.set(0, 0, 0); - state.player.quaternion.identity(); - state.player.speed = 200; - const legal = state.commander.legalStatus; - const pirate = state.world.spawn('pirate', new THREE.Vector3(ORBIT, 0, 0), 1); - pirate.state.speed = SPEED; - const cp = new ScriptedCoPilot(); - const look = new THREE.Matrix4(); - const up = new THREE.Vector3(0, 1, 0); - const ahead = new THREE.Vector3(); - const nose = new THREE.Vector3(); - const to = new THREE.Vector3(); - let held = 0; - let late = 0; - for (let i = 0; i < 60 * seconds; i++) { - const t = i / 60; - pirate.object.position.set(Math.cos(RATE * t) * ORBIT, 0, Math.sin(RATE * t) * ORBIT); - // its nose along the orbit, which is the velocity `velocityOf` returns - ahead.set(-Math.sin(RATE * t), 0, Math.cos(RATE * t)).multiplyScalar(SPEED); - look.lookAt(pirate.object.position, ahead.add(pirate.object.position), up); - pirate.object.quaternion.setFromRotationMatrix(look); - const s = cp.step(1 / 60, state.player, state.world.npcs, legal, - false, null, Infinity, pirate); - if (s.kind !== 'fly') throw new Error('should be flying a live threat'); - state.player.update(1 / 60, s.demand); - if (i > 60 * 10) { - late += 1; - nose.set(0, 0, -1).applyQuaternion(state.player.quaternion); - to.copy(pirate.object.position).sub(state.player.position); - if (nose.angleTo(to) < hitCone(pirate.radius, to.length())) held += 1; - } - } - return held / late; - }; - - // TWO SAMPLE SIZES, because one share of one window is not a measurement. The - // unled pursuit scores about 5% of either window, so the floor is not tight. - const short = orbitRun(30); - const long = orbitRun(60); - check(`it keeps a circling ship inside the gun cone over 30s (${(short * 100).toFixed(0)}%)`, - short > 0.20); - check(`...and over 60s (${(long * 100).toFixed(0)}%)`, long > 0.20); -} diff --git a/train/combat-aim.ts b/train/combat-aim.ts new file mode 100644 index 00000000..830c9a57 --- /dev/null +++ b/train/combat-aim.ts @@ -0,0 +1,91 @@ +// Does the co-pilot's aim hold up in a REAL fight? — the third measure. +// +// npm run combat-aim +// +// The review of 2026-09-12 (`docs/COMBAT-COMPUTER-REVIEW.md`) measured the +// co-pilot against PRESCRIBED target paths. That probe is exact and repeatable, +// and it carries no shots, no damage, and no opponent that fights back. Its own +// closing words ask for actual NPC fights before release. This is that check. +// +// It runs the combat exercise (`game/combat-sim.ts`), which is the live game +// with a different step behind it: real pirate brains, real guns, the real +// seeded stream. The commander is fitted with a combat computer, because that +// is what pulls the trigger, so the aim becomes shots. +// +// WHAT IT MEASURES, per fight: +// +// - the share of engaged frames with a live hostile inside `hitCone` and +// `LASER_RANGE`, which is the same question the prescribed probe asks; +// - how long the fight took, and how many hostiles died. +// +// TIME TO CLEAR IS NOISY, and the share on the gun is not. A sweep of +// `COMBAT_ROLL_GATE` over 72 fights moved the share from 39.5% to about 58%, +// and moved the seconds around with no trend. Read the share. +// +// It is not a balance test. Nothing here says whether a fight is fun. +import * as THREE from 'three'; +import { Game } from '../src/game/game.ts'; +import { headlessShell } from '../src/engine/shell.ts'; +import { withoutSaving } from '../src/game/storage.ts'; +import { seedWorld } from '../src/game/rng.ts'; +import { dismissBriefing } from '../test/harness.ts'; +import { hitCone } from '../src/game/gunnery.ts'; +import { LASER_RANGE } from '../src/constants/player-gun.ts'; +import type { ExerciseSpec, ScenarioId } from '../src/game/combat-sim-scenarios.ts'; + +const DT = 1 / 60; +const nose = new THREE.Vector3(); +const to = new THREE.Vector3(); + +const fight = (scenario: ScenarioId, tier: number, seed: number) => { + const g = withoutSaving(() => { + seedWorld(seed); + const game = new Game(() => headlessShell()); + dismissBriefing(game); + return game; + }).value; + const spec: ExerciseSpec = { mode: 'scenario', scenario, tier, seed }; + if (!g.startExercise(spec, { equipment: { combatComputer: true } })) return null; + const s = g.state; + const start = s.world.npcs.filter((n) => n.state.alive).length; + let frames = 0; let onGun = 0; let engaged = 0; + withoutSaving(() => { + let t = 0; + for (let i = 0; i < 200 / DT; i++) { + g.step(DT, t); t += DT; frames++; + s.world.scene.updateMatrixWorld(true); + if (g.coursePanel() !== null) break; // the exercise ended + const live = s.world.npcs.filter((n) => n.state.alive); + if (live.length === 0) continue; + engaged++; + s.player.getForward(nose); + // the easiest live hostile: the one nearest the nose, which is what the + // gun would take + let best = Infinity; let bestCone = 0; let bestDist = 0; + for (const n of live) { + to.copy(n.object.position).sub(s.player.position); + const a = nose.angleTo(to); + if (a < best) { best = a; bestCone = hitCone(n.radius, to.length()); bestDist = to.length(); } + } + if (best < bestCone && bestDist <= LASER_RANGE) onGun++; + } + }); + const left = s.world.npcs.filter((n) => n.state.alive).length; + return { seconds: +(frames * DT).toFixed(1), killed: start - left, left, + onGun: engaged ? +(100 * onGun / engaged).toFixed(1) : 0 }; +}; + +let secs = 0; let killed = 0; let left = 0; let onGunSum = 0; let n = 0; +for (const scenario of ['single-pirate', 'pirate-pair', 'pirate-gang'] as ScenarioId[]) { + for (const tier of [1, 3, 5]) { + for (const seed of [4242, 777, 20260912, 31337, 99, 555, 12345, 6006]) { + const r = fight(scenario, tier, seed); + if (!r) continue; + n++; secs += r.seconds; killed += r.killed; left += r.left; onGunSum += r.onGun; + } + } +} +// `left` is how many hostiles outlived the fight. Zero across the grid means +// the co-pilot cleared every one of them. +console.log(JSON.stringify({ fights: n, meanSeconds: +(secs / n).toFixed(1), + killed, left, meanOnGun: +(onGunSum / n).toFixed(1) })); From c54bde51e00b1adb0138374566661cf0bf622920 Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Sat, 12 Sep 2026 20:35:12 +0100 Subject: [PATCH 049/100] The computer shoots what it aimed at, and answers a warhead with no ship The three confirmed findings of the review (docs/COMBAT-COMPUTER-REVIEW.md). Two of them made the commander an Offender in its reproductions, for a ship the computer never aimed at. All three now reproduce clean through the review's own integration probe. THE VIEW. `autoEngage` turns the front view on when it takes the stick. A pilot may look astern afterwards, and the trigger then fired the REAR laser at whatever was behind. In the reproduction that was a trader. The computer aims the NOSE, so its shot is the front view's alone. A pilot who looks away keeps her own trigger. THE LINE. The co-pilot works in ANGLES: a target inside the gun cone is one it will shoot, and nothing asked what stands in the way. A trader between the commander and a pirate took the automatic shot. `autoFireAllowed` now traces the beam with the same `traceShot` the shot itself uses. A clean ray still fires, because the gun grazes a silhouette the ray can pass by. The pilot's own pick still fires, because she may choose to shoot a trader. Anything else first holds the shot. Both rules live in `flight-weapons.ts`, which is the gun's home, rather than half there and half in `flight.ts`. THE WARHEAD. `CoPilotStep`'s disengage carried no E.C.M. request, so with the last hostile dead and a missile still closing the co-pilot said AREA CLEAR and asked for nothing. A warhead is a threat with or without a ship to steer at. The disengage now carries the answer, and one press is a complete answer because `Ordnance` caps the sky at one warhead. A MANUAL OVERRIDE still asks for none, because the pilot took the ship and the E.C.M. is a key she holds. The dormant trained seat had the same defect, and it is fixed the same way. Nine tests pin the three, and each fails when its rule is broken. The line test carries its own control: with the way clear the same shot is taken, so it cannot pass on a computer that never shoots. An earlier version of it did exactly that, because the geometry drifted a hair outside the gun cone. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- src/game/autopilot.ts | 7 ++- src/game/combat-computer.ts | 17 +++++-- src/game/flight-weapons.ts | 47 +++++++++++++++++++ src/game/flight.ts | 6 +-- src/game/scripted-co-pilot.ts | 22 +++++++-- test/aim.test.ts | 83 ++++++++++++++++++++++++++++++++++ test/scripted-co-pilot.test.ts | 16 +++++++ 7 files changed, 185 insertions(+), 13 deletions(-) diff --git a/src/game/autopilot.ts b/src/game/autopilot.ts index e5faac5d..d9138937 100644 --- a/src/game/autopilot.ts +++ b/src/game/autopilot.ts @@ -246,9 +246,11 @@ export class Autopilot { if (step.kind === 'disengage') { s.session.ccEngaged = false; if (handsOn) s.session.handFlown = true; + // THE E.C.M. IS THE STEP'S, EVEN HERE. A warhead still closing is not + // answered by a clear area (the review of 2026-09-12). return { demand: null, - ecm: false, + ecm: step.ecm, events: [say(step.reason, step.reason === 'MANUAL OVERRIDE' ? 2 : 3)], }; } @@ -275,9 +277,10 @@ export class Autopilot { if (step.kind === 'disengage') { s.session.ccEngaged = false; if (handsOn) s.session.handFlown = true; + // ...and the same here — see `combatDemand` above. return { demand: null, - ecm: false, + ecm: step.ecm, events: [say(step.reason, step.reason === 'MANUAL OVERRIDE' ? 2 : 3)], }; } diff --git a/src/game/combat-computer.ts b/src/game/combat-computer.ts index 20d9e584..f188e860 100644 --- a/src/game/combat-computer.ts +++ b/src/game/combat-computer.ts @@ -38,8 +38,13 @@ import { import { ThreatLock } from './threat-lock.ts'; export type AutopilotStep = - /** hands off — the reason is for the player */ - | { kind: 'disengage'; reason: string } + /** + * Hands off — the reason is for the player. + * + * `ecm` rides along for the reason `CoPilotStep`'s does. A warhead in the air + * is a threat with or without a ship to steer at (the review of 2026-09-12). + */ + | { kind: 'disengage'; reason: string; ecm: boolean } /** * What it wants — and, separately, whether it reaches for the E.C.M. * @@ -157,7 +162,7 @@ export class CombatComputer { missilePos: V3 | null = null, playerToStation = Infinity, ): AutopilotStep { - if (manualInput) return { kind: 'disengage', reason: 'MANUAL OVERRIDE' }; + if (manualInput) return { kind: 'disengage', reason: 'MANUAL OVERRIDE', ecm: false }; // COMMITTED, not merely nearest. A fresh-every-frame pick flipped the // fought ship up to 26.8 times a minute, and the brain's bearing slots @@ -175,7 +180,11 @@ export class CombatComputer { ); if (!threat || !brain) { this.threatLock.clear(); - return { kind: 'disengage', reason: 'AREA CLEAR — COMBAT COMPUTER OFF' }; + return { + kind: 'disengage', + reason: 'AREA CLEAR — COMBAT COMPUTER OFF', + ecm: autopilotEcm(true, missilePos !== null), + }; } this.state.timer -= dt; diff --git a/src/game/flight-weapons.ts b/src/game/flight-weapons.ts index 2a2c2e84..804d97c4 100644 --- a/src/game/flight-weapons.ts +++ b/src/game/flight-weapons.ts @@ -35,6 +35,10 @@ import { sfx } from '../audio.ts'; import { Combat, BEAM_FLASH, type DamageSource } from './combat.ts'; import type { CombatEvent } from './combat-events.ts'; import { firePlayerLaser, damagePlayer } from './combat-player.ts'; +import { traceShot } from './shot.ts'; +import { viewDirection } from './views.ts'; +import { isHostileToPlayer } from './hostility.ts'; +import { pickedTarget } from './targets.ts'; import { CombatInstrumentation, type CombatObserver } from './instrumentation.ts'; import { fireEcm, ordnanceMessage, type Ordnance, type OrdnanceOutcome } from './ordnance.ts'; import { dealToNpc } from './damage-dealt.ts'; @@ -238,6 +242,49 @@ export class Weapons { this.applyCombat(firePlayerLaser(this.state, this.combat, this.combatScratch)); } + /** + * May the COMPUTER pull the trigger this frame? The human's is never asked. + * + * @param want whether the co-pilot asked for the trigger at all. + * + * THE COMPUTER SHOT AT WHATEVER THE BEAM MET FIRST, and the review of + * 2026-09-12 found what that costs. A trader flying between the commander and + * a pirate took the automatic shot, and the commander became an Offender for + * it. The co-pilot works in ANGLES: a target inside the gun cone is a target + * it will shoot, and nothing asked what stands in the way. + * + * So the same trace the shot itself uses answers first (`shot.ts`). Three + * rules, and each one has a reason: + * + * - A MISS is allowed. The gun grazes a silhouette the ray can pass by + * (gunnery.ts), and to refuse every clean ray would refuse most shots. + * - THE PILOT'S OWN PICK is allowed, whatever it is. She may choose to + * shoot a trader, and the computer aims what she picked (docs/TODO/206). + * - ANYTHING ELSE FIRST holds the shot: another ship that is not hostile, + * the station, or a canister. + * + * THE VIEW IS THE OTHER HALF of the same finding. `autoEngage` turns the + * front view on when it takes the stick. The pilot may look astern + * afterwards, and the trigger then fired the REAR laser at whatever was + * behind. The computer never aimed at that, and never saw it. So the + * automatic shot is the front view's alone, and a pilot who looks away keeps + * her own trigger. + */ + autoFireAllowed(want: boolean): boolean { + const { commander, player, session, world } = this.state; + if (!want || session.view !== 0) return false; + const dir = viewDirection(player.quaternion, 0, this.combatScratch.b); + const hit = traceShot( + player.position, dir, world.npcs, world.cargo.items, + session.witchspace ? null : world.station, + this.combatScratch.ray, this.combatScratch.a); + if (hit.kind === 'miss') return true; + if (hit.kind !== 'ship') return false; + if (hit.ship === pickedTarget(world.npcs)) return true; + return isHostileToPlayer(hit.ship, commander.legalStatus, + player.position.distanceTo(world.station.position)); + } + /** * Destruction credited to the player. * diff --git a/src/game/flight.ts b/src/game/flight.ts index e2dfe7fb..0821022a 100644 --- a/src/game/flight.ts +++ b/src/game/flight.ts @@ -344,9 +344,9 @@ export class Flight { // (docs/TODO/72). const bought = this.state.commander.equipment.combatComputer; if (auto.ecm && bought) this.weapons.triggerEcm(); - return auto.demand - ? { ...auto.demand, fire: (bought && auto.demand.fire) || hands.fire } - : hands; + // The hands are never asked. `autoFireAllowed` holds the computer's rule. + const shoots = bought && this.weapons.autoFireAllowed(auto.demand?.fire ?? false); + return auto.demand ? { ...auto.demand, fire: shoots || hands.fire } : hands; } /** diff --git a/src/game/scripted-co-pilot.ts b/src/game/scripted-co-pilot.ts index 7f0d94d2..23b8522a 100644 --- a/src/game/scripted-co-pilot.ts +++ b/src/game/scripted-co-pilot.ts @@ -56,8 +56,16 @@ import { MAX_LEAD_SECONDS } from '../constants/pass-aim.ts'; import type { V3 } from '../ai-training/observation.ts'; export type CoPilotStep = - /** hands off — the reason is for the player */ - | { kind: 'disengage'; reason: string } + /** + * Hands off — the reason is for the player. + * + * IT STILL ANSWERS A WARHEAD. A missile in the air is a threat with or without + * a SHIP to steer at. The review of 2026-09-12 found the two fused. With the + * last hostile dead and a warhead still closing, the co-pilot said AREA CLEAR + * and asked for no E.C.M. One press is a complete answer, because `Ordnance` + * caps the sky at one warhead. So the press on this frame clears it. + */ + | { kind: 'disengage'; reason: string; ecm: boolean } /** * What the pursuit wants this frame. It is the SAME FlightDemand that a pair * of hands produces (player.ts): ramped pitch and roll rates, a throttle, @@ -117,7 +125,9 @@ export class ScriptedCoPilot { playerToStation = Infinity, picked: NpcShip | null = null, ): CoPilotStep { - if (manualInput) return { kind: 'disengage', reason: 'MANUAL OVERRIDE' }; + // MANUAL OVERRIDE ASKS FOR NO E.C.M. The pilot took the ship, and the + // E.C.M. is a key she holds. Every other way out still answers a warhead. + if (manualInput) return { kind: 'disengage', reason: 'MANUAL OVERRIDE', ecm: false }; this.underFire = Math.max(0, this.underFire - dt); // How far off the nose a candidate is — the turn it would cost to lock. const offNose = (npc: NpcShip): number => this.nose.set(0, 0, -1) @@ -150,7 +160,11 @@ export class ScriptedCoPilot { ); if (!threat) { this.reset(); - return { kind: 'disengage', reason: 'AREA CLEAR' }; + return { + kind: 'disengage', + reason: 'AREA CLEAR', + ecm: autopilotEcm(true, missilePos !== null), + }; } const targetPos = threat.object.position; const dist = targetPos.distanceTo(player.position); diff --git a/test/aim.test.ts b/test/aim.test.ts index 49d34c1b..00973d14 100644 --- a/test/aim.test.ts +++ b/test/aim.test.ts @@ -141,3 +141,86 @@ function beside(g: Game, role: 'pirate' | 'trader', x: number, seed: number): Np run(g, 30); check('a course picked mid-fight is dropped too', g.state.session.course === null); } + +// --- WHAT AUTHORIZES THE COMPUTER'S SHOT ------------------------------------ +// +// Two findings of the review of 2026-09-12 (`docs/COMBAT-COMPUTER-REVIEW.md`). +// Each one made the commander an Offender in its own reproduction, for a ship +// the computer never aimed at. +// +// The commander is fitted with a combat computer, because that is the fitting +// that gives the trigger away. Without it the aim is free and the trigger stays +// the pilot's, so neither fault can arise. +console.log('\nthe computer holds its shot unless the shot is its own'); +{ + // THE VIEW. `autoEngage` turns the front view on when it takes the stick. A + // pilot may look astern afterwards, and the trigger then fired the REAR + // laser at whatever was behind. + const g = open(20_260_930); + g.state.commander.equipment.combatComputer = true; + const pirate = beside(g, 'pirate', 200, 11); + pirate.state.speed = 0; + // a trader parked behind, where the rear laser points + const behind = g.state.player.position.clone() + .add(new THREE.Vector3(0, 0, 900).applyQuaternion(g.state.player.quaternion)); + const trader = g.state.world.spawn('trader', behind, 12); + trader.state.speed = 0; + g.state.commander.equipment.rearLaser = true; + + run(g, 120); + check('the computer has the stick, with a pirate ahead', g.state.session.ccEngaged); + g.state.session.view = 1; // look astern, as a command key does + const before = g.state.sys.laserTemp; + run(g, 60); + eq('looking astern, the computer fires nothing at all', + g.state.sys.laserTemp <= before, true); + check('...so the trader behind is not provoked', !trader.state.provokedByPlayer); + eq('...and the commander is still clean', g.state.commander.legalStatus, 0); +} + +{ + // THE LINE. A trader between the commander and the pirate took the shot. + const g = open(20_260_931); + g.state.commander.equipment.combatComputer = true; + const ahead = (d: number) => g.state.player.position.clone() + .add(new THREE.Vector3(0, 0, -d).applyQuaternion(g.state.player.quaternion)); + const pirate = g.state.world.spawn('pirate', ahead(2400), 13); + pirate.state.speed = 0; + run(g, 180); // let the nose come onto it + + // Both are put ON the nose, so the shot is one the computer really wants and + // the trader is squarely in the beam. Drifting geometry made an earlier + // version of this test pass for the wrong reason: the pirate slid a hair + // outside the gun cone, so nothing fired either way. + const park = (n: typeof pirate, d: number): void => { + n.object.position.copy(ahead(d)); + n.object.updateMatrixWorld(true); + }; + park(pirate, 900); + const trader = g.state.world.spawn('trader', ahead(450), 14); + trader.state.speed = 0; + park(trader, 450); + run(g, 30); + check('with a trader in the way, the computer holds its fire', + g.state.sys.laserTemp === 0, + `laser temp ${g.state.sys.laserTemp.toFixed(3)}`); + check('...so the trader is not provoked', !trader.state.provokedByPlayer); + eq('...and the commander is still clean', g.state.commander.legalStatus, 0); + + // THE CONTROL: with the way clear, the same geometry does fire. Without it, + // the two checks above would pass on a computer that never shoots at all. + trader.state.alive = false; + park(pirate, 900); + run(g, 30); + check('...and with the way clear, the same shot is taken', + g.state.sys.laserTemp > 0, `laser temp ${g.state.sys.laserTemp.toFixed(3)}`); + + // ...and the pilot's OWN pick is hers to shoot at, whatever it is. + const picked = g.state.world.spawn('trader', ahead(450), 15); + picked.state.speed = 0; + park(picked, 450); + pickTarget(g.state.world.npcs, picked); + run(g, 60); + check('a trader the PILOT picked is shot at', picked.state.provokedByPlayer, + `provoked ${picked.state.provokedByPlayer}`); +} diff --git a/test/scripted-co-pilot.test.ts b/test/scripted-co-pilot.test.ts index 12e85ecd..1b7b5f9d 100644 --- a/test/scripted-co-pilot.test.ts +++ b/test/scripted-co-pilot.test.ts @@ -98,6 +98,22 @@ console.log('\nscripted combat computer'); { x: 0, y: 400, z: 0 }); check('a clear sky gets no E.C.M.', clear.kind === 'fly' && !clear.ecm); check('...and a warhead in it always does', loud.kind === 'fly' && loud.ecm); + + // A WARHEAD OUTLIVES THE SHIP THAT FIRED IT. The review of 2026-09-12 found + // the two fused: with the last hostile dead and a missile still closing, + // the co-pilot said AREA CLEAR and asked for no E.C.M. at all. One press is + // a complete answer, because `Ordnance` caps the sky at one warhead. + const alone = new ScriptedCoPilot(); + const gone = alone.step(1 / 60, state.player, [], legal, false, { x: 0, y: 400, z: 0 }); + check('with the last ship dead, a warhead still gets the E.C.M.', + gone.kind === 'disengage' && gone.ecm); + const quietly = alone.step(1 / 60, state.player, [], legal, false, null); + check('...and an empty sky with no warhead asks for nothing', + quietly.kind === 'disengage' && !quietly.ecm); + // A pilot who takes the stick keeps her own E.C.M. key. + const taken = alone.step(1 / 60, state.player, [], legal, true, { x: 0, y: 400, z: 0 }); + check('...and a manual override asks for none either', + taken.kind === 'disengage' && taken.reason === 'MANUAL OVERRIDE' && !taken.ecm); } // hands and an empty sky both give the ship back, in the co-pilot's words From b12e1a87fa08dafe6758f4f50c8859056d662964 Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Sat, 12 Sep 2026 20:38:45 +0100 Subject: [PATCH 050/100] One handover contract: the rates are the ship's, and the memory is the fight's MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Review recommendation 5 (docs/COMBAT-COMPUTER-REVIEW.md). It found three ways a resumed co-pilot flew differently from a fresh one at the same geometry. All three are the same mistake: the controller kept a private copy of state the world already holds, or held state a new engagement should not inherit. THE RATES ARE THE SHIP'S. `ScriptedCoPilot` kept its own `pitchRate` and `rollRate` and ramped from those. `PlayerShip.update` writes the ship's from the demand it flew, so in ordinary flight the two are the same number. They differ in exactly the two places the review measured. A manual override left the copy holding a roll the ship had stopped, and re-engagement put a −1.13 rad/s roll back on a target dead ahead. A restored save put the ship's own roll back correctly, then replaced it on the next step, turning a continued −1.48 into −0.17. So the ramp reads `player.pitchRate` and `player.rollRate`, and the controller keeps no rates at all. `AutopilotShip` carries them, which is the one interface change. Nothing new has to be saved, because `persistence.ts` already carries the ship's rates. THE MEMORY IS THE FIGHT'S. `reset()` cleared the lock and the rates and left `steerMem.side` behind, so a reset controller could bank the opposite way from a fresh one. It now clears everything. There is no state here a new engagement should inherit, so there is nothing to choose between. The review's own integration probe measures all four reproductions as exact matches now. `save_mid_turn` reports an orientation difference of 0, from 0.0219. `reenage_after_manual_override` and `reset_retains_steering_side` both report the resumed controller asking exactly what a fresh one asks. Six tests pin the contract. The bank-side one needs a geometry where the memory actually decides, so it commits the bank with a target BELOW, then asks with one LEVEL, where the flip margin holds whichever side is committed. Its first assertion checks the two controllers still disagree, so the second cannot pass on a fixture that stopped testing anything. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- src/game/combat-computer.ts | 11 +++++ src/game/scripted-co-pilot.ts | 34 +++++++++----- test/flight.test.ts | 5 ++- test/scripted-co-pilot.test.ts | 81 ++++++++++++++++++++++++++++++++++ 4 files changed, 118 insertions(+), 13 deletions(-) diff --git a/src/game/combat-computer.ts b/src/game/combat-computer.ts index f188e860..c6a31fc3 100644 --- a/src/game/combat-computer.ts +++ b/src/game/combat-computer.ts @@ -62,6 +62,17 @@ export interface AutopilotShip { position: THREE.Vector3; quaternion: THREE.Quaternion; speed: number; + /** + * The rates the ship is ACTUALLY turning at. + * + * The scripted co-pilot ramps from these rather than from a copy of its own + * last ask (`scripted-co-pilot.ts`). `PlayerShip.update` writes them from the + * demand it flew, so in ordinary flight the two are the same number. They + * differ exactly where the review of 2026-09-12 found a defect: after a + * manual override, and after a restore. + */ + pitchRate: number; + rollRate: number; } /** diff --git a/src/game/scripted-co-pilot.ts b/src/game/scripted-co-pilot.ts index 23b8522a..37768cd6 100644 --- a/src/game/scripted-co-pilot.ts +++ b/src/game/scripted-co-pilot.ts @@ -87,9 +87,6 @@ export class ScriptedCoPilot { /** where the target goes, and where the nose is sent — see `step` */ private readonly threatVel = new THREE.Vector3(); private readonly aim = new THREE.Vector3(); - /** ramped turn rates, so the co-pilot's turn continues smoothly frame to frame */ - private pitchRate = 0; - private rollRate = 0; /** which vertical the bank-to-turn is committed to — see pitch-roll-steer.ts */ private readonly steerMem: SteerMemory = freshSteerMemory(); /** @@ -107,11 +104,17 @@ export class ScriptedCoPilot { this.underFire = UNDER_FIRE_SECONDS; } - /** Let go of the fight entirely — the next step starts from nothing. */ + /** + * Let go of the fight entirely — the next engagement starts from nothing. + * + * EVERY field goes, and `steerMem.side` used to survive. A reset controller + * then banked the opposite way from a fresh one at the same geometry (the + * review of 2026-09-12). There is no state here a new engagement should + * inherit, so there is nothing to choose between. + */ reset(): void { this.lock.clear(); - this.pitchRate = 0; - this.rollRate = 0; + this.steerMem.side = freshSteerMemory().side; this.underFire = 0; } @@ -202,10 +205,17 @@ export class ScriptedCoPilot { // co-pilot flies your ship as your hands would. const cmd = bankToTurn(player.quaternion, this.aim.sub(player.position), this.steerMem, cone, COMBAT_ROLL_GATE); - this.pitchRate = rampFlightRate( - this.pitchRate, cmd.pitch * PLAYER_FLIGHT.maxPitch, cmd.pitch !== 0, dt); - this.rollRate = rampFlightRate( - this.rollRate, cmd.roll * PLAYER_FLIGHT.maxRoll, cmd.roll !== 0, dt); + // THE RAMP READS THE SHIP, not a copy of the last ask. `PlayerShip.update` + // writes these from the demand it flew, so in ordinary flight the two are + // the same number. They differ where it matters (the review of + // 2026-09-12). A manual override leaves the ship somewhere the co-pilot's + // copy does not know about. A restored save puts the ship's own rates back, + // while a fresh controller's copy reads zero. So this needs no rate state, + // and nothing has to save one. + const pitchRate = rampFlightRate( + player.pitchRate, cmd.pitch * PLAYER_FLIGHT.maxPitch, cmd.pitch !== 0, dt); + const rollRate = rampFlightRate( + player.rollRate, cmd.roll * PLAYER_FLIGHT.maxRoll, cmd.roll !== 0, dt); // How fast the target RECEDES, which is the speed that holds a standoff. Its // whole speed is the wrong number. A ship that circles you holds its range @@ -219,8 +229,8 @@ export class ScriptedCoPilot { return { kind: 'fly', demand: { - pitchRate: this.pitchRate, - rollRate: this.rollRate, + pitchRate, + rollRate, // THE STANDOFF IS MEASURED FROM THE HULL (docs/TODO/211). A rock is // 54 units across the radius, and the derelict is 340. A range held // to the centre put the commander 160 units off the derelict's hull, diff --git a/test/flight.test.ts b/test/flight.test.ts index c4bebaed..5ce06dc7 100644 --- a/test/flight.test.ts +++ b/test/flight.test.ts @@ -317,7 +317,10 @@ console.log('\nflight demands'); // the machinery under test, on the fixture genome — there are no shipped // defence weights since 2026-08-05 const brain = defendShaped; - const player = { position: new THREE.Vector3(), quaternion: new THREE.Quaternion(), speed: 200 }; + const player = { + position: new THREE.Vector3(), quaternion: new THREE.Quaternion(), speed: 200, + pitchRate: 0, rollRate: 0, + }; const sys = freshSystems(); const pirate = new NpcShip('pirate', new THREE.Vector3(0, 0, -900), 5); pirate.state.provoked = true; diff --git a/test/scripted-co-pilot.test.ts b/test/scripted-co-pilot.test.ts index 1b7b5f9d..53392cbf 100644 --- a/test/scripted-co-pilot.test.ts +++ b/test/scripted-co-pilot.test.ts @@ -289,3 +289,84 @@ console.log('\nthe co-pilot leads the nose and matches the radial speed'); check('...but one that crosses at 300 keeps the ship turning with it', turnFor(300) > 0); } + +// --- ONE HANDOVER CONTRACT ------------------------------------------------ +// +// The review of 2026-09-12 found three ways a resumed co-pilot flew differently +// from a fresh one at the same geometry. The contract that answers all three: +// +// 1. THE RATES ARE THE SHIP'S. The co-pilot keeps no copy of its last ask. It +// ramps from `player.pitchRate` and `player.rollRate`, which +// `PlayerShip.update` writes from the demand it flew. So a manual override +// and a restored save both leave the ramp reading the truth. +// 2. THE ENGAGEMENT MEMORY GOES ON `reset`. The lock, the bank side and the +// under-fire timer are all the engagement's, and none of them is worth +// inheriting. +// 3. NOTHING HERE NEEDS SAVING. What survives a save is the ship's own rates, +// which `persistence.ts` already carries. +console.log('\nthe co-pilot hands the ship over on one contract'); +{ + seedWorld(4246); + const state = freshState(newCommander()); + state.world.build(state.systems[state.commander.systemIndex]); + state.world.clearNpcs(); + state.player.position.set(0, 0, 0); + state.player.quaternion.identity(); + state.player.speed = 200; + const legal = state.commander.legalStatus; + // off to one side, so there is a real bank to make + const pirate = state.world.spawn('pirate', new THREE.Vector3(900, 120, -1400), 1); + pirate.state.speed = 0; + + /** One step of a co-pilot at the fixture's geometry. */ + const ask = (cp: ScriptedCoPilot) => { + const s = cp.step(1 / 60, state.player, state.world.npcs, legal, false, null); + if (s.kind !== 'fly') throw new Error('should be flying a live threat'); + return s.demand; + }; + + // A controller that flew for a while, then had the ship taken off it. + const used = new ScriptedCoPilot(); + for (let i = 0; i < 90; i++) ask(used); + const handedBack = used.step(1 / 60, state.player, state.world.npcs, legal, true, null); + check('touching the controls hands the ship back', handedBack.kind === 'disengage'); + + // The pilot flies it somewhere, and the ship stops turning. + state.player.pitchRate = 0; + state.player.rollRate = 0; + const resumed = ask(used); + const fresh = ask(new ScriptedCoPilot()); + eq('a resumed co-pilot asks for the same roll a fresh one does', + resumed.rollRate, fresh.rollRate); + eq('...and the same pitch', resumed.pitchRate, fresh.pitchRate); + + // ...AND A RESET ONE TOO, which `steerMem.side` used to break. + // + // The geometry has to be one where the memory actually decides. A target + // BELOW commits the bank to the bottom. A target LEVEL to one side then has + // the same roll either way round, so the flip margin holds whichever side is + // committed, and a stale one shows. + const wrongWay = new ScriptedCoPilot(); + pirate.object.position.set(0, -900, -1400); + for (let i = 0; i < 60; i++) ask(wrongWay); + pirate.object.position.set(900, 0, -1400); + state.player.pitchRate = 0; + state.player.rollRate = 0; + check('a co-pilot that kept flying banks the way it committed to', + ask(wrongWay).rollRate * ask(new ScriptedCoPilot()).rollRate < 0, + 'the fixture is only a test of reset() while these disagree'); + state.player.pitchRate = 0; + state.player.rollRate = 0; + wrongWay.reset(); + eq('...and a reset one banks the way a fresh one does', + ask(wrongWay).rollRate, ask(new ScriptedCoPilot()).rollRate); + + // THE RAMP READS THE SHIP. A ship already rolling continues from that rate, + // rather than from a zero the co-pilot kept to itself. + state.player.rollRate = -1.2; + const carried = ask(new ScriptedCoPilot()).rollRate; + state.player.rollRate = 0; + const fromRest = ask(new ScriptedCoPilot()).rollRate; + check('a ship already rolling carries that rate into the ramp', + carried < fromRest - 0.5, `${carried.toFixed(3)} against ${fromRest.toFixed(3)}`); +} From c9bf0af0d8f6668cebf846763682f973a6ab1abf Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Sat, 12 Sep 2026 20:43:59 +0100 Subject: [PATCH 051/100] A commitment has to be going somewhere, and the lead survives re-measurement Review recommendations 3 and 4 (docs/COMBAT-COMPUTER-REVIEW.md). Both asked for a measurement before a change, and the two measurements disagree about whether to change anything. THE LEAD NEEDED NO CHANGE, and the concern that prompted the ask has gone. The review measured a lead costing the straight-crossing case 74.3%, against 98.7% with none, at a bank gate of 0.1. At `COMBAT_ROLL_GATE`'s settled value the same case scores 89% WITH the lead. A sweep of `PURSUIT_LEAD_GAIN` over both grids and 72 real fights puts the shipped 2.0 on the best worst case of both grids, and at 3.0 one orbit is lost outright. The table is beside the constant, so the next reader does not repeat the sweep. THE COMMITMENT DID. `ENGAGED_CONE` called a target an attack in progress on its angle alone. The review held one 3,000 units away and 23 degrees off, with a second hostile 500 units dead ahead, and ten seconds later the easy shot was still refused. A cone says where a ship is. It does not say the attack is going anywhere. `ENGAGED_PATIENCE` is the answer: the veto now also asks that the target fell inside the gun cone within the last 3 seconds. `THREAT_MIN_HOLD` and `THREAT_SWITCH_MARGIN` are untouched, so a switch still needs a much nearer target held for long enough. THE VALUE IS NOT PINNED BY MEASUREMENT, and the constant says so. A sweep from 1 second to 999 moved nothing: not the 21 prescribed paths, which carry one target and cannot exercise a switch, and not 72 fights through `npm run combat-aim`. The rule is dormant in everything this repository can measure, and it fires in the case the review built. That case is a fight a player can meet, so it ships with the honest note that 3 seconds is reasoned rather than fitted. The test carries its own control: a commitment that IS landing shots keeps the lock. With the patience effectively off, the first assertion fails and the control still passes. The co-pilot's tests now divide by the question each asks. What it asks for stays in `scripted-co-pilot.test.ts`. Where the nose goes is `co-pilot-tracking.test.ts`. Who it holds, and what survives a handover, is the new `co-pilot-engagement.test.ts`. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- src/constants/CATALOG.md | 9 +- src/constants/combat-computer.ts | 49 ++++++++++ src/game/scripted-co-pilot.ts | 28 +++++- test/co-pilot-engagement.test.ts | 154 +++++++++++++++++++++++++++++++ test/run.ts | 1 + test/scripted-co-pilot.test.ts | 81 ---------------- 6 files changed, 233 insertions(+), 89 deletions(-) create mode 100644 test/co-pilot-engagement.test.ts diff --git a/src/constants/CATALOG.md b/src/constants/CATALOG.md index bdee32ae..35b8f010 100644 --- a/src/constants/CATALOG.md +++ b/src/constants/CATALOG.md @@ -2,7 +2,7 @@ -454 exported constants. Regenerate with `npm run generate:constants`; +455 exported constants. Regenerate with `npm run generate:constants`; search names, meanings and values with `npm run constants:find -- ""`. | Domain | Symbol | Literal / expression | Purpose | Rule ID | Source | @@ -80,9 +80,10 @@ search names, meanings and values with `npm run constants:find -- ""`. | combat-computer | PURSUIT_SLASH_CONE | 1.3 | A pursuit PIRATE switches flight models on where it sits in the commander's arc. | | [combat-computer.ts:178](./combat-computer.ts#L178) | | combat-computer | PURSUIT_HOLD_CONE | 1.85 | | | [combat-computer.ts:179](./combat-computer.ts#L179) | | combat-computer | ENGAGED_CONE | 0.6 | The nose-to-target angle, in radians, within which the co-pilot counts itself ENGAGED and will not switch targets. | | [combat-computer.ts:188](./combat-computer.ts#L188) | -| combat-computer | COMBAT_ROLL_GATE | 0.27 | How near its bank the co-pilot must be before it pulls the nose, in radians. | copilot.rollGate | [combat-computer.ts:240](./combat-computer.ts#L240) | -| combat-computer | TARGET_DIST_WEIGHT | 800 | How many world units of range weigh as much as one radian of off-nose turn. | copilot.targetDistWeight | [combat-computer.ts:258](./combat-computer.ts#L258) | -| combat-computer | PURSUIT_LEAD_GAIN | 2.0 | How many SECONDS the co-pilot aims ahead of a target, per radian that its nose still has to swing. | copilot.leadGain | [combat-computer.ts:309](./combat-computer.ts#L309) | +| combat-computer | ENGAGED_PATIENCE | 3 | How long the co-pilot stays committed to a target it cannot shoot, in seconds. | copilot.engagedPatience | [combat-computer.ts:221](./combat-computer.ts#L221) | +| combat-computer | COMBAT_ROLL_GATE | 0.27 | How near its bank the co-pilot must be before it pulls the nose, in radians. | copilot.rollGate | [combat-computer.ts:273](./combat-computer.ts#L273) | +| combat-computer | TARGET_DIST_WEIGHT | 800 | How many world units of range weigh as much as one radian of off-nose turn. | copilot.targetDistWeight | [combat-computer.ts:291](./combat-computer.ts#L291) | +| combat-computer | PURSUIT_LEAD_GAIN | 2.0 | How many SECONDS the co-pilot aims ahead of a target, per radian that its nose still has to swing. | copilot.leadGain | [combat-computer.ts:358](./combat-computer.ts#L358) | | combat-record | SAMPLE_HZ | 10 | How often the code samples the geometry, in Hz. | | [combat-record.ts:12](./combat-record.ts#L12) | | combat-record | SIX_CONE | Math.PI / 3 | The rear cone that counts as somebody's six, as a half-angle from directly astern. | | [combat-record.ts:20](./combat-record.ts#L20) | | combat-record | PASS_CLOSE | 400 | What an attack run is, in ranges. | | [combat-record.ts:42](./combat-record.ts#L42) | diff --git a/src/constants/combat-computer.ts b/src/constants/combat-computer.ts index d61cc98d..47cc2b77 100644 --- a/src/constants/combat-computer.ts +++ b/src/constants/combat-computer.ts @@ -187,6 +187,39 @@ export const PURSUIT_HOLD_CONE = 1.85; */ export const ENGAGED_CONE = 0.6; +/** + * How long the co-pilot stays committed to a target it cannot shoot, in + * seconds. Past it, `ENGAGED_CONE` no longer vetoes a switch. + * + * ENGAGED USED TO MEAN ROUGHLY ON THE NOSE, AND NOTHING MORE. The review of + * 2026-09-12 held a target 3,000 units away and 23 degrees off, with a second + * hostile 500 units dead ahead. Ten seconds later the lock still refused the + * easy shot, and a fresh controller took it. A cone says where a ship is. It + * does not say the attack is going anywhere. + * + * So the veto now asks for PROGRESS as well. The target must fall inside the + * gun cone within this many seconds. The distance rule still governs the rest, and + * `THREAT_MIN_HOLD` and `THREAT_SWITCH_MARGIN` are untouched. A switch still + * needs a target much nearer, held for long enough. + * + * THE VALUE IS NOT PINNED BY MEASUREMENT, and that is worth saying plainly. A + * sweep from 1 second to 999 moved nothing. It moved neither the review's 21 + * prescribed paths, which carry one target and cannot exercise a switch at all, + * nor 72 real fights through `npm run combat-aim`. The rule is dormant in + * everything this repository can measure. It fires in the case the review + * built, where a near hostile is ignored for a far one. That case is a fight a + * player can meet. + * + * So 3 seconds is reasoned rather than fitted. It is about two swings of the + * nose at `MAX_LEAD_SECONDS`. It is long enough that a target crossing the + * sight is not dropped between passes, and short enough that a chase going + * nowhere ends. Measure it on a harness that produces the geometry before you + * move it. + * + * @rule copilot.engagedPatience + */ +export const ENGAGED_PATIENCE = 3; + /** * How near its bank the co-pilot must be before it pulls the nose, in radians. * Above it, `bankToTurn` asks for NO pitch at all. @@ -297,6 +330,22 @@ export const TARGET_DIST_WEIGHT = 800; * move it. A 13-target sample and a 40-target sample disagreed about the radial * throttle's worth, so a small sample is not enough to retune on. * + * RE-MEASURED AT `COMBAT_ROLL_GATE`, on the review of 2026-09-12. That review + * asked for the lead to be revisited once the bank was fixed. A lead cost the + * straight-crossing case 74.3%, against 98.7% with none. At the gate this + * repository settled on, that trade is gone. The same case scores 89% WITH the + * lead. The sweep over the review's two grids and 72 real fights: + * + * | gain | 21 paths, 60s | 54 orbits, 90s | 72 fights | + * | 0 | 93.4%, 32.7% | 93.3%, 50.2% | 33.8% | + * | 1 | 97.8%, 81.7% | 96.9%, 70.3% | 60.0% | + * | 2 | 98.3%, 88.5% | 97.6%, 77.2% | 57.5% | + * | 3 | 98.9%, 86.1% | 93.4%, 0.0% | 59.7% | + * + * The second figure of each pair is the worst case. 2.0 holds the best worst + * case on both grids. At 3.0 one orbit is lost outright, which is the hole the + * paragraph above names, found again on a different grid. + * * THE HOME IS THIS FILE, and the owner check disagrees. It reads the words * "rule" and "bounded" above and reaches for the law domain. This is a feel * setting of the SCRIPTED co-pilot. It sits in the `PURSUIT_*` block that the diff --git a/src/game/scripted-co-pilot.ts b/src/game/scripted-co-pilot.ts index 37768cd6..55d18565 100644 --- a/src/game/scripted-co-pilot.ts +++ b/src/game/scripted-co-pilot.ts @@ -48,8 +48,8 @@ import { rampFlightRate, type FlightDemand } from '../player.ts'; import { LASER_RANGE } from '../constants/player-gun.ts'; import { UNDER_FIRE_SECONDS } from '../constants/attack-run.ts'; import { - THREAT_RANGE, PURSUIT_SPEED_DEADBAND, ENGAGED_CONE, TARGET_DIST_WEIGHT, - PURSUIT_LEAD_GAIN, COMBAT_ROLL_GATE, + THREAT_RANGE, PURSUIT_SPEED_DEADBAND, ENGAGED_CONE, ENGAGED_PATIENCE, + TARGET_DIST_WEIGHT, PURSUIT_LEAD_GAIN, COMBAT_ROLL_GATE, } from '../constants/combat-computer.ts'; import { PLAYER_FLIGHT } from '../constants/player-flight.ts'; import { MAX_LEAD_SECONDS } from '../constants/pass-aim.ts'; @@ -99,6 +99,13 @@ export class ScriptedCoPilot { * evasive behaviour needs no new wiring. */ private underFire = 0; + /** + * Seconds since the held target was last inside the gun cone, and the ship + * the count belongs to. Together they are "is this attack going anywhere". + * `ENGAGED_PATIENCE` is what reads them. + */ + private sinceGunOn = 0; + private counting: NpcShip | null = null; noteHit(): void { this.underFire = UNDER_FIRE_SECONDS; @@ -116,6 +123,8 @@ export class ScriptedCoPilot { this.lock.clear(); this.steerMem.side = freshSteerMemory().side; this.underFire = 0; + this.sinceGunOn = 0; + this.counting = null; } step( @@ -159,7 +168,12 @@ export class ScriptedCoPilot { // easier (Chris). The ranking hands over a better target only when the // co-pilot is NOT engaged, which means the current one ran wide or ran // behind. - (npc) => offNose(npc) < ENGAGED_CONE, + // + // ...AND THAT THE KILL IS GOING SOMEWHERE. A cone alone held a target + // 3,000 units off at 23 degrees while a second hostile sat 500 units dead + // ahead (the review of 2026-09-12). `ENGAGED_PATIENCE` is how long a + // target may go unshot and still block the switch. + (npc) => offNose(npc) < ENGAGED_CONE && this.sinceGunOn < ENGAGED_PATIENCE, ); if (!threat) { this.reset(); @@ -226,6 +240,12 @@ export class ScriptedCoPilot { // step. Copy it again before you use it as a distance below this line. const recede = Math.max(0, this.threatVel.dot(this.toThreat.normalize())); + // IS THIS ATTACK GOING ANYWHERE? The count is per target, so a switch + // gives the new one a full `ENGAGED_PATIENCE` before it can be dropped. + const onGun = dist <= LASER_RANGE && facing < cone; + if (threat !== this.counting) { this.counting = threat; this.sinceGunOn = 0; } + this.sinceGunOn = onGun ? 0 : this.sinceGunOn + dt; + return { kind: 'fly', demand: { @@ -241,7 +261,7 @@ export class ScriptedCoPilot { // the trigger only when the shot would count: the player gun's own cone // and range (gunnery.ts). The laser's heat and cooldown pace it from // there, which is what makes this a marksman rather than a sprayer - fire: dist <= LASER_RANGE && facing < cone, + fire: onGun, }, // a warhead is always answered. Whether one is on its way is the world's // fact, and the gate is the same one every E.C.M. press goes through diff --git a/test/co-pilot-engagement.test.ts b/test/co-pilot-engagement.test.ts new file mode 100644 index 00000000..a02a3a9b --- /dev/null +++ b/test/co-pilot-engagement.test.ts @@ -0,0 +1,154 @@ +// THE ENGAGEMENT: who the co-pilot holds, and what happens at a handover. +// +// Split from `scripted-co-pilot.test.ts` on 2026-09-12, when that file passed +// the 400-line ceiling. Three files now divide the co-pilot's tests by the +// question each one asks: +// +// - `scripted-co-pilot.test.ts` — what it ASKS FOR: the trigger, the E.C.M., +// the standoff, the lead and the throttle; +// - `co-pilot-tracking.test.ts` — where the nose GOES, over time; +// - this file — WHO it holds, and what survives when the ship changes hands. +// +// Both subjects here come from the review of 2026-09-12 +// (`docs/COMBAT-COMPUTER-REVIEW.md`), and neither is visible in a demand read +// one frame at a time. + +import * as THREE from 'three'; +import { ScriptedCoPilot } from '../src/game/scripted-co-pilot.ts'; +import { freshState } from '../src/game/state.ts'; +import { newCommander } from '../src/game/commander.ts'; +import { seedWorld } from '../src/game/rng.ts'; +import { check, eq } from './harness.ts'; + +// --- ONE HANDOVER CONTRACT ------------------------------------------------ +// +// The review of 2026-09-12 found three ways a resumed co-pilot flew differently +// from a fresh one at the same geometry. The contract that answers all three: +// +// 1. THE RATES ARE THE SHIP'S. The co-pilot keeps no copy of its last ask. It +// ramps from `player.pitchRate` and `player.rollRate`, which +// `PlayerShip.update` writes from the demand it flew. So a manual override +// and a restored save both leave the ramp reading the truth. +// 2. THE ENGAGEMENT MEMORY GOES ON `reset`. The lock, the bank side and the +// under-fire timer are all the engagement's, and none of them is worth +// inheriting. +// 3. NOTHING HERE NEEDS SAVING. What survives a save is the ship's own rates, +// which `persistence.ts` already carries. +console.log('\nthe co-pilot hands the ship over on one contract'); +{ + seedWorld(4246); + const state = freshState(newCommander()); + state.world.build(state.systems[state.commander.systemIndex]); + state.world.clearNpcs(); + state.player.position.set(0, 0, 0); + state.player.quaternion.identity(); + state.player.speed = 200; + const legal = state.commander.legalStatus; + // off to one side, so there is a real bank to make + const pirate = state.world.spawn('pirate', new THREE.Vector3(900, 120, -1400), 1); + pirate.state.speed = 0; + + /** One step of a co-pilot at the fixture's geometry. */ + const ask = (cp: ScriptedCoPilot) => { + const s = cp.step(1 / 60, state.player, state.world.npcs, legal, false, null); + if (s.kind !== 'fly') throw new Error('should be flying a live threat'); + return s.demand; + }; + + // A controller that flew for a while, then had the ship taken off it. + const used = new ScriptedCoPilot(); + for (let i = 0; i < 90; i++) ask(used); + const handedBack = used.step(1 / 60, state.player, state.world.npcs, legal, true, null); + check('touching the controls hands the ship back', handedBack.kind === 'disengage'); + + // The pilot flies it somewhere, and the ship stops turning. + state.player.pitchRate = 0; + state.player.rollRate = 0; + const resumed = ask(used); + const fresh = ask(new ScriptedCoPilot()); + eq('a resumed co-pilot asks for the same roll a fresh one does', + resumed.rollRate, fresh.rollRate); + eq('...and the same pitch', resumed.pitchRate, fresh.pitchRate); + + // ...AND A RESET ONE TOO, which `steerMem.side` used to break. + // + // The geometry has to be one where the memory actually decides. A target + // BELOW commits the bank to the bottom. A target LEVEL to one side then has + // the same roll either way round, so the flip margin holds whichever side is + // committed, and a stale one shows. + const wrongWay = new ScriptedCoPilot(); + pirate.object.position.set(0, -900, -1400); + for (let i = 0; i < 60; i++) ask(wrongWay); + pirate.object.position.set(900, 0, -1400); + state.player.pitchRate = 0; + state.player.rollRate = 0; + check('a co-pilot that kept flying banks the way it committed to', + ask(wrongWay).rollRate * ask(new ScriptedCoPilot()).rollRate < 0, + 'the fixture is only a test of reset() while these disagree'); + state.player.pitchRate = 0; + state.player.rollRate = 0; + wrongWay.reset(); + eq('...and a reset one banks the way a fresh one does', + ask(wrongWay).rollRate, ask(new ScriptedCoPilot()).rollRate); + + // THE RAMP READS THE SHIP. A ship already rolling continues from that rate, + // rather than from a zero the co-pilot kept to itself. + state.player.rollRate = -1.2; + const carried = ask(new ScriptedCoPilot()).rollRate; + state.player.rollRate = 0; + const fromRest = ask(new ScriptedCoPilot()).rollRate; + check('a ship already rolling carries that rate into the ramp', + carried < fromRest - 0.5, `${carried.toFixed(3)} against ${fromRest.toFixed(3)}`); +} + +// --- THE COMMITMENT HAS TO BE GOING SOMEWHERE ------------------------------ +// +// The review of 2026-09-12 built this geometry. A held target 3,000 units away +// and 23 degrees off the nose, and a second hostile 500 units dead ahead. The +// cone alone called the far one an attack in progress and vetoed the switch, so +// ten seconds later the easy shot was still refused. `ENGAGED_PATIENCE` is the +// answer, and `npm run combat-aim` cannot see it: over 72 real fights a sweep of +// that constant from 1 second to 999 moved nothing at all. +console.log('\nthe co-pilot lets go of a kill that is going nowhere'); +{ + seedWorld(4247); + const state = freshState(newCommander()); + state.world.build(state.systems[state.commander.systemIndex]); + state.world.clearNpcs(); + state.player.position.set(0, 0, 0); + state.player.quaternion.identity(); + state.player.speed = 0; + const legal = state.commander.legalStatus; + + // 23 degrees off the nose, far out. Inside `ENGAGED_CONE`, and no shot. + const far = state.world.spawn('pirate', + new THREE.Vector3(Math.sin(0.4) * 3000, 0, -Math.cos(0.4) * 3000), 1); + far.state.speed = 0; + const cp = new ScriptedCoPilot(); + // The geometry is held still, so only the SELECTION rule can move. The ship + // flies nothing, because the question is which ship the co-pilot holds. + for (let i = 0; i < 120; i++) { + cp.step(1 / 60, state.player, state.world.npcs, legal, false, null); + } + const near = state.world.spawn('pirate', new THREE.Vector3(0, 0, -500), 2); + near.state.speed = 0; + + // Long enough to pass `ENGAGED_PATIENCE` with no shot on the far one. + let fires = false; + for (let i = 0; i < 60 * 6; i++) { + const s = cp.step(1 / 60, state.player, state.world.npcs, legal, false, null); + if (s.kind === 'fly' && s.demand.fire) fires = true; + } + check('a target it cannot shoot stops blocking the easy one', fires); + + // THE CONTROL: a commitment that IS going somewhere still holds. The near + // ship is on the gun, so the far one must not steal it back. + const steady = new ScriptedCoPilot(); + let held = 0; + for (let i = 0; i < 60 * 6; i++) { + const s = steady.step(1 / 60, state.player, state.world.npcs, legal, false, null); + if (s.kind === 'fly' && s.demand.fire) held += 1; + } + check('...and one that is landing shots keeps the lock', held > 60 * 3, + `${(held / 60).toFixed(1)}s of trigger over 6s`); +} diff --git a/test/run.ts b/test/run.ts index 55b0b1a4..0d455dee 100644 --- a/test/run.ts +++ b/test/run.ts @@ -129,6 +129,7 @@ import './tactics.test.ts'; import './tactic-choice.test.ts'; import './scripted-co-pilot.test.ts'; import './co-pilot-tracking.test.ts'; +import './co-pilot-engagement.test.ts'; import './pitch-roll-steer.test.ts'; import './pursuit.test.ts'; import './human-shape.test.ts'; diff --git a/test/scripted-co-pilot.test.ts b/test/scripted-co-pilot.test.ts index 53392cbf..1b7b5f9d 100644 --- a/test/scripted-co-pilot.test.ts +++ b/test/scripted-co-pilot.test.ts @@ -289,84 +289,3 @@ console.log('\nthe co-pilot leads the nose and matches the radial speed'); check('...but one that crosses at 300 keeps the ship turning with it', turnFor(300) > 0); } - -// --- ONE HANDOVER CONTRACT ------------------------------------------------ -// -// The review of 2026-09-12 found three ways a resumed co-pilot flew differently -// from a fresh one at the same geometry. The contract that answers all three: -// -// 1. THE RATES ARE THE SHIP'S. The co-pilot keeps no copy of its last ask. It -// ramps from `player.pitchRate` and `player.rollRate`, which -// `PlayerShip.update` writes from the demand it flew. So a manual override -// and a restored save both leave the ramp reading the truth. -// 2. THE ENGAGEMENT MEMORY GOES ON `reset`. The lock, the bank side and the -// under-fire timer are all the engagement's, and none of them is worth -// inheriting. -// 3. NOTHING HERE NEEDS SAVING. What survives a save is the ship's own rates, -// which `persistence.ts` already carries. -console.log('\nthe co-pilot hands the ship over on one contract'); -{ - seedWorld(4246); - const state = freshState(newCommander()); - state.world.build(state.systems[state.commander.systemIndex]); - state.world.clearNpcs(); - state.player.position.set(0, 0, 0); - state.player.quaternion.identity(); - state.player.speed = 200; - const legal = state.commander.legalStatus; - // off to one side, so there is a real bank to make - const pirate = state.world.spawn('pirate', new THREE.Vector3(900, 120, -1400), 1); - pirate.state.speed = 0; - - /** One step of a co-pilot at the fixture's geometry. */ - const ask = (cp: ScriptedCoPilot) => { - const s = cp.step(1 / 60, state.player, state.world.npcs, legal, false, null); - if (s.kind !== 'fly') throw new Error('should be flying a live threat'); - return s.demand; - }; - - // A controller that flew for a while, then had the ship taken off it. - const used = new ScriptedCoPilot(); - for (let i = 0; i < 90; i++) ask(used); - const handedBack = used.step(1 / 60, state.player, state.world.npcs, legal, true, null); - check('touching the controls hands the ship back', handedBack.kind === 'disengage'); - - // The pilot flies it somewhere, and the ship stops turning. - state.player.pitchRate = 0; - state.player.rollRate = 0; - const resumed = ask(used); - const fresh = ask(new ScriptedCoPilot()); - eq('a resumed co-pilot asks for the same roll a fresh one does', - resumed.rollRate, fresh.rollRate); - eq('...and the same pitch', resumed.pitchRate, fresh.pitchRate); - - // ...AND A RESET ONE TOO, which `steerMem.side` used to break. - // - // The geometry has to be one where the memory actually decides. A target - // BELOW commits the bank to the bottom. A target LEVEL to one side then has - // the same roll either way round, so the flip margin holds whichever side is - // committed, and a stale one shows. - const wrongWay = new ScriptedCoPilot(); - pirate.object.position.set(0, -900, -1400); - for (let i = 0; i < 60; i++) ask(wrongWay); - pirate.object.position.set(900, 0, -1400); - state.player.pitchRate = 0; - state.player.rollRate = 0; - check('a co-pilot that kept flying banks the way it committed to', - ask(wrongWay).rollRate * ask(new ScriptedCoPilot()).rollRate < 0, - 'the fixture is only a test of reset() while these disagree'); - state.player.pitchRate = 0; - state.player.rollRate = 0; - wrongWay.reset(); - eq('...and a reset one banks the way a fresh one does', - ask(wrongWay).rollRate, ask(new ScriptedCoPilot()).rollRate); - - // THE RAMP READS THE SHIP. A ship already rolling continues from that rate, - // rather than from a zero the co-pilot kept to itself. - state.player.rollRate = -1.2; - const carried = ask(new ScriptedCoPilot()).rollRate; - state.player.rollRate = 0; - const fromRest = ask(new ScriptedCoPilot()).rollRate; - check('a ship already rolling carries that rate into the ramp', - carried < fromRest - 0.5, `${carried.toFixed(3)} against ${fromRest.toFixed(3)}`); -} From 1198911d6f7f3a93432d8bb9fc9ed3886ad98c9b Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Sat, 12 Sep 2026 21:12:31 +0100 Subject: [PATCH 052/100] A fight starts on two soft pings, not one hard beep Chris, 2026-09-12: *"The alarm sound for a pirate is a bit too much. I think a simple couple of pings would do."* WHICH SOUND THAT IS. Nothing in the game is named an alarm, and no sound repeats while a pirate is near. The one thing that marks a pirate turning up is `combatComputerEngaged`. `autoEngage` plays it when the computer takes the stick for a fight, and it prints no console line at all, because the lines that matter arrive at the same moment. So that beep is the whole announcement. It was a 1000 Hz SQUARE wave for 0.12 seconds at the standard gain. That is a klaxon by construction. 1000 Hz sits in the band the ear is sharpest in, and a square wave carries every odd harmonic above it. It is now two SINE pings, 880 Hz then 1175 Hz, 0.05 seconds each at a lower gain, the second landing after the first rather than over it. A sine carries no harmonics, which is the difference between a buzz and a ping. Two of them rising a fourth say attention where one said alarm. BOTH ARE SCHEDULED UP FRONT. `sweep` takes an offset now, rather than the `setTimeout` that `dock` and `ecm` use for their later voices. A timer puts the second half of a cue outside the call, where `test/audio.test.ts` cannot see it and a paused tab can lose it. The cue is the one named occasion that is not a single square tone, so it leaves that table and asserts its own claim. Six assertions, and all six fail with the old beep in place. I cannot hear it. The change is reasoned from the waveform and the band, and the test pins the shape rather than the taste. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- src/audio.ts | 45 +++++++++++++++++++++++++++++++++++---------- test/audio.test.ts | 29 ++++++++++++++++++++++++++++- 2 files changed, 63 insertions(+), 11 deletions(-) diff --git a/src/audio.ts b/src/audio.ts index 0a0a0ea8..40a8602b 100644 --- a/src/audio.ts +++ b/src/audio.ts @@ -78,14 +78,14 @@ function ac(): AudioContext | null { * The skip also means a wreck beyond earshot costs no oscillator and no buffer. */ function env( - a: AudioContext, gain: number, duration: number, place?: Place, + a: AudioContext, gain: number, duration: number, place?: Place, at = 0, ): GainNode | null { const floor = 0.001; const level = gain * (place ? distanceGain(place.distance) : 1); if (level <= floor) return null; const g = a.createGain(); - g.gain.setValueAtTime(level, a.currentTime); - g.gain.exponentialRampToValueAtTime(floor, a.currentTime + duration); + g.gain.setValueAtTime(level, a.currentTime + at); + g.gain.exponentialRampToValueAtTime(floor, a.currentTime + at + duration); // Stereo width where the browser has a panner, straight through where it does // not. The same rule is already in music.ts for the waltz, and it holds for // the sky. An absent StereoPannerNode must cost the placement, not the sound. @@ -99,21 +99,28 @@ function env( return g; } +/** + * @param at seconds from now to start, for a cue made of more than one voice. + * It is SCHEDULED rather than left to a timer, so the whole sound exists the + * moment it is asked for. A `setTimeout` would put the second half outside the + * call, where `test/audio.test.ts` cannot see it, and where a paused tab can + * lose it. + */ function sweep( type: OscillatorType, from: number, to: number, duration: number, gain: number, - place?: Place, + place?: Place, at = 0, ): void { const a = ac(); if (!a) return; - const g = env(a, gain, duration, place); + const g = env(a, gain, duration, place, at); if (!g) return; const o = a.createOscillator(); o.type = type; - o.frequency.setValueAtTime(from, a.currentTime); - o.frequency.exponentialRampToValueAtTime(Math.max(1, to), a.currentTime + duration); + o.frequency.setValueAtTime(from, a.currentTime + at); + o.frequency.exponentialRampToValueAtTime(Math.max(1, to), a.currentTime + at + duration); o.connect(g); - o.start(); - o.stop(a.currentTime + duration); + o.start(a.currentTime + at); + o.stop(a.currentTime + at + duration); } /** The common square-wave voice used by the named interface sounds below. */ @@ -197,7 +204,25 @@ export const sfx = { contractExpired(): void { tone(220, 0.2); }, contractAccepted(): void { tone(900, 0.1); }, dockingComputerEngaged(): void { tone(700, 0.12); }, - combatComputerEngaged(): void { tone(1000, 0.12); }, + /** + * A fight starts, and this is the only thing that says so. `autoEngage` + * prints no console line, because the lines that matter arrive at the same + * moment (autopilot.ts). + * + * TWO SOFT PINGS, and it was one hard beep (Chris, 2026-09-12: *"The alarm + * sound for a pirate is a bit too much. I think a simple couple of pings + * would do."*). It was a 1000 Hz SQUARE wave for 0.12 seconds at the standard + * gain. A square wave at 1000 Hz sits in the ear's most sensitive band, and it + * carries every odd harmonic above that. So it reads as a klaxon. + * + * A sine carries no harmonics at all, which is the difference between a buzz + * and a ping. Two of them rising a fourth say ATTENTION where one says ALARM, + * and each is shorter and quieter than the beep it replaces. + */ + combatComputerEngaged(): void { + sweep('sine', 880, 880, 0.05, 0.05); + sweep('sine', 1175, 1175, 0.05, 0.05, undefined, 0.09); + }, stationDefenceLaunched(): void { tone(300, 0.18); }, cargoLost(): void { tone(300, 0.12); }, equipmentDestroyed(): void { tone(240, 0.2); }, diff --git a/test/audio.test.ts b/test/audio.test.ts index 7b78883d..adc9fd35 100644 --- a/test/audio.test.ts +++ b/test/audio.test.ts @@ -29,7 +29,6 @@ const expected = { contractExpired: [220, 0.2], contractAccepted: [900, 0.1], dockingComputerEngaged: [700, 0.12], - combatComputerEngaged: [1000, 0.12], stationDefenceLaunched: [300, 0.18], cargoLost: [300, 0.12], equipmentDestroyed: [240, 0.2], @@ -58,6 +57,34 @@ for (const [name, [frequency, duration]] of Object.entries(expected)) { eq(`${name} keeps the standard gain`, peak(tone), 0.08); } +// THE FIGHT CUE IS TWO PINGS, and it was one beep. Chris, 2026-09-12: *"The +// alarm sound for a pirate is a bit too much. I think a simple couple of pings +// would do."* It was 1000 Hz square for 0.12s at the standard gain, which is a +// klaxon: that band is where the ear is sharpest, and a square wave carries +// every odd harmonic above it. +// +// It is the one named occasion that is not a single square tone, so it leaves +// the table above and asserts its own claim: two SINE voices, each shorter and +// quieter than the beep, the second after the first rather than over it. +{ + tones.length = 0; + sfx.combatComputerEngaged(); + const cue = [...tones]; + eq('the fight cue is two voices', cue.length, 2); + check('...both sine, so neither buzzes', cue.every((t) => t.type === 'sine'), + cue.map((t) => t.type).join(',')); + check('...each well under the 0.12s beep it replaced', + cue.every((t) => t.duration <= 0.06), cue.map((t) => t.duration).join(',')); + check('...and quieter than the standard gain', + cue.every((t) => peak(t) < 0.08), cue.map((t) => peak(t)).join(',')); + check('the second ping rises above the first', + cue.length === 2 && cue[1].frequency > cue[0].frequency, + cue.map((t) => t.frequency).join(' then ')); + check('...and lands after it, rather than on top of it', + cue.length === 2 && cue[1].at >= cue[0].at + cue[0].duration, + cue.map((t) => `${t.at}+${t.duration}`).join(' then ')); +} + // The countdown blip is the one occasion whose pitch depends on a GAME rule — // how many seconds of warning the drive gives — and audio.ts used to write that // 5 out as a digit. So the assertion is the CLAIM rather than the expression: From 7a5363845306054a7177a56cc5d9dfbc00d7a980 Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Sat, 12 Sep 2026 21:14:42 +0100 Subject: [PATCH 053/100] The fight cue is a couple of beeps Chris, 2026-09-12: *"Hmm, I just want a couple of beeps."* The previous commit answered *"a couple of pings"* with two sine voices rising a fourth, which is a design where none was asked for. It is the house beep now, twice, at 800 Hz for 0.06 seconds each. The same square voice and the same gain as every other named occasion, so it sits in the family rather than over it. It was one 1000 Hz beep for 0.12 seconds, which is half again as long as the standard beep. The offset that `sweep` gained last commit stays, and `tone` takes one too. Both beeps are scheduled up front rather than through a timer, so the whole cue exists the moment it is asked for, and the test can see all of it. Six assertions, and four of them fail with the old single beep in place. The two that do not are the voice and the gain, which is the point: everything about a beep is unchanged except that there are two. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- src/audio.ts | 23 +++++++++++------------ test/audio.test.ts | 33 ++++++++++++++++----------------- 2 files changed, 27 insertions(+), 29 deletions(-) diff --git a/src/audio.ts b/src/audio.ts index 40a8602b..70c7058d 100644 --- a/src/audio.ts +++ b/src/audio.ts @@ -124,8 +124,8 @@ function sweep( } /** The common square-wave voice used by the named interface sounds below. */ -function tone(frequency: number, duration = 0.08, gain = 0.08): void { - sweep('square', frequency, frequency, duration, gain); +function tone(frequency: number, duration = 0.08, gain = 0.08, at = 0): void { + sweep('square', frequency, frequency, duration, gain, undefined, at); } function noiseBurst(duration: number, gain: number, lowpass = 4000, place?: Place): void { @@ -209,19 +209,18 @@ export const sfx = { * prints no console line, because the lines that matter arrive at the same * moment (autopilot.ts). * - * TWO SOFT PINGS, and it was one hard beep (Chris, 2026-09-12: *"The alarm - * sound for a pirate is a bit too much. I think a simple couple of pings - * would do."*). It was a 1000 Hz SQUARE wave for 0.12 seconds at the standard - * gain. A square wave at 1000 Hz sits in the ear's most sensitive band, and it - * carries every odd harmonic above that. So it reads as a klaxon. + * A COUPLE OF BEEPS, and it was one long one (Chris, 2026-09-12: *"The alarm + * sound for a pirate is a bit too much"*, then *"I just want a couple of + * beeps"*). It was 1000 Hz for 0.12 seconds. That is half again as long as the + * standard beep, near the top of the range the ear is sharpest in. * - * A sine carries no harmonics at all, which is the difference between a buzz - * and a ping. Two of them rising a fourth say ATTENTION where one says ALARM, - * and each is shorter and quieter than the beep it replaces. + * These are the standard beep, twice, at 800 Hz. Same square voice and same + * gain as every other named occasion, so it sits in the family rather than + * over it. */ combatComputerEngaged(): void { - sweep('sine', 880, 880, 0.05, 0.05); - sweep('sine', 1175, 1175, 0.05, 0.05, undefined, 0.09); + tone(800, 0.06); + tone(800, 0.06, 0.08, 0.12); }, stationDefenceLaunched(): void { tone(300, 0.18); }, cargoLost(): void { tone(300, 0.12); }, diff --git a/test/audio.test.ts b/test/audio.test.ts index adc9fd35..c5481b05 100644 --- a/test/audio.test.ts +++ b/test/audio.test.ts @@ -57,30 +57,29 @@ for (const [name, [frequency, duration]] of Object.entries(expected)) { eq(`${name} keeps the standard gain`, peak(tone), 0.08); } -// THE FIGHT CUE IS TWO PINGS, and it was one beep. Chris, 2026-09-12: *"The -// alarm sound for a pirate is a bit too much. I think a simple couple of pings -// would do."* It was 1000 Hz square for 0.12s at the standard gain, which is a -// klaxon: that band is where the ear is sharpest, and a square wave carries -// every odd harmonic above it. +// THE FIGHT CUE IS A COUPLE OF BEEPS, and it was one long one. Chris, +// 2026-09-12: *"The alarm sound for a pirate is a bit too much"*, then *"I just +// want a couple of beeps"*. It was 1000 Hz for 0.12s, half again as long as the +// standard beep and near the top of the band the ear is sharpest in. // -// It is the one named occasion that is not a single square tone, so it leaves -// the table above and asserts its own claim: two SINE voices, each shorter and -// quieter than the beep, the second after the first rather than over it. +// It is the one named occasion made of more than one voice, so it leaves the +// table above and asserts its own claim. Everything else about it is the house +// beep: the same square voice, and the same gain. { tones.length = 0; sfx.combatComputerEngaged(); const cue = [...tones]; - eq('the fight cue is two voices', cue.length, 2); - check('...both sine, so neither buzzes', cue.every((t) => t.type === 'sine'), + eq('the fight cue is two beeps', cue.length, 2); + check('...both the house square voice', cue.every((t) => t.type === 'square'), cue.map((t) => t.type).join(',')); - check('...each well under the 0.12s beep it replaced', - cue.every((t) => t.duration <= 0.06), cue.map((t) => t.duration).join(',')); - check('...and quieter than the standard gain', - cue.every((t) => peak(t) < 0.08), cue.map((t) => peak(t)).join(',')); - check('the second ping rises above the first', - cue.length === 2 && cue[1].frequency > cue[0].frequency, + check('...at the standard gain, like every other named occasion', + cue.every((t) => peak(t) === 0.08), cue.map((t) => peak(t)).join(',')); + check('...the same pitch, so it reads as one cue rather than two events', + cue.length === 2 && cue[0].frequency === cue[1].frequency, cue.map((t) => t.frequency).join(' then ')); - check('...and lands after it, rather than on top of it', + check('...each shorter than the 0.12s beep it replaced', + cue.every((t) => t.duration <= 0.08), cue.map((t) => t.duration).join(',')); + check('...and the second lands after the first, not over it', cue.length === 2 && cue[1].at >= cue[0].at + cue[0].duration, cue.map((t) => `${t.at}+${t.duration}`).join(' then ')); } From 6ff43d9ea0bb1207af34556a2702ec08817f90b4 Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Sat, 12 Sep 2026 21:16:45 +0100 Subject: [PATCH 054/100] The fight cue is soft, and the voice was always the problem Chris, 2026-09-12: *"It back to the horrible beep - what's going on?"* He is running a dev server, so this is the sound itself and not a stale build. WHAT WENT WRONG. He called the cue too much, then asked for a couple of beeps. The second commit read "beeps" as the house `tone`, which is a SQUARE wave, and only shortened it and dropped the pitch. That changed nothing that mattered. A square wave carries every odd harmonic above its pitch, and this cue sits where the ear is sharpest. The harshness was never the count or the length. It was the voice. So it is two SINE beeps at 700 Hz, 0.06 seconds each, 0.12 apart. Sine carries no harmonics at all. Two of them, at the same pitch, with no interval and no design: a couple of beeps, and nothing else. It is now the one named occasion that is not the house square voice. That is a real difference rather than an exception. Every other named sound is a cockpit acknowledgement the pilot asked for. This one interrupts her, and it is the only sound that does. The test asserts the voice rather than the taste, and it fails on square. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- src/audio.ts | 23 +++++++++++++++-------- test/audio.test.ts | 8 ++++++-- 2 files changed, 21 insertions(+), 10 deletions(-) diff --git a/src/audio.ts b/src/audio.ts index 70c7058d..f4929f94 100644 --- a/src/audio.ts +++ b/src/audio.ts @@ -209,18 +209,25 @@ export const sfx = { * prints no console line, because the lines that matter arrive at the same * moment (autopilot.ts). * - * A COUPLE OF BEEPS, and it was one long one (Chris, 2026-09-12: *"The alarm + * TWO SOFT BEEPS, and it took three goes (Chris, 2026-09-12: *"The alarm * sound for a pirate is a bit too much"*, then *"I just want a couple of - * beeps"*). It was 1000 Hz for 0.12 seconds. That is half again as long as the - * standard beep, near the top of the range the ear is sharpest in. + * beeps"*, then *"It back to the horrible beep"*). * - * These are the standard beep, twice, at 800 Hz. Same square voice and same - * gain as every other named occasion, so it sits in the family rather than - * over it. + * THE VOICE IS WHAT MAKES IT HORRIBLE, and the count never was. A square wave + * carries every odd harmonic above its pitch, and near 1000 Hz that lands in + * the band the ear is sharpest in. The second attempt kept the square voice + * and only shortened it, which changed nothing that mattered. + * + * So these are SINE, which carries no harmonics at all. Two of them, at the + * same pitch, the same length apart. A couple of beeps, and nothing else. + * + * It is the one named occasion that is not the house square `tone`. Every + * other one is a cockpit acknowledgement the pilot asked for. This one is + * the game interrupting the pilot, and it is the only sound that does. */ combatComputerEngaged(): void { - tone(800, 0.06); - tone(800, 0.06, 0.08, 0.12); + sweep('sine', 700, 700, 0.06, 0.08); + sweep('sine', 700, 700, 0.06, 0.08, undefined, 0.12); }, stationDefenceLaunched(): void { tone(300, 0.18); }, cargoLost(): void { tone(300, 0.12); }, diff --git a/test/audio.test.ts b/test/audio.test.ts index c5481b05..0e5c592d 100644 --- a/test/audio.test.ts +++ b/test/audio.test.ts @@ -70,8 +70,12 @@ for (const [name, [frequency, duration]] of Object.entries(expected)) { sfx.combatComputerEngaged(); const cue = [...tones]; eq('the fight cue is two beeps', cue.length, 2); - check('...both the house square voice', cue.every((t) => t.type === 'square'), - cue.map((t) => t.type).join(',')); + // THE VOICE IS WHAT MADE IT HORRIBLE. A square wave carries every odd + // harmonic above its pitch, and this cue sat where the ear is sharpest. It is + // the one named occasion that is not the house square voice, because it is + // the one that interrupts the pilot rather than answering her. + check('...both on the soft voice, not the house square', + cue.every((t) => t.type === 'sine'), cue.map((t) => t.type).join(',')); check('...at the standard gain, like every other named occasion', cue.every((t) => peak(t) === 0.08), cue.map((t) => peak(t)).join(',')); check('...the same pitch, so it reads as one cue rather than two events', From 48b9f12cfd805fcaffd064dc1791119e9a231d16 Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Sat, 12 Sep 2026 21:21:07 +0100 Subject: [PATCH 055/100] The fight cue whoops twice Chris, 2026-09-12: *"how about a whoop whoop - like a klaxon just two of them though"*. Each whoop is a sine rising from 320 to 880 Hz over 0.22 seconds, and there are two, 0.28 apart. A GLIDE is what makes a whoop, and that is a different lever from the voice. Three earlier attempts confused the two: the harshness was the square wave, and the klaxon is the rise. A real klaxon runs until somebody silences it. This one says its piece twice and stops, because the fight it announces is already under way. `test/audio-fixtures.ts` records a glide's target from today. It dropped it before, so a test of a whoop would have passed on two flat tones. Eight assertions cover the cue, and six of them fail on the beep it replaced. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- src/audio.ts | 31 +++++++++++++++----------- test/audio-fixtures.ts | 14 +++++++++--- test/audio.test.ts | 49 ++++++++++++++++++++++++++---------------- test/music.test.ts | 4 ++-- 4 files changed, 61 insertions(+), 37 deletions(-) diff --git a/src/audio.ts b/src/audio.ts index f4929f94..3e705b16 100644 --- a/src/audio.ts +++ b/src/audio.ts @@ -209,25 +209,30 @@ export const sfx = { * prints no console line, because the lines that matter arrive at the same * moment (autopilot.ts). * - * TWO SOFT BEEPS, and it took three goes (Chris, 2026-09-12: *"The alarm - * sound for a pirate is a bit too much"*, then *"I just want a couple of - * beeps"*, then *"It back to the horrible beep"*). + * WHOOP WHOOP (Chris, 2026-09-12: *"how about a whoop whoop - like a klaxon + * just two of them though"*). It took four goes to get here, and the three + * before it are worth the record. It was one 1000 Hz square beep. He called + * it too much and asked for pings, then for beeps, and the beeps came back + * square and were still horrible. * - * THE VOICE IS WHAT MAKES IT HORRIBLE, and the count never was. A square wave - * carries every odd harmonic above its pitch, and near 1000 Hz that lands in - * the band the ear is sharpest in. The second attempt kept the square voice - * and only shortened it, which changed nothing that mattered. + * THE VOICE AND THE SHAPE ARE DIFFERENT LEVERS, and only the second one + * makes a klaxon. A square wave carries every odd harmonic above its pitch, + * which is what made every earlier version grate. A GLIDE is what makes a + * whoop, and it needs no harshness at all. The pitch rises through the sound + * rather than sitting on one note. * - * So these are SINE, which carries no harmonics at all. Two of them, at the - * same pitch, the same length apart. A couple of beeps, and nothing else. + * So each whoop is a sine rising from 320 to 880 Hz over 0.22 seconds, and + * there are two. A klaxon runs until somebody silences it. This one says its + * piece twice and stops. The fight it announces is already under way, so it + * has nothing left to warn about. * * It is the one named occasion that is not the house square `tone`. Every - * other one is a cockpit acknowledgement the pilot asked for. This one is - * the game interrupting the pilot, and it is the only sound that does. + * other one is a cockpit acknowledgement the pilot asked for. This one is the + * game interrupting the pilot, and it is the only sound that does. */ combatComputerEngaged(): void { - sweep('sine', 700, 700, 0.06, 0.08); - sweep('sine', 700, 700, 0.06, 0.08, undefined, 0.12); + sweep('sine', 320, 880, 0.22, 0.08); + sweep('sine', 320, 880, 0.22, 0.08, undefined, 0.28); }, stationDefenceLaunched(): void { tone(300, 0.18); }, cargoLost(): void { tone(300, 0.12); }, diff --git a/test/audio-fixtures.ts b/test/audio-fixtures.ts index fb2d62ab..65dac0f6 100644 --- a/test/audio-fixtures.ts +++ b/test/audio-fixtures.ts @@ -32,6 +32,14 @@ export interface Tone { frequency: number; /** every scheduled pitch, as `[hz, at]` — one entry unless the voice vibratos */ pitches: [number, number][]; + /** + * Where a GLIDE was aimed, or null for a voice that holds its pitch. + * + * Recorded from 2026-09-12, when the fight cue became a whoop. The glide IS + * that sound, and a fixture that dropped the ramp target would have passed on + * two flat tones (`test/audio.test.ts`). + */ + rampTo: number | null; /** cents away from `frequency`, as the layer asked for */ detune: number; duration: number; @@ -148,8 +156,8 @@ class FakeAudioContext { createOscillator() { const recorded: Tone = { - type: 'sine', frequency: 0, pitches: [], detune: 0, duration: 0, at: 0, - periodic: false, amp: null, + type: 'sine', frequency: 0, pitches: [], rampTo: null, detune: 0, + duration: 0, at: 0, periodic: false, amp: null, }; tones.push(recorded); const node = { @@ -159,7 +167,7 @@ class FakeAudioContext { if (!recorded.pitches.length) recorded.frequency = value; recorded.pitches.push([value, at - 10]); }, - exponentialRampToValueAtTime() {}, + exponentialRampToValueAtTime(value: number) { recorded.rampTo = value; }, }, /** * A pulse wave. The fake keeps no spectrum — what a test can ask is diff --git a/test/audio.test.ts b/test/audio.test.ts index 0e5c592d..0f7712ae 100644 --- a/test/audio.test.ts +++ b/test/audio.test.ts @@ -57,35 +57,46 @@ for (const [name, [frequency, duration]] of Object.entries(expected)) { eq(`${name} keeps the standard gain`, peak(tone), 0.08); } -// THE FIGHT CUE IS A COUPLE OF BEEPS, and it was one long one. Chris, -// 2026-09-12: *"The alarm sound for a pirate is a bit too much"*, then *"I just -// want a couple of beeps"*. It was 1000 Hz for 0.12s, half again as long as the -// standard beep and near the top of the band the ear is sharpest in. +// THE FIGHT CUE IS A WHOOP WHOOP, and it took four goes. Chris, 2026-09-12: +// *"The alarm sound for a pirate is a bit too much"*, then *"I just want a +// couple of beeps"*, then *"It back to the horrible beep"*, then *"how about a +// whoop whoop - like a klaxon just two of them though"*. // -// It is the one named occasion made of more than one voice, so it leaves the -// table above and asserts its own claim. Everything else about it is the house -// beep: the same square voice, and the same gain. +// It was one 1000 Hz SQUARE beep for 0.12s. Two levers were confused for one +// through three of those attempts. The VOICE is what grated, because a square +// wave carries every odd harmonic above its pitch. The SHAPE is what makes a +// klaxon, and that is a glide rather than a note. +// +// So the claim is both, and the glide is the half a flat cue would pass +// without. `test/audio-fixtures.ts` records the ramp target from this date for +// exactly that reason. { tones.length = 0; sfx.combatComputerEngaged(); const cue = [...tones]; - eq('the fight cue is two beeps', cue.length, 2); - // THE VOICE IS WHAT MADE IT HORRIBLE. A square wave carries every odd - // harmonic above its pitch, and this cue sat where the ear is sharpest. It is - // the one named occasion that is not the house square voice, because it is - // the one that interrupts the pilot rather than answering her. - check('...both on the soft voice, not the house square', + eq('the fight cue is two whoops', cue.length, 2); + check('...each one a GLIDE, which is what makes a whoop', + cue.every((t) => t.rampTo !== null && t.rampTo !== t.frequency), + cue.map((t) => `${t.frequency}->${t.rampTo}`).join(',')); + check('...rising, so it reads as an alert rather than a sigh', + cue.every((t) => (t.rampTo ?? 0) > t.frequency), + cue.map((t) => `${t.frequency}->${t.rampTo}`).join(',')); + check('...on the soft voice, not the house square that grated', cue.every((t) => t.type === 'sine'), cue.map((t) => t.type).join(',')); check('...at the standard gain, like every other named occasion', cue.every((t) => peak(t) === 0.08), cue.map((t) => peak(t)).join(',')); - check('...the same pitch, so it reads as one cue rather than two events', - cue.length === 2 && cue[0].frequency === cue[1].frequency, - cue.map((t) => t.frequency).join(' then ')); - check('...each shorter than the 0.12s beep it replaced', - cue.every((t) => t.duration <= 0.08), cue.map((t) => t.duration).join(',')); - check('...and the second lands after the first, not over it', + check('...the same glide twice, so it is one cue and not two events', + cue.length === 2 && cue[0].frequency === cue[1].frequency + && cue[0].rampTo === cue[1].rampTo, + cue.map((t) => `${t.frequency}->${t.rampTo}`).join(' then ')); + check('...the second after the first, not over it', cue.length === 2 && cue[1].at >= cue[0].at + cue[0].duration, cue.map((t) => `${t.at}+${t.duration}`).join(' then ')); + // A klaxon runs until somebody silences it. This one says its piece and + // stops, because the fight it announces has already started. + check('...and the whole cue is over inside a second', + cue.length === 2 && cue[1].at + cue[1].duration < 1, + `${(cue[1].at + cue[1].duration).toFixed(2)}s`); } // The countdown blip is the one occasion whose pitch depends on a GAME rule — diff --git a/test/music.test.ts b/test/music.test.ts index e6f3ef5b..a84e8f31 100644 --- a/test/music.test.ts +++ b/test/music.test.ts @@ -124,8 +124,8 @@ console.log('\nthe docking waltz'); // across the whole note. It must fail the check above, or the check is // measuring nothing. const asItWas: Tone = { - type: 'square', frequency: 440, pitches: [], detune: 0, duration: 0.313, - at: 0.05, periodic: false, + type: 'square', frequency: 440, pitches: [], rampTo: null, detune: 0, + duration: 0.313, at: 0.05, periodic: false, amp: { events: [[0.0001, 0.05], [0.05, 0.07], [0.0001, 0.363]] }, }; check('...and the envelope it replaced holds nothing', heldFor(asItWas) <= 0); From 964ea0ccbc0557910315a931d2fc0eb866ccde6e Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Sat, 12 Sep 2026 21:32:06 +0100 Subject: [PATCH 056/100] The computer engages once, and it was engaging sixty times a second Chris, 2026-09-12: *"why does it go on for so long? Several long seconds?"* He was describing the sound a fight makes, and four commits had already tried to fix that sound. It was never the sound. TWO RANGES FOR ONE QUESTION. `autoEngage` asked the condition light whether there was a fight, and that looks `PLAYER_INTEREST_RANGE` out, which is 9,000 units. The co-pilot only looks `THREAT_RANGE`, which is 6,500. A pirate between the two engaged the computer, and the co-pilot refused it in the SAME frame. Measured, with a pirate held at 7,500 units for 5 seconds: before 300 engagements, 300 fight cues, AREA CLEAR on all 300 frames after 0 engagements, 0 cues, and nothing on the console So the cue played 60 times a second, each copy overlapping the last. That reads as one continuous noise for as long as a pirate sits in the band, and no waveform would have survived it. The console held AREA CLEAR the whole time as well. `engaging` in hostility.ts takes the range now, and the two callers pass what they actually mean. The condition light and the bribe key keep the ship's own engage range. `Autopilot.fightOn` and the co-pilot's own filter both pass `THREAT_RANGE`, and they share the one predicate rather than spelling it twice. THE FIRST VERSION OF THE TEST PASSED ON THE BUG, and that is worth the record. It sampled `session.ccEngaged` at the end of each frame. The flag never survives a frame here: it goes true in `autoEngage` and false again in the co-pilot, both inside `pilotDemand`. So the test measures the console instead, which is what a player sees. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- src/game/autopilot.ts | 17 ++++++++++-- src/game/hostility.ts | 20 ++++++++------ src/game/scripted-co-pilot.ts | 10 +++++-- test/aim.test.ts | 52 +++++++++++++++++++++++++++++++++++ 4 files changed, 86 insertions(+), 13 deletions(-) diff --git a/src/game/autopilot.ts b/src/game/autopilot.ts index d9138937..e983ec37 100644 --- a/src/game/autopilot.ts +++ b/src/game/autopilot.ts @@ -43,6 +43,7 @@ import { ScriptedCoPilot } from './scripted-co-pilot.ts'; import type { SoundEvent } from './sounds.ts'; import type { GameState } from './state.ts'; import { DOCK_COMPUTER_RANGE } from '../constants/docking-computer.ts'; +import { THREAT_RANGE } from '../constants/combat-computer.ts'; /** What an autopilot reports for the orchestrator to say and play. */ export type AutopilotEvent = @@ -154,12 +155,24 @@ export class Autopilot { /** * Is there a fight for the computer to line the ship up in? A hostile ship - * near, by the condition light's own rule, or a target the pilot picked. + * inside the CO-PILOT's reach, or a target the pilot picked. + * + * IT USED TO ASK THE CONDITION LIGHT, which looks 9,000 units out. The + * co-pilot only looks `THREAT_RANGE`, which is 6,500. A pirate in that band + * engaged the computer, and the co-pilot refused it in the same frame. That + * happened on EVERY frame. Measured at a pirate 7,500 units off, it was 300 + * engagements in 5 seconds. Each one carried its own sound and its own AREA + * CLEAR on the console (Chris, 2026-09-12: *"why does it go on for so long? + * Several long seconds?"*). + * + * A picked target has no range test, because the co-pilot has none for one + * either. The pilot's pick comes first, at any distance. */ private fightOn(): boolean { const s = this.state; return pickedTarget(s.world.npcs) !== null || hostilesNear( - s.world.npcs, s.player.position, s.commander.legalStatus, this.playerToStation); + s.world.npcs, s.player.position, s.commander.legalStatus, this.playerToStation, + THREAT_RANGE); } /** diff --git a/src/game/hostility.ts b/src/game/hostility.ts index f344ee88..ae4b87eb 100644 --- a/src/game/hostility.ts +++ b/src/game/hostility.ts @@ -99,16 +99,20 @@ export function isHostileToPlayer( /** * Is this ship both cross with you and close enough to act on it? * - * The same range the ship itself engages at, from - * `constants/player-interest.ts`. One home for it, because everything that - * answers "who is in this fight" has to agree. Those are the condition light - * below, and the bribe key, which may only buy off a ship that is on you. + * One home for it, because everything that answers "who is in this fight" has + * to agree. The condition light and the bribe key take the default range, which + * is the one the ship itself engages at (`constants/player-interest.ts`). + * + * THE RANGE IS THE CALLER'S, from 2026-09-12, and it had to become one. The + * combat computer looks a shorter way out than the light does, and the two + * disagreeing cost 60 engagements a second. See `Autopilot.fightOn`. */ -function engaging( +export function engaging( npc: HostileShip, playerPos: THREE.Vector3, legalStatus: number, playerToStation: number, + range: number = PLAYER_INTEREST_RANGE, ): boolean { return isHostileToPlayer(npc, legalStatus, playerToStation) - && npc.object.position.distanceTo(playerPos) < PLAYER_INTEREST_RANGE; + && npc.object.position.distanceTo(playerPos) < range; } /** @@ -119,9 +123,9 @@ function engaging( */ export function hostilesNear( npcs: readonly HostileShip[], playerPos: THREE.Vector3, legalStatus: number, - playerToStation: number, + playerToStation: number, range?: number, ): boolean { - return npcs.some((npc) => engaging(npc, playerPos, legalStatus, playerToStation)); + return npcs.some((npc) => engaging(npc, playerPos, legalStatus, playerToStation, range)); } /** diff --git a/src/game/scripted-co-pilot.ts b/src/game/scripted-co-pilot.ts index 55d18565..e482e9e0 100644 --- a/src/game/scripted-co-pilot.ts +++ b/src/game/scripted-co-pilot.ts @@ -37,7 +37,7 @@ import * as THREE from 'three'; import { ThreatLock } from './threat-lock.ts'; import type { NpcShip } from './npc.ts'; -import { isHostileToPlayer } from './hostility.ts'; +import { engaging } from './hostility.ts'; import type { AutopilotShip } from './combat-computer.ts'; import { hitCone } from './gunnery.ts'; import { autopilotEcm } from './ordnance.ts'; @@ -150,8 +150,12 @@ export class ScriptedCoPilot { // by its own rule, which two other places share. const threat = picked ?? this.lock.pick( dt, - npcs.filter((npc) => isHostileToPlayer(npc, legalStatus, playerToStation) - && npc.object.position.distanceTo(player.position) < THREAT_RANGE), + // THE SAME PREDICATE `Autopilot.fightOn` ASKS, at the same range. They + // were two spellings of one rule, and they disagreed about the range. The + // engage test looked 9,000 units out, and this one 6,500. So a pirate in + // that band engaged and was refused every frame. + npcs.filter((npc) => engaging(npc, player.position, legalStatus, + playerToStation, THREAT_RANGE)), // EASIEST to lock, not nearest. It ranks by the off-nose angle, which is // the turn it costs to get guns on. Distance is the secondary tiebreak. // diff --git a/test/aim.test.ts b/test/aim.test.ts index 00973d14..70d2cb30 100644 --- a/test/aim.test.ts +++ b/test/aim.test.ts @@ -224,3 +224,55 @@ console.log('\nthe computer holds its shot unless the shot is its own'); check('a trader the PILOT picked is shot at', picked.state.provokedByPlayer, `provoked ${picked.state.provokedByPlayer}`); } + +// --- IT ENGAGES ONCE, NOT EVERY FRAME -------------------------------------- +// +// Chris, 2026-09-12: *"why does it go on for so long? Several long seconds?"* +// He was describing the sound a fight makes. It was not the sound. +// +// `autoEngage` asked the CONDITION LIGHT whether there was a fight, and that +// looks `PLAYER_INTEREST_RANGE` out. The co-pilot only looks `THREAT_RANGE`. A +// pirate between the two engaged the computer, and the co-pilot refused it in +// the SAME frame. So the flag reads false at the end of every frame while the +// cue plays 60 times a second and the console holds AREA CLEAR throughout. +// +// That is why this measures the console rather than `ccEngaged`. The flag never +// survives a frame, so a fixture that sampled it saw nothing at all. The first +// version of this test did, and passed on the bug. +console.log('\nthe computer engages once, not once a frame'); +{ + const engagements = (distance: number): { engaged: number; clear: number } => { + const g = open(20_260_932); + const at = g.state.player.position.clone() + .add(new THREE.Vector3(0, 0, -distance).applyQuaternion(g.state.player.quaternion)); + const pirate = g.state.world.spawn('pirate', at, 21); + pirate.state.provoked = true; + pirate.state.provokedByPlayer = true; + pirate.state.speed = 0; + let engaged = 0; + let clear = 0; + withoutSaving(() => { + for (let f = 0; f < 300; f++) { + g.step(1 / 60, 20 + f / 60); + pirate.object.position.copy(at); // hold it still, so only the RULES move + if (g.state.session.ccEngaged) engaged += 1; + if (g.state.session.messageText === 'AREA CLEAR') clear += 1; + } + }); + return { engaged, clear }; + }; + + const close = engagements(4000); + check('a pirate inside the co-pilot\'s reach engages the computer', close.engaged === 300, + `${close.engaged} of 300 frames`); + check('...and it never gives the ship back', close.clear === 0, + `${close.clear} frames of AREA CLEAR`); + + // The band that broke it: past what the co-pilot will fly at, inside what the + // condition light calls a fight. + const band = engagements(7500); + check('a pirate the co-pilot will not fly at engages nothing', band.engaged === 0, + `${band.engaged} of 300 frames`); + check('...and the console is not told AREA CLEAR on every frame of the flight', + band.clear === 0, `${band.clear} frames of AREA CLEAR`); +} From 787b35d498d24f6a66aa42e98a3b51b43216f944 Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Sat, 12 Sep 2026 21:40:00 +0100 Subject: [PATCH 057/100] A course goes round what it would hit Chris, 2026-09-12: *"I visited a rock hermit and then when I left clicked fly to the station - the computer crashed me straight into the rock hermit - we need to have some avoidance of obstacles"*. The line already went round the PLANET, and round a POLICEMAN on a smuggling run. It went through everything else. Reproduced with a hermit 600 units ahead on the line to a station 60,000 out: the ship passed 26 units from the hull at 399 units a second, and the commander died. It now goes round anything solid too, at `COURSE_OBSTACLE_CLEARANCE` from the HULL. The same flight clears the hermit by 257 units and lives. THE CLEARANCE IS THE SHIP'S OWN TURNING CIRCLE, not a number chosen by eye. At top speed the tightest circle the commander can fly has a radius of speed over turn rate. A quarter circle moves a ship one radius sideways, so a line that passes that far from a hull leaves exactly the room a quarter turn needs. It moves with the flight envelope rather than against it. THREE ROLES, AND NO SHIP. A rock hermit, an asteroid and the derelict sit still and are big enough to kill you. Every other ship moves, and a course that bent round those would bend round a fight. A thing at the END of a line is never in the way of it, which is `distanceToSegment`'s existing rule. That is what still lets the hermit course fly to a hermit. The additions took two files over the 400-line ceiling, and both had the same seam. `course-clearance.ts` is where a line goes; `course-pilot.ts` is what a course does for one frame. The tests follow the same split. Eight assertions cover it, and the flight it came from is the last two: without the detour it still reports `dead`. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- src/constants/CATALOG.md | 3 +- src/constants/course.ts | 26 ++++++ src/game/course-clearance.ts | 149 ++++++++++++++++++++++++++++++++++ src/game/course-pilot.ts | 123 ++++++++-------------------- src/game/flight-course.ts | 15 ++++ test/constants.test.ts | 6 +- test/course-clearance.test.ts | 98 ++++++++++++++++++++++ test/course-pilot.test.ts | 4 +- test/mission-courses.test.ts | 2 +- test/run.ts | 1 + 10 files changed, 333 insertions(+), 94 deletions(-) create mode 100644 src/game/course-clearance.ts create mode 100644 test/course-clearance.test.ts diff --git a/src/constants/CATALOG.md b/src/constants/CATALOG.md index 35b8f010..a1b61251 100644 --- a/src/constants/CATALOG.md +++ b/src/constants/CATALOG.md @@ -2,7 +2,7 @@ -455 exported constants. Regenerate with `npm run generate:constants`; +456 exported constants. Regenerate with `npm run generate:constants`; search names, meanings and values with `npm run constants:find -- ""`. | Domain | Symbol | Literal / expression | Purpose | Rule ID | Source | @@ -136,6 +136,7 @@ search names, meanings and values with `npm run constants:find -- ""`. | course | COURSE_WATCH_STANDOFF | 1200 | How far from a ship the scan course holds, in world units (docs/TODO/208 M2). | course.watchStandoff | [course.ts:263](./course.ts#L263) | | course | COURSE_ESCORT_STANDOFF | 600 | How far from its charge the escort course flies, in world units (docs/TODO/208 M2). | course.escortStandoff | [course.ts:276](./course.ts#L276) | | course | COURSE_POLICE_CLEARANCE | SCAN_WARN_RANGE | How wide of a police ship the smuggling course flies, in world units (docs/TODO/208 M4). | | [course.ts:289](./course.ts#L289) | +| course | COURSE_OBSTACLE_CLEARANCE | PLAYER_FLIGHT.maxSpeed / PLAYER_FLIGHT.maxPitch | How far clear of a solid thing's HULL a course flies, in world units. | | [course.ts:315](./course.ts#L315) | | docking | GATE_HALF_WIDTHS | 5 | How far out the approach gate sits, in multiples of the station half-width. | docking.gateHalfWidths | [docking.ts:25](./docking.ts#L25) | | docking | TURN_IN | Math.PI / 4 | How far round from the slot axis an approach turns in, in radians. | | [docking.ts:49](./docking.ts#L49) | | docking | RUN_IN_WIDTHS | GATE_HALF_WIDTHS * 0.6 | Where the approach stops the curve and flies straight, in station half-widths. | | [docking.ts:87](./docking.ts#L87) | diff --git a/src/constants/course.ts b/src/constants/course.ts index 6c341bf2..1f12f56a 100644 --- a/src/constants/course.ts +++ b/src/constants/course.ts @@ -287,3 +287,29 @@ export const COURSE_ESCORT_STANDOFF = 600; * @domain course */ export const COURSE_POLICE_CLEARANCE = SCAN_WARN_RANGE; + +/** + * How far clear of a solid thing's HULL a course flies, in world units. + * + * Chris, 2026-09-12: *"I visited a rock hermit and then when I left clicked fly + * to the station - the computer crashed me straight into the rock hermit - we + * need to have some avoidance of obstacles"*. The line went round the planet + * and round a policeman, and through everything else. Measured, it killed the + * commander outright at 399 units a second. + * + * IT IS THE SHIP'S OWN TURNING CIRCLE, not a number chosen by eye. At top + * speed the tightest circle the commander can fly has a radius of speed over + * turn rate. A quarter circle moves a ship one radius sideways. So a line that + * passes that far from a hull leaves exactly the room a quarter turn needs. + * `sidestep` then aims half as far again, which is the margin. + * + * It moves with the envelope rather than against it. A faster or less agile + * hull needs a wider berth, and this says so without being retuned. + * + * FROM THE HULL, as the docking standoff is (docs/TODO/211). A hermit is 120 + * units across the radius, and the derelict is 340. A clearance from the CENTRE + * would be a different rule for each of them. + * + * @domain course + */ +export const COURSE_OBSTACLE_CLEARANCE = PLAYER_FLIGHT.maxSpeed / PLAYER_FLIGHT.maxPitch; diff --git a/src/game/course-clearance.ts b/src/game/course-clearance.ts new file mode 100644 index 00000000..89e047cb --- /dev/null +++ b/src/game/course-clearance.ts @@ -0,0 +1,149 @@ +// WHERE TO AIM, so that the line a course flies is clear of what is on it. +// +// Split from `course-pilot.ts` on 2026-09-12, when that file passed the +// 400-line ceiling. It is a different subject from the one next door. That file +// flies a course: which leg, what speed, which switches to ask for. This one is +// pure geometry over a line and a thing beside it. It knows nothing about a +// course, a demand or a ship. +// +// THREE THINGS ARE IN THE WAY, and each has its own clearance: +// +// - the PLANET, at `COURSE_PLANET_CLEARANCE` above its surface; +// - a SOLID in the sky — a rock hermit, an asteroid, the derelict — at +// `COURSE_OBSTACLE_CLEARANCE` from its hull; +// - a POLICEMAN, on a smuggling run alone. That one is about being SEEN +// rather than about hitting anything, which is why its clearance comes +// from the scan's own warning band. +// +// All three end in `sidestep`, which is the one rule. Aim beside the thing, on +// the side the line already passes, and half as far again. + +import * as THREE from 'three'; +import { + COURSE_OBSTACLE_CLEARANCE, COURSE_PLANET_CLEARANCE, COURSE_POLICE_CLEARANCE, +} from '../constants/course.ts'; + +/** Something solid a course must not fly through — see `clearOfObstacles`. */ +export interface Obstacle { + at: THREE.Vector3; + /** the hull's own radius, because the clearance is measured from the hull */ + radius: number; +} + +const seg = new THREE.Vector3(); +const off = new THREE.Vector3(); + +/** + * Where to aim, so that the line to the target clears the planet + * (docs/TODO/205 M3). The clearance is the planet's own radius plus + * `COURSE_PLANET_CLEARANCE`, which is above the height the planet holds the + * torus drive down at. + * + * @returns `out`, holding the point to aim at. + */ +export function clearOfPlanet( + from: THREE.Vector3, to: THREE.Vector3, planet: THREE.Vector3, radius: number, + out: THREE.Vector3, +): THREE.Vector3 { + return sidestep(from, to, planet, radius + COURSE_PLANET_CLEARANCE, out); +} + +/** + * Where to aim, so that the line to the target keeps clear of the police + * (docs/TODO/208 M4). + * + * A police ship reads a hold inside `SCAN_RANGE`, which is 2,600 units, and + * the smuggling course must not be read. It aims wide of the nearest + * policeman in the way, at `COURSE_POLICE_CLEARANCE`, which is the warning + * band. The line from there is clear, and the ship then turns onto the + * target. Where no wide line exists, it takes the widest it can find. + */ +export function clearOfPolice( + from: THREE.Vector3, to: THREE.Vector3, police: readonly THREE.Vector3[], + out: THREE.Vector3, +): THREE.Vector3 { + let worst: { at: THREE.Vector3; miss: number } | null = null; + for (const at of police) { + const miss = distanceToSegment(from, to, at); + if (miss >= COURSE_POLICE_CLEARANCE) continue; + if (worst === null || miss < worst.miss) worst = { at, miss }; + } + return worst === null ? out.copy(to) + : sidestep(from, to, worst.at, COURSE_POLICE_CLEARANCE, out); +} + +/** + * Where to aim, so that the line keeps clear of everything solid in the way. + * + * Chris flew into a rock hermit on the station course (2026-09-12). The line + * went round the planet and round a policeman, and through everything else. + * + * It takes the WORST one, by how near the line passes its hull, and aims wide + * of that. One detour a frame is enough, because the ship re-plans on the next + * one. The line from a detour point is a new line, with its own worst thing in + * the way. Where nothing is in the way it returns the target unchanged. + * + * A thing at the END of the line is never in the way of it. That is + * `distanceToSegment`'s rule, and it is what lets the hermit course fly to a + * hermit. + * + * @returns `out`, holding the point to aim at. + */ +export function clearOfObstacles( + from: THREE.Vector3, to: THREE.Vector3, obstacles: readonly Obstacle[], + out: THREE.Vector3, +): THREE.Vector3 { + let worst: { o: Obstacle; over: number } | null = null; + for (const o of obstacles) { + const clear = o.radius + COURSE_OBSTACLE_CLEARANCE; + // How far INSIDE its clearance the line passes, so the worst is the one + // with least room rather than the one nearest the ship. + const over = clear - distanceToSegment(from, to, o.at); + if (over <= 0) continue; + if (worst === null || over > worst.over) worst = { o, over }; + } + return worst === null ? out.copy(to) + : sidestep(from, to, worst.o.at, worst.o.radius + COURSE_OBSTACLE_CLEARANCE, out); +} + +/** How near the line from `from` to `to` passes `at`. */ +function distanceToSegment( + from: THREE.Vector3, to: THREE.Vector3, at: THREE.Vector3, +): number { + seg.subVectors(to, from); + const len2 = seg.lengthSq(); + const t = len2 > 0 ? Math.max(0, Math.min(1, off.subVectors(at, from).dot(seg) / len2)) : 0; + // The nearest point is the target itself: nothing is between. + if (t >= 1) return Infinity; + return off.copy(from).addScaledVector(seg, t).sub(at).length(); +} + +/** + * Where to aim, so that the line keeps `clear` units from one thing in the + * way. It aims beside that thing, on the same side as the line, and half as + * far again. The line from there is clear, and the ship then turns onto the + * target. + * + * A target that is itself the nearest point needs no detour. docs/TODO/205 M3 + * found a hermit low over the planet. The line to it always counted as + * blocked, and the ship circled the detour point for ever. + * + * @returns `out`, holding the point to aim at. + */ +function sidestep( + from: THREE.Vector3, to: THREE.Vector3, at: THREE.Vector3, clear: number, + out: THREE.Vector3, +): THREE.Vector3 { + seg.subVectors(to, from); + const len2 = seg.lengthSq(); + const t = len2 > 0 ? Math.max(0, Math.min(1, off.subVectors(at, from).dot(seg) / len2)) : 0; + if (t >= 1) return out.copy(to); + off.copy(from).addScaledVector(seg, t).sub(at); + if (off.length() >= clear) return out.copy(to); + // A line through the centre has no side. Any direction square to it will do. + if (off.lengthSq() < 1e-6) { + off.set(seg.y, -seg.x, 0); + if (off.lengthSq() < 1e-6) off.set(0, seg.z, -seg.y); + } + return out.copy(at).addScaledVector(off.normalize(), clear * 1.5); +} diff --git a/src/game/course-pilot.ts b/src/game/course-pilot.ts index ccab044b..eb8abe47 100644 --- a/src/game/course-pilot.ts +++ b/src/game/course-pilot.ts @@ -27,8 +27,19 @@ // holds until the tank is full; // - the jump course flies straight while the countdown runs. // -// EVERY LINE GOES ROUND THE PLANET. A line that dips below the clearance -// altitude aims at a point beside the planet instead, until the line clears. +// EVERY LINE GOES ROUND WHAT IT WOULD HIT. Three things are in the way, and +// each has its own clearance: +// +// - the PLANET, at `COURSE_PLANET_CLEARANCE` above its surface; +// - a SOLID in the sky — a rock hermit, an asteroid, the derelict — at +// `COURSE_OBSTACLE_CLEARANCE` from its hull; +// - a POLICEMAN, but only on a smuggling run, which is a different rule +// about being seen rather than about hitting anything. +// +// A line that dips below the clearance altitude aims at a point beside the +// planet instead, until the line clears. A solid is the same trick at a smaller +// scale. It came from a flight, where the station course took the commander +// straight into the hermit she just left. // The arrival at the witchpoint already sits on the station's side of the // planet. A launch, the star and a rock far out have no such promise. @@ -40,10 +51,13 @@ import { PLAYER_FLIGHT } from '../constants/player-flight.ts'; import { SLOT_SPEED_LIMIT } from '../constants/docking.ts'; import { COURSE_AIM_DEADZONE, COURSE_ROLL_GATE, COURSE_ARRIVE_BRAKE, COURSE_ARRIVE_TOLERANCE, COURSE_DERELICT_STANDOFF, - COURSE_HERMIT_SPEED, COURSE_HERMIT_STANDOFF, COURSE_PLANET_CLEARANCE, + COURSE_HERMIT_SPEED, COURSE_HERMIT_STANDOFF, COURSE_COLLECT_SPEED, COURSE_ESCORT_STANDOFF, COURSE_RUN_REACH, COURSE_SKIM_DISTANCE, - COURSE_POLICE_CLEARANCE, COURSE_TORUS_CONE, COURSE_TORUS_DROP, COURSE_WATCH_STANDOFF, + COURSE_TORUS_CONE, COURSE_TORUS_DROP, COURSE_WATCH_STANDOFF, } from '../constants/course.ts'; +import { + clearOfObstacles, clearOfPlanet, clearOfPolice, type Obstacle, +} from './course-clearance.ts'; import type { MissionHow } from './mission-course.ts'; /** What the course pilot reads for one frame. A flat view, so a test needs no world. */ @@ -68,6 +82,15 @@ export interface CourseView { readonly tankFull: boolean; /** where the hostile ships on the scanner are, for the run course */ readonly threats: readonly THREE.Vector3[]; + /** + * The solid things within scanner range that a line must not pass through: + * a rock hermit, an asteroid and the derelict. Every course reads it. + * + * NOT every ship. A pirate is small and it moves, and a line bent round one + * would be a line bent round a fight. These are the things that sit still and + * are big enough to kill you (Chris, 2026-09-12). + */ + readonly obstacles: readonly Obstacle[]; /** where the police ships within scanner range are, for the smuggling course */ readonly police: readonly THREE.Vector3[]; /** where the cargo adrift within scanner range is, nearest first */ @@ -121,6 +144,8 @@ export class CoursePilot { private readonly aim = new THREE.Vector3(); private readonly away = new THREE.Vector3(); private readonly wideOf = new THREE.Vector3(); + /** the aim once it is clear of the planet AND of anything solid */ + private readonly clearAim = new THREE.Vector3(); /** Forget the bank, for a new course. */ reset(): void { this.mem = freshSteerMemory(); } @@ -229,7 +254,11 @@ export class CoursePilot { a.speed + Math.sqrt(2 * COURSE_ARRIVE_BRAKE * PLAYER_FLIGHT.accel * Math.max(0, left))); const band = PLAYER_FLIGHT.accel * dt; const throttle = v.speed < wanted - band ? 1 : v.speed > wanted + band ? -1 : 0; - const aim = clearOfPlanet(v.position, a.target, v.planetPos, v.planetRadius, this.aim); + // ROUND THE PLANET FIRST, then round anything solid on what is left. The + // planet is the bigger detour, so a line bent round it is the line a rock + // can then be in the way of. + const wide = clearOfPlanet(v.position, a.target, v.planetPos, v.planetRadius, this.aim); + const aim = clearOfObstacles(v.position, wide, v.obstacles, this.clearAim); const p = this.pointAt(v, aim, throttle, dt); return { ...p, torus: p.torus && left > COURSE_TORUS_DROP, handOver: false, done: false }; } @@ -279,87 +308,3 @@ function straight(v: CourseView, dt: number): FlightDemand { function hold(v: CourseView, dt: number): FlightDemand { return { ...straight(v, dt), throttle: v.speed > PLAYER_FLIGHT.accel * dt ? -1 : 0 }; } - -const seg = new THREE.Vector3(); -const off = new THREE.Vector3(); - -/** - * Where to aim, so that the line to the target clears the planet - * (docs/TODO/205 M3). The clearance is the planet's own radius plus - * `COURSE_PLANET_CLEARANCE`, which is above the height the planet holds the - * torus drive down at. - * - * @returns `out`, holding the point to aim at. - */ -export function clearOfPlanet( - from: THREE.Vector3, to: THREE.Vector3, planet: THREE.Vector3, radius: number, - out: THREE.Vector3, -): THREE.Vector3 { - return sidestep(from, to, planet, radius + COURSE_PLANET_CLEARANCE, out); -} - -/** - * Where to aim, so that the line to the target keeps clear of the police - * (docs/TODO/208 M4). - * - * A police ship reads a hold inside `SCAN_RANGE`, which is 2,600 units, and - * the smuggling course must not be read. It aims wide of the nearest - * policeman in the way, at `COURSE_POLICE_CLEARANCE`, which is the warning - * band. The line from there is clear, and the ship then turns onto the - * target. Where no wide line exists, it takes the widest it can find. - */ -export function clearOfPolice( - from: THREE.Vector3, to: THREE.Vector3, police: readonly THREE.Vector3[], - out: THREE.Vector3, -): THREE.Vector3 { - let worst: { at: THREE.Vector3; miss: number } | null = null; - for (const at of police) { - const miss = distanceToSegment(from, to, at); - if (miss >= COURSE_POLICE_CLEARANCE) continue; - if (worst === null || miss < worst.miss) worst = { at, miss }; - } - return worst === null ? out.copy(to) - : sidestep(from, to, worst.at, COURSE_POLICE_CLEARANCE, out); -} - -/** How near the line from `from` to `to` passes `at`. */ -function distanceToSegment( - from: THREE.Vector3, to: THREE.Vector3, at: THREE.Vector3, -): number { - seg.subVectors(to, from); - const len2 = seg.lengthSq(); - const t = len2 > 0 ? Math.max(0, Math.min(1, off.subVectors(at, from).dot(seg) / len2)) : 0; - // The nearest point is the target itself: nothing is between. - if (t >= 1) return Infinity; - return off.copy(from).addScaledVector(seg, t).sub(at).length(); -} - -/** - * Where to aim, so that the line keeps `clear` units from one thing in the - * way. It aims beside that thing, on the same side as the line, and half as - * far again. The line from there is clear, and the ship then turns onto the - * target. - * - * A target that is itself the nearest point needs no detour. docs/TODO/205 M3 - * found a hermit low over the planet. The line to it always counted as - * blocked, and the ship circled the detour point for ever. - * - * @returns `out`, holding the point to aim at. - */ -function sidestep( - from: THREE.Vector3, to: THREE.Vector3, at: THREE.Vector3, clear: number, - out: THREE.Vector3, -): THREE.Vector3 { - seg.subVectors(to, from); - const len2 = seg.lengthSq(); - const t = len2 > 0 ? Math.max(0, Math.min(1, off.subVectors(at, from).dot(seg) / len2)) : 0; - if (t >= 1) return out.copy(to); - off.copy(from).addScaledVector(seg, t).sub(at); - if (off.length() >= clear) return out.copy(to); - // A line through the centre has no side. Any direction square to it will do. - if (off.lengthSq() < 1e-6) { - off.set(seg.y, -seg.x, 0); - if (off.lengthSq() < 1e-6) off.set(0, seg.z, -seg.y); - } - return out.copy(at).addScaledVector(off.normalize(), clear * 1.5); -} diff --git a/src/game/flight-course.ts b/src/game/flight-course.ts index 65ed6eeb..5b216ade 100644 --- a/src/game/flight-course.ts +++ b/src/game/flight-course.ts @@ -22,6 +22,12 @@ // holding a second copy of the rule. import { CoursePilot } from './course-pilot.ts'; + +/** + * The roles a course steers round. See `CourseView.obstacles` for why these + * three and no ship. + */ +const OBSTACLE_ROLES = new Set(['hermit', 'asteroid', 'generation']); import type { CourseKind } from './courses.ts'; import { MAX_FUEL } from '../constants/commander.ts'; import { hostilesNear, hostilesOnScanner } from './hostility.ts'; @@ -132,6 +138,15 @@ export class FlightCourse { .sort((a, b) => a.distanceTo(p.position) - b.distanceTo(p.position)), threats: hostilesOnScanner(w.npcs, p.position, this.state.commander.legalStatus, p.position.distanceTo(w.station.position)).map((n) => n.object.position), + // THE SOLID THINGS, so a line does not go through one. Three roles sit + // still and are big enough to kill the commander. A rock hermit is 120 + // units across the radius, the derelict is 340, and a rock is 54. Every + // other ship moves, and a course that bent round those would bend round + // a fight. + obstacles: w.npcs + .filter((n) => n.state.alive && OBSTACLE_ROLES.has(n.role) + && n.object.position.distanceTo(p.position) <= SCANNER_RANGE) + .map((n) => ({ at: n.object.position, radius: n.radius })), dcEngaged: s.dcEngaged, mission: mission === null ? null : { at: mission.at, speed: mission.speed, how: mission.how }, diff --git a/test/constants.test.ts b/test/constants.test.ts index 813e4b0f..879acbed 100644 --- a/test/constants.test.ts +++ b/test/constants.test.ts @@ -407,9 +407,11 @@ const OUTSIDE: readonly Group[] = [ + ' finishes its work (docs/TODO/205 M3), beside the switch that says it.' + ' What a course button says while it flies, and what a jump row says' + ' when the ship cannot jump, beside the rule that raises them (M5).' - + ' KINDS is the list of courses, read off the codes that name them', + + ' KINDS is the list of courses, read off the codes that name them.' + + ' OBSTACLE_ROLES is which NPC roles a course steers round, and a role' + + ' is a word rather than a number', files: { - 'game/flight-course.ts': ['COURSE_ENDS'], + 'game/flight-course.ts': ['COURSE_ENDS', 'OBSTACLE_ROLES'], 'game/courses.ts': ['COURSE_NAMES', 'JUMP_WHY'], 'game/course-actions.ts': ['KINDS'], // what each role is called on the target list (docs/TODO/206 M1) diff --git a/test/course-clearance.test.ts b/test/course-clearance.test.ts new file mode 100644 index 00000000..fb6f40d6 --- /dev/null +++ b/test/course-clearance.test.ts @@ -0,0 +1,98 @@ +// WHERE A COURSE AIMS, so that its line is clear of what is on it. +// +// Split from `course-pilot.test.ts` on 2026-09-12, when that file passed the +// 400-line ceiling, and it follows the split of the code it tests. That file +// asks what a course DOES for one frame. This one asks where the line goes. +// +// `src/game/course-clearance.ts` is the subject. The second block is the flight +// it came from, so the pure geometry above it is held to a real approach. + +import * as THREE from 'three'; +import { Game } from '../src/game/game.ts'; +import { headlessShell } from '../src/engine/shell.ts'; +import { withoutSaving } from '../src/game/storage.ts'; +import { seedWorld } from '../src/game/rng.ts'; +import { clearOfObstacles } from '../src/game/course-clearance.ts'; +import { COURSE_OBSTACLE_CLEARANCE } from '../src/constants/course.ts'; +import { check, dismissBriefing, eq } from './harness.ts'; + +// --- A COURSE GOES ROUND WHAT IT WOULD HIT --------------------------------- +// +// Chris, 2026-09-12: *"I visited a rock hermit and then when I left clicked fly +// to the station - the computer crashed me straight into the rock hermit - we +// need to have some avoidance of obstacles"*. +// +// The line already went round the planet and, on a smuggling run, round a +// policeman. It went through everything else. +console.log('\na course goes round what it would hit'); +{ + const out = new THREE.Vector3(); + const from = new THREE.Vector3(); + const to = new THREE.Vector3(0, 0, -60_000); + const rock = (at: THREE.Vector3, radius = 120) => ({ at, radius }); + + eq('with nothing in the way, the aim is the target', + clearOfObstacles(from, to, [], out).equals(to), true); + check('a hermit ON the line moves the aim off it', + clearOfObstacles(from, to, [rock(new THREE.Vector3(0, 0, -600))], out) + .distanceTo(to) > 1, `${out.x.toFixed(0)},${out.y.toFixed(0)},${out.z.toFixed(0)}`); + check('...far enough that the new line clears its hull', + clearOfObstacles(from, to, [rock(new THREE.Vector3(0, 0, -600))], out) + .distanceTo(new THREE.Vector3(0, 0, -600)) > 120 + COURSE_OBSTACLE_CLEARANCE, + `${out.distanceTo(new THREE.Vector3(0, 0, -600)).toFixed(0)} units from its centre`); + check('a hermit well off the line is left alone', + clearOfObstacles(from, to, [rock(new THREE.Vector3(9000, 0, -600))], out).equals(to)); + // A thing AT the end of the line is the target, not an obstacle. That is what + // lets the hermit course fly to a hermit. + check('a hermit at the far end of the line is not in the way of it', + clearOfObstacles(from, to, [rock(to.clone())], out).equals(to)); + // The worst is the one with least room, not the one nearest the ship. + const near = rock(new THREE.Vector3(300, 0, -600)); + const tight = rock(new THREE.Vector3(20, 0, -4000)); + check('the tightest squeeze is the one it steers round, not the nearest', + clearOfObstacles(from, to, [near, tight], out).distanceTo(tight.at) + < clearOfObstacles(from, to, [near, tight], out).distanceTo(near.at)); +} + +// ...and the flight it came from: the station course past the hermit the +// commander just left. Without the detour this kills her outright at 399 units +// a second. +{ + const g = withoutSaving(() => { + seedWorld(20_260_933); + const game = new Game(() => headlessShell()); + dismissBriefing(game); + game.launch(); + return game; + }).value; + withoutSaving(() => { for (let f = 0, at = 0; f < 400; f++) g.step(1 / 60, at += 1 / 60); }); + g.state.world.clearNpcs(); + + // Out in the belt, with the station on the far side of the hermit, and the + // nose already down the line — a ship that has just left a hermit. + const away = new THREE.Vector3(1, 0.2, 0.3).normalize(); + g.state.player.position.copy(g.state.world.station.position).addScaledVector(away, 60_000); + const toStation = g.state.world.station.position.clone() + .sub(g.state.player.position).normalize(); + const at = g.state.player.position.clone().addScaledVector(toStation, 600); + const hermit = g.state.world.spawn('hermit', at, 3); + hermit.state.speed = 0; + g.state.player.quaternion.setFromRotationMatrix(new THREE.Matrix4() + .lookAt(g.state.player.position, g.state.world.station.position, new THREE.Vector3(0, 1, 0))); + g.state.session.course = 'station'; + + let closest = Infinity; + withoutSaving(() => { + for (let f = 0; f < 60 * 40; f++) { + g.step(1 / 60, 20 + f / 60); + hermit.object.position.copy(at); // hold it still, so only the RULES move + closest = Math.min(closest, g.state.player.position.distanceTo(at) - hermit.radius); + if (g.mode !== 'flight') break; + } + }); + check('the station course flies past the hermit rather than into it', + g.mode === 'flight', `ended as ${g.mode}`); + check('...clear of its hull by most of a turning circle', + closest > COURSE_OBSTACLE_CLEARANCE * 0.8, + `${closest.toFixed(0)} units, against a clearance of ${COURSE_OBSTACLE_CLEARANCE.toFixed(0)}`); +} diff --git a/test/course-pilot.test.ts b/test/course-pilot.test.ts index 6988f944..5fbb87fe 100644 --- a/test/course-pilot.test.ts +++ b/test/course-pilot.test.ts @@ -11,7 +11,8 @@ import { Game } from '../src/game/game.ts'; import { headlessShell } from '../src/engine/shell.ts'; import { withoutSaving } from '../src/game/storage.ts'; import { seedWorld } from '../src/game/rng.ts'; -import { CoursePilot, clearOfPlanet, type CourseView } from '../src/game/course-pilot.ts'; +import { CoursePilot, type CourseView } from '../src/game/course-pilot.ts'; +import { clearOfPlanet } from '../src/game/course-clearance.ts'; import { COURSE_DERELICT_STANDOFF, COURSE_PLANET_CLEARANCE } from '../src/constants/course.ts'; import { HERMIT_DOCK_SPEED } from '../src/constants/hermit-market.ts'; import { CABIN_TEMP_FATAL } from '../src/constants/sun.ts'; @@ -44,6 +45,7 @@ const view = (station: THREE.Vector3, over: Partial = {}): CourseVie hermitPos: null, tankFull: false, threats: [], + obstacles: [], loot: [], police: [], mission: null, diff --git a/test/mission-courses.test.ts b/test/mission-courses.test.ts index dfd02a6a..3c2919e9 100644 --- a/test/mission-courses.test.ts +++ b/test/mission-courses.test.ts @@ -16,7 +16,7 @@ import { withoutSaving } from '../src/game/storage.ts'; import { seedWorld } from '../src/game/rng.ts'; import { runMissions } from '../src/game/mission-bridge.ts'; import { missionCourse } from '../src/game/mission-course.ts'; -import { clearOfPolice } from '../src/game/course-pilot.ts'; +import { clearOfPolice } from '../src/game/course-clearance.ts'; import { SCAN_RANGE } from '../src/constants/law.ts'; import { COURSE_POLICE_CLEARANCE } from '../src/constants/course.ts'; import { COURSE_KEYS } from '../src/game/bindings.ts'; diff --git a/test/run.ts b/test/run.ts index 0d455dee..97af90dc 100644 --- a/test/run.ts +++ b/test/run.ts @@ -73,6 +73,7 @@ import './bribe-flight.test.ts'; import './prompts.test.ts'; import './courses.test.ts'; import './course-pilot.test.ts'; +import './course-clearance.test.ts'; import './course-launch.test.ts'; import './course-buttons.test.ts'; import './skip.test.ts'; From 2d7af571543005817f9993926d73c8386f6ccad5 Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Sat, 12 Sep 2026 21:47:48 +0100 Subject: [PATCH 058/100] The collect course holds one canister, and leads it Chris, 2026-09-12: *"Collecting cargo often seems to be difficult - we miss it quite a lot - especially when it is moving."* A probe named the faults by flying ONE canister against five. One alone was never missed, at any drift, in three seconds. Five were missed seven times with the cargo at rest. So the count was the fault, not the drift. THE PICK. The course took `loot[0]`, the nearest, recomputed every frame. The ship closed on one canister, a second became nearer as it moved, and the course turned away from the first. It now holds the one it is flying at until the canister is aboard or off the scanner. That is the rule the combat co-pilot already keeps for a target it is lined up on, and the same fault it was fixed for. THE AIM. It was where the canister had been. A canister drifts at up to 45 units a second and the scoop reaches 45, so an aim at its old place arrives a whole scoop behind it. The lead is the time to cover the gap at the course's own speed, capped by `COURSE_COLLECT_LEAD`. THE CAP IS WHAT IS FITTED, and it needed 80 runs a row to see. One run of five canisters flips between all five and two of five, so an earlier sweep of 5 runs chose a value the wider one rejects. Over 240 canisters at the three moving drifts: | cap | collected | mean time | | 0 | 191/240 | 75.0s | | 2 | 210/240 | 58.6s | | 5 | 231/240 | 50.8s | | 6 | 219/240 | 59.4s | Cargo at rest is untouched at every cap, because a still canister has no velocity to lead on. It was 80 of 80 in 21.6 seconds throughout. The tests pin the two rules rather than the flight, because the flight that measured them is two minutes of simulation a run. A nearer canister does not steal one the course is on, and a drifting one is aimed ahead of. Each fails when its own rule is taken out. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- src/constants/CATALOG.md | 13 +++---- src/constants/course.ts | 35 ++++++++++++++++++ src/game/course-pilot.ts | 74 ++++++++++++++++++++++++++++++++++----- src/game/flight-course.ts | 6 ++-- test/course-pilot.test.ts | 57 ++++++++++++++++++++++++++++++ 5 files changed, 167 insertions(+), 18 deletions(-) diff --git a/src/constants/CATALOG.md b/src/constants/CATALOG.md index a1b61251..805f1079 100644 --- a/src/constants/CATALOG.md +++ b/src/constants/CATALOG.md @@ -2,7 +2,7 @@ -456 exported constants. Regenerate with `npm run generate:constants`; +457 exported constants. Regenerate with `npm run generate:constants`; search names, meanings and values with `npm run constants:find -- ""`. | Domain | Symbol | Literal / expression | Purpose | Rule ID | Source | @@ -132,11 +132,12 @@ search names, meanings and values with `npm run constants:find -- ""`. | course | RUN_CLOSE_MARGIN | 50 | Below this lead in top speed, in world units a second, the run row says the ship is only a little faster (docs/TODO/206 M5). | course.runCloseMargin | [course.ts:211](./course.ts#L211) | | course | COURSE_RUN_REACH | 50_000 | How far ahead the run course aims, in world units, on the line away from the hostile ships (docs/TODO/206 M5). | course.runReach | [course.ts:221](./course.ts#L221) | | course | COURSE_COLLECT_SPEED | 60 | How fast the collect course flies onto a canister, in world units a second (docs/TODO/206 M6). | course.collectSpeed | [course.ts:235](./course.ts#L235) | -| course | COURSE_DOCK_HANDOVER | 1500 | How far from the station the station course hands the ship to the pilot, in world units (docs/TODO/207 M1). | course.dockHandover | [course.ts:249](./course.ts#L249) | -| course | COURSE_WATCH_STANDOFF | 1200 | How far from a ship the scan course holds, in world units (docs/TODO/208 M2). | course.watchStandoff | [course.ts:263](./course.ts#L263) | -| course | COURSE_ESCORT_STANDOFF | 600 | How far from its charge the escort course flies, in world units (docs/TODO/208 M2). | course.escortStandoff | [course.ts:276](./course.ts#L276) | -| course | COURSE_POLICE_CLEARANCE | SCAN_WARN_RANGE | How wide of a police ship the smuggling course flies, in world units (docs/TODO/208 M4). | | [course.ts:289](./course.ts#L289) | -| course | COURSE_OBSTACLE_CLEARANCE | PLAYER_FLIGHT.maxSpeed / PLAYER_FLIGHT.maxPitch | How far clear of a solid thing's HULL a course flies, in world units. | | [course.ts:315](./course.ts#L315) | +| course | COURSE_COLLECT_LEAD | 5 | The furthest ahead of a drifting canister the collect course will aim, in seconds. | course.collectLead | [course.ts:270](./course.ts#L270) | +| course | COURSE_DOCK_HANDOVER | 1500 | How far from the station the station course hands the ship to the pilot, in world units (docs/TODO/207 M1). | course.dockHandover | [course.ts:284](./course.ts#L284) | +| course | COURSE_WATCH_STANDOFF | 1200 | How far from a ship the scan course holds, in world units (docs/TODO/208 M2). | course.watchStandoff | [course.ts:298](./course.ts#L298) | +| course | COURSE_ESCORT_STANDOFF | 600 | How far from its charge the escort course flies, in world units (docs/TODO/208 M2). | course.escortStandoff | [course.ts:311](./course.ts#L311) | +| course | COURSE_POLICE_CLEARANCE | SCAN_WARN_RANGE | How wide of a police ship the smuggling course flies, in world units (docs/TODO/208 M4). | | [course.ts:324](./course.ts#L324) | +| course | COURSE_OBSTACLE_CLEARANCE | PLAYER_FLIGHT.maxSpeed / PLAYER_FLIGHT.maxPitch | How far clear of a solid thing's HULL a course flies, in world units. | | [course.ts:350](./course.ts#L350) | | docking | GATE_HALF_WIDTHS | 5 | How far out the approach gate sits, in multiples of the station half-width. | docking.gateHalfWidths | [docking.ts:25](./docking.ts#L25) | | docking | TURN_IN | Math.PI / 4 | How far round from the slot axis an approach turns in, in radians. | | [docking.ts:49](./docking.ts#L49) | | docking | RUN_IN_WIDTHS | GATE_HALF_WIDTHS * 0.6 | Where the approach stops the curve and flies straight, in station half-widths. | | [docking.ts:87](./docking.ts#L87) | diff --git a/src/constants/course.ts b/src/constants/course.ts index 1f12f56a..8d038be8 100644 --- a/src/constants/course.ts +++ b/src/constants/course.ts @@ -234,6 +234,41 @@ export const COURSE_RUN_REACH = 50_000; */ export const COURSE_COLLECT_SPEED = 60; +/** + * The furthest ahead of a drifting canister the collect course will aim, in + * seconds. + * + * Chris, 2026-09-12: *"Collecting cargo often seems to be difficult - we miss + * it quite a lot - especially when it is moving."* The course aimed at where + * the canister WAS. A canister drifts at up to 45 units a second, and the scoop + * reaches 45. So an aim at its old place arrives a whole scoop behind it. + * + * The lead itself is the time to cover the gap at `COURSE_COLLECT_SPEED`, which + * is an intercept rather than a guess. THE CAP IS WHAT IS FITTED. `arrive` + * flies faster than the collect speed while it is far out, so the raw time + * over-leads at range. An uncapped aim then chases a point the canister never + * reaches. + * + * Measured over 80 runs a row, five canisters a run, at four drifts and four + * scatter directions. The figure is how many of 240 were aboard inside two + * minutes, across the three moving drifts: + * + * | cap | collected | mean time | + * | 0 | 191/240 | 75.0s | + * | 2 | 210/240 | 58.6s | + * | 3 | 216/240 | 60.9s | + * | 4 | 217/240 | 55.1s | + * | 5 | 231/240 | 50.8s | + * | 6 | 219/240 | 59.4s | + * + * Cargo at rest is untouched at every cap, because a still canister has no + * velocity to lead on. It was 80 of 80 in 21.6 seconds throughout. + * + * @rule course.collectLead + * @domain course + */ +export const COURSE_COLLECT_LEAD = 5; + /** * How far from the station the station course hands the ship to the pilot, * in world units (docs/TODO/207 M1). diff --git a/src/game/course-pilot.ts b/src/game/course-pilot.ts index eb8abe47..75e643cf 100644 --- a/src/game/course-pilot.ts +++ b/src/game/course-pilot.ts @@ -16,7 +16,9 @@ // // THE STEER MEMORY IS NOT SAVED. It holds which vertical a bank takes, and a // restore that starts it fresh costs one bank at most. The scripted co-pilot -// makes the same bargain. +// makes the same bargain. The canister the collect course holds is the same +// bargain again. A restore picks the nearest, and that is the pick it makes +// from cold anyway. // // THREE SHAPES OF COURSE fly today: // @@ -51,7 +53,7 @@ import { PLAYER_FLIGHT } from '../constants/player-flight.ts'; import { SLOT_SPEED_LIMIT } from '../constants/docking.ts'; import { COURSE_AIM_DEADZONE, COURSE_ROLL_GATE, COURSE_ARRIVE_BRAKE, COURSE_ARRIVE_TOLERANCE, COURSE_DERELICT_STANDOFF, - COURSE_HERMIT_SPEED, COURSE_HERMIT_STANDOFF, + COURSE_COLLECT_LEAD, COURSE_HERMIT_SPEED, COURSE_HERMIT_STANDOFF, COURSE_COLLECT_SPEED, COURSE_ESCORT_STANDOFF, COURSE_RUN_REACH, COURSE_SKIM_DISTANCE, COURSE_TORUS_CONE, COURSE_TORUS_DROP, COURSE_WATCH_STANDOFF, } from '../constants/course.ts'; @@ -94,7 +96,7 @@ export interface CourseView { /** where the police ships within scanner range are, for the smuggling course */ readonly police: readonly THREE.Vector3[]; /** where the cargo adrift within scanner range is, nearest first */ - readonly loot: readonly THREE.Vector3[]; + readonly loot: readonly Adrift[]; /** * What the mission asks for here (docs/TODO/208 M1): where its target is, * how fast it moves, and what the ship does about it. Null when no live leg @@ -110,6 +112,13 @@ export interface CourseView { readonly handOverRange: number; } +/** A canister the collect course can fly at, and where it is going. */ +export interface Adrift { + at: THREE.Vector3; + /** its drift, in world units a second — the collect course leads on it */ + velocity: THREE.Vector3; +} + /** What the course pilot asks for this frame. */ export interface CourseStep { /** what it wants flown, or null where something else flies the ship */ @@ -139,6 +148,23 @@ interface Arrival { export class CoursePilot { private mem: SteerMemory = freshSteerMemory(); + /** + * The canister the collect course is flying at, held until it is taken or it + * leaves the scanner. + * + * IT USED TO TAKE THE NEAREST, EVERY FRAME. Chris, 2026-09-12: *"Collecting + * cargo often seems to be difficult - we miss it quite a lot - especially + * when it is moving."* The ship closed on one canister, a second became + * nearer as it moved, and the course turned away from the first. Measured + * over five canisters, that was 7 missed passes with the cargo at rest and 16 + * with it adrift. One canister alone was never missed at all, at any drift, + * which is what named the fault. + * + * The identity is the canister's own position vector, which `flight-course.ts` + * passes by reference. A canister that is scooped or drifts out of range + * leaves the list, and the next pick is the nearest again. + */ + private held: THREE.Vector3 | null = null; private readonly dir = new THREE.Vector3(); private readonly fwd = new THREE.Vector3(); private readonly aim = new THREE.Vector3(); @@ -146,9 +172,14 @@ export class CoursePilot { private readonly wideOf = new THREE.Vector3(); /** the aim once it is clear of the planet AND of anything solid */ private readonly clearAim = new THREE.Vector3(); + /** where a drifting canister will be when the ship gets there */ + private readonly lead = new THREE.Vector3(); /** Forget the bank, for a new course. */ - reset(): void { this.mem = freshSteerMemory(); } + reset(): void { + this.mem = freshSteerMemory(); + this.held = null; + } step(v: CourseView, dt: number): CourseStep { switch (v.course) { @@ -171,11 +202,22 @@ export class CoursePilot { } case 'run': return v.threats.length === 0 ? ended() : this.run(v, dt); case 'collect': { - const next = v.loot[0]; - if (next === undefined) return ended(); - // Fly onto it. The scoop takes it aboard inside `SCOOP_RANGE`, and - // the next one is then the nearest (docs/TODO/206 M6). - return { ...this.arrive(v, { target: next, standoff: 0, speed: COURSE_COLLECT_SPEED }, dt), done: false }; + const next = this.holdLoot(v.loot); + if (next === null) return ended(); + // FLY ONTO WHERE IT WILL BE. A canister drifts at up to 45 units a + // second, and the scoop reaches 45. An aim at where it IS therefore + // arrives a whole scoop behind it (Chris, 2026-09-12). The lead is the + // time to cover the gap at the speed the course flies. That is the same + // shape the co-pilot leads a ship with. + const gap = v.position.distanceTo(next.at); + this.lead.copy(next.at).addScaledVector( + next.velocity, Math.min(COURSE_COLLECT_LEAD, gap / COURSE_COLLECT_SPEED)); + // The scoop takes it aboard inside `SCOOP_RANGE`, and the next one is + // then the nearest (docs/TODO/206 M6). + return { + ...this.arrive(v, { target: this.lead, standoff: 0, speed: COURSE_COLLECT_SPEED }, dt), + done: false, + }; } // A rock is fought, not flown to: `flight-instruments.ts` picks the next // one as the target, and the computer's aim lines the ship up on it. @@ -263,6 +305,20 @@ export class CoursePilot { return { ...p, torus: p.torus && left > COURSE_TORUS_DROP, handOver: false, done: false }; } + /** + * Which canister to fly at: the one already held, while it is still there. + * + * A pilot who is nearly on a canister does not turn away because another + * drifted closer. It is the same rule the combat co-pilot keeps for a target + * it is lined up on, and the same fault it was fixed for. + */ + private holdLoot(loot: readonly Adrift[]): Adrift | null { + const still = loot.find((c) => c.at === this.held); + if (still !== undefined) return still; + this.held = loot[0]?.at ?? null; + return loot[0] ?? null; + } + /** Bank and pull the nose onto a point, with this throttle. */ private pointAt( v: CourseView, point: THREE.Vector3, throttle: number, dt: number, diff --git a/src/game/flight-course.ts b/src/game/flight-course.ts index 5b216ade..58452ffb 100644 --- a/src/game/flight-course.ts +++ b/src/game/flight-course.ts @@ -133,9 +133,9 @@ export class FlightCourse { && n.object.position.distanceTo(p.position) <= SCANNER_RANGE * 2) .map((n) => n.object.position), loot: w.cargo.items - .map((c) => c.object.position) - .filter((at) => at.distanceTo(p.position) <= SCANNER_RANGE) - .sort((a, b) => a.distanceTo(p.position) - b.distanceTo(p.position)), + .filter((c) => c.object.position.distanceTo(p.position) <= SCANNER_RANGE) + .map((c) => ({ at: c.object.position, velocity: c.velocity })) + .sort((a, b) => a.at.distanceTo(p.position) - b.at.distanceTo(p.position)), threats: hostilesOnScanner(w.npcs, p.position, this.state.commander.legalStatus, p.position.distanceTo(w.station.position)).map((n) => n.object.position), // THE SOLID THINGS, so a line does not go through one. Three roles sit diff --git a/test/course-pilot.test.ts b/test/course-pilot.test.ts index 5fbb87fe..ed353bce 100644 --- a/test/course-pilot.test.ts +++ b/test/course-pilot.test.ts @@ -329,3 +329,60 @@ console.log('\nnothing appears inside the planet'); check('...and a ship placed well clear of it appears where it was placed (the control)', aboveGround(w, high).distanceTo(high) < 1e-6); } + +// --- THE COLLECT COURSE HOLDS ONE CANISTER, AND LEADS IT ------------------- +// +// Chris, 2026-09-12: *"Collecting cargo often seems to be difficult - we miss +// it quite a lot - especially when it is moving."* +// +// Two faults, and a probe named them by flying ONE canister against five. One +// alone was never missed, at any drift. Five were missed seven times with the +// cargo at rest. So the first fault was the PICK: the course took the nearest +// every frame, and turned away from a canister it was nearly on when another +// drifted closer. The second was the AIM, which was where the canister had +// been. +// +// Both are asserted on the RULE rather than through a two-minute flight. The +// flight is what measured them, and its figures are beside +// `COURSE_COLLECT_LEAD`: over 80 runs a drift, the led course took 231 of 240 +// canisters against 191 unled. +console.log('\nthe collect course holds one canister, and leads it'); +{ + const DT = 1 / 60; + const far = new THREE.Vector3(0, 0, -50_000); + const still = (at: THREE.Vector3) => ({ at, velocity: new THREE.Vector3() }); + const ahead = new THREE.Vector3(0, 0, -600); + const aside = new THREE.Vector3(1400, 0, -600); + + // THE PICK. A canister dead ahead asks for no turn. One off to the side asks + // for a big one. So the demand says which of the two the course is flying at. + const turn = (s: { demand: { pitchRate: number; rollRate: number } | null }): number => + Math.abs(s.demand?.pitchRate ?? 0) + Math.abs(s.demand?.rollRate ?? 0); + + const fresh = new CoursePilot(); + const onAhead = turn(fresh.step(view(far, { course: 'collect', loot: [still(ahead)] }), DT)); + const onAside = turn(new CoursePilot() + .step(view(far, { course: 'collect', loot: [still(aside)] }), DT)); + check('the fixture can tell the two apart', onAside > onAhead + 0.01, + `${onAhead.toFixed(3)} ahead against ${onAside.toFixed(3)} aside`); + + const held = new CoursePilot(); + held.step(view(far, { course: 'collect', loot: [still(aside)] }), DT); + // ...and now a nearer one turns up, first in the list. + const kept = turn(held.step( + view(far, { course: 'collect', loot: [still(ahead), still(aside)] }), DT)); + check('a nearer canister does not steal one the course is already on', + kept > onAhead + 0.01, `${kept.toFixed(3)}, against ${onAhead.toFixed(3)} for the near one`); + + // ...until it is gone, and then the nearest is the next. + const moved = turn(held.step(view(far, { course: 'collect', loot: [still(ahead)] }), DT)); + check('...and when it is aboard, the course takes the next', moved <= onAhead + 0.01, + `${moved.toFixed(3)}`); + + // THE AIM. A canister dead ahead and drifting sideways is not where it was. + const drifting = { at: ahead.clone(), velocity: new THREE.Vector3(200, 0, 0) }; + const led = turn(new CoursePilot() + .step(view(far, { course: 'collect', loot: [drifting] }), DT)); + check('a drifting canister is aimed ahead of, not at', led > onAhead + 0.01, + `${led.toFixed(3)}, against ${onAhead.toFixed(3)} for the same place at rest`); +} From dc2973df966d16f134f07ad8ba68de4a72883f75 Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Sat, 12 Sep 2026 22:33:31 +0100 Subject: [PATCH 059/100] The docking computer is a button, not an automatic Chris, 2026-09-12: *"I have a docking computer - but instead of it being activated I still get the lining and only once that is done does the computer activate. I think we should have an options when in range 'Docking Computer' and if you click it activates. Otherwise we have the lining up and manual docking."* The course asked who flies the slot BEFORE the line-up once, and a fitted computer never saw one. Then cb248f6 moved the question AFTER it, so a commander who had paid for the fitting still sat through a line-up she did not want. The question is hers now, and it is open for the whole stretch. A DOCKING COMPUTER button stands above the line-up's own row, and above the roll strip in the mini game. A commander who fumbles the slot can still hand it over. A commander with no computer fitted is offered nothing, as before. It is the key's own code, so the button and the C key are one path rather than two. `Instruments.dockingComputer` ends the trial when the computer engages, because the two cannot both fly the ship. Without that the buttons would read LINING UP while the computer flew. `Autopilot.handOverToDock` goes with it. It was the course's own hand-over, and nothing calls it now. Eight assertions cover it, over the buttons and two flights. A pilot who presses it is flown in. A pilot who does not keeps the ship, and the slot is never taken because she flies nothing. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- src/game/autopilot.ts | 20 ------ src/game/cockpit-buttons.ts | 25 +++++-- src/game/cockpit-view.ts | 2 + src/game/flight-instruments.ts | 12 ++++ src/game/world-step.ts | 24 +++---- test/dock-trial.test.ts | 117 ++++++++++++++++++++------------- test/fight-buttons.test.ts | 2 +- 7 files changed, 115 insertions(+), 87 deletions(-) diff --git a/src/game/autopilot.ts b/src/game/autopilot.ts index e983ec37..ba364d2a 100644 --- a/src/game/autopilot.ts +++ b/src/game/autopilot.ts @@ -120,26 +120,6 @@ export class Autopilot { return events; } - /** - * A course hands the ship to the docking computer (docs/TODO/205 M3). - * - * It needs no fitted computer, and that is a stopgap. Until docs/TODO/207 - * gives the pilot a trial at the slot, a course to the station ends in a - * free dock. The course asks only inside `DOCK_COMPUTER_RANGE`, so the range - * refusal of `toggleDocking` cannot arise here. - */ - handOverToDock(): AutopilotEvent[] { - const s = this.state; - if (s.session.dcEngaged) return []; - s.session.dcEngaged = true; - s.dockPlan.phase = 'gate'; - return [ - say('DOCKING COMPUTER ENGAGED', 2), - { kind: 'sound', name: 'dockingComputerEngaged' }, - { kind: 'dockingMusic', on: true }, - ]; - } - /** * How far the commander is from the station, for the station's truce * (`truceHolds`, law.ts). diff --git a/src/game/cockpit-buttons.ts b/src/game/cockpit-buttons.ts index c118915c..6638c522 100644 --- a/src/game/cockpit-buttons.ts +++ b/src/game/cockpit-buttons.ts @@ -60,6 +60,13 @@ export interface ActionSource { readonly ecmKey: string | null; /** a hostile missile is on its way, so the E.C.M. is the button to press */ readonly missileInbound: boolean; + /** + * The docking computer's key, or null where none is fitted. It is offered as + * a button for the whole of the pilot's stretch at the slot (Chris, + * 2026-09-12). A commander who paid for the fitting may use it at any point, + * rather than fly a line-up she did not ask for. + */ + readonly dockKey: string | null; /** the pilot flies the last stretch into the slot (docs/TODO/207 M2) */ readonly trial: boolean; /** ...and the rails have it, so the mini game is on (docs/TODO/212) */ @@ -81,13 +88,23 @@ export function actionButtonsFor(a: ActionSource): HudButton[] { // The last stretch into the slot asks for two things and nothing else: the // roll, and the speed (docs/TODO/207 M2). So the pilot's buttons are those // two while it runs, and the guns wait. + // THE FITTING THE COMMANDER PAID FOR, offered for the whole stretch. It + // flies the rest of the approach and the slot, and it ends the trial. + const handOver = (): HudButton[] => (a.dockKey === null ? [] + : [{ code: a.dockKey, label: 'DOCKING COMPUTER', hint: 'IT FLIES YOU IN' }]); if (a.trial && !a.rails) { - // The computer is lining the ship up, and the pilot has nothing to do yet - // (docs/TODO/212). A strip that did nothing would be a lie. - return [{ code: 'dock-lining-up', label: 'LINING UP', hint: 'STAND BY FOR THE SLOT' }]; + // The computer is lining the ship up, and the pilot has nothing else to do + // yet (docs/TODO/212). A strip that did nothing would be a lie. + return [ + ...handOver(), + { code: 'dock-lining-up', label: 'LINING UP', hint: 'STAND BY FOR THE SLOT' }, + ]; } if (a.trial) { - const out: HudButton[] = [{ code: a.rollStripCode, label: 'DRAG TO ROLL', strip: true }]; + const out: HudButton[] = [ + ...handOver(), + { code: a.rollStripCode, label: 'DRAG TO ROLL', strip: true }, + ]; if (a.accelKey) { out.push({ code: a.accelKey, label: 'THRUST', hint: 'HOLD TO GO IN', hold: true }); } diff --git a/src/game/cockpit-view.ts b/src/game/cockpit-view.ts index c37011c3..a9c6aadf 100644 --- a/src/game/cockpit-view.ts +++ b/src/game/cockpit-view.ts @@ -224,6 +224,8 @@ export class CockpitView { launchKey: key('launchMissile'), ecmKey: this.state.commander.equipment.ecm ? key('fireEcm') : null, missileInbound: this.ordnance.missileInbound, + dockKey: this.state.commander.equipment.dockingComputer + ? key('toggleDockingComputer') : null, trial: this.state.session.dockTrial, rails: this.state.session.dockRails, accelKey: keymap().accel[0] ?? null, diff --git a/src/game/flight-instruments.ts b/src/game/flight-instruments.ts index a2e59851..31abc14d 100644 --- a/src/game/flight-instruments.ts +++ b/src/game/flight-instruments.ts @@ -161,8 +161,20 @@ export class Instruments { */ massLocked(): boolean { return massLocked(this.state); } + /** + * The docking computer, on or off, from the key or from the button. + * + * IT ENDS THE TRIAL, because the two cannot both fly the ship. The button is + * offered for the whole of the pilot's stretch (`cockpit-buttons.ts`), so a + * commander who fumbles the slot can still hand it over. `watchDockTrial` + * would clear the flag eventually, on range alone, and the buttons would + * read LINING UP while the computer flew. + */ dockingComputer(): void { + const s = this.state.session; + const was = s.dcEngaged; this.applyAutopilot(this.autopilot.toggleDocking()); + if (!was && s.dcEngaged) { s.dockTrial = false; s.dockRails = false; } } /** diff --git a/src/game/world-step.ts b/src/game/world-step.ts index 6f4ba4f0..8727edbb 100644 --- a/src/game/world-step.ts +++ b/src/game/world-step.ts @@ -474,22 +474,14 @@ export class WorldStep { fire: pilot.demand.fire, }; } - // LINED UP. Now, and only now, the question of who takes it in. - // - // A fitted docking computer takes it, and this is the one place that - // hand-over is decided (docs/TODO/212). `autopilot.ts`'s - // `handOverToDock` still engages it from the pilot's own key. That one - // resets the plan phase, which is right from cold. It would be wrong from - // here, because the run latch is already earned and the ship is on the - // axis. - if (this.state.commander.equipment.dockingComputer) { - session.dockTrial = false; - session.dcEngaged = true; - out.push(say('DOCKING COMPUTER ENGAGED', 2)); - out.push({ kind: 'sound', name: 'dockingComputerEngaged' }); - out.push({ kind: 'dockingMusic', on: true }); - return this.dockingDemand(dt, pilot, plan); - } + // LINED UP, AND THE SLOT IS THE PILOT'S. It used to ask here whether a + // docking computer was fitted, and hand the ship to it. Chris, + // 2026-09-12: *"I have a docking computer - but instead of it being + // activated I still get the lining and only once that is done does the + // computer activate."* A fitting the commander paid for should not wait + // on a line-up she did not ask for. It is a BUTTON now, offered for the + // whole of the trial (`cockpit-buttons.ts`). The line-up is what she gets + // if she does not press it. session.dockRails = true; out.push(say('THE SLOT IS YOURS — THRUST IN, AND MATCH ITS SPIN', 5)); } diff --git a/test/dock-trial.test.ts b/test/dock-trial.test.ts index da32b88c..2cd8f25d 100644 --- a/test/dock-trial.test.ts +++ b/test/dock-trial.test.ts @@ -19,6 +19,7 @@ import { withoutSaving } from '../src/game/storage.ts'; import { seedWorld } from '../src/game/rng.ts'; import { RAILS_CONE, RAILS_STOPPED, SLOT_HALF_ACROSS } from '../src/constants/docking.ts'; import { slotNormal } from '../src/world/slot.ts'; +import { keyCodeIfBound } from '../src/ui/key-help.ts'; import { check, dismissBriefing, eq } from './harness.ts'; console.log('\nthe last stretch into the slot'); @@ -27,7 +28,7 @@ console.log('\nthe last stretch into the slot'); { const trial = actionButtonsFor({ fireKey: 'KeyA', missiles: 3, armed: false, locked: false, armKey: 'KeyT', - launchKey: 'KeyM', ecmKey: 'KeyE', targets: null, missileInbound: false, + launchKey: 'KeyM', ecmKey: 'KeyE', targets: null, missileInbound: false, dockKey: null, trial: true, rails: true, accelKey: 'Space', decelKey: 'KeyX', rollStripCode: 'roll', }); eq('the stretch shows a strip and two held buttons, and no guns', @@ -36,7 +37,7 @@ console.log('\nthe last stretch into the slot'); // (docs/TODO/212). A strip that did nothing would be a lie. const lining = actionButtonsFor({ fireKey: 'KeyA', missiles: 3, armed: false, locked: false, armKey: 'KeyT', - launchKey: 'KeyM', ecmKey: 'KeyE', targets: null, missileInbound: false, + launchKey: 'KeyM', ecmKey: 'KeyE', targets: null, missileInbound: false, dockKey: null, trial: true, rails: false, accelKey: 'Space', decelKey: 'KeyX', rollStripCode: 'roll', }); eq('while the computer lines up, the pilot sees one word and no controls', @@ -291,54 +292,78 @@ console.log('\nthe computer finishes the line-up before the pilot gets the slot' + `${(noseAtStop * 180 / Math.PI).toFixed(1)} degrees off`); } -// --- ONE LINE-UP, WHOEVER TAKES THE SHIP IN -------------------------------- +// --- THE DOCKING COMPUTER IS A BUTTON, NOT AN AUTOMATIC -------------------- // -// Chris, 2026-09-12: *"I think we should merge both paths?"* +// Chris, 2026-09-12: *"I have a docking computer - but instead of it being +// activated I still get the lining and only once that is done does the computer +// activate. I think we should have an options when in range 'Docking Computer' +// and if you click it activates. Otherwise we have the lining up and manual +// docking."* // -// The course used to ask who flies the slot BEFORE the line-up. A commander -// with a docking computer fitted was handed straight to it, and never saw a -// line-up at all. Now every commander gets the same one: the computer flies to -// the right distance, stops, and turns the nose onto the axis. Only then does -// it ask who takes the ship in. -console.log('\na fitted docking computer takes the ship after the same line-up'); +// The course used to ask who flies the slot BEFORE the line-up, and a fitted +// computer never saw one. Then it asked AFTER, and a commander who had paid for +// the fitting still had to sit through a line-up she did not want. Now the +// question is hers, and it is open for the whole of the stretch. +console.log('\nthe docking computer is offered, and it takes the ship when asked'); { - const g = withoutSaving(() => { - seedWorld(20_260_951); - const game = new Game(() => headlessShell()); - dismissBriefing(game); - game.launch(); - game.arriveInSystem(); - return game; - }).value; - g.state.commander.equipment.dockingComputer = true; - g.state.world.clearNpcs(); - g.state.session.course = 'station'; + const dockKey = keyCodeIfBound('flight', 'toggleDockingComputer') ?? ''; + // THE BUTTON IS THERE THROUGHOUT, from the first frame of the line-up to the + // last of the mini game. A commander who fumbles the slot can still hand it + // over. + const source = (rails: boolean, fitted: boolean) => ({ + fireKey: 'KeyA', missiles: 0, armed: false, locked: false, armKey: 'KeyT', + launchKey: 'KeyM', ecmKey: null, targets: null, missileInbound: false, + dockKey: fitted ? dockKey : null, + trial: true, rails, accelKey: 'Space', decelKey: 'KeyX', rollStripCode: 'roll', + }); + check('while the computer lines up, a fitted one is offered', + actionButtonsFor(source(false, true)).some((b) => b.label === 'DOCKING COMPUTER')); + check('...and during the pilot\'s own run in, too', + actionButtonsFor(source(true, true)).some((b) => b.label === 'DOCKING COMPUTER')); + check('a commander with none is offered nothing', + !actionButtonsFor(source(false, false)).some((b) => b.label === 'DOCKING COMPUTER') + && !actionButtonsFor(source(true, false)).some((b) => b.label === 'DOCKING COMPUTER')); - const dt = 1 / 60; - const out = new THREE.Vector3(); - const fwd = new THREE.Vector3(); - let noseAtEngage = -1; - let sawTrial = false; - let railsTaken = false; - withoutSaving(() => { - for (let f = 0, at = 0; f < 300 / dt; f++) { - const was = g.state.session.dcEngaged; - if (g.state.session.dockTrial && !was) sawTrial = true; - g.step(dt, at += dt); - if (g.state.session.dockRails) railsTaken = true; - if (!was && g.state.session.dcEngaged) { - slotNormal(g.state.world.station, out).multiplyScalar(-1); - noseAtEngage = g.state.player.getForward(fwd).angleTo(out); + /** Fly the approach, pressing the button when `ask` says to. */ + const fly = (ask: boolean): { sawTrial: boolean; docked: boolean; engaged: boolean } => { + const g = withoutSaving(() => { + seedWorld(20_260_951); + const game = new Game(() => headlessShell()); + dismissBriefing(game); + game.launch(); + game.arriveInSystem(); + return game; + }).value; + g.state.commander.equipment.dockingComputer = true; + g.state.world.clearNpcs(); + g.state.session.course = 'station'; + const dt = 1 / 60; + let sawTrial = false; + let pressed = false; + let engaged = false; + withoutSaving(() => { + for (let f = 0, at = 0; f < 300 / dt; f++) { + if (g.state.session.dockTrial) sawTrial = true; + if (ask && !pressed && g.state.session.dockTrial) { + g.input.injectPress(dockKey); + pressed = true; + } + g.step(dt, at += dt); + if (g.state.session.dcEngaged) engaged = true; + if (g.mode !== 'flight') break; } - if (g.mode !== 'flight') break; - } - }); + }); + return { sawTrial, docked: g.mode === 'docked', engaged }; + }; + + const asked = fly(true); + check('a fitted computer still goes through the line-up first', asked.sawTrial); + check('...and pressing it hands the ship over', asked.engaged); + check('...and it flies the ship in from there', asked.docked); - check('a fitted computer still goes through the line-up first', sawTrial); - check('...and takes the ship only once its nose is on the axis', - noseAtEngage >= 0 && noseAtEngage < RAILS_CONE, - noseAtEngage < 0 ? 'it never took the ship' - : `${(noseAtEngage * 180 / Math.PI).toFixed(2)} degrees off`); - check('...never through the pilot\'s rails, which it has no use for', !railsTaken); - check('...and it flies the ship in from there', g.mode === 'docked'); + // NOBODY PRESSES IT, and the line-up and the mini game are what she gets. + // She flies nothing here, so the slot is never taken. + const alone = fly(false); + check('a pilot who does not press it keeps the ship', !alone.engaged); + check('...and the line-up hands her the slot instead', !alone.docked); } diff --git a/test/fight-buttons.test.ts b/test/fight-buttons.test.ts index 14558537..f620851e 100644 --- a/test/fight-buttons.test.ts +++ b/test/fight-buttons.test.ts @@ -20,7 +20,7 @@ console.log('\nthe pilot\'s buttons'); const base = { fireKey: 'KeyA', missiles: 3, armed: false, locked: false, - armKey: 'KeyT', launchKey: 'KeyM', ecmKey: null, targets: null, missileInbound: false, + armKey: 'KeyT', launchKey: 'KeyM', ecmKey: null, targets: null, missileInbound: false, dockKey: null, trial: false, rails: false, accelKey: 'Space', decelKey: 'KeyX', rollStripCode: 'roll', }; { From cb7785b4a229800a8df7f22e863e6f4974b1af53 Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Sat, 12 Sep 2026 22:33:45 +0100 Subject: [PATCH 060/100] The collect course flies slowly enough to correct Chris, 2026-09-12: *"collecting cargo seems to be broken sometimes. I seem to run at maximum speed, then slow down and then miss it and then run at maximum speed."* That is the trace exactly. `arrive` picks its speed from a braking curve, which is right for a big target on a straight line. A trace of a stuck run showed 400 units a second with a canister 250 units off, for two minutes. A SHIP THAT FAST CANNOT CORRECT. Its tightest turn has a radius of 276 units and the scoop reaches 45, so a lateral error the steering leaves at that point cannot be closed at all. The ship sails past and comes round again, for ever. `COURSE_COLLECT_CAP` is twice `COURSE_COLLECT_SPEED`, the speed the course settles at. That is a turn radius of 83 units, under twice the scoop's reach. Measured over 64 runs of five canisters, at four drifts and four scatter directions: | cap | left behind | mean time | | 400 | 4 of 64 | 43.5s | | 150 | 0 of 64 | 32.0s | | 120 | 0 of 64 | 29.8s | | 90 | 0 of 64 | 32.6s | | 60 | 36 of 64 | | At 60 it is the collect speed itself, and the course can no longer catch a canister drifting at 45. HOLDING ONE CANISTER MADE THE LOOP PERMANENT rather than causing it. 2d7af57 stopped the course switching away, and switching away had looked like progress. Both are needed: the hold, and a speed the hold can act at. The test file passed the 400-line ceiling again, and the seam is `CoursePilot.arrive`: one function with four callers that fly to a thing and stop. Those move to `course-arrivals.test.ts`, and the four fixtures both files need move to `course-fixtures.ts` rather than being copied. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- src/constants/CATALOG.md | 13 +- src/constants/course.ts | 37 ++++++ src/game/course-pilot.ts | 11 +- test/course-arrivals.test.ts | 162 +++++++++++++++++++++++++ test/course-fixtures.ts | 90 ++++++++++++++ test/course-pilot.test.ts | 224 ++++------------------------------- test/run.ts | 1 + 7 files changed, 329 insertions(+), 209 deletions(-) create mode 100644 test/course-arrivals.test.ts create mode 100644 test/course-fixtures.ts diff --git a/src/constants/CATALOG.md b/src/constants/CATALOG.md index 805f1079..180be021 100644 --- a/src/constants/CATALOG.md +++ b/src/constants/CATALOG.md @@ -2,7 +2,7 @@ -457 exported constants. Regenerate with `npm run generate:constants`; +458 exported constants. Regenerate with `npm run generate:constants`; search names, meanings and values with `npm run constants:find -- ""`. | Domain | Symbol | Literal / expression | Purpose | Rule ID | Source | @@ -133,11 +133,12 @@ search names, meanings and values with `npm run constants:find -- ""`. | course | COURSE_RUN_REACH | 50_000 | How far ahead the run course aims, in world units, on the line away from the hostile ships (docs/TODO/206 M5). | course.runReach | [course.ts:221](./course.ts#L221) | | course | COURSE_COLLECT_SPEED | 60 | How fast the collect course flies onto a canister, in world units a second (docs/TODO/206 M6). | course.collectSpeed | [course.ts:235](./course.ts#L235) | | course | COURSE_COLLECT_LEAD | 5 | The furthest ahead of a drifting canister the collect course will aim, in seconds. | course.collectLead | [course.ts:270](./course.ts#L270) | -| course | COURSE_DOCK_HANDOVER | 1500 | How far from the station the station course hands the ship to the pilot, in world units (docs/TODO/207 M1). | course.dockHandover | [course.ts:284](./course.ts#L284) | -| course | COURSE_WATCH_STANDOFF | 1200 | How far from a ship the scan course holds, in world units (docs/TODO/208 M2). | course.watchStandoff | [course.ts:298](./course.ts#L298) | -| course | COURSE_ESCORT_STANDOFF | 600 | How far from its charge the escort course flies, in world units (docs/TODO/208 M2). | course.escortStandoff | [course.ts:311](./course.ts#L311) | -| course | COURSE_POLICE_CLEARANCE | SCAN_WARN_RANGE | How wide of a police ship the smuggling course flies, in world units (docs/TODO/208 M4). | | [course.ts:324](./course.ts#L324) | -| course | COURSE_OBSTACLE_CLEARANCE | PLAYER_FLIGHT.maxSpeed / PLAYER_FLIGHT.maxPitch | How far clear of a solid thing's HULL a course flies, in world units. | | [course.ts:350](./course.ts#L350) | +| course | COURSE_COLLECT_CAP | COURSE_COLLECT_SPEED * 2 | The fastest the collect course flies on its way to a canister, in world units a second. | course.collectCap | [course.ts:307](./course.ts#L307) | +| course | COURSE_DOCK_HANDOVER | 1500 | How far from the station the station course hands the ship to the pilot, in world units (docs/TODO/207 M1). | course.dockHandover | [course.ts:321](./course.ts#L321) | +| course | COURSE_WATCH_STANDOFF | 1200 | How far from a ship the scan course holds, in world units (docs/TODO/208 M2). | course.watchStandoff | [course.ts:335](./course.ts#L335) | +| course | COURSE_ESCORT_STANDOFF | 600 | How far from its charge the escort course flies, in world units (docs/TODO/208 M2). | course.escortStandoff | [course.ts:348](./course.ts#L348) | +| course | COURSE_POLICE_CLEARANCE | SCAN_WARN_RANGE | How wide of a police ship the smuggling course flies, in world units (docs/TODO/208 M4). | | [course.ts:361](./course.ts#L361) | +| course | COURSE_OBSTACLE_CLEARANCE | PLAYER_FLIGHT.maxSpeed / PLAYER_FLIGHT.maxPitch | How far clear of a solid thing's HULL a course flies, in world units. | | [course.ts:387](./course.ts#L387) | | docking | GATE_HALF_WIDTHS | 5 | How far out the approach gate sits, in multiples of the station half-width. | docking.gateHalfWidths | [docking.ts:25](./docking.ts#L25) | | docking | TURN_IN | Math.PI / 4 | How far round from the slot axis an approach turns in, in radians. | | [docking.ts:49](./docking.ts#L49) | | docking | RUN_IN_WIDTHS | GATE_HALF_WIDTHS * 0.6 | Where the approach stops the curve and flies straight, in station half-widths. | | [docking.ts:87](./docking.ts#L87) | diff --git a/src/constants/course.ts b/src/constants/course.ts index 8d038be8..c7b7c397 100644 --- a/src/constants/course.ts +++ b/src/constants/course.ts @@ -269,6 +269,43 @@ export const COURSE_COLLECT_SPEED = 60; */ export const COURSE_COLLECT_LEAD = 5; +/** + * The fastest the collect course flies on its way to a canister, in world + * units a second. + * + * Chris, 2026-09-12: *"collecting cargo seems to be broken sometimes. I seem to + * run at maximum speed, then slow down and then miss it and then run at maximum + * speed."* That is the trace exactly. `arrive` picks a speed from the braking + * curve, which is right for a big target on a straight line. It reached 400 + * with a canister 250 units off. + * + * A SHIP THAT FAST CANNOT CORRECT. Its tightest turn has a radius of 276 units, + * and the scoop reaches 45. So a lateral error the steering leaves at that + * point cannot be closed at all. The ship sails past, and comes round again. + * Held on one canister it loops for ever, which is what "broken" looked like. + * + * It is twice `COURSE_COLLECT_SPEED`, the speed the course settles at. That is + * a turn radius of 83 units, which is under twice the scoop's reach. + * + * Measured over 64 runs, five canisters a run, at four drifts and four scatter + * directions. The figure is how many runs left cargo behind after two minutes: + * + * | cap | left behind | mean time | + * | 400 | 4 of 64 | 43.5s | + * | 180 | 4 of 64 | 35.9s | + * | 150 | 0 of 64 | 32.0s | + * | 120 | 0 of 64 | 29.8s | + * | 90 | 0 of 64 | 32.6s | + * | 60 | 36 of 64 | | + * + * At 60 it is the collect speed itself, and the course can no longer catch a + * canister that drifts at 45. + * + * @rule course.collectCap + * @domain course + */ +export const COURSE_COLLECT_CAP = COURSE_COLLECT_SPEED * 2; + /** * How far from the station the station course hands the ship to the pilot, * in world units (docs/TODO/207 M1). diff --git a/src/game/course-pilot.ts b/src/game/course-pilot.ts index 75e643cf..22c888c4 100644 --- a/src/game/course-pilot.ts +++ b/src/game/course-pilot.ts @@ -53,7 +53,7 @@ import { PLAYER_FLIGHT } from '../constants/player-flight.ts'; import { SLOT_SPEED_LIMIT } from '../constants/docking.ts'; import { COURSE_AIM_DEADZONE, COURSE_ROLL_GATE, COURSE_ARRIVE_BRAKE, COURSE_ARRIVE_TOLERANCE, COURSE_DERELICT_STANDOFF, - COURSE_COLLECT_LEAD, COURSE_HERMIT_SPEED, COURSE_HERMIT_STANDOFF, + COURSE_COLLECT_CAP, COURSE_COLLECT_LEAD, COURSE_HERMIT_SPEED, COURSE_HERMIT_STANDOFF, COURSE_COLLECT_SPEED, COURSE_ESCORT_STANDOFF, COURSE_RUN_REACH, COURSE_SKIM_DISTANCE, COURSE_TORUS_CONE, COURSE_TORUS_DROP, COURSE_WATCH_STANDOFF, } from '../constants/course.ts'; @@ -141,6 +141,8 @@ const IDLE: CourseStep = { demand: null, torus: false, handOver: false, done: fa * about 19 u/s for ever, and never counted as arrived (docs/TODO/205 M3). */ interface Arrival { + /** the fastest it may fly on the way, or undefined for the ship's own top speed */ + cap?: number; readonly target: THREE.Vector3; readonly standoff: number; readonly speed: number; @@ -215,7 +217,10 @@ export class CoursePilot { // The scoop takes it aboard inside `SCOOP_RANGE`, and the next one is // then the nearest (docs/TODO/206 M6). return { - ...this.arrive(v, { target: this.lead, standoff: 0, speed: COURSE_COLLECT_SPEED }, dt), + ...this.arrive(v, { + target: this.lead, standoff: 0, + speed: COURSE_COLLECT_SPEED, cap: COURSE_COLLECT_CAP, + }, dt), done: false, }; } @@ -292,7 +297,7 @@ export class CoursePilot { if (Math.abs(left) <= COURSE_ARRIVE_TOLERANCE && v.speed <= a.speed + PLAYER_FLIGHT.accel * dt) { return { demand: hold(v, dt), torus: false, handOver: false, done: true }; } - const wanted = Math.min(PLAYER_FLIGHT.maxSpeed, + const wanted = Math.min(a.cap ?? PLAYER_FLIGHT.maxSpeed, a.speed + Math.sqrt(2 * COURSE_ARRIVE_BRAKE * PLAYER_FLIGHT.accel * Math.max(0, left))); const band = PLAYER_FLIGHT.accel * dt; const throttle = v.speed < wanted - band ? 1 : v.speed > wanted + band ? -1 : 0; diff --git a/test/course-arrivals.test.ts b/test/course-arrivals.test.ts new file mode 100644 index 00000000..eb186da2 --- /dev/null +++ b/test/course-arrivals.test.ts @@ -0,0 +1,162 @@ +// THE COURSES THAT FLY TO A THING AND STOP THERE. +// +// Split from `course-pilot.test.ts` on 2026-09-12, when that file passed the +// 400-line ceiling. The seam is `CoursePilot.arrive`, one function with four +// callers: the derelict, the hermit, the star and the loose cargo. Each flies +// to a standoff from something and settles at a speed. +// +// What stays next door is the STATION course, and the rules every line obeys: +// the hand-over to the pilot, the planet detour, the roll and the flight key. + +import * as THREE from 'three'; +import { CoursePilot } from '../src/game/course-pilot.ts'; +import { HERMIT_DOCK_SPEED } from '../src/constants/hermit-market.ts'; +import { COURSE_COLLECT_CAP, COURSE_DERELICT_STANDOFF } from '../src/constants/course.ts'; +import { CABIN_TEMP_FATAL } from '../src/constants/sun.ts'; +import { MAX_FUEL } from '../src/constants/commander.ts'; +import { PLAYER_FLIGHT } from '../src/constants/player-flight.ts'; +import { SCOOP_RANGE } from '../src/constants/scoop.ts'; +import { derelictReport } from '../src/game/derelict.ts'; +import { generateGalaxy } from '../src/galaxy/galaxy.ts'; +import { arrived, arrivedWith, fly, view } from './course-fixtures.ts'; +import { check, eq } from './harness.ts'; + +console.log('\nthe derelict course'); +{ + const g = arrivedWith('generation'); + g.state.session.course = 'derelict'; + fly(g, 300, () => g.state.session.course === null); + const gen = g.state.world.npcs.find((n) => n.role === 'generation')!; + const dist = g.state.player.position.distanceTo(gen.object.position); + check('the ship stops at the standoff from the generation ship', + Math.abs(dist - COURSE_DERELICT_STANDOFF) < 200, `${Math.round(dist)} units`); + check('...at the derelict\'s own drift', Math.abs(g.state.player.speed - gen.state.speed) < 10, + `${g.state.player.speed.toFixed(1)} u/s against ${gen.state.speed.toFixed(1)}`); + check('...and the course is done for the visit', g.state.session.coursesDone.includes('derelict')); + check('...and the scan says what is there, in the world\'s own words', + g.state.session.messageText.length > 20, `said: ${g.state.session.messageText}`); +} + +console.log('\nwhat a derelict\'s scan reports'); +{ + // The words come off the world's seed, so a derelict tells the same story + // on every visit, and two worlds tell different ones (docs/TODO/208 M5). + const systems = generateGalaxy(1); + const twice = [derelictReport(systems[7]), derelictReport(systems[7])]; + eq('the same world reports the same thing twice', twice[0], twice[1]); + const said = new Set(systems.map((sys) => derelictReport(sys))); + check('...and the galaxy tells more than one story', said.size > 3, `${said.size} of them`); + check('...each of them a sentence', [...said].every((line) => line.endsWith('.'))); +} + +console.log('\nthe hermit course'); +{ + const g = arrivedWith('hermit'); + g.state.session.course = 'hermit'; + fly(g, 400, () => g.state.session.hermitTrading); + check('the hermit opens his trade at the end of the course', g.state.session.hermitTrading); + check('...with the ship slow enough for the hermit\'s rule', + g.state.player.speed < HERMIT_DOCK_SPEED, `${g.state.player.speed.toFixed(1)} u/s`); + check('...and the ship never struck the rock', g.state.sys.foreShield > 0 && g.mode !== 'dead'); +} + +console.log('\nthe star course'); +{ + const g = arrived(20_260_913); + g.state.commander.equipment.scoops = true; + g.state.commander.fuel = 5; + g.state.session.course = 'skim'; + let peak = 0; + fly(g, 400, () => { + peak = Math.max(peak, g.state.sys.cabinTemp); + return g.state.session.course === null; + }); + eq('the star course fills the tank', g.state.commander.fuel, MAX_FUEL); + check('...the ship lives, and the cabin stays short of fatal', + g.mode !== 'dead' && peak < CABIN_TEMP_FATAL * 0.6, `peak ${peak.toFixed(3)}`); + check('...and the course is done for the visit', g.state.session.coursesDone.includes('skim')); +} + +// --- THE COLLECT COURSE HOLDS ONE CANISTER, AND LEADS IT ------------------- +// +// Chris, 2026-09-12: *"Collecting cargo often seems to be difficult - we miss +// it quite a lot - especially when it is moving."* +// +// Two faults, and a probe named them by flying ONE canister against five. One +// alone was never missed, at any drift. Five were missed seven times with the +// cargo at rest. So the first fault was the PICK: the course took the nearest +// every frame, and turned away from a canister it was nearly on when another +// drifted closer. The second was the AIM, which was where the canister had +// been. +// +// Both are asserted on the RULE rather than through a two-minute flight. The +// flight is what measured them, and its figures are beside +// `COURSE_COLLECT_LEAD`: over 80 runs a drift, the led course took 231 of 240 +// canisters against 191 unled. +console.log('\nthe collect course holds one canister, and leads it'); +{ + const DT = 1 / 60; + const far = new THREE.Vector3(0, 0, -50_000); + const still = (at: THREE.Vector3) => ({ at, velocity: new THREE.Vector3() }); + const ahead = new THREE.Vector3(0, 0, -600); + const aside = new THREE.Vector3(1400, 0, -600); + + // THE PICK. A canister dead ahead asks for no turn. One off to the side asks + // for a big one. So the demand says which of the two the course is flying at. + const turn = (s: { demand: { pitchRate: number; rollRate: number } | null }): number => + Math.abs(s.demand?.pitchRate ?? 0) + Math.abs(s.demand?.rollRate ?? 0); + + const fresh = new CoursePilot(); + const onAhead = turn(fresh.step(view(far, { course: 'collect', loot: [still(ahead)] }), DT)); + const onAside = turn(new CoursePilot() + .step(view(far, { course: 'collect', loot: [still(aside)] }), DT)); + check('the fixture can tell the two apart', onAside > onAhead + 0.01, + `${onAhead.toFixed(3)} ahead against ${onAside.toFixed(3)} aside`); + + const held = new CoursePilot(); + held.step(view(far, { course: 'collect', loot: [still(aside)] }), DT); + // ...and now a nearer one turns up, first in the list. + const kept = turn(held.step( + view(far, { course: 'collect', loot: [still(ahead), still(aside)] }), DT)); + check('a nearer canister does not steal one the course is already on', + kept > onAhead + 0.01, `${kept.toFixed(3)}, against ${onAhead.toFixed(3)} for the near one`); + + // ...until it is gone, and then the nearest is the next. + const moved = turn(held.step(view(far, { course: 'collect', loot: [still(ahead)] }), DT)); + check('...and when it is aboard, the course takes the next', moved <= onAhead + 0.01, + `${moved.toFixed(3)}`); + + // THE AIM. A canister dead ahead and drifting sideways is not where it was. + const drifting = { at: ahead.clone(), velocity: new THREE.Vector3(200, 0, 0) }; + const led = turn(new CoursePilot() + .step(view(far, { course: 'collect', loot: [drifting] }), DT)); + check('a drifting canister is aimed ahead of, not at', led > onAhead + 0.01, + `${led.toFixed(3)}, against ${onAhead.toFixed(3)} for the same place at rest`); +} + +// ...AND IT DOES NOT FLY AT IT TOO FAST TO CORRECT. +// +// Chris, 2026-09-12: *"collecting cargo seems to be broken sometimes. I seem to +// run at maximum speed, then slow down and then miss it and then run at maximum +// speed."* A trace showed exactly that: 400 units a second with a canister 250 +// units off, a sail past, and a loop. `arrive` picks its speed from a braking +// curve, which is right for a big target on a straight line. At 400 the ship's +// tightest turn has a radius of 276 units, and the scoop reaches 45. +// +// Holding one canister (above) made the loop permanent rather than causing it. +// The old course switched away, which looked like progress. +{ + const adrift = { at: new THREE.Vector3(0, 0, -4000), velocity: new THREE.Vector3() }; + const collect = new CoursePilot() + .step(view(new THREE.Vector3(0, 0, -50_000), { course: 'collect', loot: [adrift] }), 1 / 60); + check('a canister 4,000 units off still opens the throttle', + collect.demand?.throttle === 1); + check('...and the cap is under half what the ship can fly', + COURSE_COLLECT_CAP < PLAYER_FLIGHT.maxSpeed / 2, + `${COURSE_COLLECT_CAP} against ${PLAYER_FLIGHT.maxSpeed}`); + check('...and its turning circle is inside twice the scoop', + COURSE_COLLECT_CAP / PLAYER_FLIGHT.maxPitch < SCOOP_RANGE * 2, + `${(COURSE_COLLECT_CAP / PLAYER_FLIGHT.maxPitch).toFixed(0)} units against ${SCOOP_RANGE}`); + check('...while still fast enough to catch a canister at its top drift', + COURSE_COLLECT_CAP > 45, `${COURSE_COLLECT_CAP}`); +} diff --git a/test/course-fixtures.ts b/test/course-fixtures.ts new file mode 100644 index 00000000..c3a62bac --- /dev/null +++ b/test/course-fixtures.ts @@ -0,0 +1,90 @@ +// The fixtures the course tests share: a flat view, two arrivals and a flight. +// +// A fixture module rather than a block in one file, for the reason +// `audio-fixtures.ts` is one. `course-pilot.test.ts` and +// `course-arrivals.test.ts` split on 2026-09-12, and both need the same four. A +// second copy would be two fixtures that drift, and a fixture that disagrees +// with its twin measures nothing. + +import * as THREE from 'three'; +import { Game } from '../src/game/game.ts'; +import { headlessShell } from '../src/engine/shell.ts'; +import { withoutSaving } from '../src/game/storage.ts'; +import { seedWorld } from '../src/game/rng.ts'; +import type { CourseView } from '../src/game/course-pilot.ts'; +import { DOCK_COMPUTER_RANGE } from '../src/constants/docking-computer.ts'; +import { dismissBriefing } from './harness.ts'; + +export /** A ship at the origin, nose down −Z, and a station somewhere. */ +const view = (station: THREE.Vector3, over: Partial = {}): CourseView => ({ + course: 'station', + position: new THREE.Vector3(), + quaternion: new THREE.Quaternion(), + pitchRate: 0, + rollRate: 0, + speed: 0, + stationPos: station, + planetPos: new THREE.Vector3(0, 1e7, 0), + planetRadius: 5000, + sunPos: new THREE.Vector3(1e7, 0, 0), + derelictPos: null, + derelictSpeed: 0, + hermitPos: null, + tankFull: false, + threats: [], + obstacles: [], + loot: [], + police: [], + mission: null, + dcEngaged: false, + handOverRange: DOCK_COMPUTER_RANGE, + ...over, +}); + +export /** A commander who arrives at the witchpoint with an empty sky. */ +function arrived(seed: number): Game { + const g = withoutSaving(() => { + seedWorld(seed); + const game = new Game(() => headlessShell()); + dismissBriefing(game); + game.launch(); + game.arriveInSystem(); + return game; + }).value; + g.state.world.clearNpcs(); + return g; +} + +export /** A commander at the witchpoint of a system whose sky holds this role. */ +function arrivedWith(role: string): Game { + for (let i = 0; i < 200; i++) { + const g = withoutSaving(() => { + seedWorld(4000 + i); + const game = new Game(() => headlessShell()); + dismissBriefing(game); + game.launch(); + game.state.commander.systemIndex = (i * 29) % 256; + game.arriveInSystem(); + return game; + }).value; + if (g.state.world.npcs.some((n) => n.role === role)) { + // Only the target stays, so that no fight or mass lock blurs the claim. + for (const n of g.state.world.npcs) if (n.role !== role) n.state.alive = false; + return g; + } + } + throw new Error(`no system in the sample holds a ${role}`); +} + +export /** Fly the picked course until it ends, the ship dies, or the time runs out. */ +function fly(g: Game, seconds: number, until: () => boolean): number { + const dt = 1 / 60; + let f = 0; + withoutSaving(() => { + for (let at = 0; f < seconds / dt; f++) { + g.step(dt, at += dt); + if (until() || g.mode === 'dead') break; + } + }); + return f * dt; +} diff --git a/test/course-pilot.test.ts b/test/course-pilot.test.ts index ed353bce..3701c2c0 100644 --- a/test/course-pilot.test.ts +++ b/test/course-pilot.test.ts @@ -7,52 +7,21 @@ // the slot. import * as THREE from 'three'; -import { Game } from '../src/game/game.ts'; -import { headlessShell } from '../src/engine/shell.ts'; import { withoutSaving } from '../src/game/storage.ts'; -import { seedWorld } from '../src/game/rng.ts'; -import { CoursePilot, type CourseView } from '../src/game/course-pilot.ts'; +import { CoursePilot } from '../src/game/course-pilot.ts'; import { clearOfPlanet } from '../src/game/course-clearance.ts'; -import { COURSE_DERELICT_STANDOFF, COURSE_PLANET_CLEARANCE } from '../src/constants/course.ts'; -import { HERMIT_DOCK_SPEED } from '../src/constants/hermit-market.ts'; -import { CABIN_TEMP_FATAL } from '../src/constants/sun.ts'; -import { MAX_FUEL } from '../src/constants/commander.ts'; +import { COURSE_PLANET_CLEARANCE } from '../src/constants/course.ts'; import { SPAWN_PLANET_ALTITUDE } from '../src/constants/spawn-placement.ts'; import { aboveGround } from '../src/game/spawning.ts'; -import { derelictReport } from '../src/game/derelict.ts'; -import { generateGalaxy } from '../src/galaxy/galaxy.ts'; import { DOCK_COMPUTER_RANGE } from '../src/constants/docking-computer.ts'; import { COURSE_DOCK_HANDOVER } from '../src/constants/course.ts'; import { MASS_LOCK_STATION } from '../src/constants/torus.ts'; -import { check, dismissBriefing, eq } from './harness.ts'; +import { keyCodeIfBound } from '../src/ui/key-help.ts'; +import { arrived, fly, view } from './course-fixtures.ts'; +import { check, eq } from './harness.ts'; console.log('\nthe course pilot, one frame at a time'); -/** A ship at the origin, nose down −Z, and a station somewhere. */ -const view = (station: THREE.Vector3, over: Partial = {}): CourseView => ({ - course: 'station', - position: new THREE.Vector3(), - quaternion: new THREE.Quaternion(), - pitchRate: 0, - rollRate: 0, - speed: 0, - stationPos: station, - planetPos: new THREE.Vector3(0, 1e7, 0), - planetRadius: 5000, - sunPos: new THREE.Vector3(1e7, 0, 0), - derelictPos: null, - derelictSpeed: 0, - hermitPos: null, - tankFull: false, - threats: [], - obstacles: [], - loot: [], - police: [], - mission: null, - dcEngaged: false, - handOverRange: DOCK_COMPUTER_RANGE, - ...over, -}); { const pilot = new CoursePilot(); @@ -88,24 +57,13 @@ const view = (station: THREE.Vector3, over: Partial = {}): CourseVie console.log('\nthe station course, flown from the witchpoint'); -/** A commander who arrives at the witchpoint with an empty sky. */ -function arrived(seed: number): Game { - const g = withoutSaving(() => { - seedWorld(seed); - const game = new Game(() => headlessShell()); - dismissBriefing(game); - game.launch(); - game.arriveInSystem(); - return game; - }).value; - g.state.world.clearNpcs(); - return g; -} +// THE COMPUTER IS A BUTTON, NOT AN AUTOMATIC (Chris, 2026-09-12: *"I have a +// docking computer - but instead of it being activated I still get the lining +// and only once that is done does the computer activate"*). Every commander +// gets the line-up, and a fitted computer flies the rest when she asks for it. +// The block below flies the same course with nobody pressing anything. { - // A fitted docking computer flies the slot, as it does today. Without one, - // the course hands the ship to the pilot instead (docs/TODO/207 M1), and - // the block below flies that. const g = arrived(20_260_911); g.state.commander.equipment.dockingComputer = true; const start = g.state.player.position.distanceTo(g.state.world.station.position); @@ -116,12 +74,18 @@ function arrived(seed: number): Game { let torusSeen = false; let handOverAt = -1; let dockedAt = -1; + let pressed = false; const dt = 1 / 60; const limit = 180 / dt; withoutSaving(() => { for (let f = 0, at = 0; f < limit; f++) { g.step(dt, at += dt); if (g.state.session.torusEngaged) torusSeen = true; + // The pilot presses the button the moment it is offered. + if (!pressed && g.state.session.dockTrial) { + g.input.injectPress(keyCodeIfBound('flight', 'toggleDockingComputer') ?? ''); + pressed = true; + } if (handOverAt < 0 && g.state.session.dcEngaged) { handOverAt = g.state.player.position.distanceTo(g.state.world.station.position); } @@ -129,9 +93,9 @@ function arrived(seed: number): Game { } }); check('the course ran the torus on the way in', torusSeen); - check('...it handed over inside the docking computer\'s range', + check('...the button then engaged the computer, inside its range', handOverAt > 0 && handOverAt <= DOCK_COMPUTER_RANGE + 50, `${Math.round(handOverAt)} units`); - check('...and the ship docked inside three minutes, with no hand on the stick', + check('...and it flew the ship in, inside three minutes', dockedAt > 0 && g.mode === 'docked', `mode ${g.mode}, ${dockedAt.toFixed(1)} s`); eq('...and the dock ends the visit, so no course is left', g.state.session.course, null); } @@ -204,95 +168,6 @@ console.log('\nevery line goes round the planet'); check('a line that clears the planet aims at the target itself', out.equals(clear)); } -/** A commander at the witchpoint of a system whose sky holds this role. */ -function arrivedWith(role: string): Game { - for (let i = 0; i < 200; i++) { - const g = withoutSaving(() => { - seedWorld(4000 + i); - const game = new Game(() => headlessShell()); - dismissBriefing(game); - game.launch(); - game.state.commander.systemIndex = (i * 29) % 256; - game.arriveInSystem(); - return game; - }).value; - if (g.state.world.npcs.some((n) => n.role === role)) { - // Only the target stays, so that no fight or mass lock blurs the claim. - for (const n of g.state.world.npcs) if (n.role !== role) n.state.alive = false; - return g; - } - } - throw new Error(`no system in the sample holds a ${role}`); -} - -/** Fly the picked course until it ends, the ship dies, or the time runs out. */ -function fly(g: Game, seconds: number, until: () => boolean): number { - const dt = 1 / 60; - let f = 0; - withoutSaving(() => { - for (let at = 0; f < seconds / dt; f++) { - g.step(dt, at += dt); - if (until() || g.mode === 'dead') break; - } - }); - return f * dt; -} - -console.log('\nthe derelict course'); -{ - const g = arrivedWith('generation'); - g.state.session.course = 'derelict'; - fly(g, 300, () => g.state.session.course === null); - const gen = g.state.world.npcs.find((n) => n.role === 'generation')!; - const dist = g.state.player.position.distanceTo(gen.object.position); - check('the ship stops at the standoff from the generation ship', - Math.abs(dist - COURSE_DERELICT_STANDOFF) < 200, `${Math.round(dist)} units`); - check('...at the derelict\'s own drift', Math.abs(g.state.player.speed - gen.state.speed) < 10, - `${g.state.player.speed.toFixed(1)} u/s against ${gen.state.speed.toFixed(1)}`); - check('...and the course is done for the visit', g.state.session.coursesDone.includes('derelict')); - check('...and the scan says what is there, in the world\'s own words', - g.state.session.messageText.length > 20, `said: ${g.state.session.messageText}`); -} - -console.log('\nwhat a derelict\'s scan reports'); -{ - // The words come off the world's seed, so a derelict tells the same story - // on every visit, and two worlds tell different ones (docs/TODO/208 M5). - const systems = generateGalaxy(1); - const twice = [derelictReport(systems[7]), derelictReport(systems[7])]; - eq('the same world reports the same thing twice', twice[0], twice[1]); - const said = new Set(systems.map((sys) => derelictReport(sys))); - check('...and the galaxy tells more than one story', said.size > 3, `${said.size} of them`); - check('...each of them a sentence', [...said].every((line) => line.endsWith('.'))); -} - -console.log('\nthe hermit course'); -{ - const g = arrivedWith('hermit'); - g.state.session.course = 'hermit'; - fly(g, 400, () => g.state.session.hermitTrading); - check('the hermit opens his trade at the end of the course', g.state.session.hermitTrading); - check('...with the ship slow enough for the hermit\'s rule', - g.state.player.speed < HERMIT_DOCK_SPEED, `${g.state.player.speed.toFixed(1)} u/s`); - check('...and the ship never struck the rock', g.state.sys.foreShield > 0 && g.mode !== 'dead'); -} - -console.log('\nthe star course'); -{ - const g = arrived(20_260_913); - g.state.commander.equipment.scoops = true; - g.state.commander.fuel = 5; - g.state.session.course = 'skim'; - let peak = 0; - fly(g, 400, () => { - peak = Math.max(peak, g.state.sys.cabinTemp); - return g.state.session.course === null; - }); - eq('the star course fills the tank', g.state.commander.fuel, MAX_FUEL); - check('...the ship lives, and the cabin stays short of fatal', - g.mode !== 'dead' && peak < CABIN_TEMP_FATAL * 0.6, `peak ${peak.toFixed(3)}`); - check('...and the course is done for the visit', g.state.session.coursesDone.includes('skim')); -} console.log('\nthe station course goes round a planet in its way'); { @@ -304,8 +179,14 @@ console.log('\nthe station course goes round a planet in its way'); g.state.player.position.copy(w.planetPos).addScaledVector(through, -(w.planetRadius * 8)); g.state.session.course = 'station'; let lowest = Infinity; + let pressed = false; fly(g, 400, () => { lowest = Math.min(lowest, g.state.player.position.distanceTo(w.planetPos) - w.planetRadius); + // The line-up is the pilot's until she asks for the computer. + if (!pressed && g.state.session.dockTrial) { + g.input.injectPress(keyCodeIfBound('flight', 'toggleDockingComputer') ?? ''); + pressed = true; + } return g.mode !== 'flight'; }); check('the ship never flies lower than the clearance', lowest > COURSE_PLANET_CLEARANCE * 0.9, @@ -329,60 +210,3 @@ console.log('\nnothing appears inside the planet'); check('...and a ship placed well clear of it appears where it was placed (the control)', aboveGround(w, high).distanceTo(high) < 1e-6); } - -// --- THE COLLECT COURSE HOLDS ONE CANISTER, AND LEADS IT ------------------- -// -// Chris, 2026-09-12: *"Collecting cargo often seems to be difficult - we miss -// it quite a lot - especially when it is moving."* -// -// Two faults, and a probe named them by flying ONE canister against five. One -// alone was never missed, at any drift. Five were missed seven times with the -// cargo at rest. So the first fault was the PICK: the course took the nearest -// every frame, and turned away from a canister it was nearly on when another -// drifted closer. The second was the AIM, which was where the canister had -// been. -// -// Both are asserted on the RULE rather than through a two-minute flight. The -// flight is what measured them, and its figures are beside -// `COURSE_COLLECT_LEAD`: over 80 runs a drift, the led course took 231 of 240 -// canisters against 191 unled. -console.log('\nthe collect course holds one canister, and leads it'); -{ - const DT = 1 / 60; - const far = new THREE.Vector3(0, 0, -50_000); - const still = (at: THREE.Vector3) => ({ at, velocity: new THREE.Vector3() }); - const ahead = new THREE.Vector3(0, 0, -600); - const aside = new THREE.Vector3(1400, 0, -600); - - // THE PICK. A canister dead ahead asks for no turn. One off to the side asks - // for a big one. So the demand says which of the two the course is flying at. - const turn = (s: { demand: { pitchRate: number; rollRate: number } | null }): number => - Math.abs(s.demand?.pitchRate ?? 0) + Math.abs(s.demand?.rollRate ?? 0); - - const fresh = new CoursePilot(); - const onAhead = turn(fresh.step(view(far, { course: 'collect', loot: [still(ahead)] }), DT)); - const onAside = turn(new CoursePilot() - .step(view(far, { course: 'collect', loot: [still(aside)] }), DT)); - check('the fixture can tell the two apart', onAside > onAhead + 0.01, - `${onAhead.toFixed(3)} ahead against ${onAside.toFixed(3)} aside`); - - const held = new CoursePilot(); - held.step(view(far, { course: 'collect', loot: [still(aside)] }), DT); - // ...and now a nearer one turns up, first in the list. - const kept = turn(held.step( - view(far, { course: 'collect', loot: [still(ahead), still(aside)] }), DT)); - check('a nearer canister does not steal one the course is already on', - kept > onAhead + 0.01, `${kept.toFixed(3)}, against ${onAhead.toFixed(3)} for the near one`); - - // ...until it is gone, and then the nearest is the next. - const moved = turn(held.step(view(far, { course: 'collect', loot: [still(ahead)] }), DT)); - check('...and when it is aboard, the course takes the next', moved <= onAhead + 0.01, - `${moved.toFixed(3)}`); - - // THE AIM. A canister dead ahead and drifting sideways is not where it was. - const drifting = { at: ahead.clone(), velocity: new THREE.Vector3(200, 0, 0) }; - const led = turn(new CoursePilot() - .step(view(far, { course: 'collect', loot: [drifting] }), DT)); - check('a drifting canister is aimed ahead of, not at', led > onAhead + 0.01, - `${led.toFixed(3)}, against ${onAhead.toFixed(3)} for the same place at rest`); -} diff --git a/test/run.ts b/test/run.ts index 97af90dc..a9d2bf23 100644 --- a/test/run.ts +++ b/test/run.ts @@ -74,6 +74,7 @@ import './prompts.test.ts'; import './courses.test.ts'; import './course-pilot.test.ts'; import './course-clearance.test.ts'; +import './course-arrivals.test.ts'; import './course-launch.test.ts'; import './course-buttons.test.ts'; import './skip.test.ts'; From 9f7f8d3cbbf6da8f65f7d47c7fa6e792a0f3711c Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Sun, 13 Sep 2026 09:17:37 +0100 Subject: [PATCH 061/100] Two reviews read the missions, and two plans answer them docs/MISSIONS-REVIEW.md reads the mission machine and its data. The machine is sound. Five rules around it do not hold: an arc is offered in every galaxy at its seed index, a side job is offered one time per career, a smuggling run keeps the goods, the word `fled` reaches no leg that answers it, and the side-job count silences the patron's messages. docs/MISSIONS-FLIGHT-REVIEW.md flies every kind of job in a real headless game, eight times each. The ship finishes 92 runs of 96. A hunt is over in four to thirteen seconds. The escort's charge flees for ever after one hit, and the course followed it into the planet once. The probes and their output are under docs/reviews/missions-2026-09-12. Chris read both on 2026-09-13 and said "let's fix the broken parts", and then "there should be surprises". docs/TODO/213 is the fixes, in five milestones. docs/TODO/214 is the surprises. Both are queued. Co-Authored-By: Claude Fable 5.1 Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- docs/MISSIONS-FLIGHT-REVIEW.md | 308 +++++++++++++++ docs/MISSIONS-REVIEW.md | 355 ++++++++++++++++++ ...hold-and-a-hit-trader-goes-back-to-work.md | 180 +++++++++ docs/TODO/214-a-job-has-a-surprise-in-it.md | 136 +++++++ docs/TODO/QUEUE.json | 5 +- docs/TODO/README.md | 11 +- .../missions-2026-09-12/escort-probe.ts | 79 ++++ .../missions-2026-09-12/escort-results.txt | 311 +++++++++++++++ .../missions-2026-09-12/flight-probe.ts | 228 +++++++++++ .../missions-2026-09-12/flight-results.txt | 45 +++ docs/reviews/missions-2026-09-12/probe.ts | 146 +++++++ docs/reviews/missions-2026-09-12/results.txt | 61 +++ 12 files changed, 1863 insertions(+), 2 deletions(-) create mode 100644 docs/MISSIONS-FLIGHT-REVIEW.md create mode 100644 docs/MISSIONS-REVIEW.md create mode 100644 docs/TODO/213-the-mission-rules-hold-and-a-hit-trader-goes-back-to-work.md create mode 100644 docs/TODO/214-a-job-has-a-surprise-in-it.md create mode 100644 docs/reviews/missions-2026-09-12/escort-probe.ts create mode 100644 docs/reviews/missions-2026-09-12/escort-results.txt create mode 100644 docs/reviews/missions-2026-09-12/flight-probe.ts create mode 100644 docs/reviews/missions-2026-09-12/flight-results.txt create mode 100644 docs/reviews/missions-2026-09-12/probe.ts create mode 100644 docs/reviews/missions-2026-09-12/results.txt diff --git a/docs/MISSIONS-FLIGHT-REVIEW.md b/docs/MISSIONS-FLIGHT-REVIEW.md new file mode 100644 index 00000000..2914cfb0 --- /dev/null +++ b/docs/MISSIONS-FLIGHT-REVIEW.md @@ -0,0 +1,308 @@ +# The ship finishes every job, and the job is over before the player arrives + +Review date: 13 September 2026. Source revision: `cb7785b`. Part two of +[`MISSIONS-REVIEW.md`](MISSIONS-REVIEW.md), which reviewed the machine and its +data. This part asks two questions about the flight. Can a player succeed? Is +it fun? + +**The mechanisms are there.** A fresh commander with a pulse laser can finish +every one of the eight kinds of job with the ship's own automation. The sky +is as shipped, with ordinary traffic. The probe flew each kind eight times and +finished 92 runs of 96. The four that did not finish are all escorts. + +**The fun is the problem.** A hunt is over in four to thirteen seconds. The +target comes to the commander, the computer aims, and a pulse laser kills a +Krait before the arrival line leaves the console. Five of the eight kinds +resolve in under thirty seconds with no decision in them. Every leg then ends +with the same two-minute flight to the station. The escort is the one long +job, and it is long because a Python is slow. No production code changed +during this review. + +## Scope and measurement + +Two probes sit beside part one's in +[`reviews/missions-2026-09-12/`](reviews/missions-2026-09-12/). + +[`flight-probe.ts`](reviews/missions-2026-09-12/flight-probe.ts) runs a real +headless game. A fresh commander holds one live leg whose work is in the +system she arrives in. Ordinary traffic stays in the sky. The probe presses +the job's own button. It holds the trigger while the computer aims. It +presses the button again when a fight dropped the course. It presses the +docking computer when the station course hands over. Scoops are fitted for a scoop. +A docking computer is fitted for a leg that ends at the station, because the +probe has no hands for the slot. Each kind is flown eight times, on eight +different days, so the arrival seeds eight different skies. The output is +[`flight-results.txt`](reviews/missions-2026-09-12/flight-results.txt). + +[`escort-probe.ts`](reviews/missions-2026-09-12/escort-probe.ts) traces the +escort runs that stalled, ten seconds at a time. The output is +[`escort-results.txt`](reviews/missions-2026-09-12/escort-results.txt). + +The numbers below are sim seconds from the end of the arrival. They do not +include the jump, the tunnel, or the slot. + +| job | done | failed | dead | stalled | time to done | fights on the way | ship after | +| --- | ---: | ---: | ---: | ---: | ---: | ---: | --- | +| hunt a Krait | 8 | 0 | 0 | 0 | 4 s | 1.0 | full | +| hunt a Cobra Mk III (Lave arc) | 8 | 0 | 0 | 0 | 4 s | 1.0 | full | +| hunt a Fer-de-Lance (Xeer arc) | 8 | 0 | 0 | 0 | 8 s | 1.0 | fore shield 162 of 255 | +| hunt an Asp (Edle arc) | 8 | 0 | 0 | 0 | 12 s | 1.0 | fore shield 105 of 255 | +| hunt the Constrictor | 8 | 0 | 0 | 0 | 62 s | 1.0 | energy 213, shields 130 and 219 | +| scan an Anaconda for 20 s | 8 | 0 | 0 | 0 | 24 s | 0.1 | full | +| escort a Python to station range | 4 | 0 | 1 | 3 | 497 s | 0.3 | full | +| scoop a canister | 8 | 0 | 0 | 0 | 14 s | 0.3 | full | +| scoop a pod | 8 | 0 | 0 | 0 | 13 s | 0.1 | full | +| clear the lane, then dock | 8 | 0 | 0 | 0 | 130 s | 3.1 | full | +| deliver: fly to the station and dock | 8 | 0 | 0 | 0 | 125 s | 1.4 | full | +| smuggle: slip past the police and dock | 8 | 0 | 0 | 0 | 116 s | 2.6 | full | + +A first batch of the smuggle run, before the days were varied, was scanned in +two runs of eight. The second batch was scanned in none. So the police read +the hold in about one run in eight. + +## What a job costs the player, in time + +A job has six parts, and only one of them is the job. + +1. **The offer.** The MISSIONS screen lists the title, the briefing pages, + the patron and the fee. One button accepts. +2. **The chart.** A diamond marks the world. The readout under the cursor + says how many days away it is. A launch with no destination is refused. +3. **The jump.** The countdown is five seconds, and then the tunnel. +4. **The job.** The arrival line says where the target is, in units and a + bearing. The first course button says what to do about it, in the job's + words. Four to twenty-seven seconds pass, and the console says the leg + moved. +5. **The station.** The station is 62,000 to 82,000 units from the + witchpoint. The station course takes 95 to 145 seconds, and one to three + pirate waves drop it on the way. Fast forward runs eight times faster + while no hostile ship is near. +6. **The slot.** A commander without a docking computer matches the + station's roll and the speed by hand. A docking computer costs 1,500 + credits. + +So a side job is about two minutes of flight with a few seconds of job in +it. The escort is the one exception, at eight and a half minutes. + +| job | pays | the job's own seconds | seconds to the station | +| --- | ---: | ---: | ---: | +| hunt | 800 Cr | 4 | 125 | +| ambush | 600 Cr | 0, and the lane fight on the way | 130 | +| smuggle | 700 Cr | 0 | 116 | +| escort | 600 Cr | 497 | 0 | +| rescue | 500 Cr | 13 | 125 | +| recover | 400 Cr | 14 | 125, and the origin world after | +| deliver | 300 Cr | 0 | 125 | +| scan | 250 Cr | 24 | 125 | + +A Cobra with twenty tonnes clears about 200 credits on a good trade jump. A +hunt pays four of those for one jump. The pull is strong. Part one found +that each side job is offered one time per career, so the pull stops after +eight jobs. + +## 1. High priority: a hunt is over in seconds, and nothing threatens the ship + +**Evidence:** the table above, [`mission-course.ts`](../src/game/mission-course.ts), +[`flight-course.ts`](../src/game/flight-course.ts), +[`autopilot.ts:168`](../src/game/autopilot.ts#L168). + +The target spawns 2,500 to 4,500 units from the witchpoint. It is a pirate, +so it turns to attack the commander. The mission course picks it as the +target, the computer engages by itself, and the aim holds it in the sights. +The probe holds the trigger. A Krait dies in four seconds and a Cobra Mk III +in four. An Asp, the fastest and best-armed hull an arc names, dies in +twelve. The ship ends every hunt with full energy, and only the Asp and the +Fer-de-Lance mark a shield. + +The Constrictor is the same story, one minute long. The gun warning says a +pulse laser needs 115 unbroken hits, and it is right. It does not matter. +The computer's aim gives 115 unbroken hits in a minute, and the ship ends +with energy 213 and shields 130 and 219. + +The warning itself is wrong on every other hunt. `huntWarning` says TARGET +ARMOUR HALVES LASER FIRE for any target where a military laser scores more +than the fitted one. That is every ship, so every side hunt and every arc +hunt says it. Only the Constrictor halves a hit. + +**What this means for the player.** The hunt was the 1984 game's whole +content. Here the decision is one press, and the outcome is never in doubt. +A pilot who holds the trigger cannot lose a hunt with the starting gun. + +**Recommended changes.** The fight has to be the content, or the hunt has to +be a chase. + +- A hunted ship does not come to the commander. It runs, and the commander + runs it down. Part one found that a pirate never leaves the system, so the + escape branches the skeletons already carry are dead. A target that CAN + leave makes the four seconds count. +- A hunted ship flies with company. The lane already spawns three pirates + beside a job, and that job is the one with a fight in it. +- The tier tables that scale ordinary pirates to the commander's standing + can scale a mission target too. +- The warning names the Constrictor's halving on the Constrictor alone. + +## 2. High priority: the escort's charge flees for ever, and the course follows it into the planet + +**Evidence:** [`escort-results.txt`](reviews/missions-2026-09-12/escort-results.txt), +[`npc.ts:793`](../src/game/npc.ts#L793), +[`npc-trader.ts`](../src/game/npc-trader.ts), +[`world-step.ts:590`](../src/game/world-step.ts#L590), +[`course-pilot.ts`](../src/game/course-pilot.ts). + +Three escorts of eight stalled, and one killed the commander. The traces +show one cause. A trader that takes a hit from anybody sets `fleeing`, and +nothing ever clears it. A fleeing trader runs from the point of the hit at +full speed for the rest of its life. It never returns to its working life. So it never comes inside station range, and the leg never ends. + +Seed 1 met a pirate wave at fifty seconds. The charge took a hit in the +crossfire. From sixty seconds to six hundred it flew at 160 units a second. It went +between 34,000 and 39,000 units from the station, and back. The commander +was 370 units behind it. + +Seed 2 met nobody. At twenty seconds the commander's fore shield was 165 of +255 and the charge was fleeing. The escort course rammed it. The course +flies to a standoff of 600 units at the charge's own speed, and the approach +overshoots into the hull. A ram is a hit from the commander, so the charge +fled from her, and it fled for 580 seconds more. + +Seed 5 ended with CRASHED INTO THE PLANET at 559 seconds. The ship had full +energy and full shields, 80 units above the surface at 89 units a second. The +fleeing charge flew through the planet, because a ship does not crash. The +escort course aimed 600 units short of it. The course steers round the +planet on the way to a target. It does not refuse a target that is below +the clearance altitude. + +The four escorts that finished took 464 to 559 seconds. A Python flies to +the station at 136 units a second, and the station is 72,000 units away. +That is eight and a half minutes beside a ship that needs nothing from the +commander until something shoots it. Fast forward would cut it to about a +minute, and nothing on the screen says so. + +**Recommended changes.** + +- `fleeing` clears after some seconds with no attacker alive and no shot + fired. A trader that was hit once should go back to work. +- The escort standoff cannot ram. The approach speed near the charge is + capped, as the collect course caps its own. +- A course refuses a target below the planet's clearance altitude, and says + so, rather than fly the commander after it. +- The charge waits for the commander, or moves only while she is within some + distance. Plan 208 named this fault and left it. Until then the escort is + a job the commander watches. +- The charge starts nearer the station, or flies at the commander's pace, so + the leg is two minutes rather than nine. + +## 3. Medium priority: the tour opens with a job a new commander cannot fly + +**Evidence:** [`lave.ts:29`](../src/missions/skeletons/arcs/lave.ts#L29), +[`side.ts`](../src/missions/skeletons/side.ts), +[`course-actions.ts:220`](../src/game/course-actions.ts#L220), +[`shop.ts:57`](../src/constants/shop.ts#L57). + +A new commander starts with 100 credits, a pulse laser and no fuel scoops. +Fuel scoops cost 525 credits at a world of tech level five or more. Three of +the eight side jobs are a scoop, and so is the first leg of the Lave arc. The +Lave arc has no gate, so its hail is the first thing a new commander hears at +Lave. She accepts it, jumps, and reads NEEDS FUEL SCOOPS on the one button +that matters. The row is honest, and the arc holds a slot for thirty days. + +The arc has a way round. A canister shot before the scoop turns the leg into +a scan, and then into a hunt. Nothing tells her that the way round exists, +and shooting the patron's ledger is not a thing a new player tries. + +**Recommended changes.** Gate the arc on the scoops, on a kill count, or on +credits. Or open the tour with a leg that needs nothing: a delivery, a lane, +or a hunt. The recovery can be the second leg. + +## 4. Medium priority: every leg is the same two-minute flight to the station + +**Evidence:** the second table, [`courses.ts`](../src/game/courses.ts), +[`course-actions.ts`](../src/game/course-actions.ts). + +The job is four to twenty-seven seconds. The flight to the station is 95 to +145 seconds, and one to three pirate waves interrupt it. The waves are the +same waves a commander meets with no job. So the play a job adds is a few +seconds at the witchpoint, and the play that fills the time is the ordinary +lane. + +The lane job is the one whose content is on the way. Three pirates wait for +the commander, the fight takes the course, and the station is the end. It +finished eight of eight with no death and full shields, so it is not hard. +It is the right shape. + +**Recommended change.** Put the job where the time is. A target near the +station, or on the line to it, makes the flight the job. A hunt that starts +when the commander is half way in is a hunt that interrupts something. + +## 5. Low priority: the smuggling run is scanned one time in eight + +**Evidence:** [`course-pilot.ts`](../src/game/course-pilot.ts), +[`course-clearance.ts`](../src/game/course-clearance.ts), +[`world-step.ts:870`](../src/game/world-step.ts#L870). + +The slip course aims wide of every policeman within two scanner ranges, at +4,400 units, outside the 2,600 units a Viper reads a hold at. It worked in +fourteen runs of sixteen. A Viper that spawns on the final approach, inside +the hand-over, still reads the hold. That is a fair risk for 700 credits. +The failure says what the police found, and the machine says the job is +lost. + +## 6. Low priority: the scan and the two scoops are short and sure + +The Anaconda waits near the station and never leaves. The hold course keeps +it in view, and the count runs. Twenty-four seconds, eight of eight. A +canister and a pod are scooped in thirteen to fourteen seconds, eight of +eight, with scoops fitted. Without them the row says NEEDS FUEL SCOOPS and +refuses. Mechanically these are sound. As content, a scan is twenty seconds +of a number that counts up. + +## The words the player reads + +The dossiers are good. THE GOVERNOR'S MISSING LEDGER has three briefing +pages in the patron's voice. Each leg has an arrive line, a success line and +a failure line, with the world and the fee in them. KRAIT ON THE LANE +says who asks and what it pays in two sentences. The arrival line says +where the target is, in units and a bearing. The course button says HUNT THE +KRAIT. The console says the count of a scan and the tonnes of a smuggling +load. A player is never lost for what to do next. + +Two lines are wrong. The gun warning is finding 1. The hail THERE ARE N +SIDE JOBS ON THE STATION BOARD is said on every dock where any are open. It +hides the patron's messages, which is part one's finding 5. + +## Is it fun? + +Not yet. The pieces are all present, and each one is sound. Together they +make a loop in which the player decides one thing, and then watches. + +- **The decision is the accept.** After it, the player presses the one row + the situation offers. She holds a button while the computer aims. She + presses the station row. No job asks a second question. +- **The threat is gone.** The computer's aim and the auto-engage make every + fight a matter of the trigger. A fresh commander with a pulse laser + came through 95 runs of 96 alive, and the one death was a crash. The lane's + three pirates took nobody. +- **Failure costs nothing.** Standing moves and nothing reads it. A deadline + is fourteen or thirty days, and a jump is one to three. A failed job is a + fee not earned. +- **The choice trigger exists and no skeleton uses it.** The machine can + put a question to the player mid-arc. None of the five arcs does. +- **The travel is the game, and fast forward skips it.** The flight to the + station is where the pirates are. The job is over before it starts. + +**What would make it fun**, in the order a plan would take them: + +1. Make the hunt a chase. A target that runs, or that has to be found with + a scan first, turns four seconds into a pursuit with a scanner. +2. Make the escort about position. The charge moves while the commander is + near, and stops when she is not. Then the escort is hers. +3. Ask a question. The `choice` trigger is built and tested. One choice per + arc, with a consequence the log tells, is a story. +4. Let standing mean something. A patron who remembers a failure offers + less, or nothing. A patron who remembers a success opens the next arc a + jump early. +5. Put the job on the way in, not at the witchpoint. + +The arcs give the game a spine, and the log tells the path a player took. +The words are there. What is missing is a moment in each job where the +player can get it wrong. diff --git a/docs/MISSIONS-REVIEW.md b/docs/MISSIONS-REVIEW.md new file mode 100644 index 00000000..3137b716 --- /dev/null +++ b/docs/MISSIONS-REVIEW.md @@ -0,0 +1,355 @@ +# The mission machine is sound, and five rules around it do not hold + +Review date: 12 September 2026. Source revision: `cb7785b`. Part one of two. +Part two, [`MISSIONS-FLIGHT-REVIEW.md`](MISSIONS-FLIGHT-REVIEW.md), reviews +how a job is flown, and whether it is fun. + +The machine itself is in good shape. One pure step reads an event and returns +a new record with its effects. The bridge applies the effects one time, before +any save. The lint gate is proved able to fail. The suite passes 5,972 checks. + +The faults sit around the machine, in the data and the wiring. Four are high +priority. An arc is offered in every galaxy at its seed index. A side job is +offered one time per career, and the rule says it comes back. A smuggling run +pays and leaves the goods aboard. The word `fled` reaches no leg that answers +it. No production code changed during this review. + +## Scope and measurement + +The review read every file under [`src/missions/`](../src/missions/). It read +the six game-side modules that feed the machine, the mission constants and the +skeletons. It read the mission tests and the plans 190, 192, 203 and 208. + +Every claim below was checked against the code that runs. Ten claims were +also driven through the real machine with no game world, as +[`test/mission-machine.test.ts`](../test/mission-machine.test.ts) does. The +probe is [`reviews/missions-2026-09-12/probe.ts`](reviews/missions-2026-09-12/probe.ts), +and its output is [`results.txt`](reviews/missions-2026-09-12/results.txt) +beside it. A finding names its probe block in brackets. + +## 1. High priority: an arc is offered in every galaxy at its seed index + +**Evidence:** [`offers.ts:59`](../src/missions/offers.ts#L59), +[`offers.ts:71`](../src/missions/offers.ts#L71), +[`model.ts:183`](../src/missions/model.ts#L183), +[`lave.ts:29`](../src/missions/skeletons/arcs/lave.ts#L29). Probe [1]. + +A world patron is a seed slot, and a seed slot is an index. Every galaxy has +an index 7. `nearHome` compares the commander's index with that slot, and the +five arcs carry no `galaxy` gate. Only the Constrictor does. The comment on +`Gate.galaxy` says that a world patron is already in one galaxy. The code +does not hold that. + +The probe stands the commander at index 7 of galaxy 2, which is Esrilees. The +offer list holds `arc-lave`. The hail says THE GOVERNOR OF LAVE HAS A JOB FOR +YOU. The patron reads THE COMPANY DIRECTOR OF ESRILEES. The dossier's pages +name Lave. The player reads three names for one person. + +The same fault reaches the tour after a galactic jump. The machine moves each +lead to the tour world of the new galaxy, as +[`tour.ts`](../src/missions/tour.ts) intends. The arc that lead opens then +places its handover leg toward a seed index in the new galaxy. Its own lead +points at a seed index too. The probe accepts the relocated Rabedira arc +in galaxy 2. Its convoy leg lands four jumps from galaxy-2 index 100, which is +not a tour world. The tour holds for one arc and then drifts. + +There are two ways out, and the choice is Chris's. The first gates every +world-patron skeleton to galaxy 1 and makes the lint refuse one without a +gate. The relocation on a galactic jump then has no arc to relocate, and the +comment on `tour.ts` about islands goes. The second gives `PatronRef.world` a +galaxy beside its slot. It then derives the hail, the pitch and the dossier +from the world rather than from a fixed name. The second is the larger change and +the one the tour's own comment asks for. + +## 2. High priority: a side job is offered one time per career + +**Evidence:** [`offers.ts:123`](../src/missions/offers.ts#L123), +[`model.ts:203`](../src/missions/model.ts#L203), +[`side.ts:22`](../src/missions/skeletons/side.ts#L22), +[`missions.ts:63`](../src/constants/missions.ts#L63). Probe [2]. + +`Skeleton.cap` is how many times a side job repeats, and absent means one +time. No side job sets it. So each of the eight side jobs can be taken one +time in a career. After that its row is gone from every board in the galaxy. + +Failure rule 5 in plan 190 says a side mission comes back after a delay. The +doc comment on `MISSION_REOFFER_DAYS` says the same. It says that without +the delay one job reads as the only work in the galaxy. The probe +ends `side-recover` on day 10. The job is shut on day 11, on day 18 and on day +400. + +The test that pins rule 5 uses a fixture with `cap: 3` +([`mission-offers.test.ts:102`](../test/mission-offers.test.ts#L102)). So the +mechanism is proved, and the shipped data is never held to the rule. A board +of two or three jobs, once each, empties in a few sessions. + +**Recommended change:** decide what a side job's cap is, and set it in +`side.ts` or make absent mean no cap for a side job. Add one test over +`SIDE_JOBS` that ends each job and asks for it again after the delay. + +## 3. High priority: a smuggling run pays and leaves the goods aboard + +**Evidence:** [`model.ts:375`](../src/missions/model.ts#L375), +[`mission-bridge.ts:109`](../src/game/mission-bridge.ts#L109), +[`smuggle.ts:18`](../src/missions/verbs/smuggle.ts#L18). Probe [3]. + +The leg starts with a `cargo` effect, and the bridge puts three tonnes of +narcotics in the hold. A dock at the target with the tonnes still aboard +succeeds. The success settles a fee of 700 credits. No effect takes the +goods back out. The effect union has no unload, and the settlement asks for +none. + +So the commander keeps the fee and the narcotics, and sells the narcotics at +the market she just landed at. The probe's success effects are a payment, a +deed and two lines. There is no cargo effect among them. The verb test checks +the payment and never reads the hold after it. + +**Recommended change:** an `unload` effect, or a signed `cargo` effect, that +the smuggle leg's success branch emits. The bridge's arithmetic already +tolerates a negative count, but a named effect reads better than a sign. + +## 4. High priority: the word `fled` reaches no leg that answers it + +**Evidence:** [`world-step.ts:564`](../src/game/world-step.ts#L564), +[`npc.ts:793`](../src/game/npc.ts#L793), +[`trader-flight.ts:169`](../src/game/trader-flight.ts#L169), +[`escort.ts:15`](../src/missions/verbs/escort.ts#L15), +[`scan.ts:14`](../src/missions/verbs/scan.ts#L14), +[`hunt.ts:25`](../src/missions/verbs/hunt.ts#L25). Probe [4]. + +Plan 208 M3 says that the `fled` trigger has a sender at last. The world +sends `fled` or `escaped` when a tagged ship despawns. Only +`trader-flight.ts` sets `wantsDespawn`, and only a trader sets `fleeing`. +The guard at `npc.ts:793` names the role. A hunt's target is a pirate +([`spawning.ts:206`](../src/game/spawning.ts#L206)). A pirate never leaves +the system, so a hunt never hears `fled` or `escaped`. The three arcs' +`targetFled` branches and the side hunt's `targetEscaped` branch cannot be +reached in play. + +The two verbs whose targets are traders ignore `fled`. An escort's charge that +a pirate hits runs for the edge of the system and jumps out. The world sends +`fled`. The escort verb answers `escaped`, `escortLost` and `destroyed`, and +returns null on `fled`. The leg stays live, the entity stays alive, and the +charge is spawned again on the next arrival. The console says nothing. The +same holds for a scan's subject that the player shoots. This is the commonest +way an escort is lost, and it is silent. + +The test at [`mission-courses.test.ts:142`](../test/mission-courses.test.ts#L142) +sets `fleeing` on a pirate by hand. It proves the wiring from the flag to the +machine. It does not prove that the world can raise the flag on a hunt's +target, and the world cannot. + +**Recommended change:** the escort and the scan verbs take `fled` as +`targetEscaped`, or as a branch of their own. Decide whether a hunted pirate +can ever leave, and remove the dead branches if it cannot. Add a lint rule: +every trigger a verb module can emit has a branch on the leg, or the skeleton +lists it as ignored. + +## 5. Medium priority: the side-job count silences the patron's messages + +**Evidence:** [`hail.ts:39`](../src/missions/hail.ts#L39), +[`hints.ts:114`](../src/missions/hints.ts#L114). Probe [5]. + +Plan 190 sets a ladder of hints for a far lead. Inside one jump, the patron +sends a message when the commander docks. After four idle docks, the patron +writes one more time. Both are one line, and a dock that makes an offer says +nothing else. + +That rule was written when an offer was rare. Most worlds now carry two or +three side jobs, so most docks make an offer. `hail` passes +`offers.length > 0` as `hailed`, and `dockHint` returns null on it. The probe +docks at Leleer, one jump from Rabedira, with a lead to Rabedira saved. The +dock says THERE ARE 2 SIDE JOBS ON THE STATION BOARD and nothing else. With +the side jobs removed, the same dock says A MESSAGE FROM RABEDIRA. The fourth +idle dock behaves the same way. + +The board rumour and the DATA ON line do not read `hailed`, so a far lead is +not invisible. The two dock messages are. + +**Recommended change:** count only an arc's hail as `hailed`, so a side-job +count and a lead message can share one dock. + +## 6. Medium priority: a save that names a ghost id stops the machine + +**Evidence:** [`machine.ts:76`](../src/missions/machine.ts#L76), +[`lookups.ts:11`](../src/missions/lookups.ts#L11), +[`repair.ts:18`](../src/missions/repair.ts#L18). Probe [6]. + +`repairMissionState` checks that each field has its shape. It does not check +that a live mission names a skeleton the code ships, or a leg that skeleton +has. `skeletonOf` and `legOf` throw on a miss. The comment on each says that +the lint keeps a live mission from naming a ghost. The lint reads skeletons. +It never reads a save. + +The probe loads a record with a live mission on `arc-ghost`. A dock throws. +An abandon throws, so the player cannot free the slot. A record on a real +arc with a leg named `old` throws the same way. + +No shipped id changed since 7 September, so no present save is hit. The +next rename of a leg hits every player who holds that mission. + +**Recommended change:** `repair.ts` drops a live mission or a lead whose +skeleton or leg is unknown, and the loader says one line about it. + +## 7. Medium priority: the journal holds no galaxy + +**Evidence:** [`model.ts:272`](../src/missions/model.ts#L272), +[`story.ts:43`](../src/missions/story.ts#L43), +[`log.ts:45`](../src/game/screens/log.ts#L45), +[`mission-bridge.ts:100`](../src/game/mission-bridge.ts#L100). Probe [7]. + +A journal entry records a world as an index. A lead records a galaxy beside +its index. The LOG screen renders every page with the systems of the galaxy +the commander is in. So after a galactic jump every earlier page names the +wrong worlds. The probe accepts the Lave arc in galaxy 1 and jumps. Rendered +with galaxy 1 the opening line says LAVE. Rendered with galaxy 2 it says +ESRILEES. The route map under the page draws the wrong chart for the same +reason. + +The lead announcement on a galactic jump has the same root. The failed arc +offers its lead at the seed index. The bridge says ASK AT that index in the +new galaxy. The machine then moves the lead to the tour world. The probe +records a lead at world 11 and announces world 6. + +**Recommended change:** a `galaxy` on `JournalEntry`, and a story that reads +it. The relocation in `leaveGalaxy` moves before the announcement, or the +announcement reads the relocated lead. + +## 8. Low priority: a local patron's standing is keyed by the wrong world + +**Evidence:** [`lookups.ts:21`](../src/missions/lookups.ts#L21), +[`machine.ts:323`](../src/missions/machine.ts#L323). Probe [8]. + +`patronId` names a local patron by the world the commander stands at when +the branch settles. A local patron is whoever runs the station the job was +taken at, and [`patrons.ts`](../src/missions/patrons.ts) reads the origin for +the name and the face. A delivery accepted at Tiraor and landed at Edzaon +credits `world-159`, which is Edzaon. + +Nothing reads `standing` yet, so the fault is latent. The key is wrong from +the first write, and the first reader inherits it. + +**Recommended change:** `patronId` reads `acceptedAt` for a local patron. + +## 9. Low priority: a restored mission ship takes the pirate row + +**Evidence:** [`mission-bridge.ts:141`](../src/game/mission-bridge.ts#L141), +[`persistence.ts:242`](../src/game/persistence.ts#L242). Probe [9]. + +`missionShipSpec` looks every tagged ship up under the pirate role. A +restore consults it first. An escort's charge and a scan's subject fly the +trader row. A Python and a Cobra Mk III have both rows, so a reload gives the +charge a pirate's energy and guns. A Boa, an Anaconda and a Transporter have +no pirate row, so they fall through to the trader lookup and come back right. +The spawn and the restore disagree for two of the five trader designs. + +**Recommended change:** `missionShipSpec` reads the role through `verbJob` +on the live leg, as `spawning.ts` does. + +## 10. Low priority: a branch that cannot place its next leg drops the settlement + +**Evidence:** [`machine.ts:244`](../src/missions/machine.ts#L244), +[`lint.ts:25`](../src/missions/lint.ts#L25). Probe [10]. + +`takeBranch` returns before the settlement and the journal when the next +leg's placement finds no world. By then `react` marked the entity dead. +So a kill that cannot place its next leg pays nothing, writes nothing, and +leaves the leg live with no target to spawn. The Constrictor's hunt has no +deadline, so that mission would hold its slot for good. + +The lint measures a `band` from every world and does not measure a +`handover`. The probe measures the four handovers from every world of galaxy +1, and each has a candidate. So the path is unreachable today. It opens when +an arc is accepted in another galaxy, which finding 1 allows. + +**Recommended change:** the lint measures a handover from every world, as it +does a band. `takeBranch` settles and falls back to `anywhere` when a +placement fails, rather than return. + +## 11. Low priority: model surface that nothing ships + +**Evidence:** [`model.ts:25`](../src/missions/model.ts#L25), +[`model.ts:78`](../src/missions/model.ts#L78), +[`model.ts:102`](../src/missions/model.ts#L102), +[`model.ts:190`](../src/missions/model.ts#L190), +[`model.ts:333`](../src/missions/model.ts#L333). + +The machine tests exercise each of these. No skeleton the game ships uses +them, and no game code sends them: + +- the `misjumped` input, which nothing sends; +- the `entity` placement, and the `hull` and `lastWorld` fields on an + entity, which nothing writes after the leg starts; +- the `cargo` field on a deliver verb, which the verb never reads; +- `Skeleton.anchor`, which nothing reads, and the `event` kind; +- the `choice` and `flag` triggers, `setFlags`, `flags`, `notFlags`, + `excludes`, `minRating`, `legalStatus`, `withinJumps` and `legal`; +- a settlement's `override` and `spawn`, and the `changes` record they feed. + +None of this is wrong. Each is a place the next fault can hide, and each +costs a reader time. The model header can say which parts a shipped skeleton +uses and which wait for a plan. + +## 12. Low priority: comments that the code left behind + +- [`missions.ts:4`](../src/constants/missions.ts#L4) names + `game/missions.ts` as the machine that spends the constants. Plan 190 M2 + removed that file. +- [`queries.ts:36`](../src/missions/queries.ts#L36) says the lint does not + see two overrides at one world. `overrideProblems` in `lint.ts` does. +- [`deliver.ts:5`](../src/missions/verbs/deliver.ts#L5) says a hold check + arrives with 190 M4. It did not arrive. +- [`model.ts:25`](../src/missions/model.ts#L25) says an item table arrives + with 190 M4. `ItemId` is a free string. +- [`model.ts:183`](../src/missions/model.ts#L183) says a world patron is + already in one galaxy. Finding 1 shows that it is not. +- The comment on `MissionState.idleDocks` says docks since the journal last + moved. `hail` counts docks since a dock last moved it. A kill in flight + does not reset it. + +## What holds + +- **The machine is pure, and one call runs it.** `stepMissions` clones the + record. The bridge installs the copy and applies the effects before any + save. A reload cannot pay twice. The Constrictor runs end to end through + the probe: bounty on the kill, orders at any station, fee at the courier + world. +- **A settlement is paid one time.** The next leg's verb ignores a second + input for the same kill. That is the whole duplicate-payment rule, and it + is one comparison on a tag. +- **The lint is proved able to fail.** Seventeen fixtures each break one rule, + and the gate names each fault. +- **Every verb is a job.** Eight verb modules, eight side jobs, five arcs + and the Navy mission. The verbs decide and the machine resolves, which is + invariant 15 one level down. +- **The offers, the hints and the words are their own files**, and each + falls back to plain words when a dossier is absent. +- **Days reach the machine.** A jump and a witch-space rescue both send + `dayPassed`, and days move nowhere else. A deadline cannot pass unseen. +- **A rescued passenger rides under the pod's tag.** The survivor screen + opens for one. A deadline after the scoop hands the passenger over as an + ordinary survivor. + +## What the tests do not cover + +- No test holds the shipped side jobs to failure rule 5. The re-offer test + uses a fixture with a cap. +- No test proves that the world can send `fled` for a hunt's target. The one + test sets the flag by hand on a pirate. +- No test offers an arc in a galaxy other than 1. +- No test reads the hold after a smuggling run succeeds. +- No test loads a save with an unknown skeleton or leg id. +- No test renders the log after a galactic jump. +- The lint has no rule that every trigger a verb can emit has a branch. + +## Decisions to record, not defects + +- A hunted ship wrecked by anybody pays the full bounty. `hunt.ts` records + the decision. A pirate that kills the Krait earns the commander 800 + credits. +- An escort's fee needs no presence from the commander. The charge is safe + when it reaches station range with no enemy near it, wherever she is. +- Every arrival says YOUR JOB AT X IS N JUMPS AWAY for every held job that is + elsewhere. Three jobs give three lines behind ARRIVED. +- The hail says THERE ARE N SIDE JOBS ON THE STATION BOARD on every dock + where any are open. It says so whether she read them or not. diff --git a/docs/TODO/213-the-mission-rules-hold-and-a-hit-trader-goes-back-to-work.md b/docs/TODO/213-the-mission-rules-hold-and-a-hit-trader-goes-back-to-work.md new file mode 100644 index 00000000..6c1746da --- /dev/null +++ b/docs/TODO/213-the-mission-rules-hold-and-a-hit-trader-goes-back-to-work.md @@ -0,0 +1,180 @@ +# 213 — The mission rules hold, and a hit trader goes back to work + +**Kind:** defect · **Severity:** high · **Size:** medium · **Depends on:** +nothing · **Blocks:** 214 · **GitHub:** none + +## Where we are + +Two reviews of the missions landed on 2026-09-12 and 2026-09-13. +[`docs/MISSIONS-REVIEW.md`](../MISSIONS-REVIEW.md) reads the machine and its +data. [`docs/MISSIONS-FLIGHT-REVIEW.md`](../MISSIONS-FLIGHT-REVIEW.md) +flies every kind of job in a real headless game. The machine is sound. The +rules around it do not hold. Chris read both on 2026-09-13 and said *"let's +fix the broken parts"*. This plan is the broken parts. 214 is what he asked +for next: surprises. + +The probes under [`docs/reviews/missions-2026-09-12/`](../reviews/missions-2026-09-12/) +measured each fault, and each milestone below says which probe block shows +it. The findings, by the number the reviews gave them: + +| review | finding | what is wrong | +| --- | --- | --- | +| flight 2 | the escort | a trader hit once flees for ever. The escort course rams its charge. It follows a charge into the planet | +| machine 4 | `fled` | the escort and scan verbs ignore it. A scan subject wrecked by nobody is ignored too | +| machine 2 | the cap | no side job sets `cap`, so each is offered one time per career | +| machine 3 | the goods | a smuggling run pays and leaves the narcotics aboard | +| machine 1 | the galaxy | an arc is offered in every galaxy at its seed index | +| flight 3 | the scoops | the Lave arc and two side jobs need scoops a new commander has not got | +| flight 1 | the warning | TARGET ARMOUR HALVES LASER FIRE is said on every hunt | +| machine 5 | the hint | the side-job count silences the patron's dock messages | +| machine 6 | the save | a live mission on a ghost id throws on dock and on abandon | +| machine 7 | the journal | it holds no galaxy, so the log misnames a world after a jump | +| machine 8 | standing | a local patron's key is the world where the branch settled | +| machine 9 | the restore | a restored mission ship takes the pirate row | +| machine 10 | the placement | a branch that cannot place its next leg drops the settlement | +| machine 12 | the comments | six say what the code no longer does | + +## What to do + +Five milestones. Each is one commit. + +### M1 — the flight: a hit trader goes back to work, and the escort ends + +- **`fleeing` clears.** A trader that took no hit for `TRADER_CALM_SECONDS` + and has no live attacker goes back to its working life. A new clock on + the ship counts the seconds since the last hit. `npc-trader.ts` reads it + at the top of the fleeing branch. +- **The escort and scan verbs answer `fled`** as `targetEscaped`. The scan + verb answers `escortLost` as `targetDestroyed`, as the hunt and the escort + already do. +- **The escort course cannot ram its charge.** Inside three standoffs of the + charge the approach speed is capped at the charge's speed plus + `COURSE_ESCORT_CLOSING`. +- **A course refuses a target below the planet's clearance.** The mission + arrival ends with a reason, and the console says THE TARGET IS TOO NEAR + THE PLANET. `CourseStep` gains `why`, and `endCourse` says it in place of + the course's usual word. + +### M2 — the data: a side job comes back, the goods leave, the arcs stay home + +- **A side job with no `cap` repeats without limit**, after + `MISSION_REOFFER_DAYS`. The model comment and `canAccept` change together. +- **A smuggling run unloads.** The smuggle verb's success carries `unload`. + The machine emits an `unload` effect. The bridge takes the tonnes out of + the hold, and no more than are aboard. +- **Every arc is gated to galaxy 1.** The five arcs set `offer.galaxy`. The + lint refuses a world patron whose skeleton has no galaxy gate. The lead + relocation in `leaveGalaxy` goes, with `leadWorldIn` and its tests. A lead + keeps its galaxy, and the LEADS row already says IN ANOTHER GALAXY. +- **A scoop job needs scoops before it is offered.** `Gate.scoops` and + `CommanderFacts.scoops`. The Lave arc, `side-recover` and `side-rescue` + set it. The gate is outside the dossier hash, so no dossier changes. + +### M3 — the words: the warning and the hint + +- **The gun warning speaks for a target that halves a hit**, which is the + Constrictor's `playerLaserMultiplier`, and for no other. +- **A side-job count does not silence a lead.** `hail` passes only an arc's + hail as `hailed`, so the one-jump message and the reminder come through + behind the count. + +### M4 — the record: the save, the journal, the standing, the restore + +- **The loader drops a ghost.** `repairMissionState` drops a live mission + or a lead whose skeleton or leg the code no longer ships, and the loader + says one line about it. +- **The journal holds a galaxy.** `JournalEntry.galaxy`, written by every + push. `storyPages` names a world through the entry's own galaxy, from a + memo of generated galaxies. An entry with no galaxy reads as galaxy 1. +- **The lead announcement names the right world.** The `lead` effect carries + the galaxy, and the bridge names the world through that galaxy's systems. +- **A local patron's standing is keyed by the origin.** `patronId` reads + `acceptedAt` for a local patron. +- **A restored mission ship takes its leg's role.** `missionShipSpec` reads + the role through `verbJob`. +- **A branch that cannot place its next leg still settles.** It falls back + to `anywhere`, and the lint measures a handover from every world, as it + measures a band. + +### M5 — the lint and the comments + +- **Every trigger a verb can emit has a branch, or the leg names it under + `ignores`.** A table in `verbs/registry.ts` says what each verb emits. + The shipped legs that ignore a trigger say so: a side hunt and the + Constrictor ignore `targetFled`, because a pirate cannot leave a system + today. 214 revisits that. +- **The six stale comments go.** They are the machine that spends the + mission constants, and the override conflict the lint does see. They are + the hold check and the item table that never arrived. They are the world + patron in one galaxy, and the idle-dock count. + +## Decisions already made + +- **Fix the broken parts first** (Chris, 2026-09-13). +- **Surprises are 214, not this plan** (Chris, 2026-09-13: *"there should be + surprises"*). +- **The verb decides, and the machine applies** (invariant 15, one level + down). No fix here moves a rule out of its home. +- **A branch change needs a dossier regeneration.** The dossier hash covers + the legs, the verbs, the branches and the pitch. A gate, a spawn and an + `ignores` list are outside it. So this plan adds no branch to a shipped + skeleton. + +## Open questions + +Three questions the review put to Chris, answered here by the review's own +recommendation. Each is one line to change if he decides otherwise. + +- **Does the tour play in other galaxies?** No. The names, the patrons and + the dossiers are galaxy 1's. +- **How many times does a side job repeat?** Without limit, a week apart. + Eight jobs per career is a short game. +- **Does the tour open with a scoop?** It waits for the scoops. A gate is + one line, and a new first leg is a regeneration. + +## Watch out for + +- **A new constant follows `CLAUDE.md`'s rule.** Run `constants:find` for + the name, two synonyms and the value. Then `generate:constants` and + `constants:check`. +- **The seeded stream.** No fix here draws from it. +- **`NpcState` is walked generically into a snapshot.** A new clock on the + ship is saved for free, and a restore from an old save reads it as + absent. Give it a default. +- **The dossier `--check`.** Run it after M2 and M5 to prove the hash did + not move. +- **`test/tour.test.ts` pins the relocation.** M2 removes those checks with + the code, and keeps the checks on `arcStarts`. + +## Verification + +The gates always run: `npm run check`. + +The tier: a rule that changes how a mission and a fight go. The two review +probes run again after M5, and their new output is committed as +`results-after.txt` and `flight-results-after.txt` beside the old. + +Evidence, one per fault: + +- A real-game test puts a commander on the escort, hits the charge, and + sees it go back to its working life after the calm. The escort finishes. +- A real-game test flies the escort approach with the sky empty and sees + the fore shield stay full. +- A course-pilot test hands the mission arrival a target inside the + clearance and reads the refusal. +- The verb tests send `fled` to the escort and the scan, and `escortLost` + to the scan. +- The offer test ends each shipped side job and asks for it again a week + on. +- The verb test reads the hold after a smuggling run succeeds. +- The offer test stands a commander at galaxy 2's index 7 and sees no arc. +- The lint test breaks a fixture one more way per new rule, and the gate + names each fault. +- The bridge test restores a Python escort and reads the trader row. +- The story test renders a galaxy-1 journal against galaxy 2 and reads the + right names. +- The loader test loads a live mission on a ghost id and sees it dropped. + +## What the milestones found + +Written as each milestone lands. diff --git a/docs/TODO/214-a-job-has-a-surprise-in-it.md b/docs/TODO/214-a-job-has-a-surprise-in-it.md new file mode 100644 index 00000000..05079a25 --- /dev/null +++ b/docs/TODO/214-a-job-has-a-surprise-in-it.md @@ -0,0 +1,136 @@ +# 214 — A job has a surprise in it + +**Kind:** enhancement · **Severity:** high · **Size:** large · **Depends on:** +213 · **Blocks:** nothing · **GitHub:** none + +## Where we are + +[`docs/MISSIONS-FLIGHT-REVIEW.md`](../MISSIONS-FLIGHT-REVIEW.md) flew every +kind of job eight times. Every hunt ended in four to thirteen seconds. The +ship ended 95 runs of 96 alive, and the one death was a crash. Five kinds of +job resolve in under thirty seconds with no decision in them. + +Chris set the direction on 2026-09-13: *"I think the missions are too easy - +there should be surprises. Like collecting a canister triggers an ambush. Or +there are pirates waiting for you when you jump in. An escort mission should +be more difficult than just flying to the station."* + +What exists today: + +- `Leg.spawn` lists ships that wait at the leg's world, spawned on every + arrival. Two legs use it, both with `LANE_PIRATES`. +- A verb reports a `VerbReaction` with a trigger, progress and a line. The + machine turns it into effects, and the bridge applies the effects that are + the commander's. Nothing reaches the world from an effect. +- The escort's charge flies to the station on its own. The commander's + position is not measured. 213 M1 makes the charge recover from a hit. +- A hunted ship is a pirate, and a pirate never leaves the system. + +## What to do + +Four milestones. Each is one commit. + +### M1 — pirates wait at the jump-in + +`Leg.spawn` is the mechanism, and this milestone is data with a rule. Each +leg that sends the commander somewhere names who waits there: + +| leg | who waits | +| --- | --- | +| a side hunt | the Krait and one wingman | +| a side deliver | two light pirates, because somebody wants the packet | +| a side recover | one pirate that circles the canister | +| a side scan | nobody; the job is to be quiet | +| an arc hunt | the target and two of its kind | +| an arc deliver | two pirates on the far end | + +A spawn list is outside the dossier hash, so no dossier changes. The words +say nothing of it. That is the surprise. + +### M2 — a scoop springs an ambush + +- `Leg.ambush` names ships that jump in when the leg makes progress. That + is a scoop for a recover or a rescue, and the scan's end for a scan. +- The verb's reaction carries `sprung: true` on that step. The machine + emits a `spawn` effect with the ships. The bridge hands the effect back + to its caller as a spawn order, because the bridge has no world. +- Two callers can hear it: the scoop in `world-step.ts`, and the scan's + end. Each spawns the ships around the commander at `PIRATE_WAVE_RANGE`. + The console says THEY WERE WAITING FOR THE CANISTER. +- The recover, the rescue and the scan side jobs get an ambush. The Lave + arc's ledger and the Vetitice arc's pod get one. + +### M3 — an escort is the commander's to keep + +- **The charge keeps to the commander.** It moves while she is within + `ESCORT_LEASH` of it, and holds where it is when she is not. The console + says THE PYTHON IS HOLDING FOR YOU once. +- **The fee needs her there.** `escortSafe` also needs the commander within + `DOCK_COMPUTER_RANGE` of the charge. +- **Pirates come for the charge.** The escort leg spawns a pack half way to + the station, on the charge's line, with `job: 'hunt'`. A pirate preys on + a trader when the commander is out of reach, so a commander who stays + close draws the fight to herself. + +### M4 — the hunt is a chase + +- **A pirate can leave.** A hunted ship below `HUNT_FLEE_ENERGY` runs for + the edge of the system as a trader does, and jumps out at + `TRADER_JUMP_OUT`. The world already sends `fled` for it. +- **The hunt course pursues.** The fight of 206 already holds the target. + A target that runs is a target the pilot chases at full throttle. +- **The dead branches go live.** `targetFled` on the three arcs, and the + `ignores` on the side hunt from 213 M5 becomes a branch, which needs one + dossier regeneration. + +## Decisions already made + +- **Surprises: an ambush on a scoop, pirates at the jump-in, and a harder + escort** (Chris, 2026-09-13). +- **The words never tell the surprise.** A dossier is words, and the machine + never reads one. A spawn list is rules, and the dossier never reads it. +- **The verb decides, and the machine applies** (invariant 15, one level + down). A verb reports `sprung`; the machine names the effect; the + orchestrator spawns. + +## Open questions + +- **How many pirates is a surprise, and how many is a wall?** M1 starts + small, and the flight probe measures the death rate after each milestone. + A side job should kill a fresh commander in about one run in eight, and + no more. +- **Does M4's regeneration wait for Chris?** Yes. The generator runs through + the `claude` command line on his machine. + +## Watch out for + +- **The seeded stream.** A spawn at a scoop draws positions from the world + stream, as a pirate wave does. Draw once per ship, in a fixed order. +- **A spawn order is not a message.** The bridge returns messages today. A + second return, or a field on the message, must not make a message + carry a world change. +- **The lane pirates are untracked**, and so are these. A kill among them + settles nothing. Say so in the model. + +## Verification + +The gates always run: `npm run check`. + +The tier: a rule that changes how a mission and a fight go. The flight +probe runs after each milestone. The numbers to move: + +- a hunt's time to done, from 4 seconds toward a minute; +- the escort's finish rate, to eight of eight, with fights on the way; +- the death rate on a side job, to about one in eight; +- a scoop that springs an ambush, seen in the probe's fight count. + +Evidence: + +- A real-game test scoops the recover canister and sees the ambush spawn. +- A real-game test parks the commander and sees the charge hold. +- A verb test sends `fled` to a hunt with a branch and reads the branch. +- Chris plays one side job of each kind on his phone. + +## What the milestones found + +Written as each milestone lands. diff --git a/docs/TODO/QUEUE.json b/docs/TODO/QUEUE.json index 189020e1..bd917194 100644 --- a/docs/TODO/QUEUE.json +++ b/docs/TODO/QUEUE.json @@ -1,4 +1,7 @@ { "version": 1, - "items": [] + "items": [ + 213, + 214 + ] } diff --git a/docs/TODO/README.md b/docs/TODO/README.md index d5d546ca..2fe9a5b0 100644 --- a/docs/TODO/README.md +++ b/docs/TODO/README.md @@ -13,7 +13,16 @@ active context: ## Execution queue -The queue is empty. +1. [213](213-the-mission-rules-hold-and-a-hit-trader-goes-back-to-work.md) — the mission rules hold, and a hit trader goes back to work. +2. [214](214-a-job-has-a-surprise-in-it.md) — a job has a surprise in it. + +**213 AND 214 CAME FROM CHRIS ON 2026-09-13**, after two reviews of the +missions. `docs/MISSIONS-REVIEW.md` read the machine and found five rules +that do not hold. `docs/MISSIONS-FLIGHT-REVIEW.md` flew every kind of job +and found the escort broken and the rest too easy. He said *"let's fix the +broken parts"*, and then *"there should be surprises"*. 213 is the fixes. +214 is the surprises: an ambush on a scoop, pirates at the jump-in, and an +escort that needs the commander. **205 TO 208 CAME FROM CHRIS ON 2026-09-11, the day 204 landed.** He flew the touch controls of 204 on a phone, and he could not fly the ship. He diff --git a/docs/reviews/missions-2026-09-12/escort-probe.ts b/docs/reviews/missions-2026-09-12/escort-probe.ts new file mode 100644 index 00000000..cd621b78 --- /dev/null +++ b/docs/reviews/missions-2026-09-12/escort-probe.ts @@ -0,0 +1,79 @@ +// Why an escort stalls: a trace of the charge and the commander, ten seconds +// at a time, on the seeds flight-probe.ts saw time out or die. +// +// node --experimental-strip-types --no-warnings docs/reviews/missions-2026-09-12/escort-probe.ts + +import { Game } from '../../../src/game/game.ts'; +import { headlessShell } from '../../../src/engine/shell.ts'; +import { withoutSaving } from '../../../src/game/storage.ts'; +import { seedWorld } from '../../../src/game/rng.ts'; +import { runMissions } from '../../../src/game/mission-bridge.ts'; +import { COURSE_KEYS } from '../../../src/game/bindings.ts'; +import { keymap } from '../../../src/engine/keymap.ts'; +import { hostilesNear } from '../../../src/game/hostility.ts'; + +const DT = 1 / 60; +const FIRE = keymap().fire[0]; + +function escortGame(k: number): Game { + const g = withoutSaving(() => { + seedWorld(20_260_950 + k); + const game = new Game(() => headlessShell()); + if (game.mode === 'briefing') { game.input.injectPress('Escape'); game.step(DT, DT); } + return game; + }).value; + const c = g.state.commander; + for (let world = 0; world < 256 && c.missions.live.length === 0; world++) { + c.systemIndex = world; + withoutSaving(() => runMissions(c, { kind: 'accept', skeleton: 'side-escort' }, g.state.systems, () => 0.5)); + } + c.missions.live[0].target = c.systemIndex; + c.day += k * 3; + withoutSaving(() => { + g.launch(); + for (let f = 0, at = 0; f < 400; f++) g.step(DT, at += DT); + g.arriveInSystem(); + for (let f = 0, at = 0; f < 400; f++) g.step(DT, at += DT); + }); + return g; +} + +for (const k of [1, 2, 5, 7, 0]) { + const g = escortGame(k); + const s = g.state; + const charge = s.world.npcs.find((n) => n.state.missionTag !== null)!; + const st = s.world.station.position; + console.log(`\nseed ${k}: the charge starts ${Math.round(charge.object.position.distanceTo(st)).toLocaleString()} from the station, ` + + `${Math.round(charge.object.position.distanceTo(s.player.position)).toLocaleString()} from the commander`); + console.log(' t | charge: phase flee speed to-station | commander: to-charge energy shields course | hostile'); + let minGap = Infinity; + let rams = 0; + let lastEnergy = s.sys.energy; + withoutSaving(() => { + g.input.injectPress(COURSE_KEYS.mission); + for (let f = 0; f < 600 * 60; f++) { + const hostile = hostilesNear(s.world.npcs, s.player.position, s.commander.legalStatus, s.player.position.distanceTo(st)); + if (s.session.ccEngaged) g.input.press(FIRE); else g.input.release(FIRE); + if (!hostile && s.session.course === null && !s.session.dockTrial && g.mode === 'flight') g.input.injectPress(COURSE_KEYS.mission); + g.step(DT, 100 + f * DT); + const gap = s.player.position.distanceTo(charge.object.position); + minGap = Math.min(minGap, gap); + if (s.sys.energy < lastEnergy - 5 && gap < 200) rams += 1; + lastEnergy = s.sys.energy; + if (f % 600 === 0 || g.mode === 'dead' || s.commander.missions.done['side-escort']) { + console.log(`${String(Math.round(f * DT)).padStart(4)} | ${charge.state.traderPhase.padEnd(9)} ${String(charge.state.fleeing).padEnd(5)} ${String(Math.round(charge.state.speed)).padStart(5)} ${Math.round(charge.object.position.distanceTo(st)).toLocaleString().padStart(9)} | ` + + `${Math.round(gap).toLocaleString().padStart(10)} ${String(s.sys.energy).padStart(6)} ${String(s.sys.foreShield).padStart(3)}/${String(s.sys.aftShield).padEnd(3)} ${String(s.session.course).padEnd(9)} | ${hostile}`); + } + if (g.mode === 'dead') { + const w = s.world; + console.log(` THE COMMANDER DIED at ${Math.round(f * DT)} s; ${rams} energy drops within 200 units of the charge; nearest ${Math.round(minGap)}`); + console.log(` at death: ${Math.round(s.player.position.distanceTo(w.planetPos) - w.planetRadius).toLocaleString()} above the planet, ${Math.round(s.player.position.distanceTo(st)).toLocaleString()} from the station, ${Math.round(s.player.position.distanceTo(w.sunPos)).toLocaleString()} from the sun, speed ${Math.round(s.player.speed)}`); + break; + } + if (s.commander.missions.done['side-escort']) { console.log(` ESCORT ${s.commander.missions.done['side-escort'].toUpperCase()} at ${Math.round(f * DT)} s; nearest ${Math.round(minGap)}`); break; } + if (!charge.state.alive) { console.log(` the charge died at ${Math.round(f * DT)} s`); break; } + } + }); + g.input.release(FIRE); + if (!s.commander.missions.done['side-escort'] && g.mode !== 'dead') console.log(` still going at 600 s; nearest ${Math.round(minGap)}; ${rams} energy drops within 200 units of the charge`); +} diff --git a/docs/reviews/missions-2026-09-12/escort-results.txt b/docs/reviews/missions-2026-09-12/escort-results.txt new file mode 100644 index 00000000..6323be2a --- /dev/null +++ b/docs/reviews/missions-2026-09-12/escort-results.txt @@ -0,0 +1,311 @@ + +seed 1: the charge starts 69,886 from the station, 4,181 from the commander + t | charge: phase flee speed to-station | commander: to-charge energy shields course | hostile + 0 | arriving false 136 69,883 | 4,180 255 255/255 mission | false + 10 | arriving false 136 68,523 | 1,102 255 255/255 mission | false + 20 | arriving false 136 67,163 | 710 255 255/255 mission | false + 30 | arriving false 136 65,803 | 616 255 255/255 mission | false + 40 | arriving false 136 64,443 | 626 255 255/255 mission | false + 50 | arriving false 136 63,083 | 716 255 255/255 mission | true + 60 | arriving true 145 61,833 | 1,079 254 255/255 null | true + 70 | arriving true 160 60,343 | 105 255 255/255 mission | false + 80 | arriving true 160 58,766 | 122 255 255/255 mission | false + 90 | arriving true 160 57,190 | 138 255 255/255 mission | false + 100 | arriving true 160 55,615 | 155 255 255/255 mission | false + 110 | arriving true 160 54,042 | 172 255 255/255 mission | false + 120 | arriving true 160 52,471 | 188 255 255/255 mission | false + 130 | arriving true 160 50,902 | 205 255 255/255 mission | false + 140 | arriving true 160 49,334 | 222 255 255/255 mission | false + 150 | arriving true 160 47,755 | 239 255 255/255 mission | false + 160 | arriving true 160 46,161 | 256 255 255/255 mission | false + 170 | arriving true 160 44,570 | 273 255 255/255 mission | false + 180 | arriving true 160 42,995 | 289 255 255/255 mission | false + 190 | arriving true 160 41,448 | 306 255 255/255 mission | false + 200 | arriving true 160 39,937 | 323 255 255/255 mission | false + 210 | arriving true 160 38,469 | 340 255 255/255 mission | false + 220 | arriving true 160 37,017 | 356 255 255/255 mission | false + 230 | arriving true 160 35,585 | 367 255 255/255 mission | false + 240 | arriving true 160 34,641 | 367 255 255/255 mission | false + 250 | arriving true 160 34,733 | 367 255 255/255 mission | false + 260 | arriving true 160 35,758 | 367 255 255/255 mission | false + 270 | arriving true 160 37,201 | 366 255 255/255 mission | false + 280 | arriving true 160 38,426 | 373 255 255/255 mission | false + 290 | arriving true 160 38,829 | 367 255 255/255 mission | false + 300 | arriving true 160 38,291 | 371 255 255/255 mission | false + 310 | arriving true 160 37,086 | 369 255 255/255 mission | false + 320 | arriving true 160 35,671 | 369 255 255/255 mission | false + 330 | arriving true 160 34,689 | 373 255 255/255 mission | false + 340 | arriving true 160 34,732 | 370 255 255/255 mission | false + 350 | arriving true 160 35,794 | 366 255 255/255 mission | false + 360 | arriving true 160 37,245 | 371 255 255/255 mission | false + 370 | arriving true 160 38,451 | 371 255 255/255 mission | false + 380 | arriving true 160 38,855 | 371 255 255/255 mission | false + 390 | arriving true 160 38,411 | 374 255 255/255 mission | false + 400 | arriving true 160 37,139 | 367 255 255/255 mission | false + 410 | arriving true 160 35,713 | 372 255 255/255 mission | false + 420 | arriving true 160 34,817 | 368 255 255/255 mission | false + 430 | arriving true 160 34,960 | 370 255 255/255 mission | false + 440 | arriving true 160 35,937 | 372 255 255/255 mission | false + 450 | arriving true 160 37,370 | 370 255 255/255 mission | false + 460 | arriving true 160 38,585 | 375 255 255/255 mission | false + 470 | arriving true 160 39,003 | 371 255 255/255 mission | false + 480 | arriving true 160 38,482 | 374 255 255/255 mission | false + 490 | arriving true 160 37,273 | 372 255 255/255 mission | false + 500 | arriving true 160 35,861 | 372 255 255/255 mission | false + 510 | arriving true 160 34,903 | 375 255 255/255 mission | false + 520 | arriving true 160 34,996 | 370 255 255/255 mission | false + 530 | arriving true 160 36,090 | 367 255 255/255 mission | false + 540 | arriving true 160 37,536 | 371 255 255/255 mission | false + 550 | arriving true 160 38,705 | 371 255 255/255 mission | false + 560 | arriving true 160 39,024 | 368 255 255/255 mission | false + 570 | arriving true 160 38,325 | 366 255 255/255 mission | false + 580 | arriving true 160 37,050 | 373 255 255/255 mission | false + 590 | arriving true 160 35,677 | 367 255 255/255 mission | false + still going at 600 s; nearest 70; 0 energy drops within 200 units of the charge + +seed 2: the charge starts 74,822 from the station, 4,317 from the commander + t | charge: phase flee speed to-station | commander: to-charge energy shields course | hostile + 0 | arriving false 136 74,819 | 4,319 255 255/255 mission | false + 10 | arriving false 136 73,463 | 531 255 255/255 mission | false + 20 | arriving true 160 72,237 | 174 255 165/255 mission | false + 30 | arriving true 160 71,142 | 192 255 196/255 mission | false + 40 | arriving true 160 70,066 | 209 255 226/255 mission | false + 50 | arriving true 160 69,010 | 227 255 255/255 mission | false + 60 | arriving true 160 67,975 | 245 255 255/255 mission | false + 70 | arriving true 160 66,963 | 262 255 255/255 mission | false + 80 | arriving true 160 65,974 | 280 255 255/255 mission | false + 90 | arriving true 160 65,010 | 298 255 255/255 mission | false + 100 | arriving true 160 64,071 | 315 255 255/255 mission | false + 110 | arriving true 160 63,158 | 333 255 255/255 mission | false + 120 | arriving true 160 62,273 | 351 255 255/255 mission | false + 130 | arriving true 160 61,417 | 368 255 255/255 mission | false + 140 | arriving true 160 60,592 | 386 255 255/255 mission | false + 150 | arriving true 160 59,798 | 404 255 255/255 mission | false + 160 | arriving true 160 59,036 | 421 255 255/255 mission | false + 170 | arriving true 160 58,308 | 439 255 255/255 mission | false + 180 | arriving true 160 57,616 | 457 255 255/255 mission | false + 190 | arriving true 160 56,960 | 474 255 255/255 mission | false + 200 | arriving true 160 56,342 | 492 255 255/255 mission | false + 210 | arriving true 160 55,763 | 510 255 255/255 mission | false + 220 | arriving true 160 55,225 | 677 255 255/255 mission | false + 230 | arriving true 160 54,727 | 715 255 255/255 mission | false + 240 | arriving true 160 54,273 | 732 255 255/255 mission | false + 250 | arriving true 160 53,862 | 730 255 255/255 mission | false + 260 | arriving true 160 53,496 | 708 255 255/255 mission | false + 270 | arriving true 160 53,176 | 667 255 255/255 mission | false + 280 | arriving true 160 52,902 | 630 255 255/255 mission | false + 290 | arriving true 160 52,675 | 608 255 255/255 mission | false + 300 | arriving true 160 52,496 | 600 255 255/255 mission | false + 310 | arriving true 160 52,365 | 611 255 255/255 mission | false + 320 | arriving true 160 52,283 | 642 255 255/255 mission | false + 330 | arriving true 160 52,250 | 688 255 255/255 mission | false + 340 | arriving true 160 52,266 | 721 255 255/255 mission | false + 350 | arriving true 160 52,331 | 734 255 255/255 mission | false + 360 | arriving true 160 52,444 | 727 255 255/255 mission | false + 370 | arriving true 160 52,606 | 701 255 255/255 mission | false + 380 | arriving true 160 52,816 | 658 255 255/255 mission | false + 390 | arriving true 160 53,074 | 624 255 255/255 mission | false + 400 | arriving true 160 53,378 | 604 255 255/255 mission | false + 410 | arriving true 160 53,728 | 601 255 255/255 mission | false + 420 | arriving true 160 54,123 | 616 255 255/255 mission | false + 430 | arriving true 160 54,562 | 651 255 255/255 mission | false + 440 | arriving true 160 55,045 | 697 255 255/255 mission | false + 450 | arriving true 160 55,569 | 725 255 255/255 mission | false + 460 | arriving true 160 56,134 | 734 255 255/255 mission | false + 470 | arriving true 160 56,738 | 723 255 255/255 mission | false + 480 | arriving true 160 57,381 | 692 255 255/255 mission | false + 490 | arriving true 160 58,060 | 649 255 255/255 mission | false + 500 | arriving true 160 58,776 | 618 255 255/255 mission | false + 510 | arriving true 160 59,526 | 602 255 255/255 mission | false + 520 | arriving true 160 60,308 | 602 255 255/255 mission | false + 530 | arriving true 160 61,123 | 622 255 255/255 mission | false + 540 | arriving true 160 61,969 | 662 255 255/255 mission | false + 550 | arriving true 160 62,843 | 705 255 255/255 mission | false + 560 | arriving true 160 63,746 | 729 255 255/255 mission | false + 570 | arriving true 160 64,676 | 733 255 255/255 mission | false + 580 | arriving true 160 65,632 | 718 255 255/255 mission | false + 590 | arriving true 160 66,612 | 683 255 255/255 mission | false + still going at 600 s; nearest 49; 0 energy drops within 200 units of the charge + +seed 5: the charge starts 74,302 from the station, 4,553 from the commander + t | charge: phase flee speed to-station | commander: to-charge energy shields course | hostile + 0 | arriving false 136 74,300 | 4,554 255 255/255 mission | false + 10 | arriving false 136 72,940 | 708 255 255/255 mission | false + 20 | arriving false 136 71,580 | 130 255 255/255 mission | false + 30 | arriving false 136 70,220 | 127 255 255/255 mission | false + 40 | arriving false 136 68,860 | 123 255 255/255 mission | false + 50 | arriving false 136 67,500 | 120 255 255/255 mission | false + 60 | arriving false 136 66,140 | 117 255 255/255 mission | false + 70 | arriving false 136 64,780 | 113 255 255/255 mission | false + 80 | arriving false 136 63,420 | 110 255 255/255 mission | false + 90 | arriving false 136 62,060 | 107 255 255/255 mission | false + 100 | arriving false 136 60,700 | 103 255 255/255 mission | false + 110 | arriving false 136 59,340 | 100 255 255/255 mission | false + 120 | arriving false 136 57,980 | 97 255 255/255 mission | false + 130 | arriving false 136 56,620 | 93 255 255/255 mission | false + 140 | arriving false 136 55,260 | 90 255 255/255 mission | false + 150 | arriving false 136 53,900 | 87 255 255/255 mission | false + 160 | arriving false 136 52,540 | 83 255 255/255 mission | false + 170 | arriving false 136 51,180 | 80 255 255/255 mission | false + 180 | arriving false 136 49,820 | 77 255 255/255 mission | false + 190 | arriving false 136 48,460 | 73 255 255/255 mission | false + 200 | arriving false 136 47,100 | 70 255 255/255 mission | false + 210 | arriving false 136 45,740 | 67 255 255/255 mission | false + 220 | arriving false 136 44,380 | 63 255 255/255 mission | false + 230 | arriving false 136 43,020 | 60 255 255/255 mission | false + 240 | arriving false 136 41,660 | 57 255 255/255 mission | false + 250 | arriving false 136 40,300 | 53 255 255/255 mission | false + 260 | arriving false 136 38,940 | 50 255 255/255 mission | false + 270 | arriving false 136 37,580 | 47 255 255/255 mission | false + 280 | arriving true 160 36,105 | 177 255 155/255 mission | false + 290 | arriving true 160 34,505 | 195 255 185/255 mission | false + 300 | arriving true 160 32,905 | 213 255 216/255 mission | false + 310 | arriving true 160 31,305 | 230 255 246/255 mission | false + 320 | arriving true 160 29,706 | 248 255 255/255 mission | false + 330 | arriving true 160 28,106 | 266 255 255/255 mission | false + 340 | arriving true 160 26,506 | 283 255 255/255 mission | false + 350 | arriving true 160 24,907 | 301 255 255/255 mission | false + 360 | arriving true 160 23,307 | 319 255 255/255 mission | false + 370 | arriving true 160 21,708 | 336 255 255/255 mission | false + 380 | arriving true 160 20,108 | 354 255 255/255 mission | false + 390 | arriving true 160 18,509 | 372 255 255/255 mission | false + 400 | arriving true 160 16,910 | 389 255 255/255 mission | false + 410 | arriving true 160 15,311 | 407 255 255/255 mission | false + 420 | arriving true 160 13,712 | 425 255 255/255 mission | false + 430 | arriving true 160 12,114 | 442 255 255/255 mission | false + 440 | arriving true 160 10,516 | 460 255 255/255 mission | false + 450 | arriving true 160 8,919 | 478 255 255/255 mission | false + 460 | arriving true 160 7,323 | 495 255 255/255 mission | false + 470 | arriving true 160 5,729 | 513 255 255/255 mission | false + 480 | arriving true 160 4,140 | 625 255 255/255 mission | false + 490 | arriving true 160 2,565 | 605 255 255/255 mission | false + 500 | arriving true 160 1,068 | 600 255 255/255 mission | false + 510 | arriving true 160 905 | 615 255 255/255 mission | false + 520 | arriving true 160 2,370 | 649 255 255/255 mission | false + 530 | arriving true 160 3,942 | 694 255 255/255 mission | false + 540 | arriving true 160 5,530 | 724 255 255/255 mission | false + 550 | arriving true 160 7,123 | 734 255 255/255 mission | false + 559 | arriving true 160 8,620 | 723 255 255/255 mission | false + THE COMMANDER DIED at 559 s; 0 energy drops within 200 units of the charge; nearest 45 + at death: 80 above the planet, 7,900 from the station, 316,954 from the sun, speed 89 + +seed 7: the charge starts 71,610 from the station, 2,768 from the commander + t | charge: phase flee speed to-station | commander: to-charge energy shields course | hostile + 0 | arriving false 136 71,608 | 2,768 255 255/255 mission | false + 10 | arriving false 136 70,248 | 697 255 255/255 mission | false + 20 | arriving false 136 68,888 | 603 255 255/255 mission | false + 30 | arriving false 136 67,528 | 658 255 255/255 mission | false + 40 | arriving false 136 66,168 | 714 255 255/255 mission | false + 50 | arriving false 136 64,808 | 622 255 255/255 mission | false + 60 | arriving false 136 63,448 | 618 255 255/255 mission | false + 70 | arriving false 136 62,088 | 714 255 255/255 mission | false + 80 | arriving false 136 60,728 | 660 255 255/255 mission | false + 90 | arriving false 136 59,368 | 601 255 255/255 mission | false + 100 | arriving false 136 58,008 | 689 255 255/255 mission | false + 110 | arriving false 136 56,648 | 700 255 255/255 mission | false + 120 | arriving false 136 55,288 | 607 255 255/255 mission | false + 130 | arriving false 136 53,928 | 645 255 255/255 mission | false + 140 | arriving false 136 52,568 | 717 255 255/255 mission | false + 150 | arriving false 136 51,208 | 632 255 255/255 mission | false + 160 | arriving false 136 49,848 | 610 255 255/255 mission | false + 170 | arriving false 136 48,488 | 709 255 255/255 mission | false + 180 | arriving false 136 47,128 | 674 255 255/255 mission | false + 190 | arriving false 136 45,768 | 600 255 255/255 mission | false + 200 | arriving false 136 44,408 | 676 255 255/255 mission | false + 210 | arriving false 136 43,048 | 708 255 255/255 mission | false + 220 | arriving false 136 41,688 | 612 255 255/255 mission | true + 230 | arriving true 160 40,618 | 1,703 255 238/245 mission | false + 240 | arriving true 160 39,146 | 166 255 243/255 mission | false + 250 | arriving true 160 37,727 | 182 255 255/255 mission | false + 260 | arriving true 160 36,322 | 199 255 255/255 mission | false + 270 | arriving true 160 34,935 | 216 255 255/255 mission | false + 280 | arriving true 160 33,572 | 232 255 255/255 mission | false + 290 | arriving true 160 32,307 | 249 255 255/255 mission | false + 300 | arriving true 160 31,203 | 266 255 255/255 mission | false + 310 | arriving true 160 30,268 | 283 255 255/255 mission | false + 320 | arriving true 160 29,499 | 300 255 255/255 mission | false + 330 | arriving true 160 28,881 | 317 255 255/255 mission | false + 340 | arriving true 160 28,393 | 334 255 255/255 mission | false + 350 | arriving true 160 28,009 | 351 255 255/255 mission | false + 360 | arriving true 160 27,762 | 365 255 255/255 mission | false + 370 | arriving true 160 27,761 | 372 255 255/255 mission | false + 380 | arriving true 160 28,046 | 372 255 255/255 mission | false + 390 | arriving true 160 28,478 | 370 255 255/255 mission | false + 400 | arriving true 160 28,882 | 377 255 255/255 mission | false + 410 | arriving true 160 29,079 | 376 255 255/255 mission | false + 420 | arriving true 160 28,982 | 378 255 255/255 mission | false + 430 | arriving true 160 28,660 | 378 255 255/255 mission | false + 440 | arriving true 160 28,220 | 377 255 255/255 mission | false + 450 | arriving true 160 27,876 | 381 255 255/255 mission | false + 460 | arriving true 160 27,799 | 376 255 255/255 mission | false + 470 | arriving true 160 28,031 | 372 255 255/255 mission | false + 480 | arriving true 160 28,437 | 372 255 255/255 mission | false + 490 | arriving true 160 28,827 | 376 255 255/255 mission | false + 500 | arriving true 160 29,063 | 378 255 255/255 mission | false + 510 | arriving true 160 28,970 | 371 255 255/255 mission | false + 520 | arriving true 160 28,636 | 373 255 255/255 mission | false + 530 | arriving true 160 28,219 | 378 255 255/255 mission | false + 540 | arriving true 160 27,891 | 374 255 255/255 mission | false + 550 | arriving true 160 27,823 | 372 255 255/255 mission | false + 560 | arriving true 160 28,035 | 374 255 255/255 mission | false + 570 | arriving true 160 28,425 | 380 255 255/255 mission | false + 580 | arriving true 160 28,824 | 376 255 255/255 mission | false + 590 | arriving true 160 29,015 | 371 255 255/255 mission | false + still going at 600 s; nearest 67; 0 energy drops within 200 units of the charge + +seed 0: the charge starts 73,667 from the station, 5,329 from the commander + t | charge: phase flee speed to-station | commander: to-charge energy shields course | hostile + 0 | arriving false 136 73,665 | 5,330 255 255/255 mission | false + 10 | arriving false 136 72,306 | 1,798 255 255/255 mission | false + 20 | arriving false 136 70,946 | 624 255 255/255 mission | false + 30 | arriving false 136 69,586 | 621 255 255/255 mission | false + 40 | arriving false 136 68,226 | 715 255 255/255 mission | false + 50 | arriving false 136 66,866 | 655 255 255/255 mission | false + 60 | arriving false 136 65,506 | 601 255 255/255 mission | false + 70 | arriving false 136 64,146 | 692 255 255/255 mission | false + 80 | arriving false 136 62,786 | 697 255 255/255 mission | false + 90 | arriving false 136 61,426 | 605 255 255/255 mission | false + 100 | arriving false 136 60,066 | 649 255 255/255 mission | false + 110 | arriving false 136 58,706 | 716 255 255/255 mission | false + 120 | arriving false 136 57,346 | 628 255 255/255 mission | false + 130 | arriving false 136 55,986 | 613 255 255/255 mission | false + 140 | arriving false 136 54,626 | 711 255 255/255 mission | false + 150 | arriving false 136 53,266 | 669 255 255/255 mission | false + 160 | arriving false 136 51,906 | 600 255 255/255 mission | false + 170 | arriving false 136 50,546 | 681 255 255/255 mission | false + 180 | arriving false 136 49,186 | 705 255 255/255 mission | false + 190 | arriving false 136 47,826 | 610 255 255/255 mission | false + 200 | arriving false 136 46,466 | 636 255 255/255 mission | false + 210 | arriving false 136 45,106 | 717 255 255/255 mission | false + 220 | arriving false 136 43,746 | 639 255 255/255 mission | false + 230 | arriving false 136 42,386 | 606 255 255/255 mission | false + 240 | arriving false 136 41,026 | 704 255 255/255 mission | false + 250 | arriving false 136 39,666 | 683 255 255/255 mission | false + 260 | arriving false 136 38,306 | 601 255 255/255 mission | false + 270 | arriving false 136 36,946 | 667 255 255/255 mission | false + 280 | arriving false 136 35,586 | 711 255 255/255 mission | false + 290 | arriving false 136 34,226 | 617 255 255/255 mission | false + 300 | arriving false 136 32,866 | 625 255 255/255 mission | false + 310 | arriving false 136 31,506 | 716 255 255/255 mission | false + 320 | arriving false 136 30,146 | 651 255 255/255 mission | false + 330 | arriving false 136 28,786 | 602 255 255/255 mission | false + 340 | arriving false 136 27,426 | 696 255 255/255 mission | false + 350 | arriving false 136 26,066 | 694 255 255/255 mission | false + 360 | arriving false 136 24,706 | 604 255 255/255 mission | false + 370 | arriving false 136 23,346 | 654 255 255/255 mission | false + 380 | arriving false 136 21,986 | 715 255 255/255 mission | false + 390 | arriving false 136 20,626 | 625 255 255/255 mission | false + 400 | arriving false 136 19,266 | 615 255 255/255 mission | false + 410 | arriving false 136 17,906 | 712 255 255/255 mission | false + 420 | arriving false 136 16,546 | 664 255 255/255 mission | false + 430 | arriving false 136 15,186 | 600 255 255/255 mission | false + 440 | arriving false 136 13,826 | 685 255 255/255 mission | false + 450 | arriving false 136 12,466 | 703 255 255/255 mission | false + 460 | arriving false 136 11,106 | 608 255 255/255 mission | false + 470 | arriving false 136 9,746 | 640 255 255/255 mission | false + 480 | arriving false 136 8,386 | 717 255 255/255 mission | false + 490 | arriving false 136 7,026 | 635 255 255/255 mission | false + 500 | arriving false 136 5,666 | 608 255 255/255 mission | false + 510 | arriving false 136 4,306 | 707 255 255/255 mission | false + 516 | arriving false 136 3,499 | 696 255 255/255 mission | false + ESCORT COMPLETE at 516 s; nearest 540 diff --git a/docs/reviews/missions-2026-09-12/flight-probe.ts b/docs/reviews/missions-2026-09-12/flight-probe.ts new file mode 100644 index 00000000..39a32f56 --- /dev/null +++ b/docs/reviews/missions-2026-09-12/flight-probe.ts @@ -0,0 +1,228 @@ +// The flight probe behind docs/MISSIONS-REVIEW.md, part two: can the ship's +// own automation finish each kind of job, and how long does it take? +// +// node --experimental-strip-types --no-warnings docs/reviews/missions-2026-09-12/flight-probe.ts [seeds] +// +// Each run is a real headless Game. A fresh commander (pulse laser, three +// missiles, 100 Cr) is put on one live leg whose work is in the system she +// arrives in. Ordinary traffic stays in the sky. The probe presses the job's +// own button, holds the trigger in a fight, presses the button again when a +// fight drops the course, and presses the docking computer when the station +// course hands over. Scoops are fitted for a scoop, and a docking computer +// for a leg that ends at the station, because the probe has no hands for the +// slot. The output is committed beside it as flight-results.txt. + +import { Game } from '../../../src/game/game.ts'; +import { headlessShell } from '../../../src/engine/shell.ts'; +import { withoutSaving } from '../../../src/game/storage.ts'; +import { seedWorld } from '../../../src/game/rng.ts'; +import { runMissions } from '../../../src/game/mission-bridge.ts'; +import { COURSE_KEYS } from '../../../src/game/bindings.ts'; +import { keymap } from '../../../src/engine/keymap.ts'; +import { SOURCE_DESIGN, CONSTRICTOR_SPEC } from '../../../src/game/ship-specs.ts'; +import { shipDesignIdOf } from '../../../src/game/ship-identity.ts'; +import { hostilesNear } from '../../../src/game/hostility.ts'; +import type { MissionState } from '../../../src/missions/model.ts'; + +const SEEDS = Number(process.argv[2] ?? 8); +const DT = 1 / 60; +const FIRE = keymap().fire[0]; +const DOCK_KEY = 'KeyC'; + +interface Kit { scoops?: boolean; dc?: boolean } + +function newGame(seed: number, kit: Kit): Game { + const g = withoutSaving(() => { + seedWorld(seed); + const game = new Game(() => headlessShell()); + if (game.mode === 'briefing') { game.input.injectPress('Escape'); game.step(DT, DT); } + return game; + }).value; + const c = g.state.commander; + c.equipment.scoops = kit.scoops ?? false; + c.equipment.dockingComputer = kit.dc ?? false; + return g; +} + +/** Accept a side job where a board offers it, and move its work here. */ +function onSideJob(g: Game, skeleton: string): void { + const c = g.state.commander; + for (let world = 0; world < 256 && c.missions.live.length === 0; world++) { + c.systemIndex = world; + withoutSaving(() => runMissions(c, { kind: 'accept', skeleton }, g.state.systems, () => 0.5)); + } + if (!c.missions.live[0]) throw new Error(`no world offers ${skeleton}`); + c.missions.live[0].target = c.systemIndex; +} + +/** Put a hand-built live leg on the record: an arc's hunt, with its ship here. */ +function onArcHunt(g: Game, skeleton: string, leg: string, ship: string): void { + const c = g.state.commander; + const here = c.systemIndex; + const tag = `${skeleton}#1#${leg}`; + const st: MissionState = c.missions; + st.live.push({ skeleton, leg, target: here, tag, progress: 0, deadlineDay: null }); + st.journal.push({ skeleton, leg, outcome: 'accepted', day: c.day, world: here }); + st.entities[tag] = { kind: 'ship', ship, hull: 1, lastWorld: here, alive: true }; +} + +/** + * Launch, jump, and arrive with the job's target in the sky and the traffic + * too. The arrival reseeds the world from the system and the day, so each + * seed lands on a different day to meet a different sky. + */ +function arrive(g: Game, k = 0): void { + g.state.commander.day += k * 3; + withoutSaving(() => { + g.launch(); + for (let f = 0, at = 0; f < 400; f++) g.step(DT, at += DT); + g.arriveInSystem(); + for (let f = 0, at = 0; f < 400; f++) g.step(DT, at += DT); + }); +} + +interface Run { + outcome: 'done' | 'failed' | 'dead' | 'timeout'; + seconds: number; + fights: number; + scanned: boolean; + kills: number; + /** energy and the two shields when the run ended, as the HUD reads them */ + energy: number; + fore: number; + aft: number; + /** how far the station was from the witchpoint at the arrival */ + stationAway: number; +} + +/** + * Fly a course button until `until` says the work is done, the leg failed, + * the ship died, or the seconds ran out. `trigger` holds the laser in a + * fight. The button is pressed again whenever a fight dropped the course. + */ +function fly( + g: Game, key: string, seconds: number, until: () => boolean, failed: () => boolean, trigger: boolean, +): Run { + const s = g.state; + const kills0 = s.commander.kills; + let fights = 0; + let inFight = false; + let flown = 0; + let outcome: Run['outcome'] = 'timeout'; + const stationAway = s.player.position.distanceTo(s.world.station.position); + withoutSaving(() => { + g.input.injectPress(key); + for (let f = 0; f < seconds * 60; f++) { + const hostile = hostilesNear(s.world.npcs, s.player.position, s.commander.legalStatus, + s.player.position.distanceTo(s.world.station.position)); + if (hostile && !inFight) fights += 1; + inFight = hostile; + if (trigger && s.session.ccEngaged) g.input.press(FIRE); else g.input.release(FIRE); + // The course dropped for a fight and the fight is over: press it again. + if (!hostile && s.session.course === null && !s.session.dockTrial && g.mode === 'flight') { + g.input.injectPress(key); + } + // The station course handed over: the docking computer flies the slot. + if (s.session.dockTrial && !s.session.dcEngaged && s.commander.equipment.dockingComputer) { + g.input.injectPress(DOCK_KEY); + } + g.step(DT, 100 + f * DT); + flown = f * DT; + if (g.mode === 'dead') { outcome = 'dead'; break; } + if (failed()) { outcome = 'failed'; break; } + if (until()) { outcome = 'done'; break; } + } + }); + g.input.release(FIRE); + return { + outcome, seconds: flown, fights, scanned: s.session.policeScanned, kills: s.commander.kills - kills0, + energy: s.sys.energy, fore: s.sys.foreShield, aft: s.sys.aftShield, stationAway, + }; +} + +const done = (g: Game, id: string) => g.state.commander.missions.done[id] === 'complete'; +const failed = (g: Game, id: string) => g.state.commander.missions.done[id] === 'fail'; +const leg = (g: Game) => g.state.commander.missions.live[0]?.leg; +const isDocked = (g: Game) => g.mode !== 'flight' && g.mode !== 'dead'; + +interface Case { + name: string; + kit: Kit; + put: (g: Game) => void; + key: string; + seconds: number; + until: (g: Game) => boolean; + failed: (g: Game) => boolean; + trigger: boolean; +} + +const cobra = shipDesignIdOf(SOURCE_DESIGN.cobraMk3); +const asp = shipDesignIdOf(SOURCE_DESIGN.asp); +const fdl = shipDesignIdOf(SOURCE_DESIGN.ferDeLance); + +const CASES: Case[] = [ + { name: 'side-hunt: a Krait, pulse laser', kit: {}, put: (g) => onSideJob(g, 'side-hunt'), + key: COURSE_KEYS.mission, seconds: 300, until: (g) => done(g, 'side-hunt'), failed: (g) => failed(g, 'side-hunt'), trigger: true }, + { name: 'arc-lave runner: a Cobra Mk III, pulse laser', kit: {}, put: (g) => onArcHunt(g, 'arc-lave', 'runner', cobra), + key: COURSE_KEYS.mission, seconds: 300, until: (g) => leg(g) !== 'runner', failed: (g) => failed(g, 'arc-lave'), trigger: true }, + { name: 'arc-xeer chase: a Fer-de-Lance, pulse laser', kit: {}, put: (g) => onArcHunt(g, 'arc-xeer', 'chase', fdl), + key: COURSE_KEYS.mission, seconds: 300, until: (g) => leg(g) !== 'chase', failed: (g) => failed(g, 'arc-xeer'), trigger: true }, + { name: 'arc-edle purge: an Asp, pulse laser', kit: {}, put: (g) => onArcHunt(g, 'arc-edle', 'purge', asp), + key: COURSE_KEYS.mission, seconds: 300, until: (g) => leg(g) !== 'purge', failed: (g) => failed(g, 'arc-edle'), trigger: true }, + { name: 'constrictor hunt, pulse laser', kit: {}, put: (g) => onArcHunt(g, 'constrictor', 'hunt', CONSTRICTOR_SPEC.designId), + key: COURSE_KEYS.mission, seconds: 300, until: (g) => leg(g) !== 'hunt', failed: (g) => failed(g, 'constrictor'), trigger: true }, + { name: 'side-scan: an Anaconda for 20 s', kit: {}, put: (g) => onSideJob(g, 'side-scan'), + key: COURSE_KEYS.mission, seconds: 300, until: (g) => done(g, 'side-scan'), failed: (g) => failed(g, 'side-scan'), trigger: true }, + { name: 'side-escort: a Python to station range', kit: {}, put: (g) => onSideJob(g, 'side-escort'), + key: COURSE_KEYS.mission, seconds: 900, until: (g) => done(g, 'side-escort'), failed: (g) => failed(g, 'side-escort'), trigger: true }, + { name: 'side-recover: scoop a canister (scoops fitted)', kit: { scoops: true }, put: (g) => onSideJob(g, 'side-recover'), + key: COURSE_KEYS.mission, seconds: 240, until: (g) => leg(g) === 'home', failed: (g) => failed(g, 'side-recover'), trigger: true }, + { name: 'side-rescue: scoop a pod (scoops fitted)', kit: { scoops: true }, put: (g) => onSideJob(g, 'side-rescue'), + key: COURSE_KEYS.mission, seconds: 240, until: (g) => (g.state.commander.missions.live[0]?.progress ?? 0) > 0, failed: (g) => failed(g, 'side-rescue'), trigger: true }, + { name: 'side-ambush: the lane, then dock (docking computer)', kit: { dc: true }, put: (g) => onSideJob(g, 'side-ambush'), + key: COURSE_KEYS.station, seconds: 480, until: (g) => done(g, 'side-ambush'), failed: (g) => failed(g, 'side-ambush'), trigger: true }, + { name: 'side-deliver: fly to the station and dock (docking computer)', kit: { dc: true }, put: (g) => onSideJob(g, 'side-deliver'), + key: COURSE_KEYS.station, seconds: 480, until: (g) => done(g, 'side-deliver'), failed: (g) => failed(g, 'side-deliver'), trigger: true }, + { name: 'side-smuggle: slip past the police and dock (docking computer)', kit: { dc: true }, put: (g) => onSideJob(g, 'side-smuggle'), + key: COURSE_KEYS.mission, seconds: 480, until: (g) => done(g, 'side-smuggle'), failed: (g) => failed(g, 'side-smuggle'), trigger: true }, +]; + +console.log(`flight probe: ${SEEDS} seeds per case, ordinary traffic in the sky\n`); +for (const c of CASES) { + const runs: Run[] = []; + const t0 = Date.now(); + for (let k = 0; k < SEEDS; k++) { + const g = newGame(20_260_950 + k, c.kit); + c.put(g); + arrive(g, k); + runs.push(fly(g, c.key, c.seconds, () => c.until(g), () => c.failed(g), c.trigger)); + if (c.name.startsWith('side-escort') && runs[k].outcome !== 'done') { + const charge = g.state.world.npcs.find((n) => n.state.missionTag !== null); + const st = g.state.world.station.position; + console.log(` escort seed ${k}: ${runs[k].outcome}; the charge is ${charge ? `${charge.state.alive ? 'alive' : 'dead'}, phase ${charge.state.traderPhase}, ${Math.round(charge.object.position.distanceTo(st)).toLocaleString()} units from the station, docked ${charge.state.docked}` : 'gone from the sky'}`); + } + } + const n = (o: Run['outcome']) => runs.filter((r) => r.outcome === o).length; + const doneRuns = runs.filter((r) => r.outcome === 'done'); + const mean = doneRuns.length ? doneRuns.reduce((a, r) => a + r.seconds, 0) / doneRuns.length : NaN; + const max = doneRuns.length ? Math.max(...doneRuns.map((r) => r.seconds)) : NaN; + const fights = runs.reduce((a, r) => a + r.fights, 0) / runs.length; + console.log(c.name); + console.log(` done ${n('done')} failed ${n('failed')} dead ${n('dead')} timeout ${n('timeout')} of ${runs.length}` + + ` | time to done: mean ${mean.toFixed(0)} s, worst ${max.toFixed(0)} s` + + ` | fights per run ${fights.toFixed(1)} | kills ${runs.reduce((a, r) => a + r.kills, 0)}` + + (c.name.startsWith('side-smuggle') ? ` | scanned ${runs.filter((r) => r.scanned).length}` : '') + + ` | wall ${((Date.now() - t0) / 1000).toFixed(0)} s`); + console.log(' per seed: ' + runs.map((r) => `${r.outcome[0]}${r.seconds.toFixed(0)}`).join(' ') + + ` | ship after: energy ${(runs.reduce((a, r) => a + r.energy, 0) / runs.length).toFixed(0)}, shields ${(runs.reduce((a, r) => a + r.fore, 0) / runs.length).toFixed(0)}/${(runs.reduce((a, r) => a + r.aft, 0) / runs.length).toFixed(0)}` + + ` | station ${Math.round(runs[0].stationAway).toLocaleString()} units from the witchpoint`); +} + +console.log('\nwithout fuel scoops, the scoop rows refuse:'); +{ + const g = newGame(20_260_950, {}); + onSideJob(g, 'side-recover'); + arrive(g); + const row = g.coursePanel()?.rows?.find((r) => r.kind === 'mission'); + console.log(` side-recover row: "${row?.what}" why: "${row?.why}"`); +} diff --git a/docs/reviews/missions-2026-09-12/flight-results.txt b/docs/reviews/missions-2026-09-12/flight-results.txt new file mode 100644 index 00000000..54bb5ba0 --- /dev/null +++ b/docs/reviews/missions-2026-09-12/flight-results.txt @@ -0,0 +1,45 @@ +flight probe: 8 seeds per case, ordinary traffic in the sky + +side-hunt: a Krait, pulse laser + done 8 failed 0 dead 0 timeout 0 of 8 | time to done: mean 4 s, worst 5 s | fights per run 1.0 | kills 8 | wall 0 s + per seed: d5 d4 d4 d5 d4 d4 d5 d4 | ship after: energy 254, shields 255/255 | station 71,626 units from the witchpoint +arc-lave runner: a Cobra Mk III, pulse laser + done 8 failed 0 dead 0 timeout 0 of 8 | time to done: mean 4 s, worst 5 s | fights per run 1.0 | kills 8 | wall 0 s + per seed: d4 d5 d5 d5 d5 d4 d5 d4 | ship after: energy 254, shields 255/255 | station 63,792 units from the witchpoint +arc-xeer chase: a Fer-de-Lance, pulse laser + done 8 failed 0 dead 0 timeout 0 of 8 | time to done: mean 8 s, worst 9 s | fights per run 1.0 | kills 7 | wall 0 s + per seed: d6 d9 d8 d9 d9 d7 d9 d6 | ship after: energy 254, shields 162/255 | station 63,958 units from the witchpoint +arc-edle purge: an Asp, pulse laser + done 8 failed 0 dead 0 timeout 0 of 8 | time to done: mean 12 s, worst 13 s | fights per run 1.0 | kills 8 | wall 0 s + per seed: d11 d13 d11 d12 d13 d13 d11 d11 | ship after: energy 254, shields 105/255 | station 64,040 units from the witchpoint +constrictor hunt, pulse laser + done 8 failed 0 dead 0 timeout 0 of 8 | time to done: mean 62 s, worst 66 s | fights per run 1.0 | kills 8 | wall 0 s + per seed: d64 d63 d60 d59 d64 d61 d66 d57 | ship after: energy 213, shields 130/219 | station 64,405 units from the witchpoint +side-scan: an Anaconda for 20 s + done 8 failed 0 dead 0 timeout 0 of 8 | time to done: mean 24 s, worst 27 s | fights per run 0.1 | kills 1 | wall 0 s + per seed: d25 d23 d23 d23 d27 d22 d27 d21 | ship after: energy 255, shields 255/255 | station 69,173 units from the witchpoint + escort seed 1: timeout; the charge is alive, phase arriving, 37,845 units from the station, docked false + escort seed 2: timeout; the charge is alive, phase arriving, 104,860 units from the station, docked false + escort seed 5: dead; the charge is alive, phase arriving, 8,620 units from the station, docked false + escort seed 7: timeout; the charge is alive, phase arriving, 28,391 units from the station, docked false +side-escort: a Python to station range + done 4 failed 0 dead 1 timeout 3 of 8 | time to done: mean 497 s, worst 519 s | fights per run 0.3 | kills 2 | wall 2 s + per seed: d516 t900 t900 d519 d490 d559 d464 t900 | ship after: energy 255, shields 255/255 | station 72,080 units from the witchpoint +side-recover: scoop a canister (scoops fitted) + done 8 failed 0 dead 0 timeout 0 of 8 | time to done: mean 14 s, worst 23 s | fights per run 0.3 | kills 2 | wall 0 s + per seed: d23 d14 d11 d11 d9 d13 d19 d12 | ship after: energy 255, shields 255/255 | station 62,707 units from the witchpoint +side-rescue: scoop a pod (scoops fitted) + done 8 failed 0 dead 0 timeout 0 of 8 | time to done: mean 13 s, worst 26 s | fights per run 0.1 | kills 1 | wall 0 s + per seed: d8 d18 d13 d10 d13 d6 d26 d8 | ship after: energy 255, shields 255/255 | station 81,801 units from the witchpoint +side-ambush: the lane, then dock (docking computer) + done 8 failed 0 dead 0 timeout 0 of 8 | time to done: mean 130 s, worst 141 s | fights per run 3.1 | kills 43 | wall 1 s + per seed: d122 d138 d131 d141 d132 d135 d106 d139 | ship after: energy 255, shields 255/255 | station 70,808 units from the witchpoint +side-deliver: fly to the station and dock (docking computer) + done 8 failed 0 dead 0 timeout 0 of 8 | time to done: mean 125 s, worst 144 s | fights per run 1.4 | kills 10 | wall 0 s + per seed: d106 d144 d141 d121 d113 d137 d144 d98 | ship after: energy 255, shields 255/255 | station 72,080 units from the witchpoint +side-smuggle: slip past the police and dock (docking computer) + done 8 failed 0 dead 0 timeout 0 of 8 | time to done: mean 116 s, worst 134 s | fights per run 2.6 | kills 27 | scanned 0 | wall 1 s + per seed: d117 d111 d98 d134 d123 d124 d104 d111 | ship after: energy 255, shields 255/255 | station 69,173 units from the witchpoint + +without fuel scoops, the scoop rows refuse: + side-recover row: "RECOVER THE CARGO" why: "NEEDS FUEL SCOOPS" diff --git a/docs/reviews/missions-2026-09-12/probe.ts b/docs/reviews/missions-2026-09-12/probe.ts new file mode 100644 index 00000000..73204e6a --- /dev/null +++ b/docs/reviews/missions-2026-09-12/probe.ts @@ -0,0 +1,146 @@ +// The probes behind docs/MISSIONS-REVIEW.md. Each block drives the real +// mission machine with no game world, as test/mission-machine.test.ts does. +// +// node --experimental-strip-types --no-warnings docs/reviews/missions-2026-09-12/probe.ts +// +// The output is committed beside it as results.txt. + +import { generateGalaxy } from '../../../src/galaxy/galaxy.ts'; +import { routeTable } from '../../../src/galaxy/route.ts'; +import { stepMissions } from '../../../src/missions/machine.ts'; +import { canAccept, offersFor, sideJobsAt } from '../../../src/missions/offers.ts'; +import { emptyMissionState } from '../../../src/missions/state.ts'; +import { SKELETONS } from '../../../src/missions/skeletons/index.ts'; +import { SIDE_JOBS } from '../../../src/missions/skeletons/side.ts'; +import { pickByJumps } from '../../../src/missions/placement.ts'; +import { patronFor } from '../../../src/missions/patrons.ts'; +import { storyPages } from '../../../src/missions/story.ts'; +import { NARCOTICS } from '../../../src/constants/commodities.ts'; +import { specForDesign, SOURCE_DESIGN } from '../../../src/game/ship-specs.ts'; +import { shipDesignIdOf } from '../../../src/game/ship-identity.ts'; +import type { CommanderFacts, MissionState } from '../../../src/missions/model.ts'; + +const g1 = generateGalaxy(1); +const g2 = generateGalaxy(2); +const facts = (o: Partial = {}): CommanderFacts => ({ + galaxy: 1, systemIndex: 7, kills: 0, combatScore: 0, legalStatus: 0, day: 0, cargo: new Array(17).fill(0), ...o, +}); +const ctx = (c: Partial = {}, systems = g1, skeletons?: readonly typeof SKELETONS[number][]) => + ({ commander: facts(c), systems, rng: () => 0.5, ...(skeletons ? { skeletons } : {}) }); +const boardWith = (id: string): number => + g1.find((s) => sideJobsAt(s, SKELETONS).some((j) => j.id === id))!.index; +const start = (id: string) => { + const here = boardWith(id); + const r = stepMissions(emptyMissionState(), { kind: 'accept', skeleton: id }, ctx({ systemIndex: here })); + if (!r.state.live.length) throw new Error(`${id} not accepted at ${here}`); + return { r, here }; +}; +const kinds = (effects: { kind: string; text?: string }[]): string[] => + effects.map((e) => e.kind + (e.text ? ':' + e.text : '')); + +console.log('[1] an arc is offered in every galaxy at its seed index'); +{ + const c2 = { commander: facts({ galaxy: 2, systemIndex: 7 }), systems: g2 }; + console.log(' canAccept arc-lave at galaxy 2 index 7:', canAccept(emptyMissionState(), 'arc-lave', c2)); + console.log(' galaxy-2 world at index 7:', g2[7].name, '| patron:', patronFor({ kind: 'world', seedSlot: 7 }, facts({ galaxy: 2 }), g2).name); + console.log(' offers there:', offersFor(emptyMissionState(), c2).map((s) => s.id).join(' ')); + // After a galactic jump the lead moves to the tour world, and the arc it opens + // then hands over toward a seed index, not the tour. + let r = stepMissions(emptyMissionState(), { kind: 'accept', skeleton: 'arc-lave' }, ctx()); + r = stepMissions(r.state, { kind: 'galaxyChanged', from: 1, to: 2 }, ctx({ galaxy: 2, systemIndex: 7 }, g2)); + const lead = r.state.leads[0]; + console.log(' lead after the jump:', JSON.stringify(lead), '| announced world:', (r.effects.find((e) => e.kind === 'lead') as { world: number }).world); + r = stepMissions(r.state, { kind: 'accept', skeleton: 'arc-rabedira' }, ctx({ galaxy: 2, systemIndex: lead.world }, g2)); + console.log(' arc-rabedira accepted at the relocated lead:', r.state.live.length === 1); + const paper = r.state.live[0]; + r = stepMissions(r.state, { kind: 'docked' }, ctx({ galaxy: 2, systemIndex: paper.target! }, g2)); + const toGoal = routeTable(g2, 100).jumps; + console.log(` convoy leg placed ${toGoal[r.state.live[0].target!]} jumps from galaxy-2 index 100 (${g2[100].name}), which is not the tour`); +} + +console.log('\n[2] a side job with no cap is offered once per career'); +{ + console.log(' caps:', SIDE_JOBS.map((s) => `${s.id}=${s.cap}`).join(' ')); + const { r, here } = start('side-recover'); + const ended = stepMissions(r.state, { kind: 'abandon', skeleton: 'side-recover' }, ctx({ systemIndex: here, day: 10 })); + for (const day of [11, 17, 18, 400]) { + console.log(` canAccept side-recover at its board on day ${day}:`, canAccept(ended.state, 'side-recover', { commander: facts({ systemIndex: here, day }), systems: g1 })); + } +} + +console.log('\n[3] a smuggle run pays and leaves the goods aboard'); +{ + const { r } = start('side-smuggle'); + const cargo = new Array(17).fill(0); cargo[NARCOTICS] = 3; + const done = stepMissions(r.state, { kind: 'docked' }, ctx({ systemIndex: r.state.live[0].target!, cargo })); + console.log(' effects on success:', done.effects.map((e) => e.kind + (e.kind === 'pay' ? `(${e.tenths})` : e.kind === 'cargo' ? `(${e.tonnes})` : '')).join(' ')); +} + +console.log('\n[4] what each ship verb makes of the four ways a target can go'); +for (const id of ['side-hunt', 'side-scan', 'side-escort']) { + const { r } = start(id); + const tag = r.state.live[0].tag!; + for (const kind of ['fled', 'escaped', 'escortLost', 'destroyed'] as const) { + const s = stepMissions(r.state, { kind, tag }, ctx()); + const pay = s.effects.filter((e) => e.kind === 'pay').map((e) => (e as { tenths: number }).tenths).join(','); + console.log(` ${id.padEnd(11)} ${kind.padEnd(10)} live=${s.state.live.length} done=${s.state.done[id] ?? '-'} entityAlive=${s.state.entities[tag]?.alive} pay=${pay || '-'} says=${s.effects.filter((e) => e.kind === 'say').length}`); + } +} + +console.log('\n[5] the dock hint is shadowed by the side-job count'); +{ + const jumps = routeTable(g1, 6).jumps; + const oneOut = g1.find((s) => jumps[s.index] === 1)!; + const st: MissionState = { ...emptyMissionState(), done: { 'arc-lave': 'complete' }, leads: [{ skeleton: 'arc-rabedira', galaxy: 1, world: 6, sinceDay: 0 }] }; + const r = stepMissions(st, { kind: 'docked' }, ctx({ systemIndex: oneOut.index })); + console.log(` dock at ${oneOut.name}, one jump from Rabedira:`, kinds(r.effects).join(' | ')); + const r2 = stepMissions(st, { kind: 'docked' }, ctx({ systemIndex: oneOut.index }, g1, SKELETONS.filter((s) => s.kind !== 'side'))); + console.log(' the same dock with the side jobs removed:', kinds(r2.effects).join(' | ')); + const far = g1.find((s) => jumps[s.index] === 3)!; + const r3 = stepMissions({ ...st, idleDocks: 3 }, { kind: 'docked' }, ctx({ systemIndex: far.index })); + console.log(` fourth idle dock at ${far.name}, three jumps out:`, kinds(r3.effects).join(' | ')); +} + +console.log('\n[6] a saved record that names a ghost skeleton or leg'); +{ + const ghost: MissionState = { ...emptyMissionState(), live: [{ skeleton: 'arc-ghost', leg: 'x', target: null, tag: null, progress: 0, deadlineDay: null }] }; + const oldLeg: MissionState = { ...emptyMissionState(), live: [{ skeleton: 'arc-lave', leg: 'old', target: null, tag: null, progress: 0, deadlineDay: null }] }; + for (const [name, st, input] of [ + ['ghost skeleton, docked', ghost, { kind: 'docked' }], + ['ghost skeleton, abandon', ghost, { kind: 'abandon', skeleton: 'arc-ghost' }], + ['ghost leg, docked', oldLeg, { kind: 'docked' }], + ] as const) { + try { stepMissions(st, input, ctx()); console.log(` ${name}: ok`); } + catch (e) { console.log(` ${name}: THROWS "${(e as Error).message}"`); } + } +} + +console.log('\n[7] the journal holds no galaxy, so the log misnames a world after a jump'); +{ + let r = stepMissions(emptyMissionState(), { kind: 'accept', skeleton: 'arc-lave' }, ctx()); + r = stepMissions(r.state, { kind: 'galaxyChanged', from: 1, to: 2 }, ctx({ galaxy: 2, systemIndex: 7 }, g2)); + const inG1 = storyPages(r.state, g1)[0].lines[0]; + const inG2 = storyPages(r.state, g2)[0].lines[0]; + console.log(' the acceptance line, rendered with galaxy 1:', inG1); + console.log(' the same line, rendered with galaxy 2: ', inG2); +} + +console.log('\n[8] a local patron\'s standing is keyed by where the branch settles'); +{ + const { r, here } = start('side-deliver'); + const target = r.state.live[0].target!; + const done = stepMissions(r.state, { kind: 'docked' }, ctx({ systemIndex: target })); + console.log(` accepted at ${g1[here].name} (${here}), delivered at ${g1[target].name} (${target}), standing:`, JSON.stringify(done.state.standing)); +} + +console.log('\n[9] the pirate row a restored mission ship is looked up under'); +for (const k of ['python', 'cobraMk3', 'anaconda', 'boa', 'transporter'] as const) { + const id = shipDesignIdOf(SOURCE_DESIGN[k]); + console.log(` ${k.padEnd(12)} pirate row: ${String(!!specForDesign('pirate', id)).padEnd(5)} trader row: ${!!specForDesign('trader', id)}`); +} + +console.log('\n[10] handover placement has a candidate from every world of galaxy 1'); +for (const [g, name] of [[6, 'Rabedira'], [100, 'Vetitice'], [150, 'Xeer'], [162, 'Edle']] as const) { + const dry = g1.filter((s) => pickByJumps(g1, s.index, g, { min: 2, max: 4 }, () => 0.5) === null); + console.log(` toward ${name.padEnd(9)} worlds with no candidate: ${dry.length}`); +} diff --git a/docs/reviews/missions-2026-09-12/results.txt b/docs/reviews/missions-2026-09-12/results.txt new file mode 100644 index 00000000..ac94d2b7 --- /dev/null +++ b/docs/reviews/missions-2026-09-12/results.txt @@ -0,0 +1,61 @@ +[1] an arc is offered in every galaxy at its seed index + canAccept arc-lave at galaxy 2 index 7: true + galaxy-2 world at index 7: Esrilees | patron: THE COMPANY DIRECTOR OF ESRILEES + offers there: arc-lave side-deliver side-smuggle side-escort + lead after the jump: {"skeleton":"arc-rabedira","galaxy":2,"world":11,"sinceDay":0} | announced world: 6 + arc-rabedira accepted at the relocated lead: true + convoy leg placed 4 jumps from galaxy-2 index 100 (Isusle), which is not the tour + +[2] a side job with no cap is offered once per career + caps: side-hunt=undefined side-deliver=undefined side-recover=undefined side-rescue=undefined side-ambush=undefined side-smuggle=undefined side-escort=undefined side-scan=undefined + canAccept side-recover at its board on day 11: false + canAccept side-recover at its board on day 17: false + canAccept side-recover at its board on day 18: false + canAccept side-recover at its board on day 400: false + +[3] a smuggle run pays and leaves the goods aboard + effects on success: pay(7000) say deed say + +[4] what each ship verb makes of the four ways a target can go + side-hunt fled live=1 done=- entityAlive=true pay=- says=0 + side-hunt escaped live=0 done=fail entityAlive=undefined pay=- says=1 + side-hunt escortLost live=0 done=complete entityAlive=undefined pay=8000 says=1 + side-hunt destroyed live=0 done=complete entityAlive=undefined pay=8000 says=1 + side-scan fled live=1 done=- entityAlive=true pay=- says=0 + side-scan escaped live=0 done=fail entityAlive=undefined pay=- says=1 + side-scan escortLost live=1 done=- entityAlive=true pay=- says=0 + side-scan destroyed live=0 done=fail entityAlive=undefined pay=- says=1 + side-escort fled live=1 done=- entityAlive=true pay=- says=0 + side-escort escaped live=0 done=fail entityAlive=undefined pay=- says=1 + side-escort escortLost live=0 done=fail entityAlive=undefined pay=- says=1 + side-escort destroyed live=0 done=fail entityAlive=undefined pay=- says=1 + +[5] the dock hint is shadowed by the side-job count + dock at Leleer, one jump from Rabedira: say:THERE ARE 2 SIDE JOBS ON THE STATION BOARD. + the same dock with the side jobs removed: later:A MESSAGE FROM RABEDIRA: COME WHEN YOU CAN. THERE IS WORK. + fourth idle dock at Ontimaxe, three jumps out: say:THERE ARE 3 SIDE JOBS ON THE STATION BOARD. + +[6] a saved record that names a ghost skeleton or leg + ghost skeleton, docked: THROWS "mission arc-ghost: no such skeleton" + ghost skeleton, abandon: THROWS "mission arc-ghost: no such skeleton" + ghost leg, docked: THROWS "mission arc-lave: no leg old" + +[7] the journal holds no galaxy, so the log misnames a world after a jump + the acceptance line, rendered with galaxy 1: On day 0 the commander took the governor's contract at LAVE, to chase down a stolen ledger. + the same line, rendered with galaxy 2: On day 0 the commander took the governor's contract at ESRILEES, to chase down a stolen ledger. + +[8] a local patron's standing is keyed by where the branch settles + accepted at Tiraor (5), delivered at Edzaon (159), standing: {"world-159":1} + +[9] the pirate row a restored mission ship is looked up under + python pirate row: true trader row: true + cobraMk3 pirate row: true trader row: true + anaconda pirate row: false trader row: true + boa pirate row: false trader row: true + transporter pirate row: false trader row: true + +[10] handover placement has a candidate from every world of galaxy 1 + toward Rabedira worlds with no candidate: 0 + toward Vetitice worlds with no candidate: 0 + toward Xeer worlds with no candidate: 0 + toward Edle worlds with no candidate: 0 From e2b0fe64f8f27bbc71a115f2122caa384241ea9e Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Sun, 13 Sep 2026 09:25:57 +0100 Subject: [PATCH 062/100] docs/TODO/213 M1: a hit trader goes back to work, and the escort ends A trader that took a hit fled for the rest of its life, so an escort's charge that a pirate grazed, or that the commander's own course bumped, never reached the station. Three escorts of eight stalled and one crashed. A new clock on the ship, `calm`, counts the seconds since the last hit. A trader calm for TRADER_CALM_SECONDS with nobody hunting it goes back to its working life. The escort and scan verbs answer `fled` as an escape, and the scan verb takes a subject wrecked by nobody as destroyed. The escort course caps its closing speed inside three standoffs, so it cannot ram its charge. A mission course refuses a target below the planet's clearance, and says why, rather than fly the commander after it. The four numbers a mission's course spends left constants/course.ts, which crossed the size ceiling, for constants/mission-course.ts. The flight probe finishes eight escorts of eight now, from four. Co-Authored-By: Claude Fable 5.1 Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- ...hold-and-a-hit-trader-goes-back-to-work.md | 24 ++++++- src/constants/CATALOG.md | 52 +++++++-------- src/constants/attack-run.ts | 16 +++++ src/constants/course.ts | 41 ------------ src/constants/mission-course.ts | 64 +++++++++++++++++++ src/game/course-clearance.ts | 5 +- src/game/course-pilot.ts | 25 +++++++- src/game/flight-course.ts | 11 ++-- src/game/npc-state.ts | 8 ++- src/game/npc-trader.ts | 9 +++ src/game/npc.ts | 2 + src/missions/verbs/escort.ts | 6 +- src/missions/verbs/scan.ts | 8 ++- test/course-pilot.test.ts | 16 +++++ test/mission-courses.test.ts | 29 ++++++++- test/mission-verbs.test.ts | 8 +++ test/npc-trader.test.ts | 22 +++++++ 17 files changed, 261 insertions(+), 85 deletions(-) create mode 100644 src/constants/mission-course.ts diff --git a/docs/TODO/213-the-mission-rules-hold-and-a-hit-trader-goes-back-to-work.md b/docs/TODO/213-the-mission-rules-hold-and-a-hit-trader-goes-back-to-work.md index 6c1746da..69f1b5af 100644 --- a/docs/TODO/213-the-mission-rules-hold-and-a-hit-trader-goes-back-to-work.md +++ b/docs/TODO/213-the-mission-rules-hold-and-a-hit-trader-goes-back-to-work.md @@ -177,4 +177,26 @@ Evidence, one per fault: ## What the milestones found -Written as each milestone lands. +### M1 + +- **The escort finishes eight of eight.** The flight probe ran again after + the milestone. Before it, four escorts of eight finished, three stalled + and one crashed. After it, all eight finish, in 488 to 525 seconds, and + the ship ends with shields 249 and 255. +- **The calm is one clock on the ship**, `calm`, the seconds since the last + hit. `takeDamage` resets it and `tickClocks` runs it, beside + `underFire`. The snapshot walks `NpcState` generically, so a save carries + it and an old save reads it as 0. `TRADER_CALM_SECONDS` is twenty, and it + lives beside `UNDER_FIRE_SECONDS` under `@rule trader.calmSeconds`. +- **A course that ends for a reason is not done.** `endCourse` used to add + every ended course to `coursesDone`, which takes it off the list for the + visit. A refusal now leaves it on the list, so the pilot can pick the job + again once the charge climbs out of the planet. +- **Ninety seconds beside the charge cost no shield**, and the ship never + came inside a quarter of the standoff. The real-game test holds both. +- **`constants/course.ts` crossed the size ceiling by three lines.** The + four numbers a mission's course spends left it for + `constants/mission-course.ts`: the scan standoff, the escort standoff, + the escort closing speed and the police clearance. Their rule ids stay + under `course.`, and each says `@domain mission-course`. +- The suite gains 13 checks, to 5,984. diff --git a/src/constants/CATALOG.md b/src/constants/CATALOG.md index 180be021..103b98c2 100644 --- a/src/constants/CATALOG.md +++ b/src/constants/CATALOG.md @@ -2,7 +2,7 @@ -458 exported constants. Regenerate with `npm run generate:constants`; +460 exported constants. Regenerate with `npm run generate:constants`; search names, meanings and values with `npm run constants:find -- ""`. | Domain | Symbol | Literal / expression | Purpose | Rule ID | Source | @@ -15,8 +15,9 @@ search names, meanings and values with `npm run constants:find -- ""`. | attack-run | EXTEND_RANGE_MAX | 850 | | | [attack-run.ts:28](./attack-run.ts#L28) | | attack-run | EXTEND_RANGE | (EXTEND_RANGE_MIN + EXTEND_RANGE_MAX) / 2 | Default turn-back range for a caller that rolled none — mid-band. | | [attack-run.ts:31](./attack-run.ts#L31) | | attack-run | UNDER_FIRE_SECONDS | 1.2 | How long a ship keeps to evasive flight after the last hit. | | [attack-run.ts:37](./attack-run.ts#L37) | -| attack-run | CLOSING_THROTTLE_MIN | 0.45 | The slowest that an attacking ship throttles back to in order to turn. | | [attack-run.ts:45](./attack-run.ts#L45) | -| attack-run | MIN_CRUISE_FRACTION | 0.43 | A hostile cannot throttle below this fraction of its top speed. | | [attack-run.ts:52](./attack-run.ts#L52) | +| attack-run | TRADER_CALM_SECONDS | 20 | How long a trader keeps to its run after the last hit it took: twenty seconds. | trader.calmSeconds | [attack-run.ts:53](./attack-run.ts#L53) | +| attack-run | CLOSING_THROTTLE_MIN | 0.45 | The slowest that an attacking ship throttles back to in order to turn. | | [attack-run.ts:61](./attack-run.ts#L61) | +| attack-run | MIN_CRUISE_FRACTION | 0.43 | A hostile cannot throttle below this fraction of its top speed. | | [attack-run.ts:68](./attack-run.ts#L68) | | audio | AUDIBLE_RANGE | SCANNER_RANGE | How far a bang carries, in world units. | audio.audibleRange | [audio.ts:35](./audio.ts#L35) | | audio | STEREO_WIDTH | 0.7 | How far across the stereo field a sound may sit: 0 is mono, 1 is one ear only. | audio.stereoWidth | [audio.ts:58](./audio.ts#L58) | | blame | PROVOKES | { laser: true, missile: true, bomb: true, ram: false, } | Which of the commander's damage sources provoke the ship they hit. | | [blame.ts:22](./blame.ts#L22) | @@ -117,28 +118,25 @@ search names, meanings and values with `npm run constants:find -- ""`. | contracts | CONTRACT_RANGE | MAX_FUEL | How far away a contract may send you, in tenths of a light year: exactly as far as a full tank reaches. | | [contracts.ts:27](./contracts.ts#L27) | | contracts | PASSENGER_BERTH_TONNES | 2 | What one passenger costs the hold, in tonnes. | contracts.passengerBerthTonnes | [contracts.ts:51](./contracts.ts#L51) | | contracts | SMUGGLE_DELIVERY_NOTORIETY | 0.06 | How loudly a delivered smuggling run is talked about, per tonne landed. | contracts.smuggleDeliveryNotoriety | [contracts.ts:81](./contracts.ts#L81) | -| course | COURSE_TORUS_CONE | 0.1 | How far off the nose the target may sit, in radians, before the course pilot engages the torus drive. | course.torusCone | [course.ts:32](./course.ts#L32) | -| course | COURSE_AIM_DEADZONE | 0.02 | How near the nose a course counts its target as straight ahead, in radians. | | [course.ts:56](./course.ts#L56) | -| course | COURSE_ROLL_GATE | 0.05 | How near its bank a course pilot must be before it pulls the nose, in radians. | | [course.ts:83](./course.ts#L83) | -| course | COURSE_TORUS_DROP | TORUS_MULTIPLIER * PLAYER_FLIGHT.maxSpeed * 2.5 | How far from its target the course pilot drops the torus drive, in world units, before an arrival. | | [course.ts:96](./course.ts#L96) | -| course | COURSE_ARRIVE_BRAKE | 0.7 | The share of the ship's thrust that an arrival plans to brake with. | course.arriveBrake | [course.ts:108](./course.ts#L108) | -| course | COURSE_ARRIVE_TOLERANCE | 75 | How near its standoff the ship must be to count as arrived, in world units. | course.arriveTolerance | [course.ts:118](./course.ts#L118) | -| course | COURSE_DERELICT_STANDOFF | GENERATION_CARGO_SCATTER + 400 | Where the derelict course stops, as a distance from the generation ship's centre, in world units. | | [course.ts:131](./course.ts#L131) | -| course | COURSE_HERMIT_STANDOFF | 240 | Where the hermit course stops, as a distance from the rock's centre, in world units. | course.hermitStandoff | [course.ts:144](./course.ts#L144) | -| course | COURSE_SKIM_DISTANCE | 65_000 | The hold distance of the skim course, from the centre of the star, in world units. | course.skimDistance | [course.ts:159](./course.ts#L159) | -| course | COURSE_PLANET_CLEARANCE | MASS_LOCK_PLANET_ALTITUDE * 1.25 | How high above the planet's surface a course keeps its line, in world units. | | [course.ts:171](./course.ts#L171) | -| course | COURSE_HERMIT_SPEED | HERMIT_DOCK_SPEED / 2 | The speed at which the hermit course arrives, in world units a second. | | [course.ts:181](./course.ts#L181) | -| course | SKIP_SPEED | 8 | How much faster the world runs under the fast forward button, as a count of fixed steps in one screen frame (docs/TODO/205 M7). | course.skipSpeed | [course.ts:197](./course.ts#L197) | -| course | RUN_CLOSE_MARGIN | 50 | Below this lead in top speed, in world units a second, the run row says the ship is only a little faster (docs/TODO/206 M5). | course.runCloseMargin | [course.ts:211](./course.ts#L211) | -| course | COURSE_RUN_REACH | 50_000 | How far ahead the run course aims, in world units, on the line away from the hostile ships (docs/TODO/206 M5). | course.runReach | [course.ts:221](./course.ts#L221) | -| course | COURSE_COLLECT_SPEED | 60 | How fast the collect course flies onto a canister, in world units a second (docs/TODO/206 M6). | course.collectSpeed | [course.ts:235](./course.ts#L235) | -| course | COURSE_COLLECT_LEAD | 5 | The furthest ahead of a drifting canister the collect course will aim, in seconds. | course.collectLead | [course.ts:270](./course.ts#L270) | -| course | COURSE_COLLECT_CAP | COURSE_COLLECT_SPEED * 2 | The fastest the collect course flies on its way to a canister, in world units a second. | course.collectCap | [course.ts:307](./course.ts#L307) | -| course | COURSE_DOCK_HANDOVER | 1500 | How far from the station the station course hands the ship to the pilot, in world units (docs/TODO/207 M1). | course.dockHandover | [course.ts:321](./course.ts#L321) | -| course | COURSE_WATCH_STANDOFF | 1200 | How far from a ship the scan course holds, in world units (docs/TODO/208 M2). | course.watchStandoff | [course.ts:335](./course.ts#L335) | -| course | COURSE_ESCORT_STANDOFF | 600 | How far from its charge the escort course flies, in world units (docs/TODO/208 M2). | course.escortStandoff | [course.ts:348](./course.ts#L348) | -| course | COURSE_POLICE_CLEARANCE | SCAN_WARN_RANGE | How wide of a police ship the smuggling course flies, in world units (docs/TODO/208 M4). | | [course.ts:361](./course.ts#L361) | -| course | COURSE_OBSTACLE_CLEARANCE | PLAYER_FLIGHT.maxSpeed / PLAYER_FLIGHT.maxPitch | How far clear of a solid thing's HULL a course flies, in world units. | | [course.ts:387](./course.ts#L387) | +| course | COURSE_TORUS_CONE | 0.1 | How far off the nose the target may sit, in radians, before the course pilot engages the torus drive. | course.torusCone | [course.ts:31](./course.ts#L31) | +| course | COURSE_AIM_DEADZONE | 0.02 | How near the nose a course counts its target as straight ahead, in radians. | | [course.ts:55](./course.ts#L55) | +| course | COURSE_ROLL_GATE | 0.05 | How near its bank a course pilot must be before it pulls the nose, in radians. | | [course.ts:82](./course.ts#L82) | +| course | COURSE_TORUS_DROP | TORUS_MULTIPLIER * PLAYER_FLIGHT.maxSpeed * 2.5 | How far from its target the course pilot drops the torus drive, in world units, before an arrival. | | [course.ts:95](./course.ts#L95) | +| course | COURSE_ARRIVE_BRAKE | 0.7 | The share of the ship's thrust that an arrival plans to brake with. | course.arriveBrake | [course.ts:107](./course.ts#L107) | +| course | COURSE_ARRIVE_TOLERANCE | 75 | How near its standoff the ship must be to count as arrived, in world units. | course.arriveTolerance | [course.ts:117](./course.ts#L117) | +| course | COURSE_DERELICT_STANDOFF | GENERATION_CARGO_SCATTER + 400 | Where the derelict course stops, as a distance from the generation ship's centre, in world units. | | [course.ts:130](./course.ts#L130) | +| course | COURSE_HERMIT_STANDOFF | 240 | Where the hermit course stops, as a distance from the rock's centre, in world units. | course.hermitStandoff | [course.ts:143](./course.ts#L143) | +| course | COURSE_SKIM_DISTANCE | 65_000 | The hold distance of the skim course, from the centre of the star, in world units. | course.skimDistance | [course.ts:158](./course.ts#L158) | +| course | COURSE_PLANET_CLEARANCE | MASS_LOCK_PLANET_ALTITUDE * 1.25 | How high above the planet's surface a course keeps its line, in world units. | | [course.ts:170](./course.ts#L170) | +| course | COURSE_HERMIT_SPEED | HERMIT_DOCK_SPEED / 2 | The speed at which the hermit course arrives, in world units a second. | | [course.ts:180](./course.ts#L180) | +| course | SKIP_SPEED | 8 | How much faster the world runs under the fast forward button, as a count of fixed steps in one screen frame (docs/TODO/205 M7). | course.skipSpeed | [course.ts:196](./course.ts#L196) | +| course | RUN_CLOSE_MARGIN | 50 | Below this lead in top speed, in world units a second, the run row says the ship is only a little faster (docs/TODO/206 M5). | course.runCloseMargin | [course.ts:210](./course.ts#L210) | +| course | COURSE_RUN_REACH | 50_000 | How far ahead the run course aims, in world units, on the line away from the hostile ships (docs/TODO/206 M5). | course.runReach | [course.ts:220](./course.ts#L220) | +| course | COURSE_COLLECT_SPEED | 60 | How fast the collect course flies onto a canister, in world units a second (docs/TODO/206 M6). | course.collectSpeed | [course.ts:234](./course.ts#L234) | +| course | COURSE_COLLECT_LEAD | 5 | The furthest ahead of a drifting canister the collect course will aim, in seconds. | course.collectLead | [course.ts:269](./course.ts#L269) | +| course | COURSE_COLLECT_CAP | COURSE_COLLECT_SPEED * 2 | The fastest the collect course flies on its way to a canister, in world units a second. | course.collectCap | [course.ts:306](./course.ts#L306) | +| course | COURSE_DOCK_HANDOVER | 1500 | How far from the station the station course hands the ship to the pilot, in world units (docs/TODO/207 M1). | course.dockHandover | [course.ts:320](./course.ts#L320) | +| course | COURSE_OBSTACLE_CLEARANCE | PLAYER_FLIGHT.maxSpeed / PLAYER_FLIGHT.maxPitch | How far clear of a solid thing's HULL a course flies, in world units. | | [course.ts:346](./course.ts#L346) | | docking | GATE_HALF_WIDTHS | 5 | How far out the approach gate sits, in multiples of the station half-width. | docking.gateHalfWidths | [docking.ts:25](./docking.ts#L25) | | docking | TURN_IN | Math.PI / 4 | How far round from the slot axis an approach turns in, in radians. | | [docking.ts:49](./docking.ts#L49) | | docking | RUN_IN_WIDTHS | GATE_HALF_WIDTHS * 0.6 | Where the approach stops the curve and flies straight, in station half-widths. | | [docking.ts:87](./docking.ts#L87) | @@ -249,6 +247,10 @@ search names, meanings and values with `npm run constants:find -- ""`. | market | SALE_NOTORIETY_REVENUE | 40_000 | What a sale does to your reputation. | | [market.ts:30](./market.ts#L30) | | market | SALE_NOTORIETY_CONTRABAND | 0.04 | Extra talk per tonne of CONTRABAND sold, on top of the takings. | | [market.ts:45](./market.ts#L45) | | market | SALE_NOTORIETY_MAX | 0.5 | The most heat that one sale can raise, out of the 0..1 bar that `LivingGalaxy` keeps. | market.saleNotorietyMax | [market.ts:61](./market.ts#L61) | +| mission-course | COURSE_WATCH_STANDOFF | 1200 | How far from a ship the scan course holds, in world units (docs/TODO/208 M2). | course.watchStandoff | [mission-course.ts:23](./mission-course.ts#L23) | +| mission-course | COURSE_ESCORT_STANDOFF | 600 | How far from its charge the escort course flies, in world units (docs/TODO/208 M2). | course.escortStandoff | [mission-course.ts:36](./mission-course.ts#L36) | +| mission-course | COURSE_ESCORT_CLOSING | 60 | How much faster than its charge the escort course may close, in world units a second, once it is inside three standoffs of it: sixty. | course.escortClosing | [mission-course.ts:51](./mission-course.ts#L51) | +| mission-course | COURSE_POLICE_CLEARANCE | SCAN_WARN_RANGE | How wide of a police ship the smuggling course flies, in world units (docs/TODO/208 M4). | | [mission-course.ts:64](./mission-course.ts#L64) | | missions | MISSION_KILL_THRESHOLD | 16 | Kills before the Navy considers you worth a word: 16, as the original demanded. | missions.killThreshold | [missions.ts:14](./missions.ts#L14) | | missions | MISSION_HUNT_RANGE | { min: 30, max: 80 } as const | The Constrictor hides this far from where you are briefed, in tenths of a light year. | | [missions.ts:22](./missions.ts#L22) | | missions | MISSION_COURIER_RANGE | { min: 50, max: 90 } as const | The courier run is longer: the plans matter more than your convenience. | | [missions.ts:25](./missions.ts#L25) | diff --git a/src/constants/attack-run.ts b/src/constants/attack-run.ts index e67fbec2..62f9fc97 100644 --- a/src/constants/attack-run.ts +++ b/src/constants/attack-run.ts @@ -36,6 +36,22 @@ export const EXTEND_RANGE = (EXTEND_RANGE_MIN + EXTEND_RANGE_MAX) / 2; */ export const UNDER_FIRE_SECONDS = 1.2; +/** + * How long a trader keeps to its run after the last hit it took: twenty + * seconds. After that, with no live attacker, it goes back to work. + * + * A trader that took a hit ran for the rest of its life until docs/TODO/213 + * M1. An escort's charge that a pirate grazed then flew from the station + * for ever. So did one that the commander's own course bumped. The escort + * could not end. The clock is the same shape as `UNDER_FIRE_SECONDS`: a decay from + * the last hit, not a latch. It is much longer, because a trader that turns + * back into a fight it just fled is a trader that dies. Twenty seconds is a + * pirate wave's approach, so a wave that is still there keeps it running. + * + * @rule trader.calmSeconds + */ +export const TRADER_CALM_SECONDS = 20; + /** * The slowest that an attacking ship throttles back to in order to turn. There * are two literals on purpose. This one sits just above `MIN_CRUISE_FRACTION`, so diff --git a/src/constants/course.ts b/src/constants/course.ts index c7b7c397..60ccc500 100644 --- a/src/constants/course.ts +++ b/src/constants/course.ts @@ -7,7 +7,6 @@ import { HERMIT_DOCK_SPEED } from './hermit-market.ts'; import { PLAYER_FLIGHT } from './player-flight.ts'; import { MASS_LOCK_PLANET_ALTITUDE, TORUS_MULTIPLIER } from './torus.ts'; import { GENERATION_CARGO_SCATTER } from './spawn-placement.ts'; -import { SCAN_WARN_RANGE } from './law.ts'; /** * How far off the nose the target may sit, in radians, before the course @@ -320,46 +319,6 @@ export const COURSE_COLLECT_CAP = COURSE_COLLECT_SPEED * 2; */ export const COURSE_DOCK_HANDOVER = 1500; -/** - * How far from a ship the scan course holds, in world units - * (docs/TODO/208 M2). - * - * A scan counts seconds while the ship is inside `SCANNER_RANGE`, which is - * 6,000, and within `WATCH_CONE` of the nose. So the hold sits well inside - * the range, and near enough that the ship fills a useful part of the cone. - * It is far enough out that a trader's own wandering does not shake it off. - * - * @rule course.watchStandoff - * @domain course - */ -export const COURSE_WATCH_STANDOFF = 1200; - -/** - * How far from its charge the escort course flies, in world units - * (docs/TODO/208 M2). - * - * The escort is safe when no hostile ship is within 3,500 units of the - * charge. A pilot who flies this close is inside that ring, and the fight - * comes to the pilot rather than to the charge. - * - * @rule course.escortStandoff - * @domain course - */ -export const COURSE_ESCORT_STANDOFF = 600; - -/** - * How wide of a police ship the smuggling course flies, in world units - * (docs/TODO/208 M4). - * - * A policeman reads a hold inside `SCAN_RANGE`, which is 2,600 units. This is - * the warning band, `SCAN_WARN_RANGE`, so the course keeps a margin outside - * the range that would end the job. It is the same rule from the other side, - * so the two cannot drift apart. - * - * @domain course - */ -export const COURSE_POLICE_CLEARANCE = SCAN_WARN_RANGE; - /** * How far clear of a solid thing's HULL a course flies, in world units. * diff --git a/src/constants/mission-course.ts b/src/constants/mission-course.ts new file mode 100644 index 00000000..0c9e4f5e --- /dev/null +++ b/src/constants/mission-course.ts @@ -0,0 +1,64 @@ +// How a mission's course flies the ship (docs/TODO/208). +// +// A live job is the first row of the course list. `game/course-pilot.ts` +// flies it in one of five shapes: a fight, a hold, an escort, a scoop and a +// slip past the police. These are the numbers the hold, the escort and the +// slip spend. They left `course.ts` when docs/TODO/213 M1 pushed that file +// over the size ceiling, and a mission's course is a subject of its own. + +import { SCAN_WARN_RANGE } from './law.ts'; + +/** + * How far from a ship the scan course holds, in world units + * (docs/TODO/208 M2). + * + * A scan counts seconds while the ship is inside `SCANNER_RANGE`, which is + * 6,000, and within `WATCH_CONE` of the nose. So the hold sits well inside + * the range, and near enough that the ship fills a useful part of the cone. + * It is far enough out that a trader's own wandering does not shake it off. + * + * @rule course.watchStandoff + * @domain mission-course + */ +export const COURSE_WATCH_STANDOFF = 1200; + +/** + * How far from its charge the escort course flies, in world units + * (docs/TODO/208 M2). + * + * The escort is safe when no hostile ship is within 3,500 units of the + * charge. A pilot who flies this close is inside that ring, and the fight + * comes to the pilot rather than to the charge. + * + * @rule course.escortStandoff + * @domain mission-course + */ +export const COURSE_ESCORT_STANDOFF = 600; + +/** + * How much faster than its charge the escort course may close, in world + * units a second, once it is inside three standoffs of it: sixty. + * + * The approach used to brake from full speed to the charge's own at the + * standoff, and it overshot into the hull (docs/TODO/213 M1). A ram is a hit + * from the commander, and a trader that is hit runs. So the escort's own + * course set its charge to flight in one run of eight. Sixty over the charge + * closes 1,800 units in half a minute, and it stops inside the tolerance. + * + * @rule course.escortClosing + * @domain mission-course + */ +export const COURSE_ESCORT_CLOSING = 60; + +/** + * How wide of a police ship the smuggling course flies, in world units + * (docs/TODO/208 M4). + * + * A policeman reads a hold inside `SCAN_RANGE`, which is 2,600 units. This is + * the warning band, `SCAN_WARN_RANGE`, so the course keeps a margin outside + * the range that would end the job. It is the same rule from the other side, + * so the two cannot drift apart. + * + * @domain mission-course + */ +export const COURSE_POLICE_CLEARANCE = SCAN_WARN_RANGE; diff --git a/src/game/course-clearance.ts b/src/game/course-clearance.ts index 89e047cb..e0995047 100644 --- a/src/game/course-clearance.ts +++ b/src/game/course-clearance.ts @@ -19,9 +19,8 @@ // the side the line already passes, and half as far again. import * as THREE from 'three'; -import { - COURSE_OBSTACLE_CLEARANCE, COURSE_PLANET_CLEARANCE, COURSE_POLICE_CLEARANCE, -} from '../constants/course.ts'; +import { COURSE_OBSTACLE_CLEARANCE, COURSE_PLANET_CLEARANCE } from '../constants/course.ts'; +import { COURSE_POLICE_CLEARANCE } from '../constants/mission-course.ts'; /** Something solid a course must not fly through — see `clearOfObstacles`. */ export interface Obstacle { diff --git a/src/game/course-pilot.ts b/src/game/course-pilot.ts index 22c888c4..ca16a673 100644 --- a/src/game/course-pilot.ts +++ b/src/game/course-pilot.ts @@ -54,9 +54,12 @@ import { SLOT_SPEED_LIMIT } from '../constants/docking.ts'; import { COURSE_AIM_DEADZONE, COURSE_ROLL_GATE, COURSE_ARRIVE_BRAKE, COURSE_ARRIVE_TOLERANCE, COURSE_DERELICT_STANDOFF, COURSE_COLLECT_CAP, COURSE_COLLECT_LEAD, COURSE_HERMIT_SPEED, COURSE_HERMIT_STANDOFF, - COURSE_COLLECT_SPEED, COURSE_ESCORT_STANDOFF, COURSE_RUN_REACH, COURSE_SKIM_DISTANCE, - COURSE_TORUS_CONE, COURSE_TORUS_DROP, COURSE_WATCH_STANDOFF, + COURSE_COLLECT_SPEED, COURSE_PLANET_CLEARANCE, COURSE_RUN_REACH, COURSE_SKIM_DISTANCE, + COURSE_TORUS_CONE, COURSE_TORUS_DROP, } from '../constants/course.ts'; +import { + COURSE_ESCORT_CLOSING, COURSE_ESCORT_STANDOFF, COURSE_WATCH_STANDOFF, +} from '../constants/mission-course.ts'; import { clearOfObstacles, clearOfPlanet, clearOfPolice, type Obstacle, } from './course-clearance.ts'; @@ -129,6 +132,8 @@ export interface CourseStep { readonly handOver: boolean; /** the course is finished, and it leaves the ship */ readonly done: boolean; + /** why it ended before its work was done, for the console; absent for an ordinary end */ + readonly why?: string; } const IDLE: CourseStep = { demand: null, torus: false, handOver: false, done: false }; @@ -236,10 +241,24 @@ export class CoursePilot { // A slip is the station course on a line wide of the police // (docs/TODO/208 M4). It hands the ship over as that course does. if (m.how === 'slip') return this.toStation(v, dt, m.at); + // A TARGET BELOW THE CLEARANCE IS REFUSED (docs/TODO/213 M1). A ship + // does not crash, and a charge that ran flew through the planet with + // the course 600 units behind it. The commander crashed at 80 units + // with full shields. The line round the planet cannot help when the + // target itself is inside it. + if (m.at.distanceTo(v.planetPos) - v.planetRadius < COURSE_PLANET_CLEARANCE) { + return { ...ended(), why: 'THE TARGET IS TOO NEAR THE PLANET — COURSE OFF' }; + } const standoff = m.how === 'hold' ? COURSE_WATCH_STANDOFF : m.how === 'escort' ? COURSE_ESCORT_STANDOFF : 0; const speed = m.how === 'scoop' ? COURSE_COLLECT_SPEED : m.speed; - return { ...this.arrive(v, { target: m.at, standoff, speed }, dt), done: false }; + // An escort closes gently. Inside three standoffs its speed is the + // charge's plus `COURSE_ESCORT_CLOSING`, so the approach cannot ram + // the charge and set it to flight (docs/TODO/213 M1). + const near = m.how === 'escort' + && v.position.distanceTo(m.at) <= COURSE_ESCORT_STANDOFF * 3; + const cap = near ? m.speed + COURSE_ESCORT_CLOSING : undefined; + return { ...this.arrive(v, { target: m.at, standoff, speed, cap }, dt), done: false }; } default: return IDLE; } diff --git a/src/game/flight-course.ts b/src/game/flight-course.ts index 58452ffb..c4165485 100644 --- a/src/game/flight-course.ts +++ b/src/game/flight-course.ts @@ -157,7 +157,7 @@ export class FlightCourse { if (step.torus !== s.torusEngaged && (!step.torus || !this.host.massLocked())) { this.host.toggleTorus(); } - if (step.done) this.endCourse(s.course); + if (step.done) this.endCourse(s.course, step.why); return step.demand; } @@ -275,15 +275,16 @@ export class FlightCourse { * A course finished its work. It leaves the ship, and it leaves the list * for the rest of the visit. The console says what the ship did. */ - private endCourse(kind: CourseKind): void { + private endCourse(kind: CourseKind, why?: string): void { const s = this.state.session; s.course = null; - if (!s.coursesDone.includes(kind)) s.coursesDone.push(kind); + // A course that ended for a reason is not done: the list offers it again. + if (why === undefined && !s.coursesDone.includes(kind)) s.coursesDone.push(kind); this.coursePilot.reset(); // The derelict's own words, read off the world's seed (docs/TODO/208 M5). - const said = kind === 'derelict' + const said = why ?? (kind === 'derelict' ? derelictReport(this.state.systems[this.state.commander.systemIndex] as StarSystem) - : COURSE_ENDS[kind]; + : COURSE_ENDS[kind]); if (said) this.host.showMessage(said, 6); } } diff --git a/src/game/npc-state.ts b/src/game/npc-state.ts index a0d4e0d2..c0b5a73a 100644 --- a/src/game/npc-state.ts +++ b/src/game/npc-state.ts @@ -153,6 +153,12 @@ export interface NpcState { flownBy: 'brain' | 'scripted' | 'pursuit' | 'fleeing' | 'none'; /** seconds of evasive flying left after the last hit taken — see break-off.ts */ underFire: number; + /** + * Seconds since the last hit this ship took. A trader that fled reads it + * against `TRADER_CALM_SECONDS` to go back to work (docs/TODO/213 M1). It + * is saved with the rest, and an old save reads it as 0. + */ + calm: number; /** * How far out THIS run goes before turning back, rolled from the band in * break-off.ts every time the ship starts extending. State for `hasEcm`'s @@ -275,7 +281,7 @@ export function freshNpcState(maxEnergy: number): NpcState { tumbleAxis: randomDirection(new THREE.Vector3()), energy: maxEnergy, regenCarry: 0, alive: true, provoked: false, provokedByPlayer: false, missiles: 0, - missionTag: null, targeted: false, announcedClose: false, observed: 0, missionReported: false, fleeing: false, attackPhase: 'closing', underFire: 0, flownBy: 'none', + missionTag: null, targeted: false, announcedClose: false, observed: 0, missionReported: false, fleeing: false, attackPhase: 'closing', underFire: 0, calm: 0, flownBy: 'none', extendRange: EXTEND_RANGE_MAX, passSide: 1, passesMade: 0, tactic: 'run', tacticClock: 0, dryFor: 0, tradeTimer: 0, diff --git a/src/game/npc-trader.ts b/src/game/npc-trader.ts index 38dedce8..c947858e 100644 --- a/src/game/npc-trader.ts +++ b/src/game/npc-trader.ts @@ -31,6 +31,7 @@ import * as THREE from 'three'; import { defenceBrain } from './brains.ts'; import { defenceBrainNameFor } from './brain-names.ts'; import { TURN_AND_FIGHT_RANGE } from '../constants/player-interest.ts'; +import { TRADER_CALM_SECONDS } from '../constants/attack-run.ts'; import { approach, velocityOf } from './flight-maths.ts'; import { attack } from './npc-attack-run.ts'; import { brainFly } from './npc-brain-pilot.ts'; @@ -54,6 +55,14 @@ class Trader implements NpcBehaviour { const distPlayer = tmpDir.copy(player.position) .sub(ship.object.position).length(); + // THE RUN ENDS. A trader that took no hit for the calm, with nobody left + // hunting it, goes back to its working life (docs/TODO/213 M1). It used + // to run for the rest of its life, so an escort's charge that was grazed + // once never reached the station. + if (ship.state.fleeing && ship.state.calm >= TRADER_CALM_SECONDS + && ship.nearestAttacker(dt) === null) { + ship.state.fleeing = false; + } if (ship.state.fleeing) { // Armed traders turn and fight. WHICH pilot is brain-names.ts's answer. // The shipped answer is the hand-written three-phase attack run, pointed diff --git a/src/game/npc.ts b/src/game/npc.ts index d4846370..0b8b75af 100644 --- a/src/game/npc.ts +++ b/src/game/npc.ts @@ -789,6 +789,7 @@ export class NpcShip { // funnels through, because damage-dealt.ts routes lasers, ordnance and rams // here. So the attack run answers all of them, and not gunfire alone. this.state.underFire = UNDER_FIRE_SECONDS; + this.state.calm = 0; if (byPlayer) this.state.provokedByPlayer = true; if (from && this.role === 'trader') { this.state.fleeFrom.copy(from); @@ -819,6 +820,7 @@ export class NpcShip { tickClocks(dt: number): void { this.regenerate(dt); this.state.underFire = Math.max(0, this.state.underFire - dt); + this.state.calm += dt; this.state.missileReload = Math.max(0, this.state.missileReload - dt); } diff --git a/src/missions/verbs/escort.ts b/src/missions/verbs/escort.ts index 6911aa62..9b93c3c7 100644 --- a/src/missions/verbs/escort.ts +++ b/src/missions/verbs/escort.ts @@ -3,7 +3,9 @@ // The game decides when that holds and sends `escortSafe` (world-step.ts, // under the rules docs/TODO/190 states). This leg only reads the verdict. A // ship lost on the way, to anyone, is `targetDestroyed`. One that jumps out -// is `targetEscaped`. +// is `targetEscaped`, whether it left on its own or ran from a hit. The +// charge that ran was ignored until docs/TODO/213 M1, and the commonest +// way an escort is lost was silent. import type { VerbModule } from './verb.ts'; @@ -12,6 +14,6 @@ export const escort: VerbModule = (ctx, input) => { if (!('tag' in input) || input.tag !== ctx.live.tag) return null; if (input.kind === 'escortSafe') return { trigger: 'success' }; if (input.kind === 'escortLost' || input.kind === 'destroyed') return { trigger: 'targetDestroyed' }; - if (input.kind === 'escaped') return { trigger: 'targetEscaped' }; + if (input.kind === 'escaped' || input.kind === 'fled') return { trigger: 'targetEscaped' }; return null; }; diff --git a/src/missions/verbs/scan.ts b/src/missions/verbs/scan.ts index 981ef136..98284cab 100644 --- a/src/missions/verbs/scan.ts +++ b/src/missions/verbs/scan.ts @@ -2,7 +2,9 @@ // // The game counts the seconds (world-step.ts) and sends `scanned` once they // are up. A target destroyed before then is `targetDestroyed`, and a patron -// who wanted it watched, not killed, says what that costs. +// who wanted it watched, not killed, says what that costs. A subject wrecked +// with credit to nobody is destroyed all the same. One that ran from a hit +// escaped, as much as one that jumped out (docs/TODO/213 M1). import type { VerbModule } from './verb.ts'; @@ -10,7 +12,7 @@ export const scan: VerbModule = (ctx, input) => { if (ctx.leg.verb.kind !== 'scan') return null; if (!('tag' in input) || input.tag !== ctx.live.tag) return null; if (input.kind === 'scanned') return { trigger: 'success' }; - if (input.kind === 'destroyed') return { trigger: 'targetDestroyed' }; - if (input.kind === 'escaped') return { trigger: 'targetEscaped' }; + if (input.kind === 'destroyed' || input.kind === 'escortLost') return { trigger: 'targetDestroyed' }; + if (input.kind === 'escaped' || input.kind === 'fled') return { trigger: 'targetEscaped' }; return null; }; diff --git a/test/course-pilot.test.ts b/test/course-pilot.test.ts index 3701c2c0..ba66d01a 100644 --- a/test/course-pilot.test.ts +++ b/test/course-pilot.test.ts @@ -194,6 +194,22 @@ console.log('\nthe station course goes round a planet in its way'); eq('...and it still docks', g.mode, 'docked'); } +console.log('\na mission target below the clearance is refused'); +{ + // docs/TODO/213 M1: a charge that ran flew through the planet, and the + // escort course followed it. The commander crashed with full shields. + const v = view(new THREE.Vector3(0, 0, -50_000)); + const low = v.planetPos.clone().add(new THREE.Vector3(0, -(v.planetRadius + 100), 0)); + const refused = new CoursePilot().step( + view(v.stationPos, { course: 'mission', mission: { at: low, speed: 100, how: 'escort' } }), 1 / 60); + check('a target 100 units above the planet ends the course', refused.done); + check('...with a reason for the console', typeof refused.why === 'string' && refused.why.length > 0); + const clear = v.planetPos.clone().add(new THREE.Vector3(0, -(v.planetRadius + COURSE_PLANET_CLEARANCE * 2), 0)); + const flown = new CoursePilot().step( + view(v.stationPos, { course: 'mission', mission: { at: clear, speed: 100, how: 'escort' } }), 1 / 60); + check('...and one well above it is flown (the control)', !flown.done && flown.demand !== null); +} + console.log('\nnothing appears inside the planet'); { // docs/TODO/205 M3 found a hermit 1,545 units inside the planet, and a diff --git a/test/mission-courses.test.ts b/test/mission-courses.test.ts index 3c2919e9..547bb25a 100644 --- a/test/mission-courses.test.ts +++ b/test/mission-courses.test.ts @@ -18,7 +18,8 @@ import { runMissions } from '../src/game/mission-bridge.ts'; import { missionCourse } from '../src/game/mission-course.ts'; import { clearOfPolice } from '../src/game/course-clearance.ts'; import { SCAN_RANGE } from '../src/constants/law.ts'; -import { COURSE_POLICE_CLEARANCE } from '../src/constants/course.ts'; +import { COURSE_ESCORT_STANDOFF, COURSE_POLICE_CLEARANCE } from '../src/constants/mission-course.ts'; +import { TRADER_CALM_SECONDS } from '../src/constants/attack-run.ts'; import { COURSE_KEYS } from '../src/game/bindings.ts'; import { keymap } from '../src/engine/keymap.ts'; import { check, dismissBriefing, eq } from './harness.ts'; @@ -124,6 +125,32 @@ const words = (g: Game): string | null => missionCourse( g.coursePanel()?.rows?.some((r) => r.kind === 'station') === true); } +console.log('\nthe escort course does not ram its charge, and a grazed charge goes back to work'); +{ + // docs/TODO/213 M1. The approach braked from full speed to the charge's + // own at the standoff and overshot into the hull. A ram is a hit from the + // commander, and a trader that is hit ran for the rest of its life. + const g = onTheJob('side-escort', 20_260_947); + const charge = g.state.world.npcs.find((n) => n.state.missionTag !== null); + if (!charge) throw new Error('the escort spawned no charge'); + const shields = g.state.sys.foreShield; + let nearest = Infinity; + fly(g, 90, () => { + nearest = Math.min(nearest, g.state.player.position.distanceTo(charge.object.position)); + return false; + }); + check('ninety seconds beside the charge cost no shield', g.state.sys.foreShield === shields, + `${g.state.sys.foreShield} of ${shields}`); + check('...and the ship never came inside a quarter of the standoff', + nearest > COURSE_ESCORT_STANDOFF / 4, `${Math.round(nearest)} units at the nearest`); + check('...and the charge is not on the run', !charge.state.fleeing); + charge.takeLaserHit(1, g.state.player.position.clone(), false); + check('a graze sets the charge to flight', charge.state.fleeing); + fly(g, TRADER_CALM_SECONDS + 5, () => !charge.state.fleeing); + check('...and it goes back to work once the calm has passed', !charge.state.fleeing); + eq('...on its way to the station', charge.state.traderPhase, 'arriving'); +} + console.log('\na hunted ship that runs has fled, not escaped'); { // Before docs/TODO/208 M3 the world sent `escaped` whichever way a tagged diff --git a/test/mission-verbs.test.ts b/test/mission-verbs.test.ts index 42601288..56fb1c88 100644 --- a/test/mission-verbs.test.ts +++ b/test/mission-verbs.test.ts @@ -172,6 +172,10 @@ console.log('\nescort and scan, through the machine'); stepMissions(st, { kind: 'escortLost', tag }, moved(ctx, target)).state.done[SIDE_ESCORT.id], 'fail'); eq('...and so does one that jumps out', stepMissions(st, { kind: 'escaped', tag }, moved(ctx, target)).state.done[SIDE_ESCORT.id], 'fail'); + // A charge that a pirate hit runs, and jumps out while it runs. The world + // sends `fled` for that, and the verb ignored it until docs/TODO/213 M1. + eq('...and so does one that ran from a hit', + stepMissions(st, { kind: 'fled', tag }, moved(ctx, target)).state.done[SIDE_ESCORT.id], 'fail'); const sctx = boardFor(SIDE_SCAN); const sst = accept(SIDE_SCAN, sctx); @@ -183,6 +187,10 @@ console.log('\nescort and scan, through the machine'); eq('the scan pays', paid(scanned.effects), SIDE_JOB_PAY.scan); const killed = stepMissions(sst, { kind: 'destroyed', tag: stag }, sctx); eq('a subject destroyed fails it, and the patron minds', killed.state.standing[`world-${sctx.commander.systemIndex}`], -3); + const wrecked = stepMissions(sst, { kind: 'escortLost', tag: stag }, sctx); + eq('...and one wrecked by nobody is destroyed all the same', wrecked.state.standing[`world-${sctx.commander.systemIndex}`], -3); + eq('a subject that ran from a hit has escaped', + stepMissions(sst, { kind: 'fled', tag: stag }, sctx).state.done[SIDE_SCAN.id], 'fail'); const hctx = boardFor(SIDE_HUNT); const hst = accept(SIDE_HUNT, hctx); diff --git a/test/npc-trader.test.ts b/test/npc-trader.test.ts index 979e6299..1150a0f6 100644 --- a/test/npc-trader.test.ts +++ b/test/npc-trader.test.ts @@ -24,6 +24,7 @@ import type { BehaviourShip } from '../src/game/npc-behaviour.ts'; import { freshNpcState } from '../src/game/npc-state.ts'; import { seedWorld } from '../src/game/rng.ts'; import { SHIPPED_BRAINS } from '../src/game/brain-names.ts'; +import { TRADER_CALM_SECONDS } from '../src/constants/attack-run.ts'; import { check, eq } from './harness.ts'; // --- it flies a BehaviourShip, and it calls the working life ---------------- @@ -135,4 +136,25 @@ console.log('a trader, flown off an object literal'); eq('...and it reports no flight model', it.state.flownBy, 'none'); eq('...and it advanced too', it.advanced(), DT); } + + // 3. THE RUN ENDS (docs/TODO/213 M1). A trader that fled ran for the rest + // of its life, so an escort's charge that was grazed once never reached + // the station. The calm is seconds since the last hit, with nobody left + // hunting it. + { + const it = ship(true); + it.state.calm = TRADER_CALM_SECONDS; + traderBehaviour().fly(it, DT, commander, view); + check('a trader calm for long enough goes back to work', !it.state.fleeing); + check('...and picks a waypoint at once', it.state.waypoint.lengthSq() > 0); + const still = ship(true); + still.state.calm = TRADER_CALM_SECONDS - 1; + traderBehaviour().fly(still, DT, commander, view); + check('one that was hit more recently still runs', still.state.fleeing); + const hunted = ship(true); + hunted.state.calm = TRADER_CALM_SECONDS * 2; + hunted.nearestAttacker = () => ({} as never); + traderBehaviour().fly(hunted, DT, commander, view); + check('...and so does one that is still hunted, however calm', hunted.state.fleeing); + } } From 1af5cbef2c653b267c563d3d8730b1212de14e88 Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Sun, 13 Sep 2026 09:32:30 +0100 Subject: [PATCH 063/100] docs/TODO/213 M2: a side job comes back, the goods leave, the arcs stay home No side job had a cap, and absent read as once, so each of the eight was offered one time per career. Absent means without limit now, a week apart, as failure rule 5 says. A smuggling run paid its fee and left the narcotics aboard. The smuggle verb's success carries `unload`, the machine emits an unload effect, and the bridge takes the tonnes out of the hold. A world patron is a seed slot, and a seed slot is an index that every galaxy has. Galaxy 2's Esrilees offered the governor of Lave's job. Every arc is gated to galaxy 1, the lint refuses a world patron without a galaxy gate, and a lead keeps its galaxy across a galactic jump. The relocation to the new galaxy's tour goes, with leadWorldIn. A scoop breaks on a hull without fuel scoops. The Lave arc and the two scoop side jobs wait for them before they are offered. Co-Authored-By: Claude Fable 5.1 Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- docs/ARCHITECTURE.md | 3 +- ...hold-and-a-hit-trader-goes-back-to-work.md | 18 ++++++++ docs/reviews/missions-2026-09-12/probe.ts | 12 +++--- src/game/mission-bridge.ts | 14 +++++-- src/missions/lint.ts | 6 +++ src/missions/machine.ts | 34 +++++++-------- src/missions/model.ts | 14 ++++++- src/missions/offers.ts | 15 ++++--- src/missions/skeletons/arcs/edle.ts | 2 +- src/missions/skeletons/arcs/index.ts | 4 ++ src/missions/skeletons/arcs/lave.ts | 2 +- src/missions/skeletons/arcs/rabedira.ts | 2 +- src/missions/skeletons/arcs/vetitice.ts | 2 +- src/missions/skeletons/arcs/xeer.ts | 2 +- src/missions/skeletons/side.ts | 9 ++-- src/missions/tour-page.ts | 2 +- src/missions/tour.ts | 21 ++++------ src/missions/verbs/smuggle.ts | 10 +++-- src/missions/verbs/verb.ts | 2 + test/arcs.test.ts | 11 +++-- test/dossiers.test.ts | 2 +- test/mission-game.test.ts | 41 +++++++++++++++---- test/mission-machine.test.ts | 2 +- test/mission-offers.test.ts | 36 +++++++++++++++- test/mission-pieces.test.ts | 2 +- test/mission-skeletons.test.ts | 5 ++- test/mission-verbs.test.ts | 4 +- test/patrons.test.ts | 2 +- test/station.test.ts | 4 ++ test/tour-page.test.ts | 4 +- test/tour.test.ts | 8 ++-- tools/dossier-prompts.ts | 2 +- 32 files changed, 211 insertions(+), 86 deletions(-) diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md index f4dd5633..833757ea 100644 --- a/docs/ARCHITECTURE.md +++ b/docs/ARCHITECTURE.md @@ -252,7 +252,8 @@ Two quirks are deliberate: skeleton: a leg by id, a patron's key, and where a skeleton is offered. `placement.ts` picks a leg's world with one draw. A band measures tenths on the chart. A handover measures jumps on the full-tank graph. `tour.ts` places the five arc starts from the seed, - and a galactic jump moves a lead by the same rule (docs/TODO/192). `queries.ts` answers the game's questions without a change. `lint.ts` + and an arc is offered in galaxy 1 alone. So a lead keeps its galaxy across + a galactic jump (docs/TODO/213). `queries.ts` answers the game's questions without a change. `lint.ts` holds the five failure rules as data checks, and `test/mission-skeletons.test.ts` runs it over every skeleton. `repair.ts` reads a saved record for both loaders, and drops the old stage number. diff --git a/docs/TODO/213-the-mission-rules-hold-and-a-hit-trader-goes-back-to-work.md b/docs/TODO/213-the-mission-rules-hold-and-a-hit-trader-goes-back-to-work.md index 69f1b5af..64ca4c0d 100644 --- a/docs/TODO/213-the-mission-rules-hold-and-a-hit-trader-goes-back-to-work.md +++ b/docs/TODO/213-the-mission-rules-hold-and-a-hit-trader-goes-back-to-work.md @@ -200,3 +200,21 @@ Evidence, one per fault: the escort closing speed and the police clearance. Their rule ids stay under `course.`, and each says `@domain mission-course`. - The suite gains 13 checks, to 5,984. + +### M2 + +- **The dossier hash did not move.** A gate and a spawn list are outside + it, as the plan said, and `generate:dossiers --check` passes with every + skeleton changed. +- **The lead announcement moved here from M4.** Without the relocation, a + lead an arc offers on a galactic jump was recorded in the galaxy she + arrived in, at a seed index there. `offerLead` reads the galaxy from the + next arc's gate, and the bridge names the world through that galaxy. +- **Two tests pinned the old rules by accident.** `test/arcs.test.ts` said + the first arc opens with no gate. `test/station.test.ts` pinned the dock's + hail lines with the Lave arc among them. The first is rewritten. The second + fits scoops, because the offers are not its subject. +- **The review probe needed the new fact.** `probe.ts` builds its own + commander facts, and it gained `scoops` so the after-run can read the + same blocks. +- The suite has 6,001 checks. diff --git a/docs/reviews/missions-2026-09-12/probe.ts b/docs/reviews/missions-2026-09-12/probe.ts index 73204e6a..c47fb703 100644 --- a/docs/reviews/missions-2026-09-12/probe.ts +++ b/docs/reviews/missions-2026-09-12/probe.ts @@ -23,7 +23,7 @@ import type { CommanderFacts, MissionState } from '../../../src/missions/model.t const g1 = generateGalaxy(1); const g2 = generateGalaxy(2); const facts = (o: Partial = {}): CommanderFacts => ({ - galaxy: 1, systemIndex: 7, kills: 0, combatScore: 0, legalStatus: 0, day: 0, cargo: new Array(17).fill(0), ...o, + galaxy: 1, systemIndex: 7, kills: 0, combatScore: 0, legalStatus: 0, day: 0, cargo: new Array(17).fill(0), scoops: true, ...o, }); const ctx = (c: Partial = {}, systems = g1, skeletons?: readonly typeof SKELETONS[number][]) => ({ commander: facts(c), systems, rng: () => 0.5, ...(skeletons ? { skeletons } : {}) }); @@ -49,13 +49,15 @@ console.log('[1] an arc is offered in every galaxy at its seed index'); let r = stepMissions(emptyMissionState(), { kind: 'accept', skeleton: 'arc-lave' }, ctx()); r = stepMissions(r.state, { kind: 'galaxyChanged', from: 1, to: 2 }, ctx({ galaxy: 2, systemIndex: 7 }, g2)); const lead = r.state.leads[0]; - console.log(' lead after the jump:', JSON.stringify(lead), '| announced world:', (r.effects.find((e) => e.kind === 'lead') as { world: number }).world); + console.log(' lead after the jump:', JSON.stringify(lead), '| announced world:', (r.effects.find((e) => e.kind === 'lead') as { world: number } | undefined)?.world); r = stepMissions(r.state, { kind: 'accept', skeleton: 'arc-rabedira' }, ctx({ galaxy: 2, systemIndex: lead.world }, g2)); console.log(' arc-rabedira accepted at the relocated lead:', r.state.live.length === 1); const paper = r.state.live[0]; - r = stepMissions(r.state, { kind: 'docked' }, ctx({ galaxy: 2, systemIndex: paper.target! }, g2)); - const toGoal = routeTable(g2, 100).jumps; - console.log(` convoy leg placed ${toGoal[r.state.live[0].target!]} jumps from galaxy-2 index 100 (${g2[100].name}), which is not the tour`); + if (paper) { + r = stepMissions(r.state, { kind: 'docked' }, ctx({ galaxy: 2, systemIndex: paper.target! }, g2)); + const toGoal = routeTable(g2, 100).jumps; + console.log(` convoy leg placed ${toGoal[r.state.live[0].target!]} jumps from galaxy-2 index 100 (${g2[100].name}), which is not the tour`); + } } console.log('\n[2] a side job with no cap is offered once per career'); diff --git a/src/game/mission-bridge.ts b/src/game/mission-bridge.ts index f1fd6208..02c7d7ba 100644 --- a/src/game/mission-bridge.ts +++ b/src/game/mission-bridge.ts @@ -42,7 +42,7 @@ export function missionFacts(c: CommanderData): CommanderFacts { return { galaxy: c.galaxy, systemIndex: c.systemIndex, kills: c.kills, combatScore: c.combatScore, legalStatus: c.legalStatus, day: c.day, - cargo: c.cargo, + cargo: c.cargo, scoops: c.equipment.scoops, }; } @@ -97,12 +97,16 @@ export function runMissions( if (text) out.push({ kind: 'message', text, seconds: 6, queued: true }); break; } - case 'lead': + // The lead's own galaxy names the world. An arc that fails on a galactic + // jump leaves its lead in the galaxy it came from (docs/TODO/213 M2). + case 'lead': { + const named = e.galaxy === c.galaxy ? systems : systemsOf(e.galaxy); out.push({ kind: 'message', queued: true, seconds: 6, - text: `THERE IS A LEAD. ASK AT ${systems[e.world].name.toUpperCase()}.`, + text: `THERE IS A LEAD. ASK AT ${named[e.world].name.toUpperCase()}.`, }); break; + } // The patron's goods go aboard, as far as the hold allows. A hold too // full for all of them is a leg that starts short. The smuggle verb then // fails a dock with fewer tonnes than it wants. @@ -122,6 +126,10 @@ export function runMissions( }); break; } + // The goods delivered leave the hold, and no more than are aboard. + case 'unload': + c.cargo[e.commodity] = Math.max(0, c.cargo[e.commodity] - e.tonnes); + break; // Passengers a finished mission left aboard are survivors now, once. case 'survivors': c.survivors += e.people; break; // A change to a world is kept on the record until its day, and the diff --git a/src/missions/lint.ts b/src/missions/lint.ts index 7ce9944c..3a4203b4 100644 --- a/src/missions/lint.ts +++ b/src/missions/lint.ts @@ -13,6 +13,9 @@ // docs/TODO/192 adds two. An arc's final leg ends two to four jumps from // the lead's start world, measured on the full-tank graph. Two legs that // force two different blueprint sets at one world are a conflict. +// +// docs/TODO/213 M2 adds one. A world patron's skeleton names the galaxy it +// is offered in, because a seed slot is an index that every galaxy has. import { ARC_HANDOVER_JUMPS } from '../constants/missions.ts'; import type { StarSystem } from '../galaxy/galaxy.ts'; @@ -29,6 +32,9 @@ export function lintSkeleton( const ids = new Set(s.legs.map((l) => l.id)); if (s.legs.length === 0) out.push(`${s.id}: no legs`); if (ids.size !== s.legs.length) out.push(`${s.id}: a leg id repeats`); + if (s.patron.kind === 'world' && s.offer.galaxy === undefined) { + out.push(`${s.id}: a world patron needs a galaxy gate`); + } for (const leg of s.legs) { const at = `${s.id}/${leg.id}`; diff --git a/src/missions/machine.ts b/src/missions/machine.ts index 3e66b936..d606021e 100644 --- a/src/missions/machine.ts +++ b/src/missions/machine.ts @@ -31,9 +31,8 @@ import type { import { canAccept } from './offers.ts'; import { placeLeg } from './placement.ts'; import { legOf, patronId, startWorld } from './lookups.ts'; -import { ARC_TOUR, SKELETONS, skeletonById } from './skeletons/index.ts'; +import { SKELETONS, skeletonById } from './skeletons/index.ts'; import { fillSlots, legPay, lineSlots } from './text.ts'; -import { leadWorldIn } from './tour.ts'; import { sameTrigger, triggerLabel, wordKind } from './triggers.ts'; import { verbItem, verbModule, verbNeedsShip } from './verbs/registry.ts'; import { DEADLINE_WARNING_DAYS } from '../constants/missions.ts'; @@ -63,7 +62,7 @@ export function stepMissions( // A world change holds through its last day, and is gone the day after. st.changes = st.changes.filter((ch) => ch.until >= ctx.commander.day); break; - case 'galaxyChanged': leaveGalaxy(st, input.to, ctx, effects); break; + case 'galaxyChanged': leaveGalaxy(st, ctx, effects); break; default: react(st, input, ctx, effects); } if (input.kind === 'docked') hail(st, ctx, effects, st.journal.length !== journalBefore); @@ -122,24 +121,20 @@ function abandon( /** * The commander left the galaxy. Every live mission fails by its own final - * outcome, with the departure as the reason. Every lead moves to the world - * the tour of the new galaxy gives its arc (tour.ts), from the arrival - * world. Its galaxy moves with it, so a lead never points at an index in a - * galaxy she is not in. `ctx.systems` is the galaxy she arrives in. + * outcome, with the departure as the reason. A lead stays where it was + * saved. An arc is offered in its own galaxy (`Gate.galaxy`), so the LEADS + * row says IN ANOTHER GALAXY until she returns. The leads used to move to + * the tour of the new galaxy. The arc they opened there placed its legs by + * seed index, which is not the tour (docs/TODO/213 M2). */ function leaveGalaxy( - st: MissionState, to: number, ctx: MissionContext, effects: MissionEffect[], + st: MissionState, ctx: MissionContext, effects: MissionEffect[], ): void { const c = ctx.commander; for (const live of [...st.live]) { st.journal.push({ skeleton: live.skeleton, leg: live.leg, outcome: 'galaxyLeft', day: c.day, world: c.systemIndex }); finish(st, live, 'fail', ctx, effects); } - for (const lead of st.leads) { - if (!skeletonById(lead.skeleton, ctx.skeletons ?? SKELETONS)) continue; - lead.galaxy = to; - lead.world = leadWorldIn(ctx.systems, c.systemIndex, ARC_TOUR.indexOf(lead.skeleton)); - } } // --- events ----------------------------------------------------------------- @@ -169,6 +164,9 @@ function react( if (reaction.passenger && input.kind === 'scooped') { st.passengers.push({ tag: input.tag, mission: live.skeleton }); } + if (reaction.unload && leg.verb.kind === 'smuggle') { + effects.push({ kind: 'unload', commodity: leg.verb.commodity, tonnes: leg.verb.tonnes }); + } if (reaction.say !== undefined) { effects.push({ kind: 'say', text: fillSlots(reaction.say, lineSlots(ctx.systems, live.target, legPay(leg))) }); } @@ -368,7 +366,10 @@ function finish( /** * Save a lead, once. A lead to an arc she holds or finished is dropped, as - * failure rule 3 asks. The effect tells the game to announce it. + * failure rule 3 asks. The effect tells the game to announce it. The lead + * is in the arc's own galaxy where its gate names one. So an arc that fails + * on a galactic jump leaves its lead behind, in the galaxy the next arc is + * offered in (docs/TODO/213 M2). */ function offerLead( st: MissionState, id: string, ctx: MissionContext, effects: MissionEffect[], @@ -379,6 +380,7 @@ function offerLead( if (st.leads.some((l) => l.skeleton === id)) return; const c = ctx.commander; const world = startWorld(target, c); - st.leads.push({ skeleton: id, galaxy: c.galaxy, world, sinceDay: c.day }); - effects.push({ kind: 'lead', skeleton: id, galaxy: c.galaxy, world }); + const galaxy = target.offer.galaxy ?? c.galaxy; + st.leads.push({ skeleton: id, galaxy, world, sinceDay: c.day }); + effects.push({ kind: 'lead', skeleton: id, galaxy, world }); } diff --git a/src/missions/model.ts b/src/missions/model.ts index 0ba25422..069ab240 100644 --- a/src/missions/model.ts +++ b/src/missions/model.ts @@ -57,6 +57,8 @@ export interface CommanderFacts { day: number; /** tonnes per commodity index, read only: a smuggle leg asks what is aboard */ cargo: readonly number[]; + /** fuel scoops fitted: a scoop job asks before it is offered (docs/TODO/213 M2) */ + scoops: boolean; } /** A temporary change to a world that a later mission asks for. */ @@ -180,8 +182,14 @@ export interface Gate { /** skeletons that must be finished first, by either outcome */ done?: string[]; withinJumps?: number; - /** the Navy briefs in galaxy 1 only; a world patron is already in one galaxy */ + /** + * The galaxy the offer stands in. A world patron must name one, because a + * seed slot is an index and every galaxy has that index. The lint holds + * it (docs/TODO/213 M2). The Navy briefs in galaxy 1 only. + */ galaxy?: number; + /** the job needs fuel scoops fitted, so the offer waits for them */ + scoops?: boolean; } export interface Skeleton { @@ -200,7 +208,7 @@ export interface Skeleton { fail: Outcome; /** skeletons this one shuts out, for good */ excludes?: string[]; - /** how many times a side job repeats; absent means once */ + /** how many times a side job repeats; absent means without limit (failure rule 5) */ cap?: number; } @@ -373,5 +381,7 @@ export type MissionEffect = | { kind: 'standingSpawn'; world: number; until: number; ships: TaggedShip[] } /** the patron's goods go aboard: a smuggle leg starts with them */ | { kind: 'cargo'; commodity: number; tonnes: number } + /** the patron's goods leave the hold: a smuggle leg ends with them delivered */ + | { kind: 'unload'; commodity: number; tonnes: number } /** passengers a finished mission leaves in the crew spaces, as survivors */ | { kind: 'survivors'; people: number }; diff --git a/src/missions/offers.ts b/src/missions/offers.ts index 8bbc63d2..ad6246fe 100644 --- a/src/missions/offers.ts +++ b/src/missions/offers.ts @@ -4,8 +4,10 @@ // A gate is the skeleton's own conditions. A LEAD opens the offer regardless // of the gate, at the lead's world (docs/TODO/190, failure rule 3). Neither // opens a slot: `MISSION_LIVE_CAP` holds, and a lead waits for one. A side -// job with a `cap` comes back after `MISSION_REOFFER_DAYS`, and an arc she -// holds or finished never comes back (failure rule 5). +// job comes back after `MISSION_REOFFER_DAYS`, until its `cap` is spent +// where it has one. An arc she holds or finished never comes back (failure +// rule 5). No side job had a cap, and absent read as once, so each +// was offered one time per career until docs/TODO/213 M2. // // It is read by the machine on `accept` and on `docked`, by the desk that // lists the MISSIONS screen, and by the tests. It changes nothing. @@ -72,6 +74,7 @@ function gateOpen(gate: Gate, st: MissionState, c: CommanderFacts): boolean { if (gate.minKills !== undefined && c.kills < gate.minKills) return false; if (gate.minRating !== undefined && ratingRung(c.combatScore) < gate.minRating) return false; if (gate.legalStatus === 'clean' && c.legalStatus !== 0) return false; + if (gate.scoops && !c.scoops) return false; if (gate.flags?.some((f) => !st.flags.includes(f))) return false; if (gate.notFlags?.some((f) => st.flags.includes(f))) return false; if (gate.done?.some((d) => !(d in st.done))) return false; @@ -106,9 +109,9 @@ export function leadHere(st: MissionState, id: string, c: CommanderFacts): boole * Whether the commander can accept this skeleton where she stands. * * A LEAD OPENS THE OFFER regardless of the gate. It does not open a slot, and - * it does not restart an arc she holds or finished. A side job with a `cap` - * comes back until the cap is spent, and not before `MISSION_REOFFER_DAYS` - * from the day it last ended. + * it does not restart an arc she holds or finished. A side job comes back + * until its `cap` is spent, where it has one, and not before + * `MISSION_REOFFER_DAYS` from the day it last ended. */ export function canAccept(st: MissionState, id: string, ctx: OfferContext): boolean { const from = ctx.skeletons ?? SKELETONS; @@ -120,7 +123,7 @@ export function canAccept(st: MissionState, id: string, ctx: OfferContext): bool // was not written, which a hand-built record can do. if (s.kind !== 'side' && id in st.done) return false; const ended = endings(st, id); - if (ended.count >= (s.kind === 'side' ? (s.cap ?? 1) : 1)) return false; + if (ended.count >= (s.kind === 'side' ? (s.cap ?? Infinity) : 1)) return false; if (ended.count > 0 && ctx.commander.day < ended.lastDay + MISSION_REOFFER_DAYS) return false; if (excluded(st, id, from)) return false; if (leadHere(st, id, ctx.commander)) return true; diff --git a/src/missions/skeletons/arcs/edle.ts b/src/missions/skeletons/arcs/edle.ts index b63195ab..79fc36b6 100644 --- a/src/missions/skeletons/arcs/edle.ts +++ b/src/missions/skeletons/arcs/edle.ts @@ -25,7 +25,7 @@ export const ARC_EDLE: Skeleton = { patron: { kind: 'world', seedSlot: 162 }, hail: 'A COLONEL OF THE STATE GUARD AT EDLE HAS ORDERS FOR YOU', pitch: 'A MANIFEST TO CARRY, A TRANSPORTER TO GUARD, AND AN ASP TO PURGE. THE STATE PAYS.', - offer: { done: ['arc-xeer'] }, + offer: { galaxy: 1, done: ['arc-xeer'] }, legs: [ { id: 'manifest', verb: { kind: 'deliver' }, place: AWAY, diff --git a/src/missions/skeletons/arcs/index.ts b/src/missions/skeletons/arcs/index.ts index d69197d5..4beb27d7 100644 --- a/src/missions/skeletons/arcs/index.ts +++ b/src/missions/skeletons/arcs/index.ts @@ -8,6 +8,10 @@ // // Each file names its theme in a comment. The words a player reads are the // dossier's (docs/TODO/191), and the lines here are the plain fallback. +// +// Every arc is gated to galaxy 1 (docs/TODO/213 M2). A world patron is a +// seed slot, and a seed slot is an index that every galaxy has. Without the +// gate, galaxy 2's Esrilees offered the governor of Lave's job. import type { Skeleton } from '../../model.ts'; import { ARC_EDLE } from './edle.ts'; diff --git a/src/missions/skeletons/arcs/lave.ts b/src/missions/skeletons/arcs/lave.ts index 5e4b85fb..2f0e7fa8 100644 --- a/src/missions/skeletons/arcs/lave.ts +++ b/src/missions/skeletons/arcs/lave.ts @@ -26,7 +26,7 @@ export const ARC_LAVE: Skeleton = { patron: { kind: 'world', seedSlot: 7 }, hail: 'THE GOVERNOR OF LAVE HAS A JOB FOR YOU', pitch: 'THE GRUB EXPORT LEDGER WENT ADRIFT WITH A SMUGGLER. THE GOVERNOR WANTS IT BACK, AND THE SMUGGLER CAUGHT.', - offer: {}, + offer: { galaxy: 1, scoops: true }, legs: [ { id: 'ledger', verb: { kind: 'recover', item: 'grub-ledger' }, place: { kind: 'band', ...SIDE_JOB_RANGE }, diff --git a/src/missions/skeletons/arcs/rabedira.ts b/src/missions/skeletons/arcs/rabedira.ts index bb19bd26..35689291 100644 --- a/src/missions/skeletons/arcs/rabedira.ts +++ b/src/missions/skeletons/arcs/rabedira.ts @@ -23,7 +23,7 @@ export const ARC_RABEDIRA: Skeleton = { patron: { kind: 'world', seedSlot: 6 }, hail: 'AN ENVOY AT RABEDIRA ASKS FOR YOU', pitch: 'A TRUCE PAPER MUST REACH A NEIGHBOUR, AND THEN THE ENVOY MUST REACH THE MEETING ALIVE.', - offer: { done: ['arc-lave'] }, + offer: { galaxy: 1, done: ['arc-lave'] }, legs: [ { id: 'paper', verb: { kind: 'deliver' }, place: { kind: 'band', ...SIDE_JOB_RANGE }, diff --git a/src/missions/skeletons/arcs/vetitice.ts b/src/missions/skeletons/arcs/vetitice.ts index 46a26b54..4a4499eb 100644 --- a/src/missions/skeletons/arcs/vetitice.ts +++ b/src/missions/skeletons/arcs/vetitice.ts @@ -22,7 +22,7 @@ export const ARC_VETITICE: Skeleton = { patron: { kind: 'world', seedSlot: 100 }, hail: 'THE PLANNING DIRECTOR AT VETITICE HAS A QUOTA TO MEET', pitch: 'PIRATES HOLD THE LANE THE COLLECTIVE\'S SHIPMENT MUST CROSS. CLEAR IT, BRING IN THE SURVEYOR, AND CARRY THE MANIFEST.', - offer: { done: ['arc-rabedira'] }, + offer: { galaxy: 1, done: ['arc-rabedira'] }, legs: [ { id: 'lane', verb: { kind: 'ambush' }, place: { kind: 'band', ...SIDE_JOB_RANGE }, spawn: [...LANE_PIRATES], diff --git a/src/missions/skeletons/arcs/xeer.ts b/src/missions/skeletons/arcs/xeer.ts index 1a97af80..6d261217 100644 --- a/src/missions/skeletons/arcs/xeer.ts +++ b/src/missions/skeletons/arcs/xeer.ts @@ -23,7 +23,7 @@ export const ARC_XEER: Skeleton = { patron: { kind: 'world', seedSlot: 150 }, hail: 'THE PORT ADMINISTRATOR AT XEER WANTS PROOF', pitch: 'AN ANACONDA IS FORGING THE HARVEST. WATCH IT, THEN CATCH THE SHIP THAT CARRIES THE PAPERS.', - offer: { done: ['arc-vetitice'] }, + offer: { galaxy: 1, done: ['arc-vetitice'] }, legs: [ { id: 'watch', verb: { kind: 'scan', ship: shipDesignIdOf(SOURCE_DESIGN.anaconda), seconds: SCAN_SECONDS }, diff --git a/src/missions/skeletons/side.ts b/src/missions/skeletons/side.ts index e2c6433c..6ee102ba 100644 --- a/src/missions/skeletons/side.ts +++ b/src/missions/skeletons/side.ts @@ -3,7 +3,10 @@ // // Each is a LOCAL job. The patron is whoever runs the station she stands at. // About a third of the jobs are on any one world's board (offers.ts). Each -// has a `failed` branch, a deadline, and a fee from `SIDE_JOB_PAY`. The +// has a `failed` branch, a deadline, and a fee from `SIDE_JOB_PAY`. None +// has a cap, so each comes back a week after it ends (failure rule 5). The +// two scoops wait for fuel scoops, because a canister breaks on a hull +// without them (docs/TODO/213 M2). The // rescue is the scientist of docs/TODO/190: a pod shot before the scoop // turns the leg into a delivery at a lower fee. The words are plain, and a // dossier (item 191) replaces them on screen when one exists. @@ -58,7 +61,7 @@ export const SIDE_DELIVER: Skeleton = { export const SIDE_RECOVER: Skeleton = { ...LOCAL, id: 'side-recover', hail: 'THE STATION LOST SOMETHING', pitch: 'A CANISTER WENT ADRIFT ONE JUMP OUT. SCOOP IT AND BRING IT BACK.', - offer: {}, + offer: { scoops: true }, legs: [ { id: 'find', verb: { kind: 'recover', item: 'station-canister' }, place: AWAY, @@ -85,7 +88,7 @@ export const SIDE_RECOVER: Skeleton = { export const SIDE_RESCUE: Skeleton = { ...LOCAL, id: 'side-rescue', hail: 'THE STATION HAS A PILOT ADRIFT', pitch: 'A SURVEY PILOT IS IN A POD ONE JUMP OUT. BRING HER IN ALIVE.', - offer: {}, + offer: { scoops: true }, legs: [ { id: 'pod', verb: { kind: 'rescue' }, place: AWAY, diff --git a/src/missions/tour-page.ts b/src/missions/tour-page.ts index 87d18197..e2d47940 100644 --- a/src/missions/tour-page.ts +++ b/src/missions/tour-page.ts @@ -124,7 +124,7 @@ export function recoveryLegs(s: Skeleton): Set { } const facts = (galaxy: number, systemIndex: number): CommanderFacts => ({ - galaxy, systemIndex, kills: 0, combatScore: 0, legalStatus: 0, day: 0, cargo: [], + galaxy, systemIndex, kills: 0, combatScore: 0, legalStatus: 0, day: 0, cargo: [], scoops: false, }); function arcEntry( diff --git a/src/missions/tour.ts b/src/missions/tour.ts index 1cf88b33..fe8a2d9d 100644 --- a/src/missions/tour.ts +++ b/src/missions/tour.ts @@ -8,11 +8,13 @@ // world's random stream, so the tour is the same in every career. Lave's // tour is Lave's tour. // -// A galactic jump runs the same rule on the new galaxy from the arrival -// world (machine.ts). Galaxies 3, 4, 6, 7 and 8 each strand a group of -// worlds. A commander who arrives on an island gets a tour of the island. -// The bands widen when a band is empty, and a start is never a world no -// chain of jumps reaches. +// The tour is galaxy 1's. An arc is offered in the galaxy its gate names, +// and a lead keeps its galaxy across a galactic jump (docs/TODO/213 M2). A +// galactic jump used to run this rule on the new galaxy. The arc the moved +// lead opened then placed its legs by seed index, which is not a tour. The +// bands widen when a band is empty. A start is never a world no chain of +// jumps reaches. So a tour from any world of any galaxy is still well +// formed. import { TOUR_ARCS, TOUR_STEP_JUMPS } from '../constants/missions.ts'; import type { StarSystem } from '../galaxy/galaxy.ts'; @@ -49,12 +51,3 @@ export function arcStarts(systems: readonly StarSystem[], first: number, count = } return starts; } - -/** - * Where a lead to the arc at `tourIndex` points in a galaxy entered at - * `arrival`. A skeleton outside the tour waits at the arrival world. - */ -export function leadWorldIn(systems: readonly StarSystem[], arrival: number, tourIndex: number): number { - if (tourIndex < 0) return arrival; - return arcStarts(systems, arrival)[tourIndex] ?? arrival; -} diff --git a/src/missions/verbs/smuggle.ts b/src/missions/verbs/smuggle.ts index 344bd106..e813f93a 100644 --- a/src/missions/verbs/smuggle.ts +++ b/src/missions/verbs/smuggle.ts @@ -1,9 +1,11 @@ // Smuggle: carry the patron's goods to the leg's world, past the police. // // The goods go aboard when the leg starts (the machine's `cargo` effect). A -// dock at the target with the tonnes still aboard succeeds. A dock there -// with fewer is `failed`: the goods were sold. A police scan on the way is -// `failed` too, because the hold was read. +// dock at the target with the tonnes still aboard succeeds, and the goods +// leave the hold (the `unload` effect, docs/TODO/213 M2). They stayed aboard +// before that, so a run paid its fee and left the narcotics to sell. A dock +// there with fewer is `failed`: the goods were sold. A police scan on the +// way is `failed` too, because the hold was read. import type { VerbModule } from './verb.ts'; @@ -15,5 +17,5 @@ export const smuggle: VerbModule = (ctx, input) => { const t = ctx.live.target; if (t !== null && t !== ctx.commander.systemIndex) return null; const aboard = ctx.commander.cargo[verb.commodity] ?? 0; - return { trigger: aboard >= verb.tonnes ? 'success' : 'failed' }; + return aboard >= verb.tonnes ? { trigger: 'success', unload: true } : { trigger: 'failed' }; }; diff --git a/src/missions/verbs/verb.ts b/src/missions/verbs/verb.ts index 6c0189ba..de7f1670 100644 --- a/src/missions/verbs/verb.ts +++ b/src/missions/verbs/verb.ts @@ -22,6 +22,8 @@ export interface VerbReaction { progress?: number; /** the scooped pod is this mission's passenger; the machine records it */ passenger?: boolean; + /** the leg's goods are delivered, and the machine asks the game to take them off */ + unload?: boolean; /** * What the console says about a step that takes no branch, with `{TARGET}` * for the leg's world (docs/TODO/203 M4). A branch speaks through its diff --git a/test/arcs.test.ts b/test/arcs.test.ts index 661ba051..cf5e2218 100644 --- a/test/arcs.test.ts +++ b/test/arcs.test.ts @@ -39,8 +39,11 @@ console.log('\nthe five arcs sit on the tour'); check('every arc has two to four legs, and mixes its verbs', ARCS.every((a) => a.legs.length >= 2 && a.legs.length <= 4 && new Set(a.legs.map((l) => l.verb.kind)).size >= 2)); - check('the first arc opens with no gate, and each later one waits for the one before', - Object.keys(ARCS[0].offer).length === 0 + // The first arc asks for the galaxy and the scoops alone (docs/TODO/213 + // M2): a scoop breaks on a hull without them. Every arc names its galaxy. + check('the first arc opens on the galaxy and the scoops, and each later one waits for the one before', + Object.keys(ARCS[0].offer).sort().join() === 'galaxy,scoops' + && ARCS.every((a) => a.offer.galaxy === 1) && ARCS.slice(1).every((a, i) => a.offer.done?.join() === ARCS[i].id)); check('every arc is in SKELETONS', ARCS.every((a) => SKELETONS.includes(a))); } @@ -78,7 +81,7 @@ function inputFor(st: MissionState, arc: Skeleton, avoid: readonly string[] | nu * would. */ function walk(arc: Skeleton, avoid: readonly string[] | null, done: string[]): { st: MissionState; legs: string[]; c: CommanderFacts } { - const c: CommanderFacts = { galaxy: 1, systemIndex: startOf(arc), kills: 0, combatScore: 0, legalStatus: 0, day: 1, cargo: [] }; + const c: CommanderFacts = { galaxy: 1, systemIndex: startOf(arc), kills: 0, combatScore: 0, legalStatus: 0, scoops: true, day: 1, cargo: [] }; const ctx = () => ({ commander: c, systems: g1, rng: () => 0.37 }); let st = emptyMissionState(); for (const d of done) st.done[d] = 'complete'; @@ -129,7 +132,7 @@ for (const [i, arc] of ARCS.entries()) { console.log('\nan arc is offered at its world only'); { - const c: CommanderFacts = { galaxy: 1, systemIndex: LAVE, kills: 0, combatScore: 0, legalStatus: 0, day: 1, cargo: [] }; + const c: CommanderFacts = { galaxy: 1, systemIndex: LAVE, kills: 0, combatScore: 0, legalStatus: 0, scoops: true, day: 1, cargo: [] }; check('the first arc is on offer at Lave from the first dock', offersFor(emptyMissionState(), { commander: c, systems: g1 }).some((s) => s.id === 'arc-lave')); check('...and not at Leesti', !offersFor(emptyMissionState(), { commander: { ...c, systemIndex: 8 }, systems: g1 }).some((s) => s.id === 'arc-lave')); diff --git a/test/dossiers.test.ts b/test/dossiers.test.ts index f35a49a9..5cfaa1ab 100644 --- a/test/dossiers.test.ts +++ b/test/dossiers.test.ts @@ -174,7 +174,7 @@ console.log('\n...and every reader speaks the dossier\'s words, or the skeleton\ { const LAVE = 7; const facts = (day = 0): CommanderFacts => ({ - galaxy: 1, systemIndex: LAVE, kills: 20, combatScore: 0, legalStatus: 0, day, cargo: [], + galaxy: 1, systemIndex: LAVE, kills: 20, combatScore: 0, legalStatus: 0, scoops: true, day, cargo: [], }); const ctx = (c: CommanderFacts): MissionContext => ({ commander: c, systems: g1, rng: () => 0.5 }); const full = (id: string): Dossier | null => { diff --git a/test/mission-game.test.ts b/test/mission-game.test.ts index 6931ad31..1ac8de22 100644 --- a/test/mission-game.test.ts +++ b/test/mission-game.test.ts @@ -15,6 +15,8 @@ import { destroyShip } from '../src/game/combat-wreck.ts'; import { runMissions } from '../src/game/mission-bridge.ts'; import { parseSnapshot } from '../src/game/snapshot-parse.ts'; import { CONSTRICTOR_BLUEPRINT_SET } from '../src/constants/blueprint-set.ts'; +import { NARCOTICS } from '../src/constants/commodities.ts'; +import { SIDE_JOB_PAY, SMUGGLE_TONNES } from '../src/constants/missions.ts'; import { generateGalaxy } from '../src/galaxy/galaxy.ts'; import { routeEstimate } from '../src/galaxy/route.ts'; import { stepMissions } from '../src/missions/machine.ts'; @@ -200,13 +202,13 @@ console.log('\nthe galactic drive asks before it fails a held mission'); eq('...and no tagged entity is left behind', Object.keys(c.missions.entities).length, 0); } -console.log('\na lead crosses the galaxy with her, to a world she can reach'); +console.log('\na lead stays in the galaxy it was saved in (docs/TODO/213 M2)'); { // No shipped arc leaves a lead yet, so the pair is built here, as // test/mission-machine.test.ts builds its own. const first: Skeleton = { id: 'first', kind: 'arc', anchor: 'local', patron: { kind: 'world', seedSlot: LAVE }, - hail: 'HAIL', pitch: 'GO', offer: {}, + hail: 'HAIL', pitch: 'GO', offer: { galaxy: 1 }, legs: [{ id: 'go', verb: { kind: 'deliver' }, place: { kind: 'anywhere' }, line: 'GO', next: [{ on: 'success', to: 'complete' }, { on: 'failed', to: 'fail' }], @@ -221,18 +223,22 @@ console.log('\na lead crosses the galaxy with her, to a world she can reach'); const state: MissionState = { ...emptyMissionState(), live: [{ skeleton: 'first', leg: 'go', target: null, tag: null, progress: 0, deadlineDay: null }], - leads: [{ skeleton: 'second', galaxy: 1, world: 12, sinceDay: 0 }], }; const r = stepMissions(state, { kind: 'galaxyChanged', from: 1, to: 2 }, { - commander: { galaxy: 2, systemIndex: arrival, kills: 0, combatScore: 0, legalStatus: 0, day: 5, cargo: [] }, + commander: { galaxy: 2, systemIndex: arrival, kills: 0, combatScore: 0, legalStatus: 0, scoops: true, day: 5, cargo: [] }, systems: g2, rng: () => 0.5, skeletons: pair, }); eq('the held arc failed', r.state.done.first, 'fail'); eq('...and the lead it leaves is saved once', r.state.leads.length, 1); const lead = r.state.leads[0]; - eq('the earlier lead now names the new galaxy', lead.galaxy, 2); - check('...and a world a chain of full-tank jumps reaches from the arrival', - lead.world === arrival || routeEstimate(g2, g2[arrival], g2[lead.world]) !== null); + // The arc is offered in galaxy 1, so the lead points there, and not at + // index 12 of the galaxy she arrived in. + eq('the lead is in the galaxy the next arc is offered in', lead.galaxy, 1); + eq('...at that arc\'s own world', lead.world, 12); + eq('...and the announcement carries the same galaxy', + (r.effects.find((e) => e.kind === 'lead') as { galaxy: number } | undefined)?.galaxy, 1); + check('...and the arrival world of galaxy 2 was not made a lead', arrival !== lead.world || lead.galaxy === 1); + check('the pair is well formed (the control)', routeEstimate(g2, g2[arrival], g2[12]) !== undefined); // A save carries the pair together. An index alone names nothing across // galaxies. @@ -288,3 +294,24 @@ console.log('\na jump reaches the machine as a day and an arrival, and the lane check('...and the next dock completes the lane job through the game', c.missions.live.length === 0 && c.missions.done['side-ambush'] === 'complete'); } + +console.log('\na smuggling run leaves the goods at the far end (docs/TODO/213 M2)'); +{ + // The run paid its fee and left the narcotics aboard to sell. Through the + // real bridge: the goods go aboard at the acceptance, and off at the dock. + seedWorld(1913); + const g = withoutSaving(() => new Game(() => headlessShell())).value; + dismissBriefing(g); + const c = g.state.commander; + for (let world = 0; world < 256 && c.missions.live.length === 0; world++) { + c.systemIndex = world; + withoutSaving(() => runMissions(c, { kind: 'accept', skeleton: 'side-smuggle' }, g.state.systems, () => 0.5)); + } + eq('the patron\'s goods went aboard', c.cargo[NARCOTICS], SMUGGLE_TONNES); + const before = c.credits; + c.systemIndex = c.missions.live[0].target as number; + withoutSaving(() => runMissions(c, { kind: 'docked' }, g.state.systems)); + eq('the dock at the far end pays', c.credits - before, SIDE_JOB_PAY.smuggle); + eq('...and the goods are off the ship', c.cargo[NARCOTICS], 0); + eq('...and the job is complete', c.missions.done['side-smuggle'], 'complete'); +} diff --git a/test/mission-machine.test.ts b/test/mission-machine.test.ts index bac5367f..0e48d07b 100644 --- a/test/mission-machine.test.ts +++ b/test/mission-machine.test.ts @@ -28,7 +28,7 @@ const LAVE = 7; /** A commander at Lave with `over` on top: the facts, and nothing else. */ const facts = (over: Partial = {}): CommanderFacts => ({ - galaxy: 1, systemIndex: LAVE, kills: 0, combatScore: 0, legalStatus: 0, day: 0, cargo: [], ...over, + galaxy: 1, systemIndex: LAVE, kills: 0, combatScore: 0, legalStatus: 0, scoops: true, day: 0, cargo: [], ...over, }); /** A generator that counts its draws, so a test can say how many it made. */ diff --git a/test/mission-offers.test.ts b/test/mission-offers.test.ts index 021dd5be..5f253584 100644 --- a/test/mission-offers.test.ts +++ b/test/mission-offers.test.ts @@ -8,6 +8,7 @@ // arc leaves a lead yet. import { canAccept, offersFor, sideJobsAt } from '../src/missions/offers.ts'; +import { generateGalaxy } from '../src/galaxy/galaxy.ts'; import { stepMissions } from '../src/missions/machine.ts'; import { boardRumour, leadJumps, leadLine, worldNews } from '../src/missions/hints.ts'; import { emptyMissionState } from '../src/missions/state.ts'; @@ -31,7 +32,7 @@ import { check, eq } from './harness.ts'; const LAVE = 7; const facts = (over: Partial = {}): CommanderFacts => ({ - galaxy: 1, systemIndex: LAVE, kills: 0, combatScore: 0, legalStatus: 0, day: 0, cargo: [], ...over, + galaxy: 1, systemIndex: LAVE, kills: 0, combatScore: 0, legalStatus: 0, scoops: false, day: 0, cargo: [], ...over, }); /** An arc at Lave that leads to a second arc at `world`. */ @@ -234,3 +235,36 @@ console.log('\nevery world has a roster of side jobs from the seed'); check('...and open everywhere with no galaxy to read a roster from', canAccept(st, off.id, { commander: facts({ systemIndex: LAVE }) })); } + +console.log('\nthe shipped side jobs come back, and an arc stays in its galaxy (docs/TODO/213 M2)'); +{ + // No side job has a cap, and absent read as once. Each was offered one + // time per career, and the boards emptied in a few sessions. + const g2 = generateGalaxy(2); + const escort = sideJobsAt(g1[LAVE], SKELETONS).find((s) => !s.offer.scoops)!; + const ctxAt = (day: number) => ({ commander: facts({ day }), systems: g1, rng: () => 0.5 }); + const held = stepMissions(emptyMissionState(), { kind: 'accept', skeleton: escort.id }, ctxAt(10)).state; + const ended = stepMissions(held, { kind: 'abandon', skeleton: escort.id }, ctxAt(10)).state; + eq(`${escort.id} ended on day 10`, ended.done[escort.id], 'fail'); + check('...and it is shut the next day', !canAccept(ended, escort.id, ctxAt(11))); + check(`...and open ${MISSION_REOFFER_DAYS} days on, with no cap to spend`, + canAccept(ended, escort.id, ctxAt(10 + MISSION_REOFFER_DAYS))); + check('...and open again a year on', canAccept(ended, escort.id, ctxAt(400))); + + // Galaxy 2's index 7 is Esrilees, and it offered the governor of Lave's job. + check('the Lave arc is offered at Lave, with scoops fitted', + canAccept(emptyMissionState(), 'arc-lave', { commander: facts({ scoops: true }), systems: g1 })); + check('...and not at index 7 of galaxy 2', + !canAccept(emptyMissionState(), 'arc-lave', { commander: facts({ galaxy: 2, scoops: true }), systems: g2 })); + eq('...where no arc is offered at all', + offersFor(emptyMissionState(), { commander: facts({ galaxy: 2, scoops: true }), systems: g2 }) + .filter((s) => s.kind === 'arc').length, 0); + + // A scoop breaks on a hull without fuel scoops, so the offer waits for them. + check('the Lave arc waits for the scoops', + !canAccept(emptyMissionState(), 'arc-lave', { commander: facts(), systems: g1 })); + const scoop = sideJobsAt(g1[LAVE], SKELETONS).find((s) => s.offer.scoops)!; + check(`...and so does ${scoop.id}`, + !canAccept(emptyMissionState(), scoop.id, { commander: facts(), systems: g1 }) + && canAccept(emptyMissionState(), scoop.id, { commander: facts({ scoops: true }), systems: g1 })); +} diff --git a/test/mission-pieces.test.ts b/test/mission-pieces.test.ts index ed489bcf..c0099de1 100644 --- a/test/mission-pieces.test.ts +++ b/test/mission-pieces.test.ts @@ -24,7 +24,7 @@ import { check, eq } from './harness.ts'; const LAVE = 7; const facts = (over: Partial = {}): CommanderFacts => ({ - galaxy: 1, systemIndex: LAVE, kills: 0, combatScore: 0, legalStatus: 0, day: 10, cargo: [], ...over, + galaxy: 1, systemIndex: LAVE, kills: 0, combatScore: 0, legalStatus: 0, scoops: true, day: 10, cargo: [], ...over, }); const half = () => 0.5; diff --git a/test/mission-skeletons.test.ts b/test/mission-skeletons.test.ts index c226604a..92885413 100644 --- a/test/mission-skeletons.test.ts +++ b/test/mission-skeletons.test.ts @@ -26,7 +26,7 @@ check('the Constrictor ships', SKELETONS.some((s) => s.id === 'constrictor')); function arc(over: Partial = {}): Skeleton { return { id: 'a', kind: 'arc', anchor: 'local', patron: { kind: 'world', seedSlot: 7 }, - hail: 'HAIL', pitch: 'GO', offer: {}, + hail: 'HAIL', pitch: 'GO', offer: { galaxy: 1 }, legs: [ { id: 'one', verb: { kind: 'deliver' }, place: { kind: 'band', min: 30, max: 80 }, line: 'ONE', @@ -102,6 +102,9 @@ const faults: [string, Skeleton, readonly Skeleton[], string][] = [ ['a handover toward a skeleton that does not exist', arc({ legs: [{ ...legs()[0], place: { kind: 'handover', toward: 'ghost', min: 2, max: 4 } }, legs()[1]] }), [b], 'unknown skeleton ghost'], + // A seed slot is an index that every galaxy has (docs/TODO/213 M2). + ['a world patron with no galaxy gate', + arc({ offer: {} }), [b], 'galaxy gate'], ]; for (const [name, s, others, word] of faults) { const problems = lintSkeleton(s, [s, ...others], g1); diff --git a/test/mission-verbs.test.ts b/test/mission-verbs.test.ts index 56fb1c88..20237fb4 100644 --- a/test/mission-verbs.test.ts +++ b/test/mission-verbs.test.ts @@ -30,7 +30,7 @@ import { LANE_PIRATES } from '../src/missions/skeletons/lane.ts'; import { check, dismissBriefing, eq } from './harness.ts'; const facts = (over: Partial = {}): CommanderFacts => ({ - galaxy: 1, systemIndex: 7, kills: 0, combatScore: 0, legalStatus: 0, day: 0, cargo: [], ...over, + galaxy: 1, systemIndex: 7, kills: 0, combatScore: 0, legalStatus: 0, scoops: true, day: 0, cargo: [], ...over, }); const paid = (effects: MissionEffect[]): number => effects.reduce((sum, e) => sum + (e.kind === 'pay' ? e.tenths : 0), 0); @@ -145,6 +145,8 @@ console.log('\nsmuggle: the goods go aboard, and the patrol is the risk'); const hold = (tonnes: number): number[] => { const c = new Array(17).fill(0); c[NARCOTICS] = tonnes; return c; }; const landed = stepMissions(r.state, { kind: 'docked' }, moved(ctx, target, { cargo: hold(SMUGGLE_TONNES) })); eq('a dock at the target with the goods aboard pays', paid(landed.effects), SIDE_JOB_PAY.smuggle); + check('...and the goods leave the hold (docs/TODO/213 M2)', + landed.effects.some((e) => e.kind === 'unload' && e.commodity === NARCOTICS && e.tonnes === SMUGGLE_TONNES)); const light = stepMissions(r.state, { kind: 'docked' }, moved(ctx, target, { cargo: hold(SMUGGLE_TONNES - 1) })); eq('...and with a tonne sold on the way it fails', light.state.done[SIDE_SMUGGLE.id], 'fail'); const elsewhere = stepMissions(r.state, { kind: 'docked' }, moved(ctx, 7, { cargo: hold(SMUGGLE_TONNES) })); diff --git a/test/patrons.test.ts b/test/patrons.test.ts index c3b596ef..9a18a883 100644 --- a/test/patrons.test.ts +++ b/test/patrons.test.ts @@ -23,7 +23,7 @@ import { check, eq } from './harness.ts'; const LAVE = 7; const facts = (systemIndex: number, galaxy = 1): CommanderFacts => ({ - galaxy, systemIndex, kills: 0, combatScore: 0, legalStatus: 0, day: 0, cargo: [], + galaxy, systemIndex, kills: 0, combatScore: 0, legalStatus: 0, scoops: true, day: 0, cargo: [], }); console.log('\na patron has a name and a face, and the Navy has neither'); diff --git a/test/station.test.ts b/test/station.test.ts index 4ed374e8..62077400 100644 --- a/test/station.test.ts +++ b/test/station.test.ts @@ -59,6 +59,10 @@ function setup() { { const x = setup(); seedWorld(190_019); + // The offers this dock hails are the subject of missions/offers.ts, not + // this test. Scoops are fitted so the board reads as it did before the + // scoop jobs waited for them (docs/TODO/213 M2). + x.state.commander.equipment.scoops = true; const events = x.station.dock(); eq('dock reports platform consequences in their former applied order', events.map(label).join('|'), [ diff --git a/test/tour-page.test.ts b/test/tour-page.test.ts index bb8ac191..d24ac00e 100644 --- a/test/tour-page.test.ts +++ b/test/tour-page.test.ts @@ -33,7 +33,7 @@ console.log('\nthe tour as data: five arcs in order, each with a patron and a fa eq('the arcs are in tour order', m.arcs.map((a) => a.id).join(), ARC_TOUR.join()); eq('...on the tour\'s worlds', m.arcs.map((a) => a.world.name).join(' > '), 'Lave > Rabedira > Vetitice > Xeer > Edle'); check('each arc\'s patron is the world patron of its world, with a face', - m.arcs.every((a) => a.patron.name === patronFor({ kind: 'world', seedSlot: a.world.index }, { galaxy: 1, systemIndex: 0, kills: 0, combatScore: 0, legalStatus: 0, day: 0, cargo: [] }, g1).name + m.arcs.every((a) => a.patron.name === patronFor({ kind: 'world', seedSlot: a.world.index }, { galaxy: 1, systemIndex: 0, kills: 0, combatScore: 0, legalStatus: 0, scoops: true, day: 0, cargo: [] }, g1).name && a.patron.portrait.startsWith('species/'))); const jumps = m.arcs.slice(0, -1).map((a) => a.jumpsToNext); check(`each arc's world is ${TOUR_STEP_JUMPS.min} to ${TOUR_STEP_JUMPS.max} jumps from the next (${jumps.join(', ')})`, @@ -81,7 +81,7 @@ console.log('\n...and the game\'s LOG and the page share one builder'); c.missions.journal.push({ skeleton: 'side-rescue', leg: 'pod', outcome: 'accepted', day: 3, world: 7 }); const html = captureById(() => { new LogScreen(() => ({ commander: c, systems: g1 })).render(); }).get('screen') ?? ''; const pages = storyPages(c.missions, g1); - const patron = patronFor({ kind: 'local' }, { galaxy: 1, systemIndex: 7, kills: 0, combatScore: 0, legalStatus: 0, day: 0, cargo: [] }, g1, 7); + const patron = patronFor({ kind: 'local' }, { galaxy: 1, systemIndex: 7, kills: 0, combatScore: 0, legalStatus: 0, scoops: true, day: 0, cargo: [] }, g1, 7); const built = logHtml({ pages, route: routeMapSvg(g1, [7]), portrait: patron.portrait, patron: patron.name }); check('the screen contains the builder\'s markup verbatim', html.includes(built.trim())); check('...with the title and the BACK key around it', html.includes("COMMANDER'S LOG") && html.includes('data-key="Escape"')); diff --git a/test/tour.test.ts b/test/tour.test.ts index d8cf71ef..f1ca7c29 100644 --- a/test/tour.test.ts +++ b/test/tour.test.ts @@ -15,7 +15,7 @@ import { stepMissions } from '../src/missions/machine.ts'; import type { Skeleton } from '../src/missions/model.ts'; import { pickByJumps, placeLeg } from '../src/missions/placement.ts'; import { emptyMissionState } from '../src/missions/state.ts'; -import { arcStarts, leadWorldIn } from '../src/missions/tour.ts'; +import { arcStarts } from '../src/missions/tour.ts'; import { g1 } from './fixtures.ts'; import { check, eq } from './harness.ts'; @@ -83,7 +83,7 @@ console.log('\n...the handover placement ends an arc near the next start'); line: 'END', next: [{ on: 'success', to: 'complete' }, { on: 'failed', to: 'fail' }] }], complete: { pay: 0, lead: 'next' }, fail: { pay: 0, lead: 'next' }, }; - const facts = { galaxy: 1, systemIndex: LAVE, kills: 0, combatScore: 0, legalStatus: 0, day: 0, cargo: [] }; + const facts = { galaxy: 1, systemIndex: LAVE, kills: 0, combatScore: 0, legalStatus: 0, scoops: true, day: 0, cargo: [] }; const placed = placeLeg(arc.legs[0].place, emptyMissionState(), facts, g1, half, 'arc', [arc, next]); check('placeLeg places a handover leg', placed.ok && placed.target !== null); const r = stepMissions(emptyMissionState(), { kind: 'accept', skeleton: 'arc' }, { @@ -94,7 +94,7 @@ console.log('\n...the handover placement ends an arc near the next start'); routeTable(g1, goal).jumps[target] >= ARC_HANDOVER_JUMPS.min && routeTable(g1, goal).jumps[target] <= ARC_HANDOVER_JUMPS.max); } -console.log('\n...and a lead follows a galactic jump to a world she can reach'); +console.log('\n...and a tour from any arrival world of any galaxy is well formed'); { let bad = 0; let checked = 0; @@ -106,11 +106,9 @@ console.log('\n...and a lead follows a galactic jump to a world she can reach'); checked += 1; if (starts.length !== TOUR_ARCS || starts[0] !== arrival) bad += 1; if (starts.some((s) => reach[s] === Infinity)) bad += 1; - for (let k = 0; k < TOUR_ARCS; k += 1) if (reach[leadWorldIn(systems, arrival, k)] === Infinity) bad += 1; } } eq(`in all eight galaxies, from ${checked} arrival worlds, every start is reachable`, bad, 0); - eq('a skeleton outside the tour waits at the arrival world', leadWorldIn(g1, 99, -1), 99); // Galaxy 8 strands Oresrati: a tour from there is a tour of one world. const g8 = generateGalaxy(8); const alone = g8.find((s) => routeTable(g8, s.index).jumps.filter((j) => j !== Infinity).length === 1); diff --git a/tools/dossier-prompts.ts b/tools/dossier-prompts.ts index dec21e56..61231e70 100644 --- a/tools/dossier-prompts.ts +++ b/tools/dossier-prompts.ts @@ -132,7 +132,7 @@ function patronLine(s: Skeleton): { line: string; own: string } { own: '', }; } - const facts = { galaxy: 1, systemIndex: 0, kills: 0, combatScore: 0, legalStatus: 0, day: 0, cargo: [] }; + const facts = { galaxy: 1, systemIndex: 0, kills: 0, combatScore: 0, legalStatus: 0, day: 0, cargo: [], scoops: false }; const p = patronFor(s.patron, facts, generateGalaxy(1)); if (s.patron.kind === 'navy') { return { line: `Patron: ${p.name}, in service signals: rank, no courtesy, no name, no world. Use neither {PATRON} nor {HERE}.`, own: '' }; From e2bbabb1c3c315ec3f51d7269c0c0d128cd71dcb Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Sun, 13 Sep 2026 09:34:53 +0100 Subject: [PATCH 064/100] docs/TODO/213 M3: the gun warning speaks for the Constrictor, and a board does not silence a lead TARGET ARMOUR HALVES LASER FIRE was said on every side hunt and every arc hunt, because a military laser scores more than a pulse laser against every hull. Only the Constrictor's policy halves a player hit. The warning reads that field, and says nothing for a target at 1. A dock that made any offer said nothing about a lead. Most worlds carry side jobs, so the patron's one-jump message and the fourth-dock reminder never came through. Only an arc's hail counts as a hail now, and the message queues behind the side-job count. Co-Authored-By: Claude Fable 5.1 Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- ...on-rules-hold-and-a-hit-trader-goes-back-to-work.md | 10 ++++++++++ src/game/hunt-warning.ts | 7 +++++++ src/missions/hail.ts | 5 ++++- test/mission-offers.test.ts | 8 ++++++++ test/missions.test.ts | 10 +++++++++- 5 files changed, 38 insertions(+), 2 deletions(-) diff --git a/docs/TODO/213-the-mission-rules-hold-and-a-hit-trader-goes-back-to-work.md b/docs/TODO/213-the-mission-rules-hold-and-a-hit-trader-goes-back-to-work.md index 64ca4c0d..5e757912 100644 --- a/docs/TODO/213-the-mission-rules-hold-and-a-hit-trader-goes-back-to-work.md +++ b/docs/TODO/213-the-mission-rules-hold-and-a-hit-trader-goes-back-to-work.md @@ -218,3 +218,13 @@ Evidence, one per fault: commander facts, and it gained `scoops` so the after-run can read the same blocks. - The suite has 6,001 checks. + +### M3 + +- **The halving is a field, and the warning reads it.** `playerLaserMultiplier` + on the target's energy policy is the Constrictor's half. The warning + returns nothing for a policy at 1, before it prices a gun. Every test that + read the Constrictor's warning still reads it. +- **A side-job count queues, and the message queues behind it.** The dock + says THERE IS ONE SIDE JOB ON THE STATION BOARD, and then A MESSAGE FROM + the patron next door. Only an arc's hail silences the hint now. diff --git a/src/game/hunt-warning.ts b/src/game/hunt-warning.ts index 34a4dfd6..fc7bb985 100644 --- a/src/game/hunt-warning.ts +++ b/src/game/hunt-warning.ts @@ -19,6 +19,12 @@ // The one thing a commander must not do is fly forty light years to find that // out. The beam laser is the trap: it is the upgrade, and it is worse here // than the gun it replaced. +// +// IT SPEAKS FOR A TARGET THAT HALVES A HIT, AND FOR NO OTHER (docs/TODO/213 +// M3). A military laser scores more than a pulse laser against every hull. +// So the words TARGET ARMOUR HALVES LASER FIRE were said on every side hunt +// and every arc hunt. Only the Constrictor's policy halves a player hit, and +// the numbers are its signpost. A Krait needs no signpost. import type { CommanderData, LaserType } from './commander.ts'; import { playerLaser } from './gunnery.ts'; @@ -56,6 +62,7 @@ export function huntGunCheck(commander: CommanderData, target: NpcSpec): GunChec * player learns to skip. */ export function huntWarning(commander: CommanderData, target: NpcSpec, patron = 'NAVY'): string { + if (npcEnergyPolicy(target.profileId).playerLaserMultiplier >= 1) return ''; const g = huntGunCheck(commander, target); if (g.fitted === g.best) return ''; return `${patron}: TARGET ARMOUR HALVES LASER FIRE — YOUR ${g.fitted.toUpperCase()} LASER` diff --git a/src/missions/hail.ts b/src/missions/hail.ts index 99e24ab1..10daf914 100644 --- a/src/missions/hail.ts +++ b/src/missions/hail.ts @@ -36,7 +36,10 @@ export function hail( if (arcs.length === 0) effects.push({ kind: 'say', text, command: 'openMissions' }); else effects.push({ kind: 'later', text }); } - const hint = dockHint(st, ctx.commander, ctx.systems, offers.length > 0, st.idleDocks); + // ONLY AN ARC'S HAIL IS A HAIL. Most worlds carry side jobs, so a count + // that counted as one silenced the patron's message on almost every dock + // (docs/TODO/213 M3). The message queues behind the count. + const hint = dockHint(st, ctx.commander, ctx.systems, arcs.length > 0, st.idleDocks); if (hint) effects.push({ kind: 'later', ...hint }); } diff --git a/test/mission-offers.test.ts b/test/mission-offers.test.ts index 5f253584..699a3391 100644 --- a/test/mission-offers.test.ts +++ b/test/mission-offers.test.ts @@ -150,6 +150,14 @@ console.log('\nhints: the word travels by distance, one line per dock'); const both = dock(lead(next.index), LAVE, arcs(next.index)); eq('a dock that makes an offer says nothing about a lead', said(both.effects).join('|'), 'A WORD FROM THE GOVERNOR'); + // ...but a board of side jobs is not an offer of that kind. Most worlds + // carry one, and it silenced the message on almost every dock + // (docs/TODO/213 M3). + const board = dock(quiet(lead(next.index)), LAVE, [...arcs(next.index), ...SIDE_JOBS]); + check('a dock with side jobs on the board still passes the message on', + said(board.effects).some((t) => t.includes('SIDE JOB')) + && said(board.effects).some((t) => t.includes('MESSAGE FROM') && t.includes(next.name.toUpperCase())), + said(board.effects).join('|')); // The second message, after docks with no progress. let st = quiet(lead(near.index)); diff --git a/test/missions.test.ts b/test/missions.test.ts index 73193194..1e1c2f13 100644 --- a/test/missions.test.ts +++ b/test/missions.test.ts @@ -16,7 +16,9 @@ import { newCommander } from '../src/game/commander.ts'; import type { CommanderData } from '../src/game/commander.ts'; import { stepTrumbles, trumbleMessage } from '../src/game/trumbles.ts'; import { BREED_INTERVAL, MAX_TRUMBLES } from '../src/constants/trumbles.ts'; -import { constrictorGunCheck, constrictorWarning } from '../src/game/hunt-warning.ts'; +import { constrictorGunCheck, constrictorWarning, huntWarning } from '../src/game/hunt-warning.ts'; +import { SOURCE_DESIGN, specForDesign } from '../src/game/ship-specs.ts'; +import { shipDesignIdOf } from '../src/game/ship-identity.ts'; import { check, eq } from './harness.ts'; // --- the Navy's gun warning -------------------------------------------------- @@ -43,6 +45,12 @@ console.log('\nthe Navy gun warning'); && constrictorWarning(withLaser('beam')).includes('MILITARY')); eq('a commander already carrying the right gun is told nothing', constrictorWarning(withLaser('military')), ''); + // A military laser scores more against every hull, so the warning was + // said on every hunt. Only a target that halves a hit needs the signpost + // (docs/TODO/213 M3). + const krait = specForDesign('pirate', shipDesignIdOf(SOURCE_DESIGN.krait))!; + eq('...and a Krait, which halves nothing, earns no warning at all', + huntWarning(withLaser('pulse'), krait, 'PATRON'), ''); } } From 27f0ca0bb8d447a539b2dc302b310a77d15daf53 Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Sun, 13 Sep 2026 09:40:37 +0100 Subject: [PATCH 065/100] docs/TODO/213 M4: the save, the journal, the standing and the restore hold A live mission on a skeleton or a leg the code no longer ships threw on the next dock, and on the abandon that could have freed the slot. The loaders drop a ghost live mission, lead or passenger, and the rest of the record stands. A journal entry carries its galaxy, and the story names each world through the galaxy its entry was written in. The LOG draws the route of the galaxy she is in. One memo of the eight galaxies, galaxy/galaxies.ts, serves the bridge, the story and the LOG. A local patron's standing is keyed by the world the job was taken at. A restored mission ship takes the role its leg flies it under, so a Python escort no longer comes back with a pirate's guns. A branch whose next leg cannot be placed starts it at any station and still settles, and the lint measures a handover from every world, as it measures a band. Co-Authored-By: Claude Fable 5.1 Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- ...hold-and-a-hit-trader-goes-back-to-work.md | 17 +++++ src/galaxy/galaxies.ts | 23 +++++++ src/game/mission-bridge.ts | 33 +++++----- src/game/screens/log.ts | 19 ++++-- src/game/spawning.ts | 3 +- src/missions/lint.ts | 13 +++- src/missions/lookups.ts | 10 ++- src/missions/machine.ts | 24 ++++--- src/missions/model.ts | 6 ++ src/missions/repair.ts | 18 +++++- src/missions/story.ts | 22 +++++-- src/missions/verbs/registry.ts | 11 +++- test/mission-game.test.ts | 63 ++++++++++++++++++- test/mission-pieces.test.ts | 25 ++++++++ test/mission-skeletons.test.ts | 4 ++ test/mission-story.test.ts | 26 ++++++++ test/mission-verbs.test.ts | 16 ++++- 17 files changed, 282 insertions(+), 51 deletions(-) create mode 100644 src/galaxy/galaxies.ts diff --git a/docs/TODO/213-the-mission-rules-hold-and-a-hit-trader-goes-back-to-work.md b/docs/TODO/213-the-mission-rules-hold-and-a-hit-trader-goes-back-to-work.md index 5e757912..c5bddd46 100644 --- a/docs/TODO/213-the-mission-rules-hold-and-a-hit-trader-goes-back-to-work.md +++ b/docs/TODO/213-the-mission-rules-hold-and-a-hit-trader-goes-back-to-work.md @@ -228,3 +228,20 @@ Evidence, one per fault: - **A side-job count queues, and the message queues behind it.** The dock says THERE IS ONE SIDE JOB ON THE STATION BOARD, and then A MESSAGE FROM the patron next door. Only an arc's hail silences the hint now. + +### M4 + +- **One memo of the eight galaxies**, `galaxy/galaxies.ts`. The bridge kept + a memo of one galaxy at a time, and a story that names two galaxies + thrashes a memo of one. The bridge, the story and the LOG read the one memo. +- **The LOG draws the route of the galaxy she is in.** A page carries its + galaxy, and the route map takes the pages of the commander's galaxy. A + page from another galaxy still reads, with its own names. +- **The loaders have no console**, so a dropped ghost is silent. The header + of `repair.ts` says so. A test drives a ghost skeleton, a ghost leg, a + ghost lead and a ghost passenger through both loaders. +- **The role a job's ship flies under has one home**, `jobRole` in the + verb registry. The spawn and the restore both read it. +- **A test fixture met the ghost rule.** The galaxy-change test saves a lead + to a fixture skeleton, which the loader now drops. The saved lead names a + shipped arc instead. diff --git a/src/galaxy/galaxies.ts b/src/galaxy/galaxies.ts new file mode 100644 index 00000000..1867831f --- /dev/null +++ b/src/galaxy/galaxies.ts @@ -0,0 +1,23 @@ +// The eight galaxies, generated once each and kept. +// +// `generateGalaxy` is a pure function of its number, and it costs a few +// milliseconds. Three readers want a galaxy the commander is not in. The +// mission bridge names a lead's world. The story names a journal entry's +// world. The LOG draws the route (docs/TODO/213 M4). One memo, so no reader +// keeps a second copy of the same 256 systems. The bridge kept a memo of +// one galaxy at a time before this file. A story that names two galaxies +// thrashes a memo of one. + +import { generateGalaxy, type StarSystem } from './galaxy.ts'; + +const memo = new Map(); + +/** The systems of `galaxy`, generated on the first ask and kept. */ +export function galaxySystems(galaxy: number): readonly StarSystem[] { + let s = memo.get(galaxy); + if (!s) { + s = generateGalaxy(galaxy); + memo.set(galaxy, s); + } + return s; +} diff --git a/src/game/mission-bridge.ts b/src/game/mission-bridge.ts index 02c7d7ba..b0924e46 100644 --- a/src/game/mission-bridge.ts +++ b/src/game/mission-bridge.ts @@ -11,7 +11,8 @@ // ONE OPERATION. The record and its effects land together, before any save, // so a reload cannot find the credits paid and the leg still owed. -import { COMMODITIES, generateGalaxy, type StarSystem } from '../galaxy/galaxy.ts'; +import { COMMODITIES, type StarSystem } from '../galaxy/galaxy.ts'; +import { galaxySystems } from '../galaxy/galaxies.ts'; import { afterDeed } from './character.ts'; import { cargoCapacity, cargoTonnes, type CommanderData } from './commander.ts'; import { random } from './rng.ts'; @@ -20,6 +21,8 @@ import { huntWarning } from './hunt-warning.ts'; import { dossierWord } from '../missions/dossiers.ts'; import { stepMissions } from '../missions/machine.ts'; import { legOf } from '../missions/lookups.ts'; +import { liveLegs } from '../missions/queries.ts'; +import { jobRole, verbJob, verbNeedsShip } from '../missions/verbs/registry.ts'; import type { CommanderFacts, LiveMission, MissionInput, Skeleton } from '../missions/model.ts'; import { skeletonById } from '../missions/skeletons/index.ts'; import { FUGITIVE } from '../constants/law.ts'; @@ -46,19 +49,6 @@ export function missionFacts(c: CommanderData): CommanderFacts { }; } -/** - * The systems of a galaxy, for a caller that holds only the commander. - * - * The wreck resolver and the world step have no `GameState.systems` in reach. - * The galaxy is a pure function of its number, and a memo of one galaxy at a - * time keeps the generator off the hot path. - */ -let memo: { galaxy: number; systems: StarSystem[] } | null = null; -function systemsOf(galaxy: number): readonly StarSystem[] { - if (!memo || memo.galaxy !== galaxy) memo = { galaxy, systems: generateGalaxy(galaxy) }; - return memo.systems; -} - /** * Run one input through the machine, install the record, apply the costs. * @@ -67,7 +57,7 @@ function systemsOf(galaxy: number): readonly StarSystem[] { */ export function runMissions( c: CommanderData, input: MissionInput, - systems: readonly StarSystem[] = systemsOf(c.galaxy), rng: () => number = random, + systems: readonly StarSystem[] = galaxySystems(c.galaxy), rng: () => number = random, skeletons?: readonly Skeleton[], ): MissionMessage[] { const { state, effects } = stepMissions(c.missions, input, { @@ -100,7 +90,7 @@ export function runMissions( // The lead's own galaxy names the world. An arc that fails on a galactic // jump leaves its lead in the galaxy it came from (docs/TODO/213 M2). case 'lead': { - const named = e.galaxy === c.galaxy ? systems : systemsOf(e.galaxy); + const named = e.galaxy === c.galaxy ? systems : galaxySystems(e.galaxy); out.push({ kind: 'message', queued: true, seconds: 6, text: `THERE IS A LEAD. ASK AT ${named[e.world].name.toUpperCase()}.`, @@ -145,10 +135,17 @@ export function runMissions( return out; } -/** The roster row for a mission ship, by the design its entity names. */ +/** + * The roster row for a mission ship, by the design its entity names and the + * role its leg flies it under. Every tagged ship was looked up as a pirate + * until docs/TODO/213 M4, so a restored Python escort took a pirate's guns. + */ export function missionShipSpec(c: CommanderData, tag: string): NpcSpec | undefined { const e = c.missions.entities[tag]; - return e ? specForDesign('pirate', e.ship) : undefined; + if (!e) return undefined; + const leg = liveLegs(c.missions).find(({ live }) => live.tag === tag)?.leg; + const role = leg && verbNeedsShip(leg.verb) ? jobRole(verbJob(leg.verb)) : 'pirate'; + return specForDesign(role, e.ship); } /** diff --git a/src/game/screens/log.ts b/src/game/screens/log.ts index 84f7195e..3cdcd7a6 100644 --- a/src/game/screens/log.ts +++ b/src/game/screens/log.ts @@ -15,17 +15,21 @@ import { storyPages, type StoryPage } from '../../missions/story.ts'; import { routeMapSvg } from '../../missions/route-map.ts'; import { skeletonById } from '../../missions/skeletons/index.ts'; import { missionFacts } from '../mission-bridge.ts'; +import { galaxySystems } from '../../galaxy/galaxies.ts'; export interface LogContext { readonly commander: CommanderData; readonly systems: StarSystem[]; } -/** The latest page's patron, by name and face. A local patron ran the origin's station. */ -function patronOf(page: StoryPage | undefined, c: CommanderData, systems: StarSystem[]): Patron { +/** + * The latest page's patron, by name and face. A local patron ran the + * origin's station, in the page's own galaxy (docs/TODO/213 M4). + */ +function patronOf(page: StoryPage | undefined, c: CommanderData): Patron { const s = page ? skeletonById(page.skeleton) : null; if (!page || !s) return NAVY_PATRON; - return patronFor(s.patron, missionFacts(c), systems, page.origin); + return patronFor(s.patron, { ...missionFacts(c), galaxy: page.galaxy }, galaxySystems(page.galaxy), page.origin); } export class LogScreen implements Screen { @@ -42,9 +46,12 @@ export class LogScreen implements Screen { render(): void { const { commander, systems } = this.ctx(); - const pages = storyPages(commander.missions, systems); - const worlds = pages.flatMap((p) => p.worlds); - const patron = patronOf(pages[pages.length - 1], commander, systems); + // Every page names its worlds through its own galaxy. The route is the + // chart of the galaxy she is in, so it draws the pages from this one. + const pages = storyPages(commander.missions, + (galaxy) => (galaxy === commander.galaxy ? systems : galaxySystems(galaxy))); + const worlds = pages.filter((p) => p.galaxy === commander.galaxy).flatMap((p) => p.worlds); + const patron = patronOf(pages[pages.length - 1], commander); renderLog({ pages, route: routeMapSvg(systems, worlds), diff --git a/src/game/spawning.ts b/src/game/spawning.ts index 7a0cf308..ee7b2dd6 100644 --- a/src/game/spawning.ts +++ b/src/game/spawning.ts @@ -23,6 +23,7 @@ import { steerQuatToward } from './flight-maths.ts'; import { pirateSpecForTier, specForDesign, type NpcSpec } from './ship-specs.ts'; import type { NpcRole } from './ship-roles.ts'; import type { TaggedItem, TaggedShip } from '../missions/model.ts'; +import { jobRole } from '../missions/verbs/registry.ts'; import { memberTier } from './threat.ts'; import { slotNormal } from '../world/slot.ts'; import { random, randomInt, randomDirection } from './rng.ts'; @@ -203,7 +204,7 @@ export function spawnPopulation( // lint is the place to catch that. const spawned: NpcShip[] = []; for (const tagged of missionShips) { - const role = tagged.job === 'hunt' ? 'pirate' : 'trader'; + const role = jobRole(tagged.job); const spec = specForDesign(role, tagged.ship); if (!spec) continue; const pos = playerPos.clone() diff --git a/src/missions/lint.ts b/src/missions/lint.ts index 3a4203b4..862e65f5 100644 --- a/src/missions/lint.ts +++ b/src/missions/lint.ts @@ -24,6 +24,7 @@ import { routeTable } from '../galaxy/route.ts'; import type { Leg, Skeleton } from './model.ts'; import { specForDesign } from '../game/ship-specs.ts'; import { verbJob, verbModule, verbNeedsShip } from './verbs/registry.ts'; +import { pickByJumps } from './placement.ts'; export function lintSkeleton( s: Skeleton, all: readonly Skeleton[], systems: readonly StarSystem[], @@ -49,8 +50,16 @@ export function lintSkeleton( out.push(`${at}: branch to unknown leg ${b.to}`); } } - if (leg.place.kind === 'handover' && !all.some((t) => t.id === (leg.place as { toward: string }).toward)) { - out.push(`${at}: handover toward unknown skeleton ${leg.place.toward}`); + if (leg.place.kind === 'handover') { + const toward = all.find((t) => t.id === (leg.place as { toward: string }).toward); + if (!toward) out.push(`${at}: handover toward unknown skeleton ${leg.place.toward}`); + // Measured from every world, as a band is (docs/TODO/213 M4). A leg + // that cannot be placed starts at any station, and that is a guard. + const goal = toward ? startOf(toward) : null; + const band = leg.place; + const dry = goal === null ? null + : systems.find((from) => pickByJumps(systems, from.index, goal, band, () => 0) === null); + if (dry) out.push(`${at}: handover ${band.min}-${band.max} has no candidate from ${dry.name}`); } if (leg.place.kind === 'band') { const band = leg.place; diff --git a/src/missions/lookups.ts b/src/missions/lookups.ts index 8aa2cf18..f401ebc4 100644 --- a/src/missions/lookups.ts +++ b/src/missions/lookups.ts @@ -16,12 +16,16 @@ export function legOf(skeleton: Skeleton, id: string): Leg { /** * The key that `MissionState.standing` and a dossier file use for a patron. - * A local patron is the world she stands at, so the key names that world. + * A local patron is whoever runs the station the job was taken at, so the + * key names `origin` where the caller knows it. Without one it names the + * world she stands at, which is right on the board. It named that world + * at every settlement until docs/TODO/213 M4, so a delivery credited the + * far end's patron. */ -export function patronId(skeleton: Skeleton, commander: CommanderFacts): string { +export function patronId(skeleton: Skeleton, commander: CommanderFacts, origin?: number): string { const p = skeleton.patron; if (p.kind === 'navy') return 'navy'; - return `world-${p.kind === 'world' ? p.seedSlot : commander.systemIndex}`; + return `world-${p.kind === 'world' ? p.seedSlot : (origin ?? commander.systemIndex)}`; } /** diff --git a/src/missions/machine.ts b/src/missions/machine.ts index d606021e..8979a93e 100644 --- a/src/missions/machine.ts +++ b/src/missions/machine.ts @@ -31,6 +31,7 @@ import type { import { canAccept } from './offers.ts'; import { placeLeg } from './placement.ts'; import { legOf, patronId, startWorld } from './lookups.ts'; +import { acceptedAt } from './queries.ts'; import { SKELETONS, skeletonById } from './skeletons/index.ts'; import { fillSlots, legPay, lineSlots } from './text.ts'; import { sameTrigger, triggerLabel, wordKind } from './triggers.ts'; @@ -90,7 +91,7 @@ function accept( const first = skeleton.legs[0]; const placed = placeLeg(first.place, st, c, ctx.systems, ctx.rng, id, ctx.skeletons ?? SKELETONS); if (!placed.ok) return; - st.journal.push({ skeleton: id, leg: first.id, outcome: 'accepted', day: c.day, world: c.systemIndex }); + st.journal.push({ skeleton: id, leg: first.id, outcome: 'accepted', day: c.day, world: c.systemIndex, galaxy: c.galaxy }); const live: LiveMission = { skeleton: id, leg: first.id, target: null, tag: null, progress: 0, deadlineDay: null, }; @@ -115,7 +116,7 @@ function abandon( const live = st.live.find((l) => l.skeleton === id); if (!live) return; const c = ctx.commander; - st.journal.push({ skeleton: id, leg: live.leg, outcome: 'abandoned', day: c.day, world: c.systemIndex }); + st.journal.push({ skeleton: id, leg: live.leg, outcome: 'abandoned', day: c.day, world: c.systemIndex, galaxy: c.galaxy }); finish(st, live, 'fail', ctx, effects); } @@ -132,7 +133,7 @@ function leaveGalaxy( ): void { const c = ctx.commander; for (const live of [...st.live]) { - st.journal.push({ skeleton: live.skeleton, leg: live.leg, outcome: 'galaxyLeft', day: c.day, world: c.systemIndex }); + st.journal.push({ skeleton: live.skeleton, leg: live.leg, outcome: 'galaxyLeft', day: c.day, world: c.systemIndex, galaxy: c.galaxy }); finish(st, live, 'fail', ctx, effects); } } @@ -222,7 +223,7 @@ function takeBranch( ): void { const skeleton = skeletonOf(live.skeleton, ctx); const c = ctx.commander; - const entry = { skeleton: live.skeleton, leg: live.leg, outcome: triggerLabel(branch.on), day: c.day, world: c.systemIndex }; + const entry = { skeleton: live.skeleton, leg: live.leg, outcome: triggerLabel(branch.on), day: c.day, world: c.systemIndex, galaxy: c.galaxy }; const leg = legOf(skeleton, live.leg); const kind = wordKind(leg, branch); const word = (target: number | null): DossierWord | undefined => (kind @@ -239,10 +240,15 @@ function takeBranch( } const next = legOf(skeleton, branch.to); const placed = placeLeg(next.place, st, c, ctx.systems, ctx.rng, live.skeleton, ctx.skeletons ?? SKELETONS); - if (!placed.ok) return; - settle(st, skeleton, branch.settle, placed.target, ctx, effects, word(placed.target)); + // A LEG THAT CANNOT BE PLACED STARTS AT ANY STATION. The branch used to + // return here, before the settlement and the journal, with the target + // already dead. The kill paid nothing and the mission held its slot for + // good (docs/TODO/213 M4). The lint measures every band and every + // handover from every world, so the path is a guard rather than a rule. + const target = placed.ok ? placed.target : null; + settle(st, skeleton, branch.settle, target, ctx, effects, word(target)); st.journal.push(entry); - startLeg(st, live, skeleton, next, placed.target, ctx, effects); + startLeg(st, live, skeleton, next, target, ctx, effects); } /** @@ -318,7 +324,7 @@ function settle( if (!st.flags.includes(f)) { st.flags.push(f); added.push(f); } } if (s.standing) { - const id = patronId(skeleton, ctx.commander); + const id = patronId(skeleton, ctx.commander, acceptedAt(st, skeleton.id)); st.standing[id] = (st.standing[id] ?? 0) + s.standing; } // A change to a world is the game's to keep (mission-bridge.ts), at the @@ -350,7 +356,7 @@ function finish( const o = skeleton[outcome]; settle(st, skeleton, o, null, ctx, effects); st.done[live.skeleton] = outcome; - st.journal.push({ skeleton: live.skeleton, leg: live.leg, outcome, day: c.day, world: c.systemIndex }); + st.journal.push({ skeleton: live.skeleton, leg: live.leg, outcome, day: c.day, world: c.systemIndex, galaxy: c.galaxy }); st.live = st.live.filter((l) => l !== live); for (const tag of Object.keys(st.entities)) { if (tag.startsWith(`${live.skeleton}#`)) delete st.entities[tag]; diff --git a/src/missions/model.ts b/src/missions/model.ts index 069ab240..bbbf574f 100644 --- a/src/missions/model.ts +++ b/src/missions/model.ts @@ -284,6 +284,12 @@ export interface JournalEntry { outcome: string; day: number; world: number; + /** + * The galaxy `world` is an index in. Absent on a record written before + * docs/TODO/213 M4, and it reads as galaxy 1. The log named every world + * through the galaxy she stood in, so a jump renamed her whole past. + */ + galaxy?: number; } export interface EntityState { diff --git a/src/missions/repair.ts b/src/missions/repair.ts index faecfc8e..0e3f0247 100644 --- a/src/missions/repair.ts +++ b/src/missions/repair.ts @@ -7,15 +7,22 @@ // carries a `mission` field with a stage number instead. That field is // dropped by the caller, and this installs an empty record in its place. The // save loads, and only the mission progress is lost (docs/TODO/190). +// +// A GHOST IS DROPPED (docs/TODO/213 M4). A live mission, a lead or a +// passenger can point at a skeleton or a leg the code no longer ships. Such +// a record threw on the next dock. It threw on the abandon too, so the slot +// stayed held. The loaders have no console, so the drop is silent, and the +// rest of the record stands. -import type { MissionState } from './model.ts'; +import type { MissionState, Skeleton } from './model.ts'; +import { SKELETONS, skeletonById } from './skeletons/index.ts'; import { emptyMissionState } from './state.ts'; const isRecord = (v: unknown): v is Record => typeof v === 'object' && v !== null && !Array.isArray(v); /** The stored record when every field has its shape, else an empty one. */ -export function repairMissionState(raw: unknown): MissionState { +export function repairMissionState(raw: unknown, skeletons: readonly Skeleton[] = SKELETONS): MissionState { const empty = emptyMissionState(); if (!isRecord(raw)) return empty; const arrays = ['live', 'leads', 'flags', 'passengers', 'journal'] as const; @@ -26,5 +33,12 @@ export function repairMissionState(raw: unknown): MissionState { // Fields added after the first records were written: absent reads as none. if (typeof kept.idleDocks !== 'number') kept.idleDocks = 0; if (!Array.isArray(kept.changes)) kept.changes = []; + const known = (skeleton: string, leg?: string): boolean => { + const s = skeletonById(skeleton, skeletons); + return s !== null && (leg === undefined || s.legs.some((l) => l.id === leg)); + }; + kept.live = kept.live.filter((l) => known(l.skeleton, l.leg)); + kept.leads = kept.leads.filter((l) => known(l.skeleton)); + kept.passengers = kept.passengers.filter((p) => known(p.mission)); return kept; } diff --git a/src/missions/story.ts b/src/missions/story.ts index 064cf434..9d201ed8 100644 --- a/src/missions/story.ts +++ b/src/missions/story.ts @@ -10,6 +10,7 @@ // site page (item 193 of docs/TODO/190) both render what it returns. import type { StarSystem } from '../galaxy/galaxy.ts'; +import { galaxySystems } from '../galaxy/galaxies.ts'; import { dossierFor } from './dossiers.ts'; import type { Dossier, JournalEntry, MissionState } from './model.ts'; import { SKELETONS, skeletonById } from './skeletons/index.ts'; @@ -21,6 +22,8 @@ export interface StoryPage { title: string; /** the world the run was accepted at */ origin: number; + /** the galaxy `origin` and `worlds` are indices in (docs/TODO/213 M4) */ + galaxy: number; /** every world the journal names on this run, in order, without repeats */ worlds: number[]; lines: string[]; @@ -40,10 +43,13 @@ function plainOutcome(outcome: string): string { const ENDINGS = new Set(['complete', 'fail', 'abandoned', 'galaxyLeft']); +/** The galaxy an entry's world is an index in: its own, or 1 for a record from before it was written. */ +const galaxyOf = (e: JournalEntry): number => e.galaxy ?? 1; + function lineFor( - e: JournalEntry, dossier: Dossier | null, systems: readonly StarSystem[], + e: JournalEntry, dossier: Dossier | null, galaxies: (galaxy: number) => readonly StarSystem[], ): string { - const slots = { WORLD: systems[e.world].name.toUpperCase(), DAY: String(e.day) }; + const slots = { WORLD: galaxies(galaxyOf(e))[e.world].name.toUpperCase(), DAY: String(e.day) }; const own = dossier?.story.legs[e.leg]?.[e.outcome]; if (own) return fillSlots(own, slots); if (e.outcome === 'accepted') { @@ -62,11 +68,17 @@ function lineFor( /** * The pages, oldest first. A run opens at its `accepted` entry and closes * at its ending. A run with no ending yet is the last page for its mission. + * + * Every world is named through the galaxy its own entry names. `systems` + * is galaxy 1's, for a caller that holds one galaxy, or a function of the + * galaxy number, which the LOG passes (docs/TODO/213 M4). */ export function storyPages( - st: MissionState, systems: readonly StarSystem[], + st: MissionState, systems: readonly StarSystem[] | ((galaxy: number) => readonly StarSystem[]), skeletons = SKELETONS, dossiers: (id: string) => Dossier | null = dossierFor, ): StoryPage[] { + const galaxies = typeof systems === 'function' ? systems + : (galaxy: number): readonly StarSystem[] => (galaxy === 1 ? systems : galaxySystems(galaxy)); const pages: StoryPage[] = []; const open = new Map(); for (const e of st.journal) { @@ -75,14 +87,14 @@ export function storyPages( const page: StoryPage = { skeleton: e.skeleton, title: dossier?.title ?? plainTitle(skeletonById(e.skeleton, skeletons)?.id ?? e.skeleton), - origin: e.world, worlds: [], lines: [], ending: null, + origin: e.world, galaxy: galaxyOf(e), worlds: [], lines: [], ending: null, }; pages.push(page); open.set(e.skeleton, page); } const page = open.get(e.skeleton); if (!page) continue; - page.lines.push(lineFor(e, dossiers(e.skeleton), systems)); + page.lines.push(lineFor(e, dossiers(e.skeleton), galaxies)); if (page.worlds[page.worlds.length - 1] !== e.world) page.worlds.push(e.world); if (e.outcome === 'complete' || e.outcome === 'fail') { page.ending = e.outcome; diff --git a/src/missions/verbs/registry.ts b/src/missions/verbs/registry.ts index b8a86b2a..6cecefa0 100644 --- a/src/missions/verbs/registry.ts +++ b/src/missions/verbs/registry.ts @@ -5,7 +5,7 @@ // eight are here since docs/TODO/190 M4. The table stays partial in type, so // a ninth verb added to the model is a lint failure until its module lands. -import type { Verb } from '../model.ts'; +import type { TaggedShip, Verb } from '../model.ts'; import { ambush } from './ambush.ts'; import { deliver } from './deliver.ts'; import { escort } from './escort.ts'; @@ -35,6 +35,15 @@ export function verbJob(verb: Extract): 'hunt' | 'escort return verb.kind === 'hunt' ? 'hunt' : verb.kind === 'escort' ? 'escort' : 'scan'; } +/** + * The roster role a job's ship is spawned and restored under. The spawn and + * the restore each mapped it alone until docs/TODO/213 M4, and the restore + * read every tagged ship as a pirate. + */ +export function jobRole(job: TaggedShip['job']): 'pirate' | 'trader' { + return job === 'hunt' ? 'pirate' : 'trader'; +} + /** The item a recover or a rescue leg puts adrift, or null. */ export function verbItem(verb: Verb): 'cargo' | 'capsule' | null { return verb.kind === 'recover' ? 'cargo' : verb.kind === 'rescue' ? 'capsule' : null; diff --git a/test/mission-game.test.ts b/test/mission-game.test.ts index 1ac8de22..b489674b 100644 --- a/test/mission-game.test.ts +++ b/test/mission-game.test.ts @@ -12,7 +12,10 @@ import { withoutSaving, readSave, writeSave, makeRecord } from '../src/game/stor import { seedWorld } from '../src/game/rng.ts'; import { newCommander, type CommanderData } from '../src/game/commander.ts'; import { destroyShip } from '../src/game/combat-wreck.ts'; -import { runMissions } from '../src/game/mission-bridge.ts'; +import { missionShipSpec, runMissions } from '../src/game/mission-bridge.ts'; +import { repairMissionState } from '../src/missions/repair.ts'; +import { SOURCE_DESIGN, specForDesign } from '../src/game/ship-specs.ts'; +import { shipDesignIdOf } from '../src/game/ship-identity.ts'; import { parseSnapshot } from '../src/game/snapshot-parse.ts'; import { CONSTRICTOR_BLUEPRINT_SET } from '../src/constants/blueprint-set.ts'; import { NARCOTICS } from '../src/constants/commodities.ts'; @@ -242,13 +245,16 @@ console.log('\na lead stays in the galaxy it was saved in (docs/TODO/213 M2)'); // A save carries the pair together. An index alone names nothing across // galaxies. + // The loader drops a lead to a skeleton the game does not ship (213 M4), + // so the saved lead names a shipped arc with the same galaxy and world. seedWorld(1904); const g = withoutSaving(() => new Game(() => headlessShell())).value; dismissBriefing(g); - g.state.commander.missions = r.state; + const shipped = { ...r.state, leads: [{ ...r.state.leads[0], skeleton: 'arc-rabedira' }] }; + g.state.commander.missions = shipped; const snap = parseSnapshot(structuredClone(g.captureSnapshot())); eq('a save keeps the lead\'s galaxy and world together', - JSON.stringify(snap.commander.missions.leads), JSON.stringify(r.state.leads)); + JSON.stringify(snap.commander.missions.leads), JSON.stringify(shipped.leads)); } console.log('\na jump reaches the machine as a day and an arrival, and the lane completes (docs/TODO/203 M1)'); @@ -315,3 +321,54 @@ console.log('\na smuggling run leaves the goods at the far end (docs/TODO/213 M2 eq('...and the goods are off the ship', c.cargo[NARCOTICS], 0); eq('...and the job is complete', c.missions.done['side-smuggle'], 'complete'); } + +console.log('\na save that names a ghost loads without it (docs/TODO/213 M4)'); +{ + // A live mission on a skeleton or a leg the code no longer ships threw on + // the next dock, and on the abandon that could have freed the slot. + const st: MissionState = { + ...emptyMissionState(), + live: [ + { skeleton: 'arc-ghost', leg: 'x', target: null, tag: null, progress: 0, deadlineDay: null }, + { skeleton: 'arc-lave', leg: 'old', target: null, tag: null, progress: 0, deadlineDay: null }, + { skeleton: 'arc-lave', leg: 'ledger', target: 12, tag: null, progress: 0, deadlineDay: null }, + ], + leads: [ + { skeleton: 'arc-ghost', galaxy: 1, world: 6, sinceDay: 0 }, + { skeleton: 'arc-rabedira', galaxy: 1, world: 6, sinceDay: 0 }, + ], + passengers: [{ tag: 'arc-ghost#1#x', mission: 'arc-ghost' }], + }; + const kept = repairMissionState(st); + eq('the two ghosts among the live missions are dropped', kept.live.map((l) => l.leg).join(), 'ledger'); + eq('...and the ghost lead', kept.leads.map((l) => l.skeleton).join(), 'arc-rabedira'); + eq('...and the ghost passenger', kept.passengers.length, 0); + seedWorld(1914); + const g = withoutSaving(() => new Game(() => headlessShell())).value; + dismissBriefing(g); + g.state.commander.missions = st; + const parsed = parseSnapshot(structuredClone(g.captureSnapshot())); + eq('the world loader drops them too', parsed.commander.missions.live.length, 1); + const stepped = stepMissions(parsed.commander.missions, { kind: 'docked' }, { + commander: { galaxy: 1, systemIndex: 7, kills: 0, combatScore: 0, legalStatus: 0, scoops: true, day: 0, cargo: [] }, + systems: generateGalaxy(1), rng: () => 0.5, + }); + check('...and the machine takes the record it leaves', stepped.state.live.length === 1); +} + +console.log('\na restored mission ship takes the role its leg flies it under (docs/TODO/213 M4)'); +{ + seedWorld(1915); + const g = withoutSaving(() => new Game(() => headlessShell())).value; + dismissBriefing(g); + const c = g.state.commander; + for (let world = 0; world < 256 && c.missions.live.length === 0; world++) { + c.systemIndex = world; + withoutSaving(() => runMissions(c, { kind: 'accept', skeleton: 'side-escort' }, g.state.systems, () => 0.5)); + } + const tag = c.missions.live[0].tag as string; + const python = shipDesignIdOf(SOURCE_DESIGN.python); + eq('the Python escort restores from the trader row', missionShipSpec(c, tag), specForDesign('trader', python)); + check('...which is not the pirate row', specForDesign('pirate', python) !== specForDesign('trader', python)); + eq('a tag no entity names restores nothing', missionShipSpec(c, 'nobody'), undefined); +} diff --git a/test/mission-pieces.test.ts b/test/mission-pieces.test.ts index c0099de1..d70d85c6 100644 --- a/test/mission-pieces.test.ts +++ b/test/mission-pieces.test.ts @@ -61,6 +61,31 @@ console.log('\na gate by jumps: an arc is offered inside withinJumps of its worl !canAccept(empty, 'near', { commander: facts({ systemIndex: one }), skeletons: [near, home] })); } +console.log('\na leg that cannot be placed starts at any station, and the branch still settles (docs/TODO/213 M4)'); +{ + // The branch used to return before the settlement, with the target + // already dead, so the kill paid nothing and the mission held its slot. + const stuck = arc('stuck', { + legs: [ + { + id: 'one', verb: { kind: 'deliver' }, place: { kind: 'here' }, line: 'ONE', + next: [{ on: 'success', to: 'two', settle: { pay: 100 } }, { on: 'failed', to: 'fail' }], + }, + { + id: 'two', verb: { kind: 'deliver' }, place: { kind: 'entity', tag: 'nothing-by-this-name' }, line: 'TWO', + next: [{ on: 'success', to: 'complete' }, { on: 'failed', to: 'fail' }], + }, + ], + }); + const ctx: MissionContext = { commander: facts(), systems: g1, rng: half, skeletons: [stuck] }; + const held = stepMissions(emptyMissionState(), { kind: 'accept', skeleton: 'stuck' }, ctx).state; + const r = stepMissions(held, { kind: 'docked' }, ctx); + eq('the mission moved to the leg that could not be placed', r.state.live[0]?.leg, 'two'); + eq('...at any station', r.state.live[0]?.target, null); + eq('...and the branch paid', r.effects.filter((e) => e.kind === 'pay').reduce((s, e) => s + (e as { tenths: number }).tenths, 0), 100); + eq('...and the journal has the step', r.state.journal.filter((j) => j.outcome === 'success').length, 1); +} + console.log('\na flag fires the branch that names it, once'); { // `giver` sets the flag when it completes. `waiter` holds a leg that diff --git a/test/mission-skeletons.test.ts b/test/mission-skeletons.test.ts index 92885413..555a4ba7 100644 --- a/test/mission-skeletons.test.ts +++ b/test/mission-skeletons.test.ts @@ -105,6 +105,10 @@ const faults: [string, Skeleton, readonly Skeleton[], string][] = [ // A seed slot is an index that every galaxy has (docs/TODO/213 M2). ['a world patron with no galaxy gate', arc({ offer: {} }), [b], 'galaxy gate'], + // A handover is measured from every world, as a band is (docs/TODO/213 M4). + ['a handover with no candidate from some world', + arc({ legs: [{ ...legs()[0], place: { kind: 'handover', toward: 'b', min: 30, max: 40 } }, legs()[1]] }), + [b], 'no candidate from'], ]; for (const [name, s, others, word] of faults) { const problems = lintSkeleton(s, [s, ...others], g1); diff --git a/test/mission-story.test.ts b/test/mission-story.test.ts index c6e783c2..21504014 100644 --- a/test/mission-story.test.ts +++ b/test/mission-story.test.ts @@ -19,6 +19,7 @@ import { headlessShell } from '../src/engine/shell.ts'; import { withoutSaving } from '../src/game/storage.ts'; import { seedWorld } from '../src/game/rng.ts'; import { newCommander } from '../src/game/commander.ts'; +import { generateGalaxy } from '../src/galaxy/galaxy.ts'; import { CHART_SPAN_X, CHART_SPAN_Y } from '../src/constants/chart-metric.ts'; import { captureById } from './screen-capture.ts'; import { constrictorAt, g1 } from './fixtures.ts'; @@ -147,3 +148,28 @@ console.log('\nthe LOG screen, painted and opened'); g.step(1 / 60, 1 + 1 / 60); eq('...and Escape closes it', g.screens.topId, null); } + +console.log('\nthe story names a world through the galaxy its entry was written in (docs/TODO/213 M4)'); +{ + // The log named every world through the galaxy she stood in, so a galactic + // jump renamed her whole past. A journal entry carries its galaxy now, and + // one from before it was written reads as galaxy 1. + const g2 = generateGalaxy(2); + const inOne: MissionState = { + ...emptyMissionState(), + journal: [ + { skeleton: SIDE_RESCUE.id, leg: 'pod', outcome: 'accepted', day: 3, world: LAVE, galaxy: 1 }, + { skeleton: SIDE_RESCUE.id, leg: 'pod', outcome: 'fail', day: 9, world: 12, galaxy: 1 }, + { skeleton: 'constrictor', leg: 'hunt', outcome: 'accepted', day: 21, world: LAVE }, + ], + }; + const none = (): null => null; + const readIn2 = storyPages(inOne, (g) => (g === 2 ? g2 : g1), undefined, none); + check('a galaxy-1 entry read in galaxy 2 still names the galaxy-1 world', + readIn2[0].lines[0].includes(g1[LAVE].name.toUpperCase()) && !readIn2[0].lines[0].includes(g2[LAVE].name.toUpperCase())); + eq('...and the page says which galaxy its worlds are in', readIn2[0].galaxy, 1); + check('an entry with no galaxy reads as galaxy 1', readIn2[1].lines[0].includes(g1[LAVE].name.toUpperCase())); + eq('...on a page in galaxy 1', readIn2[1].galaxy, 1); + eq('an array stands for galaxy 1, as every earlier caller meant', + storyPages(inOne, g1, undefined, none)[0].lines[1], readIn2[0].lines[1]); +} diff --git a/test/mission-verbs.test.ts b/test/mission-verbs.test.ts index 20237fb4..88fdec22 100644 --- a/test/mission-verbs.test.ts +++ b/test/mission-verbs.test.ts @@ -12,7 +12,7 @@ import { missionItems, missionSpawns, scanSecondsFor } from '../src/missions/que import { emptyMissionState } from '../src/missions/state.ts'; import type { CommanderFacts, MissionEffect, MissionState, Skeleton } from '../src/missions/model.ts'; import { - SIDE_ESCORT, SIDE_HUNT, SIDE_RECOVER, SIDE_RESCUE, SIDE_SCAN, SIDE_SMUGGLE, + SIDE_DELIVER, SIDE_ESCORT, SIDE_HUNT, SIDE_RECOVER, SIDE_RESCUE, SIDE_SCAN, SIDE_SMUGGLE, } from '../src/missions/skeletons/side.ts'; import { RESCUE_SALVAGE_PAY, SCAN_SECONDS, SIDE_JOB_PAY, SMUGGLE_TONNES, @@ -155,6 +155,20 @@ console.log('\nsmuggle: the goods go aboard, and the patrol is the risk'); eq('a police scan on the way fails it', read.state.done[SIDE_SMUGGLE.id], 'fail'); } +console.log('\na local patron\'s standing is keyed by the world the job was taken at (docs/TODO/213 M4)'); +{ + // A delivery accepted at one world and landed at another credited the far + // end's patron, because the key named the world where the branch settled. + const dctx = boardFor(SIDE_DELIVER); + const dst = accept(SIDE_DELIVER, dctx); + const origin = dctx.commander.systemIndex; + const target = dst.live[0].target as number; + check('the delivery goes to another world', target !== origin); + const done = stepMissions(dst, { kind: 'docked' }, moved(dctx, target)); + eq('the standing lands on the patron who gave the job', done.state.standing[`world-${origin}`], 1); + eq('...and none on the world it was delivered to', done.state.standing[`world-${target}`], undefined); +} + console.log('\nescort and scan, through the machine'); { const ctx = boardFor(SIDE_ESCORT); From db72eee80f603b0a6db5c74a7347f0d12eab982a Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Sun, 13 Sep 2026 09:45:53 +0100 Subject: [PATCH 066/100] docs/TODO/213 M5: the lint holds every trigger a verb can emit, and six comments say what the code does Three arcs carried a branch for a hunted ship that runs, and the world could not send it, because a pirate never leaves a system. One side job dropped the same trigger on the floor. No gate saw either. The verb registry now says what each verb can emit, and the lint refuses a leg that neither answers a trigger nor lists it under `ignores`. The side hunt says it ignores `targetFled`, and 214 makes the chase real. A hunt that cannot escape cannot run out either, so the Constrictor needs no such line. Six comments said what the code no longer does: the machine that spends the mission constants, the override conflict the lint does see, a hold check and an item table that never arrived, a world patron in one galaxy, and the idle-dock count. missions/model.ts crossed the size ceiling by one line. The shape of a patron and a dossier, which the machine never reads, left it for missions/words.ts. Both review probes ran again, and their output is committed beside the old: the escort finishes eight of eight, a side job comes back a week on, the goods leave the hold, and a galaxy-1 journal reads in galaxy 1. Co-Authored-By: Claude Fable 5.1 Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- docs/ARCHITECTURE.md | 2 +- ...hold-and-a-hit-trader-goes-back-to-work.md | 46 +++++++++++++ .../missions-2026-09-12/flight-probe.ts | 5 +- .../flight-results-after.txt | 41 ++++++++++++ .../missions-2026-09-12/results-after.txt | 60 +++++++++++++++++ src/constants/CATALOG.md | 46 ++++++------- src/constants/missions.ts | 7 +- src/game/screens/log.ts | 2 +- src/game/screens/missions.ts | 3 +- src/missions/dossiers.ts | 3 +- src/missions/dossiers/index.ts | 2 +- src/missions/hints.ts | 3 +- src/missions/lint.ts | 11 +++- src/missions/model.ts | 65 ++++--------------- src/missions/patrons.ts | 3 +- src/missions/queries.ts | 6 +- src/missions/skeletons/side.ts | 4 ++ src/missions/story.ts | 3 +- src/missions/tour-page.ts | 3 +- src/missions/verbs/deliver.ts | 5 +- src/missions/verbs/hunt.ts | 8 ++- src/missions/verbs/registry.ts | 25 ++++++- src/missions/words.ts | 59 +++++++++++++++++ test/dossiers.test.ts | 3 +- test/mission-skeletons.test.ts | 18 +++++ test/mission-story.test.ts | 3 +- test/mission-verbs.test.ts | 5 ++ test/tour-page.test.ts | 2 +- tools/dossier-faults.ts | 3 +- tools/dossier-prompts.ts | 5 +- tools/generate-dossiers.ts | 2 +- 31 files changed, 348 insertions(+), 105 deletions(-) create mode 100644 docs/reviews/missions-2026-09-12/flight-results-after.txt create mode 100644 docs/reviews/missions-2026-09-12/results-after.txt create mode 100644 src/missions/words.ts diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md index 833757ea..7ed22c95 100644 --- a/docs/ARCHITECTURE.md +++ b/docs/ARCHITECTURE.md @@ -242,7 +242,7 @@ Two quirks are deliberate: offers it lists. `src/game/hunt-warning.ts` prices her gun against the ship a hunt names, through the combat oracle. - `src/missions/` is the mission machine (docs/TODO/190). `model.ts` holds the - types. A skeleton under `skeletons/` is one mission's rules, written by a + types, and `words.ts` the shape of a patron and a dossier. A skeleton under `skeletons/` is one mission's rules, written by a developer. A dossier is its generated words, and the machine never reads one. `machine.ts` is one pure step. It takes the record, one input and the facts it may read. It returns a new record with the effects the game applies. diff --git a/docs/TODO/213-the-mission-rules-hold-and-a-hit-trader-goes-back-to-work.md b/docs/TODO/213-the-mission-rules-hold-and-a-hit-trader-goes-back-to-work.md index c5bddd46..9ba43fe6 100644 --- a/docs/TODO/213-the-mission-rules-hold-and-a-hit-trader-goes-back-to-work.md +++ b/docs/TODO/213-the-mission-rules-hold-and-a-hit-trader-goes-back-to-work.md @@ -245,3 +245,49 @@ Evidence, one per fault: - **A test fixture met the ghost rule.** The galaxy-change test saves a lead to a fixture skeleton, which the loader now drops. The saved lead names a shipped arc instead. + +### M5 + +- **A hunt that cannot escape cannot run out either.** The hunt verb sent + `targetFled` for any hunt. So the table of what a hunt can emit needed + the Constrictor to ignore a word it can never hear. The verb answers + neither `escaped` nor `fled` for a hunt with `canEscape` false. The + side hunt alone lists `ignores: ['targetFled']`. +- **The table lives in the verb registry**, `verbTriggers`, beside the + module table, so a ninth verb needs both entries. +- **The probes ran again.** `results-after.txt` shows a side job open a + week on, and the goods unloaded. It shows the standing on the origin, the + lead in its own galaxy, and a galaxy-1 journal named in galaxy 1. Block 6 still throws: + the probe hands the machine a ghost directly, and the machine still + refuses one. The loaders drop it before the machine sees it. + `flight-results-after.txt` shows the escort at eight of eight. Every + other row reads as before, because the flight itself did not change. +- **`missions/model.ts` crossed the size ceiling by one line.** The shape of + a patron and a dossier, which the machine never reads, left it for + `missions/words.ts`. Fourteen importers name the new home, and the + generated `dossiers/index.ts` names it through its generator. +- The suite has 6,029 checks. + +## Outcome + +213 landed on 2026-09-13. A hit trader goes back to work after twenty calm +seconds, the escort course closes gently, and a course refuses a target +below the planet. The escort finishes eight of eight in the flight probe, +from four. A side job comes back a week after it ends. A smuggling run +leaves its goods at the far end. Every arc is gated to galaxy 1, and a +lead keeps its galaxy. A scoop job waits for the scoops. The gun warning +speaks for the Constrictor alone. A side-job count no longer silences a +lead. The loaders drop a ghost. The journal names its galaxy, and standing +is keyed by the origin. A restored mission ship takes its leg's role, and +a branch that cannot place its next leg still settles. The lint holds a +galaxy gate, a handover from every world, and every trigger a verb can +emit. Six comments say what the code does. + +Two things the plan did not have. `constants/course.ts` crossed the size +ceiling, and the four numbers a mission's course spends left it for +`constants/mission-course.ts`. The lead announcement moved from M4 into +M2, because the relocation's removal made it wrong at once. + +Three decisions stand as the review recommended, and each is one line to +change. The tour is galaxy 1's. A side job repeats without limit. The first +arc waits for the scoops. The suite has 6,029 assertions, from 5,972. diff --git a/docs/reviews/missions-2026-09-12/flight-probe.ts b/docs/reviews/missions-2026-09-12/flight-probe.ts index 39a32f56..7f46acb0 100644 --- a/docs/reviews/missions-2026-09-12/flight-probe.ts +++ b/docs/reviews/missions-2026-09-12/flight-probe.ts @@ -220,8 +220,11 @@ for (const c of CASES) { console.log('\nwithout fuel scoops, the scoop rows refuse:'); { - const g = newGame(20_260_950, {}); + // The offer waits for the scoops since docs/TODO/213 M2, so the job is + // taken with them and flown without, as a sale of the scoops would leave it. + const g = newGame(20_260_950, { scoops: true }); onSideJob(g, 'side-recover'); + g.state.commander.equipment.scoops = false; arrive(g); const row = g.coursePanel()?.rows?.find((r) => r.kind === 'mission'); console.log(` side-recover row: "${row?.what}" why: "${row?.why}"`); diff --git a/docs/reviews/missions-2026-09-12/flight-results-after.txt b/docs/reviews/missions-2026-09-12/flight-results-after.txt new file mode 100644 index 00000000..f676bed2 --- /dev/null +++ b/docs/reviews/missions-2026-09-12/flight-results-after.txt @@ -0,0 +1,41 @@ +flight probe: 8 seeds per case, ordinary traffic in the sky + +side-hunt: a Krait, pulse laser + done 8 failed 0 dead 0 timeout 0 of 8 | time to done: mean 4 s, worst 5 s | fights per run 1.0 | kills 8 | wall 0 s + per seed: d5 d4 d4 d5 d4 d4 d5 d4 | ship after: energy 254, shields 255/255 | station 71,626 units from the witchpoint +arc-lave runner: a Cobra Mk III, pulse laser + done 8 failed 0 dead 0 timeout 0 of 8 | time to done: mean 4 s, worst 5 s | fights per run 1.0 | kills 8 | wall 0 s + per seed: d4 d5 d5 d5 d5 d4 d5 d4 | ship after: energy 254, shields 255/255 | station 63,792 units from the witchpoint +arc-xeer chase: a Fer-de-Lance, pulse laser + done 8 failed 0 dead 0 timeout 0 of 8 | time to done: mean 8 s, worst 9 s | fights per run 1.0 | kills 7 | wall 0 s + per seed: d6 d9 d8 d9 d9 d7 d9 d6 | ship after: energy 254, shields 162/255 | station 63,958 units from the witchpoint +arc-edle purge: an Asp, pulse laser + done 8 failed 0 dead 0 timeout 0 of 8 | time to done: mean 12 s, worst 13 s | fights per run 1.0 | kills 8 | wall 0 s + per seed: d11 d13 d11 d12 d13 d13 d11 d11 | ship after: energy 254, shields 105/255 | station 64,040 units from the witchpoint +constrictor hunt, pulse laser + done 8 failed 0 dead 0 timeout 0 of 8 | time to done: mean 62 s, worst 66 s | fights per run 1.0 | kills 8 | wall 0 s + per seed: d64 d63 d60 d59 d64 d61 d66 d57 | ship after: energy 213, shields 130/219 | station 64,405 units from the witchpoint +side-scan: an Anaconda for 20 s + done 8 failed 0 dead 0 timeout 0 of 8 | time to done: mean 24 s, worst 27 s | fights per run 0.1 | kills 1 | wall 0 s + per seed: d25 d23 d23 d23 d27 d22 d27 d21 | ship after: energy 255, shields 255/255 | station 69,173 units from the witchpoint +side-escort: a Python to station range + done 8 failed 0 dead 0 timeout 0 of 8 | time to done: mean 508 s, worst 525 s | fights per run 0.3 | kills 2 | wall 2 s + per seed: d516 d488 d525 d519 d490 d521 d511 d497 | ship after: energy 255, shields 249/255 | station 72,080 units from the witchpoint +side-recover: scoop a canister (scoops fitted) + done 8 failed 0 dead 0 timeout 0 of 8 | time to done: mean 14 s, worst 23 s | fights per run 0.3 | kills 2 | wall 0 s + per seed: d23 d14 d11 d11 d9 d13 d19 d12 | ship after: energy 255, shields 255/255 | station 62,707 units from the witchpoint +side-rescue: scoop a pod (scoops fitted) + done 8 failed 0 dead 0 timeout 0 of 8 | time to done: mean 13 s, worst 26 s | fights per run 0.1 | kills 1 | wall 0 s + per seed: d8 d18 d13 d10 d13 d6 d26 d8 | ship after: energy 255, shields 255/255 | station 81,801 units from the witchpoint +side-ambush: the lane, then dock (docking computer) + done 8 failed 0 dead 0 timeout 0 of 8 | time to done: mean 133 s, worst 150 s | fights per run 3.1 | kills 42 | wall 1 s + per seed: d122 d138 d131 d141 d143 d135 d106 d150 | ship after: energy 255, shields 255/255 | station 70,808 units from the witchpoint +side-deliver: fly to the station and dock (docking computer) + done 8 failed 0 dead 0 timeout 0 of 8 | time to done: mean 128 s, worst 144 s | fights per run 1.4 | kills 10 | wall 1 s + per seed: d106 d144 d141 d144 d113 d137 d144 d98 | ship after: energy 255, shields 255/255 | station 72,080 units from the witchpoint +side-smuggle: slip past the police and dock (docking computer) + done 8 failed 0 dead 0 timeout 0 of 8 | time to done: mean 116 s, worst 134 s | fights per run 2.6 | kills 27 | scanned 0 | wall 1 s + per seed: d117 d111 d98 d134 d123 d124 d104 d114 | ship after: energy 255, shields 255/255 | station 69,173 units from the witchpoint + +without fuel scoops, the scoop rows refuse: + side-recover row: "RECOVER THE CARGO" why: "NEEDS FUEL SCOOPS" diff --git a/docs/reviews/missions-2026-09-12/results-after.txt b/docs/reviews/missions-2026-09-12/results-after.txt new file mode 100644 index 00000000..a9a2e040 --- /dev/null +++ b/docs/reviews/missions-2026-09-12/results-after.txt @@ -0,0 +1,60 @@ +[1] an arc is offered in every galaxy at its seed index + canAccept arc-lave at galaxy 2 index 7: false + galaxy-2 world at index 7: Esrilees | patron: THE COMPANY DIRECTOR OF ESRILEES + offers there: side-deliver side-smuggle side-escort + lead after the jump: {"skeleton":"arc-rabedira","galaxy":1,"world":6,"sinceDay":0} | announced world: 6 + arc-rabedira accepted at the relocated lead: false + +[2] a side job with no cap is offered once per career + caps: side-hunt=undefined side-deliver=undefined side-recover=undefined side-rescue=undefined side-ambush=undefined side-smuggle=undefined side-escort=undefined side-scan=undefined + canAccept side-recover at its board on day 11: false + canAccept side-recover at its board on day 17: true + canAccept side-recover at its board on day 18: true + canAccept side-recover at its board on day 400: true + +[3] a smuggle run pays and leaves the goods aboard + effects on success: unload pay(7000) say deed say + +[4] what each ship verb makes of the four ways a target can go + side-hunt fled live=1 done=- entityAlive=true pay=- says=0 + side-hunt escaped live=0 done=fail entityAlive=undefined pay=- says=1 + side-hunt escortLost live=0 done=complete entityAlive=undefined pay=8000 says=1 + side-hunt destroyed live=0 done=complete entityAlive=undefined pay=8000 says=1 + side-scan fled live=0 done=fail entityAlive=undefined pay=- says=1 + side-scan escaped live=0 done=fail entityAlive=undefined pay=- says=1 + side-scan escortLost live=0 done=fail entityAlive=undefined pay=- says=1 + side-scan destroyed live=0 done=fail entityAlive=undefined pay=- says=1 + side-escort fled live=0 done=fail entityAlive=undefined pay=- says=1 + side-escort escaped live=0 done=fail entityAlive=undefined pay=- says=1 + side-escort escortLost live=0 done=fail entityAlive=undefined pay=- says=1 + side-escort destroyed live=0 done=fail entityAlive=undefined pay=- says=1 + +[5] the dock hint is shadowed by the side-job count + dock at Leleer, one jump from Rabedira: say:THERE ARE 2 SIDE JOBS ON THE STATION BOARD. | later:A MESSAGE FROM RABEDIRA: COME WHEN YOU CAN. THERE IS WORK. + the same dock with the side jobs removed: later:A MESSAGE FROM RABEDIRA: COME WHEN YOU CAN. THERE IS WORK. + fourth idle dock at Ontimaxe, three jumps out: say:THERE ARE 3 SIDE JOBS ON THE STATION BOARD. | later:A SECOND MESSAGE FROM RABEDIRA: THE OFFER STANDS. + +[6] a saved record that names a ghost skeleton or leg + ghost skeleton, docked: THROWS "mission arc-ghost: no such skeleton" + ghost skeleton, abandon: THROWS "mission arc-ghost: no such skeleton" + ghost leg, docked: THROWS "mission arc-lave: no leg old" + +[7] the journal holds no galaxy, so the log misnames a world after a jump + the acceptance line, rendered with galaxy 1: On day 0 the commander took the governor's contract at LAVE, to chase down a stolen ledger. + the same line, rendered with galaxy 2: On day 0 the commander took the governor's contract at ESRILEES, to chase down a stolen ledger. + +[8] a local patron's standing is keyed by where the branch settles + accepted at Tiraor (5), delivered at Edzaon (159), standing: {"world-5":1} + +[9] the pirate row a restored mission ship is looked up under + python pirate row: true trader row: true + cobraMk3 pirate row: true trader row: true + anaconda pirate row: false trader row: true + boa pirate row: false trader row: true + transporter pirate row: false trader row: true + +[10] handover placement has a candidate from every world of galaxy 1 + toward Rabedira worlds with no candidate: 0 + toward Vetitice worlds with no candidate: 0 + toward Xeer worlds with no candidate: 0 + toward Edle worlds with no candidate: 0 diff --git a/src/constants/CATALOG.md b/src/constants/CATALOG.md index 103b98c2..09e07a1e 100644 --- a/src/constants/CATALOG.md +++ b/src/constants/CATALOG.md @@ -251,29 +251,29 @@ search names, meanings and values with `npm run constants:find -- ""`. | mission-course | COURSE_ESCORT_STANDOFF | 600 | How far from its charge the escort course flies, in world units (docs/TODO/208 M2). | course.escortStandoff | [mission-course.ts:36](./mission-course.ts#L36) | | mission-course | COURSE_ESCORT_CLOSING | 60 | How much faster than its charge the escort course may close, in world units a second, once it is inside three standoffs of it: sixty. | course.escortClosing | [mission-course.ts:51](./mission-course.ts#L51) | | mission-course | COURSE_POLICE_CLEARANCE | SCAN_WARN_RANGE | How wide of a police ship the smuggling course flies, in world units (docs/TODO/208 M4). | | [mission-course.ts:64](./mission-course.ts#L64) | -| missions | MISSION_KILL_THRESHOLD | 16 | Kills before the Navy considers you worth a word: 16, as the original demanded. | missions.killThreshold | [missions.ts:14](./missions.ts#L14) | -| missions | MISSION_HUNT_RANGE | { min: 30, max: 80 } as const | The Constrictor hides this far from where you are briefed, in tenths of a light year. | | [missions.ts:22](./missions.ts#L22) | -| missions | MISSION_COURIER_RANGE | { min: 50, max: 90 } as const | The courier run is longer: the plans matter more than your convenience. | | [missions.ts:25](./missions.ts#L25) | -| missions | CONSTRICTOR_BOUNTY | 25_000 | What a kill of the Constrictor pays — 2,500 Cr, in tenths of a credit. | | [missions.ts:28](./missions.ts#L28) | -| missions | COURIER_PAYMENT | 15_000 | ...and what a delivery of the plans pays: 1,500 Cr. | | [missions.ts:31](./missions.ts#L31) | -| missions | MISSION_LIVE_CAP | 3 | How many missions a commander can hold open at one time: three. | missions.liveCap | [missions.ts:47](./missions.ts#L47) | -| missions | MISSION_REOFFER_DAYS | 7 | Days before a finished side job is offered again: a week. | missions.reofferDays | [missions.ts:63](./missions.ts#L63) | -| missions | LEAD_RUMOUR_JUMPS | 5 | Inside this many jumps of a lead's world, the station talks about it. | missions.leadRumourJumps | [missions.ts:76](./missions.ts#L76) | -| missions | LEAD_NAG_DOCKS | 4 | Docks with no mission progress before a patron with a lead writes a second time. | missions.leadNagDocks | [missions.ts:88](./missions.ts#L88) | -| missions | SIDE_JOB_PAY | { hunt: 8_000, deliver: 3_000, recover: 4_000, rescue: 5_000, ambush: 6_000, smuggle: 7_000, escort: 6_000, scan: 2_500, } as const | What a side job pays, per verb, in tenths of a credit. | missions.sideJobPay | [missions.ts:102](./missions.ts#L102) | -| missions | RESCUE_SALVAGE_PAY | 1_500 | The lower fee a rescue pays when the pod is lost and the data still arrives, in tenths of a credit. | missions.rescueSalvagePay | [missions.ts:118](./missions.ts#L118) | -| missions | SIDE_JOB_RANGE | { min: 20, max: 70 } as const | How far a side job sends the commander, in tenths of a light year: two to seven. | missions.sideJobRange | [missions.ts:126](./missions.ts#L126) | -| missions | SIDE_JOB_DAYS | 14 | Days a side job allows before its deadline passes: two weeks. | missions.sideJobDays | [missions.ts:133](./missions.ts#L133) | -| missions | DEADLINE_WARNING_DAYS | 3 | How many days before a deadline the console starts to say how many are left. | missions.deadlineWarningDays | [missions.ts:144](./missions.ts#L144) | -| missions | SCAN_SECONDS | 20 | Seconds a scan target must stay under the scanner lock: twenty, which is a pass and a turn at a trader's speed. | missions.scanSeconds | [missions.ts:152](./missions.ts#L152) | -| missions | WATCH_CONE | 0.35 | How far off the centre of the view a scan's subject may sit and still count as watched, in radians: 0.35, which is twenty degrees. | missions.watchCone | [missions.ts:166](./missions.ts#L166) | -| missions | SMUGGLE_TONNES | 3 | Tonnes of the patron's goods on a smuggle job: three, which fits a Cobra's hold beside its own stock. | missions.smuggleTonnes | [missions.ts:178](./missions.ts#L178) | -| missions | ESCORT_ENEMY_ROLES | ['pirate', 'hunter', 'thargoid', 'thargon'] | The roles that count as an enemy near an escorted ship: the ones that prey. | | [missions.ts:187](./missions.ts#L187) | -| missions | TOUR_ARCS | 5 | How many arcs the tour holds: five, Chris's number (docs/TODO/190, item 192). | missions.tourArcs | [missions.ts:197](./missions.ts#L197) | -| missions | TOUR_STEP_JUMPS | { min: 4, max: 6 } as const | How far each arc's start world is from the one before it, in JUMPS on the full-tank graph: four to six. | missions.tourStepJumps | [missions.ts:210](./missions.ts#L210) | -| missions | ARC_HANDOVER_JUMPS | { min: 2, max: 4 } as const | How far an arc's final leg lies from the next arc's start world, in JUMPS: two to four. | missions.arcHandoverJumps | [missions.ts:219](./missions.ts#L219) | -| missions | ARC_PAY | { hunt: 12_000, deliver: 5_000, recover: 6_000, rescue: 8_000, ambush: 9_000, smuggle: 10_000, escort: 9_000, scan: 4_000, } as const | What an arc leg pays, per verb, in tenths of a credit. | missions.arcPay | [missions.ts:232](./missions.ts#L232) | -| missions | ARC_LEG_DAYS | 30 | Days an arc leg allows before its deadline passes: a month, twice a side job's fortnight, because an arc leg may be four jumps out. | missions.arcLegDays | [missions.ts:245](./missions.ts#L245) | +| missions | MISSION_KILL_THRESHOLD | 16 | Kills before the Navy considers you worth a word: 16, as the original demanded. | missions.killThreshold | [missions.ts:15](./missions.ts#L15) | +| missions | MISSION_HUNT_RANGE | { min: 30, max: 80 } as const | The Constrictor hides this far from where you are briefed, in tenths of a light year. | | [missions.ts:23](./missions.ts#L23) | +| missions | MISSION_COURIER_RANGE | { min: 50, max: 90 } as const | The courier run is longer: the plans matter more than your convenience. | | [missions.ts:26](./missions.ts#L26) | +| missions | CONSTRICTOR_BOUNTY | 25_000 | What a kill of the Constrictor pays — 2,500 Cr, in tenths of a credit. | | [missions.ts:29](./missions.ts#L29) | +| missions | COURIER_PAYMENT | 15_000 | ...and what a delivery of the plans pays: 1,500 Cr. | | [missions.ts:32](./missions.ts#L32) | +| missions | MISSION_LIVE_CAP | 3 | How many missions a commander can hold open at one time: three. | missions.liveCap | [missions.ts:48](./missions.ts#L48) | +| missions | MISSION_REOFFER_DAYS | 7 | Days before a finished side job is offered again: a week. | missions.reofferDays | [missions.ts:64](./missions.ts#L64) | +| missions | LEAD_RUMOUR_JUMPS | 5 | Inside this many jumps of a lead's world, the station talks about it. | missions.leadRumourJumps | [missions.ts:77](./missions.ts#L77) | +| missions | LEAD_NAG_DOCKS | 4 | Docks with no mission progress before a patron with a lead writes a second time. | missions.leadNagDocks | [missions.ts:89](./missions.ts#L89) | +| missions | SIDE_JOB_PAY | { hunt: 8_000, deliver: 3_000, recover: 4_000, rescue: 5_000, ambush: 6_000, smuggle: 7_000, escort: 6_000, scan: 2_500, } as const | What a side job pays, per verb, in tenths of a credit. | missions.sideJobPay | [missions.ts:103](./missions.ts#L103) | +| missions | RESCUE_SALVAGE_PAY | 1_500 | The lower fee a rescue pays when the pod is lost and the data still arrives, in tenths of a credit. | missions.rescueSalvagePay | [missions.ts:119](./missions.ts#L119) | +| missions | SIDE_JOB_RANGE | { min: 20, max: 70 } as const | How far a side job sends the commander, in tenths of a light year: two to seven. | missions.sideJobRange | [missions.ts:127](./missions.ts#L127) | +| missions | SIDE_JOB_DAYS | 14 | Days a side job allows before its deadline passes: two weeks. | missions.sideJobDays | [missions.ts:134](./missions.ts#L134) | +| missions | DEADLINE_WARNING_DAYS | 3 | How many days before a deadline the console starts to say how many are left. | missions.deadlineWarningDays | [missions.ts:145](./missions.ts#L145) | +| missions | SCAN_SECONDS | 20 | Seconds a scan target must stay under the scanner lock: twenty, which is a pass and a turn at a trader's speed. | missions.scanSeconds | [missions.ts:153](./missions.ts#L153) | +| missions | WATCH_CONE | 0.35 | How far off the centre of the view a scan's subject may sit and still count as watched, in radians: 0.35, which is twenty degrees. | missions.watchCone | [missions.ts:167](./missions.ts#L167) | +| missions | SMUGGLE_TONNES | 3 | Tonnes of the patron's goods on a smuggle job: three, which fits a Cobra's hold beside its own stock. | missions.smuggleTonnes | [missions.ts:179](./missions.ts#L179) | +| missions | ESCORT_ENEMY_ROLES | ['pirate', 'hunter', 'thargoid', 'thargon'] | The roles that count as an enemy near an escorted ship: the ones that prey. | | [missions.ts:188](./missions.ts#L188) | +| missions | TOUR_ARCS | 5 | How many arcs the tour holds: five, Chris's number (docs/TODO/190, item 192). | missions.tourArcs | [missions.ts:198](./missions.ts#L198) | +| missions | TOUR_STEP_JUMPS | { min: 4, max: 6 } as const | How far each arc's start world is from the one before it, in JUMPS on the full-tank graph: four to six. | missions.tourStepJumps | [missions.ts:211](./missions.ts#L211) | +| missions | ARC_HANDOVER_JUMPS | { min: 2, max: 4 } as const | How far an arc's final leg lies from the next arc's start world, in JUMPS: two to four. | missions.arcHandoverJumps | [missions.ts:220](./missions.ts#L220) | +| missions | ARC_PAY | { hunt: 12_000, deliver: 5_000, recover: 6_000, rescue: 8_000, ambush: 9_000, smuggle: 10_000, escort: 9_000, scan: 4_000, } as const | What an arc leg pays, per verb, in tenths of a credit. | missions.arcPay | [missions.ts:233](./missions.ts#L233) | +| missions | ARC_LEG_DAYS | 30 | Days an arc leg allows before its deadline passes: a month, twice a side job's fortnight, because an arc leg may be four jumps out. | missions.arcLegDays | [missions.ts:246](./missions.ts#L246) | | npc-gun | NPC_LASER_RANGE | LASER_RANGE | How far an NPC can shoot: the player's reach. | | [npc-gun.ts:17](./npc-gun.ts#L17) | | npc-gun | NPC_COOLDOWN_LO | 0.9 | Time between an NPC's shots. | | [npc-gun.ts:31](./npc-gun.ts#L31) | | npc-gun | NPC_COOLDOWN_SPREAD | 0.8 | | | [npc-gun.ts:32](./npc-gun.ts#L32) | diff --git a/src/constants/missions.ts b/src/constants/missions.ts index c9bdad7f..02f86f5d 100644 --- a/src/constants/missions.ts +++ b/src/constants/missions.ts @@ -1,9 +1,10 @@ // The Navy mission, as numbers: what earns the briefing, how far away each leg // is laid, and what the Navy pays. // -// The five-stage machine that spends these is game/missions.ts. Money is in -// tenths of a credit (invariant 8), and distances are in tenths of a light year, -// as everywhere else. +// The skeletons under src/missions/skeletons/ spend these, and the machine +// in src/missions/machine.ts runs them (docs/TODO/190). Money is in tenths +// of a credit (invariant 8), and distances are in tenths of a light year, as +// everywhere else. /** * Kills before the Navy considers you worth a word: 16, as the original demanded. diff --git a/src/game/screens/log.ts b/src/game/screens/log.ts index 3cdcd7a6..0a27d2b5 100644 --- a/src/game/screens/log.ts +++ b/src/game/screens/log.ts @@ -9,7 +9,7 @@ import { renderLog } from '../../ui/screens-log.ts'; import type { CommanderData } from '../commander.ts'; import type { StarSystem } from '../../galaxy/galaxy.ts'; import type { Input } from '../../engine/input.ts'; -import type { Patron } from '../../missions/model.ts'; +import type { Patron } from '../../missions/words.ts'; import { NAVY_PATRON, patronFor } from '../../missions/patrons.ts'; import { storyPages, type StoryPage } from '../../missions/story.ts'; import { routeMapSvg } from '../../missions/route-map.ts'; diff --git a/src/game/screens/missions.ts b/src/game/screens/missions.ts index 60c975d9..60b4561e 100644 --- a/src/game/screens/missions.ts +++ b/src/game/screens/missions.ts @@ -20,7 +20,8 @@ import { renderMissions, type HeldRow, type OfferRow } from '../../ui/screens.ts import type { Screen, ScreenOutcome } from '../../ui/screen-host.ts'; import type { CommanderData } from '../commander.ts'; import { standingOrders, type MissionOrder } from '../orders.ts'; -import type { Dossier, Skeleton } from '../../missions/model.ts'; +import type { Skeleton } from '../../missions/model.ts'; +import type { Dossier } from '../../missions/words.ts'; import { dossierFor } from '../../missions/dossiers.ts'; import { leadLine } from '../../missions/hints.ts'; import { patronFor } from '../../missions/patrons.ts'; diff --git a/src/missions/dossiers.ts b/src/missions/dossiers.ts index 94e47670..efb94614 100644 --- a/src/missions/dossiers.ts +++ b/src/missions/dossiers.ts @@ -9,7 +9,8 @@ import type { StarSystem } from '../galaxy/galaxy.ts'; import { DOSSIER_FILES } from './dossiers/index.ts'; -import type { CommanderFacts, Dossier, DossierWord } from './model.ts'; +import type { CommanderFacts, DossierWord } from './model.ts'; +import type { Dossier } from './words.ts'; import { patronFor } from './patrons.ts'; import { skeletonById } from './skeletons/index.ts'; import { fillSlots } from './text.ts'; diff --git a/src/missions/dossiers/index.ts b/src/missions/dossiers/index.ts index 6a4518a6..529fd45f 100644 --- a/src/missions/dossiers/index.ts +++ b/src/missions/dossiers/index.ts @@ -4,7 +4,7 @@ // own to fall out of step with this directory. `--check` fails when a file // here is missing from this list. -import type { DossierFile } from '../model.ts'; +import type { DossierFile } from '../words.ts'; import d_arc_edle from './arc-edle.json' with { type: 'json' }; import d_arc_lave from './arc-lave.json' with { type: 'json' }; import d_arc_rabedira from './arc-rabedira.json' with { type: 'json' }; diff --git a/src/missions/hints.ts b/src/missions/hints.ts index dffcee05..6f8e29a2 100644 --- a/src/missions/hints.ts +++ b/src/missions/hints.ts @@ -25,7 +25,8 @@ import { LEAD_NAG_DOCKS, LEAD_RUMOUR_JUMPS } from '../constants/missions.ts'; import type { StarSystem } from '../galaxy/galaxy.ts'; import { routeEstimate } from '../galaxy/route.ts'; import { dossierFor, hintSlots } from './dossiers.ts'; -import type { CommanderFacts, Dossier, DossierWord, Lead, MissionState } from './model.ts'; +import type { CommanderFacts, DossierWord, Lead, MissionState } from './model.ts'; +import type { Dossier } from './words.ts'; import { fillSlots } from './text.ts'; type Dossiers = (id: string) => Dossier | null; diff --git a/src/missions/lint.ts b/src/missions/lint.ts index 862e65f5..7e648c66 100644 --- a/src/missions/lint.ts +++ b/src/missions/lint.ts @@ -16,6 +16,9 @@ // // docs/TODO/213 M2 adds one. A world patron's skeleton names the galaxy it // is offered in, because a seed slot is an index that every galaxy has. +// +// docs/TODO/213 M5 adds one more. Every trigger a verb can emit has a +// branch on the leg, or the leg lists it under `ignores`. import { ARC_HANDOVER_JUMPS } from '../constants/missions.ts'; import type { StarSystem } from '../galaxy/galaxy.ts'; @@ -23,7 +26,8 @@ import { distanceTenths } from '../galaxy/navigation.ts'; import { routeTable } from '../galaxy/route.ts'; import type { Leg, Skeleton } from './model.ts'; import { specForDesign } from '../game/ship-specs.ts'; -import { verbJob, verbModule, verbNeedsShip } from './verbs/registry.ts'; +import { verbJob, verbModule, verbNeedsShip, verbTriggers } from './verbs/registry.ts'; +import { sameTrigger, triggerLabel } from './triggers.ts'; import { pickByJumps } from './placement.ts'; export function lintSkeleton( @@ -45,6 +49,11 @@ export function lintSkeleton( if (!specForDesign(role, leg.verb.ship)) out.push(`${at}: no ${role} row for ${leg.verb.ship}`); } if (!leg.next.some((b) => b.on === 'failed')) out.push(`${at}: no failed branch`); + for (const t of verbModule(leg.verb.kind) ? verbTriggers(leg.verb) : []) { + const answered = leg.next.some((b) => sameTrigger(b.on, t)) + || (leg.ignores ?? []).some((i) => sameTrigger(i, t)); + if (!answered) out.push(`${at}: no branch for ${triggerLabel(t)}, and it is not ignored`); + } for (const b of leg.next) { if (b.to !== 'complete' && b.to !== 'fail' && !ids.has(b.to)) { out.push(`${at}: branch to unknown leg ${b.to}`); diff --git a/src/missions/model.ts b/src/missions/model.ts index bbbf574f..737aa9a0 100644 --- a/src/missions/model.ts +++ b/src/missions/model.ts @@ -14,7 +14,8 @@ // // Nothing here runs. The types are the contract between four places. Those // are the skeletons under `skeletons/`, the verb modules, the machine, and the -// game code that sends inputs and applies effects. +// game code that sends inputs and applies effects. The shape of the words a +// model writes, a patron and a dossier, is `words.ts` (docs/TODO/213 M5). import type { BlueprintOverride } from '../game/blueprint-set.ts'; import type { ShipDesignId } from '../game/ship-identity.ts'; @@ -22,7 +23,7 @@ import type { ShipDesignId } from '../game/ship-identity.ts'; /** A mission ship names a catalogue design (`ship-identity.ts`). */ export type ShipId = ShipDesignId; -/** An item a recovery leg wants. The item table arrives with docs/TODO/190 M4. */ +/** An item a recovery leg wants, as a free name. No table of items exists. */ export type ItemId = string; /** @@ -169,6 +170,13 @@ export interface Leg { spawn?: TaggedShip[]; /** true raises the mis-jump chance, as the 1984 courier run did */ carryingPlans?: boolean; + /** + * Triggers the verb can emit that this leg answers with nothing, on + * purpose. The lint refuses a leg that drops a trigger without saying so + * (docs/TODO/213 M5). A side hunt ignores `targetFled`, because a pirate + * cannot leave a system today, and 214 revisits that. + */ + ignores?: Trigger[]; /** the first branch whose trigger matches is the one taken */ next: Branch[]; } @@ -212,57 +220,6 @@ export interface Skeleton { cap?: number; } -export interface Patron { - id: string; - world: number | 'navy'; - name: string; - role: string; - species: string; - voice: string; - /** image path; '' uses the world's portrait */ - portrait: string; -} - -/** - * A mission's generated words. Each field may carry the slots its comment - * names and no other, and `tools/dossier-faults.ts` holds that (docs/TODO/191). - */ -export interface Dossier { - skeleton: string; - /** the prompt hash it was written from, which covers the skeleton's shape */ - hash: string; - /** a name for the mission, with no slot */ - title: string; - /** pages the patron speaks, with {PATRON} {HERE} */ - briefing: string[]; - /** by leg: the console's word on the leg, with {TARGET} {PAY} */ - legs: Record; - /** the LEADS row, with {PATRON} {WORLD} */ - lead: string; - /** the board's rumour inside the rumour range, and the message one jump out, with {PATRON} {WORLD} */ - rumour: { far: string; near: string }; - /** the DATA ON line, with {PATRON} {WORLD} */ - news: string; - /** paths under `public/`; an absent file degrades to no image */ - images: { target?: string; place?: string }; - story: { - /** with {WORLD} {DAY} */ - opening: string; - closing: { complete: string; fail: string }; - /** by leg, then by trigger label (`triggerLabel`, machine.ts), with {WORLD} {DAY} */ - legs: Record>; - }; -} - -/** One committed dossier file, with what the run that wrote it cost. */ -export interface DossierFile { - promptVersion: number; - model: string; - generated: string; - usage: { requests: number; inputTokens: number; outputTokens: number }; - dossier: Dossier; -} - export interface LiveMission { skeleton: string; leg: string; @@ -334,7 +291,7 @@ export interface MissionState { entities: Record; passengers: MissionPassenger[]; journal: JournalEntry[]; - /** docks since the journal last moved; the second patron message reads it */ + /** docks since a dock last moved the journal; the second patron message reads it */ idleDocks: number; /** what settlements changed about the worlds, each until a day */ changes: WorldChangeRecord[]; diff --git a/src/missions/patrons.ts b/src/missions/patrons.ts index 158bf600..85847e3d 100644 --- a/src/missions/patrons.ts +++ b/src/missions/patrons.ts @@ -17,7 +17,8 @@ import { speciesName, type StarSystem } from '../galaxy/galaxy.ts'; import { portraitUrl } from '../ui/portrait.ts'; -import type { CommanderFacts, Patron, PatronRef } from './model.ts'; +import type { CommanderFacts, PatronRef } from './model.ts'; +import type { Patron } from './words.ts'; import galaxy1 from './patrons/galaxy-1.json' with { type: 'json' }; /** One committed patron. `system` is checked against the live galaxy, not trusted. */ diff --git a/src/missions/queries.ts b/src/missions/queries.ts index f4fe48bd..06dbf3ea 100644 --- a/src/missions/queries.ts +++ b/src/missions/queries.ts @@ -32,9 +32,9 @@ export function liveLegs( /** * The override a live leg puts in force at `here`, or null. * - * The first live mission that names one wins. Two live legs with two - * overrides at one world is a conflict the skeleton lint does not see yet. - * The arc plan, item 192 of docs/TODO/190, decides it when a second arc exists. + * The first live mission that names one wins. Two legs of two skeletons + * that force two sets at one world are a conflict, and `lint.ts` refuses + * the pair before it ships (docs/TODO/192). */ export function missionOverride( st: MissionState, here: number, from: readonly Skeleton[] = SKELETONS, diff --git a/src/missions/skeletons/side.ts b/src/missions/skeletons/side.ts index 6ee102ba..b66b6a30 100644 --- a/src/missions/skeletons/side.ts +++ b/src/missions/skeletons/side.ts @@ -32,6 +32,10 @@ export const SIDE_HUNT: Skeleton = { legs: [{ id: 'hunt', verb: { kind: 'hunt', ship: shipDesignIdOf(SOURCE_DESIGN.krait), canEscape: true }, place: AWAY, line: 'BOUNTY: DESTROY THE KRAIT — LAST SEEN AT {TARGET}', deadlineDays: SIDE_JOB_DAYS, + // A pirate cannot leave a system today, so a Krait that runs is a Krait + // that comes back on the next arrival. A branch would change the dossier + // hash, and 214 M4 makes the chase real (docs/TODO/213 M5). + ignores: ['targetFled'], next: [ { on: 'targetDestroyed', to: 'complete', settle: { pay: SIDE_JOB_PAY.hunt, say: 'THE KRAIT IS DESTROYED. THE STATION PAYS {PAY}.' } }, { on: 'targetEscaped', to: 'fail' }, diff --git a/src/missions/story.ts b/src/missions/story.ts index 9d201ed8..70519aab 100644 --- a/src/missions/story.ts +++ b/src/missions/story.ts @@ -12,7 +12,8 @@ import type { StarSystem } from '../galaxy/galaxy.ts'; import { galaxySystems } from '../galaxy/galaxies.ts'; import { dossierFor } from './dossiers.ts'; -import type { Dossier, JournalEntry, MissionState } from './model.ts'; +import type { JournalEntry, MissionState } from './model.ts'; +import type { Dossier } from './words.ts'; import { SKELETONS, skeletonById } from './skeletons/index.ts'; import { fillSlots } from './text.ts'; diff --git a/src/missions/tour-page.ts b/src/missions/tour-page.ts index e2d47940..8647f863 100644 --- a/src/missions/tour-page.ts +++ b/src/missions/tour-page.ts @@ -20,7 +20,8 @@ import type { StarSystem } from '../galaxy/galaxy.ts'; import { routeTable } from '../galaxy/route.ts'; import { dossierFor } from './dossiers.ts'; -import type { CommanderFacts, Dossier, Patron, Skeleton, Verb } from './model.ts'; +import type { CommanderFacts, Skeleton, Verb } from './model.ts'; +import type { Dossier, Patron } from './words.ts'; import { patronFor } from './patrons.ts'; import { routeMapSvg } from './route-map.ts'; import { ARC_TOUR, SKELETONS, skeletonById } from './skeletons/index.ts'; diff --git a/src/missions/verbs/deliver.ts b/src/missions/verbs/deliver.ts index 049248d3..ec4c2823 100644 --- a/src/missions/verbs/deliver.ts +++ b/src/missions/verbs/deliver.ts @@ -1,8 +1,9 @@ // Deliver: dock at the leg's world. A null target means any station. // // The Constrictor's report leg and its courier leg are both this verb. The -// first has no target, and the second has one. A cargo delivery checks the -// hold too, and that arrives with docs/TODO/190 M4. +// first has no target, and the second has one. The verb carries a `cargo` +// field for a delivery that checks the hold. No shipped leg sets it, and +// this module reads none (docs/TODO/213 M5). import type { VerbModule } from './verb.ts'; diff --git a/src/missions/verbs/hunt.ts b/src/missions/verbs/hunt.ts index a4097280..03f5f490 100644 --- a/src/missions/verbs/hunt.ts +++ b/src/missions/verbs/hunt.ts @@ -11,6 +11,11 @@ // ship is gone either way, so the hunt takes it as destroyed. A branch that // paid less for another's kill would be a third outcome, and no skeleton // has one. +// +// A SHIP THAT CANNOT ESCAPE CANNOT RUN OUT EITHER (docs/TODO/213 M5). The +// Constrictor is always where the Navy says. `fled` reached this module +// for any hunt. So the lint's table of what a hunt can emit needed the +// Constrictor to ignore a word it can never hear. import type { VerbModule } from './verb.ts'; @@ -21,7 +26,8 @@ export const hunt: VerbModule = (ctx, input) => { if (input.kind === 'destroyed' || input.kind === 'escortLost') { return { trigger: 'targetDestroyed' }; } - if (input.kind === 'escaped' && verb.canEscape) return { trigger: 'targetEscaped' }; + if (!verb.canEscape) return null; + if (input.kind === 'escaped') return { trigger: 'targetEscaped' }; if (input.kind === 'fled') return { trigger: 'targetFled' }; return null; }; diff --git a/src/missions/verbs/registry.ts b/src/missions/verbs/registry.ts index 6cecefa0..b8c8ed29 100644 --- a/src/missions/verbs/registry.ts +++ b/src/missions/verbs/registry.ts @@ -4,8 +4,14 @@ // `test/mission-skeletons.test.ts` fails on a skeleton that names one. All // eight are here since docs/TODO/190 M4. The table stays partial in type, so // a ninth verb added to the model is a lint failure until its module lands. +// +// `verbTriggers` says what each module can emit, and the lint holds every +// leg to it. A trigger a verb can emit has a branch, or the leg lists it +// under `ignores` (docs/TODO/213 M5). Three arcs carried a branch the world +// could not reach, and one side job dropped a trigger on the floor, and no +// gate saw either. -import type { TaggedShip, Verb } from '../model.ts'; +import type { TaggedShip, Trigger, Verb } from '../model.ts'; import { ambush } from './ambush.ts'; import { deliver } from './deliver.ts'; import { escort } from './escort.ts'; @@ -44,6 +50,23 @@ export function jobRole(job: TaggedShip['job']): 'pirate' | 'trader' { return job === 'hunt' ? 'pirate' : 'trader'; } +/** + * Every trigger a verb's module can emit for a leg with this verb. The + * machine adds `failed` and `deadlinePassed` of its own, and failure rule 1 + * already holds the `failed` branch. + */ +export function verbTriggers(verb: Verb): Trigger[] { + switch (verb.kind) { + case 'hunt': return verb.canEscape + ? ['targetDestroyed', 'targetEscaped', 'targetFled'] : ['targetDestroyed']; + case 'deliver': case 'ambush': return ['success']; + case 'recover': return ['success', 'targetDestroyed']; + case 'rescue': return [{ survivor: 'landed' }, { survivor: 'sold' }, 'targetDestroyed']; + case 'smuggle': return ['success', 'failed']; + case 'escort': case 'scan': return ['success', 'targetDestroyed', 'targetEscaped']; + } +} + /** The item a recover or a rescue leg puts adrift, or null. */ export function verbItem(verb: Verb): 'cargo' | 'capsule' | null { return verb.kind === 'recover' ? 'cargo' : verb.kind === 'rescue' ? 'capsule' : null; diff --git a/src/missions/words.ts b/src/missions/words.ts new file mode 100644 index 00000000..217a4d00 --- /dev/null +++ b/src/missions/words.ts @@ -0,0 +1,59 @@ +// The words a model writes: a patron, and a mission's dossier. +// +// A PATRON is the person who offers a mission, by name, role and voice +// (`patrons.ts`). A DOSSIER is one mission's generated words, written +// offline and committed as JSON (`dossiers.ts`, docs/TODO/191). The machine +// never reads either, so generated text can never change what a mission +// does (docs/TODO/190). These shapes left `model.ts` when docs/TODO/213 M5 +// pushed it over the size ceiling. The rules stay there. + +export interface Patron { + id: string; + world: number | 'navy'; + name: string; + role: string; + species: string; + voice: string; + /** image path; '' uses the world's portrait */ + portrait: string; +} + +/** + * A mission's generated words. Each field may carry the slots its comment + * names and no other, and `tools/dossier-faults.ts` holds that (docs/TODO/191). + */ +export interface Dossier { + skeleton: string; + /** the prompt hash it was written from, which covers the skeleton's shape */ + hash: string; + /** a name for the mission, with no slot */ + title: string; + /** pages the patron speaks, with {PATRON} {HERE} */ + briefing: string[]; + /** by leg: the console's word on the leg, with {TARGET} {PAY} */ + legs: Record; + /** the LEADS row, with {PATRON} {WORLD} */ + lead: string; + /** the board's rumour inside the rumour range, and the message one jump out, with {PATRON} {WORLD} */ + rumour: { far: string; near: string }; + /** the DATA ON line, with {PATRON} {WORLD} */ + news: string; + /** paths under `public/`; an absent file degrades to no image */ + images: { target?: string; place?: string }; + story: { + /** with {WORLD} {DAY} */ + opening: string; + closing: { complete: string; fail: string }; + /** by leg, then by trigger label (`triggerLabel`, machine.ts), with {WORLD} {DAY} */ + legs: Record>; + }; +} + +/** One committed dossier file, with what the run that wrote it cost. */ +export interface DossierFile { + promptVersion: number; + model: string; + generated: string; + usage: { requests: number; inputTokens: number; outputTokens: number }; + dossier: Dossier; +} diff --git a/test/dossiers.test.ts b/test/dossiers.test.ts index 5cfaa1ab..b199462c 100644 --- a/test/dossiers.test.ts +++ b/test/dossiers.test.ts @@ -18,8 +18,9 @@ import { DOSSIER_FILES } from '../src/missions/dossiers/index.ts'; import { boardRumour, dockHint, leadJumps, leadLine, worldNews } from '../src/missions/hints.ts'; import { stepMissions, type MissionContext } from '../src/missions/machine.ts'; import type { - CommanderFacts, Dossier, MissionEffect, MissionState, Skeleton, + CommanderFacts, MissionEffect, MissionState, Skeleton, } from '../src/missions/model.ts'; +import type { Dossier } from '../src/missions/words.ts'; import { patronFor } from '../src/missions/patrons.ts'; import { SKELETONS, skeletonById } from '../src/missions/skeletons/index.ts'; import { SIDE_HUNT, SIDE_RESCUE } from '../src/missions/skeletons/side.ts'; diff --git a/test/mission-skeletons.test.ts b/test/mission-skeletons.test.ts index 555a4ba7..8fa58d97 100644 --- a/test/mission-skeletons.test.ts +++ b/test/mission-skeletons.test.ts @@ -10,6 +10,8 @@ import { SKELETONS } from '../src/missions/skeletons/index.ts'; import { lintSkeleton } from '../src/missions/lint.ts'; import type { Skeleton } from '../src/missions/model.ts'; import { routeEstimate } from '../src/galaxy/route.ts'; +import { SOURCE_DESIGN } from '../src/game/ship-specs.ts'; +import { shipDesignIdOf } from '../src/game/ship-identity.ts'; import { g1 } from './fixtures.ts'; import { check, eq } from './harness.ts'; @@ -48,6 +50,7 @@ const b: Skeleton = { legs: [{ ...arc().legs[1], id: 'one', place: { kind: 'here' } }], }; const legs = () => arc().legs; +const cobra = shipDesignIdOf(SOURCE_DESIGN.cobraMk3); /** A world eight or more jumps from Rabedira: too far for a final leg. */ const far = g1.find((s) => (routeEstimate(g1, g1[6], s)?.jumps ?? 0) >= 8)!.index; const withOverride = (leg: Skeleton['legs'][number], set: 'constrictor' | 'thargoid', where: 'target' | 'everywhere') => @@ -109,7 +112,22 @@ const faults: [string, Skeleton, readonly Skeleton[], string][] = [ ['a handover with no candidate from some world', arc({ legs: [{ ...legs()[0], place: { kind: 'handover', toward: 'b', min: 30, max: 40 } }, legs()[1]] }), [b], 'no candidate from'], + // Every trigger a verb can emit has a branch, or the leg says it ignores it + // (docs/TODO/213 M5). + ['a hunt that can escape with no branch for the escape', + arc({ legs: [{ ...legs()[0], verb: { kind: 'hunt', ship: cobra, canEscape: true }, + next: [{ on: 'targetDestroyed', to: 'two' }, { on: 'failed', to: 'fail' }] }, legs()[1]] }), + [b], 'no branch for targetEscaped'], ]; +{ + const quiet = arc({ legs: [{ ...legs()[0], verb: { kind: 'hunt', ship: cobra, canEscape: true }, + ignores: ['targetEscaped', 'targetFled'], + next: [{ on: 'targetDestroyed', to: 'two' }, { on: 'failed', to: 'fail' }] }, legs()[1]] }); + eq('...and the same leg that says it ignores them is clean', lintSkeleton(quiet, [quiet, b], g1).join('; '), ''); + const still = arc({ legs: [{ ...legs()[0], verb: { kind: 'hunt', ship: cobra, canEscape: false }, + next: [{ on: 'targetDestroyed', to: 'two' }, { on: 'failed', to: 'fail' }] }, legs()[1]] }); + eq('...and a hunt that cannot escape needs neither', lintSkeleton(still, [still, b], g1).join('; '), ''); +} for (const [name, s, others, word] of faults) { const problems = lintSkeleton(s, [s, ...others], g1); check(`the gate names ${name}`, problems.some((p) => p.includes(word)), problems.join('; ')); diff --git a/test/mission-story.test.ts b/test/mission-story.test.ts index 21504014..9c37b093 100644 --- a/test/mission-story.test.ts +++ b/test/mission-story.test.ts @@ -10,7 +10,8 @@ import { dossierFor } from '../src/missions/dossiers.ts'; import { storyPages } from '../src/missions/story.ts'; import { routeMapSvg } from '../src/missions/route-map.ts'; import { emptyMissionState } from '../src/missions/state.ts'; -import type { Dossier, MissionState } from '../src/missions/model.ts'; +import type { MissionState } from '../src/missions/model.ts'; +import type { Dossier } from '../src/missions/words.ts'; import { SIDE_RESCUE } from '../src/missions/skeletons/side.ts'; import { renderLog } from '../src/ui/screens-log.ts'; import { LogScreen } from '../src/game/screens/log.ts'; diff --git a/test/mission-verbs.test.ts b/test/mission-verbs.test.ts index 88fdec22..e95e691c 100644 --- a/test/mission-verbs.test.ts +++ b/test/mission-verbs.test.ts @@ -220,6 +220,11 @@ console.log('\nescort and scan, through the machine'); // left to kill. eq('a target wrecked by somebody else still ends the hunt', paid(stepMissions(hst, { kind: 'escortLost', tag: htag }, hctx).effects), SIDE_JOB_PAY.hunt); + // A pirate cannot leave a system today, so the side hunt says it ignores + // the word, and the lint holds it to that (docs/TODO/213 M5). + check('a side hunt says it ignores a target that fled', + SIDE_HUNT.legs[0].ignores?.includes('targetFled') === true); + eq('...and answers it with nothing', stepMissions(hst, { kind: 'fled', tag: htag }, hctx).state.live.length, 1); } console.log('\nescort, through a real world step'); diff --git a/test/tour-page.test.ts b/test/tour-page.test.ts index d24ac00e..62a821c2 100644 --- a/test/tour-page.test.ts +++ b/test/tour-page.test.ts @@ -13,7 +13,7 @@ import { escapeHtml } from '../src/engine/escape-html.ts'; import config, { FOOTER_MARKER } from '../vite.config.ts'; import { LogScreen } from '../src/game/screens/log.ts'; import { newCommander, type CommanderData } from '../src/game/commander.ts'; -import type { Dossier } from '../src/missions/model.ts'; +import type { Dossier } from '../src/missions/words.ts'; import { patronFor } from '../src/missions/patrons.ts'; import { routeMapSvg } from '../src/missions/route-map.ts'; import { ARC_TOUR, SKELETONS } from '../src/missions/skeletons/index.ts'; diff --git a/tools/dossier-faults.ts b/tools/dossier-faults.ts index a49a4b92..279adb7c 100644 --- a/tools/dossier-faults.ts +++ b/tools/dossier-faults.ts @@ -13,7 +13,8 @@ // names a system other than the patron's own world. No field breaks the // ladder-word rule. -import type { Dossier, Skeleton } from '../src/missions/model.ts'; +import type { Skeleton } from '../src/missions/model.ts'; +import type { Dossier } from '../src/missions/words.ts'; import { shapeOf } from './dossier-prompts.ts'; import { proseLadderOffences } from './ladder-rules.ts'; import { faults, foreignSystemNames, type FaultOptions } from './system-prompts.ts'; diff --git a/tools/dossier-prompts.ts b/tools/dossier-prompts.ts index 61231e70..110b1a55 100644 --- a/tools/dossier-prompts.ts +++ b/tools/dossier-prompts.ts @@ -15,7 +15,8 @@ import { COMMODITIES, generateGalaxy } from '../src/galaxy/galaxy.ts'; import { shipDesign } from '../src/game/ship-identity.ts'; import { triggerLabel } from '../src/missions/triggers.ts'; -import type { DossierFile, Leg, Placement, Skeleton, Trigger, Verb } from '../src/missions/model.ts'; +import type { Leg, Placement, Skeleton, Trigger, Verb } from '../src/missions/model.ts'; +import type { DossierFile } from '../src/missions/words.ts'; import { patronFor } from '../src/missions/patrons.ts'; import { SKELETONS, skeletonById } from '../src/missions/skeletons/index.ts'; import { fnv1a } from './system-prompts.ts'; @@ -221,7 +222,7 @@ export function indexSource(names: readonly string[]): string { '// own to fall out of step with this directory. `--check` fails when a file', '// here is missing from this list.', '', - "import type { DossierFile } from '../model.ts';", + "import type { DossierFile } from '../words.ts';", ...ids.map((n) => `import ${ident(n)} from './${n}.json' with { type: 'json' };`), '', ids.length diff --git a/tools/generate-dossiers.ts b/tools/generate-dossiers.ts index 26a50ab2..775cca24 100644 --- a/tools/generate-dossiers.ts +++ b/tools/generate-dossiers.ts @@ -24,7 +24,7 @@ import { readdirSync, readFileSync, writeFileSync } from 'node:fs'; import { fileURLToPath } from 'node:url'; import { dirname, join } from 'node:path'; -import type { Dossier, DossierFile } from '../src/missions/model.ts'; +import type { Dossier, DossierFile } from '../src/missions/words.ts'; import { SKELETONS, skeletonById } from '../src/missions/skeletons/index.ts'; import { newClient, reportCost, runBatches, runLocal, type BatchJob } from './batch.ts'; import { dossierFaults } from './dossier-faults.ts'; From 05f6bb76f2e9a673af440f14c60d061276eab83c Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Sun, 13 Sep 2026 09:46:19 +0100 Subject: [PATCH 067/100] docs/TODO/213 lands: the mission rules hold, and a hit trader goes back to work Five milestones, each committed on its own. The escort finishes eight of eight in the flight probe, from four. A side job comes back a week after it ends. A smuggling run leaves its goods at the far end. Every arc is gated to galaxy 1. A scoop job waits for the scoops. The gun warning speaks for the Constrictor alone. The loaders drop a ghost. The journal names its galaxy. The lint holds every trigger a verb can emit. The suite has 6,029 assertions, from 5,972. 214, the surprises, is the queue's one item. Co-Authored-By: Claude Fable 5.1 Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- docs/TODO/QUEUE.json | 1 - docs/TODO/README.md | 19 ++++++++++++++++--- ...hold-and-a-hit-trader-goes-back-to-work.md | 0 docs/TODO/completed/README.md | 1 + 4 files changed, 17 insertions(+), 4 deletions(-) rename docs/TODO/{ => completed}/213-the-mission-rules-hold-and-a-hit-trader-goes-back-to-work.md (100%) diff --git a/docs/TODO/QUEUE.json b/docs/TODO/QUEUE.json index bd917194..0530d8d1 100644 --- a/docs/TODO/QUEUE.json +++ b/docs/TODO/QUEUE.json @@ -1,7 +1,6 @@ { "version": 1, "items": [ - 213, 214 ] } diff --git a/docs/TODO/README.md b/docs/TODO/README.md index 2fe9a5b0..f614835f 100644 --- a/docs/TODO/README.md +++ b/docs/TODO/README.md @@ -13,8 +13,7 @@ active context: ## Execution queue -1. [213](213-the-mission-rules-hold-and-a-hit-trader-goes-back-to-work.md) — the mission rules hold, and a hit trader goes back to work. -2. [214](214-a-job-has-a-surprise-in-it.md) — a job has a surprise in it. +1. [214](214-a-job-has-a-surprise-in-it.md) — a job has a surprise in it. **213 AND 214 CAME FROM CHRIS ON 2026-09-13**, after two reviews of the missions. `docs/MISSIONS-REVIEW.md` read the machine and found five rules @@ -22,7 +21,8 @@ that do not hold. `docs/MISSIONS-FLIGHT-REVIEW.md` flew every kind of job and found the escort broken and the rest too easy. He said *"let's fix the broken parts"*, and then *"there should be surprises"*. 213 is the fixes. 214 is the surprises: an ambush on a scoop, pirates at the jump-in, and an -escort that needs the commander. +escort that needs the commander. **213 landed the same day**, and it is +below. **205 TO 208 CAME FROM CHRIS ON 2026-09-11, the day 204 landed.** He flew the touch controls of 204 on a phone, and he could not fly the ship. He @@ -303,6 +303,19 @@ headphones. **#24** closed on 2026-08-12 with it: *"display is good"*. **#23** closed with 134, as #22 did with 127, #18 with 121, #20 with 122 and #21 with 123. +## What landed on 2026-09-13 + +**213 — the mission rules hold, and a hit trader goes back to work.** A +trader that took a hit ran for the rest of its life, so an escort's charge +that a pirate grazed never reached the station. It goes back to work after +twenty calm seconds, the escort course cannot ram it, and a course refuses +a target below the planet. The escort finishes eight of eight in the flight +probe, from four. A side job comes back a week after it ends. A smuggling +run leaves its goods at the far end. Every arc is gated to galaxy 1, and a +scoop job waits for the scoops. The gun warning speaks for the Constrictor +alone. The loaders drop a ghost, the journal names its galaxy, and the lint +holds every trigger a verb can emit. 6,029 assertions, from 5,972. + ## What landed on 2026-09-12 **208 — every kind of mission has a way to fly it.** A live job is the first diff --git a/docs/TODO/213-the-mission-rules-hold-and-a-hit-trader-goes-back-to-work.md b/docs/TODO/completed/213-the-mission-rules-hold-and-a-hit-trader-goes-back-to-work.md similarity index 100% rename from docs/TODO/213-the-mission-rules-hold-and-a-hit-trader-goes-back-to-work.md rename to docs/TODO/completed/213-the-mission-rules-hold-and-a-hit-trader-goes-back-to-work.md diff --git a/docs/TODO/completed/README.md b/docs/TODO/completed/README.md index f6986efe..cb5c04c2 100644 --- a/docs/TODO/completed/README.md +++ b/docs/TODO/completed/README.md @@ -222,3 +222,4 @@ Supporting records: [Elite-A alignment plan](ELITE-A-COMBAT-PLAN.md), - [x] 210 — [The ship does not roll all the way there](210-the-ship-does-not-roll-all-the-way-there.md) — Chris, 2026-09-12. He flew a course and saw the ship rotate all the way to its target. The steering held a cone: the nose circled the target, and the roll never stopped. **M1** gives the course pilot a hard roll gate, which holds the pitch still until the bank arrives. A median trip fell from 41 full turns of roll to 1.3. The fight keeps the law it has. 5,877 assertions. - [x] 211 — [The ship stops short of the rock](211-the-ship-stops-short-of-the-rock.md) — Chris, 2026-09-12. He picked a rock and the ship flew on into it. The speed deadband held a drift as well as a speed, and the standoff was measured to the target's centre. **M1** brakes to a stop inside the standoff, and measures that range from the hull. A picked rock now holds 500 units of clear space. 5,886 assertions. - [x] 212 — [The computer lines up, and the pilot plays the slot](212-the-computer-lines-up-and-the-pilot-plays-the-slot.md) — Chris, 2026-09-12. He flew 207's docking on a phone and it did not work. The pilot took the ship 407 to 886 units off the slot axis, and a roll to match the spin turned the computer's own correction. **M1** makes the stretch two stages: the computer lines the ship up, then the rails hold the line while the pilot matches the slot and the speed. **M2** puts the rails in `game/dock-rails.ts`. The computer stops the ship on the line, so the pilot thrusts the whole run in. An ideal pilot went from 0 of 4 to 6 of 6, and a pilot who touches nothing never docks. 5,893 assertions. +- [x] 213 — [The mission rules hold, and a hit trader goes back to work](213-the-mission-rules-hold-and-a-hit-trader-goes-back-to-work.md) — Chris, 2026-09-13. Two reviews read the missions and flew every kind of job. **M1** makes a hit trader go back to work, and the escort ends. **M2** makes a side job come back, unloads a smuggling run, gates every arc to galaxy 1, and makes a scoop job wait for the scoops. **M3** keeps the gun warning for the Constrictor, and lets a lead's message through a board of side jobs. **M4** drops a ghost at the loader, gives the journal a galaxy, keys standing by the origin, and restores a mission ship under its leg's role. **M5** holds every trigger a verb can emit in the lint. 6,029 assertions. From 212ed29cbd03020b30f21adb4cafe11951d61605 Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Sun, 13 Sep 2026 09:51:32 +0100 Subject: [PATCH 068/100] docs/TODO/214 M1: pirates wait at the jump-in Chris, 2026-09-13: "there are pirates waiting for you when you jump in". A hunt's target flies with a wingman of its own design. A delivery meets a pair of Sidewinders at the far end, because somebody wants the packet. A canister adrift has a Krait circling it. The words say nothing of any of them, and a spawn list is outside the dossier hash, so no dossier changes. The lint holds a spawned ship to a roster row for its role. The flight probe: a side hunt takes 7 seconds, from 4, and an Asp hunt 24, from 12. The Asp pair killed a fresh commander in one run of eight. Co-Authored-By: Claude Fable 5.1 Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- docs/TODO/214-a-job-has-a-surprise-in-it.md | 16 +++++- src/missions/lint.ts | 7 ++- src/missions/skeletons/arcs/edle.ts | 4 +- src/missions/skeletons/arcs/lave.ts | 3 +- src/missions/skeletons/arcs/rabedira.ts | 3 +- src/missions/skeletons/arcs/vetitice.ts | 4 +- src/missions/skeletons/arcs/xeer.ts | 4 +- src/missions/skeletons/lane.ts | 57 ++++++++++++++++----- src/missions/skeletons/side.ts | 7 +-- test/constants.test.ts | 5 +- test/mission-courses.test.ts | 4 +- test/mission-skeletons.test.ts | 4 ++ test/mission-verbs.test.ts | 25 ++++++++- 13 files changed, 116 insertions(+), 27 deletions(-) diff --git a/docs/TODO/214-a-job-has-a-surprise-in-it.md b/docs/TODO/214-a-job-has-a-surprise-in-it.md index 05079a25..d3a889bc 100644 --- a/docs/TODO/214-a-job-has-a-surprise-in-it.md +++ b/docs/TODO/214-a-job-has-a-surprise-in-it.md @@ -133,4 +133,18 @@ Evidence: ## What the milestones found -Written as each milestone lands. +### M1 + +- **The company lives in `skeletons/lane.ts`**, beside the lane pirates: + a pair of Sidewinders, a lone Krait, and a wingman of the target's own + design. A side hunt flies with a Krait wingman. A delivery meets the pair + at the far end, and a canister adrift has the Krait circling it. The arc + hunts fly with one of their kind, and the arc deliveries meet the pair. +- **The lint holds a spawned ship to a roster row.** A design with no row + for its job's role was skipped at the arrival in silence. +- **The flight probe moved.** A side hunt takes 7 seconds, from 4, and an + Asp hunt 24, from 12. The Asp pair killed a fresh commander in one run of + eight, which is the rate the open question asked for. A delivery meets + 2.5 fights on the way in, from 1.4. Every other row is as it was. +- **Two tests read the first tagged ship and met the wingman.** Both read + the leg's own tag now. diff --git a/src/missions/lint.ts b/src/missions/lint.ts index 7e648c66..1db2d7f6 100644 --- a/src/missions/lint.ts +++ b/src/missions/lint.ts @@ -26,7 +26,7 @@ import { distanceTenths } from '../galaxy/navigation.ts'; import { routeTable } from '../galaxy/route.ts'; import type { Leg, Skeleton } from './model.ts'; import { specForDesign } from '../game/ship-specs.ts'; -import { verbJob, verbModule, verbNeedsShip, verbTriggers } from './verbs/registry.ts'; +import { jobRole, verbJob, verbModule, verbNeedsShip, verbTriggers } from './verbs/registry.ts'; import { sameTrigger, triggerLabel } from './triggers.ts'; import { pickByJumps } from './placement.ts'; @@ -48,6 +48,11 @@ export function lintSkeleton( const role = verbJob(leg.verb) === 'hunt' ? 'pirate' : 'trader'; if (!specForDesign(role, leg.verb.ship)) out.push(`${at}: no ${role} row for ${leg.verb.ship}`); } + // A spawned ship with no row for its role is skipped at the arrival, in + // silence, and the surprise never comes (docs/TODO/214 M1). + for (const s of leg.spawn ?? []) { + if (!specForDesign(jobRole(s.job), s.ship)) out.push(`${at}: no ${jobRole(s.job)} row for the spawned ${s.ship}`); + } if (!leg.next.some((b) => b.on === 'failed')) out.push(`${at}: no failed branch`); for (const t of verbModule(leg.verb.kind) ? verbTriggers(leg.verb) : []) { const answered = leg.next.some((b) => sameTrigger(b.on, t)) diff --git a/src/missions/skeletons/arcs/edle.ts b/src/missions/skeletons/arcs/edle.ts index 79fc36b6..09a41a39 100644 --- a/src/missions/skeletons/arcs/edle.ts +++ b/src/missions/skeletons/arcs/edle.ts @@ -15,6 +15,7 @@ import { ARC_LEG_DAYS, ARC_PAY, SIDE_JOB_RANGE } from '../../../constants/missio import { SOURCE_DESIGN } from '../../../game/ship-specs.ts'; import { shipDesignIdOf } from '../../../game/ship-identity.ts'; import type { Skeleton } from '../../model.ts'; +import { PAIR, wingmanOf } from '../lane.ts'; const AWAY = { kind: 'band', ...SIDE_JOB_RANGE } as const; @@ -28,7 +29,7 @@ export const ARC_EDLE: Skeleton = { offer: { galaxy: 1, done: ['arc-xeer'] }, legs: [ { - id: 'manifest', verb: { kind: 'deliver' }, place: AWAY, + id: 'manifest', verb: { kind: 'deliver' }, place: AWAY, spawn: [...PAIR], line: 'COLONEL: TAKE THE MANIFEST TO {TARGET}', deadlineDays: ARC_LEG_DAYS, next: [ { on: 'success', to: 'guard', settle: { pay: ARC_PAY.deliver, say: 'MANIFEST DELIVERED — {PAY}. THE TRANSPORTER LEAVES FOR {TARGET}.' } }, @@ -56,6 +57,7 @@ export const ARC_EDLE: Skeleton = { }, { id: 'purge', verb: { kind: 'hunt', ship: shipDesignIdOf(SOURCE_DESIGN.asp), canEscape: true }, place: AWAY, + spawn: [...wingmanOf(shipDesignIdOf(SOURCE_DESIGN.asp), 'purge')], line: 'COLONEL: DESTROY THE ASP — LAST SEEN AT {TARGET}', deadlineDays: ARC_LEG_DAYS, next: [ { on: 'targetDestroyed', to: 'complete', settle: { pay: ARC_PAY.hunt, say: 'ASP DESTROYED — {PAY} FROM EDLE. THE TOUR IS DONE.' } }, diff --git a/src/missions/skeletons/arcs/lave.ts b/src/missions/skeletons/arcs/lave.ts index 2f0e7fa8..92cc785c 100644 --- a/src/missions/skeletons/arcs/lave.ts +++ b/src/missions/skeletons/arcs/lave.ts @@ -16,6 +16,7 @@ import { ARC_HANDOVER_JUMPS, ARC_LEG_DAYS, ARC_PAY, SIDE_JOB_RANGE } from '../.. import { SOURCE_DESIGN } from '../../../game/ship-specs.ts'; import { shipDesignIdOf } from '../../../game/ship-identity.ts'; import type { Skeleton } from '../../model.ts'; +import { wingmanOf } from '../lane.ts'; const COBRA = shipDesignIdOf(SOURCE_DESIGN.cobraMk3); @@ -48,7 +49,7 @@ export const ARC_LAVE: Skeleton = { ], }, { - id: 'runner', verb: { kind: 'hunt', ship: COBRA, canEscape: true }, + id: 'runner', verb: { kind: 'hunt', ship: COBRA, canEscape: true }, spawn: [...wingmanOf(COBRA, 'runner')], place: { kind: 'handover', toward: 'arc-rabedira', ...ARC_HANDOVER_JUMPS }, line: 'GOVERNOR: DESTROY THE SMUGGLER\'S COBRA — LAST SEEN AT {TARGET}', deadlineDays: ARC_LEG_DAYS, next: [ diff --git a/src/missions/skeletons/arcs/rabedira.ts b/src/missions/skeletons/arcs/rabedira.ts index 35689291..fe662636 100644 --- a/src/missions/skeletons/arcs/rabedira.ts +++ b/src/missions/skeletons/arcs/rabedira.ts @@ -13,6 +13,7 @@ import { ARC_HANDOVER_JUMPS, ARC_LEG_DAYS, ARC_PAY, SIDE_JOB_RANGE } from '../.. import { SOURCE_DESIGN } from '../../../game/ship-specs.ts'; import { shipDesignIdOf } from '../../../game/ship-identity.ts'; import type { Skeleton } from '../../model.ts'; +import { PAIR } from '../lane.ts'; const TOWARD = { kind: 'handover', toward: 'arc-vetitice', ...ARC_HANDOVER_JUMPS } as const; @@ -26,7 +27,7 @@ export const ARC_RABEDIRA: Skeleton = { offer: { galaxy: 1, done: ['arc-lave'] }, legs: [ { - id: 'paper', verb: { kind: 'deliver' }, place: { kind: 'band', ...SIDE_JOB_RANGE }, + id: 'paper', verb: { kind: 'deliver' }, place: { kind: 'band', ...SIDE_JOB_RANGE }, spawn: [...PAIR], line: 'ENVOY: TAKE THE TRUCE PAPER TO {TARGET}', deadlineDays: ARC_LEG_DAYS, next: [ { on: 'success', to: 'convoy', settle: { pay: ARC_PAY.deliver, say: 'PAPER DELIVERED — {PAY}. NOW THE ENVOY\'S BOA LEAVES FOR {TARGET}.' } }, diff --git a/src/missions/skeletons/arcs/vetitice.ts b/src/missions/skeletons/arcs/vetitice.ts index 4a4499eb..43de749d 100644 --- a/src/missions/skeletons/arcs/vetitice.ts +++ b/src/missions/skeletons/arcs/vetitice.ts @@ -13,7 +13,7 @@ import { ARC_HANDOVER_JUMPS, ARC_LEG_DAYS, ARC_PAY, SIDE_JOB_RANGE } from '../../../constants/missions.ts'; import type { Skeleton } from '../../model.ts'; -import { LANE_PIRATES } from '../lane.ts'; +import { LANE_PIRATES, PAIR } from '../lane.ts'; export const ARC_VETITICE: Skeleton = { id: 'arc-vetitice', @@ -51,7 +51,7 @@ export const ARC_VETITICE: Skeleton = { ], }, { - id: 'manifest', verb: { kind: 'deliver' }, + id: 'manifest', verb: { kind: 'deliver' }, spawn: [...PAIR], place: { kind: 'handover', toward: 'arc-xeer', ...ARC_HANDOVER_JUMPS }, line: 'DIRECTOR: DELIVER THE MANIFEST TO {TARGET}', deadlineDays: ARC_LEG_DAYS, next: [ diff --git a/src/missions/skeletons/arcs/xeer.ts b/src/missions/skeletons/arcs/xeer.ts index 6d261217..f342eda6 100644 --- a/src/missions/skeletons/arcs/xeer.ts +++ b/src/missions/skeletons/arcs/xeer.ts @@ -13,6 +13,7 @@ import { ARC_HANDOVER_JUMPS, ARC_LEG_DAYS, ARC_PAY, SCAN_SECONDS, SIDE_JOB_RANGE import { SOURCE_DESIGN } from '../../../game/ship-specs.ts'; import { shipDesignIdOf } from '../../../game/ship-identity.ts'; import type { Skeleton } from '../../model.ts'; +import { PAIR, wingmanOf } from '../lane.ts'; const TOWARD = { kind: 'handover', toward: 'arc-edle', ...ARC_HANDOVER_JUMPS } as const; @@ -38,6 +39,7 @@ export const ARC_XEER: Skeleton = { }, { id: 'chase', verb: { kind: 'hunt', ship: shipDesignIdOf(SOURCE_DESIGN.ferDeLance), canEscape: true }, place: TOWARD, + spawn: [...wingmanOf(shipDesignIdOf(SOURCE_DESIGN.ferDeLance), 'chase')], line: 'ADMINISTRATOR: DESTROY THE FER-DE-LANCE — LAST SEEN AT {TARGET}', deadlineDays: ARC_LEG_DAYS, next: [ { on: 'targetDestroyed', to: 'complete', settle: { pay: ARC_PAY.hunt, say: 'COURIER DESTROYED — {PAY} FROM XEER' } }, @@ -47,7 +49,7 @@ export const ARC_XEER: Skeleton = { ], }, { - id: 'trail', verb: { kind: 'deliver' }, place: TOWARD, + id: 'trail', verb: { kind: 'deliver' }, place: TOWARD, spawn: [...PAIR], line: 'ADMINISTRATOR: REPORT THE COURIER\'S TRAIL AT {TARGET}', deadlineDays: ARC_LEG_DAYS, next: [ { on: 'success', to: 'complete', settle: { pay: ARC_PAY.deliver, say: 'TRAIL REPORTED — {PAY} FROM XEER' } }, diff --git a/src/missions/skeletons/lane.ts b/src/missions/skeletons/lane.ts index 958f6945..89ade4ae 100644 --- a/src/missions/skeletons/lane.ts +++ b/src/missions/skeletons/lane.ts @@ -1,21 +1,54 @@ -// The pirates on a lane the player is sent to clear (docs/TODO/203 M2). +// The pirates a job keeps company with: on a lane, at a jump-in, and beside +// a target (docs/TODO/203 M2, docs/TODO/214 M1). // // The job Clear the Lane promises pirates on the way to the target world. So -// does the first leg of the Vetitice arc. Neither spawned any before this file, so -// the player flew an ordinary lane and could not tell what the job was about. -// Both legs name this list, so the lane is the same fight from either patron. +// does the first leg of the Vetitice arc. Neither spawned any before this file, +// so the player flew an ordinary lane and could not tell what the job was +// about. Both legs name `LANE_PIRATES`, so the lane is the same fight from +// either patron. // -// Three light hulls, flown as pirates. A Krait pair and a Mamba is a fight a -// Cobra with pulse lasers can win. It is still a fight, which a lone -// Sidewinder is not. The tags answer nothing in the machine. A lane pirate is -// scenery with a gun, and a kill among them settles no branch. +// docs/TODO/214 M1 adds the rest. Chris, 2026-09-13: *"there are pirates +// waiting for you when you jump in"*. A hunt's target flies with a wingman. +// A delivery meets a pair at the far end, because somebody wants the packet. +// A canister adrift has a Krait circling it. The words say nothing of any +// of them, and that is the surprise. A spawn list is outside the dossier +// hash, so no dossier changes. +// +// Every one of these is scenery with a gun. The tags answer nothing in the +// machine, and a kill among them settles no branch. The flight probe under +// docs/reviews/missions-2026-09-12 measures what they cost a fresh commander. import { SOURCE_DESIGN } from '../../game/ship-specs.ts'; import { shipDesignIdOf } from '../../game/ship-identity.ts'; -import type { TaggedShip } from '../model.ts'; +import type { ShipId, TaggedShip } from '../model.ts'; + +const krait = shipDesignIdOf(SOURCE_DESIGN.krait); +const mamba = shipDesignIdOf(SOURCE_DESIGN.mamba); +const sidewinder = shipDesignIdOf(SOURCE_DESIGN.sidewinder); +/** + * Three light hulls, flown as pirates. A Krait pair and a Mamba is a fight a + * Cobra with pulse lasers can win. It is still a fight, which a lone + * Sidewinder is not. + */ export const LANE_PIRATES: readonly TaggedShip[] = [ - { ship: shipDesignIdOf(SOURCE_DESIGN.krait), tag: 'lane#krait-1', job: 'hunt' }, - { ship: shipDesignIdOf(SOURCE_DESIGN.krait), tag: 'lane#krait-2', job: 'hunt' }, - { ship: shipDesignIdOf(SOURCE_DESIGN.mamba), tag: 'lane#mamba', job: 'hunt' }, + { ship: krait, tag: 'lane#krait-1', job: 'hunt' }, + { ship: krait, tag: 'lane#krait-2', job: 'hunt' }, + { ship: mamba, tag: 'lane#mamba', job: 'hunt' }, +]; + +/** Two Sidewinders at the far end of a delivery: somebody wants the packet. */ +export const PAIR: readonly TaggedShip[] = [ + { ship: sidewinder, tag: 'pair#sidewinder-1', job: 'hunt' }, + { ship: sidewinder, tag: 'pair#sidewinder-2', job: 'hunt' }, ]; + +/** One Krait circling a canister adrift. */ +export const LONE_KRAIT: readonly TaggedShip[] = [ + { ship: krait, tag: 'lone#krait', job: 'hunt' }, +]; + +/** A wingman of the target's own design, so a hunt is two of its kind. */ +export function wingmanOf(ship: ShipId, leg: string): readonly TaggedShip[] { + return [{ ship, tag: `wing#${leg}`, job: 'hunt' }]; +} diff --git a/src/missions/skeletons/side.ts b/src/missions/skeletons/side.ts index b66b6a30..30ec5c0b 100644 --- a/src/missions/skeletons/side.ts +++ b/src/missions/skeletons/side.ts @@ -19,7 +19,7 @@ import { import { SOURCE_DESIGN } from '../../game/ship-specs.ts'; import { shipDesignIdOf } from '../../game/ship-identity.ts'; import type { Branch, Skeleton } from '../model.ts'; -import { LANE_PIRATES } from './lane.ts'; +import { LANE_PIRATES, LONE_KRAIT, PAIR, wingmanOf } from './lane.ts'; const FAIL: Branch = { on: 'failed', to: 'fail' }; const LOCAL = { kind: 'side', anchor: 'local', patron: { kind: 'local' } } as const; @@ -32,6 +32,7 @@ export const SIDE_HUNT: Skeleton = { legs: [{ id: 'hunt', verb: { kind: 'hunt', ship: shipDesignIdOf(SOURCE_DESIGN.krait), canEscape: true }, place: AWAY, line: 'BOUNTY: DESTROY THE KRAIT — LAST SEEN AT {TARGET}', deadlineDays: SIDE_JOB_DAYS, + spawn: [...wingmanOf(shipDesignIdOf(SOURCE_DESIGN.krait), 'side-hunt')], // A pirate cannot leave a system today, so a Krait that runs is a Krait // that comes back on the next arrival. A branch would change the dossier // hash, and 214 M4 makes the chase real (docs/TODO/213 M5). @@ -51,7 +52,7 @@ export const SIDE_DELIVER: Skeleton = { pitch: 'A SEALED PACKET FOR A STATION ONE JUMP OUT. NO QUESTIONS, NO HOLD SPACE.', offer: {}, legs: [{ - id: 'run', verb: { kind: 'deliver' }, place: AWAY, + id: 'run', verb: { kind: 'deliver' }, place: AWAY, spawn: [...PAIR], line: 'DELIVERY: TAKE THE PACKET TO {TARGET}', deadlineDays: SIDE_JOB_DAYS, next: [ { on: 'success', to: 'complete', settle: { pay: SIDE_JOB_PAY.deliver, say: 'THE PACKET IS DELIVERED. THE STATION PAYS {PAY}.' } }, @@ -68,7 +69,7 @@ export const SIDE_RECOVER: Skeleton = { offer: { scoops: true }, legs: [ { - id: 'find', verb: { kind: 'recover', item: 'station-canister' }, place: AWAY, + id: 'find', verb: { kind: 'recover', item: 'station-canister' }, place: AWAY, spawn: [...LONE_KRAIT], line: 'RECOVERY: SCOOP THE CANISTER ADRIFT AT {TARGET}', deadlineDays: SIDE_JOB_DAYS, next: [ { on: 'success', to: 'home', settle: { pay: 0, say: 'THE CANISTER IS ABOARD. BRING IT BACK TO {TARGET}.' } }, diff --git a/test/constants.test.ts b/test/constants.test.ts index 879acbed..a39d9adf 100644 --- a/test/constants.test.ts +++ b/test/constants.test.ts @@ -120,8 +120,9 @@ const OUTSIDE: readonly Group[] = [ ], // ...and the arcs in tour order, which is a list of ids (docs/TODO/192) 'missions/skeletons/index.ts': ['SKELETONS', 'ARC_TOUR'], - // the pirates both lane legs name (docs/TODO/203 M2) - 'missions/skeletons/lane.ts': ['LANE_PIRATES'], + // the pirates both lane legs name (docs/TODO/203 M2), and the company + // a job keeps at the jump-in (docs/TODO/214 M1) + 'missions/skeletons/lane.ts': ['LANE_PIRATES', 'PAIR', 'LONE_KRAIT'], 'missions/verbs/registry.ts': ['VERBS'], // the dossier table item 191 fills, and the words that end a story page 'missions/dossiers.ts': ['DOSSIERS'], diff --git a/test/mission-courses.test.ts b/test/mission-courses.test.ts index 547bb25a..d23dfceb 100644 --- a/test/mission-courses.test.ts +++ b/test/mission-courses.test.ts @@ -158,7 +158,9 @@ console.log('\na hunted ship that runs has fled, not escaped'); // commander has fled, and three arcs have a branch for it. const flown = (fleeing: boolean): string | undefined => { const g = onTheJob('side-hunt', 20_260_945); - const ship = g.state.world.npcs.find((n) => n.state.missionTag !== null); + // The target, and not the wingman that flies with it since 214 M1. + const tag = g.state.commander.missions.live[0].tag; + const ship = g.state.world.npcs.find((n) => n.state.missionTag === tag); if (!ship) throw new Error('the hunt spawned no ship'); ship.state.fleeing = fleeing; ship.state.wantsDespawn = true; diff --git a/test/mission-skeletons.test.ts b/test/mission-skeletons.test.ts index 8fa58d97..908392fa 100644 --- a/test/mission-skeletons.test.ts +++ b/test/mission-skeletons.test.ts @@ -112,6 +112,10 @@ const faults: [string, Skeleton, readonly Skeleton[], string][] = [ ['a handover with no candidate from some world', arc({ legs: [{ ...legs()[0], place: { kind: 'handover', toward: 'b', min: 30, max: 40 } }, legs()[1]] }), [b], 'no candidate from'], + // A spawned ship needs a row for the role its job flies (docs/TODO/214 M1). + ['a spawned ship with no row for its role', + arc({ legs: [{ ...legs()[0], spawn: [{ ship: 'no-such-hull' as never, tag: 'x', job: 'hunt' }] }, legs()[1]] }), + [b], 'no pirate row for the spawned'], // Every trigger a verb can emit has a branch, or the leg says it ignores it // (docs/TODO/213 M5). ['a hunt that can escape with no branch for the escape', diff --git a/test/mission-verbs.test.ts b/test/mission-verbs.test.ts index e95e691c..14f8dd2c 100644 --- a/test/mission-verbs.test.ts +++ b/test/mission-verbs.test.ts @@ -57,7 +57,9 @@ console.log('\nrecover: a canister adrift, scooped and brought home'); eq('the job opens on the find leg', live.leg, 'find'); eq('...with a tagged canister adrift at the target', JSON.stringify(missionItems(st, target)), JSON.stringify([{ tag, kind: 'cargo' }])); - eq('...and no ship', missionSpawns(st, target).length, 0); + // ...and one Krait circling it, which answers to nothing (docs/TODO/214 M1). + eq('...and one pirate beside it that is not the leg\'s', + missionSpawns(st, target).filter((s) => s.tag !== tag).length, 1); const wrong = stepMissions(st, { kind: 'scooped', tag: 'somebody-else' }, moved(ctx, target)); eq('another canister scooped moves nothing', wrong.state.live[0].leg, 'find'); const got = stepMissions(st, { kind: 'scooped', tag }, moved(ctx, target)); @@ -155,6 +157,27 @@ console.log('\nsmuggle: the goods go aboard, and the patrol is the risk'); eq('a police scan on the way fails it', read.state.done[SIDE_SMUGGLE.id], 'fail'); } +console.log('\npirates wait at the jump-in (docs/TODO/214 M1)'); +{ + // Chris, 2026-09-13: "there are pirates waiting for you when you jump in". + const hctx = boardFor(SIDE_HUNT); + const hst = accept(SIDE_HUNT, hctx); + const at = missionSpawns(hst, hst.live[0].target as number); + eq('a side hunt spawns the Krait and a wingman', at.length, 2); + check('...both flown as pirates', at.every((s) => s.job === 'hunt')); + check('...and only the target answers to the leg', at.filter((s) => s.tag === hst.live[0].tag).length === 1); + const dctx = boardFor(SIDE_DELIVER); + const dst = accept(SIDE_DELIVER, dctx); + eq('a delivery meets a pair at the far end', missionSpawns(dst, dst.live[0].target as number).length, 2); + eq('...and nothing at the world it was taken at', missionSpawns(dst, dctx.commander.systemIndex).length, 0); + const rctx = boardFor(SIDE_RECOVER); + const rst = accept(SIDE_RECOVER, rctx); + eq('a canister adrift has one Krait circling it', missionSpawns(rst, rst.live[0].target as number).length, 1); + const sctx = boardFor(SIDE_SCAN); + const sst = accept(SIDE_SCAN, sctx); + eq('a scan meets nobody but its subject', missionSpawns(sst, sst.live[0].target as number).length, 1); +} + console.log('\na local patron\'s standing is keyed by the world the job was taken at (docs/TODO/213 M4)'); { // A delivery accepted at one world and landed at another credited the far From ee9245682de86df9cd0269769ac06a01dc4c76c1 Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Sun, 13 Sep 2026 09:56:56 +0100 Subject: [PATCH 069/100] docs/TODO/214 M2: a scoop springs an ambush Chris, 2026-09-13: "collecting a canister triggers an ambush". A leg names the ships that jump in when it makes progress, and what the console says of them. The recover and rescue verbs spring it on the scoop, and the scan verb at the scan's end. The machine names a spawn effect, the bridge hands the order back beside the lines, and the world step spawns the ships at a pirate wave's reach. The three side jobs and two arc legs get one. The words never tell it, and a spawn list is outside the dossier hash. The spawn of a tagged ship has one home now, spawnTaggedShips, which the arrival and the ambush both call. The flight probe gained two cases that go on to the station after the scoop: a recover meets 2.9 fights on the way home, from 1.4, and finishes eight of eight. Co-Authored-By: Claude Fable 5.1 Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- docs/ARCHITECTURE.md | 3 +- docs/TODO/214-a-job-has-a-surprise-in-it.md | 19 ++++++ .../missions-2026-09-12/flight-probe.ts | 24 +++++++- src/game/mission-bridge.ts | 32 ++++++++-- src/game/spawning.ts | 61 +++++++++++-------- src/game/world-step.ts | 22 +++++-- src/missions/lint.ts | 2 +- src/missions/machine.ts | 6 ++ src/missions/model.ts | 9 +++ src/missions/skeletons/arcs/lave.ts | 3 +- src/missions/skeletons/arcs/vetitice.ts | 3 +- src/missions/skeletons/side.ts | 3 + src/missions/verbs/recover.ts | 2 +- src/missions/verbs/rescue.ts | 2 +- src/missions/verbs/scan.ts | 2 +- src/missions/verbs/verb.ts | 2 + test/mission-courses.test.ts | 18 ++++++ test/mission-skeletons.test.ts | 3 + test/mission-verbs.test.ts | 27 ++++++++ 19 files changed, 202 insertions(+), 41 deletions(-) diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md index 7ed22c95..c32aaa75 100644 --- a/docs/ARCHITECTURE.md +++ b/docs/ARCHITECTURE.md @@ -237,7 +237,8 @@ Two quirks are deliberate: - `src/game/mission-bridge.ts` is the game's side of the mission machine. It runs one input, installs the record on the commander, and applies the effects that are the commander's: credits, reputation and legal status. It - hands the words back, and the caller says them. `src/game/mission-desk.ts` + hands the words back, and the caller says them. It hands a spawn order + back too, and the world step spawns an ambush (docs/TODO/214). `src/game/mission-desk.ts` is the MISSIONS screen's two actions, acceptance and abandonment, and the offers it lists. `src/game/hunt-warning.ts` prices her gun against the ship a hunt names, through the combat oracle. diff --git a/docs/TODO/214-a-job-has-a-surprise-in-it.md b/docs/TODO/214-a-job-has-a-surprise-in-it.md index d3a889bc..d07bd785 100644 --- a/docs/TODO/214-a-job-has-a-surprise-in-it.md +++ b/docs/TODO/214-a-job-has-a-surprise-in-it.md @@ -148,3 +148,22 @@ Evidence: 2.5 fights on the way in, from 1.4. Every other row is as it was. - **Two tests read the first tagged ship and met the wingman.** Both read the leg's own tag now. + +### M2 + +- **The spawn of a tagged ship has one home**, `spawnTaggedShips` in + `spawning.ts`. The arrival calls it at the mission target's reach, and + the ambush calls it at a pirate wave's reach. +- **The bridge returns two things now.** `applyMissions` returns the lines + and the spawn orders, and `runMissions` is the lines alone. Two callers + hold the world and hear the order: the scoop, and the scan's end. +- **An ambush line queues behind the settlement's own.** THE CANISTER IS + ABOARD reads first, and THEY WERE WAITING FOR THE CANISTER after it. + PIRATE SIGNATURES DETECTED is said at once. +- **A laser held on a canister breaks it.** The real-game test flies the + scoop with no trigger. The flight probe fires only while the computer + aims, and that is the rule a pilot follows too. +- **The flight probe gained two cases** that go on to the station after + the scoop, so the ambush is met. A recover meets 2.9 fights on the way + home, from 1.4, and finishes eight of eight in 149 seconds. A rescue + meets 1.4 and docks eight of eight. Nobody died. diff --git a/docs/reviews/missions-2026-09-12/flight-probe.ts b/docs/reviews/missions-2026-09-12/flight-probe.ts index 7f46acb0..f4583161 100644 --- a/docs/reviews/missions-2026-09-12/flight-probe.ts +++ b/docs/reviews/missions-2026-09-12/flight-probe.ts @@ -102,6 +102,7 @@ interface Run { */ function fly( g: Game, key: string, seconds: number, until: () => boolean, failed: () => boolean, trigger: boolean, + then: Phase[] = [], ): Run { const s = g.state; const kills0 = s.commander.kills; @@ -110,9 +111,14 @@ function fly( let flown = 0; let outcome: Run['outcome'] = 'timeout'; const stationAway = s.player.position.distanceTo(s.world.station.position); + // The phases still to fly: the first is the case's own, and the rest follow. + const phases: Phase[] = [{ key, until: () => until(), trigger }, ...then.map((p) => ({ ...p, until: () => p.until(g) }))]; + let phase = 0; withoutSaving(() => { g.input.injectPress(key); for (let f = 0; f < seconds * 60; f++) { + key = phases[phase].key; + trigger = phases[phase].trigger; const hostile = hostilesNear(s.world.npcs, s.player.position, s.commander.legalStatus, s.player.position.distanceTo(s.world.station.position)); if (hostile && !inFight) fights += 1; @@ -130,7 +136,11 @@ function fly( flown = f * DT; if (g.mode === 'dead') { outcome = 'dead'; break; } if (failed()) { outcome = 'failed'; break; } - if (until()) { outcome = 'done'; break; } + if (phases[phase].until()) { + if (phase === phases.length - 1) { outcome = 'done'; break; } + phase += 1; + g.input.injectPress(phases[phase].key); + } } }); g.input.release(FIRE); @@ -145,6 +155,8 @@ const failed = (g: Game, id: string) => g.state.commander.missions.done[id] === const leg = (g: Game) => g.state.commander.missions.live[0]?.leg; const isDocked = (g: Game) => g.mode !== 'flight' && g.mode !== 'dead'; +interface Phase { key: string; until: (g: Game) => boolean; trigger: boolean } + interface Case { name: string; kit: Kit; @@ -154,6 +166,8 @@ interface Case { until: (g: Game) => boolean; failed: (g: Game) => boolean; trigger: boolean; + /** further phases after `until`: a second key, and what ends it (docs/TODO/214 M2) */ + then?: Phase[]; } const cobra = shipDesignIdOf(SOURCE_DESIGN.cobraMk3); @@ -179,6 +193,12 @@ const CASES: Case[] = [ key: COURSE_KEYS.mission, seconds: 240, until: (g) => leg(g) === 'home', failed: (g) => failed(g, 'side-recover'), trigger: true }, { name: 'side-rescue: scoop a pod (scoops fitted)', kit: { scoops: true }, put: (g) => onSideJob(g, 'side-rescue'), key: COURSE_KEYS.mission, seconds: 240, until: (g) => (g.state.commander.missions.live[0]?.progress ?? 0) > 0, failed: (g) => failed(g, 'side-rescue'), trigger: true }, + { name: 'side-recover: scoop, then fly home and dock (docking computer)', kit: { scoops: true, dc: true }, put: (g) => onSideJob(g, 'side-recover'), + key: COURSE_KEYS.mission, seconds: 480, until: (g) => leg(g) === 'home', failed: (g) => failed(g, 'side-recover'), trigger: true, + then: [{ key: COURSE_KEYS.station, until: (g) => done(g, 'side-recover'), trigger: true }] }, + { name: 'side-rescue: scoop, then dock (docking computer)', kit: { scoops: true, dc: true }, put: (g) => onSideJob(g, 'side-rescue'), + key: COURSE_KEYS.mission, seconds: 480, until: (g) => (g.state.commander.missions.live[0]?.progress ?? 0) > 0, failed: (g) => failed(g, 'side-rescue'), trigger: true, + then: [{ key: COURSE_KEYS.station, until: (g) => isDocked(g), trigger: true }] }, { name: 'side-ambush: the lane, then dock (docking computer)', kit: { dc: true }, put: (g) => onSideJob(g, 'side-ambush'), key: COURSE_KEYS.station, seconds: 480, until: (g) => done(g, 'side-ambush'), failed: (g) => failed(g, 'side-ambush'), trigger: true }, { name: 'side-deliver: fly to the station and dock (docking computer)', kit: { dc: true }, put: (g) => onSideJob(g, 'side-deliver'), @@ -195,7 +215,7 @@ for (const c of CASES) { const g = newGame(20_260_950 + k, c.kit); c.put(g); arrive(g, k); - runs.push(fly(g, c.key, c.seconds, () => c.until(g), () => c.failed(g), c.trigger)); + runs.push(fly(g, c.key, c.seconds, () => c.until(g), () => c.failed(g), c.trigger, c.then)); if (c.name.startsWith('side-escort') && runs[k].outcome !== 'done') { const charge = g.state.world.npcs.find((n) => n.state.missionTag !== null); const st = g.state.world.station.position; diff --git a/src/game/mission-bridge.ts b/src/game/mission-bridge.ts index b0924e46..a36771b1 100644 --- a/src/game/mission-bridge.ts +++ b/src/game/mission-bridge.ts @@ -23,7 +23,7 @@ import { stepMissions } from '../missions/machine.ts'; import { legOf } from '../missions/lookups.ts'; import { liveLegs } from '../missions/queries.ts'; import { jobRole, verbJob, verbNeedsShip } from '../missions/verbs/registry.ts'; -import type { CommanderFacts, LiveMission, MissionInput, Skeleton } from '../missions/model.ts'; +import type { CommanderFacts, LiveMission, MissionInput, Skeleton, TaggedShip } from '../missions/model.ts'; import { skeletonById } from '../missions/skeletons/index.ts'; import { FUGITIVE } from '../constants/law.ts'; import type { Command } from './controls.ts'; @@ -49,22 +49,45 @@ export function missionFacts(c: CommanderData): CommanderFacts { }; } +/** What one input left for the caller: the lines to say, and the ships to spawn. */ +export interface MissionOutcome { + /** the lines to say, in order. A `say` takes the console; a `later` waits behind it (session.ts) */ + messages: MissionMessage[]; + /** ships an ambush asks for, around the commander now. Only a caller with the world can spawn them */ + spawns: TaggedShip[]; +} + /** * Run one input through the machine, install the record, apply the costs. * - * @returns the lines to say, in order. A `say` takes the console; a `later` - * waits behind it (session.ts). + * @returns the lines to say, in order. A caller that holds the world and can + * hear a spawn order calls `applyMissions` instead (docs/TODO/214 M2). */ export function runMissions( c: CommanderData, input: MissionInput, systems: readonly StarSystem[] = galaxySystems(c.galaxy), rng: () => number = random, skeletons?: readonly Skeleton[], ): MissionMessage[] { + return applyMissions(c, input, systems, rng, skeletons).messages; +} + +/** + * `runMissions`, with the spawn orders too. A spawn is a world change, and + * the bridge has no world, so the order goes back to the caller. A caller + * that cannot spawn drops it, and an ambush no caller can hear is a + * skeleton fault the flight probe would show. + */ +export function applyMissions( + c: CommanderData, input: MissionInput, + systems: readonly StarSystem[] = galaxySystems(c.galaxy), rng: () => number = random, + skeletons?: readonly Skeleton[], +): MissionOutcome { const { state, effects } = stepMissions(c.missions, input, { commander: missionFacts(c), systems, rng, skeletons, }); c.missions = state; const out: MissionMessage[] = []; + const spawns: TaggedShip[] = []; // A dossier's line replaces the skeleton's where one exists (docs/TODO/191 // M3). The machine named the line and never read it. A word with no // dossier and no plain text is silence, as the skeleton meant it. @@ -116,6 +139,7 @@ export function runMissions( }); break; } + case 'spawn': spawns.push(...e.ships); break; // The goods delivered leave the hold, and no more than are aboard. case 'unload': c.cargo[e.commodity] = Math.max(0, c.cargo[e.commodity] - e.tonnes); @@ -132,7 +156,7 @@ export function runMissions( break; } } - return out; + return { messages: out, spawns }; } /** diff --git a/src/game/spawning.ts b/src/game/spawning.ts index ee7b2dd6..1a6c81c6 100644 --- a/src/game/spawning.ts +++ b/src/game/spawning.ts @@ -196,30 +196,7 @@ export function spawnPopulation( 3 + randomInt(4), ORDINARY_GOODS); } - // A mission ship flies the roster row for its design, under the role its - // job wants. A hunt's target is a pirate, as the Constrictor always was. An - // escort's charge and a scan's subject are traders. An escort's charge - // arrives with the commander and flies for the slot, so she can see it in. - // A design the roster cannot fly in that role is skipped, and the skeleton - // lint is the place to catch that. - const spawned: NpcShip[] = []; - for (const tagged of missionShips) { - const role = jobRole(tagged.job); - const spec = specForDesign(role, tagged.ship); - if (!spec) continue; - const pos = playerPos.clone() - .add(randomDirection(new THREE.Vector3()) - .multiplyScalar(MISSION_TARGET_RANGE + random() * MISSION_TARGET_RANGE_SPAN)); - const ship = place(role, pos, 0, spec); - ship.state.missionTag = tagged.tag; - if (tagged.job === 'escort') ship.state.traderPhase = 'arriving'; - // A scan's subject waits until it is scanned (docs/TODO/203 M2). A - // trader's clock starts at zero, so it left at once. Half docked without - // a word. Half jumped out and failed the job before the player could - // find it. The world step starts its clock when the scan is done. - if (tagged.job === 'scan') ship.state.tradeTimer = Number.POSITIVE_INFINITY; - spawned.push(ship); - } + const spawned = spawnTaggedShips(world, playerPos, missionShips, MISSION_TARGET_RANGE, MISSION_TARGET_RANGE_SPAN); // A mission's canister or pod drifts at the same reach as a mission ship, // so the scanner shows it in the same place. for (const item of missionItems) { @@ -248,6 +225,42 @@ export function spawnPopulation( * @param forward where the commander is pointed. The cone is about that, so the * ship arrives where somebody can see it. */ +/** + * The tagged ships a mission asks for, `range` to `range + span` from `at` + * in a random direction each. The arrival calls it for the ships that wait + * at the jump-in. An ambush calls it for the ships that jump in on a scoop + * (docs/TODO/214 M2). + * + * A mission ship flies the roster row for its design, under the role its + * job wants. A hunt's target is a pirate, as the Constrictor always was. An + * escort's charge and a scan's subject are traders. An escort's charge + * arrives with the commander and flies for the slot, so she can see it in. + * A design the roster cannot fly in that role is skipped, and the skeleton + * lint is the place to catch that. + */ +export function spawnTaggedShips( + world: World, at: THREE.Vector3, ships: readonly TaggedShip[], range: number, span: number, +): NpcShip[] { + const spawned: NpcShip[] = []; + for (const tagged of ships) { + const role = jobRole(tagged.job); + const spec = specForDesign(role, tagged.ship); + if (!spec) continue; + const pos = at.clone() + .add(randomDirection(new THREE.Vector3()).multiplyScalar(range + random() * span)); + const ship = world.spawn(role, aboveGround(world, pos), 0, spec); + ship.state.missionTag = tagged.tag; + if (tagged.job === 'escort') ship.state.traderPhase = 'arriving'; + // A scan's subject waits until it is scanned (docs/TODO/203 M2). A + // trader's clock starts at zero, so it left at once. Half docked without + // a word. Half jumped out and failed the job before the player could + // find it. The world step starts its clock when the scan is done. + if (tagged.job === 'scan') ship.state.tradeTimer = Number.POSITIVE_INFINITY; + spawned.push(ship); + } + return spawned; +} + export function spawnPassingTrader( world: World, playerPos: THREE.Vector3, forward: THREE.Vector3, ): NpcShip { diff --git a/src/game/world-step.ts b/src/game/world-step.ts index 8727edbb..4f2f6270 100644 --- a/src/game/world-step.ts +++ b/src/game/world-step.ts @@ -46,7 +46,7 @@ import { assignNpcTargets } from './npc-targeting.ts'; import { shipArticle } from './targets.ts'; import { closePassLines } from './close-pass.ts'; import { stepEncounters } from './encounters.ts'; -import { spawnArrivingTrader, spawnPassingTrader } from './spawning.ts'; +import { spawnArrivingTrader, spawnPassingTrader, spawnTaggedShips } from './spawning.ts'; import { STATION_TRUCE } from '../constants/law.ts'; import { PIRATE_WAVE_RANGE, PIRATE_WAVE_RANGE_SPAN, THARGON_DEPLOY_RANGE, @@ -81,7 +81,7 @@ import { Ordnance, ordnanceMessage, type OrdnanceOutcome } from './ordnance.ts'; import type { NpcShip, FireEvent, WorldView } from './npc.ts'; import { nearestNpc } from './hostility.ts'; import type { SoundEvent, SoundName } from './sounds.ts'; -import { runMissions } from './mission-bridge.ts'; +import { applyMissions, runMissions, type MissionOutcome } from './mission-bridge.ts'; import { scanSecondsFor } from '../missions/queries.ts'; import { DOCK_COMPUTER_RANGE } from '../constants/docking-computer.ts'; import { ESCORT_ENEMY_ROLES, WATCH_CONE } from '../constants/missions.ts'; @@ -688,7 +688,7 @@ export class WorldStep { if (npc.state.observed >= wanted) { npc.state.missionReported = true; npc.state.tradeTimer = 0; // watched; it may go about its business now (docs/TODO/203 M2) - out.push(...runMissions(commander, { kind: 'scanned', tag })); + out.push(...this.springAmbush(applyMissions(commander, { kind: 'scanned', tag }))); } continue; } @@ -703,6 +703,20 @@ export class WorldStep { } } + /** + * The ships a mission's step asked for jump in around the commander, at a + * pirate wave's reach, and the console says so (docs/TODO/214 M2). The + * lines come back as they were, for the caller to say. + */ + private springAmbush(outcome: MissionOutcome): StepEvent[] { + const { world, player } = this.state; + if (outcome.spawns.length > 0) { + spawnTaggedShips(world, player.position, outcome.spawns, PIRATE_WAVE_RANGE, PIRATE_WAVE_RANGE_SPAN); + return [say('PIRATE SIGNATURES DETECTED', 4), ...outcome.messages]; + } + return outcome.messages; + } + /** Cargo, missiles, and the things that are only ever seen. */ private stepProjectilesAndEffects(dt: number, out: StepEvent[]): void { const { world, player, commander } = this.state; @@ -723,7 +737,7 @@ export class WorldStep { // A MISSION'S THING, and the machine says what it was. It is a // canister that never enters the hold, or a pod whose passenger rides // under the pod's own tag (docs/TODO/190 M4). - out.push(...runMissions(commander, { kind: 'scooped', tag: c.missionTag })); + out.push(...this.springAmbush(applyMissions(commander, { kind: 'scooped', tag: c.missionTag }))); out.push(heard(c.kind === 'capsule' ? 'survivorScooped' : 'cargoScooped')); } else if (c.kind === 'capsule') { // A person, not stock. See CommanderData.survivors — a capsule is not diff --git a/src/missions/lint.ts b/src/missions/lint.ts index 1db2d7f6..447f48cf 100644 --- a/src/missions/lint.ts +++ b/src/missions/lint.ts @@ -50,7 +50,7 @@ export function lintSkeleton( } // A spawned ship with no row for its role is skipped at the arrival, in // silence, and the surprise never comes (docs/TODO/214 M1). - for (const s of leg.spawn ?? []) { + for (const s of [...(leg.spawn ?? []), ...(leg.ambush?.ships ?? [])]) { if (!specForDesign(jobRole(s.job), s.ship)) out.push(`${at}: no ${jobRole(s.job)} row for the spawned ${s.ship}`); } if (!leg.next.some((b) => b.on === 'failed')) out.push(`${at}: no failed branch`); diff --git a/src/missions/machine.ts b/src/missions/machine.ts index 8979a93e..70a8abc7 100644 --- a/src/missions/machine.ts +++ b/src/missions/machine.ts @@ -172,6 +172,12 @@ function react( effects.push({ kind: 'say', text: fillSlots(reaction.say, lineSlots(ctx.systems, live.target, legPay(leg))) }); } if (reaction.trigger !== undefined) fire(st, live, reaction.trigger, ctx, effects); + // The ambush springs after the branch settles, so its line queues behind + // the settlement's own (docs/TODO/214 M2). + if (reaction.sprung && leg.ambush) { + effects.push({ kind: 'spawn', ships: leg.ambush.ships }); + effects.push({ kind: 'later', text: leg.ambush.say }); + } } // A passenger answered for is off the ship, whichever mission owned them. if (input.kind === 'survivor') st.passengers = st.passengers.filter((p) => p.tag !== input.tag); diff --git a/src/missions/model.ts b/src/missions/model.ts index 737aa9a0..6c672113 100644 --- a/src/missions/model.ts +++ b/src/missions/model.ts @@ -168,6 +168,13 @@ export interface Leg { * kill among them moves nothing. */ spawn?: TaggedShip[]; + /** + * Ships that jump in when the leg makes progress, and what the console + * says of them (docs/TODO/214 M2). A scoop springs it for a recover and a + * rescue, and the scan's end for a scan. They are untracked, as `spawn` + * is, so a kill among them settles nothing. The words never tell it. + */ + ambush?: { ships: TaggedShip[]; say: string }; /** true raises the mis-jump chance, as the 1984 courier run did */ carryingPlans?: boolean; /** @@ -346,5 +353,7 @@ export type MissionEffect = | { kind: 'cargo'; commodity: number; tonnes: number } /** the patron's goods leave the hold: a smuggle leg ends with them delivered */ | { kind: 'unload'; commodity: number; tonnes: number } + /** ships that jump in around the commander now: an ambush a leg sprang */ + | { kind: 'spawn'; ships: TaggedShip[] } /** passengers a finished mission leaves in the crew spaces, as survivors */ | { kind: 'survivors'; people: number }; diff --git a/src/missions/skeletons/arcs/lave.ts b/src/missions/skeletons/arcs/lave.ts index 92cc785c..dd18e7d2 100644 --- a/src/missions/skeletons/arcs/lave.ts +++ b/src/missions/skeletons/arcs/lave.ts @@ -16,7 +16,7 @@ import { ARC_HANDOVER_JUMPS, ARC_LEG_DAYS, ARC_PAY, SIDE_JOB_RANGE } from '../.. import { SOURCE_DESIGN } from '../../../game/ship-specs.ts'; import { shipDesignIdOf } from '../../../game/ship-identity.ts'; import type { Skeleton } from '../../model.ts'; -import { wingmanOf } from '../lane.ts'; +import { PAIR, wingmanOf } from '../lane.ts'; const COBRA = shipDesignIdOf(SOURCE_DESIGN.cobraMk3); @@ -31,6 +31,7 @@ export const ARC_LAVE: Skeleton = { legs: [ { id: 'ledger', verb: { kind: 'recover', item: 'grub-ledger' }, place: { kind: 'band', ...SIDE_JOB_RANGE }, + ambush: { ships: [...PAIR], say: 'THE SMUGGLER\'S FRIENDS WERE WAITING FOR THE LEDGER.' }, line: 'GOVERNOR: SCOOP THE LEDGER CANISTER ADRIFT AT {TARGET}', deadlineDays: ARC_LEG_DAYS, next: [ { on: 'success', to: 'runner', settle: { pay: ARC_PAY.recover, say: 'LEDGER ABOARD — {PAY}. NOW THE SMUGGLER.' } }, diff --git a/src/missions/skeletons/arcs/vetitice.ts b/src/missions/skeletons/arcs/vetitice.ts index 43de749d..77a063f9 100644 --- a/src/missions/skeletons/arcs/vetitice.ts +++ b/src/missions/skeletons/arcs/vetitice.ts @@ -13,7 +13,7 @@ import { ARC_HANDOVER_JUMPS, ARC_LEG_DAYS, ARC_PAY, SIDE_JOB_RANGE } from '../../../constants/missions.ts'; import type { Skeleton } from '../../model.ts'; -import { LANE_PIRATES, PAIR } from '../lane.ts'; +import { LANE_PIRATES, LONE_KRAIT, PAIR } from '../lane.ts'; export const ARC_VETITICE: Skeleton = { id: 'arc-vetitice', @@ -34,6 +34,7 @@ export const ARC_VETITICE: Skeleton = { }, { id: 'pod', verb: { kind: 'rescue' }, place: { kind: 'band', ...SIDE_JOB_RANGE }, + ambush: { ships: [...LONE_KRAIT], say: 'SOMEBODY WANTED THE SURVEYOR.' }, line: 'DIRECTOR: SCOOP THE SURVEYOR\'S POD AT {TARGET} AND DOCK', deadlineDays: ARC_LEG_DAYS, next: [ { on: { survivor: 'landed' }, to: 'manifest', settle: { pay: ARC_PAY.rescue, say: 'SURVEYOR LANDED — {PAY}. THE MANIFEST GOES TO {TARGET}.' } }, diff --git a/src/missions/skeletons/side.ts b/src/missions/skeletons/side.ts index 30ec5c0b..d116a026 100644 --- a/src/missions/skeletons/side.ts +++ b/src/missions/skeletons/side.ts @@ -70,6 +70,7 @@ export const SIDE_RECOVER: Skeleton = { legs: [ { id: 'find', verb: { kind: 'recover', item: 'station-canister' }, place: AWAY, spawn: [...LONE_KRAIT], + ambush: { ships: [...PAIR], say: 'THEY WERE WAITING FOR THE CANISTER.' }, line: 'RECOVERY: SCOOP THE CANISTER ADRIFT AT {TARGET}', deadlineDays: SIDE_JOB_DAYS, next: [ { on: 'success', to: 'home', settle: { pay: 0, say: 'THE CANISTER IS ABOARD. BRING IT BACK TO {TARGET}.' } }, @@ -97,6 +98,7 @@ export const SIDE_RESCUE: Skeleton = { legs: [ { id: 'pod', verb: { kind: 'rescue' }, place: AWAY, + ambush: { ships: [...LONE_KRAIT], say: 'SOMEBODY WANTED THAT POD.' }, line: 'RESCUE: SCOOP THE POD ADRIFT AT {TARGET} AND DOCK', deadlineDays: SIDE_JOB_DAYS, next: [ { on: { survivor: 'landed' }, to: 'complete', settle: { pay: SIDE_JOB_PAY.rescue, say: 'THE PILOT IS LANDED SAFE. THE STATION PAYS {PAY}.' } }, @@ -177,6 +179,7 @@ export const SIDE_SCAN: Skeleton = { legs: [{ id: 'watch', verb: { kind: 'scan', ship: shipDesignIdOf(SOURCE_DESIGN.anaconda), seconds: SCAN_SECONDS }, place: AWAY, line: 'SCAN: HOLD THE ANACONDA AT {TARGET} ON YOUR SCANNER', deadlineDays: SIDE_JOB_DAYS, + ambush: { ships: [...PAIR], say: 'THE ANACONDA\'S ESCORT SAW THE SCAN.' }, next: [ { on: 'success', to: 'complete', settle: { pay: SIDE_JOB_PAY.scan, say: 'THE SCAN IS COMPLETE. THE STATION PAYS {PAY}.' } }, { on: 'targetDestroyed', to: 'fail', settle: { pay: 0, standing: -2 } }, diff --git a/src/missions/verbs/recover.ts b/src/missions/verbs/recover.ts index ffcc5ae8..6a4a2e79 100644 --- a/src/missions/verbs/recover.ts +++ b/src/missions/verbs/recover.ts @@ -9,7 +9,7 @@ import type { VerbModule } from './verb.ts'; export const recover: VerbModule = (ctx, input) => { if (ctx.leg.verb.kind !== 'recover') return null; if (!('tag' in input) || input.tag !== ctx.live.tag) return null; - if (input.kind === 'scooped') return { trigger: 'success' }; + if (input.kind === 'scooped') return { trigger: 'success', sprung: true }; if (input.kind === 'destroyed') return { trigger: 'targetDestroyed' }; return null; }; diff --git a/src/missions/verbs/rescue.ts b/src/missions/verbs/rescue.ts index ad8e1035..3af7e1c5 100644 --- a/src/missions/verbs/rescue.ts +++ b/src/missions/verbs/rescue.ts @@ -15,7 +15,7 @@ export const rescue: VerbModule = (ctx, input) => { if (ctx.leg.verb.kind !== 'rescue') return null; if (!('tag' in input) || input.tag !== ctx.live.tag) return null; if (input.kind === 'scooped') { - return { progress: 1, passenger: true, say: 'THE PILOT IS ABOARD. DOCK AT ANY STATION AND LAND HER.' }; + return { progress: 1, passenger: true, sprung: true, say: 'THE PILOT IS ABOARD. DOCK AT ANY STATION AND LAND HER.' }; } if (input.kind === 'destroyed' && ctx.live.progress < 1) return { trigger: 'targetDestroyed' }; if (input.kind === 'survivor') return { trigger: { survivor: input.fate } }; diff --git a/src/missions/verbs/scan.ts b/src/missions/verbs/scan.ts index 98284cab..9ab0809e 100644 --- a/src/missions/verbs/scan.ts +++ b/src/missions/verbs/scan.ts @@ -11,7 +11,7 @@ import type { VerbModule } from './verb.ts'; export const scan: VerbModule = (ctx, input) => { if (ctx.leg.verb.kind !== 'scan') return null; if (!('tag' in input) || input.tag !== ctx.live.tag) return null; - if (input.kind === 'scanned') return { trigger: 'success' }; + if (input.kind === 'scanned') return { trigger: 'success', sprung: true }; if (input.kind === 'destroyed' || input.kind === 'escortLost') return { trigger: 'targetDestroyed' }; if (input.kind === 'escaped' || input.kind === 'fled') return { trigger: 'targetEscaped' }; return null; diff --git a/src/missions/verbs/verb.ts b/src/missions/verbs/verb.ts index de7f1670..ce33a143 100644 --- a/src/missions/verbs/verb.ts +++ b/src/missions/verbs/verb.ts @@ -24,6 +24,8 @@ export interface VerbReaction { passenger?: boolean; /** the leg's goods are delivered, and the machine asks the game to take them off */ unload?: boolean; + /** the step that springs the leg's ambush, where the leg has one (docs/TODO/214 M2) */ + sprung?: boolean; /** * What the console says about a step that takes no branch, with `{TARGET}` * for the leg's world (docs/TODO/203 M4). A branch speaks through its diff --git a/test/mission-courses.test.ts b/test/mission-courses.test.ts index d23dfceb..1e33cbe8 100644 --- a/test/mission-courses.test.ts +++ b/test/mission-courses.test.ts @@ -151,6 +151,24 @@ console.log('\nthe escort course does not ram its charge, and a grazed charge go eq('...on its way to the station', charge.state.traderPhase, 'arriving'); } +console.log('\nthe canister scooped springs its ambush in the sky (docs/TODO/214 M2)'); +{ + const g = onTheJob('side-recover', 20_260_948); + const live = g.state.commander.missions.live[0]; + // The Krait that circles the canister stays out of it, so the scoop is the + // only thing that can spring the pair. + for (const n of g.state.world.npcs) if (n.state.missionTag !== live.tag) n.state.alive = false; + const pirates = () => g.state.world.npcs.filter((n) => n.state.alive && n.role === 'pirate').length; + eq('the sky is clear of pirates before the scoop', pirates(), 0); + // No trigger: a laser held on a canister breaks it, and the job fails. + const took = fly(g, 240, () => g.state.commander.missions.live[0]?.leg === 'home'); + eq('the ship scoops the canister', g.state.commander.missions.live[0]?.leg, 'home'); + eq('...and the pair jumps in', pirates(), 2, ); + check('...at a pirate wave\'s reach, not on top of the ship', + g.state.world.npcs.filter((n) => n.state.alive && n.role === 'pirate') + .every((n) => n.object.position.distanceTo(g.state.player.position) > 4000), `after ${took.toFixed(0)}s`); +} + console.log('\na hunted ship that runs has fled, not escaped'); { // Before docs/TODO/208 M3 the world sent `escaped` whichever way a tagged diff --git a/test/mission-skeletons.test.ts b/test/mission-skeletons.test.ts index 908392fa..deaf6e73 100644 --- a/test/mission-skeletons.test.ts +++ b/test/mission-skeletons.test.ts @@ -116,6 +116,9 @@ const faults: [string, Skeleton, readonly Skeleton[], string][] = [ ['a spawned ship with no row for its role', arc({ legs: [{ ...legs()[0], spawn: [{ ship: 'no-such-hull' as never, tag: 'x', job: 'hunt' }] }, legs()[1]] }), [b], 'no pirate row for the spawned'], + ['an ambush with no row for its role (docs/TODO/214 M2)', + arc({ legs: [{ ...legs()[0], ambush: { ships: [{ ship: 'no-such-hull' as never, tag: 'x', job: 'hunt' }], say: 'X' } }, legs()[1]] }), + [b], 'no pirate row for the spawned'], // Every trigger a verb can emit has a branch, or the leg says it ignores it // (docs/TODO/213 M5). ['a hunt that can escape with no branch for the escape', diff --git a/test/mission-verbs.test.ts b/test/mission-verbs.test.ts index 14f8dd2c..32e0c606 100644 --- a/test/mission-verbs.test.ts +++ b/test/mission-verbs.test.ts @@ -178,6 +178,33 @@ console.log('\npirates wait at the jump-in (docs/TODO/214 M1)'); eq('a scan meets nobody but its subject', missionSpawns(sst, sst.live[0].target as number).length, 1); } +console.log('\na scoop springs an ambush, and so does the end of a scan (docs/TODO/214 M2)'); +{ + // Chris, 2026-09-13: "collecting a canister triggers an ambush". + const spawned = (effects: MissionEffect[]): number => + effects.reduce((n, e) => n + (e.kind === 'spawn' ? e.ships.length : 0), 0); + const rctx = boardFor(SIDE_RECOVER); + const rst = accept(SIDE_RECOVER, rctx); + const scooped = stepMissions(rst, { kind: 'scooped', tag: rst.live[0].tag as string }, moved(rctx, rst.live[0].target as number)); + eq('the canister scooped asks the game for the pair', spawned(scooped.effects), 2); + check('...and says so, behind the leg\'s own line', + scooped.effects.some((e) => e.kind === 'later' && e.text === SIDE_RECOVER.legs[0].ambush?.say)); + eq('...and the leg still moved on', scooped.state.live[0]?.leg, 'home'); + const pctx = boardFor(SIDE_RESCUE); + const pst = accept(SIDE_RESCUE, pctx); + eq('the pod scooped asks for the Krait', + spawned(stepMissions(pst, { kind: 'scooped', tag: pst.live[0].tag as string }, moved(pctx, pst.live[0].target as number)).effects), 1); + const sctx = boardFor(SIDE_SCAN); + const sst = accept(SIDE_SCAN, sctx); + eq('the scan done asks for the escort', spawned(stepMissions(sst, { kind: 'scanned', tag: sst.live[0].tag as string }, sctx).effects), 2); + eq('...and a subject destroyed springs nothing', + spawned(stepMissions(sst, { kind: 'destroyed', tag: sst.live[0].tag as string }, sctx).effects), 0); + const dctx = boardFor(SIDE_DELIVER); + const dst = accept(SIDE_DELIVER, dctx); + eq('a delivery has no ambush to spring', + spawned(stepMissions(dst, { kind: 'docked' }, moved(dctx, dst.live[0].target as number)).effects), 0); +} + console.log('\na local patron\'s standing is keyed by the world the job was taken at (docs/TODO/213 M4)'); { // A delivery accepted at one world and landed at another credited the far From ce6ede9b3b251640df4b4fc16fdd53cbbabdcd63 Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Sun, 13 Sep 2026 10:02:44 +0100 Subject: [PATCH 070/100] docs/TODO/214 M3: an escort is the commander's to keep Chris, 2026-09-13: "an escort mission should be more difficult than just flying to the station". The charge flew there on its own, and the escort was a job she watched. The charge holds for her now beyond ESCORT_LEASH, two thirds of the scanner, and the console says so once. The fee needs her within station range of the charge. A side escort meets a pair of Sidewinders at the jump-in, and the two arc escorts meet the lane pirates, so the fight is where the fee is judged. The flight probe: the escort finishes eight of eight, with 1.5 fights on the way from 0.3, and the ship ends with energy 239 and shields 225 and 255. The verb test crossed the size ceiling; the company blocks went to test/mission-company.test.ts, and the four helpers every verb test uses to test/fixtures.ts. M4, the chase, waits for a dossier regeneration on Chris's machine. Co-Authored-By: Claude Fable 5.1 Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- docs/TODO/214-a-job-has-a-surprise-in-it.md | 25 ++++++ src/constants/CATALOG.md | 11 +-- src/constants/mission-course.ts | 17 ++++ src/game/npc-state.ts | 10 ++- src/game/trader-flight.ts | 6 +- src/game/world-step.ts | 18 +++- src/missions/skeletons/arcs/edle.ts | 4 +- src/missions/skeletons/arcs/rabedira.ts | 4 +- src/missions/skeletons/side.ts | 2 +- test/fixtures.ts | 34 +++++++- test/mission-company.test.ts | 94 +++++++++++++++++++++ test/mission-courses.test.ts | 26 +++++- test/mission-verbs.test.ts | 93 +++----------------- test/npc-trader.test.ts | 13 +++ test/run.ts | 1 + test/trader-flight.test.ts | 1 + 16 files changed, 257 insertions(+), 102 deletions(-) create mode 100644 test/mission-company.test.ts diff --git a/docs/TODO/214-a-job-has-a-surprise-in-it.md b/docs/TODO/214-a-job-has-a-surprise-in-it.md index d07bd785..ef565dea 100644 --- a/docs/TODO/214-a-job-has-a-surprise-in-it.md +++ b/docs/TODO/214-a-job-has-a-surprise-in-it.md @@ -167,3 +167,28 @@ Evidence: the scoop, so the ambush is met. A recover meets 2.9 fights on the way home, from 1.4, and finishes eight of eight in 149 seconds. A rescue meets 1.4 and docks eight of eight. Nobody died. + +### M3 + +- **The charge holds for her.** `holding` on the ship is decided by the + world step each frame, from `ESCORT_LEASH`, and the working life reads it + as a speed of zero. The console says THE PYTHON IS HOLDING FOR YOU once, + through a second latch. The leash derives from the scanner, two thirds of + it, so a charge that holds is still on her scanner. +- **The fee needs her there.** `escortSafe` asks four things now: the + charge alive, inside station range, the commander inside that range of + it, and no enemy inside it. +- **The pirates come with the charge.** A side escort meets a pair of + Sidewinders at the jump-in, and the two arc escorts meet the lane pirates. + A pirate goes for the commander first, and the leash keeps her beside the + charge, so the fight is where the fee is judged. +- **The flight probe moved.** The escort finishes eight of eight in 500 + seconds, with 1.5 fights on the way, from 0.3, and 24 kills over the + eight. The ship ends with energy 239 and shields 225 and 255. +- **`test/mission-verbs.test.ts` crossed the size ceiling.** The company + blocks, and the lane block from 203, went to + `test/mission-company.test.ts`. The four helpers every verb test uses + went to `test/fixtures.ts`, so the two files share one fixture. +- **M4 waits for Chris.** A branch for a hunted ship that runs needs one + dossier regeneration, and the generator runs through the `claude` + command line on his machine. M1 to M3 stand on their own. diff --git a/src/constants/CATALOG.md b/src/constants/CATALOG.md index 09e07a1e..56c203d7 100644 --- a/src/constants/CATALOG.md +++ b/src/constants/CATALOG.md @@ -2,7 +2,7 @@ -460 exported constants. Regenerate with `npm run generate:constants`; +461 exported constants. Regenerate with `npm run generate:constants`; search names, meanings and values with `npm run constants:find -- ""`. | Domain | Symbol | Literal / expression | Purpose | Rule ID | Source | @@ -247,10 +247,11 @@ search names, meanings and values with `npm run constants:find -- ""`. | market | SALE_NOTORIETY_REVENUE | 40_000 | What a sale does to your reputation. | | [market.ts:30](./market.ts#L30) | | market | SALE_NOTORIETY_CONTRABAND | 0.04 | Extra talk per tonne of CONTRABAND sold, on top of the takings. | | [market.ts:45](./market.ts#L45) | | market | SALE_NOTORIETY_MAX | 0.5 | The most heat that one sale can raise, out of the 0..1 bar that `LivingGalaxy` keeps. | market.saleNotorietyMax | [market.ts:61](./market.ts#L61) | -| mission-course | COURSE_WATCH_STANDOFF | 1200 | How far from a ship the scan course holds, in world units (docs/TODO/208 M2). | course.watchStandoff | [mission-course.ts:23](./mission-course.ts#L23) | -| mission-course | COURSE_ESCORT_STANDOFF | 600 | How far from its charge the escort course flies, in world units (docs/TODO/208 M2). | course.escortStandoff | [mission-course.ts:36](./mission-course.ts#L36) | -| mission-course | COURSE_ESCORT_CLOSING | 60 | How much faster than its charge the escort course may close, in world units a second, once it is inside three standoffs of it: sixty. | course.escortClosing | [mission-course.ts:51](./mission-course.ts#L51) | -| mission-course | COURSE_POLICE_CLEARANCE | SCAN_WARN_RANGE | How wide of a police ship the smuggling course flies, in world units (docs/TODO/208 M4). | | [mission-course.ts:64](./mission-course.ts#L64) | +| mission-course | COURSE_WATCH_STANDOFF | 1200 | How far from a ship the scan course holds, in world units (docs/TODO/208 M2). | course.watchStandoff | [mission-course.ts:24](./mission-course.ts#L24) | +| mission-course | COURSE_ESCORT_STANDOFF | 600 | How far from its charge the escort course flies, in world units (docs/TODO/208 M2). | course.escortStandoff | [mission-course.ts:37](./mission-course.ts#L37) | +| mission-course | COURSE_ESCORT_CLOSING | 60 | How much faster than its charge the escort course may close, in world units a second, once it is inside three standoffs of it: sixty. | course.escortClosing | [mission-course.ts:52](./mission-course.ts#L52) | +| mission-course | ESCORT_LEASH | SCANNER_RANGE * 2 / 3 | How far the commander may fall behind her charge before it holds for her, in world units (docs/TODO/214 M3). | course.escortLeash | [mission-course.ts:68](./mission-course.ts#L68) | +| mission-course | COURSE_POLICE_CLEARANCE | SCAN_WARN_RANGE | How wide of a police ship the smuggling course flies, in world units (docs/TODO/208 M4). | | [mission-course.ts:81](./mission-course.ts#L81) | | missions | MISSION_KILL_THRESHOLD | 16 | Kills before the Navy considers you worth a word: 16, as the original demanded. | missions.killThreshold | [missions.ts:15](./missions.ts#L15) | | missions | MISSION_HUNT_RANGE | { min: 30, max: 80 } as const | The Constrictor hides this far from where you are briefed, in tenths of a light year. | | [missions.ts:23](./missions.ts#L23) | | missions | MISSION_COURIER_RANGE | { min: 50, max: 90 } as const | The courier run is longer: the plans matter more than your convenience. | | [missions.ts:26](./missions.ts#L26) | diff --git a/src/constants/mission-course.ts b/src/constants/mission-course.ts index 0c9e4f5e..142b1500 100644 --- a/src/constants/mission-course.ts +++ b/src/constants/mission-course.ts @@ -7,6 +7,7 @@ // over the size ceiling, and a mission's course is a subject of its own. import { SCAN_WARN_RANGE } from './law.ts'; +import { SCANNER_RANGE } from './console.ts'; /** * How far from a ship the scan course holds, in world units @@ -50,6 +51,22 @@ export const COURSE_ESCORT_STANDOFF = 600; */ export const COURSE_ESCORT_CLOSING = 60; +/** + * How far the commander may fall behind her charge before it holds for + * her, in world units (docs/TODO/214 M3). It is two thirds of the scanner, + * which is four thousand. + * + * The charge flew to the station on its own, and the escort was a job the + * commander watched. It moves while she is inside the leash and holds where + * it is when she is not. The leash is well outside the escort standoff of + * 600, so the course never trips it. It derives from the scanner so that a + * charge that holds is always still on her scanner. + * + * @rule course.escortLeash + * @domain mission-course + */ +export const ESCORT_LEASH = SCANNER_RANGE * 2 / 3; + /** * How wide of a police ship the smuggling course flies, in world units * (docs/TODO/208 M4). diff --git a/src/game/npc-state.ts b/src/game/npc-state.ts index c0b5a73a..6a78315f 100644 --- a/src/game/npc-state.ts +++ b/src/game/npc-state.ts @@ -130,6 +130,14 @@ export interface NpcState { observed: number; /** the escort or the scan verdict was sent once; it is never sent again */ missionReported: boolean; + /** + * A mission's charge waits, because the commander is beyond the leash + * (docs/TODO/214 M3). The world step decides it each frame, and the + * working life reads it as a speed of zero. + */ + holding: boolean; + /** the console said the charge is holding, once */ + holdSaid: boolean; fleeing: boolean; /** where this ship is in its attack run — see break-off.ts */ attackPhase: AttackPhase; @@ -281,7 +289,7 @@ export function freshNpcState(maxEnergy: number): NpcState { tumbleAxis: randomDirection(new THREE.Vector3()), energy: maxEnergy, regenCarry: 0, alive: true, provoked: false, provokedByPlayer: false, missiles: 0, - missionTag: null, targeted: false, announcedClose: false, observed: 0, missionReported: false, fleeing: false, attackPhase: 'closing', underFire: 0, calm: 0, flownBy: 'none', + missionTag: null, targeted: false, announcedClose: false, observed: 0, missionReported: false, holding: false, holdSaid: false, fleeing: false, attackPhase: 'closing', underFire: 0, calm: 0, flownBy: 'none', extendRange: EXTEND_RANGE_MAX, passSide: 1, passesMade: 0, tactic: 'run', tacticClock: 0, dryFor: 0, tradeTimer: 0, diff --git a/src/game/trader-flight.ts b/src/game/trader-flight.ts index 406666c1..a32b8edd 100644 --- a/src/game/trader-flight.ts +++ b/src/game/trader-flight.ts @@ -51,6 +51,8 @@ export interface TraderState { waypointTimer: number; /** Seconds of business left at the station. */ tradeTimer: number; + /** a mission's charge waits for the commander, so its speed is zero (docs/TODO/214 M3) */ + holding: boolean; /** Decided at spawn: does this one have business at the station? */ docksHere: boolean; /** On final approach into the slot — the station must not shove it away. */ @@ -108,7 +110,7 @@ export function stepTrader(ship: TraderShip, dt: number, world: TraderWorld): vo switch (state.traderPhase) { case 'arriving': { steerToward(ship, home, dt); - state.speed = approach(state.speed, ship.maxSpeed * 0.85, 90 * dt); + state.speed = approach(state.speed, state.holding ? 0 : ship.maxSpeed * 0.85, 90 * dt); if (ship.object.position.distanceTo(home) < TRADER_ARRIVED) { state.traderPhase = 'trading'; } @@ -131,7 +133,7 @@ export function stepTrader(ship: TraderShip, dt: number, world: TraderWorld): vo .add(randomDirection(new THREE.Vector3()).multiplyScalar(600 + random() * 1200)); } steerToward(ship, state.waypoint, dt); - state.speed = approach(state.speed, ship.maxSpeed * 0.35, 60 * dt); + state.speed = approach(state.speed, state.holding ? 0 : ship.maxSpeed * 0.35, 60 * dt); if (state.tradeTimer <= 0) { // about half put in at the station; the rest jump out from here if (state.docksHere) { diff --git a/src/game/world-step.ts b/src/game/world-step.ts index 4f2f6270..fec8971a 100644 --- a/src/game/world-step.ts +++ b/src/game/world-step.ts @@ -85,6 +85,7 @@ import { applyMissions, runMissions, type MissionOutcome } from './mission-bridg import { scanSecondsFor } from '../missions/queries.ts'; import { DOCK_COMPUTER_RANGE } from '../constants/docking-computer.ts'; import { ESCORT_ENEMY_ROLES, WATCH_CONE } from '../constants/missions.ts'; +import { ESCORT_LEASH } from '../constants/mission-course.ts'; import { SCANNER_RANGE } from '../constants/console.ts'; import { random, randomInt, randomDirection } from './rng.ts'; import type { GameState } from './state.ts'; @@ -650,9 +651,13 @@ export class WorldStep { * The two verdicts only the world can give (docs/TODO/190 M4). * * An ESCORT is safe when its ship is alive, inside `DOCK_COMPUTER_RANGE` of - * the station, and no enemy is inside that same radius of it. All three at - * once, and it is sent ONCE. `missionReported` latches, so a fight after - * the fee cannot undo it. The ship goes on to dock as any trader does. + * the station. The commander must be inside that radius of it, and no + * enemy may be. All four at once, and it is sent ONCE. + * `missionReported` latches, so a fight after the fee cannot undo it. The + * ship goes on to dock as any trader does. The commander's own place was + * not measured until docs/TODO/214 M3, and the escort was a job she + * watched. The charge also HOLDS for her beyond `ESCORT_LEASH`, and the + * console says so once. * * A SCAN counts the seconds a tagged ship spends under the scanner lock, * and sends `scanned` when the leg's seconds are up, once. @@ -693,7 +698,14 @@ export class WorldStep { continue; } const at = npc.object.position; + const away = player.position.distanceTo(at); + npc.state.holding = away > ESCORT_LEASH; + if (npc.state.holding && !npc.state.holdSaid) { + npc.state.holdSaid = true; + out.push(say(`THE ${npc.object.name.toUpperCase()} IS HOLDING FOR YOU. STAY WITH IT.`, 4)); + } if (at.distanceTo(world.station.position) > DOCK_COMPUTER_RANGE) continue; + if (away > DOCK_COMPUTER_RANGE) continue; const threatened = world.npcs.some((other) => other !== npc && other.state.alive && ESCORT_ENEMY_ROLES.includes(other.role) && other.object.position.distanceTo(at) <= DOCK_COMPUTER_RANGE); if (threatened) continue; diff --git a/src/missions/skeletons/arcs/edle.ts b/src/missions/skeletons/arcs/edle.ts index 09a41a39..50936852 100644 --- a/src/missions/skeletons/arcs/edle.ts +++ b/src/missions/skeletons/arcs/edle.ts @@ -15,7 +15,7 @@ import { ARC_LEG_DAYS, ARC_PAY, SIDE_JOB_RANGE } from '../../../constants/missio import { SOURCE_DESIGN } from '../../../game/ship-specs.ts'; import { shipDesignIdOf } from '../../../game/ship-identity.ts'; import type { Skeleton } from '../../model.ts'; -import { PAIR, wingmanOf } from '../lane.ts'; +import { LANE_PIRATES, PAIR, wingmanOf } from '../lane.ts'; const AWAY = { kind: 'band', ...SIDE_JOB_RANGE } as const; @@ -37,7 +37,7 @@ export const ARC_EDLE: Skeleton = { ], }, { - id: 'guard', verb: { kind: 'escort', ship: shipDesignIdOf(SOURCE_DESIGN.transporter) }, place: AWAY, + id: 'guard', verb: { kind: 'escort', ship: shipDesignIdOf(SOURCE_DESIGN.transporter) }, place: AWAY, spawn: [...LANE_PIRATES], line: 'COLONEL: SEE THE TRANSPORTER INTO STATION RANGE AT {TARGET}', deadlineDays: ARC_LEG_DAYS, next: [ { on: 'success', to: 'purge', settle: { pay: ARC_PAY.escort, say: 'TRANSPORTER SAFE — {PAY}. NOW THE ASP, NEAR {TARGET}.' } }, diff --git a/src/missions/skeletons/arcs/rabedira.ts b/src/missions/skeletons/arcs/rabedira.ts index fe662636..26d3b59f 100644 --- a/src/missions/skeletons/arcs/rabedira.ts +++ b/src/missions/skeletons/arcs/rabedira.ts @@ -13,7 +13,7 @@ import { ARC_HANDOVER_JUMPS, ARC_LEG_DAYS, ARC_PAY, SIDE_JOB_RANGE } from '../.. import { SOURCE_DESIGN } from '../../../game/ship-specs.ts'; import { shipDesignIdOf } from '../../../game/ship-identity.ts'; import type { Skeleton } from '../../model.ts'; -import { PAIR } from '../lane.ts'; +import { LANE_PIRATES, PAIR } from '../lane.ts'; const TOWARD = { kind: 'handover', toward: 'arc-vetitice', ...ARC_HANDOVER_JUMPS } as const; @@ -35,7 +35,7 @@ export const ARC_RABEDIRA: Skeleton = { ], }, { - id: 'convoy', verb: { kind: 'escort', ship: shipDesignIdOf(SOURCE_DESIGN.boa) }, place: TOWARD, + id: 'convoy', verb: { kind: 'escort', ship: shipDesignIdOf(SOURCE_DESIGN.boa) }, place: TOWARD, spawn: [...LANE_PIRATES], line: 'ENVOY: SEE THE BOA INTO STATION RANGE AT {TARGET}', deadlineDays: ARC_LEG_DAYS, next: [ { on: 'success', to: 'complete', settle: { pay: ARC_PAY.escort, say: 'THE ENVOY IS SAFE — {PAY} FROM RABEDIRA' } }, diff --git a/src/missions/skeletons/side.ts b/src/missions/skeletons/side.ts index d116a026..ccfc273f 100644 --- a/src/missions/skeletons/side.ts +++ b/src/missions/skeletons/side.ts @@ -159,7 +159,7 @@ export const SIDE_ESCORT: Skeleton = { pitch: 'A PYTHON IS LEAVING FOR A NEIGHBOUR AND WANTS A GUN BESIDE HER. SEE HER INTO STATION RANGE.', offer: {}, legs: [{ - id: 'cover', verb: { kind: 'escort', ship: shipDesignIdOf(SOURCE_DESIGN.python) }, place: AWAY, + id: 'cover', verb: { kind: 'escort', ship: shipDesignIdOf(SOURCE_DESIGN.python) }, place: AWAY, spawn: [...PAIR], line: 'ESCORT: SEE THE PYTHON INTO STATION RANGE AT {TARGET}', deadlineDays: SIDE_JOB_DAYS, next: [ { on: 'success', to: 'complete', settle: { pay: SIDE_JOB_PAY.escort, say: 'THE PYTHON IS SAFE IN STATION RANGE. THE STATION PAYS {PAY}.' } }, diff --git a/test/fixtures.ts b/test/fixtures.ts index 64d3489f..e04f9a73 100644 --- a/test/fixtures.ts +++ b/test/fixtures.ts @@ -17,7 +17,9 @@ import { makeRng } from '../src/game/rng.ts'; import { FIXED_DT } from '../src/constants/world-clock.ts'; import { CONSTRICTOR_SPEC } from '../src/game/ship-specs.ts'; import { emptyMissionState } from '../src/missions/state.ts'; -import type { MissionState } from '../src/missions/model.ts'; +import type { CommanderFacts, MissionEffect, MissionState, Skeleton } from '../src/missions/model.ts'; +import { stepMissions, type MissionContext } from '../src/missions/machine.ts'; +import { canAccept } from '../src/missions/offers.ts'; /** * Galaxy 1: the canonical universe, and the most-shared fixture in the suite. @@ -93,3 +95,33 @@ export function constrictorAt( } return st; } + +// --- a commander on a side job, for the verb and the company tests ---------- +// +// They lived in test/mission-verbs.test.ts until docs/TODO/214 M3 pushed it +// over the size ceiling, and test/mission-company.test.ts needs the same +// four. A second copy would be two fixtures that drift. + +/** The facts a mission rule reads, at Lave with scoops fitted, unless `over` says otherwise. */ +export const facts = (over: Partial = {}): CommanderFacts => ({ + galaxy: 1, systemIndex: 7, kills: 0, combatScore: 0, legalStatus: 0, scoops: true, day: 0, cargo: [], ...over, +}); + +/** What a step paid, in tenths. */ +export const paid = (effects: MissionEffect[]): number => + effects.reduce((sum, e) => sum + (e.kind === 'pay' ? e.tenths : 0), 0); + +/** A world whose board carries `job`, and a context standing there. */ +export function boardFor(job: Skeleton, over: Partial = {}): MissionContext { + const world = g1.find((s) => canAccept(emptyMissionState(), job.id, + { commander: facts({ systemIndex: s.index }), skeletons: [job], systems: g1 }))!; + return { commander: facts({ systemIndex: world.index, ...over }), systems: g1, rng: () => 0.5, skeletons: [job] }; +} + +/** The same context, moved to another world. */ +export const moved = (ctx: MissionContext, systemIndex: number, over: Partial = {}): MissionContext => + ({ ...ctx, commander: { ...ctx.commander, systemIndex, ...over } }); + +/** The record after `job` is accepted in `ctx`. */ +export const accept = (job: Skeleton, ctx: MissionContext): MissionState => + stepMissions(emptyMissionState(), { kind: 'accept', skeleton: job.id }, ctx).state; diff --git a/test/mission-company.test.ts b/test/mission-company.test.ts new file mode 100644 index 00000000..b59e61de --- /dev/null +++ b/test/mission-company.test.ts @@ -0,0 +1,94 @@ +// The company a job keeps: the pirates on a lane, the ones that wait at the +// jump-in, the pair beside a charge, and the ambush a scoop springs +// (docs/TODO/203 M2, docs/TODO/214). +// +// Every one of them is scenery with a gun. The tags answer nothing in the +// machine, and a kill among them settles no branch. These blocks read what a +// leg asks the arrival and the scoop to spawn. The real-game half, where the +// ships appear in the sky, is test/mission-courses.test.ts. +// +// They left test/mission-verbs.test.ts when docs/TODO/214 M3 pushed it over +// the size ceiling. + +import { stepMissions, type MissionContext } from '../src/missions/machine.ts'; +import { missionSpawns } from '../src/missions/queries.ts'; +import type { MissionEffect } from '../src/missions/model.ts'; +import { + SIDE_AMBUSH, SIDE_DELIVER, SIDE_ESCORT, SIDE_HUNT, SIDE_RECOVER, SIDE_RESCUE, SIDE_SCAN, +} from '../src/missions/skeletons/side.ts'; +import { LANE_PIRATES } from '../src/missions/skeletons/lane.ts'; +import { ESCORT_LEASH } from '../src/constants/mission-course.ts'; +import { accept, boardFor, facts, g1, moved } from './fixtures.ts'; +import { check, eq } from './harness.ts'; + +console.log('\npirates wait at the jump-in (docs/TODO/214 M1)'); +{ + // Chris, 2026-09-13: "there are pirates waiting for you when you jump in". + const hctx = boardFor(SIDE_HUNT); + const hst = accept(SIDE_HUNT, hctx); + const at = missionSpawns(hst, hst.live[0].target as number); + eq('a side hunt spawns the Krait and a wingman', at.length, 2); + check('...both flown as pirates', at.every((s) => s.job === 'hunt')); + check('...and only the target answers to the leg', at.filter((s) => s.tag === hst.live[0].tag).length === 1); + const dctx = boardFor(SIDE_DELIVER); + const dst = accept(SIDE_DELIVER, dctx); + eq('a delivery meets a pair at the far end', missionSpawns(dst, dst.live[0].target as number).length, 2); + eq('...and nothing at the world it was taken at', missionSpawns(dst, dctx.commander.systemIndex).length, 0); + const rctx = boardFor(SIDE_RECOVER); + const rst = accept(SIDE_RECOVER, rctx); + eq('a canister adrift has one Krait circling it', missionSpawns(rst, rst.live[0].target as number).length, 1); + const sctx = boardFor(SIDE_SCAN); + const sst = accept(SIDE_SCAN, sctx); + eq('a scan meets nobody but its subject', missionSpawns(sst, sst.live[0].target as number).length, 1); +} + +console.log('\nan escort keeps company (docs/TODO/214 M3)'); +{ + const ectx = boardFor(SIDE_ESCORT); + const est = accept(SIDE_ESCORT, ectx); + const at = missionSpawns(est, est.live[0].target as number); + eq('a side escort meets the charge and a pair', at.length, 3); + eq('...one of them the charge, flown as an escort', at.filter((s) => s.job === 'escort').length, 1); + check('the leash is outside the escort standoff and inside the scanner', ESCORT_LEASH > 600 && ESCORT_LEASH < 6000); +} + +console.log('\na scoop springs an ambush, and so does the end of a scan (docs/TODO/214 M2)'); +{ + // Chris, 2026-09-13: "collecting a canister triggers an ambush". + const spawned = (effects: MissionEffect[]): number => + effects.reduce((n, e) => n + (e.kind === 'spawn' ? e.ships.length : 0), 0); + const rctx = boardFor(SIDE_RECOVER); + const rst = accept(SIDE_RECOVER, rctx); + const scooped = stepMissions(rst, { kind: 'scooped', tag: rst.live[0].tag as string }, moved(rctx, rst.live[0].target as number)); + eq('the canister scooped asks the game for the pair', spawned(scooped.effects), 2); + check('...and says so, behind the leg\'s own line', + scooped.effects.some((e) => e.kind === 'later' && e.text === SIDE_RECOVER.legs[0].ambush?.say)); + eq('...and the leg still moved on', scooped.state.live[0]?.leg, 'home'); + const pctx = boardFor(SIDE_RESCUE); + const pst = accept(SIDE_RESCUE, pctx); + eq('the pod scooped asks for the Krait', + spawned(stepMissions(pst, { kind: 'scooped', tag: pst.live[0].tag as string }, moved(pctx, pst.live[0].target as number)).effects), 1); + const sctx = boardFor(SIDE_SCAN); + const sst = accept(SIDE_SCAN, sctx); + eq('the scan done asks for the escort', spawned(stepMissions(sst, { kind: 'scanned', tag: sst.live[0].tag as string }, sctx).effects), 2); + eq('...and a subject destroyed springs nothing', + spawned(stepMissions(sst, { kind: 'destroyed', tag: sst.live[0].tag as string }, sctx).effects), 0); + const dctx = boardFor(SIDE_DELIVER); + const dst = accept(SIDE_DELIVER, dctx); + eq('a delivery has no ambush to spring', + spawned(stepMissions(dst, { kind: 'docked' }, moved(dctx, dst.live[0].target as number)).effects), 0); +} + +console.log('\nambush: the lane has pirates while the leg is live (docs/TODO/203 M2)'); +{ + const ctx: MissionContext = { commander: facts(), systems: g1, rng: () => 0.5, skeletons: [SIDE_AMBUSH] }; + const st = accept(SIDE_AMBUSH, ctx); + const target = st.live[0].target as number; + eq('the lane job spawns the lane pirates at its world', + JSON.stringify(missionSpawns(st, target, [SIDE_AMBUSH])), JSON.stringify(LANE_PIRATES)); + check('...all flown as pirates', LANE_PIRATES.every((p) => p.job === 'hunt')); + eq('...and none anywhere else', missionSpawns(st, (target + 1) % g1.length, [SIDE_AMBUSH]).length, 0); + const done = stepMissions(stepMissions(st, { kind: 'arrived' }, { ...ctx, commander: facts({ systemIndex: target }) }).state, + { kind: 'docked' }, { ...ctx, commander: facts({ systemIndex: target }) }).state; + eq('...and they are gone once the lane is cleared', missionSpawns(done, target, [SIDE_AMBUSH]).length, 0); +} diff --git a/test/mission-courses.test.ts b/test/mission-courses.test.ts index 1e33cbe8..bc397450 100644 --- a/test/mission-courses.test.ts +++ b/test/mission-courses.test.ts @@ -18,7 +18,7 @@ import { runMissions } from '../src/game/mission-bridge.ts'; import { missionCourse } from '../src/game/mission-course.ts'; import { clearOfPolice } from '../src/game/course-clearance.ts'; import { SCAN_RANGE } from '../src/constants/law.ts'; -import { COURSE_ESCORT_STANDOFF, COURSE_POLICE_CLEARANCE } from '../src/constants/mission-course.ts'; +import { COURSE_ESCORT_STANDOFF, COURSE_POLICE_CLEARANCE, ESCORT_LEASH } from '../src/constants/mission-course.ts'; import { TRADER_CALM_SECONDS } from '../src/constants/attack-run.ts'; import { COURSE_KEYS } from '../src/game/bindings.ts'; import { keymap } from '../src/engine/keymap.ts'; @@ -131,7 +131,11 @@ console.log('\nthe escort course does not ram its charge, and a grazed charge go // own at the standoff and overshot into the hull. A ram is a hit from the // commander, and a trader that is hit ran for the rest of its life. const g = onTheJob('side-escort', 20_260_947); - const charge = g.state.world.npcs.find((n) => n.state.missionTag !== null); + // The charge alone: the pair that flies with it since 214 M1 would start + // a fight, and the approach is the subject. + const live = g.state.commander.missions.live[0]; + for (const n of g.state.world.npcs) if (n.state.missionTag !== live.tag) n.state.alive = false; + const charge = g.state.world.npcs.find((n) => n.state.missionTag === live.tag); if (!charge) throw new Error('the escort spawned no charge'); const shields = g.state.sys.foreShield; let nearest = Infinity; @@ -151,6 +155,24 @@ console.log('\nthe escort course does not ram its charge, and a grazed charge go eq('...on its way to the station', charge.state.traderPhase, 'arriving'); } +console.log('\nthe charge holds for a commander who falls behind (docs/TODO/214 M3)'); +{ + const g = onTheJob('side-escort', 20_260_949); + const live = g.state.commander.missions.live[0]; + for (const n of g.state.world.npcs) if (n.state.missionTag !== live.tag) n.state.alive = false; + const charge = g.state.world.npcs.find((n) => n.state.missionTag === live.tag); + if (!charge) throw new Error('the escort spawned no charge'); + // Beyond the leash, with no course picked: she is not coming. + charge.object.position.copy(g.state.player.position).add(new THREE.Vector3(0, 0, -(ESCORT_LEASH + 1000))); + const before = charge.object.position.clone(); + withoutSaving(() => { for (let f = 0; f < 10 * 60; f++) g.step(1 / 60, 100 + f / 60); }); + check('ten seconds on, the charge has held its place', + charge.object.position.distanceTo(before) < 200, `${Math.round(charge.object.position.distanceTo(before))} units`); + check('...and says so', charge.state.holding && charge.state.holdSaid); + const took = fly(g, 120, () => !charge.state.holding); + check('...until the escort course brings her inside the leash', !charge.state.holding, `after ${took.toFixed(0)}s`); +} + console.log('\nthe canister scooped springs its ambush in the sky (docs/TODO/214 M2)'); { const g = onTheJob('side-recover', 20_260_948); diff --git a/test/mission-verbs.test.ts b/test/mission-verbs.test.ts index 32e0c606..de0f98aa 100644 --- a/test/mission-verbs.test.ts +++ b/test/mission-verbs.test.ts @@ -7,10 +7,9 @@ import { stepMissions } from '../src/missions/machine.ts'; import type { MissionContext } from '../src/missions/machine.ts'; -import { canAccept } from '../src/missions/offers.ts'; import { missionItems, missionSpawns, scanSecondsFor } from '../src/missions/queries.ts'; import { emptyMissionState } from '../src/missions/state.ts'; -import type { CommanderFacts, MissionEffect, MissionState, Skeleton } from '../src/missions/model.ts'; +import type { MissionEffect, MissionState, Skeleton } from '../src/missions/model.ts'; import { SIDE_DELIVER, SIDE_ESCORT, SIDE_HUNT, SIDE_RECOVER, SIDE_RESCUE, SIDE_SCAN, SIDE_SMUGGLE, } from '../src/missions/skeletons/side.ts'; @@ -26,25 +25,8 @@ import { seedWorld } from '../src/game/rng.ts'; import { parseSnapshot } from '../src/game/snapshot-parse.ts'; import { g1 } from './fixtures.ts'; import { SIDE_AMBUSH } from '../src/missions/skeletons/side.ts'; -import { LANE_PIRATES } from '../src/missions/skeletons/lane.ts'; import { check, dismissBriefing, eq } from './harness.ts'; - -const facts = (over: Partial = {}): CommanderFacts => ({ - galaxy: 1, systemIndex: 7, kills: 0, combatScore: 0, legalStatus: 0, scoops: true, day: 0, cargo: [], ...over, -}); -const paid = (effects: MissionEffect[]): number => - effects.reduce((sum, e) => sum + (e.kind === 'pay' ? e.tenths : 0), 0); - -/** A world whose board carries `job`, and a context standing there. */ -function boardFor(job: Skeleton, over: Partial = {}): MissionContext { - const world = g1.find((s) => canAccept(emptyMissionState(), job.id, - { commander: facts({ systemIndex: s.index }), skeletons: [job], systems: g1 }))!; - return { commander: facts({ systemIndex: world.index, ...over }), systems: g1, rng: () => 0.5, skeletons: [job] }; -} -const moved = (ctx: MissionContext, systemIndex: number, over: Partial = {}): MissionContext => - ({ ...ctx, commander: { ...ctx.commander, systemIndex, ...over } }); -const accept = (job: Skeleton, ctx: MissionContext): MissionState => - stepMissions(emptyMissionState(), { kind: 'accept', skeleton: job.id }, ctx).state; +import { accept, boardFor, facts, moved, paid } from './fixtures.ts'; console.log('\nrecover: a canister adrift, scooped and brought home'); { @@ -157,54 +139,6 @@ console.log('\nsmuggle: the goods go aboard, and the patrol is the risk'); eq('a police scan on the way fails it', read.state.done[SIDE_SMUGGLE.id], 'fail'); } -console.log('\npirates wait at the jump-in (docs/TODO/214 M1)'); -{ - // Chris, 2026-09-13: "there are pirates waiting for you when you jump in". - const hctx = boardFor(SIDE_HUNT); - const hst = accept(SIDE_HUNT, hctx); - const at = missionSpawns(hst, hst.live[0].target as number); - eq('a side hunt spawns the Krait and a wingman', at.length, 2); - check('...both flown as pirates', at.every((s) => s.job === 'hunt')); - check('...and only the target answers to the leg', at.filter((s) => s.tag === hst.live[0].tag).length === 1); - const dctx = boardFor(SIDE_DELIVER); - const dst = accept(SIDE_DELIVER, dctx); - eq('a delivery meets a pair at the far end', missionSpawns(dst, dst.live[0].target as number).length, 2); - eq('...and nothing at the world it was taken at', missionSpawns(dst, dctx.commander.systemIndex).length, 0); - const rctx = boardFor(SIDE_RECOVER); - const rst = accept(SIDE_RECOVER, rctx); - eq('a canister adrift has one Krait circling it', missionSpawns(rst, rst.live[0].target as number).length, 1); - const sctx = boardFor(SIDE_SCAN); - const sst = accept(SIDE_SCAN, sctx); - eq('a scan meets nobody but its subject', missionSpawns(sst, sst.live[0].target as number).length, 1); -} - -console.log('\na scoop springs an ambush, and so does the end of a scan (docs/TODO/214 M2)'); -{ - // Chris, 2026-09-13: "collecting a canister triggers an ambush". - const spawned = (effects: MissionEffect[]): number => - effects.reduce((n, e) => n + (e.kind === 'spawn' ? e.ships.length : 0), 0); - const rctx = boardFor(SIDE_RECOVER); - const rst = accept(SIDE_RECOVER, rctx); - const scooped = stepMissions(rst, { kind: 'scooped', tag: rst.live[0].tag as string }, moved(rctx, rst.live[0].target as number)); - eq('the canister scooped asks the game for the pair', spawned(scooped.effects), 2); - check('...and says so, behind the leg\'s own line', - scooped.effects.some((e) => e.kind === 'later' && e.text === SIDE_RECOVER.legs[0].ambush?.say)); - eq('...and the leg still moved on', scooped.state.live[0]?.leg, 'home'); - const pctx = boardFor(SIDE_RESCUE); - const pst = accept(SIDE_RESCUE, pctx); - eq('the pod scooped asks for the Krait', - spawned(stepMissions(pst, { kind: 'scooped', tag: pst.live[0].tag as string }, moved(pctx, pst.live[0].target as number)).effects), 1); - const sctx = boardFor(SIDE_SCAN); - const sst = accept(SIDE_SCAN, sctx); - eq('the scan done asks for the escort', spawned(stepMissions(sst, { kind: 'scanned', tag: sst.live[0].tag as string }, sctx).effects), 2); - eq('...and a subject destroyed springs nothing', - spawned(stepMissions(sst, { kind: 'destroyed', tag: sst.live[0].tag as string }, sctx).effects), 0); - const dctx = boardFor(SIDE_DELIVER); - const dst = accept(SIDE_DELIVER, dctx); - eq('a delivery has no ambush to spring', - spawned(stepMissions(dst, { kind: 'docked' }, moved(dctx, dst.live[0].target as number)).effects), 0); -} - console.log('\na local patron\'s standing is keyed by the world the job was taken at (docs/TODO/213 M4)'); { // A delivery accepted at one world and landed at another credited the far @@ -225,7 +159,7 @@ console.log('\nescort and scan, through the machine'); const st = accept(SIDE_ESCORT, ctx); const tag = st.live[0].tag as string; const target = st.live[0].target as number; - eq('the charge is spawned as an escort', missionSpawns(st, target)[0]?.job, 'escort'); + eq('the charge is spawned as an escort', missionSpawns(st, target).find((s) => s.tag === tag)?.job, 'escort'); const stranger = stepMissions(st, { kind: 'escortSafe', tag: 'somebody-else' }, moved(ctx, target)); eq('another ship safe pays nothing', paid(stranger.effects), 0); const safe = stepMissions(st, { kind: 'escortSafe', tag }, moved(ctx, target)); @@ -311,8 +245,15 @@ console.log('\nescort, through a real world step'); step(g); eq('just outside station range nothing is paid', c.credits, before); charge.object.position.copy(station).add({ x: DOCK_COMPUTER_RANGE - 50, y: 0, z: 0 } as never); + // The commander is at the witchpoint, far from her charge (docs/TODO/214 + // M3). The fee needs her there, and the charge holds for her. + step(g); + eq('...and inside it with the commander far away, still nothing', c.credits, before); + check('...and the charge holds for her', charge.state.holding); const pirate = g.state.world.spawn('pirate', charge.object.position.clone().add({ x: 200, y: 0, z: 0 } as never), 1); + g.state.player.position.copy(charge.object.position).add({ x: 0, y: 300, z: 0 } as never); step(g); + check('with the commander beside it, the charge moves again', !charge.state.holding); eq('...and inside it with a pirate beside her, still nothing', c.credits, before); const trader = g.state.world.spawn('trader', charge.object.position.clone().add({ x: -200, y: 0, z: 0 } as never), 2); g.state.world.despawn(pirate); @@ -357,20 +298,6 @@ console.log('\nthe survivors prompt counts a passenger, and the loader keeps the parseSnapshot(old as never).canisters.length === snap.canisters.length); } -console.log('\nambush: the lane has pirates while the leg is live (docs/TODO/203 M2)'); -{ - const ctx: MissionContext = { commander: facts(), systems: g1, rng: () => 0.5, skeletons: [SIDE_AMBUSH] }; - const st = accept(SIDE_AMBUSH, ctx); - const target = st.live[0].target as number; - eq('the lane job spawns the lane pirates at its world', - JSON.stringify(missionSpawns(st, target, [SIDE_AMBUSH])), JSON.stringify(LANE_PIRATES)); - check('...all flown as pirates', LANE_PIRATES.every((p) => p.job === 'hunt')); - eq('...and none anywhere else', missionSpawns(st, (target + 1) % g1.length, [SIDE_AMBUSH]).length, 0); - const done = stepMissions(stepMissions(st, { kind: 'arrived' }, { ...ctx, commander: facts({ systemIndex: target }) }).state, - { kind: 'docked' }, { ...ctx, commander: facts({ systemIndex: target }) }).state; - eq('...and they are gone once the lane is cleared', missionSpawns(done, target, [SIDE_AMBUSH]).length, 0); -} - console.log('\na step that takes no branch still speaks (docs/TODO/203 M4)'); { const said = (effects: MissionEffect[]): string[] => effects.flatMap((e) => (e.kind === 'say' ? [e.text] : [])); diff --git a/test/npc-trader.test.ts b/test/npc-trader.test.ts index 1150a0f6..502b47f0 100644 --- a/test/npc-trader.test.ts +++ b/test/npc-trader.test.ts @@ -157,4 +157,17 @@ console.log('a trader, flown off an object literal'); traderBehaviour().fly(hunted, DT, commander, view); check('...and so does one that is still hunted, however calm', hunted.state.fleeing); } + + // 4. A CHARGE THAT HOLDS FOR THE COMMANDER slows to a stop, and goes on + // when she is back (docs/TODO/214 M3). + { + const held = ship(false); + held.state.traderPhase = 'arriving'; + held.state.holding = true; + for (let f = 0; f < 60; f++) traderBehaviour().fly(held, DT, commander, view); + check('a holding trader slows to a stop', held.state.speed < 1, `${held.state.speed.toFixed(1)} u/s`); + held.state.holding = false; + for (let f = 0; f < 60; f++) traderBehaviour().fly(held, DT, commander, view); + check('...and moves again once the hold lifts', held.state.speed > 30, `${held.state.speed.toFixed(1)} u/s`); + } } diff --git a/test/run.ts b/test/run.ts index a9d2bf23..26f4c882 100644 --- a/test/run.ts +++ b/test/run.ts @@ -53,6 +53,7 @@ import './mission-skeletons.test.ts'; import './mission-game.test.ts'; import './mission-offers.test.ts'; import './mission-verbs.test.ts'; +import './mission-company.test.ts'; import './mission-arrival.test.ts'; import './scan-watch.test.ts'; import './mission-story.test.ts'; diff --git a/test/trader-flight.test.ts b/test/trader-flight.test.ts index 16007d9e..0c41554d 100644 --- a/test/trader-flight.test.ts +++ b/test/trader-flight.test.ts @@ -80,6 +80,7 @@ console.log('\nthe four phases of a trader, off an object literal'); turnRate: 1.2, state: { traderPhase: phase, + holding: false, speed: 0, waypoint: new THREE.Vector3(), waypointTimer: 0, From 75fb94d5d8339f03a22055d8f420706c31993b68 Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Sun, 13 Sep 2026 10:03:05 +0100 Subject: [PATCH 071/100] docs/TODO/214: the flight probe after the three surprises, and the index says where 214 stands The probe's output after M1 to M3 is committed beside the earlier runs. A side hunt takes 7 seconds, from 4, and an Asp hunt 24, from 12. The Asp pair killed a fresh commander in one run of eight. The escort finishes eight of eight with 1.5 fights on the way, from 0.3. A recover meets 2.9 fights on the way home, from 1.4. 214 stays on the queue: M4, the chase, needs a dossier regeneration. Co-Authored-By: Claude Fable 5.1 Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- docs/TODO/README.md | 3 +- .../flight-results-after-214.txt | 47 +++++++++++++++++++ 2 files changed, 49 insertions(+), 1 deletion(-) create mode 100644 docs/reviews/missions-2026-09-12/flight-results-after-214.txt diff --git a/docs/TODO/README.md b/docs/TODO/README.md index f614835f..a669e94b 100644 --- a/docs/TODO/README.md +++ b/docs/TODO/README.md @@ -22,7 +22,8 @@ and found the escort broken and the rest too easy. He said *"let's fix the broken parts"*, and then *"there should be surprises"*. 213 is the fixes. 214 is the surprises: an ambush on a scoop, pirates at the jump-in, and an escort that needs the commander. **213 landed the same day**, and it is -below. +below. **214 M1 to M3 landed the same day too.** M4, the chase, waits for +a dossier regeneration on Chris's machine, so 214 stays on the queue. **205 TO 208 CAME FROM CHRIS ON 2026-09-11, the day 204 landed.** He flew the touch controls of 204 on a phone, and he could not fly the ship. He diff --git a/docs/reviews/missions-2026-09-12/flight-results-after-214.txt b/docs/reviews/missions-2026-09-12/flight-results-after-214.txt new file mode 100644 index 00000000..b50430a5 --- /dev/null +++ b/docs/reviews/missions-2026-09-12/flight-results-after-214.txt @@ -0,0 +1,47 @@ +flight probe: 8 seeds per case, ordinary traffic in the sky + +side-hunt: a Krait, pulse laser + done 8 failed 0 dead 0 timeout 0 of 8 | time to done: mean 7 s, worst 14 s | fights per run 1.0 | kills 11 | wall 0 s + per seed: d4 d5 d4 d14 d4 d4 d13 d8 | ship after: energy 254, shields 253/250 | station 72,591 units from the witchpoint +arc-lave runner: a Cobra Mk III, pulse laser + done 8 failed 0 dead 0 timeout 0 of 8 | time to done: mean 10 s, worst 14 s | fights per run 1.0 | kills 15 | wall 0 s + per seed: d11 d12 d11 d14 d11 d10 d5 d11 | ship after: energy 254, shields 250/164 | station 63,792 units from the witchpoint +arc-xeer chase: a Fer-de-Lance, pulse laser + done 8 failed 0 dead 0 timeout 0 of 8 | time to done: mean 16 s, worst 22 s | fights per run 1.0 | kills 13 | wall 0 s + per seed: d14 d21 d19 d16 d22 d15 d8 d16 | ship after: energy 225, shields 156/195 | station 63,949 units from the witchpoint +arc-edle purge: an Asp, pulse laser + done 7 failed 0 dead 1 timeout 0 of 8 | time to done: mean 24 s, worst 28 s | fights per run 1.0 | kills 14 | wall 0 s + per seed: d28 d28 d24 d27 d23 d28 d12 d16 | ship after: energy 88, shields 34/235 | station 64,041 units from the witchpoint +constrictor hunt, pulse laser + done 8 failed 0 dead 0 timeout 0 of 8 | time to done: mean 62 s, worst 66 s | fights per run 1.0 | kills 8 | wall 0 s + per seed: d64 d63 d60 d59 d64 d61 d66 d57 | ship after: energy 213, shields 130/219 | station 64,405 units from the witchpoint +side-scan: an Anaconda for 20 s + done 8 failed 0 dead 0 timeout 0 of 8 | time to done: mean 24 s, worst 27 s | fights per run 0.1 | kills 1 | wall 0 s + per seed: d25 d23 d23 d23 d27 d22 d27 d21 | ship after: energy 255, shields 255/255 | station 69,173 units from the witchpoint +side-escort: a Python to station range + done 8 failed 0 dead 0 timeout 0 of 8 | time to done: mean 500 s, worst 535 s | fights per run 1.5 | kills 24 | wall 2 s + per seed: d535 d489 d491 d518 d484 d489 d492 d506 | ship after: energy 239, shields 225/255 | station 74,065 units from the witchpoint +side-recover: scoop a canister (scoops fitted) + done 8 failed 0 dead 0 timeout 0 of 8 | time to done: mean 21 s, worst 37 s | fights per run 1.0 | kills 11 | wall 0 s + per seed: d37 d18 d18 d16 d25 d12 d29 d15 | ship after: energy 255, shields 255/255 | station 63,823 units from the witchpoint +side-rescue: scoop a pod (scoops fitted) + done 8 failed 0 dead 0 timeout 0 of 8 | time to done: mean 13 s, worst 26 s | fights per run 0.1 | kills 1 | wall 0 s + per seed: d8 d18 d13 d10 d13 d6 d26 d8 | ship after: energy 255, shields 255/255 | station 81,801 units from the witchpoint +side-recover: scoop, then fly home and dock (docking computer) + done 8 failed 0 dead 0 timeout 0 of 8 | time to done: mean 149 s, worst 185 s | fights per run 2.9 | kills 27 | wall 1 s + per seed: d179 d140 d141 d185 d156 d134 d116 d141 | ship after: energy 255, shields 255/255 | station 63,823 units from the witchpoint +side-rescue: scoop, then dock (docking computer) + done 8 failed 0 dead 0 timeout 0 of 8 | time to done: mean 144 s, worst 163 s | fights per run 1.4 | kills 11 | wall 1 s + per seed: d133 d142 d152 d122 d144 d162 d163 d134 | ship after: energy 255, shields 255/255 | station 81,801 units from the witchpoint +side-ambush: the lane, then dock (docking computer) + done 8 failed 0 dead 0 timeout 0 of 8 | time to done: mean 133 s, worst 150 s | fights per run 3.1 | kills 42 | wall 1 s + per seed: d122 d138 d131 d141 d143 d135 d106 d150 | ship after: energy 255, shields 255/255 | station 70,808 units from the witchpoint +side-deliver: fly to the station and dock (docking computer) + done 8 failed 0 dead 0 timeout 0 of 8 | time to done: mean 136 s, worst 151 s | fights per run 2.5 | kills 28 | wall 1 s + per seed: d123 d149 d150 d135 d132 d141 d151 d107 | ship after: energy 255, shields 255/255 | station 74,065 units from the witchpoint +side-smuggle: slip past the police and dock (docking computer) + done 8 failed 0 dead 0 timeout 0 of 8 | time to done: mean 116 s, worst 134 s | fights per run 2.6 | kills 27 | scanned 0 | wall 1 s + per seed: d117 d111 d98 d134 d123 d124 d104 d114 | ship after: energy 255, shields 255/255 | station 69,173 units from the witchpoint + +without fuel scoops, the scoop rows refuse: + side-recover row: "RECOVER THE CARGO" why: "NEEDS FUEL SCOOPS" From 12a3e2b8d73eaff01528d5773c4e3733e04c5c44 Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Sun, 13 Sep 2026 10:38:30 +0100 Subject: [PATCH 072/100] The target list is its own column, on the left Chris, 2026-09-13: "the buttons cover up the area where all the action is happening". The target list opened upward above the guns, bottom right, and the two together took the right side of the fight. The list is a third column now, bottom left, where the other thumb rests. `targetButtonsFor` builds it from the same source as the guns, the HUD paints a third strip, and the shell listens for taps on it. The pilot's column keeps the E.C.M., the missile and the laser. During the pilot's stretch into the slot the list is empty, as the guns are. Co-Authored-By: Claude Fable 5.1 Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- play.html | 15 +++++--- src/engine/browser-shell.ts | 5 +-- src/game/cockpit-buttons.ts | 70 +++++++++++++++++++++++-------------- src/game/cockpit-view.ts | 27 ++++++++++---- src/hud/hud-binding.ts | 3 ++ src/hud/hud.ts | 11 ++++-- src/style.css | 26 ++++++++------ test/console-plate.test.ts | 2 +- test/fight-buttons.test.ts | 11 +++++- 9 files changed, 117 insertions(+), 53 deletions(-) diff --git a/play.html b/play.html index ebd29059..590f40e6 100644 --- a/play.html +++ b/play.html @@ -36,10 +36,17 @@ -->
    +
    +
    - -
    +
    +
  • Dock. Line up with the rotating port and go in slowly. See Docking. It is the hardest thing you will do today.
    • @@ -142,8 +142,8 @@

    Controls

    right of the screen show where the ship can go next: the station, a derelict, the hermit, the star, the next jump. Click one, or tap it on a phone, and the ship flies there by itself. A dimmed button says - what you need before you can use it. FAST FORWARD makes the - trip quicker while nothing hostile is near. Touch a flight key at any + what you need before you can use it. The ▶▶ button makes + the trip quicker while nothing hostile is near. Touch a flight key at any time and you have the controls back.

    diff --git a/src/game/cockpit-buttons.ts b/src/game/cockpit-buttons.ts index 86b420b7..be02309d 100644 --- a/src/game/cockpit-buttons.ts +++ b/src/game/cockpit-buttons.ts @@ -33,7 +33,6 @@ import { COURSE_KEYS, COURSE_LIST_KEY, COURSE_SKIP_KEY, COURSE_STOP_KEY, TARGET_NONE_KEY, TARGETS_KEY, } from './bindings.ts'; import { keyCodeIfBound, keyIfBound } from '../ui/key-help.ts'; -import { SKIP_SPEED } from '../constants/course.ts'; import { LASER_RANGE } from '../constants/player-gun.ts'; /** A course as a button: its words, and what stops it, under them. */ @@ -229,15 +228,18 @@ export function gunButtonsFor(a: ActionSource): HudButton[] { /** The fast forward button, while a course flies (docs/TODO/205 M7). */ function skipButton(p: CoursePanel): HudButton | null { if (!p.skip) return null; - if (p.skip.on) { - return { code: COURSE_SKIP_KEY, label: 'FAST FORWARD IS ON', lit: true, hint: 'BACK TO NORMAL SPEED' }; - } + // An icon, and no words (Chris, 2026-09-13: "let's just have it as an + // icon", docs/TODO/221). Lit while it runs, dim while it cannot start, + // and the console says why on the press. return { - code: COURSE_SKIP_KEY, label: 'FAST FORWARD', - ...(p.skip.block === null ? { hint: `TIME RUNS ${SKIP_SPEED} TIMES FASTER` } : { note: p.skip.block }), + code: COURSE_SKIP_KEY, label: skipIcon, icon: true, + lit: p.skip.on, dim: !p.skip.on && p.skip.block !== null, }; } +/** Two arrows, the mark on every player since the tape deck. */ +const skipIcon = '\u25B6\u25B6'; + /** * The offers as buttons (docs/TODO/206 M5): what a key can do about the diff --git a/src/hud/hud-buttons.ts b/src/hud/hud-buttons.ts index 4ee21700..8c0ffcfc 100644 --- a/src/hud/hud-buttons.ts +++ b/src/hud/hud-buttons.ts @@ -22,6 +22,14 @@ export interface HudButton { readonly lit?: boolean; /** a second, quieter line: what a press does */ readonly hint?: string; + /** + * The button is an icon (docs/TODO/221): a glyph, small, and beside the + * header rather than under it. It carries no hint and no note. A refusal + * is said on the console when it is pressed, and `dim` shows it. + */ + readonly icon?: boolean; + /** the button refuses now, and says why on the console when it is pressed */ + readonly dim?: boolean; /** * The button holds its code down while it is held, as the laser button * does, rather than sending it once (`engine/hold-buttons.ts`). @@ -54,7 +62,7 @@ export class ButtonStrip { + `${text(b.label)}
    ` : `
    ` + + ` class="hud-button${b.note || b.dim ? ' dim' : ''}${b.lit ? ' lit' : ''}${b.icon ? ' icon' : ''}">` + `${text(b.label)}${b.note ? `${text(b.note)}` : ''}` + `${b.hint ? `${text(b.hint)}` : ''}
    `)).join(''); if (html === this.shown) return; diff --git a/src/style.css b/src/style.css index a3bac0aa..8ae4b66f 100644 --- a/src/style.css +++ b/src/style.css @@ -446,6 +446,11 @@ body.screen-open #message { #courses .hud-button.dim { opacity: 0.6; } #courses .hud-button .note { font-size: 10px; color: var(--hud-amber); letter-spacing: 1px; } #courses .hud-button .hint { font-size: 10px; color: var(--hud-dim); letter-spacing: 1px; } +/* An icon button sits small at the right, under the header (docs/TODO/221). */ +#courses .hud-button.icon { + align-self: flex-end; min-height: 30px; padding: 2px 12px; + font-size: 16px; letter-spacing: 2px; +} body.screen-open #courses { visibility: hidden; } /* diff --git a/src/ui/briefing.ts b/src/ui/briefing.ts index 1516f5ee..04584ffa 100644 --- a/src/ui/briefing.ts +++ b/src/ui/briefing.ts @@ -103,7 +103,7 @@ export const BRIEFING: { title: string; body: string }[] = [ the top right show where the ship can go. Choose FLY TO THE STATION and it flies there on the torus drive, at ${TORUS_MULTIPLIER} times speed. The drive cuts out near anything with mass: a planet, a - station, or somebody who has come to meet you. FAST FORWARD makes + station, or somebody who has come to meet you. The \u25B6\u25B6 button makes the trip quicker while nothing hostile is near.

    Watch the scanner in the middle of the console. You are the centre. Red contacts are hostile. Press a steering key at any time and you fly the diff --git a/test/course-buttons.test.ts b/test/course-buttons.test.ts index eb82a031..a349b0f0 100644 --- a/test/course-buttons.test.ts +++ b/test/course-buttons.test.ts @@ -57,8 +57,10 @@ function press(g: Game, code: string): void { press(g, COURSE_KEYS.station); eq('the station button picks the station course', g.state.session.course, 'station'); eq('...and the list folds away', g.coursePanel()?.rows ?? null, null); - eq('...leaving a button that says what the ship is doing, and fast forward', - courseButtonsFor(g.coursePanel()!).map((b) => b.label).join(), 'HEADING TO THE STATION,FAST FORWARD'); + eq('...leaving a button that says what the ship is doing, and the fast forward icon', + courseButtonsFor(g.coursePanel()!).map((b) => b.label).join(), 'HEADING TO THE STATION,\u25B6\u25B6'); + check('...which is an icon, with no words under it', courseButtonsFor(g.coursePanel()!)[1].icon === true + && courseButtonsFor(g.coursePanel()!)[1].hint === undefined); // A LIT BUTTON READS AS ON, SO A TAP TURNS IT OFF (Chris, 2026-09-12: *"I // think you should be able to click it to disengage it"*). It used to open diff --git a/test/key-help.test.ts b/test/key-help.test.ts index 07deeca9..3159aae6 100644 --- a/test/key-help.test.ts +++ b/test/key-help.test.ts @@ -315,7 +315,9 @@ console.log('\nthe briefing surfaces the whole first journey'); unquoted.length === 0, unquoted.join(', ')); // The fight is buttons too since docs/TODO/206, so the briefing names them // rather than the missile keys and the E.C.M. key. - const buttons = ['JUMP TO', 'FLY TO THE STATION', 'FAST FORWARD', + // The fast forward button is an icon since docs/TODO/221, so its glyph is + // what the briefing teaches. + const buttons = ['JUMP TO', 'FLY TO THE STATION', '\u25B6\u25B6', 'FIRE LASER', 'TARGETS', 'ARM A MISSILE', 'E.C.M.', 'RUN FOR IT']; const untaught = buttons.filter((b) => !text.includes(`${b}`)); check(`...and every button of the trip is named (${buttons.length})`, From de366c8acfb37f4dad7ba10329215a42fa960c1e Mon Sep 17 00:00:00 2001 From: Chris Greening Date: Sun, 13 Sep 2026 22:55:48 +0100 Subject: [PATCH 100/100] Plan 221 lands: the fast forward button is an icon The plan moves to the archive with what it found. The queue is empty. Co-Authored-By: Claude Fable 5.1 Claude-Session: https://claude.ai/code/session_01Cpi86XPSQzZQhVhRnZED58 --- docs/TODO/README.md | 4 ++ .../221-the-fast-forward-button-is-an-icon.md | 61 +++++++++++++++++++ docs/TODO/completed/README.md | 1 + 3 files changed, 66 insertions(+) create mode 100644 docs/TODO/completed/221-the-fast-forward-button-is-an-icon.md diff --git a/docs/TODO/README.md b/docs/TODO/README.md index fdab10a2..440c533d 100644 --- a/docs/TODO/README.md +++ b/docs/TODO/README.md @@ -15,6 +15,10 @@ active context: Nothing is queued. +**221 CAME FROM CHRIS ON 2026-09-13**, from his phone. The fast forward +button is a bar as wide as the course header. 221 makes it an icon. **221 +landed the same day**, and it is below. + **220 CAME FROM CHRIS ON 2026-09-13**, from his phone. A double tap or a pinch zooms the page. The address bar takes the top of the view, and the short range chart's names are too small. 220 fixes the three, and it went diff --git a/docs/TODO/completed/221-the-fast-forward-button-is-an-icon.md b/docs/TODO/completed/221-the-fast-forward-button-is-an-icon.md new file mode 100644 index 00000000..ad6d11ee --- /dev/null +++ b/docs/TODO/completed/221-the-fast-forward-button-is-an-icon.md @@ -0,0 +1,61 @@ +# 221 — The fast forward button is an icon + +**Kind:** fix · **Severity:** low · **Size:** small · **Depends on:** +nothing · **Blocks:** nothing · **GitHub:** none + +## Where we are + +Chris, 2026-09-13, from his phone: *"The fast forward button is very big - +let's just have it as an icon."* The button is a second header under the +course header while a course flies. It carries the words FAST FORWARD, a +hint under them, and the reason it cannot start when it cannot. On a phone +that is a bar as wide as the course header. + +## What to do + +One milestone. + +- A button can be an icon: a glyph, small, at the right under the header, + with no hint and no note. The painter gives it a class, and the + stylesheet its size. +- The fast forward button is two arrows. It is lit while it runs, and dim + while it cannot start. The console already says why on the press. +- The briefing and the manual name the icon where they named the words. + +## Decisions already made + +- **An icon, and no words** (Chris, 2026-09-13). + +## Open questions + +None. + +## Watch out for + +- **The briefing test lists the buttons it teaches by their words.** The + icon takes the words' place in that list. + +## Verification + +The gates always run: `npm run check`. + +Evidence: + +- A test reads the icon beside the course header, with no hint under it. +- Checked by eye in a 390 by 844 frame. + +## What the milestones found + +- **An icon is a button with two more flags**, `icon` and `dim`. The note + used to carry the refusal and dim the button at once. An icon has no + note, so `dim` says the button refuses, and the console says why. +- **The glyph is a lower-case name** in the buttons file, because the + constants gate reads an upper-case one as a rule. +- **The briefing test lists the buttons it teaches**, and the glyph took + the words' place in it. + +## Outcome + +Landed 2026-09-13, in one milestone. The fast forward button is two +arrows, small, under the course header, lit while it runs and dim while +it cannot start. 6,159 assertions. diff --git a/docs/TODO/completed/README.md b/docs/TODO/completed/README.md index 4b2416ab..e3989ece 100644 --- a/docs/TODO/completed/README.md +++ b/docs/TODO/completed/README.md @@ -225,6 +225,7 @@ Supporting records: [Elite-A alignment plan](ELITE-A-COMBAT-PLAN.md), - [x] 213 — [The mission rules hold, and a hit trader goes back to work](213-the-mission-rules-hold-and-a-hit-trader-goes-back-to-work.md) — Chris, 2026-09-13. Two reviews read the missions and flew every kind of job. **M1** makes a hit trader go back to work, and the escort ends. **M2** makes a side job come back, unloads a smuggling run, gates every arc to galaxy 1, and makes a scoop job wait for the scoops. **M3** keeps the gun warning for the Constrictor, and lets a lead's message through a board of side jobs. **M4** drops a ghost at the loader, gives the journal a galaxy, keys standing by the origin, and restores a mission ship under its leg's role. **M5** holds every trigger a verb can emit in the lint. 6,029 assertions. - [x] 215 — [The gun row lives in the console, and a list runs sideways](215-the-gun-row-lives-in-the-console-and-a-list-runs-sideways.md) — Chris, 2026-09-13. He flew the game on his phone, and three columns of buttons covered the fight. He drew the shape. **M1** puts the guns in a row at the bottom of the console, the missile as two buttons, and drops the missile squares. **M2** folds each list to a header, closed by default, that opens as one row that scrolls sideways, with one fold for both. **M3** says so in the manual. 6,072 assertions. - [x] 214 — [A job has a surprise in it](214-a-job-has-a-surprise-in-it.md) — Chris, 2026-09-13. He said the missions were too easy, and asked for surprises. **M1** puts pirates at the jump-in of every job that sends the commander somewhere. **M2** springs an ambush on a scoop and at a scan's end. **M3** makes the escort's charge hold for the commander, asks for her presence at the fee, and sends a pack for the charge. **M4** makes a hunt's target run when it is nearly dead, and measures that the run alone moves no number. 6,153 assertions. +- [x] 221 — [The fast forward button is an icon](221-the-fast-forward-button-is-an-icon.md) — Chris, 2026-09-13, from his phone. The button was a bar as wide as the course header. It is two arrows now, small, under the header, lit while it runs and dim while it cannot start. 6,159 assertions. - [x] 219 — [The Dark Wheel comes for a commander](219-the-dark-wheel-comes-for-a-commander.md) — Chris, 2026-09-13. A secret society at the higher ratings, with the old names. **M1** makes the Wheel a patron with no world, on the lawless boards, with the mark at Above Average. **M2** flies police as company and puts a parcel past three Vipers. **M3** places a leg in witchspace, and a pod among the Thargoids. **M4** puts a Thargoid at the door at Competent, and grants the cloaking device. **M5** makes the cloak work: nobody sees the ship, the bank pays, and a shot gives it away. 6,159 assertions. - [x] 220 — [The phone holds its zoom, hides its bar, and reads the chart](220-the-phone-holds-its-zoom-hides-its-bar-and-reads-the-chart.md) — Chris, 2026-09-13, from his phone. No zoom on a double tap or a pinch, by the viewport, the root's touch rule and the shell's own listeners. A manifest and the app meta tags hide the address bar from the home screen, and the first touch asks for fullscreen where a phone offers it. The short range chart's names are drawn in CSS pixels, twelve of them, and an edge name sits left of its dot. 6,153 assertions. - [x] 218 — [The commander is they, not she](218-the-commander-is-they-not-she.md) — Chris, 2026-09-13. The comments, the docs and the dossier prompt slipped into "she" for the commander, from the novella. The prompt names the commander as the player of any gender now, about 560 lines over 128 files say "they" or "the commander", other characters keep their pronouns, and the fourteen dossiers were written again under prompt version 4. 6,153 assertions.