100% found this document useful (3 votes)

4K views

Atari VCS 2600 River Raid Labeled Assembler Source Code

Analyzed, labeled and commented by Thomas Jentzsch (JTZ)

Uploaded by

AlainleGuirec

Available Formats

Download as TXT, PDF, TXT or read online on Scribd

100% found this document useful (3 votes)

4K views

Atari VCS 2600 River Raid Labeled Assembler Source Code

Analyzed, labeled and commented by Thomas Jentzsch (JTZ)

Uploaded by

AlainleGuirec

Available Formats

Download as TXT, PDF, TXT or read online on Scribd

You are on page 1/ 65

; * R I V E R R A I D *

; Copyright 1982 Activision

; Designer: Carol Shaw

; Analyzed, labeled and commented

; by Thomas Jentzsch (JTZ)
; Last Update: 13.08.2001 (v0.9)

; Section generation:
; The river is divided into sections which are generated by random. The random
; number generator can generate 57337 different sections. Each section is
; divided into 16 blocks. The last block is the bridge. For each other block a
; random Id is generated, which defines the shape of the river. The river is
; randomly generated with or without islands.
; Each block is 32 lines high and is divided into two parts. Those parts are
; neccessary for the bridge only, because it is smaller than a whole block.
;
; All objects are also randomly generated. There is one object in each block.
; First the game randomly selects if a fuel tank, an enemy object (ship, plane
; or helicopter) or a house should be generated. Then a starting x-position is
; defined and finally the direction (left/right) of the object is set.
; The ships and helicopters start patroling also randomly.
;
; Kernel:
; The main display is 160 lines tall. Below is the state display (score, fuel,
; lives and copyright).
; The kernel displays five or six of the section blocks. When a block leaves
; the display, it is replaced on the fly by a new generated one.
; It's basically a two line kernel, which is repeated twelve times. After that,
; there is code for eight more lines, where the block is iterated and all new
; parameter are set. (12 * 2 + 8 = 32!)
; The parameters for each block are:
; - a pointer to the current playfield pattern
; - a flag for a bright or dark green playfield
; - two pointers for the current object, the data is displayed interlaced,
; this gives in a single line resolution here
; - a color pointer for the object
; - x-positioning values for the object
; - some flags for the object (size, reflection...)
; All collisons are checked for each displayed block and only the hardware
; collision registers are used for that (no software calculations).

; Misc:
; - There are no score variables, the score is stored and changed directly in
; the display pointers!
; - The are no variables to store the x-positions of the objects, all
; calculations are done directly with the position values.
; (There aren't any BCD calculations in this code!)
; - All variables for the players are swapped, when the players change.
; - The game speeds aren't adjusted for PAL, the PAL game run's about 16% slower.
; (This seems to be true for most PAL conversions.)
; - ...

processor 6502
include vcs.h

;===============================================================================
; A S S E M B L E R - S W I T C H E S
;===============================================================================

FILL_OPT = 1 ; fill optimized bytes with NOPs

SCREENSAVER = 1 ; compile with screensaver code
TRAINER = 0 ; enable training mode
NTSC = 1 ; compile for NTSC

;===============================================================================
; C O N S T A N T S
;===============================================================================

; initial values for the random number generator:

SEED_LO = $14 ; change "to go, where no one has gone before" :)
SEED_HI = $A8

; color constants:
BLACK = $00
GREY = $06
ORANGE = $2A
IF NTSC
YELLOW = $1C
RED = $48
BLUE = $84
CYAN = $B0
GREEN = $D2
ELSE
YELLOW = $2C
RED = $68
BLUE = $B4
CYAN = $70
GREEN = $52
ENDIF
DARK_RED = RED - $6
LIGHT_GREEN = GREEN + $8
BROWN = YELLOW - $C
LIGHT_GREY = GREY + $6
DARK_BLUE = BLUE - $4

; main game constants:

NUM_BLOCKS = 6 ; max. number of block on screen
SECTION_BLOCKS = 16 ; number of blocks/stage
BLOCK_PARTS = 2 ; each block has two parts
BLOCK_SIZE = 32 ; number of lines/block
NUM_LINES = 160 ; number of lines in main kernel
MAX_LEVEL = 48 ; number of difficulty levels

DIGIT_H = 8 ; height of the score digits

JET_Y = 19 ; fixed y-position for jet
MIN_MISSILE = JET_Y-6 ; starting position of player missile
MAX_MISSILE = NUM_LINES+1
MISSILE_SPEED = 6 ; y-speed of the jet missile
ROAD_HEIGHT = 13 ; number of lines for road
INTRO_SCROLL = 48 ; counter for scrolling into new game

SWITCH_PAGE_ID = 9 ; first pattern id with data on different page

; constants for shape-ids:
ID_EXPLOSION0 = 0 ; used for explosion end
ID_EXPLOSION1 = 1
ID_EXPLOSION2 = 2
ID_EXPLOSION3 = 3
ID_PLANE = 4
ID_HELI0 = 5
ID_HELI1 = 6
ID_SHIP = 7
ID_BRIDGE = 8
ID_HOUSE = 9
ID_FUEL = 10

; flags for blockLst:

PF1_PAGE_FLAG = %00000001 ; pattern for PF1 in page $FC or $FD
PF2_PAGE_FLAG = %00000010 ; pattern for PF1 in page $FC or $FD
PF_COLOR_FLAG = %00000100 ; bright or dark green PF
PATROL_FLAG = %00010000 ; enemy is patroling (change directions)
PF_COLLIDE_FLAG = %00100000 ; enemy collided with playfield
ENEMY_MOVE_FLAG = %01000000 ; enemy is moving
PF_ROAD_FLAG = %10000000 ; display road and bridge

; flags for State1Lst:

DIRECTION_FLAG = %00001000 ; move direction of object
FINE_MASK = %11110000 ; mask bits for HMxy
NUSIZ_MASK = %00000111 ; mask bits for NUSIx

; flags for PF_State:

ISLAND_FLAG = %10000000 ; island displayed in block
CHANGE_FLAG = %01000000 ; begin or end of island (JTZ: this interpretation
might be wrong)

; joystick bits:
MOVE_RIGHT = %00001000
MOVE_LEFT = %00000100
MOVE_DOWN = %00000010
MOVE_UP = %00000001

; values for ENAxy:

DISABLE = %00
ENABLE = %10 ; value for enabling a missile

; values for NUSIZx:

TWO_COPIES = %001
THREE_COPIES = %011
DOUBLE_SIZE = %101
QUAD_SIZE = %111

; mask for SWCHB:

BW_MASK = %1000 ; black and white bit

;===============================================================================
; Z P - V A R I A B L E S
;===============================================================================

gameVariation = $80 ; one or two player game

gameDelay = $81 ; delay before gameVariation changes
frameCnt = $82 ; simple frame counter
random = $83 ; 8 bit random number (used for:
start of ship and helicopter, sound)
joystick = $84 ; saved joystick value (?000rldu)
IF SCREENSAVER
SS_XOR = $85 ; change colors in screensaver mode
(0/$01..$ff)
SS_Mask = $86 ; darker colors in screensaver mode
($ff/$f7)
ENDIF
dXSpeed = $87 ; x-acceleration
prevPF1PatId = $88 ; playfield pattern Id of the
previous block
PF_State = $89 ; io000000
sectionEnd = $8A ; 0 = end of section
blockOffset = $8B ; offset into first displayed block
posYLo = $8C ; low value of blockOffset
bridgeExplode = $8D ; counter for bridge explosion

; the next 36 bytes are used to save all variables for six blocks:
;---------------------------------------
blockLst = $8E ; ..$93 flags for block definition
blockLstEnd = blockLst+NUM_BLOCKS-1
;---------------------------------------
XPos1Lst = $94 ; ..$99 coarse value for x-positioning of
object
XPos1LstEnd = XPos1Lst+NUM_BLOCKS-1
;---------------------------------------
State1Lst = $9A ; ..$9F bit 0..2 = NUSIZ1, bit 3 = REFP1,
4..7 = fine move
State1LstEnd = State1Lst+NUM_BLOCKS-1
;---------------------------------------
Shape1IdLst = $A0 ;.. $A5 ids for object
Shape1IdLstEnd = Shape1IdLst+NUM_BLOCKS-1
;---------------------------------------
PF1Lst = $A6 ; ..$AB low pointer for PF1 data
PF1LstEnd = PF1Lst+NUM_BLOCKS-1
;---------------------------------------
PF2Lst = $AC ; ..$B1 low pointer for PF2 data
PF2LstEnd = PF2Lst+NUM_BLOCKS-1
;---------------------------------------
; end of block variables
missileY = $B2 ; y-position of player missile
playerX = $B3 ; x-position of player jet
speedX = $B4 ; x-speed of player jet
speedY = $B5 ; y-speed of play jet
blockPart = $B6 ; 1/2 (used for bridge)
fuelHi = $B7 ; high value of fuel (displayed)
fuelLo = $B8 ; low value of fuel
sectionBlock = $B9 ; number of block in current section
(16..1)
shapePtr0 = $BA ; ..$BB pointer to the shape for the
player jet
PF1PatId = $BC ; playfield pattern Id for the new
generated block
;---------------------------------------
player1State = $BD ; ..$C1
level = player1State ; difficulty level for current
player (1..48)
randomLoSave = player1State+1; saved random generator values for
begin of level
randomHiSave = player1State+2;
livesPtr = player1State+3; ..$C1
;---------------------------------------
player2State = $C2 ; ..$C5
livesPtr2 = player2State+3; the high pointer is not saved
here, because it's const
;---------------------------------------
gameMode = $C6 ; 0 = running; -1 = game over; 1..48
= scroll into game
shapePtr1a = $C7 ; ..$C8
shapePtr1b = $C9 ; ..$CA
colorPtr = $CB ; ..$CC
scorePtr1 = $CD ; ..$D8 12 bytes for the score display of
current player
PF1Ptr = $D9 ; ..$DA
PF2Ptr = $DB ; ..$DC
;---------------------------------------
scorePtr2 = $DD ; ..$E7 12 bytes for the score display of
other player
; the constant hi-pointers are temporary used:
blockNum = scorePtr2+1 ; current block in kernel
reflect0 = scorePtr2+3 ; flag for GRP0 (player jet)
reflection
hitEnemyIdx = scorePtr2+5 ; index of enemy that was hit by
missile
PFCrashFlag = scorePtr2+7 ; jet crashed into playfield
missileFlag = scorePtr2+9 ; $ff means: missile enabled
;---------------------------------------
collidedEnemy = $E8 ; jet collided with enemy (id)
randomLo = $E9 ; current number generator values
randomHi = $EA
randomLoSave2 = $EB ; saved number generator values for
current player
randomHiSave2 = $EC
temp2 = $ED ;
roadBlock = temp2 ; bit 7 = 1: road in block
PFcolor = $EE ; color of river banks
valleyWidth = PFcolor ; define minimum width of valley in
first levels (6/0)
playerColor = $EF ; YELLOW/BLACK
stateBKColor = $F0 ; GREY (const!)
statePFColor = $F1 ; YELLOW+2 (const!)
temp = $F2 ; main temporary variable
diffPF = temp ; difference between to PF pattern
ids
zero1 = $f3 ; always zero!
player = $F4 ; 0/1
missileX = $F5 ; x-position of player missile
zero2 = $F6 ; always zero!
IF SCREENSAVER
SS_Delay = $F7 ; screensaver delay
ENDIF
sound0Id = $F8 ;
sound0Cnt = $F9
bridgeSound = $FA ; bridge is exploding
missileSound = $FB ; missile fired
temp3 = $FC
blockLine = temp3 ; current displayed line of block in
kernel
maxId = temp3
lineNum = $FD ; counter for kernel lines

;===============================================================================
; M A C R O S
;===============================================================================

MAC FILL_NOP
IF FILL_OPT
REPEAT {1}
NOP
REPEND
ENDIF
ENDM

;===============================================================================
; R O M - C O D E (Part 1)
;===============================================================================

ORG $F000

START:
SEI ; 2
CLD ; 2
LDX #0 ; 2
Reset:
LDA #0 ; 2
.loopClear:
STA $00,X ; 4
TXS ; 2
INX ; 2
BNE .loopClear ; 2
JSR SetScorePtrs ; 6
LDA #>Zero ; 2
LDX #12-1 ; 2
JSR SetScorePtr1 ; 6 set high-pointers to $FB
LDX #colorPtr+1-PF1Lst; 2 #38
JSR GameInit ; 6
LDA random ; 3
BNE MainLoop ; 2
INC random ; 5
STA livesPtr ; 3 = 0!
LDA #<One ; 2
STA scorePtr1+10 ; 3

