// src/ui/cockpitOrbitalFocus.test.mjs — the orbital view's Live Signals // rows and its ground focus: the rows list the Mapped Installations layer's // sites around the satellite (getNearby) and the nearest satellites; a site // row, or a click on the site's marker (the layer's pick ids), turns the // camera onto it and holds it as the satellite moves; a click elsewhere, the // row again, NADIR or the site leaving the reach eases the view back, never // in one jump; a satellite row rides that satellite and stays in orbit. // The layers are stubs with the real methods' shapes. Over happy-dom. import '../testSupport/registerDom.mjs'; import test from 'node:test'; import assert from 'node:assert/strict'; import { createPinia } from 'pinia'; import { createApp, defineComponent, h, nextTick } from 'vue'; import * as Cesium from 'cesium'; import { CockpitViewController } from './cockpitController.js'; import { useCockpitStore } from './stores/cockpit.js'; import { useHudStore } from './stores/hud.js'; import CockpitView from './views/CockpitView.vue'; import ContextView from './views/ContextView.vue'; import IntelHudView from './views/IntelHudView.vue'; import { claimPointer, releasePointer } from '../data/inputOwnership.js'; import { ORBITAL_FOCUS_EASE_TAU_MS } from '../cockpitOrbitalFocus.js'; import { ORBITAL_HOP_MS } from '../cockpitOrbitalSatellites.js'; const START_MS = 1_800_000_000_000; const ASPECT = 16 / 9; const FRAME_MS = 16; /** Satellites the layer knows, by NORAD id: the ridden one and its neighbours. */ const SATELLITES = Object.freeze({ 25544: { name: 'ISS (ZARYA)', lat: 30, lon: -97, alt: 420_000, cls: 'stations' }, 49260: { name: 'LANDSAT 9', lat: 31.5, lon: -95, alt: 705_000, cls: 'imaging' }, 40697: { name: 'SENTINEL-2A', lat: 26, lon: -99, alt: 786_000, cls: 'imaging' }, 99001: { name: 'DEB FRAGMENT', lat: 30.2, lon: -97.1, alt: 430_000, cls: 'debris' }, }); /** Mapped sites as the installations layer keeps them. */ const SITES = Object.freeze({ alpha: { id: 'osm:military:way/101', osmKey: 'way/101', name: 'Camp Alpha', class: 'base', lat: 31, lon: -96.5, memberNames: ['North Field'], at: { x: 100, y: 100 }, }, bravo: { id: 'osm:military:way/202', osmKey: 'way/202', name: 'Bravo Field', class: 'airfield', lat: 29.2, lon: -97.8, at: { x: 300, y: 300 }, }, // Beyond the ±45° reach of the ISS at its start. far: { id: 'osm:military:way/303', osmKey: 'way/303', name: 'Far Range', class: 'range', lat: 33.5, lon: -101, at: { x: 500, y: 50 }, }, }); const EMPTY_GROUND = Object.freeze({ x: 640, y: 360 }); /** The Mapped Installations layer: its records, getNearby, getById, findByPick. */ function installationsLayer() { const records = Object.values(SITES).map((site) => ({ id: site.id, osmKey: site.osmKey, name: site.name, class: site.class, kind: 'installation', latitude: site.lat, longitude: site.lon, memberNames: site.memberNames || [], sources: [{ name: 'OpenStreetMap', id: site.osmKey }], })); const layer = { enabled: true, records, calls: { getNearby: 0 }, withPosition(record) { return { ...record, position: Cesium.Cartesian3.fromDegrees(record.longitude, record.latitude, 0), }; }, // As the layer's own: loaded installations within `rangeM` of // `center`, nearest first, each with its drawn position and distance. getNearby(center, rangeM, maxCount = 50) { layer.calls.getNearby += 1; if (!center) return []; const from = Cesium.Cartographic.fromCartesian(center); const geodesic = new Cesium.EllipsoidGeodesic(); return layer.records .filter((record) => record.kind === 'installation') .map((record) => { geodesic.setEndPoints( from, Cesium.Cartographic.fromDegrees(record.longitude, record.latitude), ); return { ...layer.withPosition(record), distanceM: geodesic.surfaceDistance }; }) .filter((record) => record.distanceM <= rangeM) .sort((a, b) => a.distanceM - b.distanceM) .slice(0, maxCount); }, getById(id) { if (!layer.enabled) return null; const record = layer.records.find((r) => r.id === String(id)); return record ? layer.withPosition(record) : null; }, findByPick(picked) { const id = picked?.id?.installationId || (typeof picked?.id?.id === 'string' ? picked.id.id : null); return id ? layer.getById(id) : null; }, }; return layer; } /** The satellites layer: tracking, the Cockpit subject and every position. */ function satellitesLayer(viewer) { const positions = new Map( Object.entries(SATELLITES).map(([id, sat]) => [Number(id), { ...sat }]), ); const layer = { tracked: 25544, calls: [], position(id) { const sat = positions.get(id); return Cesium.Cartesian3.fromDegrees(sat.lon, sat.lat, sat.alt); }, move(dLat, dLon) { const sat = positions.get(layer.tracked); sat.lat += dLat; sat.lon += dLon; }, getCockpitSubject() { if (layer.tracked === null) return null; const sat = positions.get(layer.tracked); return { kind: 'satellite', layerId: 'satellites', id: String(layer.tracked), noradId: layer.tracked, name: sat.name, classLabel: sat.cls.toUpperCase(), latitude: sat.lat, longitude: sat.lon, altitudeM: sat.alt, velocityMps: 7_600, groundTrackDeg: 51.6, satelliteClass: sat.cls, stale: false, }; }, getCockpitPosition(result) { if (layer.tracked === null) return null; return Cesium.Cartesian3.clone(layer.position(layer.tracked), result); }, getAllPositions(maxCount = 300) { return [...positions.entries()].slice(0, maxCount).map(([id, sat]) => ({ id, label: sat.name, position: layer.position(id), latitude: sat.lat, longitude: sat.lon, altitudeM: sat.alt, satelliteClass: sat.cls, })); }, // As the layer's: the nearest shown satellites, bounded, with the // asked-for ids and classes left out. getNearestPositions(center, maxCount = 8, { excludeIds = [], excludeClasses = [] } = {}) { layer.calls.push(['nearest']); const skip = new Set(excludeIds.map(String)); return layer .getAllPositions() .filter((entry) => !skip.has(String(entry.id))) .filter((entry) => !excludeClasses.includes(entry.satelliteClass)) .map((entry) => ({ ...entry, distanceM: Cesium.Cartesian3.distance(center, entry.position), })) .sort((a, b) => a.distanceM - b.distanceM) .slice(0, maxCount); }, /** The satellite leaves the catalogue. */ remove(id) { positions.delete(Number(id)); }, // As the layer's: tracking hands the camera to Cesium's follow. trackById(noradId) { const id = Number(noradId); if (!positions.has(id)) return false; layer.calls.push(['track', id]); layer.tracked = id; viewer.trackedEntity = { position: { getValue: () => layer.position(id) } }; return true; }, setCockpitSubject(noradId) { layer.calls.push(['subject', noradId]); return true; }, refocusTrackedById: () => true, drop() { layer.tracked = null; }, }; return layer; } function fixture(t, { reducedMotion = false } = {}) { document.body.replaceChildren(); const host = document.body.appendChild(document.createElement('div')); const pinia = createPinia(); const app = createApp( defineComponent(() => () => [h(ContextView), h(IntelHudView), h(CockpitView)]), ).use(pinia); app.mount(host); useHudStore(pinia); const store = useCockpitStore(pinia); const previousMatchMedia = globalThis.matchMedia; globalThis.matchMedia = (query) => ({ matches: query.includes('reduce') && reducedMotion, }); const listeners = () => ({ addEventListener: () => () => {} }); const shots = []; const picks = new Map(); const viewer = { trackedEntity: undefined, clock: { currentTime: null }, camera: { frustum: { fov: 1, aspectRatio: ASPECT }, cancelFlight() {}, setView({ destination, orientation }) { shots.push({ destination: Cesium.Cartesian3.clone(destination), direction: Cesium.Cartesian3.clone(orientation.direction), up: Cesium.Cartesian3.clone(orientation.up), }); }, }, entities: { contains: () => false }, scene: { preUpdate: listeners(), screenSpaceCameraController: { enableInputs: true }, pick: (position) => picks.get(`${position.x},${position.y}`), }, trackedEntityChanged: listeners(), }; // The Viewer's own input handler: its single click picks into // selectedEntity; its double-click tracks what it picks, which would end // the orbital view. const actions = new Map(); const handler = { stockClicks: 0, stockDoubleClicks: 0, getInputAction: (type) => actions.get(type), setInputAction: (action, type) => actions.set(type, action), removeInputAction: (type) => actions.delete(type), isDestroyed: () => false, }; handler.stock = () => { handler.stockClicks += 1; }; handler.stockDouble = ({ position }) => { handler.stockDoubleClicks += 1; const picked = viewer.scene.pick(position); viewer.trackedEntity = picked ? { position: { getValue: () => null } } : undefined; }; actions.set(Cesium.ScreenSpaceEventType.LEFT_CLICK, handler.stock); actions.set(Cesium.ScreenSpaceEventType.LEFT_DOUBLE_CLICK, handler.stockDouble); viewer.screenSpaceEventHandler = handler; const sites = installationsLayer(); const satellites = satellitesLayer(viewer); const modeEvents = []; const onMode = (event) => modeEvents.push(event.detail); window.addEventListener('gev:cockpit-mode-changed', onMode); const cockpit = new CockpitViewController(viewer, { services: { flightsLayer: { getTrackedInfo: () => null }, militaryFlightsLayer: { getTrackedInfo: () => null }, aisLiveVesselsLayer: { getCockpitSubject: () => null }, satellitesLayer: satellites, militaryInstallationsLayer: sites, militaryAwarenessLayer: {}, isLayerEnabled: (layerId) => layerId === 'military-installations' ? sites.enabled : true, isTr3b: () => false, holdContinuousRender() {}, releaseContinuousRender() {}, cachedGroundFloor: () => null, GROUND_FLOOR_LIFT_M: 0, }, isEntryAllowed: () => false, isBridgeEntryAllowed: () => false, isOrbitEntryAllowed: () => true, publish: { presence: (view) => store.publishPresence(view), instruments: (view) => store.publishInstruments(view), route: (view) => store.publishRoute(view), radar: (view) => store.publishRadar(view), orbital: (view) => store.publishOrbital(view), signals: (rows) => store.publishSignals(rows), }, }); Object.assign(cockpit, { setVisionMode() {}, showBriefPage() {}, startBriefRotation() {}, stopBriefRotation() {}, scheduleContextLayout() {}, updateLocalPosition() {}, maybeRefreshRegionalBrief() {}, updateContext() {}, updateRoute() {}, }); // Named markers pick as `{ installationId }`, as the layer draws them. for (const site of Object.values(SITES)) picks.set(`${site.at.x},${site.at.y}`, { id: { installationId: site.id }, primitive: {}, }); const originalNow = performance.now; const originalDateNow = Date.now; let nowMs = START_MS; performance.now = () => nowMs; Date.now = () => nowMs; t.after(() => { window.removeEventListener('gev:cockpit-mode-changed', onMode); cockpit.stop(); app.unmount(); globalThis.matchMedia = previousMatchMedia; performance.now = originalNow; Date.now = originalDateNow; document.body.classList.remove('cockpit-mode', 'cockpit-bridge', 'cockpit-orbit'); }); const frame = () => { nowMs += FRAME_MS; cockpit.update(); return shots.at(-1); }; const fire = (type, position) => actions.get(type)?.({ position }); return { $: (selector) => document.querySelector(selector), cockpit, viewer, store, shots, handler, sites, satellites, modeEvents, frame, click: (position) => fire(Cesium.ScreenSpaceEventType.LEFT_CLICK, position), /** A double-click as Cesium fires it: two clicks, then the double. */ doubleClick(position) { fire(Cesium.ScreenSpaceEventType.LEFT_CLICK, position); fire(Cesium.ScreenSpaceEventType.LEFT_CLICK, position); fire(Cesium.ScreenSpaceEventType.LEFT_DOUBLE_CLICK, position); }, /** Rebuild the Context card on the next frame, past its clock. */ refreshCard() { nowMs += 1000; cockpit.update(); }, }; } async function settle() { await nextTick(); await Promise.resolve(); } async function inOrbit(t, options) { const scene = fixture(t, options); assert.equal(scene.cockpit.enter(), true); await settle(); scene.frame(); scene.refreshCard(); await settle(); return scene; } const angleDeg = (a, b) => Cesium.Math.toDegrees(Cesium.Cartesian3.angleBetween(a, b)); const sitePosition = (key) => Cesium.Cartesian3.fromDegrees(SITES[key].lon, SITES[key].lat, 0); /** How far the camera looks from a site, degrees. */ function missDeg(shot, key) { const line = Cesium.Cartesian3.subtract( sitePosition(key), shot.destination, new Cesium.Cartesian3(), ); return angleDeg(shot.direction, line); } /** The camera's angle from nadir, degrees. */ function offNadir(shot) { const toCentre = Cesium.Cartesian3.negate(shot.destination, new Cesium.Cartesian3()); return angleDeg(shot.direction, toCentre); } /** The off-nadir angle to a site from the camera's position, degrees. */ function siteOffNadir(shot, key) { const line = Cesium.Cartesian3.subtract( sitePosition(key), shot.destination, new Cesium.Cartesian3(), ); const toCentre = Cesium.Cartesian3.negate(shot.destination, new Cesium.Cartesian3()); return angleDeg(line, toCentre); } /** * Run frames, the satellite drifting a little each one, and return the * largest turn of the camera between two frames. */ function run(scene, frames, { drift = 0.0005 } = {}) { let largest = 0; let previous = scene.shots.at(-1); for (let i = 0; i < frames; i += 1) { scene.satellites.move(drift, drift); const shot = scene.frame(); largest = Math.max(largest, angleDeg(previous.direction, shot.direction)); previous = shot; } return largest; } /** Frames enough for the focus easing to land (about 12 time constants). */ const LAND_FRAMES = Math.ceil((12 * ORBITAL_FOCUS_EASE_TAU_MS) / FRAME_MS); /** * No frame turns the camera further than this: a smooth turn, no jump. The * focus clock moves about 6% of the way in a 16 ms frame, so even a swing * back from the 45° reach stays under it. */ const MAX_TURN_PER_FRAME_DEG = 3; /** A Live Signals row's button, by layer and id. */ const rowButton = (scene, layerId, id) => scene.$( `#cockpit-signal-list button[data-signal-layer="${layerId}"][data-signal-id="${id}"]`, ); const siteRow = (scene, key) => rowButton(scene, 'military-installations', SITES[key].id); const satelliteRow = (scene, id) => rowButton(scene, 'satellites', String(id)); /** The rows as published: title, detail, tone and target. */ const rows = (scene) => scene.store.signals ?? []; /** Rebuild the rows and let the view render them. */ async function refreshRows(scene) { scene.refreshCard(); await settle(); } test('in orbit Live Signals lists the sites getNearby finds and the nearest satellites', async (t) => { const scene = await inOrbit(t); const { $, sites } = scene; assert.ok(sites.calls.getNearby > 0, 'asked the installations layer'); assert.equal($('#cockpit-context').hidden, true, 'no Contact card in orbit'); const shown = rows(scene); assert.ok(shown.length <= 5, 'five rows at most'); assert.equal(shown[0].title, 'TRACK ACQUIRED', 'the track row stays first'); // Two site rows, nearest to nadir first, then the satellites (debris out). const sitesShown = shown.filter((row) => row.target?.layerId === 'military-installations'); assert.deepEqual( sitesShown.map((row) => row.target.id).sort(), [SITES.alpha.id, SITES.bravo.id].sort(), ); for (const row of sitesShown) { assert.match(row.detail, /^(BASE|AIRFIELD) · OFF-NADIR \d+\.\d°$/); assert.match(row.className, /nearby actionable/); } const satellitesShown = shown.filter((row) => row.target?.layerId === 'satellites'); assert.deepEqual(satellitesShown.map((row) => row.title), ['LANDSAT 9', 'SENTINEL-2A']); assert.match(satellitesShown[0].detail, /^SATELLITE · (AHEAD|[LR] \d{3}°) · [\d,.]+\s+KM$/); // Each row names its own action. assert.equal(siteRow(scene, 'alpha').getAttribute('aria-label'), 'Keep the camera on Camp Alpha'); assert.equal(satelliteRow(scene, 49260).getAttribute('aria-label'), 'Ride LANDSAT 9'); // Rebuilt on the clock, rows keep their keys and times. const before = shown.map((row) => [row.key, row.time]); await refreshRows(scene); assert.deepEqual(rows(scene).map((row) => [row.key, row.time]), before); }); test('a site row turns the camera onto it, holds it, and reads its off-nadir angle', async (t) => { const scene = await inOrbit(t); const { $, cockpit, store } = scene; assert.ok(missDeg(scene.shots.at(-1), 'alpha') > 10, 'not centred at nadir'); siteRow(scene, 'alpha').click(); assert.equal(cockpit.orbital.focus.key, SITES.alpha.id); // The first frames turn part of the way: no jump onto the site. assert.ok(missDeg(scene.frame(), 'alpha') > 5, 'still turning'); const largest = run(scene, LAND_FRAMES); assert.ok(largest > 0.1 && largest < MAX_TURN_PER_FRAME_DEG, `turned ${largest}° in a frame`); for (let i = 0; i < 20; i += 1) { scene.satellites.move(0.002, 0.002); const shot = scene.frame(); assert.ok(missDeg(shot, 'alpha') < 1e-5, `frame ${i}: ${missDeg(shot, 'alpha')}°`); } for (let i = 0; i < 8; i += 1) scene.frame(); await settle(); const shot = scene.shots.at(-1); assert.equal( $('#cockpit-orbital-look-readout').textContent, `OFF-NADIR ${siteOffNadir(shot, 'alpha').toFixed(1)}°`, ); assert.equal($('#cockpit-orbital-focus').textContent, 'FOCUS · Camp Alpha'); assert.equal($('#cockpit-orbital-look-readout').getAttribute('aria-live'), 'off'); assert.equal(store.orbital.footprintKm, null); assert.match($('.cockpit-orbital-swath').textContent, /^SWATH ≈ [\d.]+ KM$/); // The held site's row reads as the subject does, first among the sites. const held = rows(scene).find((row) => row.target?.id === SITES.alpha.id); assert.match(held.className, /^track actionable$/); assert.match(held.detail, /^FOCUS · BASE · OFF-NADIR/); assert.equal(siteRow(scene, 'alpha').getAttribute('aria-label'), 'Release the camera from Camp Alpha'); }); test('another site row switches the focus; the held site row ends it', async (t) => { const scene = await inOrbit(t); const { cockpit } = scene; siteRow(scene, 'alpha').click(); run(scene, LAND_FRAMES); await settle(); siteRow(scene, 'bravo').click(); assert.equal(cockpit.orbital.focus.key, SITES.bravo.id); const largest = run(scene, LAND_FRAMES); assert.ok(largest < MAX_TURN_PER_FRAME_DEG, `turned ${largest}° in a frame`); assert.ok(missDeg(scene.shots.at(-1), 'bravo') < 1e-5); await settle(); assert.match(rows(scene).find((row) => row.target?.id === SITES.alpha.id).className, /^nearby/); siteRow(scene, 'bravo').click(); assert.equal(cockpit.orbital.focus, null); const back = run(scene, LAND_FRAMES, { drift: 0 }); assert.ok(back < MAX_TURN_PER_FRAME_DEG); assert.ok(offNadir(scene.shots.at(-1)) < 1e-6, 'back at nadir'); }); test('a click on a site marker focuses it through the layer; a click elsewhere eases back', async (t) => { const scene = await inOrbit(t); const { cockpit, handler } = scene; scene.click(SITES.alpha.at); assert.equal(cockpit.orbital.focus.key, SITES.alpha.id); assert.equal(handler.stockClicks, 1, 'Cesium still gets the click'); run(scene, LAND_FRAMES); assert.ok(missDeg(scene.shots.at(-1), 'alpha') < 1e-5); scene.click(SITES.alpha.at); assert.equal(cockpit.orbital.focus.key, SITES.alpha.id, 'kept on a second click'); const focused = offNadir(scene.shots.at(-1)); scene.click(EMPTY_GROUND); assert.equal(cockpit.orbital.focus, null); assert.ok(offNadir(scene.frame()) > focused * 0.8, 'no jump back'); const largest = run(scene, LAND_FRAMES, { drift: 0 }); assert.ok(largest < MAX_TURN_PER_FRAME_DEG); assert.ok(offNadir(scene.shots.at(-1)) < 1e-6); // A site beyond the reach is not focused, and ends a focus as a click // elsewhere does. scene.click(SITES.far.at); assert.equal(cockpit.orbital.focus ?? null, null); scene.click(SITES.alpha.at); assert.equal(cockpit.orbital.focus.key, SITES.alpha.id); scene.click(SITES.far.at); assert.equal(cockpit.orbital.focus, null); }); test('a click a tool owns is left alone', async (t) => { const scene = await inOrbit(t); const lease = claimPointer('draw'); t.after(() => releasePointer(lease)); scene.click(SITES.alpha.at); assert.equal(scene.cockpit.orbital.focus ?? null, null, 'no focus while drawing'); releasePointer(lease); scene.click(SITES.alpha.at); const again = claimPointer('draw'); t.after(() => releasePointer(again)); scene.click(EMPTY_GROUND); assert.equal(scene.cockpit.orbital.focus.key, SITES.alpha.id, 'kept while drawing'); }); test('a double-click on a site focuses it and keeps the orbital view', async (t) => { const scene = await inOrbit(t); const { cockpit, viewer, handler } = scene; scene.doubleClick(SITES.alpha.at); assert.equal(handler.stockDoubleClicks, 0, 'Cesium does not track the site'); assert.equal(viewer.trackedEntity, undefined); scene.frame(); assert.equal(cockpit.active, true, 'still in orbit'); assert.equal(cockpit.orbital.focus.key, SITES.alpha.id); scene.doubleClick(SITES.bravo.at); assert.equal(cockpit.orbital.focus.key, SITES.bravo.id); scene.doubleClick(SITES.far.at); assert.equal(handler.stockDoubleClicks, 0, 'beyond reach: not focused, not tracked'); scene.frame(); assert.equal(cockpit.active, true); scene.doubleClick(EMPTY_GROUND); assert.equal(handler.stockDoubleClicks, 1, 'anywhere else goes on to Cesium'); }); test('the focus ends by itself, easing back, when the site leaves the reach', async (t) => { const scene = await inOrbit(t); const { cockpit } = scene; siteRow(scene, 'bravo').click(); run(scene, LAND_FRAMES, { drift: 0 }); let released = null; let previous = scene.shots.at(-1); let largest = 0; for (let i = 0; i < 2000 && released === null; i += 1) { scene.satellites.move(0.004, 0.004); const shot = scene.frame(); largest = Math.max(largest, angleDeg(previous.direction, shot.direction)); previous = shot; if (!cockpit.orbital.focus) released = i; } assert.ok(released > 0, 'the focus ended'); assert.ok(offNadir(scene.shots.at(-1)) > 40, 'held to the reach'); largest = Math.max(largest, run(scene, LAND_FRAMES, { drift: 0 })); assert.ok(largest < MAX_TURN_PER_FRAME_DEG, `turned ${largest}° in a frame`); assert.ok(offNadir(scene.shots.at(-1)) < 1e-6, 'back at nadir'); }); test('turning the layer off ends the focus and says why; a reload around the site keeps it', async (t) => { const scene = await inOrbit(t); scene.click(SITES.alpha.at); run(scene, 5); scene.sites.enabled = false; scene.frame(); assert.equal(scene.cockpit.orbital.focus, null, 'layer off'); assert.equal(scene.cockpit.orbital.focusReleasing, true, 'easing back'); await refreshRows(scene); const status = rows(scene).find((row) => row.title === 'SITES STANDBY'); assert.ok(status, 'a status row says why no site is listed'); assert.equal(status.detail, 'ENABLE MAPPED INSTALLATIONS FOR SITE PINGS'); assert.equal(status.className, 'warning'); assert.ok(!rows(scene).some((row) => row.target?.layerId === 'military-installations')); assert.equal(rows(scene).filter((row) => row.target?.layerId === 'satellites').length, 2); scene.sites.enabled = true; await refreshRows(scene); assert.ok(!rows(scene).some((row) => row.title === 'SITES STANDBY')); scene.click(SITES.bravo.at); run(scene, LAND_FRAMES); // The layer reloads its thinned view: the site leaves its records for a // while. It has not moved, so the focus stays on it. const loaded = scene.sites.records; scene.sites.records = loaded.filter((r) => r.id !== SITES.bravo.id); run(scene, 10); assert.equal(scene.cockpit.orbital.focus.key, SITES.bravo.id, 'kept through a reload'); assert.ok(missDeg(scene.shots.at(-1), 'bravo') < 1e-5, 'still centred'); scene.sites.records = loaded; // A row the list shows works even if the layer just dropped its site. await refreshRows(scene); scene.sites.records = loaded.filter((r) => r.id !== SITES.alpha.id); siteRow(scene, 'alpha').click(); assert.equal(scene.cockpit.orbital.focus.key, SITES.alpha.id); }); test('a satellite row rides it, staying in orbit; RETURN goes back', async (t) => { const scene = await inOrbit(t); const { cockpit, satellites, viewer, modeEvents } = scene; assert.ok(!rows(scene).some((row) => row.title.startsWith('RETURN')), 'no history yet'); siteRow(scene, 'alpha').click(); run(scene, 5); const before = Cesium.Cartesian3.clone(scene.shots.at(-1).destination); const firstTrack = cockpit.signalItems.find((item) => item.key === 'track'); firstTrack.timestamp -= 60_000; satelliteRow(scene, 49260).click(); const newTrack = cockpit.signalItems.filter((item) => item.key === 'track'); assert.equal(newTrack.length, 1); assert.ok(newTrack[0].timestamp > firstTrack.timestamp, 'the new ride’s own time'); assert.deepEqual(satellites.calls.slice(-2), [['track', 49260], ['subject', 49260]]); assert.equal(viewer.trackedEntity, undefined, 'the Cockpit keeps the camera'); assert.equal(cockpit.subjectId, 49260); assert.equal(cockpit.orbital.focus, null, 'the focus is reset'); assert.equal(modeEvents.at(-1)?.active, true); await settle(); const shown = rows(scene); assert.deepEqual([shown[0].title, shown[0].detail], ['TRACK ACQUIRED', 'LANDSAT 9 · NADIR VIEW']); assert.equal(shown.filter((row) => row.title === 'TRACK ACQUIRED').length, 1); const back = shown.find((row) => row.title === 'RETURN · ISS (ZARYA)'); assert.ok(back, 'a RETURN row while there is history'); assert.equal(back.detail, 'PREVIOUS SATELLITE'); assert.equal(satelliteRow(scene, 25544).getAttribute('aria-label'), 'Return to ISS (ZARYA)'); assert.ok(!shown.some((row) => row.title === 'ISS (ZARYA)'), 'listed once, as RETURN'); // The camera hops along the way, never in one jump. const target = satellites.position(49260); const hopM = Cesium.Cartesian3.distance(before, target); let previous = before; let largestStep = 0; for (let i = 0; i < Math.ceil(ORBITAL_HOP_MS / FRAME_MS) + 2; i += 1) { const shot = scene.frame(); assert.equal(cockpit.active, true, `still in orbit at frame ${i}`); largestStep = Math.max(largestStep, Cesium.Cartesian3.distance(previous, shot.destination)); previous = shot.destination; } assert.ok(largestStep < hopM * 0.1, `largest step ${largestStep} m of ${hopM} m`); assert.ok(Cesium.Cartesian3.distance(previous, target) < 1, 'landed on the satellite'); run(scene, LAND_FRAMES, { drift: 0 }); assert.ok(offNadir(scene.shots.at(-1)) < 1e-6, 'looking at nadir'); // On to another, then RETURN twice back to the start. await refreshRows(scene); satelliteRow(scene, 40697).click(); assert.equal(cockpit.subjectId, 40697); await settle(); assert.ok(rows(scene).some((row) => row.title === 'RETURN · LANDSAT 9')); satelliteRow(scene, 49260).click(); assert.equal(cockpit.subjectId, 49260); await settle(); satelliteRow(scene, 25544).click(); assert.equal(cockpit.subjectId, 25544); await settle(); assert.ok(!rows(scene).some((row) => row.title.startsWith('RETURN')), 'back at the start'); scene.frame(); assert.equal(cockpit.active, true); assert.ok(!satellites.calls.some(([, id]) => id === 99001), 'debris never offered'); }); test('while the camera hops, no stale rows; on landing, rows measured from the new satellite', async (t) => { const scene = await inOrbit(t); const { cockpit } = scene; satelliteRow(scene, 49260).click(); await settle(); // Mid-hop: TRACK ACQUIRED and RETURN only, nothing measured from the old // satellite's frame (which would list LANDSAT 9 itself at 0 km). let shown = rows(scene); assert.deepEqual( shown.map((row) => row.title), ['TRACK ACQUIRED', 'RETURN · ISS (ZARYA)'], ); scene.frame(); scene.refreshCard(); await settle(); assert.ok(cockpit.orbital.hop, 'still hopping'); assert.deepEqual(rows(scene).map((row) => row.title), ['TRACK ACQUIRED', 'RETURN · ISS (ZARYA)']); // Landed: the first frame on the satellite rebuilds them at once. for (let i = 0; i < Math.ceil(ORBITAL_HOP_MS / FRAME_MS) + 2; i += 1) scene.frame(); await settle(); shown = rows(scene); assert.ok(shown.some((row) => row.target?.layerId === 'military-installations'), 'sites back'); const satellitesShown = shown.filter((row) => row.title !== 'TRACK ACQUIRED' && row.target?.layerId === 'satellites'); assert.ok(!satellitesShown.some((row) => row.title === 'LANDSAT 9'), 'never the ridden one'); assert.equal(satellitesShown.filter((row) => row.target.id === '25544').length, 1, 'ISS only as RETURN'); }); test('RETURN to a satellite that left the catalogue offers the one before it', async (t) => { const scene = await inOrbit(t); const { cockpit, satellites } = scene; satelliteRow(scene, 49260).click(); for (let i = 0; i < 80; i += 1) scene.frame(); await settle(); satelliteRow(scene, 40697).click(); for (let i = 0; i < 80; i += 1) scene.frame(); await settle(); assert.ok(rows(scene).some((row) => row.title === 'RETURN · LANDSAT 9')); satellites.remove(49260); satelliteRow(scene, 49260).click(); assert.equal(cockpit.subjectId, 40697, 'still on the same satellite'); await settle(); assert.ok(rows(scene).some((row) => row.title === 'RETURN · ISS (ZARYA)'), 'the one before'); satelliteRow(scene, 25544).click(); assert.equal(cockpit.subjectId, 25544); }); test('with Installations off no site is offered, by row, list or click', async (t) => { const scene = await inOrbit(t); const { cockpit, sites } = scene; // The real layer keeps its records and getNearby answers while off. sites.enabled = false; await refreshRows(scene); assert.ok(rows(scene).some((row) => row.title === 'SITES STANDBY')); assert.equal(cockpit.orbital.listedSites.size, 0, 'nothing kept to focus from'); assert.equal(cockpit.toggleOrbitalFocus(SITES.alpha.id), false); scene.click(SITES.alpha.at); assert.equal(cockpit.orbital.focus ?? null, null); }); test('an arrow during the ease back from a focus turns on the arrows’ clock', async (t) => { const scene = await inOrbit(t); const { cockpit } = scene; siteRow(scene, 'alpha').click(); run(scene, LAND_FRAMES); scene.click(EMPTY_GROUND); scene.frame(); assert.equal(cockpit.orbital.focusReleasing, true); const view = { ...cockpit.orbital.lookView }; assert.ok(Math.abs(view.pitchDeg) > 1 || Math.abs(view.yawDeg) > 1, 'still turned'); cockpit.onKeyDown({ key: 'ArrowUp', target: document.body, preventDefault() {}, stopImmediatePropagation() {}, }); assert.equal(cockpit.orbital.focusReleasing, false); // The arrow tilts on from where the view is, not from nadir. assert.ok( Math.abs(cockpit.orbital.lookTarget.yawDeg - view.yawDeg) < 1e-6, 'across kept', ); assert.ok(cockpit.orbital.lookTarget.pitchDeg > view.pitchDeg, 'tilted on up'); }); test('leaving orbit leaves no orbital rows to act on', async (t) => { const scene = await inOrbit(t); scene.click(SITES.alpha.at); run(scene, 5); scene.satellites.drop(); scene.frame(); assert.equal(scene.cockpit.active, false); assert.equal(scene.store.presence.context, false); scene.click(SITES.bravo.at); assert.equal(scene.cockpit.toggleOrbitalFocus(SITES.bravo.id), false); assert.equal(scene.cockpit.onOrbitalClick(SITES.bravo.at), false); assert.equal(scene.cockpit.rideOrbitalSatellite(49260), false); assert.equal(scene.cockpit.handleOrbitalSignalClick('satellites', '49260'), false); }); test('NADIR and Home end a focus; an arrow takes the view over where it is', async (t) => { const scene = await inOrbit(t); const { $, cockpit } = scene; const press = (key) => cockpit.onKeyDown({ key, target: document.body, preventDefault() {}, stopImmediatePropagation() {}, }); scene.click(SITES.alpha.at); run(scene, LAND_FRAMES); await settle(); $('#cockpit-orbital-nadir').click(); assert.equal(cockpit.orbital.focus, null); assert.ok(offNadir(scene.frame()) > 5, 'eases back'); scene.click(SITES.alpha.at); run(scene, LAND_FRAMES); press('Home'); assert.equal(cockpit.orbital.focus, null); scene.click(SITES.alpha.at); run(scene, LAND_FRAMES); const held = { ...cockpit.orbital.lookView }; press('ArrowUp'); assert.equal(cockpit.orbital.focus, null); assert.equal( cockpit.orbital.lookTarget.pitchDeg, Math.floor(held.pitchDeg / 5 + 1e-9) * 5 + 5, ); }); test('reduced motion cuts onto the site, back, and between satellites', async (t) => { const scene = await inOrbit(t, { reducedMotion: true }); await settle(); scene.click(SITES.alpha.at); assert.ok(missDeg(scene.frame(), 'alpha') < 1e-5, 'on it at once'); scene.click(EMPTY_GROUND); assert.ok(offNadir(scene.frame()) < 1e-6, 'back at once'); satelliteRow(scene, 49260).click(); const shot = scene.frame(); assert.ok(Cesium.Cartesian3.distance(shot.destination, scene.satellites.position(49260)) < 1); }); test('stopping the Cockpit hands both clicks back to Cesium', async (t) => { const scene = fixture(t); const click = Cesium.ScreenSpaceEventType.LEFT_CLICK; const double = Cesium.ScreenSpaceEventType.LEFT_DOUBLE_CLICK; assert.notEqual(scene.handler.getInputAction(click), scene.handler.stock); scene.cockpit.stop(); assert.equal(scene.handler.getInputAction(click), scene.handler.stock); assert.equal(scene.handler.getInputAction(double), scene.handler.stockDouble); }); test('the focused site keeps its row after nearer sites push it down', async (t) => { const scene = await inOrbit(t); siteRow(scene, 'alpha').click(); run(scene, LAND_FRAMES); // Eight more sites appear right below the satellite, all nearer to nadir. for (let i = 0; i < 8; i += 1) scene.sites.records.push({ id: `osm:military:way/9${i}`, osmKey: `way/9${i}`, name: `Near ${i}`, class: 'base', kind: 'installation', latitude: 30.4 + i * 0.01, longitude: -96.6, memberNames: [], sources: [], }); await refreshRows(scene); const sitesShown = rows(scene).filter((row) => row.target?.layerId === 'military-installations'); assert.equal(sitesShown.length, 2); assert.equal(sitesShown[0].target.id, SITES.alpha.id, 'the focused site is kept, first'); siteRow(scene, 'alpha').click(); assert.equal(scene.cockpit.orbital.focus, null, 'its row still ends the focus'); }); test('a site the layer drops in a reload keeps its row, and its row still focuses it', async (t) => { const scene = await inOrbit(t); await settle(); const before = rows(scene).map((row) => row.key); const loaded = scene.sites.records; // The thinned view reloads without Camp Alpha for a moment. scene.sites.records = loaded.filter((r) => r.id !== SITES.alpha.id); await refreshRows(scene); assert.deepEqual(rows(scene).map((row) => row.key), before, 'the rows hold still'); siteRow(scene, 'alpha').click(); assert.equal(scene.cockpit.orbital.focus?.key, SITES.alpha.id, 'focused from its row'); siteRow(scene, 'alpha').click(); // Gone for good: after a while it leaves the rows. for (let i = 0; i < 12; i += 1) await refreshRows(scene); assert.ok(!rows(scene).some((row) => row.target?.id === SITES.alpha.id), 'forgotten later'); }); test('shown rows keep their places while they still qualify', async (t) => { const scene = await inOrbit(t); await settle(); const sitesBefore = rows(scene) .filter((row) => row.target?.layerId === 'military-installations') .map((row) => row.target.id); // A site appears right below the satellite, nearer to nadir than both. scene.sites.records.push({ id: 'osm:military:way/999', osmKey: 'way/999', name: 'Directly Below', class: 'base', kind: 'installation', latitude: 30.01, longitude: -97.01, memberNames: [], sources: [], }); await refreshRows(scene); const sitesAfter = rows(scene) .filter((row) => row.target?.layerId === 'military-installations') .map((row) => row.target.id); assert.deepEqual(sitesAfter, sitesBefore, 'no row moves while its site is in reach'); // Once a shown site leaves the list, the nearer one takes its slot. scene.sites.records = scene.sites.records.filter((r) => r.id !== SITES.bravo.id); for (let i = 0; i < 12; i += 1) await refreshRows(scene); assert.ok( rows(scene).some((row) => row.target?.id === 'osm:military:way/999'), 'the nearer site fills the freed slot', ); });