mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-19 01:32:19 +00:00
Merge branch 'main' into fleet-entry
This commit is contained in:
42 files changed
+1494
-240
No files matched your search
+7
-4
@@ -58,12 +58,15 @@ export function cockpitAnchorCorrectionStep(
|
||||
return Math.min(distanceM, eased, correctionRateMps * dt);
|
||||
}
|
||||
|
||||
/** 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 0.1 s. A subject updated every 500 ms then turns
|
||||
* and eases 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}
|
||||
@@ -75,7 +78,7 @@ export function cockpitSubjectStepSec(elapsedMs, intervalMs) {
|
||||
const intervalSec = Number.isFinite(intervalMs)
|
||||
? Math.max(0, intervalMs) / 1000
|
||||
: 0;
|
||||
return Math.min(intervalSec + 0.1, elapsedSec);
|
||||
return Math.min(intervalSec + COCKPIT_SUBJECT_LATE_SEC, elapsedSec);
|
||||
}
|
||||
|
||||
/** Return whether a throttled cockpit presentation update is due. */
|
||||
|
||||
@@ -73,12 +73,15 @@ test('an application subject steps by its interval, never by a long stall', () =
|
||||
assert.equal(cockpitSubjectStepSec(16, 0), 0.016);
|
||||
assert.equal(cockpitSubjectStepSec(500, 500), 0.5);
|
||||
assert.equal(cockpitSubjectStepSec(520, 500), 0.52);
|
||||
// A hidden tab's minutes count as one late update.
|
||||
assert.equal(cockpitSubjectStepSec(60_000, 500), 0.6);
|
||||
assert.equal(cockpitSubjectStepSec(60_000, 0), 0.1);
|
||||
// Slow frames (5 a second) count in full...
|
||||
assert.equal(cockpitSubjectStepSec(200, 50), 0.2);
|
||||
assert.equal(cockpitSubjectStepSec(1000, 0), 1);
|
||||
// ...and a hidden tab's minutes as one late update.
|
||||
assert.equal(cockpitSubjectStepSec(60_000, 500), 1.5);
|
||||
assert.equal(cockpitSubjectStepSec(60_000, 0), 1);
|
||||
assert.equal(cockpitSubjectStepSec(-5, 500), 0);
|
||||
assert.equal(cockpitSubjectStepSec(Number.NaN, 500), 0);
|
||||
assert.equal(cockpitSubjectStepSec(1000, Number.NaN), 0.1);
|
||||
assert.equal(cockpitSubjectStepSec(1000, Number.NaN), 1);
|
||||
});
|
||||
|
||||
test('cockpit camera clearance never falls below the rendered ground floor', () => {
|
||||
|
||||
+19
-6
@@ -30,13 +30,26 @@ const TONE_RANK = Object.freeze([
|
||||
const stronger = (a, b) =>
|
||||
TONE_RANK.indexOf(b) > TONE_RANK.indexOf(a) ? b : a;
|
||||
|
||||
/** A label's width estimate (px): its longer line in small capitals. */
|
||||
/** Full-width glyphs in the BMP: CJK, kana, Hangul, full-width forms. */
|
||||
const WIDE_GLYPHS =
|
||||
/[\u1100-\u115F\u2E80-\u303E\u3041-\u33FF\u3400-\u4DBF\u4E00-\u9FFF\uA960-\uA97F\uAC00-\uD7A3\uF900-\uFAFF\uFE30-\uFE4F\uFF00-\uFF60\uFFE0-\uFFE6]/g;
|
||||
|
||||
/**
|
||||
* One line's width (px) in `.cockpit-progress-label` type (cockpitSubject.css:
|
||||
* 10 px, 0.06 em spacing): 10.6 px a full-width glyph and 6.4 px each UTF-16
|
||||
* unit of any other, so an astral glyph (an emoji, a CJK extension) counts as
|
||||
* two and an emoji in the BMP (☕) as one, narrower than it is drawn. The
|
||||
* detail line's `<small>` draws smaller, so these widths only overestimate it.
|
||||
*/
|
||||
function lineWidthPx(line) {
|
||||
const text = String(line ?? '');
|
||||
const wide = text.match(WIDE_GLYPHS)?.length ?? 0;
|
||||
return wide * 10.6 + (text.length - wide) * 6.4;
|
||||
}
|
||||
|
||||
/** A label's width estimate (px): its wider line and 8 px of padding. */
|
||||
export function estimateProgressLabelPx(label) {
|
||||
const longest = Math.max(
|
||||
String(label?.text ?? '').length,
|
||||
String(label?.detail ?? '').length,
|
||||
);
|
||||
return longest * 6.4 + 8;
|
||||
return Math.max(lineWidthPx(label?.text), lineWidthPx(label?.detail)) + 8;
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@@ -4,7 +4,10 @@
|
||||
// the travelled part.
|
||||
import test from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { cockpitProgressLayout } from './cockpitProgress.js';
|
||||
import {
|
||||
cockpitProgressLayout,
|
||||
estimateProgressLabelPx,
|
||||
} from './cockpitProgress.js';
|
||||
|
||||
const tick = (at, label = null, tone = 'normal') => ({ at, tone, label });
|
||||
const label = (text, priority, align = 'center', detail = '') => ({
|
||||
@@ -142,3 +145,59 @@ test('a long run of calls still lays out, every one a tick or part of one', () =
|
||||
assert.ok(narrow.ticks.length < wide.ticks.length);
|
||||
assert.equal(wide.ticks.length, 60);
|
||||
});
|
||||
|
||||
test('a CJK stop name gets the width its full-width glyphs need', () => {
|
||||
const text = '中央駅前広場東口'; // 8 full-width glyphs
|
||||
// 10 px type, 0.06 em apart.
|
||||
const needPx = text.length * (10 + 0.6);
|
||||
const givenPx = estimateProgressLabelPx({ text, detail: '' });
|
||||
assert.ok(
|
||||
givenPx >= needPx,
|
||||
`${givenPx} px given, about ${needPx} px needed`,
|
||||
);
|
||||
// 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('astral glyphs (emoji outside the BMP, supplementary kana) in a progress label get at least 1 em each', () => {
|
||||
// About 1 em in 10 px type, 0.06 em apart.
|
||||
const emPx = 10 + 0.6;
|
||||
for (const [text, needPx] of [
|
||||
['🚉🚆🚇🚋', 4 * emPx],
|
||||
['🚆'.repeat(8), 8 * emPx],
|
||||
// Supplementary kana, outside the full-width ranges.
|
||||
['𛀁𛀂', 2 * emPx],
|
||||
// Mixed: four emoji, a space and two full-width glyphs.
|
||||
['🚆🚇🚌🚕 乗換', 4 * emPx + 6.4 + 2 * emPx],
|
||||
]) {
|
||||
const givenPx = estimateProgressLabelPx({ text, detail: '' });
|
||||
assert.ok(
|
||||
givenPx >= needPx + 8,
|
||||
`${text}: ${givenPx} px given, about ${needPx} px needed`,
|
||||
);
|
||||
}
|
||||
});
|
||||
|
||||
test('a label is as wide as its wider line, its smaller detail line included', () => {
|
||||
assert.ok(
|
||||
estimateProgressLabelPx({ text: 'GATE', detail: '中央駅前' }) >
|
||||
estimateProgressLabelPx({ text: 'GATE', detail: '' }),
|
||||
'the wider detail line widens the label',
|
||||
);
|
||||
// As headless Chrome draws the detail's <small> (8.333 px JetBrains Mono,
|
||||
// 0.6 px apart): 'WWWWMMMMWWWW' at 67.2 px, '中央駅前広場東口' at 72.9 px.
|
||||
for (const [detail, needPx] of [
|
||||
['W'.repeat(64), 64 * (67.2 / 12)],
|
||||
['駅'.repeat(45), 45 * (72.9 / 8)],
|
||||
]) {
|
||||
const givenPx = estimateProgressLabelPx({ text: 'A', detail });
|
||||
assert.ok(
|
||||
givenPx >= needPx,
|
||||
`${detail.length} × ${detail[0]}: ${givenPx} px given, ${needPx} px needed`,
|
||||
);
|
||||
}
|
||||
});
|
||||
@@ -117,20 +117,27 @@ function lookOf(raw) {
|
||||
});
|
||||
}
|
||||
|
||||
/** Promises already given a catch: a pending one is read again on every use. */
|
||||
const caughtWords = new WeakSet();
|
||||
|
||||
/**
|
||||
* 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 as `read()` gives it, normalized: called on `provider`
|
||||
* when it is a function (so it can follow the page's language); null when it
|
||||
* is malformed (a promise too) or provider code throws, its getter included
|
||||
* (hence `read`).
|
||||
*/
|
||||
function wordedNow(provider, key, normalize) {
|
||||
function worded(provider, read, normalize) {
|
||||
try {
|
||||
const value = provider[key];
|
||||
return (
|
||||
normalize(typeof value === 'function' ? value.call(provider) : value) ??
|
||||
null
|
||||
);
|
||||
const value = read();
|
||||
const words = typeof value === 'function' ? value.call(provider) : value;
|
||||
if (typeof words?.then === 'function') {
|
||||
if (!caughtWords.has(words)) {
|
||||
caughtWords.add(words);
|
||||
Promise.resolve(words).catch(() => {});
|
||||
}
|
||||
return null;
|
||||
}
|
||||
return normalize(words) ?? null;
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
@@ -146,7 +153,7 @@ function providerName(provider, order) {
|
||||
return `#${order}`;
|
||||
}
|
||||
|
||||
/** Why `provider` cannot be kept, or null. */
|
||||
/** 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))
|
||||
@@ -165,14 +172,25 @@ function refusal(provider, kinds) {
|
||||
typeof provider.isEntryAllowed !== 'function'
|
||||
)
|
||||
return 'isEntryAllowed is not a function';
|
||||
if (!wordedNow(provider, 'entryFace', faceOf)) return 'malformed entry face';
|
||||
if (!wordedNow(provider, 'labels', labelsOf))
|
||||
return 'labels need view, exit and exitText';
|
||||
if (provider.look != null && !wordedNow(provider, 'look', lookOf))
|
||||
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 = worded(provider, () => provider.entryFace, faceOf);
|
||||
if (!face) return 'malformed entry face';
|
||||
const labels = worded(provider, () => 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
|
||||
@@ -191,7 +209,8 @@ function refusal(provider, kinds) {
|
||||
* 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,
|
||||
@@ -224,7 +243,11 @@ export function cockpitSubjectProviders(
|
||||
let copy = null;
|
||||
try {
|
||||
reason = refusal(provider, kinds);
|
||||
if (!reason) copy = keptProvider(provider, order);
|
||||
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';
|
||||
}
|
||||
@@ -241,14 +264,12 @@ export function cockpitSubjectProviders(
|
||||
return Object.freeze(kept);
|
||||
}
|
||||
|
||||
/** The frozen copy the Cockpit keeps of a provider `refusal` passed. */
|
||||
function keptProvider(provider, order) {
|
||||
// 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 = wordedNow(provider, 'entryFace', faceOf);
|
||||
let labels = wordedNow(provider, 'labels', labelsOf);
|
||||
// On or off, and its rest pitch, as first read.
|
||||
let look = wordedNow(provider, 'look', lookOf);
|
||||
/**
|
||||
* The frozen copy the Cockpit keeps of a provider that passed `refusal`,
|
||||
* seeded with the worded members `checkedWords` read.
|
||||
*/
|
||||
function keptProvider(provider, order, words) {
|
||||
let { face, labels, look } = words;
|
||||
const restPitchDeg = look?.restPitchDeg ?? 0;
|
||||
return Object.freeze({
|
||||
kind: provider.kind,
|
||||
@@ -256,16 +277,16 @@ function keptProvider(provider, order) {
|
||||
priority: finite(provider.priority) ? provider.priority : 0,
|
||||
order,
|
||||
get entryFace() {
|
||||
face = wordedNow(provider, 'entryFace', faceOf) ?? face;
|
||||
face = worded(provider, () => provider.entryFace, faceOf) ?? face;
|
||||
return face;
|
||||
},
|
||||
get labels() {
|
||||
labels = wordedNow(provider, 'labels', labelsOf) ?? labels;
|
||||
labels = worded(provider, () => provider.labels, labelsOf) ?? labels;
|
||||
return labels;
|
||||
},
|
||||
get look() {
|
||||
if (!look) return null;
|
||||
const now = wordedNow(provider, 'look', lookOf);
|
||||
const now = worded(provider, () => provider.look, lookOf);
|
||||
if (now)
|
||||
look = Object.freeze({ restPitchDeg, aheadLabel: now.aheadLabel });
|
||||
return look;
|
||||
@@ -335,11 +356,11 @@ function candidateOf(raw) {
|
||||
* a position that is not finite, an eye with no valid `upM` (0..1000), or a
|
||||
* 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'` only when asked for and the frame
|
||||
* gives a speed; otherwise it is `'exact'`. An id is compared with `heldId`
|
||||
* trimmed, as `cockpitSubjectCandidate` trims it.
|
||||
* COCKPIT_SUBJECT_MIN_HEIGHT_M..COCKPIT_SUBJECT_MAX_HEIGHT_M reads as null,
|
||||
* for the eye to stand on the shared floor (ui/cockpitCamera.js). 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.
|
||||
* @param {string} heldId The subject the view holds.
|
||||
* @returns {object|null} `{id, name, latitude, longitude, heightM, headingDeg,
|
||||
@@ -356,49 +377,57 @@ export function cockpitSubjectFrame(raw, heldId) {
|
||||
}
|
||||
|
||||
function frameOf(raw, heldId) {
|
||||
if (!isObject(raw) || typeof raw.id !== 'string' || raw.id.trim() !== heldId)
|
||||
return null;
|
||||
const latitude = raw.latitude;
|
||||
const longitude = raw.longitude;
|
||||
if (!isObject(raw)) return null;
|
||||
// Each field read once: a getter on the frame runs provider code.
|
||||
const {
|
||||
id,
|
||||
name,
|
||||
latitude,
|
||||
longitude,
|
||||
heightM,
|
||||
headingDeg: rawHeadingDeg,
|
||||
courseDeg,
|
||||
speedMps: rawSpeedMps,
|
||||
stale,
|
||||
groundClamp,
|
||||
anchor,
|
||||
eye: rawEye,
|
||||
} = raw;
|
||||
if (typeof id !== 'string' || id.trim() !== heldId) return null;
|
||||
if (!finite(latitude) || !finite(longitude) || Math.abs(latitude) > 90)
|
||||
return null;
|
||||
const eye = isObject(raw.eye) ? raw.eye : null;
|
||||
if (!eye || !finite(eye.upM) || eye.upM < 0 || eye.upM > 1000) return null;
|
||||
if (!isObject(rawEye)) return null;
|
||||
const { upM, forwardM, pitchDeg, minClearanceM } = rawEye;
|
||||
if (!finite(upM) || upM < 0 || upM > 1000) return null;
|
||||
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;
|
||||
const headingDeg = heading(rawHeadingDeg);
|
||||
const speedMps = finite(rawSpeedMps) && rawSpeedMps >= 0 ? rawSpeedMps : null;
|
||||
return {
|
||||
id: heldId,
|
||||
name: cockpitSubjectText(raw.name, 64) || cockpitSubjectText(heldId, 64),
|
||||
name: cockpitSubjectText(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(heightM) &&
|
||||
heightM >= COCKPIT_SUBJECT_MIN_HEIGHT_M &&
|
||||
heightM <= COCKPIT_SUBJECT_MAX_HEIGHT_M
|
||||
? heightM
|
||||
: null,
|
||||
headingDeg,
|
||||
courseDeg: heading(raw.courseDeg) ?? headingDeg,
|
||||
courseDeg: heading(courseDeg) ?? headingDeg,
|
||||
speedMps,
|
||||
stale: raw.stale === true,
|
||||
groundClamp: raw.groundClamp !== false,
|
||||
stale: stale === true,
|
||||
groundClamp: groundClamp !== false,
|
||||
// An inertial anchor runs on at the frame's speed; with none it would
|
||||
// close on a moving subject at the correction's floor and fall behind.
|
||||
anchor: raw.anchor === 'exact' || speedMps === null ? 'exact' : 'inertial',
|
||||
anchor: anchor === 'exact' || speedMps === null ? 'exact' : 'inertial',
|
||||
eye: {
|
||||
upM: eye.upM,
|
||||
forwardM:
|
||||
finite(eye.forwardM) && Math.abs(eye.forwardM) <= 500
|
||||
? eye.forwardM
|
||||
: 0,
|
||||
pitchDeg: finite(eye.pitchDeg) ? clamp(eye.pitchDeg, -90, 90) : 0,
|
||||
upM,
|
||||
forwardM: finite(forwardM) && Math.abs(forwardM) <= 500 ? forwardM : 0,
|
||||
pitchDeg: finite(pitchDeg) ? clamp(pitchDeg, -90, 90) : 0,
|
||||
minClearanceM:
|
||||
finite(eye.minClearanceM) && eye.minClearanceM >= 0
|
||||
? eye.minClearanceM
|
||||
: 0,
|
||||
finite(minClearanceM) && minClearanceM >= 0 ? minClearanceM : 0,
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
@@ -642,11 +642,15 @@ test('a provider whose getter throws is left out with one warning; the next is k
|
||||
]);
|
||||
});
|
||||
|
||||
test('a worded getter that starts throwing keeps the last good words', () => {
|
||||
let failing = false;
|
||||
const words = (value) => () => {
|
||||
if (failing) throw new Error('translations unavailable');
|
||||
return value;
|
||||
test('a worded getter that throws from its second read keeps the last good words', () => {
|
||||
// Registration reads each once: the second read is the first use.
|
||||
const once = (value) => {
|
||||
let read = false;
|
||||
return () => {
|
||||
if (read) throw new Error('translations unavailable');
|
||||
read = true;
|
||||
return value;
|
||||
};
|
||||
};
|
||||
const definition = provider();
|
||||
for (const [key, value] of Object.entries({
|
||||
@@ -654,22 +658,52 @@ test('a worded getter that starts throwing keeps the last good words', () => {
|
||||
entryFace: { icon: 'commute', label: 'RIDE' },
|
||||
look: { restPitchDeg: 10, aheadLabel: 'Look ahead' },
|
||||
}))
|
||||
Object.defineProperty(definition, key, { get: words(value) });
|
||||
Object.defineProperty(definition, key, { get: once(value) });
|
||||
const { kept, warnings } = keep([definition]);
|
||||
assert.deepEqual(warnings, []);
|
||||
const [ride] = kept;
|
||||
failing = true;
|
||||
assert.equal(ride.labels.view, 'Ride view');
|
||||
assert.equal(ride.entryFace.label, 'RIDE');
|
||||
assert.deepEqual(ride.look, { restPitchDeg: 10, aheadLabel: 'Look ahead' });
|
||||
// So does a worded object whose own member throws when read.
|
||||
failing = false;
|
||||
Object.defineProperty(definition, 'labels', {
|
||||
get: () => throwingGetter({ view: 'v', exit: 'e', exitText: 'x' }, 'view'),
|
||||
});
|
||||
assert.equal(ride.labels.view, 'Ride view');
|
||||
});
|
||||
|
||||
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')),
|
||||
|
||||
@@ -3847,6 +3847,7 @@
|
||||
"1 wk/s": "أسبوع/ث",
|
||||
"Play speed": "سرعة التشغيل",
|
||||
"Scroll or pinch to zoom, drag to move along · double-click to see it all": "مرّر أو اقرص للتكبير، واسحب للتنقل · انقر نقرًا مزدوجًا لرؤية الكل",
|
||||
"Real-time": "الوقت الفعلي",
|
||||
"1 min/s": "دقيقة/ث",
|
||||
"Photo © {photographer}": "صورة © {photographer}",
|
||||
"The shared flight isn't reporting now — showing where it was last seen": "الرحلة المشتركة: لا بيانات واردة الآن — يُعرض آخر موضع معروف",
|
||||
|
||||
@@ -3487,6 +3487,7 @@
|
||||
"1 wk/s": "1 Wo./s",
|
||||
"Play speed": "Wiedergabegeschwindigkeit",
|
||||
"Scroll or pinch to zoom, drag to move along · double-click to see it all": "Scrollen oder mit zwei Fingern zoomen, ziehen zum Verschieben · Doppelklick zeigt alles",
|
||||
"Real-time": "Echtzeit",
|
||||
"1 min/s": "1 min/s",
|
||||
"Photo © {photographer}": "Foto © {photographer}",
|
||||
"The shared flight isn't reporting now — showing where it was last seen": "Der geteilte Flug sendet gerade nicht – letzte bekannte Position wird gezeigt",
|
||||
|
||||
@@ -3577,6 +3577,7 @@
|
||||
"1 wk/s": "1 sem/s",
|
||||
"Play speed": "Velocidad de reproducción",
|
||||
"Scroll or pinch to zoom, drag to move along · double-click to see it all": "Usa la rueda o pellizca para hacer zoom, arrastra para desplazarte · doble clic para verlo todo",
|
||||
"Real-time": "Tiempo real",
|
||||
"1 min/s": "1 min/s",
|
||||
"Photo © {photographer}": "Foto © {photographer}",
|
||||
"The shared flight isn't reporting now — showing where it was last seen": "El vuelo compartido no está transmitiendo ahora; se muestra dónde se vio por última vez",
|
||||
|
||||
@@ -3577,6 +3577,7 @@
|
||||
"1 wk/s": "1 sem/s",
|
||||
"Play speed": "Vitesse de lecture",
|
||||
"Scroll or pinch to zoom, drag to move along · double-click to see it all": "Faites défiler ou pincez pour zoomer, glissez pour vous déplacer · double-cliquez pour tout voir",
|
||||
"Real-time": "Temps réel",
|
||||
"1 min/s": "1 min/s",
|
||||
"Photo © {photographer}": "Photo © {photographer}",
|
||||
"The shared flight isn't reporting now — showing where it was last seen": "Le vol partagé n'émet pas actuellement — affichage de sa dernière position connue",
|
||||
|
||||
@@ -3385,6 +3385,7 @@
|
||||
"Bridge radar": "רדאר הגשר",
|
||||
"Reported voyage": "הפלגה שדווחה",
|
||||
"REPORTED VOYAGE": "הפלגה שדווחה",
|
||||
"Real-time": "זמן אמת",
|
||||
"1 min/s": "דקה/שנ׳",
|
||||
"Photo © {photographer}": "צילום © {photographer}",
|
||||
"1 h/s": "שעה/שנ׳",
|
||||
|
||||
@@ -3577,6 +3577,7 @@
|
||||
"1 wk/s": "1 sett/s",
|
||||
"Play speed": "Velocità di riproduzione",
|
||||
"Scroll or pinch to zoom, drag to move along · double-click to see it all": "Scorri o pizzica per lo zoom, trascina per spostarti · doppio clic per vedere tutto",
|
||||
"Real-time": "Tempo reale",
|
||||
"1 min/s": "1 min/s",
|
||||
"Photo © {photographer}": "Foto © {photographer}",
|
||||
"The shared flight isn't reporting now — showing where it was last seen": "Il volo condiviso non sta trasmettendo ora: viene mostrata l'ultima posizione nota",
|
||||
|
||||
@@ -3397,6 +3397,7 @@
|
||||
"1 wk/s": "1週間/秒",
|
||||
"Play speed": "再生速度",
|
||||
"Scroll or pinch to zoom, drag to move along · double-click to see it all": "スクロールまたはピンチでズーム、ドラッグで移動 · ダブルクリックで全体表示",
|
||||
"Real-time": "リアルタイム",
|
||||
"1 min/s": "1分/秒",
|
||||
"Photo © {photographer}": "写真 © {photographer}",
|
||||
"The shared flight isn't reporting now — showing where it was last seen": "共有されたフライトの位置情報は現在届いていません。最後に確認された位置を表示しています",
|
||||
|
||||
@@ -3577,6 +3577,7 @@
|
||||
"1 wk/s": "1 sem/s",
|
||||
"Play speed": "Velocidade de reprodução",
|
||||
"Scroll or pinch to zoom, drag to move along · double-click to see it all": "Role ou use o gesto de pinça para dar zoom, arraste para percorrer · clique duplo para ver tudo",
|
||||
"Real-time": "Tempo real",
|
||||
"1 min/s": "1 min/s",
|
||||
"Photo © {photographer}": "Foto © {photographer}",
|
||||
"The shared flight isn't reporting now — showing where it was last seen": "O voo compartilhado não está transmitindo agora — mostrando a última posição conhecida",
|
||||
|
||||
@@ -3667,6 +3667,7 @@
|
||||
"1 wk/s": "1 нед./с",
|
||||
"Play speed": "Скорость воспроизведения",
|
||||
"Scroll or pinch to zoom, drag to move along · double-click to see it all": "Прокрутите или сведите пальцы для масштаба, перетащите для перемещения · двойной щелчок — показать всё",
|
||||
"Real-time": "Реальное время",
|
||||
"1 min/s": "1 мин/с",
|
||||
"Photo © {photographer}": "Фото © {photographer}",
|
||||
"The shared flight isn't reporting now — showing where it was last seen": "Рейс по ссылке сейчас не передаёт данные — показано последнее известное положение",
|
||||
|
||||
@@ -3479,6 +3479,7 @@
|
||||
"Bridge radar": "Bryggradar",
|
||||
"Reported voyage": "Angiven resa",
|
||||
"REPORTED VOYAGE": "ANGIVEN RESA",
|
||||
"Real-time": "Realtid",
|
||||
"1 min/s": "1 min/s",
|
||||
"Photo © {photographer}": "Foto © {photographer}",
|
||||
"The shared flight isn't reporting now — showing where it was last seen": "Den delade flygningen rapporterar inte just nu – visar senast kända position",
|
||||
|
||||
@@ -3667,6 +3667,7 @@
|
||||
"1 wk/s": "1 тиж/с",
|
||||
"Play speed": "Швидкість відтворення",
|
||||
"Scroll or pinch to zoom, drag to move along · double-click to see it all": "Прокрутіть або зведіть пальці для масштабу, перетягніть для переміщення · подвійне клацання — показати все",
|
||||
"Real-time": "Реальний час",
|
||||
"1 min/s": "1 хв/с",
|
||||
"Photo © {photographer}": "Фото © {photographer}",
|
||||
"The shared flight isn't reporting now — showing where it was last seen": "Рейс за посиланням зараз не передає даних — показано останнє відоме місце",
|
||||
|
||||
@@ -3397,6 +3397,7 @@
|
||||
"1 wk/s": "1 周/秒",
|
||||
"Play speed": "播放速度",
|
||||
"Scroll or pinch to zoom, drag to move along · double-click to see it all": "滚动或双指缩放,拖动以移动 · 双击查看全部",
|
||||
"Real-time": "实时",
|
||||
"1 min/s": "1 分钟/秒",
|
||||
"Photo © {photographer}": "照片 © {photographer}",
|
||||
"The shared flight isn't reporting now — showing where it was last seen": "分享的航班目前无位置更新——显示其最后出现的位置",
|
||||
|
||||
@@ -3397,6 +3397,7 @@
|
||||
"1 wk/s": "1 週/秒",
|
||||
"Play speed": "播放速度",
|
||||
"Scroll or pinch to zoom, drag to move along · double-click to see it all": "滾動或雙指縮放,拖動以移動 · 雙擊查看全部",
|
||||
"Real-time": "實時",
|
||||
"1 min/s": "1 分鐘/秒",
|
||||
"Photo © {photographer}": "照片 © {photographer}",
|
||||
"The shared flight isn't reporting now — showing where it was last seen": "分享的航班目前無位置更新——顯示其最後出現的位置",
|
||||
|
||||
@@ -173,14 +173,15 @@ export function createRailCockpitSubject({
|
||||
|
||||
/**
|
||||
* Which way the train runs along its shape: as its binding learnt it from
|
||||
* successive reports, else from its drawn course against the line's
|
||||
* bearing there; 0 while neither tells.
|
||||
* successive reports, else from its operator's last reported bearing
|
||||
* against the line's bearing there; 0 while neither tells. Not the drawn
|
||||
* course: before the binding tells, that course is GPS jitter.
|
||||
*/
|
||||
function directionOf(entry) {
|
||||
const binding = entry.path;
|
||||
if (binding.direction === 1 || binding.direction === -1)
|
||||
return binding.direction;
|
||||
const course = finiteOrNull(entry.courseDeg);
|
||||
const course = finiteOrNull(binding.bearingDeg);
|
||||
const point = pointAtS(binding.path, binding.drawS, scratch);
|
||||
if (course === null || !Number.isFinite(point?.bearingDeg)) return 0;
|
||||
const turn = Math.abs(((course - point.bearingDeg + 540) % 360) - 180);
|
||||
@@ -205,8 +206,12 @@ export function createRailCockpitSubject({
|
||||
finiteOrNull(drawn?.lat) ?? finiteOrNull(sample?.lat) ?? record.lat;
|
||||
position.longitude =
|
||||
finiteOrNull(drawn?.lon) ?? finiteOrNull(sample?.lon) ?? record.lon;
|
||||
position.railHeightM = Number.isFinite(drawn?.h) ? drawn.h - liftM : null;
|
||||
position.heightQuality = Number.isFinite(drawn?.q) ? drawn.q : 0;
|
||||
const quality = Number.isFinite(drawn?.q) ? drawn.q : 0;
|
||||
// Quality 0: no floor known here, so no height; a view waits for the
|
||||
// surface.
|
||||
position.railHeightM =
|
||||
quality > 0 && Number.isFinite(drawn.h) ? drawn.h - liftM : null;
|
||||
position.heightQuality = quality;
|
||||
position.atMs = finiteOrNull(drawn?.at);
|
||||
|
||||
let path = null;
|
||||
|
||||
@@ -44,6 +44,13 @@ const PACK = Object.freeze({
|
||||
routes: { R1: [0] },
|
||||
});
|
||||
|
||||
/** A floor service that knows the ground everywhere, at 12 m. */
|
||||
const WARM_GROUND = Object.freeze({
|
||||
GROUND_FLOOR_LIFT_M: 1.5,
|
||||
cachedGroundFloor: () => 12,
|
||||
warmGroundFloor() {},
|
||||
});
|
||||
|
||||
/** Two trains on the line, T1 running east and T2 west, a step a poll. */
|
||||
async function onTheLine(t, options = {}) {
|
||||
const app = harness(t, {
|
||||
@@ -76,7 +83,7 @@ const T1 = railTrainKey('mbta-rail', 'T1');
|
||||
const T2 = railTrainKey('mbta-rail', 'T2');
|
||||
|
||||
test('the selected train reads as a snapshot of its place, motion and sources', async (t) => {
|
||||
const app = await onTheLine(t);
|
||||
const app = await onTheLine(t, { ground: WARM_GROUND });
|
||||
assert.equal(app.layer.getSelectedTrain(), null, 'nothing selected');
|
||||
app.parts().selection.selectTrain(T1);
|
||||
const view = app.layer.getSelectedTrain();
|
||||
@@ -105,6 +112,7 @@ test('the selected train reads as a snapshot of its place, motion and sources',
|
||||
assert.equal(view.provenance.positionSource, 'gps');
|
||||
assert.equal(view.provenance.timestampSource, 'vehicle');
|
||||
const drawn = app.entry(T1).drawnHeight;
|
||||
assert.ok(view.position.heightQuality > 0, 'on a known floor');
|
||||
assert.equal(view.position.railHeightM, drawn.h - 1.5);
|
||||
assert.ok(Number.isFinite(view.position.latitude));
|
||||
assert.ok(Array.isArray(view.stops));
|
||||
@@ -129,6 +137,71 @@ const stopList = (...names) =>
|
||||
state: 'upcoming',
|
||||
}));
|
||||
|
||||
test('a train drawn on an unknown floor reports no rail height', async (t) => {
|
||||
// The harness's floor service is always cold: the train is drawn on the
|
||||
// ellipsoid, which is no floor for a view to stand on.
|
||||
const app = await onTheLine(t);
|
||||
app.parts().selection.selectTrain(T1);
|
||||
const view = app.layer.getSelectedTrain();
|
||||
assert.equal(view.position.heightQuality, 0, 'no floor is known');
|
||||
assert.equal(
|
||||
view.position.railHeightM,
|
||||
null,
|
||||
'an unknown floor is no height',
|
||||
);
|
||||
});
|
||||
|
||||
test('a train on a known floor at sea level reports a rail height of 0 m', async (t) => {
|
||||
const app = await onTheLine(t, {
|
||||
ground: { ...WARM_GROUND, cachedGroundFloor: () => 0 },
|
||||
});
|
||||
app.parts().selection.selectTrain(T1);
|
||||
const { position } = app.layer.getSelectedTrain();
|
||||
assert.ok(position.heightQuality > 0, 'the floor is known');
|
||||
assert.equal(position.railHeightM, 0, 'a height, not none');
|
||||
});
|
||||
|
||||
test('a train first seen standing takes no direction from its GPS jitter', async (t) => {
|
||||
// Reports 13 m apart, and the course drawn between them, do not tell which
|
||||
// way it runs; an operator's bearing does.
|
||||
const app = harness(t, { paths: { 'mbta-rail': PACK }, at: BOSTON });
|
||||
let jitterM = 0;
|
||||
app.feeds.set('mbta-rail', () => [
|
||||
train('T1', LAT, LON0 + (1000 + jitterM) / KX),
|
||||
train('T2', LAT, LON0 + (3000 + jitterM) / KX, { bearing: 270 }),
|
||||
]);
|
||||
await app.enable();
|
||||
const seen = [];
|
||||
for (const next of [13, 0, 13, 0, 13, 0]) {
|
||||
jitterM = next;
|
||||
app.run(RAIL_POLL_MS);
|
||||
await app.poll();
|
||||
app.parts().selection.selectTrain(T1);
|
||||
const standing = app.layer.getSelectedTrain().path.direction;
|
||||
app.parts().selection.selectTrain(T2);
|
||||
seen.push([standing, app.layer.getSelectedTrain().path.direction]);
|
||||
}
|
||||
assert.deepEqual(seen, Array(6).fill([0, -1]));
|
||||
});
|
||||
|
||||
test('a standing train keeps its operator’s bearing through reports that leave it out', async (t) => {
|
||||
const app = harness(t, { paths: { 'mbta-rail': PACK }, at: BOSTON });
|
||||
let bearing = 270;
|
||||
app.feeds.set('mbta-rail', () => [
|
||||
train('T1', LAT, LON0 + 1000 / KX, { bearing }),
|
||||
]);
|
||||
await app.enable();
|
||||
const seen = [];
|
||||
for (const next of [270, 270, 270, null, null, null]) {
|
||||
bearing = next;
|
||||
app.run(RAIL_POLL_MS);
|
||||
await app.poll();
|
||||
app.parts().selection.selectTrain(T1);
|
||||
seen.push(app.layer.getSelectedTrain().path.direction);
|
||||
}
|
||||
assert.deepEqual(seen, Array(6).fill(-1));
|
||||
});
|
||||
|
||||
test('a snapshot read again while nothing changed is the one read before', async (t) => {
|
||||
let list = stopList('Alpha', 'Bravo', 'Charlie');
|
||||
const app = await onTheLine(t, {
|
||||
|
||||
@@ -1,3 +1,4 @@
|
||||
import { FIX_FLAGS } from '../../data/contactPlayback.js';
|
||||
import { pointAtS, projectOnPath } from '../../data/railPaths.js';
|
||||
|
||||
/**
|
||||
@@ -47,14 +48,23 @@ export function pathWindowM(dtMs) {
|
||||
return window > PATH_WINDOW_MAX_M ? NaN : window;
|
||||
}
|
||||
|
||||
/** Arc moved between two reports before it says which way a train runs (m). */
|
||||
const DIRECTION_MIN_M = 1;
|
||||
/**
|
||||
* Arc a train must move before it tells which way it runs (m); a standing
|
||||
* train's GPS jitter stays within it.
|
||||
*/
|
||||
export const DIRECTION_MIN_M = 15;
|
||||
|
||||
/** +1 or -1 for an arc step longer than DIRECTION_MIN_M, else `known`. */
|
||||
function directionOf(step, known) {
|
||||
return Number.isFinite(step) && Math.abs(step) > DIRECTION_MIN_M
|
||||
? Math.sign(step)
|
||||
: known;
|
||||
/**
|
||||
* The direction after one more arc position `s`: once `s` is DIRECTION_MIN_M
|
||||
* or more from `turn.s`, the sign of that move, and `turn.s` moves to `s`.
|
||||
*/
|
||||
function steer(direction, turn, s) {
|
||||
if (!Number.isFinite(s)) return direction;
|
||||
if (!Number.isFinite(turn.s)) turn.s = s;
|
||||
const step = s - turn.s;
|
||||
if (Math.abs(step) < DIRECTION_MIN_M) return direction;
|
||||
turn.s = s;
|
||||
return Math.sign(step);
|
||||
}
|
||||
|
||||
function createBinding(shapeIndex, path, via, s, fix) {
|
||||
@@ -64,14 +74,19 @@ function createBinding(shapeIndex, path, via, s, fix) {
|
||||
via,
|
||||
/**
|
||||
* Which way the drawn train runs along the shape: +1 along it, -1
|
||||
* against it, 0 until two reports or a playback segment tell. Kept until
|
||||
* a rebind. Once playback has placed the train, only playback changes
|
||||
* it: the newest reports run ahead of the drawn train, so a reversal
|
||||
* they show turns it when playback reaches it.
|
||||
* against it, 0 until it has moved DIRECTION_MIN_M (steer). Kept until
|
||||
* a rebind, and while the train stands.
|
||||
* Once a playback segment has told it (`directionPlayed`), only playback
|
||||
* changes it: the newest reports run ahead of the drawn train, so a
|
||||
* reversal they show turns it when playback reaches it.
|
||||
*/
|
||||
direction: 0,
|
||||
/** The direction the last placed playback segment ran, 0 before one. */
|
||||
drawDirection: 0,
|
||||
directionPlayed: false,
|
||||
/** steer() turn points: one for the reports, one for the played segments. */
|
||||
reportTurn: { s },
|
||||
playTurn: { s: NaN, epoch: NaN },
|
||||
/** The newest operator bearing its reports gave (deg), NaN before one. */
|
||||
bearingDeg: Number.isFinite(fix.bearingDeg) ? fix.bearingDeg : NaN,
|
||||
/** Arc and time of the newest report. */
|
||||
fixS: s,
|
||||
fixT: fix.t,
|
||||
@@ -124,7 +139,7 @@ function bestRouteShape(pack, routeId, fix, accept) {
|
||||
*
|
||||
* @param {object} pack From createRailPathPack.
|
||||
* @param {{tripId?: string, routeId?: string}} ids
|
||||
* @param {{t: number, lat: number, lon: number}} fix The newest report.
|
||||
* @param {{t: number, lat: number, lon: number, bearingDeg?: number}} fix The newest report.
|
||||
* @returns {object|null} A binding, or null to keep straight-line motion.
|
||||
*/
|
||||
export function bindTrainPath(pack, { tripId, routeId } = {}, fix) {
|
||||
@@ -146,7 +161,7 @@ export function bindTrainPath(pack, { tripId, routeId } = {}, fix) {
|
||||
/**
|
||||
* Follow a new report on the bound shape.
|
||||
* @param {object} binding
|
||||
* @param {{t: number, lat: number, lon: number}} fix
|
||||
* @param {{t: number, lat: number, lon: number, bearingDeg?: number}} fix
|
||||
* @returns {boolean} False when the report lies off the line: the binding is wrong.
|
||||
*/
|
||||
export function followFix(binding, fix) {
|
||||
@@ -159,8 +174,9 @@ export function followFix(binding, fix) {
|
||||
pathWindowM(fix.t - binding.fixT),
|
||||
);
|
||||
if (!hit || hit.offsetM > PATH_OFF_TRACK_M) return false;
|
||||
if (!binding.drawDirection)
|
||||
binding.direction = directionOf(hit.s - binding.fixS, binding.direction);
|
||||
if (!binding.directionPlayed)
|
||||
binding.direction = steer(binding.direction, binding.reportTurn, hit.s);
|
||||
if (Number.isFinite(fix.bearingDeg)) binding.bearingDeg = fix.bearingDeg;
|
||||
binding.fixS = hit.s;
|
||||
binding.fixT = fix.t;
|
||||
binding.fixLat = fix.lat;
|
||||
@@ -211,7 +227,7 @@ function projectReport(binding, fix, hintS, hintT) {
|
||||
*
|
||||
* @param {object} binding
|
||||
* @param {{fromSeq: number, toSeq: number, fraction: number}} sample Playback sample.
|
||||
* @param {{from: {seq:number, t:number, lat:number, lon:number},
|
||||
* @param {{from: {seq:number, t:number, lat:number, lon:number, flags?:number},
|
||||
* to: {seq:number, t:number, lat:number, lon:number}}} segment The sample's two reports.
|
||||
* @param {{lat?: number, lon?: number, bearingDeg?: number}} out
|
||||
* @returns {boolean} False when the train should stay on its straight-line point.
|
||||
@@ -253,11 +269,15 @@ export function placeOnPath(binding, sample, segment, out) {
|
||||
cache.sTo = sTo;
|
||||
cache.ok = Number.isFinite(sFrom) && Number.isFinite(sTo);
|
||||
if (cache.ok) {
|
||||
binding.drawDirection = directionOf(
|
||||
sTo - sFrom,
|
||||
binding.drawDirection || binding.direction || 0,
|
||||
);
|
||||
binding.direction = binding.drawDirection;
|
||||
const turn = binding.playTurn;
|
||||
// A break or a new epoch is a corrected position, not a move: steer
|
||||
// on from there.
|
||||
if (from.flags & FIX_FLAGS.BREAK || from.epoch !== turn.epoch)
|
||||
turn.s = sFrom;
|
||||
turn.epoch = from.epoch;
|
||||
binding.direction = steer(binding.direction, turn, sFrom);
|
||||
binding.direction = steer(binding.direction, turn, sTo);
|
||||
if (binding.direction) binding.directionPlayed = true;
|
||||
}
|
||||
}
|
||||
if (!cache.ok) return false;
|
||||
|
||||
@@ -1,5 +1,13 @@
|
||||
import test from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import {
|
||||
FIX_FLAGS,
|
||||
advance,
|
||||
createSample,
|
||||
createTrack,
|
||||
insertFix,
|
||||
readFix,
|
||||
} from '../../data/contactPlayback.js';
|
||||
import { createRailPathPack } from '../../data/railPaths.js';
|
||||
import {
|
||||
PATH_OFF_TRACK_M,
|
||||
@@ -209,8 +217,9 @@ test('a binding learns which way its train runs, and keeps it through a stop', (
|
||||
assert.equal(along.direction, 0, 'one report tells no direction');
|
||||
assert.ok(followFix(along, fix(10_000, 700, 0)));
|
||||
assert.equal(along.direction, 1);
|
||||
// Standing still (under a metre) keeps what it learnt.
|
||||
assert.ok(followFix(along, fix(20_000, 700.4, 0)));
|
||||
// Standing at a stop, its reports jitter back 10 m: it keeps what it
|
||||
// learnt.
|
||||
assert.ok(followFix(along, fix(20_000, 690, 0)));
|
||||
assert.equal(along.direction, 1);
|
||||
const against = bindTrainPath(p, ids, fix(0, 1500, 0));
|
||||
assert.ok(followFix(against, fix(10_000, 1200, 0)));
|
||||
@@ -262,3 +271,185 @@ test('a report that runs back turns the drawn train only when playback does', ()
|
||||
);
|
||||
assert.equal(binding.direction, -1);
|
||||
});
|
||||
|
||||
test('a jump to a corrected position in a new playback epoch is no reversal', () => {
|
||||
const binding = bindTrainPath(
|
||||
pack(),
|
||||
{ tripId: 'full', routeId: 'main' },
|
||||
fix(0, 1000, 0),
|
||||
);
|
||||
const play = (seq, from, to) => {
|
||||
const { sample, segment } = playback(seq, seq + 1, from, to, 0.5);
|
||||
return placeOnPath(binding, sample, segment, {});
|
||||
};
|
||||
assert.ok(play(0, fix(0, 1000, 0), fix(60_000, 1600, 0)));
|
||||
assert.equal(binding.direction, 1);
|
||||
// The source puts it back at 1400 m: a new epoch whose first report is a
|
||||
// break, and no segment is played from 1600 m to there.
|
||||
const epoch = { epoch: 1 };
|
||||
assert.ok(
|
||||
play(
|
||||
5,
|
||||
{ ...fix(70_000, 1400, 0), ...epoch, flags: FIX_FLAGS.BREAK },
|
||||
{ ...fix(85_000, 1400, 0), ...epoch },
|
||||
),
|
||||
);
|
||||
assert.equal(binding.direction, 1, 'standing there, it keeps its way');
|
||||
// From there, a real move back still turns it.
|
||||
assert.ok(
|
||||
play(
|
||||
6,
|
||||
{ ...fix(85_000, 1400, 0), ...epoch },
|
||||
{ ...fix(100_000, 1380, 0), ...epoch },
|
||||
),
|
||||
);
|
||||
assert.equal(binding.direction, -1);
|
||||
});
|
||||
|
||||
test('a clock correction played from past its break is no reversal', () => {
|
||||
const binding = bindTrainPath(
|
||||
pack(),
|
||||
{ tripId: 'full', routeId: 'main' },
|
||||
fix(0, 600, 0),
|
||||
);
|
||||
const track = createTrack();
|
||||
const sample = createSample();
|
||||
const segment = { from: {}, to: {} };
|
||||
let now = 0;
|
||||
/** One report at `t`, then 15 s of frames; the direction after each. */
|
||||
const report = (t, eastM) => {
|
||||
insertFix(track, fix(t, eastM, 0), { receivedAt: now, wallNowMs: now });
|
||||
return [1, 2, 3].map(() => {
|
||||
now += 5000;
|
||||
advance(track, { wallNowMs: now, monoNowMs: now }, sample);
|
||||
if (sample.fromSeq >= 0) {
|
||||
readFix(track, sample.fromSeq - track.baseSeq, segment.from);
|
||||
readFix(track, sample.toSeq - track.baseSeq, segment.to);
|
||||
placeOnPath(binding, sample, segment, {});
|
||||
}
|
||||
return binding.direction;
|
||||
});
|
||||
};
|
||||
for (const eastM of [600, 750, 900, 1050, 1200, 1200, 1200, 1200])
|
||||
report(now, eastM);
|
||||
assert.equal(binding.direction, 1);
|
||||
assert.ok(binding.directionPlayed);
|
||||
// Its source's clock falls 120 s behind and puts it at 1000 m. The third
|
||||
// such report starts a new epoch, and playback starts at the newest one,
|
||||
// past the break.
|
||||
const seen = [0, 1, 2].flatMap(() => report(now - 120_000, 1000));
|
||||
assert.equal(track.resetReason, 'out-of-order');
|
||||
assert.deepEqual(seen, Array(9).fill(1));
|
||||
});
|
||||
|
||||
/** The direction after each played segment, `[fromM, toM]` 15 s apart. */
|
||||
function playDirections(binding, steps) {
|
||||
return steps.map(([fromM, toM], seq) => {
|
||||
const { sample, segment } = playback(
|
||||
seq,
|
||||
seq + 1,
|
||||
fix(seq * 15_000, fromM, 0),
|
||||
fix((seq + 1) * 15_000, toM, 0),
|
||||
0.5,
|
||||
);
|
||||
assert.ok(placeOnPath(binding, sample, segment, {}));
|
||||
return binding.direction;
|
||||
});
|
||||
}
|
||||
|
||||
/** The direction after each report, `eastMs` 15 s apart. */
|
||||
function reportDirections(binding, eastMs) {
|
||||
return eastMs.map((eastM, i) => {
|
||||
assert.ok(followFix(binding, fix((i + 1) * 15_000, eastM, 0)));
|
||||
return binding.direction;
|
||||
});
|
||||
}
|
||||
|
||||
test('a train that moves under 15 m a report still tells its direction', () => {
|
||||
const p = pack();
|
||||
const ids = { tripId: 'full', routeId: 'main' };
|
||||
// It sets off slowly, runs east, then backs out 10 m a report.
|
||||
const learnt = reportDirections(
|
||||
bindTrainPath(p, ids, fix(0, 1000, 0)),
|
||||
[1010, 1020, 1600, 1590, 1580, 1570],
|
||||
);
|
||||
assert.deepEqual(learnt, [0, 1, 1, 1, -1, -1], 'from the newest reports');
|
||||
const played = bindTrainPath(p, ids, fix(0, 1000, 0));
|
||||
assert.deepEqual(
|
||||
playDirections(played, [
|
||||
[1000, 1600],
|
||||
[1600, 1590],
|
||||
[1590, 1580],
|
||||
[1580, 1570],
|
||||
]),
|
||||
[1, 1, -1, -1],
|
||||
'from the played-back segments',
|
||||
);
|
||||
});
|
||||
|
||||
test('a train turns 15 m back from where it ran to, not 14.9 m', () => {
|
||||
const p = pack();
|
||||
const ids = { tripId: 'full', routeId: 'main' };
|
||||
for (const [backM, want, label] of [
|
||||
[1100, -1, '15 m back'],
|
||||
[1100.1, 1, '14.9 m back'],
|
||||
]) {
|
||||
const learnt = reportDirections(bindTrainPath(p, ids, fix(0, 1000, 0)), [
|
||||
1115,
|
||||
backM,
|
||||
]);
|
||||
assert.deepEqual(learnt, [1, want], `${label}, from the newest reports`);
|
||||
assert.deepEqual(
|
||||
playDirections(bindTrainPath(p, ids, fix(0, 1000, 0)), [
|
||||
[1000, 1115],
|
||||
[1115, backM],
|
||||
]),
|
||||
[1, want],
|
||||
`${label}, from the played-back segments`,
|
||||
);
|
||||
}
|
||||
});
|
||||
|
||||
test('GPS jitter of up to 14 m at a standing train keeps its direction', () => {
|
||||
const p = pack();
|
||||
const ids = { tripId: 'full', routeId: 'main' };
|
||||
const learnt = reportDirections(
|
||||
bindTrainPath(p, ids, fix(0, 1000, 0)),
|
||||
[1600, 1588, 1600, 1586, 1599, 1587],
|
||||
);
|
||||
assert.deepEqual(learnt, [1, 1, 1, 1, 1, 1], 'from the newest reports');
|
||||
const played = bindTrainPath(p, ids, fix(0, 1000, 0));
|
||||
assert.deepEqual(
|
||||
playDirections(played, [
|
||||
[1000, 1600],
|
||||
[1600, 1588],
|
||||
[1588, 1600],
|
||||
[1600, 1586],
|
||||
[1586, 1599],
|
||||
]),
|
||||
[1, 1, 1, 1, 1],
|
||||
'from the played-back segments',
|
||||
);
|
||||
|
||||
// On both sides of where it stopped: 8 m either way, 16 m from end to end.
|
||||
assert.deepEqual(
|
||||
reportDirections(
|
||||
bindTrainPath(p, ids, fix(0, 600, 0)),
|
||||
[1000, 1008, 1000, 992, 1000, 1008],
|
||||
),
|
||||
[1, 1, 1, 1, 1, 1],
|
||||
'both sides, from the newest reports',
|
||||
);
|
||||
assert.deepEqual(
|
||||
playDirections(bindTrainPath(p, ids, fix(0, 600, 0)), [
|
||||
[600, 1000],
|
||||
[1000, 1008],
|
||||
[1008, 1000],
|
||||
[1000, 992],
|
||||
[992, 1000],
|
||||
[1000, 1008],
|
||||
]),
|
||||
[1, 1, 1, 1, 1, 1],
|
||||
'both sides, from the played-back segments',
|
||||
);
|
||||
});
|
||||
@@ -16,6 +16,7 @@ import {
|
||||
import { displayMotion } from '../transit/movement.js';
|
||||
import { FIX_FLAGS, readFix } from '../../data/contactPlayback.js';
|
||||
import { roundHeadingDegrees } from '../../data/headingDegrees.js';
|
||||
import { DIRECTION_MIN_M } from './pathBinding.js';
|
||||
import {
|
||||
stopClock,
|
||||
stopLateMinutes,
|
||||
@@ -294,9 +295,6 @@ export function playbackModeFor(railMode) {
|
||||
: 'rail';
|
||||
}
|
||||
|
||||
/** Two reports closer than this are one place: a parked train's jitter (m). */
|
||||
export const FOLLOW_MIN_MOVE_M = 15;
|
||||
|
||||
const lastFix = {};
|
||||
const priorFix = {};
|
||||
|
||||
@@ -333,7 +331,7 @@ export function railTrainFollowable(entry) {
|
||||
sample.nextMotionT > sample.displayT
|
||||
)
|
||||
return true;
|
||||
return lastReportsApartM(entry.track) >= FOLLOW_MIN_MOVE_M;
|
||||
return lastReportsApartM(entry.track) >= DIRECTION_MIN_M;
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@@ -83,13 +83,16 @@ export function createTransitCockpitSubject({ state, parts, services }) {
|
||||
* lift: the drawn marker's height while the frame pass places it (in view,
|
||||
* or held), which near the ground follows the terrain between reports;
|
||||
* else its segment's two reports' floors at the playback fraction. Null
|
||||
* while either floor is unknown, as on cold terrain, so a view waits for
|
||||
* the surface. Not `entry.heightM`, the floor at the newest report, which
|
||||
* playback has not reached yet.
|
||||
* while either of those two floors is unknown, as on cold terrain, so a
|
||||
* view waits for the surface. Not `entry.heightM`, the floor at the newest
|
||||
* report, which playback has not reached yet.
|
||||
*/
|
||||
function drawnFloorOf(entry) {
|
||||
const segment = entry.segment;
|
||||
if (!segment || entry.heightPending) return null;
|
||||
const from = segment.from?.h;
|
||||
const to = segment.to?.h;
|
||||
if (!Number.isFinite(from) || !Number.isFinite(to)) return null;
|
||||
const placed =
|
||||
entry.surfaceReady === true &&
|
||||
entry.hasRendered &&
|
||||
@@ -99,9 +102,6 @@ export function createTransitCockpitSubject({ state, parts, services }) {
|
||||
const drawn = toCartographicRadians(entry.marker.position);
|
||||
if (drawn) return drawn.height - liftM;
|
||||
}
|
||||
const from = segment.from?.h;
|
||||
const to = segment.to?.h;
|
||||
if (!Number.isFinite(from) || !Number.isFinite(to)) return null;
|
||||
const f = Number.isFinite(segment.fraction)
|
||||
? Math.max(0, Math.min(1, segment.fraction))
|
||||
: 1;
|
||||
@@ -173,16 +173,32 @@ export function createTransitCockpitSubject({ state, parts, services }) {
|
||||
return snapshot;
|
||||
}
|
||||
|
||||
/** Show or hide a vehicle's sprite and trail for the hold. */
|
||||
/**
|
||||
* Place a vehicle and show or hide its sprite and trail for the hold now:
|
||||
* the icon set draws a marker as it was last pushed, not as it is.
|
||||
*/
|
||||
function repaint(entry) {
|
||||
if (!entry?.marker) return;
|
||||
if (entry.key === state._cockpitSubjectKey) entry.marker.show = false;
|
||||
else parts.rendering.placeSample(entry);
|
||||
parts.rendering.placeSample(entry);
|
||||
parts.rendering.flushMarkers();
|
||||
parts.rendering.schedulePlayback(entry);
|
||||
parts.trails.update();
|
||||
state._detectRevision += 1;
|
||||
}
|
||||
|
||||
/**
|
||||
* A vehicle let go of is out of play until a sweep finds it in view. It
|
||||
* played on while held, so the next sweep keeps its clock if it finds it in
|
||||
* view (rendering.js).
|
||||
*/
|
||||
function release(entry) {
|
||||
if (!entry) return;
|
||||
state._visible.delete(entry);
|
||||
entry.releasedFromHold = true;
|
||||
parts.rendering.requestVisibility();
|
||||
repaint(entry);
|
||||
}
|
||||
|
||||
const methods = {
|
||||
/** The selected vehicle (see createTransitCockpitSubject), or null. */
|
||||
getSelectedVehicle() {
|
||||
@@ -202,13 +218,7 @@ export function createTransitCockpitSubject({ state, parts, services }) {
|
||||
const previous = state._vehicles.get(state._cockpitSubjectKey);
|
||||
if (key === null || key === undefined) {
|
||||
state._cockpitSubjectKey = null;
|
||||
// The hold kept it in play out of view: it leaves until the next
|
||||
// visibility sweep finds it in view again.
|
||||
if (previous) {
|
||||
state._visible.delete(previous);
|
||||
parts.rendering.requestVisibility();
|
||||
}
|
||||
repaint(previous);
|
||||
release(previous);
|
||||
parts.selection.refreshSelectedCard(true);
|
||||
return true;
|
||||
}
|
||||
@@ -217,7 +227,7 @@ export function createTransitCockpitSubject({ state, parts, services }) {
|
||||
if (state._selectedKey !== key) parts.selection.selectVehicle(key);
|
||||
state._cockpitSubjectKey = key;
|
||||
state._visible.add(entry);
|
||||
if (previous && previous !== entry) repaint(previous);
|
||||
if (previous !== entry) release(previous);
|
||||
repaint(entry);
|
||||
parts.selection.refreshSelectedCard(true);
|
||||
return true;
|
||||
|
||||
@@ -165,6 +165,8 @@ export function createLifecycle({ state, services, parts }) {
|
||||
state._visible.clear();
|
||||
clearTimeout(state._cameraDebounceTimer);
|
||||
state._cameraDebounceTimer = null;
|
||||
// A hold ends with the layer (cockpitSubject.js).
|
||||
state._cockpitSubjectKey = null;
|
||||
parts.selection.clearSelection();
|
||||
state._overlayHost.setVisible(TRANSIT_SELECTED_OVERLAY_SOURCE_ID, false);
|
||||
parts.selection.removeClickHandler();
|
||||
|
||||
@@ -957,27 +957,70 @@ test('disable aborts in-flight work and a response that lands late is ignored',
|
||||
assert.equal(app.vehicles().length, 1);
|
||||
});
|
||||
|
||||
test('a held vehicle with no floor yet tells its view no height', async (t) => {
|
||||
// Not the ellipsoid: a first-person view waits for the surface instead.
|
||||
const app = harness(t, { floorAt: () => undefined });
|
||||
/**
|
||||
* Serves one bus at `place.lat` (read on every poll), enables the layer, polls
|
||||
* once and settles; returns its entry.
|
||||
*/
|
||||
async function oneBus(app, place = { lat: 42.36 }) {
|
||||
app.serve('mbta', () => ({
|
||||
status: 200,
|
||||
body: snapshot(
|
||||
'mbta',
|
||||
'MBTA',
|
||||
[vehicle('bus-1', 42.36, -71.06, Date.now() / 1000)],
|
||||
[vehicle('bus-1', place.lat, -71.06, reported())],
|
||||
{ fetchedAt: Date.now() },
|
||||
),
|
||||
}));
|
||||
app.layer.enable(app.viewer);
|
||||
await app.layer.update();
|
||||
app.settle();
|
||||
const entry = app.vehicles()[0];
|
||||
return app.vehicles()[0];
|
||||
}
|
||||
|
||||
test('a held vehicle with no floor yet tells its view no height', async (t) => {
|
||||
// Not the ellipsoid: a first-person view waits for the surface instead.
|
||||
const app = harness(t, { floorAt: () => undefined });
|
||||
const entry = await oneBus(app);
|
||||
assert.equal(entry.heightPending, true, 'it has nothing to stand on');
|
||||
assert.ok(app.layer.setCockpitSubject(entry.key) !== false);
|
||||
assert.equal(app.layer.getCockpitSubject().position.groundHeightM, null);
|
||||
});
|
||||
|
||||
test('with the camera above the height gate, a held vehicle drawn on the ellipsoid tells its view no height', async (t) => {
|
||||
const app = harness(t, { altitude: 100_000, floorAt: () => undefined });
|
||||
const entry = await oneBus(app);
|
||||
assert.ok(app.layer.setCockpitSubject(entry.key) !== false);
|
||||
app.frame();
|
||||
assert.equal(entry.surfaceReady, true, 'it is drawn');
|
||||
const drawnM = Cesium.Cartographic.fromCartesian(
|
||||
entry.marker.position,
|
||||
).height;
|
||||
assert.ok(Math.abs(drawnM) < 1e-3, `on the ellipsoid, got ${drawnM} m`);
|
||||
assert.equal(app.layer.getCockpitSubject().position.groundHeightM, null);
|
||||
});
|
||||
|
||||
test('with the camera above the height gate, a held vehicle with one floor unknown tells its view no height', async (t) => {
|
||||
// Drawn between a floor its view could stand on and none.
|
||||
for (const knownLat of [42.36, 42.361]) {
|
||||
await t.test(`floor known at ${knownLat}`, async (t) => {
|
||||
const app = harness(t, { altitude: 100_000, floorAt: () => undefined });
|
||||
app.ground._warm.set(app.ground._key(knownLat, -71.06), 12);
|
||||
const start = Date.now();
|
||||
const place = { lat: 42.36 };
|
||||
const entry = await oneBus(app, place);
|
||||
place.lat = 42.361;
|
||||
app.run(TRANSIT_POLL_MS);
|
||||
await app.layer.update();
|
||||
assert.equal(app.layer.setCockpitSubject(entry.key), true);
|
||||
app.run(start - AGE_MS + LAG_MS + TRANSIT_POLL_MS / 2 - Date.now());
|
||||
const { from, to } = entry.segment;
|
||||
assert.notEqual(Number.isFinite(from.h), Number.isFinite(to.h));
|
||||
assert.equal(entry.surfaceReady, true, 'it is drawn');
|
||||
assert.equal(app.layer.getCockpitSubject().position.groundHeightM, null);
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
test('a vehicle waits for its floor rather than standing on the ellipsoid', async (t) => {
|
||||
// The shared ground-floor system answers from the rendered mesh cell or the
|
||||
// real DEM cell; until one of them is warm there is no honest height to draw
|
||||
@@ -2118,13 +2161,19 @@ test('a segment climbs from the ground it left to the ground it reaches', async
|
||||
`its snapshot stands where it is drawn, got ${floor().toFixed(1)} m`,
|
||||
);
|
||||
|
||||
// Halfway along the segment it is halfway up; at the end, on the high ground.
|
||||
// Halfway along the segment it still follows the low ground it crosses; at
|
||||
// the end, it is on the high ground.
|
||||
const firstFixAt = start - AGE_MS;
|
||||
app.run(firstFixAt + LAG_MS + TRANSIT_POLL_MS / 2 - Date.now());
|
||||
assert.ok(
|
||||
Math.abs(height() - 11.5) < 3,
|
||||
`at the corridor floor, got ${height().toFixed(1)} m`,
|
||||
);
|
||||
// The two reports' floors blended at the fraction would say about 55 m.
|
||||
assert.ok(
|
||||
Math.abs(floor() + 1.5 - height()) < 1,
|
||||
`its snapshot stands on that floor too, got ${floor().toFixed(1)} m`,
|
||||
);
|
||||
app.run(TRANSIT_POLL_MS);
|
||||
assert.ok(
|
||||
Math.abs(height() - 101.5) < 1.5,
|
||||
@@ -4881,3 +4930,197 @@ test('a held vehicle hides, keeps moving out of view, and lets go when it goes',
|
||||
assert.equal(app.state()._cockpitSubjectKey, null);
|
||||
assert.equal(app.layer.getCockpitSubject(), null);
|
||||
});
|
||||
|
||||
/** A vehicle's icon in the set that draws it, still or moving. */
|
||||
function iconOf(app, key) {
|
||||
return app.markers('still').get(key) ?? app.markers('moving').get(key);
|
||||
}
|
||||
|
||||
test('turning Transit off ends a hold; on again, the vehicle shows, a click selects it and Escape deselects it', async (t) => {
|
||||
const app = harness(t);
|
||||
const key = await busRunningNorth(app);
|
||||
assert.equal(app.layer.setCockpitSubject(key), true);
|
||||
app.layer.disable(app.viewer);
|
||||
assert.equal(
|
||||
app.state()._cockpitSubjectKey,
|
||||
null,
|
||||
'the hold ended with the layer',
|
||||
);
|
||||
// On again, without a release: the same bus is listed again.
|
||||
app.layer.enable(app.viewer);
|
||||
await app.layer.update();
|
||||
app.settle();
|
||||
app.run(TRANSIT_POLL_MS);
|
||||
await app.layer.update();
|
||||
app.settle();
|
||||
const [entry] = app.vehicles();
|
||||
app.frame();
|
||||
assert.equal(entry.marker.show, true, 'the vehicle is drawn, not held');
|
||||
assert.equal(iconOf(app, key)?.show, true, 'and so is its icon in the set');
|
||||
app.viewer.scene.pick = () => app.pickOf(entry);
|
||||
app.input.click(new Cesium.Cartesian2(500, 400));
|
||||
assert.equal(app.state()._selectedKey, key, 'a click selects it');
|
||||
globalThis.document.dispatchEvent(
|
||||
Object.assign(new Event('keydown'), { key: 'Escape' }),
|
||||
);
|
||||
assert.equal(app.state()._selectedKey, null, 'Escape deselects');
|
||||
});
|
||||
|
||||
test('a held parked vehicle draws no icon; let go, it draws its icon again', async (t) => {
|
||||
// A parked bus with no course: nothing moves or turns its icon, so only the
|
||||
// hold itself can take the icon out of the set that draws it.
|
||||
const app = harness(t);
|
||||
app.serve('mbta', () => ({
|
||||
status: 200,
|
||||
body: snapshot(
|
||||
'mbta',
|
||||
'MBTA',
|
||||
[vehicle('bus-1', 42.36, -71.06, reported(), { stopId: 'place-1' })],
|
||||
{ fetchedAt: Date.now() },
|
||||
),
|
||||
}));
|
||||
app.layer.enable(app.viewer);
|
||||
await app.layer.update();
|
||||
app.settle();
|
||||
for (let i = 0; i < 3; i += 1) {
|
||||
app.run(TRANSIT_POLL_MS);
|
||||
await app.layer.update();
|
||||
app.settle();
|
||||
}
|
||||
const key = 'mbta:bus-1';
|
||||
const [entry] = app.vehicles();
|
||||
assert.equal(iconOf(app, key)?.show, true, 'drawn before the hold');
|
||||
assert.equal(app.layer.setCockpitSubject(key), true);
|
||||
assert.equal(iconOf(app, key)?.show ?? false, false, 'hidden at once');
|
||||
// The view rides it for a while: frames, a sweep, a poll.
|
||||
app.run(2_000, 16);
|
||||
app.settle();
|
||||
app.run(TRANSIT_POLL_MS);
|
||||
await app.layer.update();
|
||||
app.settle();
|
||||
assert.equal(entry.marker.show, false, 'its marker is hidden');
|
||||
assert.equal(
|
||||
iconOf(app, key)?.show ?? false,
|
||||
false,
|
||||
'and so is the icon the set draws',
|
||||
);
|
||||
|
||||
assert.equal(app.layer.setCockpitSubject(null), true);
|
||||
app.advance(250);
|
||||
app.settle();
|
||||
assert.equal(iconOf(app, key)?.show, true, 'let go: drawn again');
|
||||
});
|
||||
|
||||
test('a hold moved to another vehicle lets the first go out of view', async (t) => {
|
||||
const app = harness(t);
|
||||
app.serve('mbta', () => ({
|
||||
status: 200,
|
||||
body: snapshot(
|
||||
'mbta',
|
||||
'MBTA',
|
||||
[
|
||||
vehicle('bus-1', 42.36, -71.06, reported()),
|
||||
vehicle('bus-2', 42.37, -71.05, reported()),
|
||||
],
|
||||
{ fetchedAt: Date.now() },
|
||||
),
|
||||
}));
|
||||
app.layer.enable(app.viewer);
|
||||
await app.layer.update();
|
||||
app.settle();
|
||||
const bus = (id) => app.vehicles().find((entry) => entry.key === id);
|
||||
const first = bus('mbta:bus-1');
|
||||
assert.equal(app.layer.setCockpitSubject(first.key), true);
|
||||
// The view looks away from both, as a view from inside the first does.
|
||||
app.lookAt({ west: -70.98, south: 42.3, east: -70.9, north: 42.42 });
|
||||
app.advance(250);
|
||||
app.settle();
|
||||
assert.equal(app.state()._visible.has(bus('mbta:bus-2')), false);
|
||||
assert.equal(app.layer.setCockpitSubject('mbta:bus-2'), true);
|
||||
assert.equal(app.state()._visible.has(first), false, 'let go, out of play');
|
||||
assert.equal(first.marker.show, false, 'and not drawn out of view');
|
||||
});
|
||||
|
||||
test('a vehicle in view let go of a hold goes on from its own clock', async (t) => {
|
||||
// Held, it played on; let go, the sweep that finds it in view does not
|
||||
// set its clock again, though the feed's lag has grown since.
|
||||
for (const next of ['mbta:b', null]) {
|
||||
await t.test(`the hold moves to ${next}`, async (t) => {
|
||||
const app = harness(t, { floorAt: () => 5 });
|
||||
let fixAt = Date.now() - AGE_MS;
|
||||
let north = 42.36;
|
||||
app.serve('mbta', () => ({
|
||||
status: 200,
|
||||
body: snapshot(
|
||||
'mbta',
|
||||
'MBTA',
|
||||
[
|
||||
vehicle('a', north, -71.06, fixAt / 1000),
|
||||
vehicle('b', 42.37, -71.05, reported()),
|
||||
],
|
||||
{ fetchedAt: Date.now() },
|
||||
),
|
||||
}));
|
||||
app.layer.enable(app.viewer);
|
||||
await app.layer.update();
|
||||
app.settle();
|
||||
const a = app.vehicles().find((e) => e.key === 'mbta:a');
|
||||
app.layer.setCockpitSubject(a.key);
|
||||
for (let poll = 1; poll <= 5; poll += 1) {
|
||||
fixAt += TRANSIT_POLL_MS;
|
||||
north += 0.001;
|
||||
app.run(TRANSIT_POLL_MS);
|
||||
await app.layer.update();
|
||||
}
|
||||
// One late poll raises the feed's target lag.
|
||||
app.run(TRANSIT_POLL_MS + 10_000);
|
||||
fixAt += TRANSIT_POLL_MS;
|
||||
north += 0.001;
|
||||
await app.layer.update();
|
||||
app.run(3_000);
|
||||
const beforeT = a.track.displayT;
|
||||
const beforeLat = lat(a);
|
||||
app.layer.setCockpitSubject(next);
|
||||
app.advance(250);
|
||||
app.settle();
|
||||
assert.equal(app.state()._visible.has(a), true, 'A is in view');
|
||||
assert.ok(a.track.displayT >= beforeT, 'its clock did not go back');
|
||||
assert.ok(lat(a) >= beforeLat, 'nor did it move back');
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
test('holding a vehicle out of view tells its view at once the floor it stands on', async (t) => {
|
||||
// Out of view a vehicle plays on but its marker is not moved: the hold
|
||||
// places it, so its view reads the floor it is on now, not the old one or
|
||||
// null.
|
||||
const app = harness(t, { floorAt: (lat) => (lat > 42.3625 ? 100 : 10) });
|
||||
for (const [lat, floorM] of [
|
||||
[42.361, 10],
|
||||
[42.362, 10],
|
||||
[42.363, 100],
|
||||
[42.364, 100],
|
||||
])
|
||||
app.ground._warm.set(app.ground._key(lat, -71.06), floorM);
|
||||
const place = { lat: 42.36 };
|
||||
const entry = await oneBus(app, place);
|
||||
const drawnM = () =>
|
||||
Cesium.Cartographic.fromCartesian(entry.marker.position).height;
|
||||
assert.ok(Math.abs(drawnM() - 11.5) < 1, 'drawn on the low ground');
|
||||
app.lookAt({ west: -70.98, south: 42.3, east: -70.9, north: 42.42 });
|
||||
app.advance(250);
|
||||
app.settle();
|
||||
assert.equal(app.state()._visible.has(entry), false, 'out of view');
|
||||
// Unseen, it drives up the hill and stands there.
|
||||
for (const next of [42.361, 42.362, 42.363, 42.364, 42.364, 42.364]) {
|
||||
place.lat = next;
|
||||
app.run(TRANSIT_POLL_MS);
|
||||
await app.layer.update();
|
||||
}
|
||||
app.run(LAG_MS);
|
||||
app.settle();
|
||||
assert.ok(drawnM() < 30, 'its marker was left on the low ground');
|
||||
assert.equal(app.layer.setCockpitSubject(entry.key), true);
|
||||
const floorM = app.layer.getCockpitSubject().position.groundHeightM;
|
||||
assert.ok(Math.abs(floorM - 100) < 1.5, `up the hill, got ${floorM} m`);
|
||||
});
|
||||
@@ -1154,13 +1154,18 @@ export function createRendering({ state, services, parts }) {
|
||||
visibility.noSample = noSample;
|
||||
const wasShown = entry.marker.show;
|
||||
const wasVisible = state._visible.has(entry);
|
||||
// Just let go of a hold (cockpitSubject.js): it played on, so keep
|
||||
// its clock.
|
||||
const playedOn = entry.releasedFromHold === true;
|
||||
entry.releasedFromHold = false;
|
||||
if (visible) state._visible.add(entry);
|
||||
else state._visible.delete(entry);
|
||||
// Turned afresh once back in view: the camera may have moved while it
|
||||
// was out, after the pass that would have turned it.
|
||||
if (visible && !wasVisible) entry.rotationCourse = undefined;
|
||||
if (visible && entry.track?.count) {
|
||||
if (!wasVisible && !entry.qaFixture) syncPlayback(entry, now);
|
||||
if (!wasVisible && !playedOn && !entry.qaFixture)
|
||||
syncPlayback(entry, now);
|
||||
// Re-entry can advance into an unprepared corridor; loaded tiles can
|
||||
// also resolve a cold path without a poll or a render-loop wakeup.
|
||||
if (!wasVisible || entry.surfaceReady === false || entry.heightPending)
|
||||
|
||||
+31
-9
@@ -336,7 +336,7 @@ function updateVessel(nowMs) {
|
||||
* gives none) and slew toward its heading. A frame that is null, malformed or
|
||||
* for another subject ends the view, as an aircraft tracked meanwhile does.
|
||||
* The update runs on the provider's `cameraIntervalMs` (0: every frame), and
|
||||
* its rates advance by the time that interval spans (cockpitSubjectStepSec).
|
||||
* its rates advance by the time since the last update (cockpitSubjectStepSec).
|
||||
*/
|
||||
function updateSubject(nowMs) {
|
||||
const provider = this.subjectProvider;
|
||||
@@ -357,6 +357,7 @@ function updateSubject(nowMs) {
|
||||
}
|
||||
this.lastSubjectFrame = frame;
|
||||
let heightM = frame.heightM;
|
||||
let held = false;
|
||||
if (heightM === null) {
|
||||
this.services.warmGroundFloor?.([
|
||||
{ lat: frame.latitude, lon: frame.longitude },
|
||||
@@ -366,8 +367,10 @@ function updateSubject(nowMs) {
|
||||
frame.longitude,
|
||||
);
|
||||
// A frame with no height stands on the shared floor; while that is cold
|
||||
// it keeps the height it last stood at.
|
||||
heightM = Number.isFinite(floorM) ? floorM : this.subjectHeightM;
|
||||
// the eye keeps the last height it stood at (a frame's or the floor's),
|
||||
// at first the entry frame's.
|
||||
held = !Number.isFinite(floorM);
|
||||
heightM = held ? this.subjectHeightM : floorM;
|
||||
}
|
||||
if (!Number.isFinite(heightM)) {
|
||||
// Nothing to stand on yet, from the first frame: the camera stays where
|
||||
@@ -399,6 +402,21 @@ function updateSubject(nowMs) {
|
||||
}
|
||||
this.surfaceWaitStartedMs = 0;
|
||||
this.surfaceAcquiring = false;
|
||||
if (!held) {
|
||||
// The first height to replace the entry frame's is the anchor's at once
|
||||
// (an inertial anchor would close on it only at the horizontal
|
||||
// correction's rate); where the anchor stands, it stays.
|
||||
if (
|
||||
this.subjectHeightFromEntry &&
|
||||
this.cockpitAnchorValid &&
|
||||
heightM !== this.subjectHeightM
|
||||
) {
|
||||
const anchor = toCartographicRadians(this.cockpitAnchor);
|
||||
if (anchor)
|
||||
this.cockpitAnchor = fromRadians(anchor.lon, anchor.lat, heightM);
|
||||
}
|
||||
this.subjectHeightFromEntry = false;
|
||||
}
|
||||
this.subjectHeightM = heightM;
|
||||
const target = fromDegrees(frame.longitude, frame.latitude, heightM);
|
||||
const dtSec = cockpitSubjectStepSec(nowMs - this.lastFrameMs, intervalMs);
|
||||
@@ -411,7 +429,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;
|
||||
@@ -459,8 +479,10 @@ function updateSubject(nowMs) {
|
||||
* Aircraft pass none and look along the heading at the profile pitch.
|
||||
*/
|
||||
function placeCamera(target, info, nowMs, dtSec, profile, look = null) {
|
||||
if (!this.cockpitAnchorValid) {
|
||||
this.cockpitAnchor = clone(target);
|
||||
// The update that first sets the anchor stands it on the target: the time
|
||||
// before it (an entry, a floor wait) moved nothing, so it has no step.
|
||||
const anchoring = !this.cockpitAnchorValid;
|
||||
if (anchoring) {
|
||||
this.cockpitAnchorValid = true;
|
||||
this.subjectLiftM = null;
|
||||
}
|
||||
@@ -485,7 +507,7 @@ function placeCamera(target, info, nowMs, dtSec, profile, look = null) {
|
||||
: 0;
|
||||
|
||||
const groundClamp = info.groundClamp !== false;
|
||||
if (info.stale || info.anchor === 'exact') {
|
||||
if (anchoring || info.stale || info.anchor === 'exact') {
|
||||
// A feed backoff has no authoritative velocity epoch to advance from.
|
||||
// Hold the cockpit on the exact layer-rendered position so the camera
|
||||
// cannot coast away while the icon correctly remains fixed.
|
||||
@@ -503,8 +525,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,8 +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 height an application subject's eye last stood at (m). */
|
||||
this.subjectHeightM = null;
|
||||
/** Whether `subjectHeightM` is still the one its entry frame gave. */
|
||||
this.subjectHeightFromEntry = false;
|
||||
/** The ground clamp's eased lift under that subject's eye (m). */
|
||||
this.subjectLiftM = null;
|
||||
/**
|
||||
@@ -735,8 +737,16 @@ export class CockpitViewController {
|
||||
publishCockpitSignals() {
|
||||
return publishCockpitSignals.call(this);
|
||||
}
|
||||
pushCockpitSignal(key, tone, title, detail, target) {
|
||||
return pushCockpitSignal.call(this, key, tone, title, detail, target);
|
||||
pushCockpitSignal(key, tone, title, detail, target, options) {
|
||||
return pushCockpitSignal.call(
|
||||
this,
|
||||
key,
|
||||
tone,
|
||||
title,
|
||||
detail,
|
||||
target,
|
||||
options,
|
||||
);
|
||||
}
|
||||
dropCockpitSignal(key) {
|
||||
return dropCockpitSignal.call(this, key);
|
||||
|
||||
@@ -444,10 +444,10 @@ test('Cockpit places the eye at its aircraft as the Cesium maths did', async ()
|
||||
latitude: 30.19,
|
||||
longitude: -97.67,
|
||||
onGround: false,
|
||||
stale: true,
|
||||
stale: false,
|
||||
};
|
||||
const { owner, views } = cockpitOver({ info, target });
|
||||
// Held on the target while the feed is stale.
|
||||
// The first update stands the anchor on the target.
|
||||
owner.update();
|
||||
let expected = cesiumCockpitEye(Cesium, {
|
||||
target,
|
||||
@@ -456,13 +456,12 @@ test('Cockpit places the eye at its aircraft as the Cesium maths did', async ()
|
||||
dtSec: 0,
|
||||
liftM: 0,
|
||||
});
|
||||
near(views[0].destination, expected.eye, 1e-6, 'stale eye');
|
||||
near(views[0].destination, expected.eye, 1e-6, 'first eye');
|
||||
near(views[0].orientation.direction, expected.forward, 1e-12, 'direction');
|
||||
near(views[0].orientation.up, expected.up, 1e-12, 'up');
|
||||
|
||||
// Live: the anchor coasts 80 ms along the heading and is pulled toward
|
||||
// where the layer now shows the aircraft.
|
||||
info.stale = false;
|
||||
const anchor = Cesium.Cartesian3.clone(expected.anchor);
|
||||
const moved = Cesium.Cartesian3.fromDegrees(-97.6698, 30.1901, 1210);
|
||||
owner.trackedFollow.position = () => moved;
|
||||
|
||||
@@ -256,20 +256,21 @@ function updateSubjectHud(info, nowMs, forceContext) {
|
||||
this.updateLocalPosition(info);
|
||||
this.maybeRefreshRegionalBrief(info);
|
||||
this.showContextCard(false);
|
||||
const keys = new Set();
|
||||
for (const signal of hud.signals) {
|
||||
const key = `subject:${signal.id}`;
|
||||
keys.add(key);
|
||||
this.pushCockpitSignal(
|
||||
key,
|
||||
SUBJECT_SIGNAL_TONES[signal.tone] ?? 'info',
|
||||
signal.title,
|
||||
signal.detail || signal.title,
|
||||
);
|
||||
}
|
||||
const keys = new Set(hud.signals.map(({ id }) => `subject:${id}`));
|
||||
// Rows the view no longer lists leave first, so new ones take their
|
||||
// places rather than push a listed one (or TRACK ACQUIRED) off.
|
||||
for (const key of this.subjectSignalKeys ?? [])
|
||||
if (!keys.has(key)) this.dropCockpitSignal(key);
|
||||
this.subjectSignalKeys = keys;
|
||||
for (const signal of hud.signals)
|
||||
this.pushCockpitSignal(
|
||||
`subject:${signal.id}`,
|
||||
SUBJECT_SIGNAL_TONES[signal.tone] ?? 'info',
|
||||
signal.title,
|
||||
signal.detail || signal.title,
|
||||
null,
|
||||
{ inPlace: true },
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -39,17 +39,42 @@ export function publishCockpitSignals() {
|
||||
this.scheduleContextLayout();
|
||||
}
|
||||
|
||||
export function pushCockpitSignal(key, tone, title, detail, target = null) {
|
||||
/**
|
||||
* 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, so a
|
||||
* changing ETA never pushes a steady warning off the list; it keeps its
|
||||
* time while it stays listed, and one pushed off comes back as the newest
|
||||
* row.
|
||||
*/
|
||||
export function pushCockpitSignal(
|
||||
key,
|
||||
tone,
|
||||
title,
|
||||
detail,
|
||||
target = null,
|
||||
{ inPlace = false } = {},
|
||||
) {
|
||||
if (!title || !detail) return;
|
||||
const signature = `${title}|${detail}|${target?.layerId || ''}|${target?.id || ''}`;
|
||||
if (this.signalSignatures.get(key) === signature) return;
|
||||
this.signalSignatures.set(key, signature);
|
||||
// JSON, not a joined string, so a separator inside a title or detail cannot
|
||||
// make two rows match. An in-place row also changes with its tone alone.
|
||||
const signature = JSON.stringify([
|
||||
title,
|
||||
detail,
|
||||
target?.layerId || '',
|
||||
target?.id || '',
|
||||
inPlace ? tone : '',
|
||||
]);
|
||||
// A locale change words the signal again where it stands.
|
||||
const shown = this.rewordingSignals
|
||||
? this.signalItems.find((item) => item.key === key)
|
||||
: null;
|
||||
const shown =
|
||||
this.rewordingSignals || inPlace
|
||||
? this.signalItems.find((item) => item.key === key)
|
||||
: null;
|
||||
if (this.signalSignatures.get(key) === signature && (!inPlace || shown))
|
||||
return;
|
||||
this.signalSignatures.set(key, signature);
|
||||
if (shown) {
|
||||
Object.assign(shown, { title, detail });
|
||||
Object.assign(shown, { tone, title, detail });
|
||||
this.publishCockpitSignals();
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -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({
|
||||
@@ -123,7 +127,10 @@ function subjectProvider(overrides = {}) {
|
||||
return { definition, subject, calls };
|
||||
}
|
||||
|
||||
function fixture(t, { providers = [], vessel = null, layerOn = true } = {}) {
|
||||
function fixture(
|
||||
t,
|
||||
{ providers = [], vessel = null, layerOn = true, realSignals = false } = {},
|
||||
) {
|
||||
document.body.replaceChildren();
|
||||
const host = document.body.appendChild(document.createElement('div'));
|
||||
const pinia = createPinia();
|
||||
@@ -204,6 +211,7 @@ function fixture(t, { providers = [], vessel = null, layerOn = true } = {}) {
|
||||
instruments: (view) => store.publishInstruments(view),
|
||||
route: (view) => store.publishRoute(view),
|
||||
radar: (view) => store.publishRadar(view),
|
||||
signals: realSignals ? (view) => store.publishSignals(view) : undefined,
|
||||
},
|
||||
});
|
||||
Object.assign(cockpit, {
|
||||
@@ -211,17 +219,20 @@ function fixture(t, { providers = [], vessel = null, layerOn = true } = {}) {
|
||||
showBriefPage() {},
|
||||
startBriefRotation() {},
|
||||
stopBriefRotation() {},
|
||||
pushCockpitSignal(key, tone, title, detail) {
|
||||
signals.push({ key, tone, title, detail });
|
||||
},
|
||||
dropCockpitSignal(key) {
|
||||
dropped.push(key);
|
||||
},
|
||||
scheduleContextLayout() {},
|
||||
updateLocalPosition() {},
|
||||
maybeRefreshRegionalBrief() {},
|
||||
showContextCard() {},
|
||||
});
|
||||
if (!realSignals)
|
||||
Object.assign(cockpit, {
|
||||
pushCockpitSignal(key, tone, title, detail) {
|
||||
signals.push({ key, tone, title, detail });
|
||||
},
|
||||
dropCockpitSignal(key) {
|
||||
dropped.push(key);
|
||||
},
|
||||
});
|
||||
t.after(() => {
|
||||
cockpit.stop();
|
||||
app.unmount();
|
||||
@@ -281,6 +292,25 @@ async function settle() {
|
||||
/** The provider's last release call. */
|
||||
const lastRelease = (calls) => calls.findLast(([name]) => name === 'release');
|
||||
|
||||
/**
|
||||
* Move `ride`'s subject east at `speedMps` from `startMs` (the manual clock's
|
||||
* start) on an inertial anchor, its frame otherwise as it was with `extra`
|
||||
* on top; returns a function giving its longitude now.
|
||||
*/
|
||||
function movingEast(ride, startMs, speedMps, extra = {}) {
|
||||
const eastNow = () =>
|
||||
eastM((speedMps * (performance.now() - startMs)) / 1000);
|
||||
const base = ride.subject.frame;
|
||||
ride.subject.frame = () => ({
|
||||
...base,
|
||||
longitude: eastNow(),
|
||||
speedMps,
|
||||
anchor: 'inertial',
|
||||
...extra,
|
||||
});
|
||||
return eastNow;
|
||||
}
|
||||
|
||||
/** The camera's height above the ellipsoid in its last shot (m). */
|
||||
const shotHeight = (shots) =>
|
||||
Cesium.Cartographic.fromCartesian(shots.at(-1).destination).height;
|
||||
@@ -560,7 +590,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);
|
||||
@@ -585,7 +615,78 @@ test('a subject updated every 500 ms turns, eases and closes on its target at it
|
||||
// A long stall (a hidden tab) moves it as one late update would.
|
||||
clock.advance(60_000);
|
||||
cockpit.update();
|
||||
assert.ok(Math.abs(cockpit.heading - 101) < 1e-6, 'at most 0.6 s');
|
||||
assert.ok(Math.abs(cockpit.heading - 110) < 1e-6, 'at most 1.5 s');
|
||||
});
|
||||
|
||||
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 eastNow = movingEast(ride, startMs, 30);
|
||||
const { cockpit, shots } = fixture(t, { providers: [ride] });
|
||||
cockpit.syncEntry();
|
||||
assert.equal(cockpit.enter(), true);
|
||||
for (let i = 0; i < 300; i += 1) {
|
||||
clock.advance(200);
|
||||
cockpit.update();
|
||||
}
|
||||
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,
|
||||
`after 60 s the camera is ${gapM.toFixed(0)} m from the subject`,
|
||||
);
|
||||
});
|
||||
|
||||
test("an inertial subject's first camera update after a floor wait longer than its step stands on it", async (t) => {
|
||||
const startMs = 10_000;
|
||||
const clock = manualClock(t, startMs);
|
||||
const intervalMs = 500;
|
||||
const ride = subjectProvider({ cameraIntervalMs: intervalMs });
|
||||
const eastNow = movingEast(ride, startMs, 30, { heightM: null });
|
||||
const { cockpit, shots, setFloor } = fixture(t, { providers: [ride] });
|
||||
setFloor(undefined);
|
||||
cockpit.syncEntry();
|
||||
assert.equal(cockpit.enter(), true);
|
||||
const before = shots.length;
|
||||
// 2 s cold: longer than the 1.5 s an update may step.
|
||||
for (let waited = intervalMs; waited < 2000; waited += intervalMs) {
|
||||
clock.advance(intervalMs);
|
||||
cockpit.update();
|
||||
}
|
||||
assert.equal(
|
||||
shots.length,
|
||||
before,
|
||||
'no camera update while the floor is cold',
|
||||
);
|
||||
setFloor(FLOOR_M);
|
||||
clock.advance(intervalMs);
|
||||
cockpit.update();
|
||||
const shot = Cesium.Cartographic.fromCartesian(shots[before].destination);
|
||||
const leadM =
|
||||
(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`,
|
||||
);
|
||||
});
|
||||
|
||||
test('an exact anchor sits on the subject, wherever the frame moves it', async (t) => {
|
||||
@@ -863,6 +964,47 @@ test('a floor that never comes ends the view after the bounded wait, releasing t
|
||||
assert.deepEqual(lastRelease(ride.calls), ['release', 'a1', false]);
|
||||
});
|
||||
|
||||
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.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;
|
||||
const releases = [];
|
||||
@@ -942,6 +1084,30 @@ test('a provider’s labels, entry face and look follow a change of language', a
|
||||
);
|
||||
});
|
||||
|
||||
test('a provider whose labels throw after registration enters with no HUD kicker', async (t) => {
|
||||
manualClock(t, 10_000);
|
||||
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] });
|
||||
cockpit.syncEntry();
|
||||
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) => {
|
||||
const clock = manualClock(t, 10_000);
|
||||
const ride = subjectProvider();
|
||||
@@ -1122,26 +1288,78 @@ test('a subject first seen together with a built-in one comes after it', async (
|
||||
assert.equal(store.presence.entryKind, 'vessel');
|
||||
});
|
||||
|
||||
/**
|
||||
* Every world position projects to (x, y): the scene query port projects
|
||||
* through Cesium.SceneTransforms.
|
||||
*/
|
||||
function everythingAt(t, x, y) {
|
||||
t.mock.method(
|
||||
Cesium.SceneTransforms,
|
||||
'worldToWindowCoordinates',
|
||||
(_scene, _position, result = new Cesium.Cartesian2()) =>
|
||||
Object.assign(result, { x, y }),
|
||||
);
|
||||
}
|
||||
|
||||
test("a double-click on the selected vessel does not enter an application's subject", async (t) => {
|
||||
const clock = manualClock(t, 10_000);
|
||||
const ride = subjectProvider();
|
||||
ride.subject.candidate = null;
|
||||
const { cockpit, store, viewer } = fixture(t, {
|
||||
const { cockpit, store } = fixture(t, {
|
||||
providers: [ride],
|
||||
vessel: VESSEL,
|
||||
});
|
||||
everythingAt(t, 100, 100);
|
||||
cockpit.syncEntry();
|
||||
assert.equal(store.presence.entryKind, 'vessel');
|
||||
// The first press of the double-click notes where the vessel is drawn.
|
||||
cockpit.onScenePointerDown();
|
||||
// The application's subject is selected after the vessel: it takes entry.
|
||||
clock.advance(500);
|
||||
ride.subject.candidate = { id: 'a1', name: 'Example 12', selectedAt: 1 };
|
||||
cockpit.syncEntry();
|
||||
assert.equal(cockpit.resolveEntryKind(), 'example-kind');
|
||||
// Every world position lands under the pointer, the vessel's sprite too.
|
||||
viewer.scene.cartesianToCanvasCoordinates = (_position, result = {}) =>
|
||||
Object.assign(result, { x: 400, y: 300 });
|
||||
assert.equal(cockpit.onSceneDoubleClick({ x: 400, y: 300 }), false);
|
||||
assert.equal(store.presence.entryKind, 'example-kind');
|
||||
// The user double-clicks the vessel, still selected.
|
||||
assert.equal(cockpit.onSceneDoubleClick({ x: 100, y: 100 }), false);
|
||||
await settle();
|
||||
assert.notEqual(store.presence.active, true);
|
||||
assert.equal(
|
||||
cockpit.subjectProvider ?? null,
|
||||
null,
|
||||
'no provider view entered from a double-click on the vessel',
|
||||
);
|
||||
assert.equal(
|
||||
ride.calls.some(([name]) => name === 'hold'),
|
||||
false,
|
||||
'the provider subject was not held',
|
||||
);
|
||||
});
|
||||
|
||||
test('the same double-click on the vessel alone enters its bridge', async (t) => {
|
||||
manualClock(t, 10_000);
|
||||
const { cockpit, store } = fixture(t, { vessel: VESSEL });
|
||||
everythingAt(t, 100, 100);
|
||||
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 moving vessel's first bridge update after entry stands the anchor on its fix", async (t) => {
|
||||
const clock = manualClock(t, 10_000);
|
||||
const { cockpit } = fixture(t, { vessel: VESSEL });
|
||||
cockpit.syncEntry();
|
||||
assert.equal(cockpit.enter(), true);
|
||||
clock.advance(1000);
|
||||
cockpit.update();
|
||||
const anchor = Cesium.Cartographic.fromCartesian(cockpit.cockpitAnchor);
|
||||
const fix = cockpit.vesselFix;
|
||||
const gapM = Cesium.Cartesian3.distance(
|
||||
Cesium.Cartesian3.fromRadians(anchor.longitude, anchor.latitude, 0),
|
||||
Cesium.Cartesian3.fromDegrees(fix.longitude, fix.latitude, 0),
|
||||
);
|
||||
assert.ok(gapM < 0.01, `the anchor is ${gapM.toFixed(2)} m from the fix`);
|
||||
});
|
||||
|
||||
test('a provider view with look turns with the arrow keys and words its readout', async (t) => {
|
||||
@@ -1188,3 +1406,238 @@ test('rows a HUD view no longer lists leave Live Signals', async (t) => {
|
||||
cockpit.update();
|
||||
assert.ok(dropped.includes('subject:note'));
|
||||
});
|
||||
|
||||
test('a signal still listed stays in Live Signals while another one changes', async (t) => {
|
||||
const clock = manualClock(t, 10_000);
|
||||
const ride = subjectProvider();
|
||||
const { cockpit } = fixture(t, { providers: [ride], realSignals: true });
|
||||
// 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',
|
||||
},
|
||||
],
|
||||
});
|
||||
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(', ')})`,
|
||||
);
|
||||
// The changing one is one row, worded as it reads now.
|
||||
const etas = cockpit.signalItems.filter((row) => row.key === 'subject:eta');
|
||||
assert.deepEqual(
|
||||
etas.map((row) => row.detail),
|
||||
['Central in 2 min'],
|
||||
);
|
||||
// Rows pushed off the list by newer ones come back while still listed.
|
||||
for (let i = 0; i < 5; i += 1)
|
||||
cockpit.pushCockpitSignal(`other-${i}`, 'info', 'OTHER', `row ${i}`);
|
||||
assert.equal(
|
||||
cockpit.signalItems.some((row) => row.key.startsWith('subject:')),
|
||||
false,
|
||||
);
|
||||
clock.advance(1000);
|
||||
cockpit.update();
|
||||
assert.deepEqual(
|
||||
cockpit.signalItems
|
||||
.map((row) => row.key)
|
||||
.filter((key) => key.startsWith('subject:'))
|
||||
.sort(),
|
||||
['subject:doors', 'subject:eta'],
|
||||
);
|
||||
});
|
||||
|
||||
test('a Live Signals row whose tone alone changes takes the new tone', async (t) => {
|
||||
const clock = manualClock(t, 10_000);
|
||||
const ride = subjectProvider();
|
||||
const { cockpit, store } = fixture(t, {
|
||||
providers: [ride],
|
||||
realSignals: true,
|
||||
});
|
||||
const hudWith = (tone) => ({
|
||||
...HUD,
|
||||
signals: [
|
||||
{ id: 'doors', tone, title: 'DOORS', detail: 'door fault, car 2' },
|
||||
],
|
||||
});
|
||||
// The class of the row Live Signals shows.
|
||||
const doorsTone = () =>
|
||||
store.signals.find((row) => row.title === 'DOORS').className;
|
||||
ride.subject.hud = hudWith('normal');
|
||||
cockpit.syncEntry();
|
||||
assert.equal(cockpit.enter(), true);
|
||||
const tones = [doorsTone()];
|
||||
for (const tone of ['warning', 'normal']) {
|
||||
ride.subject.hud = hudWith(tone);
|
||||
clock.advance(1000);
|
||||
cockpit.update();
|
||||
tones.push(doorsTone());
|
||||
}
|
||||
assert.deepEqual(tones, ['info', 'warning', 'info']);
|
||||
});
|
||||
|
||||
test('rows a HUD view replaces leave before new ones push a listed one off', async (t) => {
|
||||
const clock = manualClock(t, 10_000);
|
||||
const ride = subjectProvider();
|
||||
const { cockpit } = fixture(t, { providers: [ride], realSignals: true });
|
||||
const row = (id, tone) => ({
|
||||
id,
|
||||
tone,
|
||||
title: id.toUpperCase(),
|
||||
detail: `row ${id}`,
|
||||
});
|
||||
ride.subject.hud = {
|
||||
...HUD,
|
||||
signals: [row('w', 'warning'), row('a'), row('b'), row('c')],
|
||||
};
|
||||
cockpit.syncEntry();
|
||||
assert.equal(cockpit.enter(), true);
|
||||
assert.ok(cockpit.signalItems.some((item) => item.key === 'track'));
|
||||
ride.subject.hud = {
|
||||
...HUD,
|
||||
signals: [row('w', 'warning'), row('a'), row('d'), row('e')],
|
||||
};
|
||||
clock.advance(1000);
|
||||
cockpit.update();
|
||||
const keys = cockpit.signalItems.map((item) => item.key);
|
||||
assert.deepEqual(
|
||||
[...keys].sort(),
|
||||
['subject:a', 'subject:d', 'subject:e', 'subject:w', 'track'],
|
||||
`rows right after the change: ${keys.join(', ')}`,
|
||||
);
|
||||
});
|
||||
|
||||
// An inertial subject placed at its entry frame's height while the floor was
|
||||
// cold stands on the floor as soon as it warms, as an exact anchor does.
|
||||
test('an inertial subject placed at its entry height stands on the floor once it warms', async (t) => {
|
||||
const clock = manualClock(t, 10_000);
|
||||
const ride = subjectProvider();
|
||||
ride.subject.frame = {
|
||||
...ride.subject.frame,
|
||||
heightM: FLOOR_M,
|
||||
speedMps: 0,
|
||||
anchor: 'inertial',
|
||||
eye: { ...ride.subject.frame.eye, forwardM: 0 },
|
||||
};
|
||||
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 };
|
||||
clock.advance(100);
|
||||
cockpit.update();
|
||||
assert.ok(Math.abs(shotHeight(shots) - (FLOOR_M + 3.5)) < 0.01);
|
||||
const floorM = FLOOR_M - 100;
|
||||
setFloor(floorM);
|
||||
for (let i = 0; i < 10; i += 1) {
|
||||
clock.advance(100);
|
||||
cockpit.update();
|
||||
}
|
||||
const heightM = shotHeight(shots);
|
||||
assert.ok(
|
||||
Math.abs(heightM - (floorM + 3.5)) < 1,
|
||||
`1 s after the floor came the eye is at ${heightM.toFixed(2)} m, not ${floorM + 3.5} m`,
|
||||
);
|
||||
});
|
||||
|
||||
/** How far east of LON the camera's last shot is (m). */
|
||||
const shotEastM = (shots) =>
|
||||
(Cesium.Math.toDegrees(
|
||||
Cesium.Cartographic.fromCartesian(shots.at(-1).destination).longitude,
|
||||
) -
|
||||
LON) *
|
||||
M_PER_DEG_LON;
|
||||
|
||||
test('the first floor after an entry height moves an inertial anchor as a cold floor does', async (t) => {
|
||||
// The provider corrects its subject 100 m east as the floor arrives.
|
||||
const run = (warm) => {
|
||||
const clock = manualClock(t, 10_000);
|
||||
const ride = subjectProvider();
|
||||
ride.subject.frame = {
|
||||
...ride.subject.frame,
|
||||
heightM: FLOOR_M,
|
||||
speedMps: 0,
|
||||
anchor: 'inertial',
|
||||
groundClamp: false,
|
||||
};
|
||||
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 };
|
||||
clock.advance(100);
|
||||
cockpit.update();
|
||||
const beforeM = shotEastM(shots);
|
||||
ride.subject.frame = { ...ride.subject.frame, longitude: eastM(100) };
|
||||
if (warm) setFloor(FLOOR_M + 0.1);
|
||||
clock.advance(100);
|
||||
cockpit.update();
|
||||
const stepM = shotEastM(shots) - beforeM;
|
||||
const heightM = shotHeight(shots);
|
||||
cockpit.stop();
|
||||
return { stepM, heightM };
|
||||
};
|
||||
const cold = run(false);
|
||||
const warm = run(true);
|
||||
assert.ok(
|
||||
Math.abs(warm.stepM - cold.stepM) < 0.02,
|
||||
`east step ${warm.stepM.toFixed(3)} m with the floor arriving, ${cold.stepM.toFixed(3)} m with it cold`,
|
||||
);
|
||||
assert.ok(Math.abs(warm.heightM - (FLOOR_M + 0.1 + 3.5)) < 0.02);
|
||||
});
|
||||
|
||||
test('the first floor after an entry height never steps an inertial anchor back to a held fix', async (t) => {
|
||||
const startMs = 10_000;
|
||||
const clock = manualClock(t, startMs);
|
||||
const ride = subjectProvider();
|
||||
const base = {
|
||||
...ride.subject.frame,
|
||||
heightM: FLOOR_M,
|
||||
speedMps: 30,
|
||||
anchor: 'inertial',
|
||||
groundClamp: false,
|
||||
};
|
||||
ride.subject.frame = base;
|
||||
const { cockpit, shots, setFloor } = fixture(t, { providers: [ride] });
|
||||
setFloor(undefined);
|
||||
cockpit.syncEntry();
|
||||
assert.equal(cockpit.enter(), true);
|
||||
// Telemetry that gives a new fix once a second, 30 m on each time.
|
||||
ride.subject.frame = () => ({
|
||||
...base,
|
||||
heightM: null,
|
||||
longitude: eastM(30 * Math.floor((performance.now() - startMs) / 1000)),
|
||||
});
|
||||
for (let i = 0; i < 17; i += 1) {
|
||||
clock.advance(100);
|
||||
cockpit.update();
|
||||
}
|
||||
const beforeM = shotEastM(shots);
|
||||
// The floor arrives 1 cm off the entry height, between two fixes.
|
||||
setFloor(FLOOR_M + 0.01);
|
||||
clock.advance(100);
|
||||
cockpit.update();
|
||||
const stepM = shotEastM(shots) - beforeM;
|
||||
assert.ok(stepM > 0, `the eye stepped ${stepM.toFixed(2)} m east`);
|
||||
});
|
||||
@@ -516,7 +516,10 @@ function enterSubject(provider) {
|
||||
this.surfaceAcquiring = false;
|
||||
this.surfaceFallback = false;
|
||||
this.cockpitAnchorValid = false;
|
||||
this.subjectHeightM = null;
|
||||
// The entry frame's height, if any, stands in for a cold floor
|
||||
// (updateSubject).
|
||||
this.subjectHeightM = frame.heightM;
|
||||
this.subjectHeightFromEntry = true;
|
||||
this.lookRestPitchDeg = provider.look?.restPitchDeg ?? null;
|
||||
this.resetLook({ immediate: true });
|
||||
this.active = true;
|
||||
|
||||
@@ -20,7 +20,7 @@ import UiSelect from '../../kit/UiSelect.js';
|
||||
const store = useWorldTimeStore();
|
||||
const { time, speed } = storeToRefs(store);
|
||||
const speeds = computed(() => [
|
||||
{ value: 'real', label: '1×' },
|
||||
{ value: 'real', label: t('Real-time') },
|
||||
{ value: 'minute', label: t('1 min/s') },
|
||||
{ value: 'hour', label: t('1 h/s') },
|
||||
{ value: 'day', label: t('1 d/s') },
|
||||
|
||||
Reference in new issue
Block a user