Elite on the PicoComputer 3

Wireframe with backface culling is both the cheapest mode and the authentic one

The original game never did hidden-line removal. Its rule was "draw an edge if either face it belongs to faces the viewer", and that is exactly what Draw3D produces when faces are created without a fill colour. Filled faces cost about the same (the triangle fill runs in C). True hidden-line mode (depthmode=2) is the expensive one: it rasterises a float depth buffer over the ship's screen box every frame, which for a close ship is more RAM than the whole MMBasic heap.

What the PC3 gives us

The PicoComputer 3 is an RP2350B machine. Everything below is from the firmware source and the PC3 manual, not from the BBC's constraints.

The keyboard, sound and display facts above are for the PC3 (USB host, HDMI). They do not hold for the PicoCalc, whose I2C keyboard cannot report held keys.

What Draw3D actually does

From graphics/Draw3D.c (1349 lines, compiled -Os, runs from flash). The published 3D manual is out of date in several places; the list below is what the parser and renderer do today, and every item matters for the port.

Model and camera

• 8 objects, 3 cameras (MAX3D, MAXCAM in configuration.h). The camera is bound at CREATE.
• Camera sits at (x, y, 0) looking down +Z, no orientation, no look-at. X right, Y up, +Z into the screen. Projection is sx = W/2 - panx + (x - camx) * viewplane / z, so viewplane is the focal length in pixels. Elite's own projection is a 256-pixel focal length on a 256-wide screen; Draw3D CAMERA 1, 320 reproduces that field of view on 320 pixels.
• This is Elite's coordinate system. Elite stores every object relative to the player, nose along +Z. No camera transform is needed: a ship's INWK position goes straight into Draw3D WRITE n, x, y, z.
• ROTATE is absolute and takes a 5-element float array [w, x, y, z, m]; m scales by m², so keep it 1.0. Feed each ship's orientation quaternion every frame. RESET bakes the current pose rather than restoring it; never call it.
• No persistent position. x, y, z on SHOW/WRITE are world offsets applied to every vertex. x, y are clamped to ±32766, z is any integer. A ship inside the field of view always satisfies |x| < 0.7 z, so the clamp only bites beyond z ≈ 46000, which is dot range anyway.

Visibility and drawing

• Backface culling per face from the first three vertices of the face: N = (v1→v2) × (v1→v0), drawn when dot(v0 - cam, N) < 0. Winding therefore decides visibility; the converter must fix winding against Elite's stored face normals. SET FLAGS n, 4, face, count inverts individual faces as a repair tool.
• Painter's sort within one object only (bubble sort of face centroids, or of the farthest vertex with depthmode=1). Objects never depth-test against each other. Use depthmode=1 for solid ships: coplanar detail polygons (the Cobra's engine recesses) sort wrongly by centroid.
• Wireframe = faces created without a fill colour: the perimeter of each front-facing face is stroked. Shared edges between two visible faces are drawn twice, harmlessly.
• Solid = fill index per face: triangles via DrawTriangle, quads as two triangles plus the four outer edges, 5+ vertices through the scanline polygon filler. Faces must have at most 20 vertices; larger ones overrun a stack array (the Cobra's 7-vertex rear and the Thargoid's 8-vertex ring are fine).
• Hidden-line (depthmode=2, RP2350 only) needs a framebuffer write target, allocates a float per pixel of the object's on-screen bounding box (a 200x150 ship = 120 KB), rasterises every visible face into it, then depth-tests each edge pixel by pixel.
• No near-plane clipping. Anything with z near or below zero projects to huge values that wrap in 16-bit screen coordinates. BASIC must skip WRITE for z below a small positive threshold; Elite treats those distances as collisions anyway.
• SHOW erases its previous box in colour 0; WRITE leaves it. With a cleared framebuffer every frame, use WRITE. After WRITE, DRAW3D(XMIN n) and HIDE stop working; the game computes screen positions itself.
• Lighting (flag 8) reads the normal of the previous face and goes black without Draw3D LIGHT. Leave it off.

Cost and memory

