Raw unit: 1 elmo = 163840 (851968 ÷ 163840 = 5.2 exactly — 3DO coordinates are integral elmo·163840, so every offset divides cleanly).

0 · 38 RockUnit(x, z) — the firing rock

Engine hook: the game tilts the chassis with the recoil offsets it passes in. It is not part of any animation loop (engine-driven), but the bytecode is real:

    2 push-const 9100          // = 49.99°/s (turn speed)
    4 push-arg 0
    6 turn base x-axis speed=c9100 target=a0
    9 push-const 9100
   11 push-arg 1
   13 turn base z-axis speed=c9100 target=a1
   16 wait-for-turn base z-axis
   19 wait-for-turn base x-axis
   22 push-const 3640          // 20°/s — the settle is slower than the jolt
   24 push-const 0
   26 turn base z-axis speed=c3640 target=c0
   29 push-const 3640
   31 push-const 0
   33 turn base x-axis speed=c3640 target=c0
   36 push-const 0
   38 return c0
   39…75 // COBBLER version string — dead bytes, never executed

// BOS reconstruction
RockUnit(x, z)
{
    turn base to x-axis x speed 9100;
    turn base to z-axis z speed 9100;
    wait-for-turn base z-axis;
    wait-for-turn base x-axis;
    turn base to z-axis 0 speed 3640;
    turn base to x-axis 0 speed 3640;
    return 0;
}

Note the push order: turn pops target first, speed second — the pushes appear in the bytecode as speed then target, because the compiler emits operands so the last push is on top. Getting this backwards aims every unit at its own speed value.

76 · 114 HitByWeapon(x, z) — same shape, twice as fast

   78 push-const 19110  // 105°/s — a hit jolt is snappier than a shot rock
   80 push-arg 1
   82 turn base z-axis speed=c19110 target=a1
   … // (same structure as RockUnit: x, waits, slower settle at 5460 = 30°/s)
  112 push-const 0
  114 return c0

HitByWeapon(x, z)
{
    turn base to z-axis z speed 19110;
    turn base to x-axis x speed 19110;
    wait-for-turn base z-axis;
    wait-for-turn base x-axis;
    turn base to z-axis 0 speed 5460;
    turn base to x-axis 0 speed 5460;
    return 0;
}

115 · 123 Create() — the hide list owns visibility

  115 hide flare1
  117 push-const 3000
  119 store-static 0 <- c3000   // s0 = 3000 ms restore delay
  121 push-const 0
  123 return c0

static-var reloadDelay;   // s0
Create()
{
hide flare1;
reloadDelay = 3000;
return 0;
}

Two facts hide here. Visibility is a script concern: the flash piece starts hidden and only FirePrimary shows it — a renderer that ignores the hide list shows a permanently lit muzzle. And the static 3000 is the default restore delay in milliseconds (not degrees — the same number would be 16.5° if it were BAM; only context tells them apart).

124 · 134 SetMaxReloadTime(t) — the engine negotiates the restore delay

  125 push-arg 0
  127 push-const 2
  129 mul a0 c2
  130 store-static 0 <- ?      // s0 = t * 2
  132 push-const 0
  134 return c0

SetMaxReloadTime(t)
{
    reloadDelay = t * 2;
    return 0;
}

The engine calls this with the weapon's reload time; AMPH stores 2× it — the documented "restore delay = 2 × the longest reload" pattern. With Weapon1=CORE_CANLASER (950 ms) the in-game restore fires 1900 ms after the last aim; the compiled default from Create (3000 ms) applies before the engine ever calls this.

135 · 154 RestoreAfterDelay() — the gun's only way home

  135 push-static 0
  137 sleep s0                 // the engine pacing, in ms
  138 push-const 6370
  140 push-const 0
  142 turn turret y-axis speed=c6370 target=c0
  145 push-const 2730
  147 push-const 0
  149 turn barrel x-axis speed=c2730 target=c0
  152 push-const 0
  154 return c0

RestoreAfterDelay()
{
    sleep reloadDelay;
    turn turret to y-axis 0 speed 6370;
    turn barrel to x-axis 0 speed 2730;
    return 0;
}

This is why AimPrimary can simply return 1: the gun re-centers itself through this thread, and every aim call re-arms it (start-script at the end of Aim). Units whose restore parks pieces at odd angles (fixed reload latches) have no other home path — dropping the restore from a reconstruction freezes them mid-aim forever.

155 · 191 AimPrimary(heading, pitch) — signals, inverted pitch, threads

  157 push-const 2
  159 signal c2                 // kill any earlier aim still running
  160 push-const 2
  162 set-signal-mask c2        // …and accept that kill for ourselves
  163 push-const 6370
  165 push-arg 0
  167 turn turret y-axis speed=c6370 target=a0
  170 push-const 2730
  172 push-const 0
  174 push-arg 1
  176 sub c0 a1                 // (0 - pitch) — THE INVERSION
  177 turn barrel x-axis speed=? target=c2730
  180 wait-for-turn turret y-axis
  183 wait-for-turn barrel x-axis
  186 start-script script#4()   // = RestoreAfterDelay
  189 push-const 1
  191 return c1                 // 1 = "aim in progress, call me again"

AimPrimary(heading, pitch)
{
    signal 2;
    set-signal-mask 2;
    turn turret to y-axis heading speed 6370;
    turn barrel to x-axis (0 - pitch) speed 2730;  // pitch is inverted!
    wait-for-turn turret y-axis;
    wait-for-turn barrel x-axis;
    start-script RestoreAfterDelay();
    return 1;
}

192 · 218 FirePrimary() — flash window and recoil

  192 show flare1                // flash ON
  194 push-const 81920000      // 500 elmo/s — effectively instant
  196 push-const -327680      // -2 elmo — the recoil distance
  198 move barrel z-axis speed=c81920000 target=c-327680
  201 push-const 150
  203 sleep c150                // the flash window: 150 ms
  204 hide flare1               // flash OFF
  206 wait-for-move barrel z-axis
  209 push-const 491520       // 3 elmo/s — the return is slow on purpose
  211 push-const 0
  213 move barrel z-axis speed=c491520 target=c0
  216 push-const 0
  218 return c0

FirePrimary()
{
    show flare1;
    move barrel to z-axis -327680 speed 81920000;  // snap back 2 elmo
    sleep 150;
    hide flare1;
    wait-for-move barrel z-axis;
    move barrel to z-axis 0 speed 491520;          // 666 ms return
    return 0;
}

The flash is exactly 150 ms wide and the recoil asymmetry is by design: kick back at 500 elmo/s (~4 ms, invisible), return at 3 elmo/s (667 ms, the visible settle). The muzzle piece z-axis is the bore direction — negative z is away from the turret (see the piece table), so negative = deeper into the tank = recoil.

219 · 242 The three out-parameter scripts — where the muzzle lives

  220 push-const 1
  222 store-arg 0 <- c1       // QueryPrimary: piece 1 = flare1
  224 push-const 0
  226 return c0
  228 push-const 2
  230 store-arg 0 <- c2       // AimFromPrimary: piece 2 = turret
  232 push-const 0
  234 return c0
  236 push-const 0
  238 store-arg 0 <- c0       // SweetSpot: piece 0 = base
  240 push-const 0
  242 return c0

QueryPrimary(piece)   { piece = 1; return 0; }  // flare1 — the MUZZLE
AimFromPrimary(piece) { piece = 2; return 0; }  // turret  — aim origin
SweetSpot(piece)      { piece = 0; return 0; }  // base    — weak point