MainLoop:
LDX #4 ; 2 offset ball
LDA fuelHi ; 3
LSR ; 2
LSR ; 2
LSR ; 2
CLC ; 2
ADC #69 ; 2
JSR SetPosX ; 6 position ball for fuel display

; * prepare everything for the main kernel: *

; set all color registers (and NUSIZ1 = 0)
INX ; 2 x = 5!
.loopSetColors:
LDA ColorTab,X ; 4
IF SCREENSAVER
EOR SS_XOR ; 3
AND SS_Mask ; 3
ELSE
FILL_NOP 4
ENDIF
STA PFcolor,X ; 4
STA NUSIZ1,X ; 4
DEX ; 2
BPL .loopSetColors ; 2
TAY ; 2 y = 0!
LDA scorePtr1+10 ; 3
CMP #<Two ; 2
BEQ .skipTwo ; 2
LDA SWCHB ; 4
LSR ; 2 reset pressed?
BCC .skipTwo ; 2 yes, skip player 2
LDA player ; 3 current player = 2?
BEQ .skipTwo ; 2 no, skip
STY playerColor ; 3 yes, set..
STY COLUP0 ; 3 ..and player 2 color = 0
.skipTwo:

; flicker background when bridge explodes:

LDA bridgeExplode ; 3
BEQ .skipExplosion ; 2
DEC bridgeExplode ; 5
LSR ; 2
BCC .skipExplosion ; 2
LDA #DARK_RED ; 2 flicker background red
IF SCREENSAVER
AND SS_Mask ; 3
ELSE
FILL_NOP 2
ENDIF
STA COLUBK ; 3
.skipExplosion:

INX ; 2 x = 0!
STX temp ; 3
STX NUSIZ0 ; 3
LDY playerX ; 3
LDA reflect0 ; 3
STA REFP0 ; 3
BEQ .noReflect ; 2
INY ; 2 adjust x-pos
.noReflect:
TYA ; 2
JSR SetPosX ; 6 x-position player jet
INX ; 2
STX CTRLPF ; 3 reflect playfield

STX VDELP1 ; 3 enable vertical delay for player 1

; set size, reflect and postion for top enemy object;

LDY XPos1Lst +NUM_BLOCKS-1; 3
LDA State1Lst+NUM_BLOCKS-1; 3
STA NUSIZ1 ; 3
STA REFP1 ; 3
JSR SetPosX2 ; 6 position top enemy object

; x-position missile:
INX ; 2
LDA missileX ; 3
JSR SetPosX ; 6 position missile

JSR DoHMove ; 6
STY PF0 ; 3 enable complete PF0 (y=$ff)

; clear collsion variables:

STY hitEnemyIdx ; 3
STY PFCrashFlag ; 3
STY missileFlag ; 3
STY collidedEnemy ; 3

; set variables for top block:

LDX #NUM_BLOCKS-1 ; 2
JSR SetPFxPtr ; 6
LDA blockOffset ; 3
CMP #3 ; 2 top block just started?
BCS .skipDex ; 2 no, skip
DEX ; 2 yes, start at block 4
.skipDex:
STX blockNum ; 3
LDY Shape1IdLst,X ; 4
LDX shapePtr1aTab,Y ; 4
STX shapePtr1a ; 3
LDX shapePtr1bTab,Y ; 4
STX shapePtr1b ; 3
LDX ColorPtrTab,Y ; 4
STX colorPtr ; 3
STA CXCLR ; 3 clear all collison registers
STA HMCLR ; 3
; calculate offset into first block:
TAX ; 2
SEC ; 2
SBC #1 ; 2
AND #$1F ; 2
STA blockLine ; 3
LSR blockLine ; 5 0..15
CMP #26 ; 2
BCC lowOffset ; 2
SBC #22 ; 2
BNE endOffset ; 2

lowOffset:
CMP #4 ; 2
BCC endOffset ; 2
AND #%01 ; 2
ORA #%10 ; 2
endOffset:

; set entrypoint into kernel:

TAY ; 2
LDA JmpHiTab,Y ; 4
PHA ; 3
LDA JmpLoTab,Y ; 4
PHA ; 3

; prepare graphics for first line of kernel:

TXA ; 2
LSR ; 2
TAY ; 2
LDA (shapePtr1a),Y ; 5
BCC .evenLine ; 2 even blockOffset!
LDA (shapePtr1b),Y ; 5
.evenLine:
CPX #26 ; 2 blockoffset >= 26?
BCS .noShape ; 2 yes, skip enemy shape
CPX #3 ; 2 blockoffset < 3?
BCC .noShape ; 2 yes, skip enemy shape
STA GRP1 ; 3 no, display enemy shape in first
row
LDA #0 ; 2
STA GRP0 ; 3 VDELP1!
.noShape:
LDA (PF1Ptr),Y ; 5
STA PF1 ; 3
LDA (PF2Ptr),Y ; 5
STA PF2 ; 3
LDA (colorPtr),Y ; 5
IF SCREENSAVER
EOR SS_XOR ; 3
AND SS_Mask ; 3
ELSE
FILL_NOP 4
ENDIF
STA COLUP1 ; 3
LDX blockNum ; 3
LDA blockLst,X ; 4
STA roadBlock ; 3 save road-state
AND #PF_COLOR_FLAG ; 2
ORA #GREEN ; 2
IF SCREENSAVER
EOR SS_XOR ; 3
AND SS_Mask ; 3
ELSE
FILL_NOP 4
ENDIF
STA PFcolor ; 3
BIT blockLstEnd ; 3 road in first block?
BPL .noRoad ; 2 no, use green color
CPY #ROAD_HEIGHT ; 2 offset inside road?
BCS .noRoad ; 2 no, use green color
LDA RoadColorTab,Y ; 4 yes, use road colors
IF SCREENSAVER
EOR SS_XOR ; 3
AND SS_Mask ; 3
ELSE
FILL_NOP 4
ENDIF
.noRoad:
STA COLUPF ; 3
LDY #NUM_LINES ; 2
STY lineNum ; 3
.waitTim:
LDA INTIM ; 4
BNE .waitTim ; 2
STA WSYNC ; 3
STA HMOVE ; 3
STA VBLANK ; 3
RTS ; 6 jump into kernel!

; * main display kernel: *

DisplayKernel SUBROUTINE

; first some external code to save cycles in the kernel:

JmpPoint2: ;12
INC lineNum ; 5
LDY blockLine ; 3
BPL enterKernel2 ; 3

.skipJet0:
LDX zero2 ; 3 load 0 with exactly 3 cylces
BEQ .contJet0 ; 3

.noRoad:
LDA PFcolor ; 3
JMP .contPFColor ; 3

.doJet0a:
LDA (shapePtr0),Y ; 5
TAX ; 2
LDA #$00 ; 2
.loopKernel1: ; @19
BEQ .contJet0a ; 2 this jump is taken when comming
from .doJet0a
BNE .contKernel1 ; 3 this jump is taken when comming
from .loopkernel1

IF SCREENSAVER = 0
FILL_NOP 1
ENDIF

JmpPoint3: ;12
JSR Wait12 ;12
.contKernel1:
NOP ; 2 @26
;--------------------------------------
; even line:
; - ...
; - draw player jet
; - load new P1 shape
; *** here starts the main kernel loop: ***
.loopKernel: ;
CPY #JET_Y ; 2 draw player jet?
BCS .skipJet0 ; 2 no, skip
LDA (shapePtr0),Y ; 5 yes, load data..
TAX ; 2 ..into x
.contJet0:
LDY blockLine ; 3
BIT roadBlock ; 3 road displayed?
BPL .noRoad ; 2 no, normal PF color
LDA RoadColorTab,Y ; 4 yes, load road colors
IF SCREENSAVER
EOR SS_XOR ; 3
.contPFColor:
AND SS_Mask ; 3
ELSE
FILL_NOP 2
.contPFColor:
FILL_NOP 1
ENDIF
STA.w temp ; 4
LDA (shapePtr1b),Y ; 5
STA GRP1 ; 3 time doesn't matter (VDELP1!)
LDA (PF1Ptr),Y ; 5
STA PF1 ; 3 @75
;--------------------------------------
; new line starts here!
; odd line:
; - set PF color
; - set P1 color
; - change PF
STA HMOVE ; 3
STX GRP0 ; 3 @2 this also updates GRP1
LDA temp ; 3
STA COLUPF ; 3 @8
LDA (colorPtr),Y ; 5
IF SCREENSAVER
EOR SS_XOR ; 3
AND SS_Mask ; 3
ELSE
FILL_NOP 4
ENDIF
STA COLUP1 ; 3 @22
LDA (PF2Ptr),Y ; 5
STA PF2 ; 3 @30
enterKernel2:
LDA (shapePtr1a),Y ; 5
STA GRP1 ; 3 time doesn't matter (VDELP1!)
LDY lineNum ; 3
DEY ; 2
BEQ .exitKernel2 ; 2
CPY #JET_Y ; 2
BCC .doJet0a ; 2
TYA ; 2
SBC missileY ; 3
AND #$F8 ; 2
BNE .skipEnable0 ; 2
LDA #ENABLE ; 2
.skipEnable0:
LDX #$00 ; 2
.contJet0a:
DEY ; 2
STY lineNum ; 3
STA WSYNC ; 3
;--------------------------------------
; even line:
; - en-/disable missile
; - update P0 and P1 graphics
; - decrease block-line
; - ...
STA HMOVE ; 3
STA ENAM0 ; 3
STX GRP0 ; 3 @6 this also updates GRP1
BEQ .exitKernel2 ; 2
DEC blockLine ; 5
BNE .loopKernel1 ; 2

;*** start of next block (requires eight extra kernel lines): ***
; new block, line 1
; - dec block-number
; - set new road-state
; - get new PF color
; - set new shape-pointer 1a
DEC blockNum ; 5
JmpPoint1:
LDX blockNum ; 3
BMI LF202 ; 2
LDA blockLst,X ; 4 save road-state
STA roadBlock ; 3
AND #PF_COLOR_FLAG ; 2 bright or dark..
ORA #GREEN ; 2 ..green
IF SCREENSAVER
EOR SS_XOR ; 3
AND SS_Mask ; 3
ELSE
FILL_NOP 4
ENDIF
STA PFcolor ; 3
LDA Shape1IdLst,X ; 4 set
TAX ; 2 shape-pointer
LDA shapePtr1aTab,X ; 4 for the
STA shapePtr1a ; 3 next enemy
LF1CE:
LDA #$00 ; 2
STA GRP1 ; 3
CPY #JET_Y ; 2
STA WSYNC ; 3
;--------------------------------------
; new block, line 2
; x = shape-id
; - set jet
; - set PF
; - set new shape-pointer 1b
; - set new color-pointer
STA HMOVE ; 3
BCS .skipJet1 ; 2
LDA (shapePtr0),Y ; 5
.skipJet1:
STA GRP0 ; 3
LDY #0 ; 2 display last line of playfield
pattern
LDA (PF1Ptr),Y ; 5
STA PF1 ; 3
LDA (PF2Ptr),Y ; 5
STA PF2 ; 3
LDY lineNum ; 3
DEY ; 2
.exitKernel2:
BEQ .exitKernel1 ; 2
LDA shapePtr1bTab,X ; 4
STA shapePtr1b ; 3
LDA ColorPtrTab,X ; 4
STA colorPtr ; 3
JmpPoint0:
CPY #JET_Y ; 2
BCS .skipJet2 ; 2
LDA (shapePtr0),Y ; 5
TAX ; 2
LDA #DISABLE ; 2
BEQ .contJet2 ; 3

LF202: INX ; 2
BEQ LF1CE ; 2
JmpPoint9:
NOP ; 2
SEC ; 2
BCS .enterKernel9 ; 3

