mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-17 00:32:21 +00:00
Civil and military aircraft were drawn a fixed 30 s (15 s) behind real time while anonymous feed reports arrive about 90 s old every 30 s, so every contact dead reckoned about a minute past its newest report and snapped when the next one landed (several km on a turn), and the tracked trail, recorded from those drawn positions and patched as reports arrived, kinked. - The display delay (data/displayDelay.js) is the 90th percentile of the newest 256 report lags plus 5 s, between the layer's floor (30 s, 15 s) and five minutes, slewed at most 0.2 s/s up and 0.05 s/s down. Icons, the renderer's live motion clock, labels, HUD, detection, the tracked camera and the trail read the one delay; following the world clock draws with none and deliveries leave it alone. - Between two reports an aircraft flies a biarc (data/fixCurve.js) that passes through both and leaves each along its track, sent as contract arc segments; the trail is the reports joined along the same curve, so the icon sits on it. Nothing drawn between reports is kept. - A report a coasting contact missed is eased onto from where it would have been that frame (at least 3 s, at most 30% over its speed, within 20 s); over 5 km it jumps. Past its newest report a contact coasts straight on: a turn rate averaged over earlier reports outlived the turn. - Forward synthetic fixes no longer block real reports older than them, and a history keeps 24 fixes. - A feed simulation (testSupport/aircraftFeedSim.mjs) checks both layers against a 90 s late feed, a fallback switch, repeated reports, outages and the world clock.
427 lines
13 KiB
JavaScript
427 lines
13 KiB
JavaScript
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import * as Cesium from 'cesium';
|
|
import { createMotion } from './motion.js';
|
|
import { createFlightState } from './state.js';
|
|
import { createTracking } from './tracking.js';
|
|
import {
|
|
staleCoastSeconds,
|
|
staleHoldsAtLastReport,
|
|
} from '../../data/motionModel.js';
|
|
import { TRAIL_CONTINUITY_MAX_SPEED_KT } from '../../data/trailContinuity.js';
|
|
import { RENDER_DELAY_SEC } from './policy.js';
|
|
|
|
const SEC = 1000;
|
|
// Ellipsoidal ground at a sea-level airfield (geoid about -32 m).
|
|
const FIELD_GROUND_M = -30;
|
|
|
|
/** A motion module over one contact's history, with a fixed clock. */
|
|
function motionFixture({ info, fixes, nowMs, ground = () => null }) {
|
|
const flightState = {
|
|
records: { data: new Map([['00a001', info]]) },
|
|
_positionHistory: new Map([['00a001', fixes]]),
|
|
_focusEvidenceIds: new Set(),
|
|
_scratchArc: {},
|
|
_scratchOffset: new Cesium.Cartesian3(),
|
|
_scratchRenderTime: new Cesium.JulianDate(),
|
|
_scratchCoastCarto: new Cesium.Cartographic(),
|
|
now: () => nowMs,
|
|
};
|
|
const motion = createMotion({
|
|
flightState,
|
|
services: {
|
|
groundFloor: {
|
|
cachedGroundFloor: ground,
|
|
floorAltitudeM: (alt, g) =>
|
|
Number.isFinite(g) ? Math.max(alt, g + 1.5) : alt,
|
|
},
|
|
camera: {},
|
|
focus: {},
|
|
},
|
|
parts: {},
|
|
});
|
|
return { flightState, motion };
|
|
}
|
|
|
|
function fix(timeMs, lat, lon, heightM, velocity, track) {
|
|
return {
|
|
time: Cesium.JulianDate.fromDate(new Date(timeMs)),
|
|
epochMs: timeMs,
|
|
position: Cesium.Cartesian3.fromDegrees(lon, lat, heightM),
|
|
velocity,
|
|
track,
|
|
};
|
|
}
|
|
|
|
const height = (position) => Cesium.Cartographic.fromCartesian(position).height;
|
|
|
|
test('a stale contact holds at its last report when it reported on the ground or low', () => {
|
|
assert.equal(staleHoldsAtLastReport({ onGround: true }), true);
|
|
// A light aircraft on final: -30 m barometric, its render height 1.5 m above the known ground.
|
|
assert.equal(
|
|
staleHoldsAtLastReport({
|
|
onGround: false,
|
|
heightM: FIELD_GROUND_M + 1.5,
|
|
groundM: FIELD_GROUND_M,
|
|
}),
|
|
true,
|
|
);
|
|
// Ground unknown: a low barometric altitude alone does not hold it; it
|
|
// coasts under the cap.
|
|
assert.equal(
|
|
staleHoldsAtLastReport({ onGround: false, heightM: 120 }),
|
|
false,
|
|
);
|
|
// A high airfield: 1,600 m barometric but 60 m above its ground.
|
|
assert.equal(
|
|
staleHoldsAtLastReport({
|
|
onGround: false,
|
|
heightM: 1_660,
|
|
groundM: 1_600,
|
|
}),
|
|
true,
|
|
);
|
|
assert.equal(
|
|
staleHoldsAtLastReport({
|
|
onGround: false,
|
|
heightM: 10_000,
|
|
groundM: 20,
|
|
}),
|
|
false,
|
|
);
|
|
});
|
|
|
|
test('a stale contact coasts up to its source limit at any speed, and a holding one not at all', () => {
|
|
const coast = (over) =>
|
|
staleCoastSeconds({
|
|
elapsedSec: 400,
|
|
coastLimitSec: 300,
|
|
speedMps: 230,
|
|
holds: false,
|
|
...over,
|
|
});
|
|
assert.equal(coast(), 300);
|
|
assert.equal(coast({ elapsedSec: 200 }), 200);
|
|
assert.equal(coast({ coastLimitSec: 60 }), 60);
|
|
assert.equal(coast({ speedMps: 1_000 }), 300);
|
|
assert.equal(coast({ holds: true }), 0);
|
|
assert.equal(coast({ elapsedSec: -5 }), 0);
|
|
});
|
|
|
|
test('a light aircraft on short final goes stale after a low, slow, descending report, the icon holds at that report, not below the ground', () => {
|
|
const t0 = Date.UTC(2026, 10, 9, 20, 0);
|
|
const fixes = [
|
|
fix(t0, 38.1279, -122.5425, 122, 40, 340),
|
|
fix(t0 + 30 * SEC, 38.133, -122.5494, 38, 37, 10),
|
|
fix(t0 + 60 * SEC, 38.1436, -122.5561, FIELD_GROUND_M + 1.5, 36.4, 63),
|
|
];
|
|
const info = {
|
|
altitude: -30,
|
|
renderAltitudeM: FIELD_GROUND_M + 1.5,
|
|
rawLat: 38.1436,
|
|
rawLon: -122.5561,
|
|
velocity: 36.4,
|
|
true_track: 63,
|
|
onGround: false,
|
|
wasAirborne: true,
|
|
lastContactEpochMs: t0 + 60 * SEC,
|
|
};
|
|
for (const afterSec of [5, 45, 90, 240]) {
|
|
const nowMs = t0 + 60 * SEC + RENDER_DELAY_SEC * SEC + afterSec * SEC;
|
|
const { motion } = motionFixture({
|
|
info,
|
|
fixes,
|
|
nowMs,
|
|
ground: () => FIELD_GROUND_M,
|
|
});
|
|
const drawn = motion._deadReckon('00a001', new Cesium.Cartesian3());
|
|
assert.ok(
|
|
Cesium.Cartesian3.distance(drawn, fixes[2].position) < 0.01,
|
|
`${afterSec} s after the report the icon is at the report`,
|
|
);
|
|
assert.ok(height(drawn) >= FIELD_GROUND_M);
|
|
}
|
|
});
|
|
|
|
function cruiser(lastContactAfterSec) {
|
|
const t0 = Date.UTC(2026, 10, 9, 20, 0);
|
|
const fixes = [
|
|
fix(t0, 40, -100, 10_000, 230, 90),
|
|
fix(t0 + 15 * SEC, 40, -99.96, 10_000, 230, 90),
|
|
];
|
|
const info = {
|
|
altitude: 10_000,
|
|
renderAltitudeM: 10_000,
|
|
rawLat: 40,
|
|
rawLon: -99.96,
|
|
velocity: 230,
|
|
true_track: 90,
|
|
onGround: false,
|
|
wasAirborne: true,
|
|
lastContactEpochMs: t0 + 15 * SEC + lastContactAfterSec * SEC,
|
|
};
|
|
const at = (afterSec) => {
|
|
const nowMs = t0 + 15 * SEC + RENDER_DELAY_SEC * SEC + afterSec * SEC;
|
|
const { motion } = motionFixture({ info, fixes, nowMs });
|
|
return motion._deadReckon('00a001', new Cesium.Cartesian3());
|
|
};
|
|
const d = (p) => Cesium.Cartesian3.distance(p, fixes[1].position);
|
|
return { at, d };
|
|
}
|
|
|
|
test('a cruising contact still heard after its last position coasts past 90 s, for up to 5 minutes, then stops', () => {
|
|
// Contact kept arriving for four minutes after the last position.
|
|
const { at, d } = cruiser(240);
|
|
const near = (got, want) => Math.abs(got - want) < want * 0.005 + 50;
|
|
assert.ok(near(d(at(90)), 230 * 90));
|
|
assert.ok(near(d(at(200)), 230 * 200), 'still moving at 200 s');
|
|
assert.ok(near(d(at(300)), 230 * 300));
|
|
assert.ok(near(d(at(400)), 230 * 300), 'stopped at 300 s');
|
|
assert.ok(Cesium.Cartesian3.distance(at(400), at(600)) < 0.01);
|
|
});
|
|
|
|
test('a cruising contact that stops reporting coasts five minutes, then stops', () => {
|
|
const { at, d } = cruiser(0);
|
|
assert.ok(Math.abs(d(at(60)) - 230 * 60) < 120);
|
|
assert.ok(Math.abs(d(at(300)) - 230 * 300) < 600);
|
|
assert.ok(Cesium.Cartesian3.distance(at(301), at(420)) < 0.01);
|
|
});
|
|
|
|
test('a bad reported speed coasts no faster than the 1,500 kt continuity limit', () => {
|
|
const t0 = Date.UTC(2026, 10, 9, 20, 0);
|
|
// 2,000 m/s (about 3,900 kt): a corrupt velocity, not a real aircraft.
|
|
const fixes = [
|
|
fix(t0, 40, -100, 10_000, 2_000, 90),
|
|
fix(t0 + 15 * SEC, 40, -99.96, 10_000, 2_000, 90),
|
|
];
|
|
const info = {
|
|
altitude: 10_000,
|
|
renderAltitudeM: 10_000,
|
|
rawLat: 40,
|
|
rawLon: -99.96,
|
|
velocity: 2_000,
|
|
true_track: 90,
|
|
onGround: false,
|
|
wasAirborne: true,
|
|
};
|
|
const nowMs = t0 + 15 * SEC + RENDER_DELAY_SEC * SEC + 300 * SEC;
|
|
const { motion } = motionFixture({ info, fixes, nowMs });
|
|
const drawn = motion._deadReckon('00a001', new Cesium.Cartesian3());
|
|
const limitMps = (TRAIL_CONTINUITY_MAX_SPEED_KT * 1852) / 3600;
|
|
const d = Cesium.Cartesian3.distance(drawn, fixes[1].position);
|
|
assert.ok(Math.abs(d - limitMps * 300) < 1_500, `${d.toFixed(0)} m`);
|
|
});
|
|
|
|
test('coasting never takes a contact below the ground', () => {
|
|
const t0 = Date.UTC(2026, 10, 9, 20, 0);
|
|
const fixes = [
|
|
fix(t0, 39.7, -105.5, 3_400, 80, 270),
|
|
fix(t0 + 15 * SEC, 39.7, -105.514, 3_400, 80, 270),
|
|
];
|
|
const info = {
|
|
altitude: 3_400,
|
|
renderAltitudeM: 3_400,
|
|
rawLat: 39.7,
|
|
rawLon: -105.514,
|
|
velocity: 80,
|
|
true_track: 270,
|
|
onGround: false,
|
|
wasAirborne: true,
|
|
};
|
|
// 3,000 m under the report, rising to 3,600 m along the coast west.
|
|
const nowMs = t0 + 15 * SEC + RENDER_DELAY_SEC * SEC + 60 * SEC;
|
|
const { motion } = motionFixture({
|
|
info,
|
|
fixes,
|
|
nowMs,
|
|
ground: (lat, lon) => (lon < -105.52 ? 3_600 : 3_000),
|
|
});
|
|
const drawn = motion._deadReckon('00a001', new Cesium.Cartesian3());
|
|
assert.ok(height(drawn) >= 3_600, `height ${height(drawn)}`);
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// The trail and head across a stale gap.
|
|
|
|
function services(trail) {
|
|
const names = [
|
|
'picking',
|
|
'sprites',
|
|
'aircraftPresentation',
|
|
'camera',
|
|
'militaryRegistry',
|
|
'labels',
|
|
'meshFloor',
|
|
'focus',
|
|
'readout',
|
|
'context',
|
|
'render',
|
|
'recession',
|
|
];
|
|
return {
|
|
...Object.fromEntries(names.map((name) => [name, {}])),
|
|
groundSnap: { createGroundSnap: () => ({ clear() {} }) },
|
|
trails: trail,
|
|
geoid: { ensureGeoidReady: async () => {}, geoidHeight: () => 0 },
|
|
groundFloor: {
|
|
resolveGroundFloorCellsBounded: async () => {},
|
|
cachedGroundFloor: () => null,
|
|
floorAltitudeM: (alt) => alt,
|
|
},
|
|
};
|
|
}
|
|
|
|
function trailHarness({ fixes, nowMs, head }) {
|
|
const calls = [];
|
|
const trail = {
|
|
createTrail: () => ({
|
|
setSegments(segments) {
|
|
calls.push(segments.map((segment) => segment.slice()));
|
|
},
|
|
setPositions(positions) {
|
|
calls.push([positions.slice()]);
|
|
},
|
|
setVisible() {},
|
|
clear() {},
|
|
destroy() {},
|
|
}),
|
|
};
|
|
const svc = services(trail);
|
|
const flightState = createFlightState({
|
|
services: svc,
|
|
source: { label: 'Fixture aircraft' },
|
|
});
|
|
const added = [];
|
|
flightState._viewer = {
|
|
isDestroyed: () => false,
|
|
entities: {
|
|
add(definition) {
|
|
added.push(definition);
|
|
return definition;
|
|
},
|
|
remove() {},
|
|
},
|
|
};
|
|
flightState._trackedIcao = '00a001';
|
|
let clock = nowMs;
|
|
flightState.now = () => clock;
|
|
flightState._positionHistory.set('00a001', fixes);
|
|
let headPosition = head;
|
|
const tracking = createTracking({
|
|
flightState,
|
|
services: svc,
|
|
parts: {
|
|
motion: {
|
|
_isTrackWarmingUp: () => false,
|
|
_trackedTrailCached: () => headPosition,
|
|
_trackedDisplayPosition: () => headPosition,
|
|
_trackedModelCenterWorld: () => null,
|
|
_trackedModelEnvelopeM: () => null,
|
|
},
|
|
},
|
|
layer: {},
|
|
});
|
|
return {
|
|
tracking,
|
|
flightState,
|
|
drawn: () => (calls.at(-1) ?? []).flat(),
|
|
// The live head the trail would draw now.
|
|
head: () => tracking._trailHeadPositions(),
|
|
setClock: (ms) => {
|
|
clock = ms;
|
|
},
|
|
setHead: (position) => {
|
|
headPosition = position;
|
|
},
|
|
};
|
|
}
|
|
|
|
test('a holding contact draws no head, and the trail ends at the last report, never past the icon', () => {
|
|
const t0 = Date.UTC(2026, 10, 9, 20, 0);
|
|
const fixes = [
|
|
fix(t0, 38.1678, -122.527, 303, 45, 200),
|
|
fix(t0 + 30 * SEC, 38.1279, -122.5425, 122, 40, 340),
|
|
fix(t0 + 60 * SEC, 38.133, -122.5494, 38, 37, 10),
|
|
fix(t0 + 90 * SEC, 38.1436, -122.5561, 0, 36.4, 63),
|
|
];
|
|
const last = fixes.at(-1).position;
|
|
// The display time is long past the last report; the icon holds there.
|
|
const h = trailHarness({
|
|
fixes,
|
|
nowMs: t0 + 90 * SEC + RENDER_DELAY_SEC * SEC + 120 * SEC,
|
|
head: Cesium.Cartesian3.clone(last),
|
|
});
|
|
h.tracking._startTrail('00a001');
|
|
// Every report, including the last, is in the trail: the head no longer
|
|
// cuts from the one before it to the icon.
|
|
assert.equal(h.drawn().length, 4);
|
|
assert.equal(h.drawn().at(-1), h.flightState._trailFixes.at(-1).position);
|
|
assert.deepEqual(h.head(), []);
|
|
});
|
|
|
|
test('while the display is between reports, the trail stops at the report behind the icon', () => {
|
|
const t0 = Date.UTC(2026, 10, 9, 20, 0);
|
|
// Reports every 10 s; the icon is drawn 30 s behind, between the 2nd and 3rd.
|
|
const fixes = [0, 1, 2, 3, 4, 5].map((i) =>
|
|
fix(t0 + i * 10 * SEC, 40, -100 + i * 0.03, 10_000, 230, 90),
|
|
);
|
|
const nowMs = t0 + 25 * SEC + RENDER_DELAY_SEC * SEC;
|
|
const icon = Cesium.Cartesian3.fromDegrees(-100 + 0.075, 40, 10_000);
|
|
const h = trailHarness({ fixes, nowMs, head: icon });
|
|
h.tracking._startTrail('00a001');
|
|
// Reports at 0, 10 and 20 s are behind the icon (display time 25 s): the
|
|
// body runs through them along their curve and ends at the third.
|
|
const body = h.drawn();
|
|
for (const report of fixes.slice(0, 3))
|
|
assert.ok(
|
|
body.some((p) => Cesium.Cartesian3.distance(p, report.position) < 0.01),
|
|
);
|
|
assert.ok(Cesium.Cartesian3.distance(body.at(-1), fixes[2].position) < 0.01);
|
|
// The head runs on from it to the icon.
|
|
const head = h.head();
|
|
assert.ok(head.length >= 2);
|
|
assert.ok(Cesium.Cartesian3.distance(head[0], fixes[2].position) < 0.01);
|
|
assert.ok(Cesium.Cartesian3.distance(head.at(-1), icon) < 0.01);
|
|
});
|
|
|
|
test('the hold-or-coast decision is made once per report: a floor that resolves mid-coast does not snap the icon back', () => {
|
|
const t0 = Date.UTC(2026, 10, 9, 20, 0);
|
|
const fixes = [
|
|
fix(t0, 39.7, -104.6, 1_900, 70, 270),
|
|
fix(t0 + 15 * SEC, 39.7, -104.6123, 1_900, 70, 270),
|
|
];
|
|
const info = {
|
|
altitude: 1_950,
|
|
renderAltitudeM: 1_900,
|
|
rawLat: 39.7,
|
|
rawLon: -104.6123,
|
|
velocity: 70,
|
|
true_track: 270,
|
|
onGround: false,
|
|
wasAirborne: true,
|
|
lastContactEpochMs: t0 + 15 * SEC + 120 * SEC,
|
|
};
|
|
// No floor known when the contact goes stale: baro says well clear of the
|
|
// ground, so it coasts. Mid-coast the floor resolves 100 m under the report.
|
|
let ground = () => null;
|
|
const at = (afterSec) => {
|
|
const nowMs = t0 + 15 * SEC + RENDER_DELAY_SEC * SEC + afterSec * SEC;
|
|
const { motion } = motionFixture({
|
|
info,
|
|
fixes,
|
|
nowMs,
|
|
ground: (lat, lon) => ground(lat, lon),
|
|
});
|
|
return motion._deadReckon('00a001', new Cesium.Cartesian3());
|
|
};
|
|
const d = (p) => Cesium.Cartesian3.distance(p, fixes[1].position);
|
|
const before = d(at(30));
|
|
assert.ok(Math.abs(before - 70 * 30) < 50, `coasted ${before.toFixed(0)} m`);
|
|
ground = () => 1_800;
|
|
const after = d(at(31));
|
|
assert.ok(
|
|
after > before,
|
|
`the icon went from ${before.toFixed(0)} m to ${after.toFixed(0)} m`,
|
|
);
|
|
});
|