Game

Space Invaders

Taito's 1978 arcade fixed shooter, read through Computer Archeology's disassembly of Midway's release.

stubAlso: Space Invaders MUpdated 2026-10-21
On this page
  1. Related
  2. Mechanics
  3. References
  4. Sources

The atlas reads Space Invaders through Christopher Cantrell’s Computer Archeology disassembly of the 8080 code, which disassembles MAME’s invaders set, Midway’s release1. Labels and comments cited here are his.

The aliens march one at a time. Each frame moves one live alien, and the rack takes a step only after every live alien has moved, so the step rate rises as the rack thins1. The rack steps 2 px per step, 3 px rightward for the last alien2,2.

See also

Mentioned in

Mechanics

MechanicKindHow
Remaining-enemy speed-upDraw-boundone alien moves per frame, so a step of the rack takes one frame per live alien
Enemy formationMarching rack55 aliens drawn from one reference alien move as a single block
Difficulty rampStart positioneach new rack starts lower, from an 8-entry table
Extra lifeOnceone ship at 1,500 points, or 1,000 by DIP switch
High scoreSingleone four-digit high score, updated when a player's game ends
Destructible terrainErodesthe shields are screen pixels; a shot's explosion pattern is erased from them, and aliens drawn over them overwrite them
Every claim about this game, by concept (12)
Destructible terrainThe shields are pixels in the 1-bit screen bitmap, not objects. Each player has a RAM buffer of four copies of the 44-byte ShieldImage, 22 rows of 2 bytes, a 22 × 16 px shape of 294 lit pixels (computed); RestoreShields ORs the buffer onto the screen, the four shields with 23 rows between them (45 from start to start), and in a two-player game RememberShields copies them from the screen back into the player's buffer, so each player keeps their own damage. The buffers are redrawn from the image at the start of a game and with each new rack.Code
Nothing tests for shields as such. Every shot is drawn with DrawSprCollision, which ANDs each byte of the shifted sprite with the screen before ORing it in and sets the collision flag if any pixel was already lit, so a shot hits a shield when its newly drawn sprite overlaps a lit shield pixel. The player's shot is 1 px wide and 4 px long and moves 4 px a step, so it is tested against every pixel row on its path (computed). A player's shot that collides below the rack takes status 3, the code for a hit on something other than an alien.Code
A player's shot that hits a shield erases itself, then ORs the 8 × 8 px ShotExploding pattern onto the screen around the point of impact; after the blow-up timer counts down from 16, EndOfBlowup erases that pattern with an inverted AND. The erase clears every pixel under the pattern's 38 set bits (computed), shield pixels included, and the first erase had already cleared the shield pixels under the shot itself, so the hole is the explosion's shape plus the shot's last 4 px.Code
An alien shot ends when its newly drawn sprite collides with any lit pixel, or when it falls below the playfield; a collision at the player's height kills the player instead. Its blow-up timer starts at 4: on the first tick ShotBlowingUp erases the shot and draws the 6 × 8 px AShotExplo pattern, and on the tick that reaches 0 it erases that pattern with an inverted AND, so a shield loses the pattern's 26 pixels (computed) plus those under the shot itself.Code
Aliens that reach the shields erase them. DrawSprite, which draws each alien, stores the shifted sprite bytes over the screen instead of ORing them in, both bytes of each of its 16 rows, so wherever an alien is drawn the shield pixels in those bytes are replaced by the alien's image and its blank pixels. The disassembly's comment on CodeBug1 describes a lone alien that "enters the players shields on the lower left where it begins to eat them".Code
Difficulty rampEach new rack starts lower on the screen. The first rack's bottom row starts at Y $78. When a rack is cleared, the count of racks beaten (taken mod 8, plus 1) picks the next start from an 8-entry table, $60, $50, $48, $48, $48, $40, $40, $40, so the 10th rack starts where the 2nd did.Code
Extra lifeSpace Invaders awards one extra ship per player when the upper two digits of the score reach 15, or 10 with DIP switch bit 3 set: at 1,500 or 1,000 points. It then clears the player's award flag, so no second ship follows.Code
High scoreSpace Invaders keeps one high score, four BCD digits at $20F4–$20F5. When a player's game ends, it compares that player's score with it, upper digits first, and copies the score over it if the score is higher.Code
Computer Archeology credits Mikael Agren with patching the original Space Invaders ROMs to add a high-score table.Code notes
Remaining-enemy speed-upSpace Invaders moves its rack of aliens one alien per frame. The interrupt at scanline 96 calls CursorNextAlien, which skips dead aliens to the next live one and waits until the end-of-screen interrupt's DrawAlien has drawn it. Only when the cursor passes the last of the 55 slots does MoveRefAlien step the reference alien, from which every other alien is drawn. A step of the rack therefore takes one 60 Hz frame per live alien: 55 frames at the start, 1 for the last alien. The listing reads MAME's invaders set, Midway's release.Code
When the rack bumps an edge, RackBump reverses it and drops it 8 px: it sets the next step's drop from $200E, which the game's RAM copy fills with $F8 (-8), and MoveRefAlien clears the drop after one step. Its step to the right is 2 px, or 3 px when one alien is left; its step to the left is always 2 px.Code
Each pass of the game loop, SpeedShots checks the number of aliens left; below 9 it sets the alien shots' step ($207E, added to a shot's Y each move) to $FB, -5 px, in place of the $FC (-4 px) that the game's RAM copy puts there, so the aliens' shots fall faster.Code

