Flight computer reference

A flight program sees the vehicle through one object, fc, passed to update(fc) fifty times per simulated second and to booster(fc) for each separated stage. This page lists everything on it. It is drawn from the simulator's own source — the flight computer and the structured reference its editor completes from — not from memory; where the two disagree, or where behaviour could not be confirmed, the entry says so.

The flight program explains the contract around update(fc), and steering and guidance the guidance planes in depth. The conventions below are what you need to read the tables.

Conventions

• Units are SI — metres, seconds, kilograms, newtons, pascals — unless a row says otherwise. Angles are in degrees.
• Readings are sensed. With the mission's sensors set to realistic or hard, every reading and every prediction is the flight computer's navigation estimate, not the truth. With ideal sensors (the default) they are the truth.
• The guidance plane. Pitch, yaw and every along-track quantity are measured in a guidance plane, a great circle with a forward direction, chosen with fc.setPlane(). On the default 'launch' plane forward is the launch azimuth.
• Signs. Every along-track quantity is + forward: horizontalSpeed, target.distance, every error (+ means long, beyond the target). Every crossrange is + right of forward. miss is the total distance.
• Commands only act inside update or booster. Called from anywhere else — a timer, a resolved promise — they throw.
• Rows marked “new” were added after the original planar simulator, or changed meaning with the move to three dimensions. Everything else keeps its original name and meaning, with “east” read as “forward in the guidance plane”.

Time and identity

The destination and arrival of a Moon or Mars mission are not in fc.mission; read fc.destination and fc.plan.arrival.

Position and velocity

Attitude

Pitch is the nose's angle above the local horizon measured in the guidance plane towards forward: 90 is straight up, 0 forward, 180 backward, −90 down, wrapped to (−180, 180]. Yaw is the nose's angle out of the plane, + to the right, from −90 to 90. Every direction field comes as a pair — a pitch and its yaw companion — so that fc.steer(fc.airRetrograde, fc.airRetrogradeYaw) points exactly along the relative wind wherever a crosswind blows it.

The six pitch fields keep their original names and are now measured in the guidance plane; their yaw companions are new.

Air data

There is no direct wind reading. The difference between the air-relative and surface-relative fields is the wind's effect on the flight.

Loads

Thermal

Mass

Propulsion

"The lit engines, or those that would light" means: the engines burning, if any are; otherwise the ones fc.setEngines() has selected.

Landing gear

Orbit and target

On an Earth mission fc.target is null when the vehicle has no platform. On a Moon or Mars mission it always carries the destination fields. About the destination itself, the platform fields describe the landing pad when the mission names one — distance is then the great-circle range and crossrange zero — and are absent when it does not; range falls back to bodyRange.

Destination

These are present on every flight. On an Earth mission fc.destination is 'earth', fc.body describes Earth and fc.plan is null.

State

Queries

Queries have no side effects and may be called at any time inside the program. The predictors cost real time — a landing plan about 1.3 ms, a stop point about 0.7 ms — so refresh them a few times a second, not every tick.

The predictors are point masses with drag in the mean wind. They know neither the gusts nor each engine's own thrust, so keep a burn closed-loop: fc.stopPoint() during the burn tells you where it is really going.

const lb = fc.predict({ landingBurn: { engines: 1 } });
if (lb && fc.radarAltitude < lb.ignitionAltitude + 50) fc.ignite();

const s = fc.stopPoint();   // once lit, a few times a second
if (s) fc.throttle(fc.throttleSetting + (s.altitude < 0 ? 0.05 : -0.02));

Commands

Engines

fc.setEngines('sea-level'); fc.ignite();   // liftoff without the vacuum engines
// … above the thick air:
const vac = fc.engineGroups.find((g) => g.vacuum);
if (vac && vac.canFire && vac.lit === 0) { fc.setEngines('all'); fc.ignite(); }

Attitude and guidance

fc.steer(fc.airRetrograde, fc.airRetrogradeYaw);   // tail-first along the relative wind, crosswind included
fc.steer({ elevation: 85, heading: 45 });           // absolute: 85° up, leaning north-east
fc.setPlane({ target: fc.mission.boosterTarget });  // forward = towards the landing platform

At a sphere-of-influence crossing a vehicle on the 'launch' or azimuth plane falls back to 'orbit', because an Earth-fixed plane means nothing about another body.

Staging and hardware

Mission, time and logging

if (phase === 'coast') fc.sleep(Math.max(0, fc.orbit.timeToApoapsis - 60));
if (phase === 'cruise') fc.cruise(6 * 3600);

Helpers and constants

These are available without the fc. prefix. All are frozen.

const alt = new PID(0.02, 0.002, 0.05, { min: 0, max: 1 });
fc.throttle(alt.update(100 - fc.altitude, fc.dt));

What the program cannot see

Inside a program these globals are undefined, though it may declare its own variables with the same names: HS, globalThis, window, self, document, frames, parent, top, opener, navigator, location, localStorage, sessionStorage, indexedDB, caches, fetch, XMLHttpRequest, WebSocket, Worker, SharedWorker, setTimeout, setInterval, setImmediate, clearTimeout, clearInterval, queueMicrotask, requestAnimationFrame, requestIdleCallback, Function, Date, performance, process, require, module, exports, global, THREE and importScripts.

Every for, while and do…while loop is guarded: more than 10 million iterations, or 500 ms of wall-clock time, in one call stops the program with an error. A command given an invalid number throws a TypeError — fc.throttle("full"), say. Errors report the line in your source. If a program throws during flight, that vehicle keeps its last commands and flies on without software. This is a fence against accidents and casual cheating, not a security boundary.

What this reference does not confirm

A few behaviours are documented from the source rather than observed in a flight, or are open questions in the simulator itself:

• The predictors away from Earth. fc.impact, fc.predict(), fc.stopPoint(), fc.timeToAltitude() and fc.passes() are written against Earth's shape, rotation and orbit propagation. What they return about the Moon or Mars has not been validated, and the reference destination programs do not rely on them there.
• fc.target.closestApproach.t is computed as the time of the closest approach so far minus now. That it is negative once the approach is behind the vehicle follows from the code; it is not separately documented.
• fc.plane on an azimuth plane. The simulator's in-app guide says it reads 'launch'; the code sets 'azimuth', as listed here. For a body plane it reads 'body', which the in-app reference does not yet list.
• fc.orbit.closed. The in-app reference describes it as clearing the atmosphere and the ground. The code checks only that the orbit is bound and, about Earth, that its lowest point is above the equatorial radius. This page follows the code.
• fc.soi on an Earth mission reports Earth and its sphere of influence about the Sun, with exitIn null, because nothing else is in the field. That reading follows from the code.