mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-18 17:22:19 +00:00
Tidy the Cockpit subject camera and HUD fixes after review
- A provider's look, height and speed are read once, so a getter that answers once is not lost; a Promise in a provider's words is refused and its rejection handled. - A huge heading slew rate is capped at a half turn per step instead of overflowing to Infinity. - A row changed in place keeps the time it first appeared; JSDoc, CURRENT-STATE and the ETA test say so. - APPLICATION.md says the app page must load the entry icon's glyph. - Tests check that entry succeeds, the vessel bridge is entered, a floor takes over from the entry height (also at 0 m), and share helpers; the provider unit test moves to the provider tests. - WIDE_GLYPH uses escapes; comments, the release notes and CURRENT-STATE match the code.
This commit is contained in:
1 parent
a72c0ba237
commit
109bb0fd4f
14 files changed
+279
-163
No files matched your search
@@ -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
|
||||
|
||||
@@ -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).
|
||||
+3
-2
@@ -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';
|
||||
|
||||
+13
-14
@@ -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
|
||||
|
||||
+4
-8
@@ -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}
|
||||
|
||||
@@ -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:
|
||||
|
||||
@@ -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', () => {
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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')),
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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}`,
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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(', ')})`,
|
||||
|
||||
Reference in new issue
Block a user