References

  1. ^ abSpace Invaders moves its rack of aliens one alien per frame. The interrupt at scanline 96 calls CursorNextAlien, which skips dead aliens to the next live one and waits until the end-of-screen interrupt's DrawAlien has drawn it. Only when the cursor passes the last of the 55 slots does MoveRefAlien step the reference alien, from which every other alien is drawn. A step of the rack therefore takes one 60 Hz frame per live alien: 55 frames at the start, 1 for the last alien. The listing reads MAME's invaders set, Midway's release.CodeComputer Archeology, Space Invaders
    How we know
    7>>> binary 0000:roms/invaders.h + roms/invaders.g + roms/invaders.f.diag + roms/invaders.e
    content/Arcade/SpaceInvaders/Code.md line 7 at 1adc2a7 · upstream ↗
    28If I understand this right then the system gets RST 8 when the beam is *near* the middle of the screen and RST 10
    content/Arcade/SpaceInvaders/Hardware.md lines 28–33 at 1adc2a7 · upstream ↗
    120; Main game-play timing loop
⋮
1240078: CD 00 01        CALL    $0100               ; {code.DrawAlien} Draw the current alien (or exploding alien)
    content/Arcade/SpaceInvaders/Code.md lines 120–124 at 1adc2a7 · upstream ↗
    138; Continues here at scanline 96
⋮
15400AB: CD 41 01        CALL    $0141               ; {code.CursorNextAlien} Advance cursor to next alien (move the alien if it is last one)
    content/Arcade/SpaceInvaders/Code.md lines 138–155 at 1adc2a7 · upstream ↗
    248CursorNextAlien:
⋮
2600146: 3A 00 20        LD      A,($2000)           ; {ram.waitOnDraw} Still waiting on ...
2610149: A7              AND     A                   ; ... this alien to be drawn?
262014A: C0              RET     NZ                  ; Yes ... leave cursor in place
⋮
2670154: 3C              INC     A                   ; Have we drawn all aliens ...
2680155: FE 37           CP      $37                 ; ... at last position?
2690157: CC A1 01        CALL    Z,$01A1             ; {code.MoveRefAlien} Yes ... move the bottom/right alien and reset index to 0
270015A: 6F              LD      L,A                 ; HL now points to alien flag
271015B: 46              LD      B,(HL)              ; Is alien ...
272015C: 05              DEC     B                   ; ... alive?
273015D: C2 54 01        JP      NZ,$0154            ; {} No ... skip to next alien
    content/Arcade/SpaceInvaders/Code.md lines 248–273 at 1adc2a7 · upstream ↗
    319MoveRefAlien:
