mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 08:12:24 +00:00
Live trains from 30 keyless operator feeds: GPS positions from 29 and Irish Rail's station reports, shown as the operators publish them. 28 work out of the box; Renfe long and medium distance and KTMB appear once their pack is built, because their vehicles name no route. Packs are opt-in (scripts/build-rail-paths.mjs): the operator's own route lines, stop names, next stops and trip-update delays for live trains. Nothing downloads when the app starts, no train is placed from a timetable, and no request carries a deployer's key.
275 lines
8.5 KiB
JavaScript
275 lines
8.5 KiB
JavaScript
// One-click transfer pipeline for clicked world targets (pre-launch defect #4).
|
|
// The layer only announces the click; the UI owns the camera.
|
|
import { test } from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import * as Cesium from 'cesium';
|
|
import {
|
|
WORLD_CLICK_FOCUS_DURATION_SEC,
|
|
WORLD_FOCUS_FRAMING,
|
|
WORLD_FOCUS_REQUEST_EVENT,
|
|
flyToWorldTarget,
|
|
isValidWorldFocusTarget,
|
|
registerWorldFocusRequestListener,
|
|
requestWorldFocus,
|
|
routeWorldFocusRequest,
|
|
} from './worldFocus.js';
|
|
|
|
const POSITION = Cesium.Cartesian3.fromDegrees(-97.74, 30.26, 0);
|
|
|
|
function stubCamera() {
|
|
const calls = { cancelFlight: 0, flights: [] };
|
|
return {
|
|
calls,
|
|
heading: Cesium.Math.toRadians(45),
|
|
cancelFlight() {
|
|
calls.cancelFlight += 1;
|
|
},
|
|
flyToBoundingSphere(sphere, options) {
|
|
calls.flights.push({ sphere, options });
|
|
},
|
|
};
|
|
}
|
|
|
|
test('a focus request carries the clicked target to any registered listener', () => {
|
|
const target = new EventTarget();
|
|
const seen = [];
|
|
const dispose = registerWorldFocusRequestListener(target, (event) =>
|
|
seen.push(event.detail),
|
|
);
|
|
assert.equal(
|
|
requestWorldFocus(
|
|
{ kind: 'vessel', position: POSITION, id: '123' },
|
|
target,
|
|
),
|
|
true,
|
|
);
|
|
assert.equal(seen.length, 1);
|
|
assert.equal(seen[0].kind, 'vessel');
|
|
assert.equal(seen[0].id, '123');
|
|
// Disposal is idempotent and removes the exact listener.
|
|
dispose();
|
|
dispose();
|
|
requestWorldFocus({ kind: 'vessel', id: '123', position: POSITION }, target);
|
|
assert.equal(seen.length, 1);
|
|
});
|
|
|
|
test('requests without a kind or a position are dropped, never dispatched', () => {
|
|
const target = new EventTarget();
|
|
let count = 0;
|
|
target.addEventListener(WORLD_FOCUS_REQUEST_EVENT, () => {
|
|
count += 1;
|
|
});
|
|
assert.equal(requestWorldFocus({ position: POSITION }, target), false);
|
|
assert.equal(requestWorldFocus({ kind: 'vessel' }, target), false);
|
|
assert.equal(requestWorldFocus(null, target), false);
|
|
assert.equal(count, 0);
|
|
});
|
|
|
|
test('routing hands the request to the UI policy, which owns the flight', () => {
|
|
const order = [];
|
|
const result = routeWorldFocusRequest(
|
|
{ detail: { kind: 'fire', id: 'fire-1', position: POSITION } },
|
|
(detail, fly) => {
|
|
order.push(`policy:${detail.kind}`);
|
|
return fly();
|
|
},
|
|
(detail) => {
|
|
order.push(`fly:${detail.kind}`);
|
|
return 'flew';
|
|
},
|
|
);
|
|
// The policy runs FIRST — it releases the follow camera before the flight.
|
|
assert.deepEqual(order, ['policy:fire', 'fly:fire']);
|
|
assert.equal(result, 'flew');
|
|
});
|
|
|
|
test('a refusing policy (cockpit owns the camera) never reaches the flight', () => {
|
|
let flights = 0;
|
|
const result = routeWorldFocusRequest(
|
|
{ detail: { kind: 'vessel', id: '123', position: POSITION } },
|
|
() => false,
|
|
() => {
|
|
flights += 1;
|
|
},
|
|
);
|
|
assert.equal(result, false);
|
|
assert.equal(flights, 0);
|
|
});
|
|
|
|
test('malformed requests are inert', () => {
|
|
assert.equal(
|
|
routeWorldFocusRequest(
|
|
null,
|
|
() => 'x',
|
|
() => 'y',
|
|
),
|
|
false,
|
|
);
|
|
assert.equal(
|
|
routeWorldFocusRequest(
|
|
{ detail: { kind: 'vessel' } },
|
|
() => 'x',
|
|
() => 'y',
|
|
),
|
|
false,
|
|
);
|
|
});
|
|
|
|
// A request that cannot fly must never cost the user their tracking: the UI
|
|
// policy releases the follow camera, so validation happens BEFORE it runs.
|
|
test('an unflyable request never reaches the release policy', () => {
|
|
const unflyable = [
|
|
{ kind: 'plane', position: POSITION }, // no framing for this kind
|
|
{ kind: 'vessel', position: { x: NaN, y: 0, z: 0 } }, // malformed position
|
|
{ kind: 'vessel', position: { x: 0, y: 0 } }, // truthy but incomplete
|
|
{ kind: 'vessel', id: '123', position: { x: 0, y: 0, z: 0 } }, // ECEF origin
|
|
{ kind: 'fire', id: 'fire-1', position: { x: 1, y: 1, z: 1 } }, // finite but inside Earth
|
|
{ kind: 'vessel', position: 'somewhere' },
|
|
{ kind: 'vessel', position: POSITION }, // missing owner id
|
|
{ position: POSITION },
|
|
];
|
|
for (const detail of unflyable) {
|
|
assert.equal(
|
|
isValidWorldFocusTarget(detail),
|
|
false,
|
|
JSON.stringify(detail),
|
|
);
|
|
let policyRuns = 0;
|
|
const result = routeWorldFocusRequest(
|
|
{ detail },
|
|
() => {
|
|
policyRuns += 1;
|
|
return 'released';
|
|
},
|
|
() => 'flew',
|
|
);
|
|
assert.equal(result, false, JSON.stringify(detail));
|
|
assert.equal(
|
|
policyRuns,
|
|
0,
|
|
`the policy must not run for ${JSON.stringify(detail)}`,
|
|
);
|
|
// Nor may such a request be dispatched in the first place.
|
|
assert.equal(requestWorldFocus(detail, new EventTarget()), false);
|
|
}
|
|
assert.equal(
|
|
isValidWorldFocusTarget({ kind: 'vessel', id: '123', position: POSITION }),
|
|
true,
|
|
);
|
|
assert.equal(
|
|
isValidWorldFocusTarget({ kind: 'fire', id: 'fire-1', position: POSITION }),
|
|
true,
|
|
);
|
|
});
|
|
|
|
test('the transfer flight supersedes any flight in progress and keeps the operator heading', () => {
|
|
const camera = stubCamera();
|
|
assert.equal(
|
|
flyToWorldTarget(
|
|
{ camera },
|
|
{ kind: 'vessel', id: '123', position: POSITION },
|
|
),
|
|
true,
|
|
);
|
|
assert.equal(
|
|
camera.calls.cancelFlight,
|
|
1,
|
|
'a prior flight must be cancelled, not queued',
|
|
);
|
|
assert.equal(camera.calls.flights.length, 1);
|
|
const { sphere, options } = camera.calls.flights[0];
|
|
assert.equal(sphere.radius, WORLD_FOCUS_FRAMING.vessel.radiusM);
|
|
assert.equal(options.duration, WORLD_CLICK_FOCUS_DURATION_SEC);
|
|
assert.equal(options.offset.range, WORLD_FOCUS_FRAMING.vessel.rangeM);
|
|
// Heading is preserved so the transfer never spins the operator around.
|
|
assert.equal(options.offset.heading, camera.heading);
|
|
assert.equal(options.easingFunction, Cesium.EasingFunction.CUBIC_IN_OUT);
|
|
});
|
|
|
|
test('fires frame wider than vessels — a fire is read by its surroundings', () => {
|
|
const camera = stubCamera();
|
|
flyToWorldTarget(
|
|
{ camera },
|
|
{ kind: 'fire', id: 'fire-1', position: POSITION },
|
|
);
|
|
const { sphere, options } = camera.calls.flights[0];
|
|
assert.equal(sphere.radius, WORLD_FOCUS_FRAMING.fire.radiusM);
|
|
assert.equal(options.offset.range, WORLD_FOCUS_FRAMING.fire.rangeM);
|
|
assert.ok(
|
|
WORLD_FOCUS_FRAMING.fire.rangeM > WORLD_FOCUS_FRAMING.vessel.rangeM,
|
|
);
|
|
assert.ok(
|
|
WORLD_FOCUS_FRAMING.fire.radiusM > WORLD_FOCUS_FRAMING.vessel.radiusM,
|
|
);
|
|
});
|
|
|
|
test('every framing is a real oblique standoff, not a nadir or an inside-out sphere', () => {
|
|
const kinds = Object.keys(WORLD_FOCUS_FRAMING);
|
|
assert.deepEqual(kinds.sort(), [
|
|
'fire',
|
|
'sighting',
|
|
'sighting-area',
|
|
'train',
|
|
'vessel',
|
|
]);
|
|
for (const kind of kinds) {
|
|
const framing = WORLD_FOCUS_FRAMING[kind];
|
|
// Looking DOWN at the target, but obliquely — a nadir drop reads as a map.
|
|
assert.ok(
|
|
framing.pitchDeg < 0,
|
|
`${kind}: pitch must look down, got ${framing.pitchDeg}`,
|
|
);
|
|
assert.ok(
|
|
framing.pitchDeg > -80,
|
|
`${kind}: pitch must stay oblique, got ${framing.pitchDeg}`,
|
|
);
|
|
// Standing off outside the framed sphere, at a human-readable distance.
|
|
assert.ok(framing.radiusM > 0, `${kind}: radius must be positive`);
|
|
assert.ok(
|
|
framing.rangeM > framing.radiusM,
|
|
`${kind}: range ${framing.rangeM} must stand off outside radius ${framing.radiusM}`,
|
|
);
|
|
// An obscured sighting frames its entire 0.2° privacy cell.
|
|
const maximumRange = kind === 'sighting-area' ? 60000 : 10000;
|
|
assert.ok(
|
|
framing.rangeM <= maximumRange,
|
|
`${kind}: range must fit its surface extent, got ${framing.rangeM}`,
|
|
);
|
|
}
|
|
// Exact shipped values — a silent retune must show up as a failing test.
|
|
assert.deepEqual(
|
|
{ ...WORLD_FOCUS_FRAMING.vessel },
|
|
{ radiusM: 150, rangeM: 1200, pitchDeg: -30 },
|
|
);
|
|
assert.deepEqual(
|
|
{ ...WORLD_FOCUS_FRAMING.fire },
|
|
{ radiusM: 400, rangeM: 3000, pitchDeg: -35 },
|
|
);
|
|
assert.deepEqual(
|
|
{ ...WORLD_FOCUS_FRAMING.train },
|
|
{ radiusM: 200, rangeM: 2500, pitchDeg: -35 },
|
|
);
|
|
assert.deepEqual(
|
|
{ ...WORLD_FOCUS_FRAMING.sighting },
|
|
{ radiusM: 250, rangeM: 2500, pitchDeg: -40 },
|
|
);
|
|
assert.deepEqual(
|
|
{ ...WORLD_FOCUS_FRAMING['sighting-area'] },
|
|
{ radiusM: 11000, rangeM: 60000, pitchDeg: -55 },
|
|
);
|
|
});
|
|
|
|
test('unknown kinds and missing viewers issue no flight', () => {
|
|
const camera = stubCamera();
|
|
assert.equal(
|
|
flyToWorldTarget({ camera }, { kind: 'plane', position: POSITION }),
|
|
false,
|
|
);
|
|
assert.equal(flyToWorldTarget({ camera }, { kind: 'vessel' }), false);
|
|
assert.equal(
|
|
flyToWorldTarget(null, { kind: 'vessel', position: POSITION }),
|
|
false,
|
|
);
|
|
assert.equal(camera.calls.flights.length, 0);
|
|
});
|