• CREATE makes 16 page-rounded allocations, so an object costs at least 4 KB whatever its size; a Cobra (28 vertices, 17 faces) is about 5 KB. Twelve objects is under 64 KB.
• Every draw recomputes all face normals (two or three sqrtf per face) and bubble-sorts the faces. For Elite meshes (4 to 17 faces) that is negligible against interpreter time. Phase 0 measures it.
• CREATE needs nine comma slots even when the fill array is omitted: Draw3D CREATE n,nv,nf,cam,v(),fc(),f(),col(),ec(),. The vertex array is FLOAT v(2, nv-1) indexed (coord, vertex).

Rendering modes compared

Elite's ships are mostly convex, which is why the original looked right without occlusion. The exceptions (the Cobra's engine recesses, the Coriolis docking slot, the Python's rear) are handled in the original by winding and normals, and the converter carries those normals across, so mode 0 gives the same picture the BBC gave.

Per-face visibility distances in the blueprints (faces that are "always drawn when far") and per-vertex level-of-detail have no equivalent in Draw3D. Neither is visible at 320x240: the dot threshold covers the far case and the near case is drawn fully.

Shape of the program

Memory budget (HDMIUSB, MODE 2)

Screen layout (320x240)

Space view 320x184 (Elite's 256x192 at 1.25x width, trimmed 8 rows), dashboard 320x56 below it. The dashboard is line art on the BBC and stays line art here: drawn once into a background copy and blitted, with the moving indicators redrawn each frame. The 3D scanner ellipse, its ship sticks and the compass live in the dashboard. Text uses an 8x8 DEFINEFONT of the BBC MOS character set so the docked screens keep the original 40-column feel at 320 pixels.

Files

Bas/elite/
  elite.bas            the game (single program to start)
  data/ships.dat       12 meshes: header stats, vertices, faces (winding fixed)
  data/tokens.dat      expanded text tokens, name digraphs, system descriptions
  data/market.dat      17 commodities: base price, econ factor, base qty, mask, unit
  data/dash.bmp        dashboard bezel (optional; line art otherwise)
  elite.cmd            commander save (A: or SD)
Bas/elite_tools/
  blueprints.py        beebasm SHIP_* blocks -> data/ships.bas + ships.json (+ 3ddemo cross-check)
  meshcheck.py         scores meshview.bas auto output: engine verdicts vs stored normals
  pc3.py               COM3 console driver: probe, cmd, run (AUTOSAVE), grab (XMODEM screen capture)
  tokens.py            TKN1/QQ16 tables -> tokens.dat
  galaxy_ref.py        reference seeds/names/system data -> tests/galaxy_ref.txt
  build.py             assemble elite.bas from parts + DATA
Bas/elite/tests/
  bench.bas            Phase 0 frame-time harness
  meshview.bas         spin any ship in the three render modes; AUTOMODE runs the winding check
  sheet.bas            contact sheets of all ships for screen capture (captures/*.png)
  galaxy_test.bas      compares 256 systems x 8 galaxies against galaxy_ref.txt

Elite mechanism to MMBasic mechanism

Phases

Each phase ends with something that runs on the PC3 and a measurable acceptance test. Sizes are relative to Chuckie Egg (about 1700 lines including data).

' bench.bas  -  Phase 0 frame-time harness.  Run at OPTION CPUSPEED 378000.
OPTION EXPLICIT
MODE 2 : FRAMEBUFFER CREATE : FRAMEBUFFER WRITE F
Draw3D CAMERA 1, 320                       ' Elite's field of view on 320 px
DIM FLOAT v(2, 27), q(4)                   ' v(coord, vertex); q = w,x,y,z,m
DIM INTEGER fc(16), f(59), col(1), ec(16), fl(16)
DIM INTEGER n, ships, i, mode
DIM FLOAT t0
' ... READ the 28 vertices into v(0..2, i), the 17 face counts into fc(),
' ... the 60 face-vertex indices into f(); col(0)=RGB(WHITE): col(1)=RGB(GRAY)
' ... ec() all 0 (edge colour index), fl() all 1 (fill colour index)
q(4) = 1                                   ' m must be 1: the engine scales by m^2
FOR mode = 0 TO 2                          ' 0 wireframe, 1 solid, 2 hidden-line
  FOR ships = 1 TO 8
    FOR n = 1 TO ships
      IF mode = 1 THEN
        Draw3D CREATE n, 28, 17, 1, v(), fc(), f(), col(), ec(), fl()
      ELSE
        Draw3D CREATE n, 28, 17, 1, v(), fc(), f(), col(), ec()    ' 9 args, no fill = wireframe
      ENDIF
    NEXT n
    t0 = TIMER
    FOR i = 1 TO 100
      CLS
      FOR n = 1 TO ships
        MATH Q_EULER RAD(i + n * 40), RAD(i * 2), 0, q()
        Draw3D ROTATE q(), n
        Draw3D WRITE n, (n - 4) * 60, 0, 900, 0, (mode = 2) * -2
      NEXT n
      FRAMEBUFFER COPY F, N, B
    NEXT i
    PRINT "mode"; mode; ships; " ships:"; (TIMER - t0) / 100; " ms/frame"
    FOR n = 1 TO ships : Draw3D CLOSE n : NEXT n
  NEXT ships
NEXT mode

1Data

Blueprint pipeline and mesh viewer

Size: small · Depends on: 0

• blueprints.py: parse elite-source.asm SHIP_* blocks; build face polygons from edge adjacency; orient winding against the stored normals; emit header stats (speed, energy, laser, missiles, bounty, canisters, visibility distance, targetable area, explosion count) and the mesh.
• Cross-check every mesh against 3ddemo.bas (same vertex count, same face count, same edge set).
• meshview.bas: cycle ships, toggle the three modes, show the face count and frame time. This is where a wrong winding shows up as a missing or ghost face.

Accept when all 12 ships display correctly in wireframe and solid at three distances, with no face flagged by hand.

Results, 9 September 2026

elite_tools/blueprints.py reads the cassette elite-source.asm and writes Bas/elite/data/ships.bas. Every blueprint edge is drawn: boundary loops chained from the edge list, single-face detail edges as extra polygons, and bare lines (the Python's four fin lines, the Thargoid's two vents, the Cobra's nose spike, the Missile's eight fin lines) as sliver triangles with one extra vertex 0.5 units off the line. Nine ships came out identical to 3ddemo.bas; the demo's Python, Thargoid, Cobra and Missile were each missing lines and the Thargon was absent.

meshview.bas in auto mode asked the engine's DIAGNOSE for every polygon at three orientations and meshcheck.py compared each verdict with the stored normal: 444 verdicts, 0 mismatches on real faces, 3 deviations on sliver lines (inherent: a sliver's normal must be perpendicular to its line). Draw times per ship match Phase 0 (0.6 to 1.7 ms wireframe, 0.8 to 3.8 ms solid; the Coriolis is the dearest). Full table in tests/meshview_results.txt.

Solid mode must use depthmode 1 (vertex-based sort). With centroid sorting the coplanar detail quads on the Cobra's rear face can be painted over by the face itself; the demo already did this.

Captured from the PC3 (SAVE IMAGE, then XMODEM S into pc3.py grab):

The cassette version has no missions (the Constrictor and Thargoid plans are disc-version features), no Trumbles, and no docking animation. They are out of scope here and could be borrowed from the disc source later.

What could sink it, and the fallback

Ship data

The meshes in Bas/3ddemo.bas (already rendering on the engine) and the blueprint statistics from the cassette source.

Meshes proven in 3ddemo.bas

The demo scales blueprint coordinates by 2 (MATH SCALE vertices(),2.0) and uses the demo z column above to frame each ship at viewplane 600. Two things to know before reusing these meshes:

• Face counts differ from the blueprints on purpose. Elite stores edges, and some edges are surface detail whose two face ids are the same face (the Viper's rear vents, the Cobra's engine recesses and cockpit). Draw3D only strokes face perimeters, so the demo's converter turned each such detail group into an extra polygon that shares its host face's normal. That is the right technique and the converter in Phase 1 must do the same.
• All twelve are now regenerated from the source (Phase 1). The demo's Python, Thargoid, Cobra and Missile were missing lines and the Thargon was absent; the Asp Mk II in the demo is a disc-version ship and is not used.

Blueprint statistics (cassette source, XX21 order)

Header fields decoded from each SHIP_* block. Bounty is the 16-bit word divided by 10. Laser and missiles come from byte 19 (%00lllmmm). Types 5 and 7 share the Cobra Mk III blueprint.

Other header bytes the game needs: the gun vertex (Cobra 21, Thargoid 15, all others 0), the explosion count (4n+6 with n from 1 for the missile to 12 for the station), and the edge heap size. Source constants: NOSH=12, NTY=13, COPS=2, THG=6, CYL=7, SST=8, MSL=9, AST=10, OIL=11, TGL=12, ESC=13, POW=15. The station's docking slot is the 20 x 60 rectangle of vertices 12 to 15 on the +z face.

Algorithm crib from the deep dives

Condensed from bbcelite.com so the implementer does not need to re-read the 6502 listing for the parts that must be bit-exact or that define the feel of the game.

Everything here was read from the cassette source pages, not the prose overviews, unless marked "verify". Formulas are written in MMBasic terms where that removes 8-bit trickery; the ones that must stay bit-exact (seeds, twist, names, market, RNG, checksum) are written as the 6502 does them.

B1 · Galaxy, system and name generation (bit-exact)

A galaxy is three 16-bit seeds s0, s1, s2 stored little-endian (bytes s0_lo s0_hi s1_lo s1_hi s2_lo s2_hi). Galaxy 1: s0=&5A4A, s1=&0248, s2=&B753. System 0 of galaxy 1 is Tibedied; each further system is four twists on. Lave sits at chart position (20, 173).

' twist (TT54), 16-bit arithmetic, carry out of the high byte discarded
tmp = (s0 + s1) AND &HFFFF : s0 = s1 : s1 = s2 : s2 = (tmp + s1) AND &HFFFF

' system data (TT24) from the current seeds
gal_x        = s1_hi
gal_y        = s0_hi \ 2
government   = (s1_lo \ 8) AND 7
economy      = s0_hi AND 7 : IF government <= 1 THEN economy = economy OR 2
tech         = (economy XOR 7) + (s1_hi AND 3) + (government + 1) \ 2   ' displayed as tech + 1
population   = tech * 4 + economy + government + 1                       ' tenths of a billion
productivity = ((economy XOR 7) + 3) * (government + 4) * population * 8 ' M Cr
radius_km    = ((s2_hi AND 15) + 11) * 256 + s1_hi

' name (cpl): 3 or 4 digraphs, on a COPY of the seeds
n = 3 : IF s0_lo AND 64 THEN n = 4
FOR k = 1 TO n : i = s2_hi AND 31 : IF i <> 0 THEN name$ = name$ + digraph$(i) : twist : NEXT

Digraph tokens 128 to 159, index 0 prints nothing and index 15 ("A?") prints just "A":

Governments 0 to 7: Anarchy, Feudal, Multi-government, Dictatorship, Communist, Confederacy, Democracy, Corporate State. Economy 0 to 7: bit 2 clear is Industrial, set is Agricultural; 0 and 5 Rich, 1 and 6 Average, 2 and 7 Poor, 3 and 4 Mainly. Check value: Tibedied is Feudal, Poor Industrial, tech level 9 (stored 8), population 3.6 billion, productivity 11520 M Cr, radius 4610 km. Galactic hyperspace rotates each of the six seed bytes left by one bit, independently, and clears the legal record.

B2 · Market (bit-exact)

One random byte QQ26 is drawn on arrival in a system and saved with the commander; prices do not change until the next arrival. Economy is 0 to 7 as above.

price (0.1 Cr) = ((base + (QQ26 AND mask) + economy * factor) AND 255) * 4   ' 8-bit wrap is intentional
quantity       = base_qty + (QQ26 AND mask) - economy * factor
IF quantity < 0 THEN quantity = 0 ELSE quantity = quantity AND 63

Check: at Lave (economy 5) food is 3.6 to 4.0 Cr and computers 89.6 to 90.8 Cr with none available.

B3 · Ship data block and scale

Each slot is 36 bytes (INWK). Positions are 24-bit sign-magnitude, ±8388607, relative to the player, z into the screen. Orientation is three vectors (nosev forward, roofv up, sidev right) of 16-bit sign-magnitude components with unit length 96 (&6000); nearly every calculation uses only the high bytes (±96). A fresh ship has sidev (96,0,0), roofv (0,96,0), nosev (0,0,-96), nose toward the viewer.

Scale: projection is 256 * value / z on a 256 x 192 view centred (128, 96), so 320 pixels wide means a 320-pixel focal length. The planet has radius 24576 (96 0) and is placed 65536 ahead on arrival, filling the view exactly; the sun is the same size, 1 to 7 planet-distances further. Ships are removed beyond 57344 on any axis (FAROF). The in-system jump moves 65536. Vertex coordinates in the blueprints are in the same units as positions (a Cobra is 256 units across), so the meshes go into Draw3D unscaled and WRITE takes the raw position. The blueprint visibility byte is compared with the distance reduced to 0..31 (LL9 part 2, which looks like the largest high byte divided by 8, so units of 2048: verify); Cobra 50 is never reached inside the bubble, Sidewinder 20 becomes a dot beyond about 40000, canister 12 beyond about 24000.

B4 · Player controls and the feel

Roll JSTX and pitch JSTY are 1..255 centred on 128. A held key moves roll by 7 and pitch by 14 per frame (saturating; pushing the other way from beyond centre first snaps to 128). With damping on, the value moves 1 toward 128 per call, called twice per frame for roll and once for pitch. Then:

d = JSTX - 128 : ALP1 = ABS(d) \ 4 : IF ALP1 < 8 THEN ALP1 = ALP1 \ 2       ' 0..31, sign in ALP2
e = ABS(JSTY - 128) + 4 : BET1 = e \ 16 : IF BET1 < 3 THEN BET1 = BET1 \ 2   ' 0..8,  sign in BET2
alpha = ALP1 / 256 : beta = BET1 / 256                                       ' radians per frame

Full roll builds in about 18 frames and decays at 2 per frame; full pitch builds in 9 and decays at 1. Speed DELTA is 0..40. These per-frame constants are what the frame-time scaling in the architecture section must preserve.

On the PC3 keep the BBC letters (they are all plain ASCII in KEYDOWN) and put the views and screens on F1 to F10. Arrow keys can double S/X/</>.

B5 · Moving a ship (MVEIT), per slot per frame, in this order

1. If (MCNT XOR slot) AND 15 = 0: TIDY the orientation (renormalise nosev, make roofv perpendicular, sidev = cross product). Each ship every 16 frames.
2. If AI on: missiles run TACTICS every frame, other ships when (MCNT XOR slot) AND 7 = 0.
3. Move forward: pos += nosev_hi * speed / 64 per axis (unit 96, so 1.5 x speed units).
4. speed += acceleration, clamp 1..max, zero the acceleration.
5. Rotate the position by the player's alpha and beta (below), then z -= DELTA.
6. Rotate nosev, roofv, sidev by alpha and beta (small-angle, roll then pitch, using updated intermediates).
7. Apply the ship's own pitch counter to (roofv, nosev) and roll counter to (roofv, sidev): X = X*(1 - 1/512) ± Y/16 : Y = Y*(1 - 1/512) ∓ X/16, about 3.6° per frame; decrement the counter unless it is 127.

Universe rotation by the player (MVEIT part 5), high bytes only:

k = y - alpha * x
z = z + beta * k
y = k - beta * z        ' uses the new z
x = x + alpha * y       ' uses the new y

With quaternions: build r from the roll angle about Z and the pitch angle about X, invert it, and apply Q_ROTATE to positions and Q_MULT to orientations. The shear the original picks up from its Minsky rotation is what TIDY corrects; a normalised quaternion has none, so the feel is the same without the drift.

View flipping (PLUT), applied to positions and all three vectors before drawing: rear negates x and z; left swaps x and z then negates the new z; right swaps x and z then negates the new x.

B6 · Tactics (TACTICS), when a slot gets its turn

1. Missiles: any ECM active destroys them. Target reached when all three high bytes are 0 (within 256 units): 250 damage to the player if very close, else 80; a target with ECM has a 6% chance (rnd < 16) to fire it. A missile reaching the station is simply destroyed.
2. Escape pods head for the planet. A hostile station spawns a Viper. A Thargon without its mothership drifts. Pirates inside the safe zone do not attack. energy += 1.
3. CNT = nosev · unit vector to the player.
4. 2.5% chance (rnd ≥ 250) of a long roll (counter = rnd OR 104). If energy > max/2 go to lasers; if > max/4 go to missiles; else 10% chance (rnd ≥ 230) of bailing out in an escape pod.
5. Missiles: m = missiles held; fire if m > 0, no ECM active and (rnd AND 31) < m. A Thargoid launches a Thargon instead. "INCOMING MISSILE".
6. Lasers: only if every position high byte is under 32. CNT as sign-magnitude: below 160 cannot shoot; 160 to 162 fires and misses (flash and sound); 163 or more hits for laser_power \ 2 damage (blueprint byte 19 shifted right once) and the attacker's acceleration is decremented.
7. Steering: XX15 = unit vector to the target. If very close (z_hi < 3 and x_hi, y_hi under 2) head away; else head toward with probability (rnd OR 128) < AI_byte. Pitch counter = 3 with sign from roofv · XX15; roll counter = 5 (only if current roll < 16) with sign from sidev · XX15 XOR the pitch sign. CNT ≥ 22 means accelerate by 3; |CNT| ≥ 18 means decelerate by 1 (missiles 2).

AI byte at spawn: traders rnd \ 2 with AI off (they never fight in the cassette version); pirates and bounty hunters rnd OR 192 (AI on, aggression 32-63) with ECM if a second random byte is 245 or more; Thargoids, Thargons, missiles and escape pods 63 with AI on; cops 32-63; station %00000001; asteroids and canisters 0.

B7 · Main-loop schedule (MCNT counts down every iteration)

MCNT is set to 0 on launch, buying fuel and hyperspace, 1 after an in-system jump, 255 on death.

B8 · Station, safe zone and docking

The station is placed at planet centre plus 2 x nosev(planet) x radius, so at altitude one radius, when MCNT AND 31 = 0, no station exists and the player is within 49152 (192 0) of that point on every axis. It spawns pointing at the planet with roll counter 255 (permanent 3.6° per frame) and AI byte %00000001. Inside the safe zone nothing hostile spawns, pirates do not attack, and the compass points at the station.

Docking checks in order: station not hostile; station nose within 26° of pointing at us (its nosev_z ≥ 86 of 96); station in front; unit vector to the station has z ≥ 89 of 96 (a 22° cone); our roll matches the slot (|roofv_x| ≥ 80 of 96, within 34°). A failed approach below speed 5 bounces without damage, otherwise it damages or kills.

B9 · Weapons, damage and rank

Fire when the laser timer is 0, the fire key is held, laser temperature < 242 and the current view has a laser. Damage is power AND 127, 15 for both pulse and beam. Each shot adds 8 to the laser temperature, which cools by 1 per iteration. Beam refires every frame; pulse sets the timer to 10, decremented at 50 Hz, so 5 shots a second. Hit test: the target is in front, not the planet or sun, not exploding, both x_hi and y_hi are 0, and x_lo² + y_lo² < targetable area. On a hit energy drops by the damage; going negative kills (canisters spawn 50% of the time, up to blueprint byte 0). NPC lasers hit the player for laser_power \ 2.

One kill point per kill in the cassette version; "RIGHT ON COMMANDER" each time the low byte wraps. Killing a Viper sets the fugitive bit.

B10 · Drawing the rest of the view

• Scanner: shown when x_hi, y_hi, z_hi are all under 64. Dot x = 123 + x_hi (clip 60..186); stick base y = 220 - z_hi/4 on the ellipse (138 x 36, x 56..192, y 204..239); stick height = -y_hi/2 (clip y 194..246). Scale those to the 320-wide dashboard by 1.25.
• Dashboard: bars 16 px; speed shows DELTA/2 (full from 32); fuel 0-70 shows fuel/4; energy 255 across four banks; shields, cabin and laser temperature, altitude 0-255 direct. Roll indicator 8 ± ALP1/4, pitch 8 ± (BET1 - 1). Compass: unit vector to the station in the safe zone, else the planet; dot at (195 + x/10, 204 - y/10), filled when z ≥ 0 (ahead), hollow when behind.
• Stardust, front view: 18 particles (3 in witchspace), 16-bit x, y, z with the high byte as the pixel offset from centre. Per frame with q = 64 x speed / z_hi: z -= speed*64 : y += |y_hi|*q : x += |x_hi|*q; roll y += alpha*x/256 : x -= alpha*y/256; pitch y_hi -= BET1 (plus a small x term the original's author calls a mystery). Recycle when |x_hi| or |y_hi| ≥ 120 or z_hi < 16: x_hi = rnd OR 8, y_hi = rnd OR 4, z_hi = rnd OR 144, random signs. Side views drift x by 8*256*speed/z_hi; the rear view reverses the perspective.
• Sun: K = 256 x r / z. Fringe CNT = 7 if K ≥ 96, 3 if ≥ 40, 1 if ≥ 16, else 0. For each row at offset V: half-width = sqrt(K² - V²) + (rnd AND CNT), one horizontal line per row.
• Planet (cassette = crater): circle of radius K at the projected centre. Crater centre = planet centre + 0.87 K x (roofv_x, roofv_y)/96 (screen y flipped); crater axes u = (nosev_x, nosev_y) K / 192, v = (sidev_x, sidev_y) K / 192, full ellipse of 64 steps; drawn only when the crater faces us (check the sign of roofv_z during Phase 2). Meridians and equators belong to the disc version.
• Explosions: a counter starts at 18 and grows by 4 per redraw to 128, then the cloud shrinks until it expires; cloud size = counter / distance; particles scatter within that size around each projected vertex, with the vertex count from the blueprint's explosion byte. The original re-seeds its RNG to redraw the same cloud for erasure; a framebuffer makes that unnecessary.

B11 · Random numbers, text and the commander file (bit-exact where it matters)

' DORND: four seed bytes r0..r3; DORND2 clears the carry first, DORND does not
a = r0 : c = a \ 128 : a = ((a * 2) AND 255) OR carry_in : x = a
a = a + r2 + c : c = a \ 256 : a = a AND 255 : r0 = a : r2 = x
a = r1 : x = a
a = a + r3 + c : c = a \ 256 : a = a AND 255 : r1 = a : r3 = x
' result: a (random byte); carry c survives to the next call

Text tokens (TT27): 0-13 control codes (cash, galaxy number, current and selected system, commander name, fuel/cash line, sentence case, beep, all caps, tab to column 21, newlines), 14-31 recursive tokens 128-145, 32-95 ASCII, 96-127 recursive, 128-159 digraphs, 160-255 recursive tokens 0-95. Stored text is XORed with 35. The Python tool expands every fixed token to a plain string so only names, numbers and case handling remain at runtime.

Commander file: 76 data bytes. 0 mission flags; 1-2 chart position (20, 173 = Lave); 3-8 galaxy seeds; 9-12 cash in 0.1 Cr (1000.0 Cr = 10000; the source table shows the bytes as E8 03 00 00, so confirm the byte order against a real save); 13 fuel 70; 15 galaxy number; 16-19 lasers front/rear/left/right (15, 0, 0, 0); 22 hold size 22; 23-39 cargo x 17; 40-69 equipment flags, missiles, legal status, market availability x 17; 70 QQ26; 71-72 kills; 73 = 128; 74 CHK2 = &AA; 75 CHK = &03. Checksum: a = 73 : c = 0 : FOR x = 73 TO 1 STEP -1 : a = a + b(x-1) + c : c = a \ 256 : a = (a AND 255) XOR b(x) : NEXT gives CHK, and CHK2 = CHK XOR &A9. Our port only needs this if it wants to import real BBC saves; a plain text file is otherwise fine.

Sources

• Annotated source and deep dives: elite.bbcelite.com; cassette indexes at /cassette/indexes/a-z.html.
• Buildable source: markmoxon/cassette-elite-beebasm, 1-source-files/main-sources/elite-source.asm (ship blueprints, text tokens, tables) and elite-loader.asm. The same file is served raw from the elite-source-code-bbc-micro-cassette repository, which is what the converter should fetch. Per-ship annotated pages: /cassette/main/variable/ship_<name>.html; the blueprint table is xx21.html.
• Key deep dives: ship blueprints, drawing ships, back-face culling, the local bubble of universe, program flow of the main game loop, pitching and rolling, orientation vectors, galaxy and system seeds, generating system names, market item prices, the 3D scanner, docking checks, stardust, drawing the sun, drawing meridians and equators, drawing explosion clouds, scheduling tasks with the main loop counter, a sense of scale.
• Firmware: graphics/Draw3D.c, graphics/Draw.h, configuration.h (MAX3D, heap and pool sizes), core/MATHS.c (quaternion and vector commands), graphics/FrameBuffer.c (COPY ... ,B), misc/External.c (gamepad).
• Existing PicoMite material: Bas/3ddemo.bas (12 Elite meshes on the engine), Bas/chuckie.bas and Bas/chuckie_tools/ (port and build pattern), PDF/3D_Graphics_User_Manual.pdf, PDF/Game_Development_Guide.pdf.