mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 08:12:24 +00:00
Brings in main up to f24abfc88: cockpit subject providers, the render
failure notice, aircraft drawn in their own mesh colours, airport ground
vehicles, and an aircraft with no ground track facing its true heading.
Under the seam:
- The render failure notice lives in the Cesium adapter
(src/render/cesium/renderFailure.js) and is the application hook
renderFailureNotice({allowReload, store}); its private Cesium fields
(Event's raise queue, the widget's render loop flag) are read through
internals.js. The inline panel's timer waits while the frame port reports
the loop stopped, and goes on after a Retry.
- Ordinary aircraft models draw white with the 'highlight' colour blend
through the draw port; tracked and emergency colours tint the mesh.
- Held trains and transit vehicles hide their route set and markers through
the draw port; the fleet model test fakes answer loads through the fake
draw port instead of Cesium's glTF loader.
- The Cockpit's subject view follows and places the camera through the
camera port.
569 lines
17 KiB
JavaScript
569 lines
17 KiB
JavaScript
import { TRACKED_ICON_COLOR } from '../layers/military/policy.js';
|
|
import { TRACKED_CYAN } from '../layers/flights/policy.js';
|
|
import { createRendering as civilRendering } from '../layers/flights/rendering.js';
|
|
import { createRendering as militaryRendering } from '../layers/military/rendering.js';
|
|
import { createMilitarySnapshotRenderer } from '../layers/military/snapshotRenderer.js';
|
|
import { createIcons as createMilitaryIcons } from '../layers/military/icons.js';
|
|
import { createContactIcons } from './aircraftIconLayer.js';
|
|
import {
|
|
aircraftMotionRegime,
|
|
createMotionRegime,
|
|
fixEpochMs,
|
|
fixPosition,
|
|
copyPosition,
|
|
historyFix,
|
|
julianAt,
|
|
} from './aircraftMotionRegime.js';
|
|
import { aircraftEmergency } from './aircraftEmergency.js';
|
|
// Source-to-voice provenance, status retention/clearing, contact-time contracts,
|
|
// and civil/military billboard, Cockpit and model tint regressions.
|
|
import { test } from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { openSkySnapshot, readsbSnapshot } from '../sources/live/index.js';
|
|
import { FlightRecords } from '../layers/flights/records.js';
|
|
import { MilitaryFlightRecords } from '../layers/military/records.js';
|
|
import { mapAnalystRecord as mapFlight } from './flights.js';
|
|
import { mapAnalystRecord as mapMilitary } from './militaryFlights.js';
|
|
import { createAnalystEngine } from './analystEngine.js';
|
|
import { normalizeAdsbLolPointResponse } from './adsbLolFallback.js';
|
|
import { createGevActionRunner } from '../voice/gevActions.js';
|
|
|
|
const NOW_MS = 1800000000000;
|
|
|
|
test('fallback status belongs to the first valid admitted aircraft row', () => {
|
|
const valid = { hex: 'a1b2c3', lat: 30, lon: -97, squawk: '1200' };
|
|
for (const status of [undefined, 'general', 'none']) {
|
|
const payload = normalizeAdsbLolPointResponse({
|
|
now: NOW_MS,
|
|
ac: [
|
|
{ ...valid, lat: 100, emergency: 'general' },
|
|
{ ...valid, emergency: status },
|
|
{ ...valid, lat: null, emergency: 'general' },
|
|
{ ...valid, emergency: status === 'general' ? 'none' : 'general' },
|
|
],
|
|
});
|
|
const snapshot = openSkySnapshot(payload, { now: NOW_MS });
|
|
assert.equal(snapshot.records.length, 1);
|
|
assert.equal(snapshot.records[0].emergency, status);
|
|
assert.equal(snapshot.records[0].latitude, 30);
|
|
}
|
|
});
|
|
|
|
function civilStore() {
|
|
return new FlightRecords({
|
|
geoidHeight: () => 0,
|
|
cachedGroundFloor: () => null,
|
|
floorAltitudeM: (value) => value,
|
|
approxDistanceKm: () => 0,
|
|
});
|
|
}
|
|
const receiveContext = {
|
|
viewerLatDeg: null,
|
|
viewerLonDeg: null,
|
|
trackedId: null,
|
|
floorWarmPoints: [],
|
|
};
|
|
|
|
test('real civil fallback preserves ADS-B emergency and priority, then clears', () => {
|
|
const store = civilStore();
|
|
const aircraft = {
|
|
hex: 'a1b2c3',
|
|
flight: 'TEST1',
|
|
lat: 30,
|
|
lon: -97,
|
|
alt_baro: 10000,
|
|
gs: 150,
|
|
track: 90,
|
|
squawk: '1200',
|
|
seen: 3,
|
|
seen_pos: 1,
|
|
};
|
|
for (const [status, expectedKind, flagged] of [
|
|
['general', 'general', true],
|
|
['minfuel', 'minfuel', false],
|
|
['none', null, false],
|
|
]) {
|
|
const payload = normalizeAdsbLolPointResponse({
|
|
now: NOW_MS,
|
|
ac: [{ ...aircraft, emergency: status }],
|
|
});
|
|
assert.equal(
|
|
payload.states[0].length,
|
|
18,
|
|
'fallback vectors retain the OpenSky shape',
|
|
);
|
|
const [observation] = openSkySnapshot(payload, { now: NOW_MS }).records;
|
|
const result = mapFlight(
|
|
aircraft.hex,
|
|
store.receive(observation, receiveContext).meta,
|
|
);
|
|
assert.equal(result.emergency, flagged);
|
|
assert.equal(result.emergencyKind, expectedKind);
|
|
assert.equal(result.emergencySource, expectedKind ? 'ads-b' : null);
|
|
assert.equal(result.lastContactAtMs, NOW_MS - 3000);
|
|
}
|
|
});
|
|
|
|
test('changed status without contact time retains general contact, including voice projection', async () => {
|
|
const store = civilStore();
|
|
const [observation] = readsbSnapshot(
|
|
{
|
|
ac: [
|
|
{
|
|
hex: 'a1b2c3',
|
|
flight: 'TEST1',
|
|
lat: 30,
|
|
lon: -97,
|
|
alt_baro: 10000,
|
|
gs: 150,
|
|
track: 90,
|
|
squawk: '1200',
|
|
emergency: 'general',
|
|
seen: 3,
|
|
seen_pos: 1,
|
|
},
|
|
],
|
|
},
|
|
{ observedAtMs: NOW_MS, now: NOW_MS },
|
|
).records;
|
|
store.receive(observation, receiveContext);
|
|
const meta = store.receive(
|
|
{ ...observation, contactTimeMs: null, squawk: '7600', emergency: 'none' },
|
|
receiveContext,
|
|
).meta;
|
|
const record = mapFlight(observation.id, meta);
|
|
assert.equal(record.emergencyKind, 'nordo');
|
|
assert.equal(record.lastContactAtMs, NOW_MS - 3000);
|
|
assert.equal(Object.hasOwn(record, 'observedAtMs'), false);
|
|
globalThis.window = globalThis.window || {
|
|
clearTimeout,
|
|
setTimeout,
|
|
requestIdleCallback: null,
|
|
};
|
|
const flights = {
|
|
id: 'flights',
|
|
source: 'fixture',
|
|
getStats: () => ({ count: 1 }),
|
|
getAnalystRecords: () => [record],
|
|
};
|
|
const runner = createGevActionRunner({
|
|
viewer: {
|
|
clock: { onTick: { addEventListener: () => () => {} } },
|
|
canvas: { addEventListener() {}, removeEventListener() {} },
|
|
scene: { canvas: { addEventListener() {}, removeEventListener() {} } },
|
|
camera: {
|
|
moveEnd: { addEventListener() {} },
|
|
positionCartographic: {
|
|
height: 300000,
|
|
latitude: 0.52,
|
|
longitude: -1.71,
|
|
},
|
|
},
|
|
},
|
|
styleManager: {
|
|
getContextModeState: () => ({ mode: null, active: false }),
|
|
getCockpitState: () => ({ active: false }),
|
|
},
|
|
dataManager: {
|
|
layers: new Map([['flights', { module: flights }]]),
|
|
isEnabled: (id) => id === 'flights',
|
|
getAll: () => [
|
|
{ id: 'flights', name: 'Flights', enabled: true, stats: { count: 1 } },
|
|
],
|
|
},
|
|
});
|
|
try {
|
|
const result = await runner('analyst_query', {
|
|
layers: ['flights'],
|
|
scope: { kind: 'anywhere' },
|
|
filters: [{ field: 'emergency', op: 'eq', value: true }],
|
|
});
|
|
assert.equal(result.ok, true);
|
|
assert.equal(result.items[0].emergency, true);
|
|
assert.equal(result.items[0].lastContactAtMs, NOW_MS - 3000);
|
|
assert.equal(result.items[0].emergencySource, 'squawk');
|
|
assert.equal(
|
|
result.items[0].emergencyBroadcast,
|
|
'broadcasting squawk 7600 (radio failure)',
|
|
);
|
|
assert.equal(
|
|
Object.hasOwn(result.items[0], 'time'),
|
|
false,
|
|
'general contact is not a generic incident timestamp',
|
|
);
|
|
} finally {
|
|
runner.dispose?.();
|
|
}
|
|
});
|
|
|
|
// OpenSky /states/all: [icao24, callsign, origin_country, time_position,
|
|
// last_contact, lon, lat, baro_alt, on_ground, velocity, true_track,
|
|
// vertical_rate, sensors, geo_alt, squawk, spi, position_source, category].
|
|
const OPENSKY = {
|
|
time: NOW_MS / 1000,
|
|
states: [
|
|
[
|
|
'a1b2c3',
|
|
'SWA696 ',
|
|
'United States',
|
|
NOW_MS / 1000 - 6,
|
|
NOW_MS / 1000 - 3,
|
|
-97.67,
|
|
30.19,
|
|
3000,
|
|
false,
|
|
150,
|
|
180,
|
|
-5,
|
|
null,
|
|
3040,
|
|
'7700',
|
|
false,
|
|
0,
|
|
4,
|
|
],
|
|
],
|
|
};
|
|
|
|
// adsb.lol /v2/mil: readsb aircraft with `seen`/`seen_pos` ages in seconds.
|
|
const ADSB_LOL = {
|
|
ac: [
|
|
{
|
|
hex: 'ae01ce',
|
|
flight: 'RCH123 ',
|
|
t: 'C17',
|
|
lat: 31.1,
|
|
lon: -97.4,
|
|
alt_baro: 18000,
|
|
gs: 300,
|
|
track: 90,
|
|
squawk: '1200',
|
|
emergency: 'general',
|
|
seen: 1.5,
|
|
seen_pos: 2,
|
|
},
|
|
],
|
|
};
|
|
|
|
function civilAnalystRecord() {
|
|
const [row] = openSkySnapshot(OPENSKY, { now: NOW_MS }).records;
|
|
const store = new FlightRecords({
|
|
geoidHeight: () => 0,
|
|
cachedGroundFloor: () => null,
|
|
floorAltitudeM: (altitude) => altitude,
|
|
approxDistanceKm: () => 0,
|
|
});
|
|
const { meta } = store.receive(row, {
|
|
viewerLatDeg: null,
|
|
viewerLonDeg: null,
|
|
trackedId: null,
|
|
floorWarmPoints: [],
|
|
});
|
|
return mapFlight(row.id, meta);
|
|
}
|
|
|
|
function militaryAnalystRecord() {
|
|
const [row] = readsbSnapshot(ADSB_LOL, {
|
|
observedAtMs: NOW_MS,
|
|
now: NOW_MS,
|
|
}).records;
|
|
const store = new MilitaryFlightRecords({
|
|
geoidHeight: () => 0,
|
|
cachedGroundFloor: () => null,
|
|
floorAltitudeM: (altitude) => altitude,
|
|
});
|
|
const { meta } = store.receive(row, {
|
|
observedAtMs: NOW_MS,
|
|
floorWarmPoints: [],
|
|
modelOwnsVisual: false,
|
|
});
|
|
return mapMilitary(row.id, meta);
|
|
}
|
|
|
|
test('OpenSky 7700 and adsb.lol emergency=general differ only in provenance', () => {
|
|
const civil = civilAnalystRecord();
|
|
const military = militaryAnalystRecord();
|
|
|
|
assert.equal(civil.emergency, true);
|
|
assert.equal(civil.emergencyKind, 'general');
|
|
assert.equal(civil.squawk, '7700');
|
|
assert.equal(civil.emergencySource, 'squawk');
|
|
assert.equal(
|
|
civil.emergencyBroadcast,
|
|
'broadcasting squawk 7700 (general emergency)',
|
|
);
|
|
assert.equal(civil.lastContactAtMs, NOW_MS - 3000, 'OpenSky last_contact');
|
|
|
|
assert.equal(military.emergency, true);
|
|
assert.equal(military.emergencyKind, 'general');
|
|
assert.equal(military.squawk, '1200', 'the code is not an emergency code');
|
|
assert.equal(military.emergencySource, 'ads-b');
|
|
assert.equal(military.emergencyBroadcast, 'ADS-B reports general emergency');
|
|
assert.equal(military.lastContactAtMs, NOW_MS - 1500, 'snapshot time - seen');
|
|
});
|
|
|
|
test('the analyst can filter emergencies by source', async () => {
|
|
const records = {
|
|
flights: [civilAnalystRecord()],
|
|
military: [militaryAnalystRecord()],
|
|
};
|
|
const engine = createAnalystEngine({
|
|
getRecords: (key) => records[key] || [],
|
|
resolveRegionRing: async () => null,
|
|
getViewContext: () => ({ lat: 30.5, lon: -97.5, viewRadiusKm: 500 }),
|
|
});
|
|
const query = (value) =>
|
|
engine.query({
|
|
layers: ['flights', 'military'],
|
|
scope: { kind: 'anywhere' },
|
|
filters: [
|
|
{ field: 'emergency', op: 'eq', value: true },
|
|
{ field: 'emergencySource', op: 'eq', value },
|
|
],
|
|
});
|
|
const bySquawk = await query('squawk');
|
|
assert.deepEqual(
|
|
bySquawk.items.map((item) => [item.icao24, item.emergencyBroadcast]),
|
|
[['a1b2c3', 'broadcasting squawk 7700 (general emergency)']],
|
|
);
|
|
const byAdsb = await query('ads-b');
|
|
assert.deepEqual(
|
|
byAdsb.items.map((item) => [item.icao24, item.emergencyBroadcast]),
|
|
[['ae01ce', 'ADS-B reports general emergency']],
|
|
);
|
|
});
|
|
|
|
test('military status changes retain only the latest known general contact', () => {
|
|
const store = new MilitaryFlightRecords({
|
|
geoidHeight: () => 0,
|
|
cachedGroundFloor: () => null,
|
|
floorAltitudeM: (v) => v,
|
|
});
|
|
const [observation] = readsbSnapshot(ADSB_LOL, {
|
|
observedAtMs: NOW_MS,
|
|
now: NOW_MS,
|
|
}).records;
|
|
const context = {
|
|
observedAtMs: NOW_MS,
|
|
floorWarmPoints: [],
|
|
modelOwnsVisual: false,
|
|
};
|
|
const unknown = mapMilitary(
|
|
observation.id,
|
|
store.receive({ ...observation, contactTimeMs: null }, context).meta,
|
|
);
|
|
assert.equal(unknown.lastContactAtMs, null);
|
|
store.receive(observation, context);
|
|
const changed = mapMilitary(
|
|
observation.id,
|
|
store.receive(
|
|
{
|
|
...observation,
|
|
contactTimeMs: null,
|
|
squawk: '7600',
|
|
emergency: 'none',
|
|
},
|
|
context,
|
|
).meta,
|
|
);
|
|
assert.equal(changed.emergencyKind, 'nordo');
|
|
assert.equal(changed.lastContactAtMs, NOW_MS - 1500);
|
|
});
|
|
|
|
test('fallback missing contact age retains known contact through the real converter', () => {
|
|
const store = civilStore();
|
|
const row = {
|
|
hex: 'a1b2c3',
|
|
lat: 30,
|
|
lon: -97,
|
|
squawk: '1200',
|
|
emergency: 'general',
|
|
seen: 3,
|
|
seen_pos: 1,
|
|
};
|
|
const receive = (row) =>
|
|
store.receive(
|
|
openSkySnapshot(
|
|
normalizeAdsbLolPointResponse({ now: NOW_MS, ac: [row] }),
|
|
{ now: NOW_MS },
|
|
).records[0],
|
|
receiveContext,
|
|
).meta;
|
|
const first = receive(row);
|
|
const second = receive({ ...row, seen: undefined, seen_pos: undefined });
|
|
assert.equal(second.lastContactEpochMs, first.lastContactEpochMs);
|
|
});
|
|
|
|
test('one omitted ADS-B status poll is retained; explicit none and changed squawk clear immediately', () => {
|
|
const store = civilStore();
|
|
const row = {
|
|
hex: 'a1b2c3',
|
|
lat: 30,
|
|
lon: -97,
|
|
squawk: '1200',
|
|
emergency: 'general',
|
|
seen: 3,
|
|
};
|
|
const receive = (row) =>
|
|
store.receive(
|
|
openSkySnapshot(
|
|
normalizeAdsbLolPointResponse({ now: NOW_MS, ac: [row] }),
|
|
{ now: NOW_MS },
|
|
).records[0],
|
|
receiveContext,
|
|
).meta;
|
|
assert.equal(receive(row).emergency.kind, 'general');
|
|
assert.equal(
|
|
receive({ ...row, emergency: undefined }).emergency?.kind,
|
|
'general',
|
|
);
|
|
assert.equal(receive({ ...row, emergency: undefined }).emergency, null);
|
|
receive(row);
|
|
assert.equal(receive({ ...row, emergency: 'none' }).emergency, null);
|
|
receive(row);
|
|
assert.equal(
|
|
receive({ ...row, emergency: undefined, squawk: '2000' }).emergency,
|
|
null,
|
|
);
|
|
});
|
|
|
|
function renderHarness(factory) {
|
|
const flightState = { records: { data: new Map() }, _trackedIcao: null };
|
|
const rendering = factory({
|
|
flightState,
|
|
services: {
|
|
militaryRegistry: { isMilitaryIcao: (id) => id === 'mil' },
|
|
aircraftPresentation: {},
|
|
camera: {},
|
|
focus: {},
|
|
recession: {},
|
|
},
|
|
parts: {},
|
|
});
|
|
return { flightState, rendering };
|
|
}
|
|
|
|
test('tint priorities cover normal, priority, emergency, tracking and Cockpit dots', () => {
|
|
for (const factory of [civilRendering, militaryRendering]) {
|
|
const { flightState, rendering } = renderHarness(factory);
|
|
const normal = rendering._fleetBillboardColor('civil', {});
|
|
assert.equal(
|
|
rendering._fleetBillboardColor('civil', {
|
|
emergency: aircraftEmergency({ emergency: 'minfuel' }),
|
|
}),
|
|
normal,
|
|
);
|
|
const red = rendering._fleetBillboardColor('civil', {
|
|
emergency: aircraftEmergency({ squawk: '7700' }),
|
|
});
|
|
assert.ok(red[0] > 0.9 && red[1] < 0.5);
|
|
flightState.records.data.set('civil', {
|
|
emergency: aircraftEmergency({ squawk: '7700' }),
|
|
});
|
|
assert.equal(rendering._modelColor('civil'), red);
|
|
if (rendering._cockpitContactColor)
|
|
assert.equal(rendering._cockpitContactColor('civil'), red);
|
|
flightState._trackedIcao = 'civil';
|
|
assert.equal(
|
|
rendering._modelColor('civil'),
|
|
factory === civilRendering ? TRACKED_CYAN : TRACKED_ICON_COLOR,
|
|
);
|
|
flightState._trackedIcao = null;
|
|
flightState.records.data.set('civil', { emergency: null });
|
|
// An ordinary model draws its mesh's own colours, whatever the billboard's.
|
|
assert.deepEqual([...rendering._modelColor('civil')], [1, 1, 1, 1]);
|
|
}
|
|
});
|
|
|
|
test('GERMAN: an existing untracked military icon repaints each poll without losing its fade', () => {
|
|
const { flightState, rendering } = renderHarness(militaryRendering);
|
|
Object.assign(flightState, {
|
|
_icons: createContactIcons(),
|
|
_models: new Map(),
|
|
_positionHistory: new Map(),
|
|
_displayCourse: new Map(),
|
|
_groundSnap: { forget() {} },
|
|
_cockpitContactMode: false,
|
|
_cockpitNearContacts: new Set(),
|
|
});
|
|
const records = new MilitaryFlightRecords({
|
|
geoidHeight: () => 0,
|
|
cachedGroundFloor: () => null,
|
|
floorAltitudeM: (value) => value,
|
|
});
|
|
flightState.records = records;
|
|
const parts = {
|
|
rendering: {
|
|
...rendering,
|
|
_iconKind: () => 'jet',
|
|
_syncModelToClass() {},
|
|
},
|
|
motion: {
|
|
_motionRegime: (history, info, renderTime) =>
|
|
aircraftMotionRegime(
|
|
history,
|
|
info,
|
|
renderTime,
|
|
{ speed: 'speedMps', track: 'track' },
|
|
createMotionRegime(),
|
|
),
|
|
_displayTimeAt: julianAt,
|
|
_fixEpochMs: fixEpochMs,
|
|
_fixPosition: fixPosition,
|
|
_copyPosition: copyPosition,
|
|
_historyFix: historyFix,
|
|
_refloorStaleGroundedContacts() {},
|
|
_sampleMeshFloor() {},
|
|
},
|
|
};
|
|
const icons = createMilitaryIcons({
|
|
flightState,
|
|
services: { focus: { focusPassIsNeeded: () => false } },
|
|
parts,
|
|
});
|
|
const row = 'abc123';
|
|
flightState._icons.put({
|
|
id: row,
|
|
pos: { x: 0, y: 0, z: 0 },
|
|
meta: { layer: 'military', id: row },
|
|
});
|
|
// The focus fade the fleet tick composes lives in its own field.
|
|
flightState._icons.setFocus(row, 0.65);
|
|
const apply = createMilitarySnapshotRenderer({
|
|
flightState,
|
|
records,
|
|
groundFloor: { warmGroundFloor() {} },
|
|
militaryRegistry: { registerMilitaryIcaos() {} },
|
|
rendering: parts.rendering,
|
|
motion: parts.motion,
|
|
icons,
|
|
tracking: {},
|
|
queries: {},
|
|
});
|
|
for (const [emergency, red] of [
|
|
['general', true],
|
|
['none', false],
|
|
['general', true],
|
|
]) {
|
|
const snapshot = readsbSnapshot(
|
|
{
|
|
ac: [
|
|
{
|
|
hex: 'abc123',
|
|
lat: 30,
|
|
lon: -97,
|
|
alt_baro: 10000,
|
|
squawk: '1200',
|
|
emergency,
|
|
seen_pos: 1,
|
|
},
|
|
],
|
|
},
|
|
{ observedAtMs: NOW_MS },
|
|
);
|
|
apply(snapshot, {});
|
|
assert.equal(flightState._icons.item(row).color[1] < 0.5, red);
|
|
assert.ok(Math.abs(flightState._icons.focus(row) - 0.65) < 1e-6);
|
|
}
|
|
});
|