.skipJet2:
TYA ; 2
SBC missileY ; 3
AND #$F8 ; 2
BNE .skipEnable1 ; 2
LDA #ENABLE ; 2
.skipEnable1:
LDX #$00 ; 2
.contJet2:
STA WSYNC ; 3
;--------------------------------------
; new block, line 3
; - en-/disabvle missile
; - set jet
; - set new PF pointers
STA HMOVE ; 3
STA ENAM0 ; 3
STX GRP0 ; 3
DEY ; 2
STY lineNum ; 3
.exitKernel1:
BEQ .exitKernel ; 2
LDX blockNum ; 3
.enterKernel9:
JSR SetPFxPtr ;50
LDA PFcolor ; 3
CPY #JET_Y ; 2
NOP ; 2 @76
;--------------------------------------
; new block, line 4
; - set new PF color
; - set PF
; - load fine movement
STA HMOVE ; 3
STA COLUPF ; 3
BCS .skipJet3 ; 2
LDA (shapePtr0),Y ; 5
STA GRP0 ; 3
.skipJet3:
LDY #SECTION_BLOCKS-1 ; 2
LDA (PF1Ptr),Y ; 5
STA PF1 ; 3
LDA (PF2Ptr),Y ; 5
STA PF2 ; 3
DEC lineNum ; 5
BEQ .exitKernel ; 2
JmpPoint8:
LDA State1Lst,X ; 4 put fine move-value
STA temp ; 3 into temp
LDY lineNum ; 3
CPY #JET_Y ; 2
BCC .skipJet4 ; 2
TYA ; 2
SBC missileY ; 3
AND #$F8 ; 2
BNE .skipEnable2 ; 2
LDA #ENABLE ; 2
.skipEnable2:
LDY #0 ; 2
.contJet4:
STA WSYNC ; 3
;--------------------------------------
; new block, line 5
; - en-/disable missile
; - set jet
; - position new shape
STA HMOVE ; 3
STA ENAM0 ; 3
STY GRP0 ; 3
; position player 1:
LDA XPos1Lst,X ; 4 load coarse move-value
BEQ .posVeryLeft ; 2
TAX ; 2
CPX #7 ; 2
BCS .posRight ; 2
.waitLeft:
DEX ; 2
BNE .waitLeft ; 2
STA RESP1 ; 3
.contLeft:
DEC lineNum ; 5
LDY lineNum ; 3
BNE .contPos ; 2
.exitKernel:
JMP DisplayState ; 3 exit the kernel

.posVeryLeft:
NOP ; 2
NOP ; 2
LDA #$60 ; 2
STA RESP1 ; 3
STA HMP1 ; 3
BNE .contLeft ; 2

.skipJet4:
LDA (shapePtr0),Y ; 5
TAY ; 2
LDA #$00 ; 2
BEQ .contJet4 ; 2

.posRight:
SBC #4 ; 2
TAX ; 2
DEC lineNum ; 5
LDY lineNum ; 3
BEQ .exitKernel ; 2
.waitRight:
DEX ; 2
BPL .waitRight ; 2
STA RESP1 ; 3
JmpPoint7:
.contPos:
STA WSYNC ; 3
;--------------------------------------
; new block, line 6
STA HMOVE ; 3
CPY #JET_Y ; 2
BCS .skipJet5 ; 2
LDA (shapePtr0),Y ; 5
STA GRP0 ; 3
.skipJet5:
LDY #SECTION_BLOCKS-2 ; 2
LDA (PF1Ptr),Y ; 5
STA PF1 ; 3
LDA (PF2Ptr),Y ; 5
STA PF2 ; 3
LDY lineNum ; 3
DEY ; 2
BEQ .exitKernel ; 2
LDX blockNum ; 3
LDA temp ; 3
STA HMP1 ; 3
JmpPoint6:
LDA #[BLOCK_SIZE-8]/2 ; 2
STA blockLine ; 3
TYA ; 2
SEC ; 2
SBC missileY ; 3
AND #$F8 ; 2
BNE .skipEnable3 ; 2
LDA #ENABLE ; 2
.skipEnable3:
CPY #JET_Y ; 2
STA WSYNC ; 3
;--------------------------------------
; new block, line 7
STA HMOVE ; 3
STA ENAM0 ; 3
BCS .skipJet6 ; 2
LDA (shapePtr0),Y ; 5
STA GRP0 ; 3
.skipJet6:
LDA State1Lst,X ; 4
STA NUSIZ1 ; 3
STA REFP1 ; 3
DEY ; 2
STY lineNum ; 3
BEQ DisplayState ; 2
STA HMCLR ; 3

; check collisions:
; (the collsion check between jet or missile and playfield aren't
; really neccessary for each block, but the collison registers
; are cleared after each block)
INX ; 2
BIT CXM0P-$30 ; 3 player missile hit enemy?
BPL .notHit ; 2
STX hitEnemyIdx ; 3 save block number
.notHit:
IF TRAINER
BIT zero1
ELSE
BIT CXP0FB-$30 ; 3 jet hit PF?
ENDIF
BPL .noPFCrash ; 2
STX PFCrashFlag ; 3
.noPFCrash:
IF TRAINER
BIT zero1
ELSE
BIT CXM0FB-$30 ; 3 player missile hit PF?
ENDIF
BPL .notHitPF ; 2
STX missileFlag ; 3
.notHitPF:
IF TRAINER
BIT zero1
ELSE
BIT CXPPMM-$30 ; 3 jet crashed into enemy?
ENDIF
BPL .noCrash ; 2
STX collidedEnemy ; 3 save block number
.noCrash:

.enterKernel5:
;--------------------------------------
; new block, line 8
STA WSYNC ; 3
STA HMOVE ; 3
CPY #JET_Y ; 2
BCS .skipJet7 ; 2
LDA (shapePtr0),Y ; 5
STA GRP0 ; 3
.skipJet7:
LDY #SECTION_BLOCKS-3 ; 2
LDA (PF1Ptr),Y ; 5
STA PF1 ; 3
LDA (PF2Ptr),Y ; 5
STA PF2 ; 3
LDY lineNum ; 3
DEY ; 2
BEQ DisplayState ; 2
BIT CXP1FB-$30 ; 3 enemy hit PF?
BPL .notEnemyPF ; 2 no, skip
LDA blockLst,X ; 4
ORA #PF_COLLIDE_FLAG ; 2 yes, set collision flag
STA blockLst,X ; 4
.notEnemyPF:
STA CXCLR ; 3 clear all collison registers

.enterKernel4:
TYA ; 2
SEC ; 2
SBC missileY ; 3
AND #$F8 ; 2
BNE .skipEnable4 ; 2
LDA #ENABLE ; 2
.skipEnable4:
CPY #JET_Y ; 2
STA WSYNC ; 3
;--------------------------------------
; new block, line 9 (= begin of even line)
STA HMOVE ; 3
STA ENAM0 ; 3
BCS .skipJet8 ; 2
LDA (shapePtr0),Y ; 5
STA GRP0 ; 3
.contJet8:
DEY ; 2
STY lineNum ; 3
BEQ DisplayState ; 2 exit the kernel
JMP .loopKernel ; 3 @26

JmpPoint5:
LDA #[BLOCK_SIZE-8]/2 ; 2
STA blockLine ; 3
BNE .enterKernel5 ; 3

JmpPoint4:
LDA #[BLOCK_SIZE-8]/2 ; 2 12
STA blockLine ; 3
BNE .enterKernel4 ; 3

.skipJet8: ; waste some time

NOP ; 2
NOP ; 2
BCS .contJet8 ; 3
DisplayState SUBROUTINE
; finish display kernel:
STA WSYNC ; 3
STA HMOVE ; 3
LDY #$00 ; 2
STY GRP1 ; 3
STY GRP0 ; 3
LDA zero1 ; 3 waste one extra cylce (but also
wastes a variable!)
STA COLUBK ; 3
STY PF0 ; 3
STY PF1 ; 3
STY PF2 ; 3
STY REFP0 ; 3
STY REFP1 ; 3
STY reflect0 ; 3
; prepare state display:
LDA #$11 ; 2 reflect PF, 2 pixel ball width,
also for HMP0!
STA RESP0 ; 3
STA RESP1 ; 3
STA CTRLPF ; 3
STA HMP0 ; 3
LDA #$20 ; 2
STA HMP1 ; 3
LDA playerColor ; 3
JSR SetColPx ; 6
LDA stateBKColor ; 3
STA COLUBK ; 3
LDA #THREE_COPIES ; 2
STA NUSIZ0 ; 3
STA NUSIZ1 ; 3
LDA statePFColor ; 3
STA COLUPF ; 3
LDY #$07 ; 2
STY VDELP0 ; 3
STY lineNum ; 3
STA HMCLR ; 3
; display score:
.loopScore:
LDA (scorePtr1+8),Y ; 5
TAX ; 2
LDA (scorePtr1+10),Y ; 5
STA WSYNC ; 3
STA HMOVE ; 3
STY temp2 ; 3
STA temp ; 3
LDA (scorePtr1),Y ; 5
STA GRP0 ; 3
LDA (scorePtr1+2),Y ; 5
STA GRP1 ; 3
LDA (scorePtr1+4),Y ; 5
STA GRP0 ; 3
LDA (scorePtr1+6),Y ; 5
LDY temp ; 3
STA GRP1 ; 3
STX GRP0 ; 3
STY GRP1 ; 3
STA GRP0 ; 3
LDY temp2 ; 3
DEY ; 2
BPL .loopScore ; 2

LDA zero1 ; 3 a = 0 (BLACK)

JSR FinishDigits ; 6 y = 14
; display fuel:
.loopFuel:
STY temp2 ; 3 line counter
LDA FuelTab4,Y ; 4
LDX FuelTab3,Y ; 4
STA WSYNC ; 3
STA HMOVE ; 3
STA temp ; 3
NOP ; 2
LDA #$00 ; 2
STA GRP0 ; 3
LDA ENABLTab,Y ; 4
STA ENABL ; 3
LDA FuelTab0,Y ; 4
STA GRP1 ; 3
LDA FuelTab1,Y ; 4
STA GRP0 ; 3
LDA FuelTab2,Y ; 4
LDY temp ; 3
STA GRP1 ; 3
STX GRP0 ; 3
STY GRP1 ; 3
STA GRP0 ; 3
LDY temp2 ; 3
DEY ; 2
BPL .loopFuel ; 2

LDA playerColor ; 3
JSR FinishDigits ; 6
INY ; 2 y=15
CLC ; 2
LDX gameMode ; 3
INX ; 2
BNE .noGame ; 2
LDA #<Space ; 2
STA livesPtr ; 3

; animate copyright message:

LDA frameCnt ; 3
LSR ; 2
LSR ; 2
LSR ; 2
CMP #20 ; 2
BCS .ok ; 2
CMP #12 ; 2
.noGame:
LDY #7 ; 2
BCC .ok ; 2
SBC #4 ; 2
TAY ; 2
.ok:
STY temp3 ; 3 copyright scroll offset
; display lives and copyright:
.loopCopyright:
LDY temp3 ; 3
LDA Copyright5,Y ; 4
STA temp ; 3
STA WSYNC ; 3
STA HMOVE ; 3
LDX Copyright4,Y ; 4
LDA (livesPtr),Y ; 5
STA GRP0 ; 3
DEC temp3 ; 5
LDA Copyright1,Y ; 4
STA GRP1 ; 3
LDA Copyright2,Y ; 4
STA GRP0 ; 3
LDA Copyright3,Y ; 4
LDY temp ; 3
STA GRP1 ; 3
STX GRP0 ; 3
STY GRP1 ; 3
STA GRP0 ; 3
DEC lineNum ; 5
BPL .loopCopyright ; 2

STA WSYNC ; 3
STA HMOVE ; 3
LDX #$00 ; 2
STX VDELP0 ; 3
STX GRP1 ; 3
STX GRP0 ; 3
LDA blockOffset ; 3
CMP #BLOCK_SIZE-6 ; 2
BCC .skipInx ; 2
INX ; 2
.skipInx:

; check collisions for the last displayed block:

BIT CXM0P-$30 ; 3 player missile hit enemy?
BPL .notHit2 ; 2
STX hitEnemyIdx ; 3 save block number
.notHit2:
IF TRAINER
BIT zero1
ELSE
BIT CXP0FB-$30 ; 3 jet hit PF?
ENDIF
BPL .noPFCrash2 ; 2
STX PFCrashFlag ; 3
.noPFCrash2:
BIT CXM0FB-$30 ; 3 player missile hit PF?
BPL .notHitPF2 ; 2
STX missileFlag ; 3
.notHitPF2:

IF NTSC
LDA #29 ; 2
ELSE
LDA #58 ; 2
ENDIF
LDY #%10000010 ; 2
STA WSYNC ; 3
STA TIM64T ; 4
STY VBLANK ; 3

BIT CXP1FB-$30 ; 3 enemy hit PF?

BPL .notEnemyPF2 ; 2
LDA blockLst,X ; 4
ORA #PF_COLLIDE_FLAG ; 2
STA blockLst,X ; 4
.notEnemyPF2:
IF TRAINER
LDA zero1
ELSE
BIT CXPPMM-$30 ; 3 jet crashed into enemy?
ENDIF
BPL .noCrash2 ; 2
STX collidedEnemy ; 3 save block number
.noCrash2:

; * update framecounter, check for screensaver: *

