Keep a landed aircraft on the ground, not at its approach height

A grounded row with no altitude fell back to the aircraft's sticky
altitude, which straight after a landing is still the approach height.
Military contacts then hung there for as long as they stayed on the
ground (the grounded floor only ever raises a height); civil contacts
held it until the ground cell under them warmed, which for a contact far
from the viewer is never. The 3D model is ground-snapped on its own, so
the plane dropped when the model took over.

A grounded contact with no altitude now uses only an altitude it gave
on the ground, else the ground fallback. Labels, the tracked readout
and the follow distance read "On the ground" / no flight level instead
of the approach altitude.
This commit is contained in:
Sameh Khamis committed 2026-11-19 20:22:33 -08:00
1 parent 20620e89bf
commit 9b10489454
8 files changed
+145 -26

No files matched your search

+9 -4
View File
@@ -194,9 +194,12 @@ export function createQueries({
lon: num(info?.rawLon),
// altitudeFt is the sticky barometric/MSL aviation field — converted to
// meters here for shape parity with the flights layer.
altitudeM: Number.isFinite(info?.altitudeFt)
? info.altitudeFt * 0.3048
: null,
// A grounded contact reports only an altitude it gave on the ground.
altitudeM: info?.onGround
? (info.groundAltitudeM ?? null)
: Number.isFinite(info?.altitudeFt)
? info.altitudeFt * 0.3048
: null,
speedMps: num(info?.speedMps),
heading: num(info?.track),
verticalRateMps: num(info?.verticalRateMps),
@@ -510,7 +513,9 @@ export function createQueries({
// TR-3B, not the airframe underneath it.
const klass = tr3bTypeLabel(icao24, info?.type || 'MIL');
if (object.klass !== klass) object.klass = klass;
const altitudeFt = info?.altitudeFt ?? 0;
// A grounded contact shows no flight level, like the civil layer; its
// sticky altitudeFt may still be the approach height.
const altitudeFt = info?.onGround ? 0 : (info?.altitudeFt ?? 0);
if (object._altitudeFt !== altitudeFt) {
object._altitudeFt = altitudeFt;
// military metadata stores altitudeFt (feet); the helper takes metres
+16 -9
View File
@@ -70,19 +70,25 @@ export class MilitaryFlightRecords {
this.missingPolls.delete(icao24);
const prevMeta = this.data.get(icao24);
// adsb.lol/readsb reports GROUND traffic as alt_baro === "ground" (no
// separate boolean). Grounded planes fall back to their last known
// altitude (field elevation is unknowable here), else 0 m — never the
// 3 km airborne default (a parked plane must not float).
// separate boolean). Grounded planes fall back to an altitude they
// reported while on the ground (field elevation is unknowable here),
// else 0 m — never the 3 km airborne default, and never the last
// AIRBORNE altitude: `altitudeFt` is sticky across the landing, so it
// still holds the approach height, and the icon would hang there while
// the ground-snapped model sits on the field (a parked plane must not
// float). `groundAltitudeM` is that ground-only altitude: set by a
// grounded report that carries one, held while grounded, dropped on
// takeoff.
const onGround = aircraft.onGround;
const altitudeFt =
aircraft.baroAltitudeM == null ? null : aircraft.baroAltitudeM / 0.3048;
const groundAltitudeM = onGround
? (aircraft.baroAltitudeM ??
(prevMeta?.onGround === true ? prevMeta.groundAltitudeM : null) ??
null)
: null;
const altitudeM =
aircraft.baroAltitudeM ??
(onGround
? Number.isFinite(prevMeta?.altitudeFt)
? prevMeta.altitudeFt * 0.3048
: 0
: 3048);
aircraft.baroAltitudeM ?? (onGround ? (groundAltitudeM ?? 0) : 3048);
const verticalRateMps = aircraft.verticalRateMps;
const callsign = aircraft.callsign;
const type = aircraft.typeCode;
@@ -198,6 +204,7 @@ export class MilitaryFlightRecords {
registration: stickyText(registration, prevMeta?.registration),
operator: stickyText(operator, prevMeta?.operator),
altitudeFt: stickyNumber(altitudeFt, prevMeta?.altitudeFt, null),
groundAltitudeM,
// geoAltitudeM/renderAltitudeM are ADDITIVE fields alongside the
// untouched aviation `altitudeFt` — never rename/replace it (labels,
// the FL readout, and the landed-fast-cull heuristic all still read
+46
View File
@@ -65,6 +65,52 @@ test('military ground records leave model-owned placement alone and warm the sam
assert.deepEqual(unowned.floorWarmPoints, owned.floorWarmPoints);
});
test('a military contact that lands with no altitude sits on the ground, not at its last airborne height', () => {
for (const [modelOwnsVisual, expected] of [
[false, 201.5],
[true, 0],
]) {
const records = store();
records.receive(
observation({ baroAltitudeM: 1539 }),
context({ modelOwnsVisual }),
);
// Every grounded report, not just the first after the landing.
for (let poll = 0; poll < 3; poll += 1) {
const landed = records.receive(
observation({ onGround: true, baroAltitudeM: null, speedMps: 4.6 }),
context({ modelOwnsVisual }),
);
assert.equal(landed.meta.renderAltitudeM, expected);
// The aviation readout keeps the last reported altitude, as before.
assert.equal(landed.meta.altitudeFt, 1539 / 0.3048);
}
}
});
test('a grounded military contact holds a ground altitude it reported earlier', () => {
const records = store();
records.receive(
observation({ onGround: true, baroAltitudeM: 320 }),
context({ modelOwnsVisual: true }),
);
for (let poll = 0; poll < 2; poll += 1) {
const next = records.receive(
observation({ onGround: true, baroAltitudeM: null }),
context({ modelOwnsVisual: true }),
);
assert.equal(next.meta.renderAltitudeM, 320);
}
// Airborne again: that ground altitude is forgotten, so the next landing
// without an altitude starts from the ground, not from it.
records.receive(observation({ baroAltitudeM: 900 }), context());
const relanded = records.receive(
observation({ onGround: true, baroAltitudeM: null }),
context({ modelOwnsVisual: true }),
);
assert.equal(relanded.meta.renderAltitudeM, 0);
});
test('military records keep bounded partial retention and release metadata only after removal admission', () => {
const first = store();
const second = store();
+8 -2
View File
@@ -365,7 +365,9 @@ export function createTracking({
parts.queries._toCleanText(info?.registration) || t('Reg unknown');
const operator =
parts.queries._toCleanText(info?.operator) || t('Operator unknown');
const altitude = parts.queries._formatAltitude(info?.altitudeFt);
const altitude = info?.onGround
? t('On the ground')
: parts.queries._formatAltitude(info?.altitudeFt);
const speedKt = info?.speedMps ? Math.round(info.speedMps * 1.944) : null;
const tail = speedKt ? `${altitude} · ${speedKt} kt` : altitude;
return [
@@ -1124,7 +1126,11 @@ export function createTracking({
// renderer's default follow distance is far too tight. It gets a calibrated
// viewFrom — behind + above, distance scaled to altitude — for a readable
// initial frame with surrounding context. (ENU: east=+X, north=+Y, up=+Z.)
const altM = info?.altitudeFt ? info.altitudeFt * 0.3048 : 1500;
const altM = info?.onGround
? 0
: info?.altitudeFt
? info.altitudeFt * 0.3048
: 1500;
const followRange = Math.min(Math.max(altM * 1.1 + 2500, 3000), 30000);
const viewFrom = vec(0, -followRange * 0.8, followRange * 0.55);