Asteroids (Computer Archeology's annotated disassembly)

Asteroids paces its main loop by its 250 Hz NMI: every fourth NMI increments a counter, and the main loop waits on that counter before each pass, so the loop runs at most 62.5 times a second (computed: 250 / 4). The atlas calls one pass a frame. The listing reads Atari's revision 2 program ROMs. asteroids/frame

About: Asteroids Inertia

Value: 62.5 main-loop passes per second, at most (computed)

The loop also waits for the vector generator to halt (6815), so a pass can take longer than four NMIs; 62.5 is a ceiling.

Cited by: Asteroids

While the ship is in play, a held rotate button turns it 3 of its 256 directions per frame. On every other frame (when the fast timer's low bit is clear), a held thrust button adds twice the cosine of the direction to the horizontal velocity and twice the sine to the vertical, read from a 65-entry sine table for a quarter turn, 0 to 127, which the lookup folds for the other quarters. Velocities carry 8 fraction bits, so one thrust step adds at most 254/256 of a position unit per frame to an axis's speed (computed). asteroids/thrust

About: Asteroids Inertia

{
 "turn": 3,
 "thrustMax": 254
}

The ship's position moves by the velocity's whole part each frame (asteroids/wrap), so a position unit per frame is the velocity's unit.

Cited by: Asteroids, Inertia

On the same every-other frames, when thrust isn't held, each axis of the ship's velocity loses 2/256 of its whole-unit part (and 1/256 more when moving right or up), about 1/128 of itself per step, until it reaches zero. With the thrust off, the ship's speed so halves in about 88 steps, 176 frames, about 2.8 seconds at 62.5 frames a second (computed). asteroids/drag

About: Asteroids Inertia

{
 "fractionPerStep": 0.0078125,
 "halfLifeFrames": 176
}

The decay is proportional to speed, so the ship coasts a long way from top speed and stops quickly from a crawl.

Cited by: Asteroids, Inertia

Thrust holds each axis of the ship's velocity to its own limit: at most 63 255/256 position units per frame right or up, and 63 255/256 left or down (computed from $3F.FF and $C0.01). Because the axes are clamped apart, a diagonal can reach about 1.41 times the top speed along one axis (computed). asteroids/top-speed

About: Asteroids Inertia

Value: 63.996 position units per frame, per axis (computed)

Drag (asteroids/drag) runs only when thrust is off, so the limit applies while thrusting.

Cited by: Asteroids, Inertia

Each frame, Asteroids adds the velocity of every object that isn't exploding (rocks, ship, saucer, and shots) to its position, on a playfield of 32 by 24 units of 256 (8,192 by 6,144 position units, computed). An object that crosses the left or right edge comes back on the other side, except the saucer, which is removed instead; one that crosses the top or bottom comes back at the other edge, the saucer included. asteroids/wrap

About: Asteroids Screen wrap

[
 8192,
 6144
]

A velocity is below 64 units per frame, so a high byte changes by at most 1 per frame and the tests above catch every crossing.

Cited by: Asteroids, Screen wrap

Hyperspace works while the ship is in play (not exploding and not waiting to return): it removes the ship, zeroes the whole parts of its velocity (the fractions in $64 and $65 stay), and sets a 48-frame return timer. The new horizontal position is a random whole unit from 3 to 28. A further random number r from 0 to 31 decides the jump: it fails when r is 24 or more and 2 × (r − 24) + 4 is at least the current rock count, so with 4 or fewer rocks 8 of the 32 values fail, and with 19 or more none do (computed). The vertical position is r below 24 and 2 × (r − 24) + 4 (4 to 18) from 24, held to 3 to 20. When the timer runs out the ship returns, or, if the jump failed, explodes and costs a ship. asteroids/hyperspace

About: Asteroids Hyperspace

{
 "returnFrames": 48,
 "failValuesMax": 8,
 "values": 32
}

The chance per jump equals the share of failing values only if 77B5's low five bits are evenly spread (asteroids/rng).

Cited by: Asteroids, Hyperspace

Each player's saucer reload value starts at 146 when a game starts and drops by 6 each time a saucer appears, as long as the result stays 32 or more. While it is 128 or more, every saucer is the large one. Below 128, a player with 30,000 points or more always gets the small saucer; under 30,000 a random byte decides, giving the small saucer when the byte is more than half the reload value: about 3 in 4 at the first chance (122) and about 15 in 16 at the floor of 32 (computed, for evenly spread bytes). asteroids/saucer-size

About: Asteroids Rank

{
 "reloadStart": 146,
 "step": 6,
 "floor": 32,
 "alwaysLargeFrom": 128,
 "alwaysSmallScore": 30000
}

The score test reads the thousands byte in BCD, so $30 is 30,000. The reload value also sets the time between saucers (6B73, 6F99), which this claim doesn't measure.

Cited by: Asteroids, Rank

Between shots, a live saucer counts down 10 runs of its routine, which runs every fourth frame (40 frames, computed), and the count pauses while the player's ship is waiting to return. The large saucer fires in a random direction, any of 256. The small saucer aims: it takes the ship's position minus its own on each axis, subtracts half the saucer's velocity, turns the pair into a direction with an arctangent routine, and adds a random error of −16 to +15 directions while the player has under 35,000 points, and −7 to +8 from 35,000. asteroids/saucer-aim

About: Asteroids Rank

{
 "shotFrames": 40,
 "errorBelow35000": [
  -16,
  15
 ],
 "errorFrom35000": [
  -7,
  8
 ]
}

Each difference keeps its top bits (two shifts into the high byte), units of 64. Whether a shot leaves also depends on a free saucer-shot slot (6CF2), not read here.

Cited by: Asteroids, Rank

A rock that is hit, by the ship, the saucer, or either's shots, halves its size code (large 4, medium 2, small 1): a large rock leaves two medium rocks, a medium rock two small ones, and a small rock none. Each piece takes its parent's position and velocity, adds a random −16 to +15 to each axis, and holds each axis to a speed of 6 to 31. The first piece's horizontal position and the second's vertical one are changed by XOR with twice the low five bits of that piece's velocity. The hit rock becomes an explosion. A piece needs a free slot of the 27, so a full field gives fewer. During a game, a hit by the ship or its shots scores 20 for a large rock, 50 for a medium one, and 100 for a small one. asteroids/split

About: Asteroids Enemy splitting

{
 "pieces": 2,
 "slots": 27,
 "points": [
  20,
  50,
  100
 ]
}

The parent's slot is freed when its explosion ends (6F82), which also lowers the rock count.

Cited by: Asteroids, Enemy splitting

A new wave starts once no rocks are left and a 127-frame wave timer, set when the last rock goes, has run out. Each wave has two more large rocks than the one before, up to 11; the count starts at 2 when a game starts, so the waves run 4, 6, 8, 10, 11, 11 (computed). asteroids/waves

About: Asteroids Difficulty ramp

[
 4,
 6,
 8,
 10,
 11
]

The two-player start also swaps in the second player's RAM page and runs the same setup there (68C4-68D3); the atlas hasn't traced which wave count player 2 starts from.

Cited by: Asteroids, Difficulty ramp

Asteroids gives a ship each time a player's score passes a multiple of 10,000: the score is two BCD bytes, and when an addition carries into the thousands byte and leaves its low digit 0, the player gains a ship. asteroids/extra-ship

About: Asteroids Extra life

Value: 10000 points per extra ship

The thousands byte holds two BCD digits, so the score rolls over at 100,000 (computed), and the rollover's 00 also gives a ship.

Cited by: Extra life

Asteroids keeps a table of ten high scores, two BCD bytes each, with three initials apiece (computed from the 20-byte and 30-byte tables), and tells a player who makes it "YOUR SCORE IS ONE OF THE TEN BEST". asteroids/high-score

About: Asteroids High score

Value: 10 scores in the table

Cited by: High score

Asteroids' random routine (77B5) shifts a 16-bit register left one bit and sets the new low bit to the old bit 14 exclusive-or the old bit 0, turning an all-zero register into 1; it returns the low byte. asteroids/rng

About: Asteroids Random number generator

A shift register with that feedback; the atlas hasn't worked out its period.