320; The "reference alien" is the bottom left. All other aliens are drawn relative to this
321; reference. This routine moves the reference alien (the delta is set elsewhere) and toggles
⋮
32601A5: 21 06 20        LD      HL,$2006            ; Set current alien ...
32701A8: 36 00           LD      (HL),$00            ; ... index to 0
⋮
33101AE: CD D9 01        CALL    $01D9               ; {code.AddDelta} Move alien
    content/Arcade/SpaceInvaders/Code.md lines 319–331 at 1adc2a7 · upstream ↗
    3910; The game starts with 55 aliens. The aliens are move/drawn one per interrupt which means it
    content/Arcade/SpaceInvaders/Code.md lines 3909–3911 at 1adc2a7 · upstream ↗

    Checked against the evidence by its author, an AI model, 2026-10-25.

    Checked by a second AI model, 2026-10-21.

    Checked by a second AI model, 2026-10-25.

    In the claim ledger

  2. ^ abWhen the rack bumps an edge, RackBump reverses it and drops it 8 px: it sets the next step's drop from $200E, which the game's RAM copy fills with $F8 (-8), and MoveRefAlien clears the drop after one step. Its step to the right is 2 px, or 3 px when one alien is left; its step to the left is always 2 px.CodeComputer Archeology, Space Invaders
    How we know
    31631597: 3A 0D 20        LD      A,($200D)           ; {ram.rackDirection} Get rack direction
3164159A: A7              AND     A                   ; Moving right?
3165159B: C2 B7 15        JP      NZ,$15B7            ; {} No ... handle moving left
⋮
317015A5: 06 FE           LD      B,$FE               ; Delta X of -2
317115A7: 3E 01           LD      A,$01               ; Rack now moving right
⋮
317315A9: 32 0D 20        LD      ($200D),A           ; {ram.rackDirection} Set new rack direction
317415AC: 78              LD      A,B                 ; B has delta X
317515AD: 32 08 20        LD      ($2008),A           ; {ram.refAlienDXr} Set new delta X
317615B0: 3A 0E 20        LD      A,($200E)           ; {ram.rackDownDelta} Set delta Y ...
317715B3: 32 07 20        LD      ($2007),A           ; {ram.refAlienDYr} ... to drop rack by 8
⋮
318315BE: CD F1 18        CALL    $18F1               ; {} Get moving-right delta X value of 2 (3 if just one alien left)
318415C1: AF              XOR     A                   ; Rack now moving left
⋮
    content/Arcade/SpaceInvaders/Code.md lines 3163–3185 at 1adc2a7 · upstream ↗
    368418F1: 06 02           LD      B,$02               ; Rack moving right delta X
368518F3: 3A 82 20        LD      A,($2082)           ; {ram.numAliens} Number of aliens on screen
368618F6: 3D              DEC     A                   ; Just one left?
368718F7: C0              RET     NZ                  ; No ... use right delta X of 2
368818F8: 04              INC     B                   ; Just one alien ... move right at 3 instead of 2
    content/Arcade/SpaceInvaders/Code.md lines 3684–3689 at 1adc2a7 · upstream ↗
    39301E4: 06 C0           LD      B,$C0               ; Number of bytes
39401E6: 11 00 1B        LD      DE,$1B00            ; RAM mirror in ROM
39501E9: 21 00 20        LD      HL,$2000            ; Start of RAM
39601EC: C3 32 1A        JP      $1A32               ; {code.BlockCopy} Copy [DE]->[HL] and return
    content/Arcade/SpaceInvaders/Code.md lines 393–396 at 1adc2a7 · upstream ↗
    40721B00: 01 00 00 10 00 00 00 00 02 78 38 78 38 00 F8 00
    content/Arcade/SpaceInvaders/Code.md line 4072 at 1adc2a7 · upstream ↗
    32601A5: 21 06 20        LD      HL,$2006            ; Set current alien ...
⋮
32801AA: 23              INC     HL                  ; Point to DeltaX
32901AB: 4E              LD      C,(HL)              ; Load DX into C
33001AC: 36 00           LD      (HL),$00            ; Set DX to 0
33101AE: CD D9 01        CALL    $01D9               ; {code.AddDelta} Move alien
    content/Arcade/SpaceInvaders/Code.md lines 326–331 at 1adc2a7 · upstream ↗

    Checked against the evidence by its author, an AI model, 2026-10-25.

    Checked by a second AI model, 2026-10-21.

    Checked by a second AI model, 2026-10-25.

    In the claim ledger

Sources

Code