diff --git a/changelog.d/1686-cockpit-subjects.md b/changelog.d/1686-cockpit-subjects.md index 8fd069db31..9cae4ddbbd 100644 --- a/changelog.d/1686-cockpit-subjects.md +++ b/changelog.d/1686-cockpit-subjects.md @@ -3,9 +3,9 @@ heading and HUD (in the page's language, via `getLocale` and `onLocaleChange` from `./i18n`); the camera can follow it without the ground clamp, anchored exactly on it, and a generic HUD adds source rows, a - banner, a veil (its light streaks stop under reduced motion) and a bottom - progress line. The Rail and Transit layers expose read and hold APIs so a - selected train or vehicle can be ridden, and `./layers/rail/paths` is + banner, a veil (its light streaks stand still under reduced motion) and a + bottom progress line. The Rail and Transit layers expose read and hold APIs + so a selected train or vehicle can be ridden, and `./layers/rail/paths` is exported; that export and the read APIs are experimental. `docs/APPLICATION.md` shows a minimal provider. GEV itself registers none, and entry to the built-in aircraft, satellite and vessel views is diff --git a/changelog.d/1787-cockpit-subject-camera-hud.md b/changelog.d/1787-cockpit-subject-camera-hud.md index 0e860b64f4..eb1b463dd4 100644 --- a/changelog.d/1787-cockpit-subject-camera-hud.md +++ b/changelog.d/1787-cockpit-subject-camera-hud.md @@ -1,9 +1,10 @@ - Keep an application's Cockpit subject steady: a height its entry frame gave - holds while the floor is still cold, so the view no longer ends; the camera - keeps up when the browser draws few frames (at 5 a second, one updated every - frame fell 700 m behind a 30 m/s subject in a minute); a provider's Live - Signals rows change where they stand, their tone included, and rows it drops - leave before new ones come in, so a changing ETA or a replaced row no longer - pushes a steady warning off the list; progress labels give CJK, kana and - Hangul names the width they need; and labels, entry face and look keep the - words checked at registration when a later read fails (German, @gekh, #1787). + holds while the floor is still cold, so the view no longer ends after the + floor wait; the camera keeps up when the browser draws few frames (at 5 a + second, one updated every frame fell 700 m behind a 30 m/s subject in a + minute); a provider's Live Signals rows change where they stand, their tone + included, and rows it drops leave before new ones come in, so a changing ETA + or a replaced row no longer pushes a steady warning off the list; progress + labels give CJK, kana and Hangul names the width they need; and labels, + entry face and look keep the words checked at registration when a later + read fails (German, @gekh, #1787). diff --git a/docs/APPLICATION.md b/docs/APPLICATION.md index b1e81b4682..4b3c05e920 100644 --- a/docs/APPLICATION.md +++ b/docs/APPLICATION.md @@ -396,8 +396,9 @@ their `this`; one that throws or returns a promise is treated as having failed. What a method returns may carry getters: one that throws when read makes a candidate none, a frame malformed (the view ends) and a HUD view keep the last; a worded member (labels, entry face, look) that throws keeps its -last good words. An entry face's `icon` must be one of the Material Symbols -`index.html` loads (`icon_names`); any other renders as its name. +last good words. An entry face's `icon` is a Material Symbols name whose glyph +the application's page must load (GEV's own `index.html` loads a subset, its +`icon_names`); a glyph the page does not load renders as its name. ```js import { getLocale, onLocaleChange } from 'gods-eye-view/i18n'; diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md index ff6762f4c5..1a40abe9c3 100644 --- a/docs/CURRENT-STATE.md +++ b/docs/CURRENT-STATE.md @@ -2743,31 +2743,30 @@ first in that order decides alone: when its gate is shut there is no entry rather than the next subject's. A frame places the eye `eye.upM` above `heightM` (the shared floor where the -frame gives none, or the last height it had, the entry frame's included, while -that floor is cold; with neither, the camera stays where it is and the HUD reads ACQUIRING SURFACE for +frame gives none, or, while that floor is cold, the last height a frame gave, +the entry frame's included; with neither, the camera stays where it is and the HUD reads ACQUIRING SURFACE for at most `COCKPIT_GROUND_WAIT_TIMEOUT_MS`, after which the view ends and the subject is released: no height stands in for a floor never read), slews toward `headingDeg` at the provider's rate, and may turn off the floor clamps (`groundClamp: false`, for a subject inside a structure) or keep the anchor exactly on the subject (`anchor: 'exact'`, for a layer that already moves it smoothly; a frame with no `speedMps` is always exact, since an inertial anchor runs on at the frame's speed); `cameraIntervalMs: 0` updates the -camera every rendered frame. Each update turns, eases and moves the view by the -time since the last one, so it keeps up when the browser draws few frames; an -update more than a second past its interval (a hidden tab) moves it as one a -second late would, and the update that first places the camera (after entry or -a floor wait) stands its anchor on the subject. A frame that is null, malformed or for another +camera every rendered frame. Each update turns the view, eases its lift and +moves an inertial anchor by the time since the last one, at most a second past +the interval (`cockpitSubjectStepSec`); an exact anchor stands where the frame +is. The update that first places the camera (after entry or a floor wait) +stands its anchor on the subject. A frame that is null, malformed or for another subject ends the view (`restoreTracking: false`), as an aircraft tracked meanwhile and the provider's layer turning off do; the exit control asks the provider to restore its subject. The generic HUD shows the provider's kicker, title, meta line, speed with its unit and tag, readout cards, always-visible -source rows, banner, route card and Live Signals rows (each changes where it -stands, its tone included, so a changing ETA never pushes a steady warning off -the list; rows the view no longer lists leave before new ones come in), a veil that darkens the -picture under the HUD (with passing light streaks, which stop under reduced -motion), arrow-key look-around when the provider asks for it, and a progress +source rows, banner, route card and Live Signals rows (each changes in place, +its tone included, and keeps the time it first appeared; rows the view no +longer lists leave before new ones come in), a veil that darkens the +picture under the HUD (with passing light streaks, which stand still under +reduced motion), arrow-key look-around when the provider asks for it, and a progress line along the bottom edge (`src/cockpitProgress.js`: close ticks merge, -labels never overlap and get about 1 em for each full-width CJK, kana or Hangul -glyph and a little more for an emoji or other astral glyph). Core translates none of the provider's text: a host +labels never overlap and are sized for CJK and emoji glyphs). Core translates none of the provider's text: a host words it for the page's language (`gods-eye-view/i18n`: `getLocale`, `onLocaleChange`). Its entry face, labels and look may be functions, read again when they are shown and on a change of language, as the diff --git a/src/cockpitMath.js b/src/cockpitMath.js index 45348a2f39..7332a8634a 100644 --- a/src/cockpitMath.js +++ b/src/cockpitMath.js @@ -58,19 +58,15 @@ export function cockpitAnchorCorrectionStep( return Math.min(distanceM, eased, correctionRateMps * dt); } -/** - * How late past its interval a subject's camera update may come and still - * advance by all of it: a browser drawing a frame a second still keeps up. - */ +/** How late past its interval an update may come and still count in full. */ const COCKPIT_SUBJECT_LATE_SEC = 1; /** * The seconds an application subject's camera update advances its heading * slew, ground lift and anchor by: the time since the last update, at most - * its update interval plus a second. A subject updated every 500 ms, or a - * browser drawing 5 frames a second, then turns, eases and moves at its - * configured rates, while a long stall (a hidden tab) still moves it no - * further than one late update would. + * its interval plus COCKPIT_SUBJECT_LATE_SEC. A subject updated every 500 ms, + * or a browser drawing 5 frames a second, then keeps up, while a long stall + * (a hidden tab) counts as one late update. * @param {number} elapsedMs Time since the last camera update. * @param {number} intervalMs The subject's update interval (0: every frame). * @returns {number} diff --git a/src/cockpitProgress.js b/src/cockpitProgress.js index c8114d3e84..6d31cdfe88 100644 --- a/src/cockpitProgress.js +++ b/src/cockpitProgress.js @@ -30,9 +30,13 @@ const TONE_RANK = Object.freeze([ const stronger = (a, b) => TONE_RANK.indexOf(b) > TONE_RANK.indexOf(a) ? b : a; -/** Full-width glyphs (CJK, kana, Hangul, full-width forms): about 1 em each. */ +/** + * Full-width glyphs in the BMP (CJK, kana, Hangul, full-width forms): about + * 1 em each. Astral ones (CJK extensions, emoji) are wide enough as any + * other two UTF-16 units (lineWidthPx). + */ const WIDE_GLYPH = - /[ᄀ-ᅟ⺀-〾ぁ-㏿㐀-䶿一-鿿ꥠ-꥿가-힣豈-﫿︰-﹏＀-⦆¢-₩\u{20000}-\u{3fffd}]/u; + /[\u1100-\u115F\u2E80-\u303E\u3041-\u33FF\u3400-\u4DBF\u4E00-\u9FFF\uA960-\uA97F\uAC00-\uD7A3\uF900-\uFAFF\uFE30-\uFE4F\uFF00-\uFF60\uFFE0-\uFFE6]/; /** * One line's width (px) in `.cockpit-progress-label` type (cockpitSubject.css: diff --git a/src/cockpitProgress.test.mjs b/src/cockpitProgress.test.mjs index e05f3fe0ff..e1835caea8 100644 --- a/src/cockpitProgress.test.mjs +++ b/src/cockpitProgress.test.mjs @@ -155,9 +155,12 @@ test('a CJK stop name gets the width its full-width glyphs need', () => { givenPx >= needPx, `${givenPx} px given, about ${needPx} px needed`, ); - // Latin, and half-width katakana, keep the narrower estimate. - assert.equal(estimateProgressLabelPx({ text: 'CENTRAL' }), 7 * 6.4 + 8); - assert.equal(estimateProgressLabelPx({ text: 'カタカナ' }), 4 * 6.4 + 8); + // As many Latin letters are narrower; half-width katakana are as narrow. + assert.ok(givenPx > estimateProgressLabelPx({ text: 'CENTRALS' })); + assert.equal( + estimateProgressLabelPx({ text: 'カタカナ' }), + estimateProgressLabelPx({ text: 'KANA' }), + ); }); test('emoji and other astral glyphs in a progress label get at least 1 em each', () => { diff --git a/src/cockpitSubjectProviders.js b/src/cockpitSubjectProviders.js index bed39e6bca..94def7c828 100644 --- a/src/cockpitSubjectProviders.js +++ b/src/cockpitSubjectProviders.js @@ -118,20 +118,31 @@ function lookOf(raw) { } /** - * A provider's worded member `key` as it reads now, normalized: the value, - * or what the function it is returns when called on `provider` (so it can - * follow the page's language); null when it is malformed or a read throws. - * Reading the member, and reading what it gives, runs provider code too (a - * getter), so both are guarded as the call is. + * A worded member's `value` normalized: the value, or what it returns when it + * is a function called on `provider` (so it can follow the page's language); + * null when it is malformed or a read throws. Reading what it gives runs + * provider code too (a getter), so it is guarded as the call is; a promise is + * malformed, and its rejection is caught rather than left unhandled. */ +function worded(provider, value, normalize) { + try { + const words = typeof value === 'function' ? value.call(provider) : value; + if (typeof words?.then === 'function') { + Promise.resolve(words).catch(() => {}); + return null; + } + return normalize(words) ?? null; + } catch { + return null; + } +} + +/** A provider's worded member `key` as it reads now (see `worded`). */ function wordedNow(provider, key, normalize) { try { - const value = provider[key]; - return ( - normalize(typeof value === 'function' ? value.call(provider) : value) ?? - null - ); + return worded(provider, provider[key], normalize); } catch { + // A getter for the member threw. return null; } } @@ -146,12 +157,8 @@ function providerName(provider, order) { return `#${order}`; } -/** - * Why `provider` cannot be kept, or null. Its worded members, read once here, - * go into `words` (`face`, `labels`, `look`) to seed its copy, so one that - * fails when read again cannot undo this check. - */ -function refusal(provider, kinds, words) { +/** Why `provider` cannot be kept, its worded members aside, or null. */ +function refusal(provider, kinds) { if (!isObject(provider)) return 'not an object'; if (typeof provider.kind !== 'string' || !KIND_PATTERN.test(provider.kind)) return 'malformed kind'; @@ -169,17 +176,25 @@ function refusal(provider, kinds, words) { typeof provider.isEntryAllowed !== 'function' ) return 'isEntryAllowed is not a function'; - words.face = wordedNow(provider, 'entryFace', faceOf); - if (!words.face) return 'malformed entry face'; - words.labels = wordedNow(provider, 'labels', labelsOf); - if (!words.labels) return 'labels need view, exit and exitText'; - if (provider.look != null) { - words.look = wordedNow(provider, 'look', lookOf); - if (!words.look) return 'look needs an aheadLabel'; - } return null; } +/** + * A provider's worded members, each read once, to seed its copy (so one that + * fails when read again cannot undo this check), or why one is malformed. + * @returns {{face: object, labels: object, look: ?object}|string} + */ +function checkedWords(provider) { + const face = wordedNow(provider, 'entryFace', faceOf); + if (!face) return 'malformed entry face'; + const labels = wordedNow(provider, 'labels', labelsOf); + if (!labels) return 'labels need view, exit and exitText'; + const lookValue = provider.look; + if (lookValue == null) return { face, labels, look: null }; + const look = worded(provider, lookValue, lookOf); + return look ? { face, labels, look } : 'look needs an aheadLabel'; +} + /** * The application's subject providers, checked once and frozen, in the order * entry asks them: ascending `priority`, ties in list order. Each has @@ -198,7 +213,8 @@ function refusal(provider, kinds, words) { * object: it is called on the provider again whenever they are shown and * when the page's language changes, so its words can follow it * (`./i18n`). A read that throws or is malformed keeps the last - * good one; `look` is on or off and `restPitchDeg` fixed as first read; + * good one; `look` is on or off and `restPitchDeg` fixed as read at + * registration; * - `cameraIntervalMs` (optional): 0..1000, null for the Cockpit's default; 0 * updates the camera every rendered frame; * - `headingSlewDps` (optional): how fast the view turns to a new heading, @@ -229,10 +245,13 @@ export function cockpitSubjectProviders( (Array.isArray(list) ? list : []).forEach((provider, order) => { let reason; let copy = null; - const words = { face: null, labels: null, look: null }; try { - reason = refusal(provider, kinds, words); - if (!reason) copy = keptProvider(provider, order, words); + reason = refusal(provider, kinds); + if (!reason) { + const words = checkedWords(provider); + if (typeof words === 'string') reason = words; + else copy = keptProvider(provider, order, words); + } } catch { reason = 'a member threw when read'; } @@ -250,14 +269,14 @@ export function cockpitSubjectProviders( } /** - * The frozen copy the Cockpit keeps of a provider `refusal` passed, seeded - * with the worded members it checked. + * The frozen copy the Cockpit keeps of a provider that passed `refusal`, + * seeded with the worded members `checkedWords` read. */ function keptProvider(provider, order, words) { // Worded members are read again on each use (see above); the last good // read stands in for one that is malformed or throws. let { face, labels, look } = words; - // On or off, and its rest pitch, as first read. + // Look stays on or off, at its rest pitch, as read at registration. const restPitchDeg = look?.restPitchDeg ?? 0; return Object.freeze({ kind: provider.kind, @@ -345,8 +364,8 @@ function candidateOf(raw) { * read of it that throws (a getter runs provider code). * A `heightM` that is not finite or lies outside * COCKPIT_SUBJECT_MIN_HEIGHT_M..COCKPIT_SUBJECT_MAX_HEIGHT_M reads as null: - * the eye then stands on the shared floor, or where it last stood while that - * is cold. The anchor is `'inertial'` by default for a frame with a valid + * the eye then stands on the shared floor, or at the last height a frame gave, + * the entry frame's included, while that is cold. The anchor is `'inertial'` by default for a frame with a valid * speed, and `'exact'` when asked for or with no speed. An id is compared * with `heldId` trimmed, as `cockpitSubjectCandidate` trims it. * @param {unknown} raw What `read()` returned. @@ -376,18 +395,20 @@ function frameOf(raw, heldId) { const heading = (value) => finite(value) ? ((value % 360) + 360) % 360 : null; const headingDeg = heading(raw.headingDeg); - const speedMps = - finite(raw.speedMps) && raw.speedMps >= 0 ? raw.speedMps : null; + // Each read once: a getter on the frame runs provider code. + const rawSpeedMps = raw.speedMps; + const speedMps = finite(rawSpeedMps) && rawSpeedMps >= 0 ? rawSpeedMps : null; + const rawHeightM = raw.heightM; return { id: heldId, name: cockpitSubjectText(raw.name, 64) || cockpitSubjectText(heldId, 64), latitude, longitude: ((((longitude + 180) % 360) + 360) % 360) - 180, heightM: - finite(raw.heightM) && - raw.heightM >= COCKPIT_SUBJECT_MIN_HEIGHT_M && - raw.heightM <= COCKPIT_SUBJECT_MAX_HEIGHT_M - ? raw.heightM + finite(rawHeightM) && + rawHeightM >= COCKPIT_SUBJECT_MIN_HEIGHT_M && + rawHeightM <= COCKPIT_SUBJECT_MAX_HEIGHT_M + ? rawHeightM : null, headingDeg, courseDeg: heading(raw.courseDeg) ?? headingDeg, diff --git a/src/cockpitSubjectProviders.test.mjs b/src/cockpitSubjectProviders.test.mjs index 2063cca412..979442cb4d 100644 --- a/src/cockpitSubjectProviders.test.mjs +++ b/src/cockpitSubjectProviders.test.mjs @@ -670,6 +670,64 @@ test('a worded getter that starts throwing keeps the last good words', () => { assert.equal(ride.labels.view, 'Ride view'); }); +for (const form of ['function', 'getter']) { + test(`worded members (as a ${form}) that throw from their second read keep the words checked at registration`, () => { + const definition = provider(); + for (const [key, value] of Object.entries({ + labels: { view: 'Ride view', exit: 'Exit ride view', exitText: 'EXIT' }, + entryFace: { icon: 'commute', label: 'RIDE' }, + look: { restPitchDeg: 10, aheadLabel: 'Look ahead' }, + })) { + let read = false; + const once = () => { + if (read) throw new Error('word bundle unloaded'); + read = true; + return value; + }; + if (form === 'function') definition[key] = once; + else Object.defineProperty(definition, key, { get: once }); + } + const { kept, warnings } = keep([definition]); + assert.deepEqual(warnings, []); + const [ride] = kept; + assert.equal(ride.labels.view, 'Ride view'); + assert.equal(ride.entryFace.label, 'RIDE'); + assert.deepEqual(ride.look, { restPitchDeg: 10, aheadLabel: 'Look ahead' }); + }); +} + +test('a worded member that returns a rejected promise keeps the last good words, the rejection caught', async () => { + const definition = provider(); + const words = definition.labels; + let reads = 0; + definition.labels = () => { + reads += 1; + return reads === 1 ? words : Promise.reject(new Error('late words')); + }; + const { kept, warnings } = keep([definition]); + assert.deepEqual(warnings, []); + assert.equal(kept[0].labels.view, words.view); + // An unhandled rejection would fail this test once it surfaces. + await new Promise((resolve) => setTimeout(resolve, 10)); +}); + +test('a frame field read through a getter is read once', () => { + const frame = { id: 'a1', latitude: 1, longitude: 2, eye: { upM: 3 } }; + const once = (value) => { + let read = false; + return () => { + const answer = read ? undefined : value; + read = true; + return answer; + }; + }; + Object.defineProperty(frame, 'heightM', { get: once(420) }); + Object.defineProperty(frame, 'speedMps', { get: once(12) }); + const normalized = cockpitSubjectFrame(frame, 'a1'); + assert.equal(normalized.heightM, 420); + assert.equal(normalized.speedMps, 12); +}); + test('a candidate, frame or HUD view whose getter throws reads as null', () => { assert.equal( cockpitSubjectCandidate(throwingGetter({ name: 'Example' }, 'id')), diff --git a/src/ui/cockpitCamera.js b/src/ui/cockpitCamera.js index feb7734798..ea371dab1b 100644 --- a/src/ui/cockpitCamera.js +++ b/src/ui/cockpitCamera.js @@ -411,7 +411,9 @@ function updateSubject(nowMs) { : slewHeading( this.heading ?? frame.headingDeg, frame.headingDeg, - rate * dtSec, + // At most half a turn, which reaches any heading: a huge rate times + // the step must not overflow to Infinity and stop the turn. + Math.min(rate * dtSec, 180), ); } let look = null; @@ -506,8 +508,8 @@ function placeCamera(target, info, nowMs, dtSec, profile, look = null) { ); const correction = sub(target, this.cockpitAnchor); const correctionDistanceM = magnitude(correction); - // An application subject's step is already bounded by its own update - // interval (cockpitSubjectStepSec); the built-in views keep the 0.1 s. + // An application subject's step is already bounded (cockpitSubjectStepSec); + // the built-in views keep the 0.1 s. const correctionStepM = cockpitAnchorCorrectionStep( correctionDistanceM, speedMps, diff --git a/src/ui/cockpitController.js b/src/ui/cockpitController.js index 00552532c7..ded0f1fd87 100644 --- a/src/ui/cockpitController.js +++ b/src/ui/cockpitController.js @@ -194,7 +194,10 @@ export class CockpitViewController { this.surfaceWaitStartedMs = 0; this.surfaceAcquiring = false; this.surfaceFallback = false; - /** The height an application subject's frame last stood at (m). */ + /** + * The last height an application subject's frame gave, the entry frame's + * included (m). + */ this.subjectHeightM = null; /** The ground clamp's eased lift under that subject's eye (m). */ this.subjectLiftM = null; diff --git a/src/ui/cockpitInstruments.js b/src/ui/cockpitInstruments.js index cf3cea895d..5e67a47e01 100644 --- a/src/ui/cockpitInstruments.js +++ b/src/ui/cockpitInstruments.js @@ -262,8 +262,7 @@ function updateSubjectHud(info, nowMs, forceContext) { for (const key of this.subjectSignalKeys ?? []) if (!keys.has(key)) this.dropCockpitSignal(key); this.subjectSignalKeys = keys; - // The view's rows are its current signals: each changes where it stands, - // so a changing one (an ETA) never pushes a steady one off the list. + // The view's rows are its current signals, each changed in place. for (const signal of hud.signals) this.pushCockpitSignal( `subject:${signal.id}`, diff --git a/src/ui/cockpitSignals.js b/src/ui/cockpitSignals.js index abfcfd12fa..997b978eee 100644 --- a/src/ui/cockpitSignals.js +++ b/src/ui/cockpitSignals.js @@ -42,8 +42,9 @@ export function publishCockpitSignals() { /** * Log a signal as the newest row, unless its key last said the same. * @param {{inPlace?: boolean}} [options] `inPlace`: a status row, such as a - * provider's, that changes where it stands rather than log a new row, and - * comes back if newer rows pushed it off the list. + * provider's, that changes where it stands rather than log a new row, so a + * changing ETA never pushes a steady warning off the list; it keeps the + * time it first appeared, and comes back if newer rows pushed it off. */ export function pushCockpitSignal( key, diff --git a/src/ui/cockpitSubjectView.test.mjs b/src/ui/cockpitSubjectView.test.mjs index 92a7a9b2eb..63d39455a9 100644 --- a/src/ui/cockpitSubjectView.test.mjs +++ b/src/ui/cockpitSubjectView.test.mjs @@ -27,6 +27,10 @@ import { fakeScenePorts } from '../testSupport/fakeCesiumScene.mjs'; const LAT = 47; const LON = 8; const FLOOR_M = 400; +/** Metres in a degree of longitude at LAT. */ +const M_PER_DEG_LON = 111_320 * Math.cos(Cesium.Math.toRadians(LAT)); +/** The longitude `m` metres east of LON. */ +const eastM = (m) => LON + m / M_PER_DEG_LON; /** A HUD view model as a provider words it. */ const HUD = Object.freeze({ @@ -560,7 +564,7 @@ test('a subject updated every 500 ms turns, eases and closes on its target at it ride.subject.frame = { ...ride.subject.frame, headingDeg: 180, - longitude: LON + 100 / (111_320 * Math.cos(Cesium.Math.toRadians(LAT))), + longitude: eastM(100), }; setFloor(FLOOR_M + 3.5); clock.advance(500); @@ -588,20 +592,35 @@ test('a subject updated every 500 ms turns, eases and closes on its target at it assert.ok(Math.abs(cockpit.heading - 110) < 1e-6, 'at most 1.5 s'); }); -test('an inertial subject drawn at 5 frames a second stays near its target', async (t) => { +test('a subject turning at the largest finite rate reaches its heading after a late update', async (t) => { const clock = manualClock(t, 10_000); + const ride = subjectProvider({ + cameraIntervalMs: 500, + headingSlewDps: Number.MAX_VALUE, + }); + const { cockpit } = fixture(t, { providers: [ride] }); + cockpit.syncEntry(); + assert.equal(cockpit.enter(), true); + clock.advance(500); + cockpit.update(); + ride.subject.frame = { ...ride.subject.frame, headingDeg: 180 }; + // A 1.5 s step: the rate times it overflows to Infinity. + clock.advance(1500); + cockpit.update(); + assert.equal(cockpit.heading, 180); +}); + +test('an inertial subject drawn at 5 frames a second stays near its target', async (t) => { + const startMs = 10_000; + const clock = manualClock(t, startMs); const ride = subjectProvider(); const SPEED_MPS = 30; - const startMs = 10_000; - const eastOf = (ms) => - LON + - (SPEED_MPS * (ms - startMs)) / - 1000 / - (111_320 * Math.cos((LAT * Math.PI) / 180)); - let nowMs = startMs; + const eastNow = () => + eastM((SPEED_MPS * (performance.now() - startMs)) / 1000); + const base = ride.subject.frame; ride.subject.frame = () => ({ - ...subjectProvider().subject.frame, - longitude: eastOf(nowMs), + ...base, + longitude: eastNow(), speedMps: SPEED_MPS, anchor: 'inertial', }); @@ -610,14 +629,9 @@ test('an inertial subject drawn at 5 frames a second stays near its target', asy assert.equal(cockpit.enter(), true); for (let i = 0; i < 300; i += 1) { clock.advance(200); - nowMs += 200; cockpit.update(); } - const target = Cesium.Cartesian3.fromDegrees( - eastOf(nowMs), - LAT, - FLOOR_M + 3.5, - ); + const target = Cesium.Cartesian3.fromDegrees(eastNow(), LAT, FLOOR_M + 3.5); const gapM = Cesium.Cartesian3.distance(shots.at(-1).destination, target); assert.ok( gapM < 50, @@ -633,15 +647,14 @@ for (const [intervalMs, waitMs] of [ const startMs = 10_000; const clock = manualClock(t, startMs); const SPEED_MPS = 30; - const mPerDegLon = 111_320 * Math.cos(Cesium.Math.toRadians(LAT)); - const eastOf = () => - LON + (SPEED_MPS * (performance.now() - startMs)) / 1000 / mPerDegLon; + const eastNow = () => + eastM((SPEED_MPS * (performance.now() - startMs)) / 1000); const ride = subjectProvider({ cameraIntervalMs: intervalMs }); const base = ride.subject.frame; ride.subject.frame = () => ({ ...base, heightM: null, - longitude: eastOf(), + longitude: eastNow(), speedMps: SPEED_MPS, anchor: 'inertial', eye: { ...base.eye, forwardM: 0 }, @@ -666,7 +679,7 @@ for (const [intervalMs, waitMs] of [ cockpit.update(); const shot = Cesium.Cartographic.fromCartesian(shots[before].destination); const leadM = - (Cesium.Math.toDegrees(shot.longitude) - eastOf()) * mPerDegLon; + (Cesium.Math.toDegrees(shot.longitude) - eastNow()) * M_PER_DEG_LON; assert.ok( Math.abs(leadM) < 1, `the first camera update leads the subject by ${leadM.toFixed(2)} m`, @@ -949,31 +962,46 @@ test('a floor that never comes ends the view after the bounded wait, releasing t assert.deepEqual(lastRelease(ride.calls), ['release', 'a1', false]); }); -test('a height the entry frame gave holds while later frames give none and the floor is cold', async (t) => { - const clock = manualClock(t, 10_000); - const ride = subjectProvider(); - const { cockpit, shots, setFloor } = fixture(t, { providers: [ride] }); - setFloor(undefined); - cockpit.syncEntry(); - // The entry frame stands at FLOOR_M (heightM 400). - assert.equal(cockpit.enter(), true); - ride.subject.frame = { ...ride.subject.frame, heightM: null }; - for ( - let elapsed = 0; - elapsed < COCKPIT_GROUND_WAIT_TIMEOUT_MS + 1000; - elapsed += 100 - ) { +for (const entryHeightM of [0, FLOOR_M]) { + test(`a height the entry frame gave (${entryHeightM} m) holds while later frames give none and the floor is cold`, async (t) => { + const clock = manualClock(t, 10_000); + const ride = subjectProvider(); + ride.subject.frame = { ...ride.subject.frame, heightM: entryHeightM }; + const { cockpit, shots, setFloor } = fixture(t, { providers: [ride] }); + setFloor(undefined); + cockpit.syncEntry(); + assert.equal(cockpit.enter(), true); + ride.subject.frame = { ...ride.subject.frame, heightM: null }; + const waitPastTimeout = () => { + for ( + let elapsed = 0; + elapsed < COCKPIT_GROUND_WAIT_TIMEOUT_MS + 1000; + elapsed += 100 + ) { + clock.advance(100); + cockpit.update(); + } + }; + waitPastTimeout(); + assert.equal( + cockpit.active, + true, + 'the view keeps the height its entry frame gave', + ); + assert.ok(shots.length > 0, 'the camera is placed'); + assert.ok(Math.abs(shotHeight(shots) - (entryHeightM + 3.5)) < 0.01); + // A floor that comes takes over, and is kept once it is cold again. + const floorM = FLOOR_M - 100; + setFloor(floorM); clock.advance(100); cockpit.update(); - } - assert.equal( - cockpit.active, - true, - 'the view keeps the height its entry frame gave', - ); - assert.ok(shots.length > 0, 'the camera is placed'); - assert.ok(Math.abs(shotHeight(shots) - (FLOOR_M + 3.5)) < 0.01); -}); + assert.ok(Math.abs(shotHeight(shots) - (floorM + 3.5)) < 0.01); + setFloor(undefined); + waitPastTimeout(); + assert.equal(cockpit.active, true); + assert.ok(Math.abs(shotHeight(shots) - (floorM + 3.5)) < 0.01); + }); +} test('an asynchronous hold that lands after entry was refused is released again', async (t) => { let heldId = null; @@ -1054,39 +1082,28 @@ test('a provider’s labels, entry face and look follow a change of language', a ); }); -/** Labels that read well once, when the provider is checked, then throw. */ -const GOOD_LABELS = Object.freeze({ - view: 'Ride view', - exit: 'Exit ride view', - exitText: 'EXIT RIDE', - kicker: 'RIDE', -}); -const labelsOnce = () => { - let reads = 0; - return function labels() { - reads += 1; - if (reads > 1) throw new Error('word bundle unloaded'); - return GOOD_LABELS; - }; -}; - -test('labels that start throwing after the first read keep the first good words', () => { - const warned = []; - const [kept] = cockpitSubjectProviders( - [{ ...subjectProvider().definition, labels: labelsOnce() }], - { warn: (message) => warned.push(message) }, - ); - assert.ok(kept, 'the provider is kept'); - assert.deepEqual({ ...kept.labels }, GOOD_LABELS); -}); - -test('entering such a provider with no HUD kicker does not throw', async (t) => { +test('a provider whose labels throw after registration enters with no HUD kicker', async (t) => { manualClock(t, 10_000); - const ride = subjectProvider({ labels: labelsOnce() }); + let read = false; + const ride = subjectProvider({ + labels() { + if (read) throw new Error('word bundle unloaded'); + read = true; + return { + view: 'Tram view', + exit: 'Exit tram view', + exitText: 'EXIT TRAM', + kicker: 'TRAM 4', + }; + }, + }); ride.subject.hud = { title: 'Example 12' }; - const { cockpit } = fixture(t, { providers: [ride] }); + const { $, cockpit } = fixture(t, { providers: [ride] }); cockpit.syncEntry(); - assert.doesNotThrow(() => cockpit.enter()); + assert.equal(cockpit.enter(), true); + await settle(); + // The kicker checked at registration stands in for the HUD view's. + assert.equal($('.cockpit-kicker').textContent, 'TRAM 4'); }); test('a read that throws ends the view once; a hud that throws keeps the last', async (t) => { @@ -1320,6 +1337,9 @@ test('the same double-click on the vessel alone enters its bridge', async (t) => cockpit.syncEntry(); assert.equal(store.presence.entryKind, 'vessel'); assert.equal(cockpit.onSceneDoubleClick({ x: 100, y: 100 }), true); + await settle(); + assert.equal(store.presence.active, true, 'the bridge is entered'); + assert.equal(cockpit.subjectKind, 'vessel'); }); test('a provider view with look turns with the arrow keys and words its readout', async (t) => { @@ -1374,27 +1394,35 @@ test('a signal still listed stays in Live Signals while another one changes', as // The real Live Signals rows, not the fixture's recorder. delete cockpit.pushCockpitSignal; delete cockpit.dropCockpitSignal; + // The ETA is logged first, so it stands below the warning. const hudWith = (minutes) => ({ ...HUD, signals: [ + { id: 'eta', title: 'NEXT', detail: `Central in ${minutes} min` }, { id: 'doors', tone: 'warning', title: 'DOORS', detail: 'door fault, car 2', }, - { id: 'eta', title: 'NEXT', detail: `Central in ${minutes} min` }, ], }); + const etaRow = () => + cockpit.signalItems.find((row) => row.key === 'subject:eta'); ride.subject.hud = hudWith(10); cockpit.syncEntry(); assert.equal(cockpit.enter(), true); + const keysAtEntry = cockpit.signalItems.map((row) => row.key); + const etaFirstSeen = etaRow().timestamp; for (let minutes = 9; minutes >= 2; minutes -= 1) { ride.subject.hud = hudWith(minutes); clock.advance(1000); cockpit.update(); } const keys = cockpit.signalItems.map((row) => row.key); + // Each row keeps its place, and the ETA the time it first appeared. + assert.deepEqual(keys, keysAtEntry); + assert.equal(etaRow().timestamp, etaFirstSeen); assert.ok( keys.includes('subject:doors'), `the warning the HUD still lists is shown (rows: ${keys.join(', ')})`,