DEC frameCnt ; 5
BNE .skipSS_Delay ; 2
LDX gameMode ; 3
INX ; 2
BNE .skipInit ; 2
JSR SwapPlayers ; 6
.skipInit:
IF SCREENSAVER
INC SS_Delay ; 5
BNE .skipSS_Delay ; 2
SEC ; 2
ROR SS_Delay ; 5
ELSE
FILL_NOP 4
ENDIF
.skipSS_Delay:
IF SCREENSAVER
LDY #$FF ; 2
LDA SWCHB ; 4
AND #BW_MASK ; 2 black and white?
BNE .colorMode ; 2 no, color mode
LDY #$0F ; 2 yes, mask out high nibble
.colorMode:
TYA ; 2
LDY #$00 ; 2
BIT SS_Delay ; 3
BPL .noScreenSaver ; 2
AND #$F7 ; 2
LDY SS_Delay ; 3
.noScreenSaver:
STY SS_XOR ; 3
ASL SS_XOR ; 5
STA SS_Mask ; 3
ELSE
FILL_NOP 28
ENDIF

; * randomly start movement of enemies: *

LDA random ; 3
ASL ; 2
ASL ; 2
ASL ; 2
EOR random ; 3
ASL ; 2
ROL random ; 5
LDA frameCnt ; 3
AND #$0F ; 2 every 16th frame
BNE .skipStartMove ; 2
LDA random ; 3
AND #$07 ; 2
CMP #5 ; 2 start one of the first five
enemies
BCC .inBound ; 2
SBC #5 ; 2 doubled chances for the first
three enemies
.inBound:
TAX ; 2
LDA blockLst,X ; 4 start
ORA #ENEMY_MOVE_FLAG ; 2 movement
STA blockLst,X ; 4 of enemy
.skipStartMove:

;* animate and move the enemy objects: *

LDX #NUM_BLOCKS-1 ; 2
.loopEnemies:
; animate some enemies:
LDY Shape1IdLst,X ; 4
CPY #ID_SHIP ; 2 don't animate ship, bridge, house
and fuel
BCS .skipAnimate ; 2
LDA #$01 ; 2 every 2nd frame
CPY #ID_PLANE ; 2 fast animate plane (not done) and
helicopter
BCS .fastAnimation ; 2
LDA #$0F ; 2 slow animate explosions (every
16th frame)
.fastAnimation:
AND frameCnt ; 3
BNE .skipAnimate ; 2
LDA AnimateIdTab,Y ; 4
STA Shape1IdLst,X ; 4
TAY ; 2
.skipAnimate:

; check for move and direction change:

LDA gameMode ; 3
BNE .skipMoveEnemy ; 2
LDA level ; 3
LSR ; 2 first level?
BEQ .skipMoveEnemy ; 2 yes, don't move
CPY #ID_PLANE ; 2 move plane in same direction every
frame
BEQ .xMoveEnemy ; 2
BCC .skipMoveEnemy ; 2
CPY #ID_BRIDGE ; 2 don't move bridge, house and fuel
BCS .skipMoveEnemy ; 2
LDA frameCnt ; 3
ROR ; 2
BCS .skipMoveEnemy ; 2 move helicopter and ship every 2nd
frame
LDA blockLst,X ; 4
ASL ; 2 enemy moving?
BPL .skipMoveEnemy ; 2 no, skip move
ASL ; 2 enemy collided with PF?
BPL .noPFCollision ; 2 no, skip
ASL ; 2 patroling enemy?
BMI .xMoveEnemy ; 2 no, skip swap direction
LDA State1Lst,X ; 4 switch
EOR #DIRECTION_FLAG ; 2 enemy move
STA State1Lst,X ; 4 direction
LDA blockLst,X ; 4
ORA #PATROL_FLAG ; 2 (re)enable patrol mode
BNE .endChangeDir ; 2

.noPFCollision:
LDA blockLst,X ; 4
AND #~PATROL_FLAG ; 2 disable patrol mode (only
temporary)
.endChangeDir:
STA blockLst,X ; 4

; move enemy one pixel left or right:

; (no real position variables, the code is working
; directly with the positioning values)
.xMoveEnemy:
LDY XPos1Lst,X ; 4
LDA State1Lst,X ; 4
LSR ; 2
LSR ; 2
LSR ; 2
LSR ; 2
EOR #$07 ; 2
BCS .xMoveLeft ; 2 moving left!
ADC #1 ; 2
CMP #15 ; 2
BCC .skipRightIny ; 2
SBC #15 ; 2
INY ; 2
.skipRightIny:
CPY #10 ; 2
BCC .contMoveX ; 2
CMP #10 ; 2 >= 160?
BCC .contMoveX ; 2 no, continue
LDY #0 ; 2 yes,..
TYA ; 2 ..move shape (plane)..
BEQ .contMoveX ; 2 ..to the very left (0)

.xMoveLeft:
SBC #1 ; 2
BCS .contMoveX2 ; 2
ADC #15 ; 2
DEY ; 2 < 0?
BPL .contMoveX ; 2 no, continue
LDY #10 ; 2 yes, move shape (plane)..
LDA #9 ; 2 ..to the very right (159)
.contMoveX:
STY XPos1Lst,X ; 4 store coarse value here
.contMoveX2:
EOR #$07 ; 2
JSR Mult16 ; 6
EOR State1Lst,X ; 4
AND #FINE_MASK ; 2 #$F0
EOR State1Lst,X ; 4
STA State1Lst,X ; 4 OR fine value into here
.skipMoveEnemy:

; clear PF-collision:
LDA blockLst,X ; 4
AND #~PF_COLLIDE_FLAG ; 2
STA blockLst,X ; 4
DEX ; 2
BMI .exitLoopEnemies ; 2
JMP .loopEnemies ; 3
.exitLoopEnemies:

; * read joystick: *

LDA SWCHA ; 4
LDX player ; 3
BEQ .player1 ; 2
JSR Mult16 ; 6
.player1:
AND #$F0 ; 2 mask out other player joystick
TAX ; 2
LDY #4 ; 2
.loopBits:
ROL ; 2 roll new 4 bits into joystick
ROL joystick ; 5 (old 4 bits got into upper
nibble!)
DEY ; 2
BNE .loopBits ; 2

CPX #$F0 ; 2
BNE .joystickMoved ; 2
LDX player ; 3
LDA INPT4-$30,X ; 4
BMI .noFire ; 2
.joystickMoved:

LDA gameMode ; 3
CMP #INTRO_SCROLL ; 2
BNE .skipRestart ; 2
LDA #64 ; 2 restart new game
STA speedY ; 3
STY gameMode ; 3 y=0!
.skipRestart:
IF SCREENSAVER
STY SS_Delay ; 3 y=0!
ELSE
FILL_NOP 2
ENDIF
.noFire:
LDX gameMode ; 3
BEQ .checkCollisions ; 2 game running
BMI .gameOver ; 2 game is over
CPX #INTRO_SCROLL+1 ; 2 scrolling into new game/life?
BCC .doSoundJmp ; 2 yes, skip decrease
BNE .startGame ; 2 no, finished scrolling, start new
game
; decrease lives:
LDA livesPtr ; 3
BEQ .finishGame ; 2 zero!
SBC #DIGIT_H ; 2
BNE LF5B5 ; 2
LDA #<Space+1 ; 2
LF5B5: CMP #<MaxOut ; 2 score overflow?
BNE LF5BB ; 2
LDA #<Three ; 2 reset lives to 3
LF5BB: STA livesPtr ; 3
.startGame:
DEC gameMode ; 5 start game
BNE .doSoundJmp ; 2

.gameOver:
INX ; 2
BEQ .doSoundJmp ; 2
DEC gameMode ; 5
BMI .doSoundJmp ; 2
STY shapePtr0 ; 3
LDA livesPtr2 ; 3
CMP #<Copyright0 ; 2 other player still alive?
BEQ .skipSwap ; 2 no, skip swap
JSR SwapPlayers ; 6
.skipSwap:
LDA livesPtr ; 3
CMP #<Copyright0 ; 2 current player still alive?
BNE .initPlayer ; 2 yes, continue
.finishGame:
JSR FinishGame ; 6
BNE .doSoundJmp ; 2

.initPlayer:
LDX #shapePtr0+2-PF1Lst;2 #22
JSR GameInit ; 6
TYA ; 2
ORA #PF_ROAD_FLAG ; 2
STA blockLstEnd ; 3
LDA randomLoSave ; 3 load..
STA randomLo ; 3 ..random variables..
LDA randomHiSave ; 3 ..with saved..
STA randomHi ; 3 ..player variables
.doSoundJmp:
JMP DoSound ; 3

.checkCollisions:
LDX collidedEnemy ; 3 collided with enemy?
BMI .endCollisions ; 2 no, skip
LDA Shape1IdLst,X ; 4
CMP #ID_PLANE ; 2 collided with explosion?
BCC .endCollisions ; 2 no, skip
CMP #ID_BRIDGE ; 2 collided with ship, plane or
helicopter?
BCC .noBridge ; 2 yes, do collision
BNE .refuel ; 2 no, collided with fuel!
INC sectionEnd ; 5 no, collided with bridge!
.noBridge:
LDY #$1F ; 2 load some sound values
LDA #1 ; 2 sound id = 1
JSR LooseJet ; 6
LDX collidedEnemy ; 3
LDA #ID_EXPLOSION2 ; 2 start explosion
JMP .contJetExplosion ; 3

.refuel:
LDA fuelHi ; 3
ADC #$01 ; 2
LDX #4 ; 2 sound id = 4
BCC .notFull ; 2
LDA #$FF ; 2
STA fuelLo ; 3
LDX #3 ; 2 sound id = 3
.notFull:
STA fuelHi ; 3
CPX sound0Id ; 3
BEQ .endCollisions ; 2
STX sound0Id ; 3
LDA #$08 ; 2
STA sound0Cnt ; 3

.endCollisions:
LDX PFCrashFlag ; 3 jet crashed?
BMI .skipCrash ; 2 no, skip
.maxedOut:
LDY #$1F ; 2
LDA #1 ; 2 sound id = 1
.looseJet:
JSR LooseJet ; 6
BNE .doSoundJmp ; 2

.skipCrash:

; decrease fuel:
LDA fuelLo ; 3
SEC ; 2
IF TRAINER
SBC #0
ELSE
SBC #$20 ; 2
ENDIF
BCS .skipDecHi ; 2
LDY fuelHi ; 3
BNE .fuelOk ; 2
LDA #2 ; 2 sound id = 2
LDY #$23 ; 2
JMP .looseJet ; 3 out of fuel!
.fuelOk:
DEC fuelHi ; 5
.skipDecHi:
STA fuelLo ; 3

; * move jet left or right: *

LDA joystick ; 3
TAY ; 2
AND #MOVE_LEFT|MOVE_RIGHT; 2
EOR #MOVE_LEFT|MOVE_RIGHT; 2
BNE .leftRight ; 2
STA dXSpeed ; 3 jet is flying straight
STA speedX ; 3
LDX #<JetStraight-1 ; 2
BNE .setPtr0 ; 2

.leftRight:
LDA dXSpeed ; 3 increase the x speed change
CLC ; 2
ADC #8 ; 2
BCS .maxChange ; 2
STA dXSpeed ; 3
.maxChange:
LDX #<JetMove-1 ; 2
TYA ; 2
AND #MOVE_RIGHT ; 2
STA reflect0 ; 3
BEQ .moveRight ; 2
BCS .maxChange2 ; 2
LDA speedX ; 3
SEC ; 2
SBC dXSpeed ; 3
BCS .setXSpeed ; 2
.maxChange2:
DEC playerX ; 5
BNE .setXSpeed ; 2

.moveRight:
BCS .maxChange3 ; 2
LDA speedX ; 3
BIT joystick ; 3 moved right before?
BPL .wasRight ; 2 yes, skip
LDA #-1 ; 2 bo, move the jet very slowly to
the left (JTZ: what's that good for?)
.wasRight:
ADC dXSpeed ; 3
BCC .setXSpeed ; 2
.maxChange3:
INC playerX ; 5
.setXSpeed:
STA speedX ; 3
.setPtr0:
STX shapePtr0 ; 3

; change jet speed:

LDX speedY ; 3
TYA ; 2
LSR ; 2
BCS .noMoveUp ; 2
.incSpeed:
TXA ; 2
ADC #2 ; 2
BCC .changeSpeed ; 2
BCS .skipChange ; 2

.noMoveUp:
LSR ; 2
BCC .noMoveDown ; 2
TXA ; 2
ASL ; 2
BCC .incSpeed ; 2
BEQ .skipChange ; 2

.noMoveDown:
TXA ; 2
CMP #$41 ; 2 minimal speed?
BCC .skipChange ; 2 yes, skip slow down
SBC #2 ; 2
.changeSpeed:
STA speedY ; 3
.skipChange:

LDX hitEnemyIdx ; 3 object hit?

BMI .skipCollisions ; 2 no, skip
LDY Shape1IdLst,X ; 4
CPY #ID_PLANE ; 2 enemy objects?
BCC .skipCollisions ; 2 no, explosions
LDA #ID_EXPLOSION1 ; 2 start explosion animation
.contJetExplosion:
LDY Shape1IdLst,X ; 4
STA Shape1IdLst,X ; 4
LDA #23 ; 2
STA bridgeSound ; 3
CPY #ID_BRIDGE ; 2
BNE .skipBridge ; 2
STA bridgeExplode ; 3 start bridge explosion
LDA #$E0|TWO_COPIES ; 2 set fixed position and size (two
copies close)
STA State1Lst,X ; 4
LDA #4 ; 2 coarse positiong value
STA XPos1Lst,X ; 4
INC sectionEnd ; 5 new section has been started
.skipBridge:

; increase score:
LDX #8 ; 2 add 10s
LDA ScoreTab,Y ; 4
BPL .loopSetPtr1 ; 2
AND #$7F ; 2 add n*100 points
LDX scorePtr1+8 ; 3
CPX #<Space ; 2
BNE .noSpace ; 2
LDX #<Zero ; 2 replace Space..
STX scorePtr1+8 ; 3 ..with Zero
.noSpace:
LDX #6 ; 2 add 100s
.loopSetPtr1:
PHA ; 3
CPX #2 ; 2 life pointer
BNE .notLivePtr ; 2
; check for bonus life:
LDA livesPtr ; 3
CMP #<Nine ; 2
BEQ .maxLives ; 2
BCC .notMax ; 2
LDA #$FF ; 2 CF=1!
.notMax:
ADC #DIGIT_H ; 2
STA livesPtr ; 3
.maxLives:
.notLivePtr:
LDA scorePtr1,X ; 4
SEC ; 2
SBC #<Space ; 2
BNE .noSpace2 ; 2
STA scorePtr1,X ; 4 point to '0'
.noSpace2:
PLA ; 4
CLC ; 2
ADC scorePtr1,X ; 4
CMP #<MaxOut ; 2
BCC .noMaxOut ; 2 exit loop
SBC #<MaxOut ; 2
STA scorePtr1,X ; 4
LDA #DIGIT_H ; 2
DEX ; 2
DEX ; 2
BPL .loopSetPtr1 ; 2

; more than 999990 points, set score to !!!!!!, game over:

LDA #<MaxOut ; 2
LDX #12-2 ; 2
JSR SetScorePtr1 ; 6
LDA #<Copyright0 ; 2
STA livesPtr ; 3
JMP .maxedOut ; 3

.noMaxOut:
STA scorePtr1,X ; 4
.noMissile:
LDX #$B4 ; 2 disable missile
BNE .directMissile ; 2
.skipCollisions:

; * move or fire missiles: *

LDA missileFlag ; 3
BPL .noMissile ; 2
LDA missileY ; 3
CMP #MAX_MISSILE+1 ; 2
BCS .checkFire ; 2
ADC #MISSILE_SPEED ; 2 y-move missile
TAX ; 2
LDA SWCHB ; 4 read difficulty
LDY player ; 3
BNE .player1a ; 2
ASL ; 2
.player1a:
TAY ; 2
BPL .guidedMissile ; 2
BMI .directMissile ; 2

.checkFire:
LDX player ; 3
LDA INPT4-$30,X ; 4
BMI .noMissile ; 2
LDX #$0F ; 2
STX missileSound ; 3
LDX #MIN_MISSILE ; 2
.guidedMissile:
LDA playerX ; 3
CLC ; 2
ADC #$05 ; 2
STA missileX ; 3
.directMissile:
STX missileY ; 3

; * sound routines: *

; TODO: analyze, labels, comments
DoSound:
; start with channel 0:
LDY #$1C ; 2
LDA sound0Cnt ; 3
LDX sound0Id ; 3
BEQ LF789 ; 2
DEX ; 2
BEQ LF770 ; 2
LDY #$0F ; 2
CPX #$02 ; 2
BCS LF776 ; 2
LDY #$08 ; 2
LF770: LSR ; 2
TAX ; 2
LDA #$08 ; 2 white noise
BNE LF77D ; 2

LF776: BEQ LF77A ; 2

LDY #$1F ; 2
LF77A: TAX ; 2
LDA #$04 ; 2 high pure tone
LF77D: DEC sound0Cnt ; 5
BNE .setAud0 ; 2
PHA ; 3
LDA #0 ; 2
STA sound0Id ; 3 stop sound0
PLA ; 4
BPL .setAud0 ; 2

; low fuel sound:

LF789: LDA gameMode ; 3 game running?
BNE .mute0 ; 2 no, quiet (x=0)
LDA fuelHi ; 3
CMP #$40 ; 2
BCS .jetSound ; 2
LDY sound0Cnt ; 3
BNE .contSound0 ; 2
LDY #$3F ; 2
.contSound0:
DEY ; 2
STY sound0Cnt ; 3
LDX fuelLo ; 3
STX temp ; 3
CMP #$04 ; 2
BCS LF7B0 ; 2
ROL temp ; 5
ROL ; 2
ROL temp ; 5
ROL ; 2
EOR #$FF ; 2
ADC #$20 ; 2
BNE .loadAud0 ; 2

LF7B0: CPY #$1C ; 2

BCC .jetSound ; 2
TYA ; 2
LSR ; 2
.loadAud0:
TAY ; 2
LDA #$0C ; 2
LDX #$0F ; 2
BNE .setAud0 ; 2

; make some noise, depending on jet speed:

.jetSound:
LDA speedY ; 3 frequency depends on y-speed
LSR ; 2
LSR ; 2
LSR ; 2
LSR ; 2
EOR #$FF ; 2
SEC ; 2
ADC #$1F ; 2
TAY ; 2
LDA joystick ; 3 volume depends on joystick
position
AND #MOVE_UP|MOVE_DOWN; 2
TAX ; 2
LDA VolumeTab,X ; 4
TAX ; 2
LDA #$08 ; 2 white noise
.setAud0:
STA AUDC0 ; 3
STY AUDF0 ; 3
.mute0:
STX AUDV0 ; 3

.noMissileSound:
LDX bridgeSound ; 3
BEQ .skipSound1 ; 2
; let the bridge explode:
.doBridge:
DEC bridgeSound ; 5 countdown volume
TXA ; 2
LSR ; 2
CLC ; 2
ADC #$04 ; 2
TAX ; 2
LDA random ; 3 random frequency
ORA #$18 ; 2
LDY #$08 ; 2
.setAud1:
STA AUDF1 ; 3
STY AUDC1 ; 3
.skipSound1:
STX AUDV1 ; 3

; start next frame:

.waitTim:
LDA INTIM ; 4
BNE .waitTim ; 2
LDY #$82 ; 2
STY WSYNC ; 3
STY VSYNC ; 3
STY WSYNC ; 3
STY WSYNC ; 3
STY WSYNC ; 3
STA VSYNC ; 3
IF NTSC
LDA #43 ; 2
ELSE
LDA #73 ; 2
ENDIF
STA TIM64T ; 4

; * check switches: *

LDA SWCHB ; 4
LSR ; 2
BCS .noReset ; 2
LDA gameVariation ; 3 RESET was pressed
STA player ; 3
LDX #$F7 ; 2
JMP Reset ; 3

.noReset:
LSR ; 2
BCS .noSelect ; 2
DEC gameDelay ; 5 SELECT was pressed
BPL .skipSelect ; 2
LDA gameVariation ; 3 toggle game (one or two player)
EOR #$01 ; 2
STA gameVariation ; 3
IF SCREENSAVER
STA SS_Delay ; 3
ELSE
FILL_NOP 2
ENDIF
STA player ; 3
ASL ; 2
ASL ; 2
ASL ; 2
ADC #DIGIT_H ; 2
JSR SetScorePtrs ; 6
JSR FinishGame ; 6
LDY #$1E ; 2
.noSelect:
STY gameDelay ; 3

.skipSelect:
LDA gameMode ; 3
BMI .mainLoopJmp ; 2
CMP #INTRO_SCROLL ; 2 scrolling into game
BNE .setBlockVars ; 2 no, generate new blocks
LDA #<JetStraight-1 ; 2 yes, set..
STA shapePtr0 ; 3 ..jet data pointer..
.mainLoopJmp:
JMP MainLoop ; 3 .. and continue with main loop

; check, if a new block is neccessary:

.setBlockVars:
LDA #3-1 ; 2 add speedY*3 to blockOffset ->
max. speed = 3 lines/frame
STA blockNum ; 3
.loopNext:
DEC blockNum ; 5
BMI .mainLoopJmp ; 2
LDA speedY ; 3
CMP #$FE ; 2 maximum speed?
BCS .incOffset ; 2 yes, increase offset
ADC posYLo ; 3
STA posYLo ; 3
BCC .loopNext ; 2
.incOffset:
INC blockOffset ; 5
LDA blockOffset ; 3
CMP #BLOCK_SIZE ; 2
BCC .loopNext ; 2

; * it#s time to create a new block: *

LDX #0 ; 2
STX blockOffset ; 3
LDY #NUM_BLOCKS ; 2
STY temp ; 3 move 6 blocks
LDA level ; 3
CMP #5 ; 2 first four levels?
BCC .firstLevels ; 2 yes, prevent small valley
LDY #0 ; 2 no, allow all widths of valley
.firstLevels:
STY valleyWidth ; 3 0 = all widths allowed, 6 =
limited widths

; first move the other blocks, to make space for the new one:
.loopBlocks: ;
LDY #5 ; 2 move 5 bytes
.loopMoveBlock:
LDA blockLst+1,X ; 4
STA blockLst,X ; 4
INX ; 2
DEY ; 2
BNE .loopMoveBlock ; 2
INX ; 2 skip one entry
DEC temp ; 5
BNE .loopBlocks ; 2

STY State1LstEnd ; 3 y=0!

LDA blockLstEnd ; 3 clear variable (except
PF_COLOR_FLAG)
AND #PF_COLOR_FLAG ; 2
STA blockLstEnd ; 3
LDX PF1PatId ; 3 copy previous PF pattern id
STX prevPF1PatId ; 3

DEC blockPart ; 5 second part of block?

BEQ .nextBlock ; 2 yes, next block
LDX sectionBlock ; 3
DEX ; 2 first part of last block of
section?
BNE .notLast ; 2 no, continue part

; the last block of a section has to be a road with bridge:

STX sectionEnd ; 3 yes, end of current section
LDA level ; 3
LSR ; 2 straight current level?
LDA #PF_ROAD_FLAG ; 2
BCS .isStraight ; 2 yes, dark green in NEXT level
LDA #PF_ROAD_FLAG|PF_COLOR_FLAG; 2 no, lighter green in NEXT level
.isStraight:
STA blockLstEnd ; 3
.notLast:
JSR NextRandom16 ; 6 new random number for next part of
block
JMP .nextBlockPart ; 3

; continue with a 'normal' block:

.nextBlock:
DEC sectionBlock ; 5 last block of section?
BNE .contSection ; 2 no, continue
JSR SaveSection ; 6 yes, save variables..
LDX #SECTION_BLOCKS ; 2 ..and got next level
STX sectionBlock ; 3
.contSection:
JSR NextRandom16 ; 6 new random number for next block
LDX sectionBlock ; 3
DEX ; 2 last block of section?
BNE .notLastBlock ; 2 no, skip
STX PF_State ; 3 yes, PF-State = static
LDA #12 ; 2 pattern-id for last block (with
bridge)
BNE .setPF1Id ; 3

.notLastBlock:
LDA level ; 3
LSR ; 2 straight level?
LDA #7 ; 2 pattern-id for straight block
BCS .setPF1Id ; 2 yes, set
LDA PF_State ; 3
DEX ; 2 last but one block of section?
BNE .notLastButOne ; 2 no, skip

; finish island before end of section:

CMP #ISLAND_FLAG|CHANGE_FLAG; 2 both flags set?
BEQ .isSetBoth ; 2 yes, 11 -> 10 (1. step to finish
island)
BNE .clearBoth ; 3 no, static PF and no island (2.
step to finish island)

; change PF_State bits 7 & 6:

; 00 -> 01/00 static -> changing or static
; 01 -> 11 changing -> island & changing
; 10 -> 00 island & static -> static (JTZ: ???)
; 11 -> 10/11 island & changing -> island & changing or static
.notLastButOne:
ASL ; 2
EOR PF_State ; 3 CHANGE_FLAG != ISLAND_FLAG?
BMI .updateFlags ; 2 yes, change flags
LDA randomLo ; 3 randomly change state?
AND #%00110000 ; 2
BNE .skipFlags ; 2 no, don't change state (75%)
.isSetBoth:
LDA PF_State ; 3
AND #ISLAND_FLAG ; 2 ISLAND_FLAG set?
BNE .isIsland ; 2 yes, clear CHANGE_FLAG
ORA #CHANGE_FLAG ; 2 no, set CHANGE_FLAG
.isIsland:
STA PF_State ; 3
LDA #0 ; 2
BEQ .setPF1Id ; 3

.updateFlags:
; change flags: 01 -> 11, 10 -> 00
LDA #ISLAND_FLAG|CHANGE_FLAG; 2
BIT PF_State ; 3 CHANGE_FLAG set?
BVS .setBoth ; 2 yes, set ISLAND_FLAG
.clearBoth:
LDA #0 ; 2 no, clear both flags
.setBoth:
STA PF_State ; 3
.skipFlags:
; create new random PF id:
; (JTZ: I'm not 100% sure, that I understand everything completely)
LDY #14 ; 2 y = 14
LDA randomLo ; 3
AND #$0F ; 2
CMP #2 ; 2
BCS .minOk ; 2
ADC #2 ; 2 minimum = 2
.minOk: ; a = 2..15
BIT PF_State ; 3 ISLAND_FLAG set?
BPL .skipDey ; 2 no, skip
DEY ; 2 y = 13
.skipDey:
LDX valleyWidth ; 3 all widths allowed?
BEQ .allWidths ; 2 yes, skip limit
LDY #8 ; 2 y = 8
.allWidths:
STY temp ; 3 save max. allowed id
CMP temp ; 3 random id < max. id?
BCC .setPF1Id ; 2 yes, skip
LDA temp ; 3 no, use max. id
.setPF1Id:
STA PF1PatId ; 3 a = 2..8 or 2..13/14
LDY #BLOCK_PARTS ; 2 reset blockPart
STY blockPart ; 3

.nextBlockPart:
LDA prevPF1PatId ; 3
TAX ; 2
SEC ; 2
SBC PF1PatId ; 3
STA diffPF ; 3 store the difference between the
two blocks
BCS .biggerPrev ; 2
; new id is bigger:
INC diffPF ; 5
CPX #SWITCH_PAGE_ID-1 ; 2
LDX PF1PatId ; 3
BCS .prevBigId ; 2
CPX #SWITCH_PAGE_ID ; 2
BCC .page1Id ; 2
LDA #-1 ; 2
ADC prevPF1PatId ; 3 CF=1! (JTZ: what's that good for?)
BPL .prevId ; 3

; old id is bigger or equal:

.biggerPrev:
BEQ .equalId ; 2
DEC diffPF ; 5 -1
.equalId:
CPX #SWITCH_PAGE_ID ; 2
BCS .page0Id ; 2
; not enough space for an island:
.page1Id:
JSR GetPageFlag ; 6
JSR LoadPFPattern ; 6 a = 0/1
STA PF1LstEnd ; 3
LDA #0 ; 2
STA PF2LstEnd ; 3
BEQ .contPage1 ; 3

; enough space for an island in previous block:

.page0Id:
LDA PF1PatId ; 3
CMP #SWITCH_PAGE_ID-1 ; 2
BCS .prevBigId ; 2
; enough space for an island in both blocks:
LDA #14+1 ; 2
SBC PF1PatId ; 3 CF=0!
BCS .prevId ; 3 negate id (inverts pattern)

.prevBigId:
LDA #PF1_PAGE_FLAG|PF2_PAGE_FLAG|PF_COLOR_FLAG; 2
.prevId:
STA PF1LstEnd ; 3
JSR GetPageFlag ; 6
SEC ; 2
ROL ; 2
JSR LoadPFPattern ; 6 a = 1/3
.contPage1:
BIT PF_State ; 3 ISLAND_FLAG set?
BPL .skipSwapPF ; 2 no, don't swap
LDA PF1LstEnd ; 3
LDX PF2LstEnd ; 3
STA PF2LstEnd ; 3
STX PF1LstEnd ; 3
.skipSwapPF:
BIT blockLstEnd ; 3 PF_ROAD_FLAG set?
BPL .skipRoad ; 2 no, skip
LDA #QUAD_SIZE ; 2 yes, create road block
STA State1LstEnd ; 3 quad size bridge
LDY #ID_BRIDGE ; 2
LDA #63 ; 2 x-position
JMP .endNewShape ; 3

.skipRoad:
; *** create new objects: ***
LDY #ID_FUEL ; 2
LDA sectionBlock ; 3
CLC ; 2
ADC blockPart ; 3
CMP #SECTION_BLOCKS+BLOCK_PARTS; 2 no enemies at first part of first
block of section
BCS .newHouse ; 2
; create more enemies and less fuel in higher difficulty levels:
LDA #64 ; 2
SBC level ; 3 1..48 (CF=0!)
ASL ; 2 a = 124..30
CMP randomHi ; 3
BCC .newEnemy ; 2 ~48%..88% -> more enemies, less
fuel and houses
BIT randomLo ; 3
BVC .newFuel ; 2 ~24%.. 6% -> less fuel
; no enemy or fuel, create new house instead:
.newHouse:
DEY ; 2 y=ID_HOUSE
LDX PF1PatId ; 3
CPX prevPF1PatId ; 3
BCC .currentSmaller ; 2
LDX prevPF1PatId ; 3
.currentSmaller: ; x = smaller id
LDA #DOUBLE_SIZE ; 2 house is double sized
STA State1LstEnd ; 3
LDA level ; 3
LSR ; 2
BCC .notStraight ; 2
; create random x-position for house in straight section:
LDA randomLo ; 3
AND #$1F ; 2
ADC #8 ; 2
CMP #25 ; 2 random position fits in left bank?
BCC .setShapeDir ; 2 yes, ok
ADC #92 ; 2 no, position house on right bank
BNE .setShapeDir ; 3

; position house in non-straight section:

.notStraight:
LDA ShapePosTab,X ; 4 x-pos based on PF1 id
BIT PF_State ; 3 ISLAND_FLAG set?
BPL .setShapeDir ; 2 no, skip
CPX #0 ; 2 PF id = 0?
BEQ .setShapeDir ; 2 no, skip
LDA #71 ; 2 fixed position for a house on
island
BNE .setShapeDir ; 3

; create new ship, helicopter or plane:

.newEnemy:
LDA #%111 ; 2
LDX level ; 3
CPX #3 ; 2 enemy planes start at level three
BCS .withPlanes ; 2
LDA #%001 ; 2 limit first levels to ship and
helicopter
.withPlanes:
AND randomHi ; 3 create random enemy object
TAX ; 2
LDY EnemyIdTab,X ; 4
.newFuel:
CPY #ID_SHIP ; 2
BNE .noShip ; 2
LDA #DOUBLE_SIZE ; 2 doublesize
STA State1LstEnd ; 3
.noShip:
LDA PF1PatId ; 3
CMP prevPF1PatId ; 3 new pat-id = previous pat-id?
BNE .newId ; 2 no,
; position object in straight blocks:
STA maxId ; 3
LDA level ; 3
LSR ; 2
BCC .notStraight2 ; 2
; position object in straight section:
LDA #106 ; 2
LDX State1LstEnd ; 3 ship? (doublesize)
BEQ .isShip ; 2 yes, position more right
LDA #97 ; 2 no, position more left
.isShip:
SBC valleyWidth ; 3 decrease maximum position (-6) in
first four levels,
; this avoids positioning near the
river bank
STA temp ; 3 store maximum position
LDA randomLo ; 3
AND #$3F ; 2
ADC #45 ; 2
ADC valleyWidth ; 3 increase random position in first
four levels (s.a.)
CMP temp ; 3 random position < maximum?
BCC .setShapeDir ; 2 yes, ok
LDA temp ; 3 no, position = maximum
.setShapeDir:
; make random direction for new shape:
BIT randomLo ; 3
BMI .invertDirection ; 2
BPL .endNewShape ; 3

.newId:
BCS .currentBigger ; 2
LDA prevPF1PatId ; 3
.currentBigger:
STA maxId ; 3 maxId cointains max(prevId, newId)

; position object in non-straight section:

.notStraight2:
; check, if there is enough space for new object:
LDX #13 ; 2 PF id
BIT PF_State ; 3 ISLAND_FLAG set?
BPL .contPage12 ; 2 no, skip
LDX #10 ; 2 yes, lower PF id
.contPage12:
CPX maxId ; 3
BCS .spaceOk ; 2
TYA ; 2
SBC #ID_SHIP-1 ; 2 new enemy is a ship?
BNE .spaceOk ; 2 no, skip
STA State1LstEnd ; 3 yes, change..
DEY ; 2 ..ship into helicopter
.spaceOk:
LDA maxId ; 3
ASL ; 2
ASL ; 2
BEQ .posSomewhere ; 2
BIT PF_State ; 3 ISLAND_FLAG set?
BPL .posSomewhere ; 2 no, position somewhere
; position object outside:
EOR #$FF ; 2
ADC #81 ; 2
BIT randomLo ; 3
BPL .skipNeg ; 2
EOR #$FF ; 2
ADC #160 ; 2
BNE .contPos ; 3

; position object somewhere:

.posSomewhere:
ADC #16 ; 2
BIT randomLo ; 3
BMI .doNeg ; 2
.contPos:
CLC ; 2
ADC #2 ; 2
ADC valleyWidth ; 3 keep space to river bank in first
levels
BNE .endNewShape ; 3

.doNeg:
EOR #$FF ; 2
ADC #160+1 ; 2
.skipNeg:
CPY #ID_FUEL ; 2 position fuel 1 pixel more right
SBC #9 ; 2
SBC valleyWidth ; 3 keep space to river bank in first
levels
LDX State1LstEnd ; 3 double sized object? (ship, house)
BEQ .invertDirection ; 2 no, skip
SBC #10 ; 2 yes, move 10 pixels left
.invertDirection:
CPY #ID_FUEL ; 2 fuel?
BEQ .endNewShape ; 2 yes, has constant direction
PHA ; 3
LDA State1LstEnd ; 3
ORA #DIRECTION_FLAG ; 2 set direction flag
STA State1LstEnd ; 3
PLA ; 4
.endNewShape:
STY Shape1IdLstEnd ; 3 save id of new object
JSR CalcPosX ; 6
STY XPos1LstEnd ; 3 save coarse x-positioning value
ORA State1LstEnd ; 3
STA State1LstEnd ; 3 save fine x-positioning value
JMP .loopNext ; 3

; end of main loop

GameInit SUBROUTINE
; Input: x (= 22/38, number of initialized variables)
; initializes some variables for new game:
.initLoop:
LDA InitTab,X ; 4
STA PF1Lst,X ; 4
DEX ; 2
BPL .initLoop ; 2

; clear some variables for new game:

LDA #0 ; 2
LDX #30 ; 2
.loopClear:
STA dXSpeed,X ; 4
DEX ; 2
BPL .loopClear ; 2

LDX #NUM_BLOCKS-1 ; 2
LDY #PF1_PAGE_FLAG ; 2
LDA level ; 3
LSR ; 2 straight level?
BCC .loopSet ; 2 no, skip
LDY #PF1_PAGE_FLAG|PF_COLOR_FLAG; 2 yes, set brighter green in
current level
.loopSet:
STY blockLst,X ; 4
DEX ; 2
BPL .loopSet ; 2
RTS ; 6

IF NTSC
LoadPFPattern SUBROUTINE
BIT PF_State ; 3 ISLAND_FLAG set?
BPL .contPage1 ; 2 no, set current page-flag
TAY ; 2 yes, read new page-flag from
table
LDA PageFlagTab,Y ; 4
.contPage1:
ORA blockLstEnd ; 3
STA blockLstEnd ; 3
LDA BankPtrTab,X ; 4 load a pattern for the river bank
CLC ; 2
ADC diffPF ; 3 adjust with difference between new
and prev PF id
STA PF2LstEnd ; 3
RTS ; 6
ELSE
FinishDigits SUBROUTINE
INY ; 2
STA WSYNC ; 3
STA HMOVE ; 3
STY GRP1 ; 3
STY GRP0 ; 3
STY GRP1 ; 3
LDY #14 ; 2 load line counter
SetColPx:
STA COLUP0 ; 3
STA COLUP1 ; 3
DoHMove:
STA WSYNC ; 3
STA HMOVE ; 3
RTS ; 6
ENDIF

NextRandom16 SUBROUTINE
; implements a 16 bit LFSR which generates a new random number:
LDA randomHi ; 3
ASL ; 2
ASL ; 2
ASL ; 2
EOR randomHi ; 3
ASL ; 2
ROL randomLo ; 5
ROL randomHi ; 5
; (JTZ: randomHi is very random, randomLo is NOT when more than one bit is used,
; because: randomLo[x+1] = randomLo[x]*2 + 0/1, but randomLo is used more often,
; randomHi only for new enemy and which. This could make the game a bit
predictable.)
RTS ; 6

SaveSection SUBROUTINE
; called at the start of a new section, increases difficulty level
; and saves random variables to be able to restart this section
LDX level ; 3 limit level to 48
CPX #MAX_LEVEL ; 2
BCC .notMax ; 2
LDX #MAX_LEVEL-2 ; 2 go back to 47
.notMax:
LDA randomLoSave ; 3
STA randomLoSave2 ; 3
LDA randomHiSave ; 3
STA randomHiSave2 ; 3
LDA randomLo ; 3
STA randomLoSave ; 3
LDA randomHi ; 3
STA randomHiSave ; 3
INX ; 2
STX level ; 3 1..48
RTS ; 6

SetPosX SUBROUTINE
; calculates the values and positions objects:
JSR CalcPosX ; 6
SetPosX2:
STA HMP0,X ; 4
INY ; 2
INY ; 2
INY ; 2
STA WSYNC ; 3
.waitPos:
DEY ; 2
BPL .waitPos ; 2
STA RESP0,X ; 4
RTS ; 6

;===============================================================================
; R O M - T A B L E S (Part 1)
;===============================================================================

align 256

PageFlagTab:
.byte 0, PF2_PAGE_FLAG, PF1_PAGE_FLAG, PF1_PAGE_FLAG|PF2_PAGE_FLAG ;
PF1_PAGE_FLAG unused!
shapePtr1bTab:
.byte <Explosion0-1, <Explosion1B-1, <Explosion2B-1, <Explosion1B-1
.byte <PlaneB-1, <Heli0B-1, <Heli1B-1, <ShipB-1, <BridgeB-1, <HouseB-1,
<FuelB-1

; x-positions of new object:

ShapePosTab:
.byte 143, 141, 7, 10, 132, 13, 128, 18, 124, 22, 120, 26, 116, 30, 112

;===============================================================================
; R O M - C O D E (Part 2)
;===============================================================================

SetPFxPtr SUBROUTINE
; called from kernel, sets pointers for new playfield data:
LDA PF1Lst,X ; 4
STA PF1Ptr ; 3
LDA blockLst,X ; 4
AND #PF1_PAGE_FLAG ; 2
ORA #>PFPat0 ; 2
STA PF1Ptr+1 ; 3

LDA PF2Lst,X ; 4
STA PF2Ptr ; 3
LDA blockLst,X ; 4
LSR ; 2
AND #PF2_PAGE_FLAG>>1 ; 2
ORA #>PFPat0 ; 2
STA PF2Ptr+1 ; 3
RTS ; 6 = 44

;===============================================================================
; R O M - T A B L E S (Part 2)
;===============================================================================

; high addresses of entry points into kernel:

JmpHiTab:
.byte >[JmpPoint0-1], >[JmpPoint1-1], >[JmpPoint2-1], >[JmpPoint3-1],
>[JmpPoint4-1]
.byte >[JmpPoint5-1], >[JmpPoint6-1], >[JmpPoint7-1], >[JmpPoint8-1],
>[JmpPoint9-1]

; used to animate explosions and helicopter:

AnimateIdTab:
.byte 0 ;
.byte ID_EXPLOSION2 ; start of explosion sequence
.byte ID_EXPLOSION3 ;
.byte ID_EXPLOSION0 ; end explosion with 0
.byte ID_PLANE ; no animation for plane
.byte ID_HELI1 ; switch between..
.byte ID_HELI0 ; ..ID_HELI0 and ID_HELI1

; low pointers to the patterns for the river bank:

BankPtrTab: ; $FCF1
.byte <PFPat0, <PFPat1, <PFPat2, <PFPat3, <PFPat4, <PFPat5, <PFPat6,
<PFPat7, <PFPat8
; last patterns are only used for islands:
.byte <PFPat9, <PFPat10, <PFPat11, <PFPat12, <PFPat13, <PFPat14

align 256

.byte $80 ; |X | $FD00

InitTab: ; $FDB1
.ds 6, <PFPat8 ; PF1Lst
.ds 6, <PFPat12 ; PF2Lst
.byte NUM_LINES+20 ; missileY
.byte 76 ; playerX
.byte 0 ; speedX
.byte 254 ; speedY
.byte 1 ;
.byte $FF, $FF ; fuelHi, fuelLo
.byte 17 ; sectionBlock
.byte <PFPat0, >PFPat0 ; shapePtr0 ;22
.byte 12 ; PF1PatId
.byte 1 ; level
.byte SEED_LO, SEED_HI ; randomLoSave, randomHiSave
.byte <Space, >Space ; livesPtr
.byte 1, SEED_LO, SEED_HI, <Space ; player2State (level,
randomLoSave, randomHiSave, livesPtr)
.byte $80 ; gameMode
.byte <FuelA, >FuelA ; shapePtr1a
.byte <FuelB, >FuelB ; shapePtr1b
.byte <ShipCol-3, >ShipCol ; colorPtr

;===============================================================================
; R O M - C O D E (Part 3)
;===============================================================================

CalcPosX SUBROUTINE
; calculates values for x-positioning:
; Input:
; - a = x-position
; Return:
; - y = coarse value for delay loop
; - a = fine value for HMxy
TAY ; 2
INY ; 2
TYA ; 2
AND #$0F ; 2
STA temp2 ; 3
TYA ; 2
LSR ; 2
LSR ; 2
LSR ; 2
LSR ; 2
TAY ; 2
CLC ; 2
ADC temp2 ; 3
CMP #$0F ; 2
BCC .skipIny ; 2
SBC #$0F ; 2
INY ; 2
.skipIny:
EOR #$07 ; 2
Mult16:
ASL ; 2
ASL ; 2
ASL ; 2
ASL ; 2
Wait12:
RTS ; 6

;===============================================================================
; R O M - T A B L E S (Part 3)
;===============================================================================

; low addresses of entry points into kernel:

JmpLoTab:
.byte <[JmpPoint0-1]
.byte <[JmpPoint1-1]
.byte <[JmpPoint2-1]
.byte <[JmpPoint3-1]
.byte <[JmpPoint4-1]
.byte <[JmpPoint5-1]
.byte <[JmpPoint6-1]
.byte <[JmpPoint7-1]
.byte <[JmpPoint8-1]
.byte <[JmpPoint9-1]

align 256

; used to en- or disable ball in fuel display:

ENABLTab:
.byte DISABLE
.byte ENABLE, ENABLE, ENABLE, ENABLE, ENABLE, ENABLE, ENABLE, ENABLE,
ENABLE, ENABLE

; the scores to the enemy objects (bit 7 = 0: 10, = 1: 100):

ScoreTab:
.byte 0, 0, 0, 0 ; EXPLOSIONS
.byte DIGIT_H * 1 | $80 ; PLANE 100
.byte DIGIT_H * 6 ; HELI 60
.byte DIGIT_H * 6 ; HELI 60
.byte DIGIT_H * 3 ; SHIP 30
.byte DIGIT_H * 5 |$80 ; BRIDGE 500
.byte 0 ; HOUSE
.byte DIGIT_H * 8 ; FUEL 80

; the data is stored for interlaced display:

.byte $FE ; |XXXXXXX |

;===============================================================================
; R O M - C O D E (Part 4)
;===============================================================================

GetPageFlag SUBROUTINE
; get bit 0 of the page for the playfield data:
TXA ;2
BEQ .exit ;2
LDA #%0 ;2
CPX #SWITCH_PAGE_ID ;2 PF id < 9
BCS .exit ;2 no, read data from page $FC
LDA #%1 ;2 yes, read data from page $FD
.exit:
RTS ;6

SetScorePtrs SUBROUTINE
STA scorePtr1+10 ;3
STA scorePtr2+10 ;3

; let score-pointers point to 'Space' to avoid leading zeros:

LDA #<Space ;2
LDX #8 ;2
.loopScorePtr2:
STA scorePtr2,X ;4
DEX ;2
DEX ;2
BPL .loopScorePtr2 ;2

LDX #8 ;2
SetScorePtr1:
STA scorePtr1,X ;4
DEX ;2
DEX ;2
BPL SetScorePtr1 ;2
RTS ;6

;===============================================================================
; R O M - T A B L E S (Part 4)
;===============================================================================
ColorPtrTab:
.byte $49 ; explosion 0 (no extra data for explosion
colors)
.byte $2A ; explosion 1
.byte $66 ; explosion 2
.byte $2A ; explosion 3
.byte <PlaneCol-6 ; plane
.byte <HelicopterCol-4 ; helicopter
.byte <HelicopterCol-4 ; helicopter
.byte <ShipCol-4 ; ship
.byte <BridgeCol-1 ; bridge
.byte <HouseCol-2 ; house (one byte shared!)
.byte <FuelCol-1 ; fuel (=$37)

HouseCol:
.byte BROWN, LIGHT_GREEN, LIGHT_GREEN, LIGHT_GREEN, LIGHT_GREEN
.byte BLACK, LIGHT_GREY, LIGHT_GREY, BLACK, BLACK
FuelCol:
.byte LIGHT_GREY, LIGHT_GREY, LIGHT_GREY, RED, RED, RED
.byte LIGHT_GREY, LIGHT_GREY, LIGHT_GREY, RED, RED, RED
HelicopterCol:
.byte CYAN, CYAN, DARK_BLUE, CYAN, ORANGE, ORANGE
IF NTSC
PlaneCol:
.byte $AC, $9C, $8C
ShipCol:
.byte $A8, $32, BLACK, BLACK
BridgeCol:
.byte $20, $14, $12, $14, $12, $18, $12, $14, $12, $14, $20
ELSE
PlaneCol:
.byte $BC, $BC, $9C
ShipCol:
.byte $98, $42, BLACK, BLACK
BridgeCol:
.byte $20, $24, $22, $24, $22, $28, $22, $24, $22, $24, $20
.byte $B4 ; unused
ENDIF

;===============================================================================
; R O M - C O D E (Part 5)
;===============================================================================

LooseJet SUBROUTINE
; called when player looses a life:
STY sound0Cnt ; 3
STA sound0Id ; 3
LDA blockLst ; 3
EOR blockLstEnd ; 3
AND #PF_COLOR_FLAG ; 2 dark section?
BEQ .skipRestartLevel ; 2 yes, skip
LDA sectionEnd ; 3 end of section?
BEQ .isEnd ; 2 yes, check restart of level
BIT blockLstEnd ; 3 road in new block?
BPL .skipRestartLevel ; 2 no, skip
JSR SaveSection ; 6 yes, goto next section
BNE .skipRestartLevel ; 3
.isEnd:
BIT blockLstEnd ; 3 PF_ROAD_FLAG set?
BMI .skipRestartLevel ; 2 yes, skip restart level
; restart level:
LDX level ; 3 limit level to 48
DEX ; 2
CPX #MAX_LEVEL-2 ; 2
BNE .skipLimit ; 2
LDX #MAX_LEVEL ; 2
.skipLimit:
STX level ; 3
LDA randomLoSave2 ; 3 retrieve saved random values
STA randomLoSave ; 3
LDA randomHiSave2 ; 3
STA randomHiSave ; 3
.skipRestartLevel:
LDA #<JetExplode-1 ; 2
STA shapePtr0 ; 3
.contFinish:
STA gameMode ; 3
LDA #NUM_LINES+20 ; 2 disable missile
STA missileY ; 3
RTS ; 6

FinishGame:
; called when the the game is not running:
LDA #$FF ; 2 disable al animations
STA frameCnt ; 3
BNE .contFinish ; 3

IF NTSC
FinishDigits SUBROUTINE
INY ; 2
STA WSYNC ; 3
STA HMOVE ; 3
STY GRP1 ; 3
STY GRP0 ; 3
STY GRP1 ; 3
LDY #14 ; 2 load line counter
SetColPx:
STA COLUP0 ; 3
STA COLUP1 ; 3
DoHMove:
STA WSYNC ; 3
STA HMOVE ; 3
RTS ; 6
ELSE
LoadPFPattern SUBROUTINE
BIT PF_State ; 3 ISLAND_FLAG set?
BPL .contPage1 ; 2 no, set current page-flag
TAY ; 2 yes, read new page-flag from
table
LDA PageFlagTab,Y ; 4
.contPage1:
ORA blockLstEnd ; 3
STA blockLstEnd ; 3
LDA BankPtrTab,X ; 4
CLC ; 2
ADC diffPF ; 3 adjust with difference between new
and prev PF id
STA PF2LstEnd ; 3
RTS ; 6
ENDIF

;===============================================================================
; R O M - T A B L E S (Part 5)
;===============================================================================

RoadColorTab:
.byte $04, $04, $08, $08, $08, $08, YELLOW, $08, $08, $08, $08 ; next two
bytes are shared
VolumeTab:
.byte $04, $04 ; next
byte ($07) is shared
EnemyIdTab:
.byte ID_SHIP, ID_HELI0, ID_SHIP, ID_HELI0, ID_PLANE, ID_SHIP, ID_HELI0,
ID_HELI0

shapePtr1aTab:
.byte <Explosion0-1, <Explosion1A-1, <Explosion2A-1, <Explosion1A-1
.byte <PlaneA-1, <Heli0A-1, <Heli1A-1, <ShipA-1, <BridgeA-1, <HouseA-1,
<FuelA-1

;===============================================================================
; R O M - C O D E (Part 6)
;===============================================================================

SwapPlayers SUBROUTINE
; swaps player variable blocks in two player game:
LDA gameVariation ;3 don't swap in one player game
BEQ .skipSwap ;2
EOR player ;3 change player
STA player ;3

LDX #3 ;2
.loopSwap0:
LDA player1State,X ;4
LDY player2State,X ;4
STA player2State,X ;4
STY player1State,X ;4
DEX ;2
BPL .loopSwap0 ;2

LDX #12-2 ;2
.loopSwap1:
LDA scorePtr1,X ;4
LDY scorePtr2,X ;4
STA scorePtr2,X ;4
STY scorePtr1,X ;4
DEX ;2
DEX ;2
BPL .loopSwap1 ;2
.skipSwap:
RTS ;6

;===============================================================================
; R O M - T A B L E S (Part 6)
;===============================================================================

ColorTab:
.byte 0, YELLOW, GREY, YELLOW+2, BLUE

.word START
.word 0

Andy Weir - The Egg
100% (1)
Andy Weir - The Egg
12 pages
Dice Game in VHDL
No ratings yet
Dice Game in VHDL
6 pages
Blackout by Connie Willis Extract
No ratings yet
Blackout by Connie Willis Extract
14 pages
Practical 2: Determination of Viscosity of Food Products Using A Viscometer
100% (2)
Practical 2: Determination of Viscosity of Food Products Using A Viscometer
9 pages
Atari VCS 2600 Pitfall Labeled Source Assembler Code
100% (1)
Atari VCS 2600 Pitfall Labeled Source Assembler Code
59 pages
Crack Me 3
No ratings yet
Crack Me 3
2,506 pages
CLX Review of Literature: Research Foundations For The Chicago Learning Exchange
No ratings yet
CLX Review of Literature: Research Foundations For The Chicago Learning Exchange
14 pages
Verilog Imp...
No ratings yet
Verilog Imp...
105 pages
ELBUG Monitor Listing
100% (2)
ELBUG Monitor Listing
22 pages
Bad P 3
No ratings yet
Bad P 3
6 pages
Ping Pong Game Using Arduino
No ratings yet
Ping Pong Game Using Arduino
34 pages
Matlab Connect4 Code
No ratings yet
Matlab Connect4 Code
30 pages
"Battleship Game" Computer Program
No ratings yet
"Battleship Game" Computer Program
12 pages
gcpad1
No ratings yet
gcpad1
7 pages
8X48 Led Matrix
No ratings yet
8X48 Led Matrix
3 pages
Lec2
No ratings yet
Lec2
3 pages
solutions_PAST PAPERS SOFTWARE DEV 2
No ratings yet
solutions_PAST PAPERS SOFTWARE DEV 2
5 pages
Enhanced Basic Source Code
No ratings yet
Enhanced Basic Source Code
147 pages
Chimera Yaw
No ratings yet
Chimera Yaw
65 pages
Задача
No ratings yet
Задача
18 pages
22bce20019. Lab Report-Dld
No ratings yet
22bce20019. Lab Report-Dld
40 pages
131. Base Drivecalc_vectors [Codebase 64 Wiki]
No ratings yet
131. Base Drivecalc_vectors [Codebase 64 Wiki]
29 pages
nqyW4WG1
No ratings yet
nqyW4WG1
2 pages
Non-Jap FRLG Arbitrary Code Execution
No ratings yet
Non-Jap FRLG Arbitrary Code Execution
46 pages
GROUP 6 - LaboratoryNo.2
No ratings yet
GROUP 6 - LaboratoryNo.2
8 pages
2048 2.1.02.bas
No ratings yet
2048 2.1.02.bas
31 pages
VERILOG
No ratings yet
VERILOG
28 pages
19EL013 Full Adder Using Data Flow and Gate Level
No ratings yet
19EL013 Full Adder Using Data Flow and Gate Level
9 pages
19EL013 LAB Assigment
No ratings yet
19EL013 LAB Assigment
9 pages
Digital Petrol Pump Machine Code
No ratings yet
Digital Petrol Pump Machine Code
10 pages
132. Base Filling_the_vectors [Codebase 64 Wiki]
No ratings yet
132. Base Filling_the_vectors [Codebase 64 Wiki]
12 pages
Snake 1
No ratings yet
Snake 1
18 pages
Assignment Mega
No ratings yet
Assignment Mega
11 pages
Jojo Training Mode Menu Fbneo 0.8.0.lua
No ratings yet
Jojo Training Mode Menu Fbneo 0.8.0.lua
143 pages
Unsigned Short Char Char: "1" "Key:" "Times:"
100% (2)
Unsigned Short Char Char: "1" "Key:" "Times:"
2 pages
Hard Memories
No ratings yet
Hard Memories
14 pages
ECE331 HW 2 Addressing Mode Homework
No ratings yet
ECE331 HW 2 Addressing Mode Homework
3 pages
8 Bit Hex To Decimal Conversion
100% (1)
8 Bit Hex To Decimal Conversion
20 pages
CODE 3
No ratings yet
CODE 3
3 pages
LCD 1100.c
No ratings yet
LCD 1100.c
8 pages
HX711
100% (1)
HX711
9 pages
Laboratory 4
No ratings yet
Laboratory 4
2 pages
Hmuv - 7
No ratings yet
Hmuv - 7
11 pages
Code
No ratings yet
Code
4 pages
DCD Lab Premid
No ratings yet
DCD Lab Premid
20 pages
Var Gamelost Frs21000
No ratings yet
Var Gamelost Frs21000
3 pages
Graphics With C: Explore The Unexplored
No ratings yet
Graphics With C: Explore The Unexplored
9 pages
Veriloh HDL Sa-2
No ratings yet
Veriloh HDL Sa-2
12 pages
Iosys Ini
No ratings yet
Iosys Ini
7 pages
Abu Minhaj Farooqi 37560 Fpga Final Exam
No ratings yet
Abu Minhaj Farooqi 37560 Fpga Final Exam
20 pages
TB Memory
No ratings yet
TB Memory
2 pages
Vlsi Lab
No ratings yet
Vlsi Lab
33 pages
Programming Fundamentals: Assignment No 4
No ratings yet
Programming Fundamentals: Assignment No 4
7 pages
Code
No ratings yet
Code
3 pages
KAMA System Complete
No ratings yet
KAMA System Complete
9 pages
Windows95 Sms Complete Rom
No ratings yet
Windows95 Sms Complete Rom
4 pages
Lpc213xx and Nokia7110
No ratings yet
Lpc213xx and Nokia7110
17 pages
ESP32 and Round OLED Smart Watch Concept - 10 Steps (With Pictures) - Instructables
No ratings yet
ESP32 and Round OLED Smart Watch Concept - 10 Steps (With Pictures) - Instructables
14 pages
Name Freebitco 2102
No ratings yet
Name Freebitco 2102
6 pages
Mega 5
No ratings yet
Mega 5
17 pages
exam_handbook
No ratings yet
exam_handbook
7 pages
Arduino Tone Control - Ino
No ratings yet
Arduino Tone Control - Ino
24 pages
Bad Shader 11
No ratings yet
Bad Shader 11
8 pages
No Ph.D. Game Design With Three.js
From Everand
No Ph.D. Game Design With Three.js
Nikiforos Kontopoulos
No ratings yet
CivRisk: A Module of Alternative Rules for the Board Game Risk
From Everand
CivRisk: A Module of Alternative Rules for the Board Game Risk
Chris Grey
No ratings yet
Using 6502 Assembly Language by Randy Hyde
100% (3)
Using 6502 Assembly Language by Randy Hyde
209 pages
Intel 8275 CRTC
100% (2)
Intel 8275 CRTC
24 pages
Atari Vcs 2600 Sound Frequency and Waveform Guide
100% (1)
Atari Vcs 2600 Sound Frequency and Waveform Guide
7 pages
Atari Vcs 2600 Music and Sound Programming Guide
No ratings yet
Atari Vcs 2600 Music and Sound Programming Guide
9 pages
Nintendo Entertainment System Architecture
100% (1)
Nintendo Entertainment System Architecture
10 pages
Atari VCS 2600 Supercharger Tape File Format
No ratings yet
Atari VCS 2600 Supercharger Tape File Format
2 pages
STELLA Programmer's Guide
No ratings yet
STELLA Programmer's Guide
56 pages
Promotion and Distribution Decisions:: Unit III
No ratings yet
Promotion and Distribution Decisions:: Unit III
17 pages
Incident Investigation Report Format No: HSE Format - 03 Rev. E Page 1 of 2
No ratings yet
Incident Investigation Report Format No: HSE Format - 03 Rev. E Page 1 of 2
2 pages
Bizhub PRO 1200 1200P Spec Sheet V1
No ratings yet
Bizhub PRO 1200 1200P Spec Sheet V1
2 pages
5 Pen PC Technology
100% (1)
5 Pen PC Technology
16 pages
Munster, Germany: Case Study For Civic Centre
No ratings yet
Munster, Germany: Case Study For Civic Centre
13 pages
Operations Management (Production
No ratings yet
Operations Management (Production
30 pages
Pega Interview Questions
100% (1)
Pega Interview Questions
3 pages
Creo 2.0 Configurations
No ratings yet
Creo 2.0 Configurations
38 pages
English Gr5
No ratings yet
English Gr5
6 pages
Gas Porosity
No ratings yet
Gas Porosity
6 pages
G653
No ratings yet
G653
7 pages
Corrosion Inspection in Oil and Gas Pipeline..
No ratings yet
Corrosion Inspection in Oil and Gas Pipeline..
4 pages
DHT11
No ratings yet
DHT11
9 pages
Effective MBA Essays
100% (1)
Effective MBA Essays
25 pages
Friedrich Wilhelm Nietzsche 15 October 1844 - 25 August 1900) Was A Prussian
No ratings yet
Friedrich Wilhelm Nietzsche 15 October 1844 - 25 August 1900) Was A Prussian
5 pages
Island Society Activity
No ratings yet
Island Society Activity
2 pages
Certificate of Calibration For Microscope Vt300
100% (3)
Certificate of Calibration For Microscope Vt300
2 pages
How To Find Everything in No Man's Sky - No Man's Sky Wiki Guide - IGN
No ratings yet
How To Find Everything in No Man's Sky - No Man's Sky Wiki Guide - IGN
1 page
Employability X PDF
No ratings yet
Employability X PDF
192 pages
Chapter 8 Manual Ogata
No ratings yet
Chapter 8 Manual Ogata
53 pages
USB Device Registry Entries - Microsoft Docs
No ratings yet
USB Device Registry Entries - Microsoft Docs
3 pages
CWB Encoding Tutorial
No ratings yet
CWB Encoding Tutorial
13 pages
Metal Slug Anthology PSP Guide - 2007 - Ignition Entertainment
No ratings yet
Metal Slug Anthology PSP Guide - 2007 - Ignition Entertainment
9 pages
Winter: Explain Why Stars Appear To Move Along Arcs During The Night. Answer
No ratings yet
Winter: Explain Why Stars Appear To Move Along Arcs During The Night. Answer
19 pages
MnSCU Chief Marketing & Communications Officer
No ratings yet
MnSCU Chief Marketing & Communications Officer
4 pages