riverraid.asm

; *** 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

; continue with channel 1:
; (missile fire or bridge explosion)
       LDA    missileSound      ; 3
       BEQ    .noMissileSound   ; 2
       DEC    missileSound      ; 5
       LDX    bridgeSound       ; 3             bridge exposion has higher priority
       BNE    .doBridge         ; 2
       EOR    #$FF              ; 2
       SEC                      ; 2
       ADC    #$1C              ; 2
       LDY    #$0C              ; 2             medium pure tone
       LDX    #$08              ; 2
       BNE    .setAud1          ; 2

.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

Zero:
       .byte $3C ; |  XXXX  | $FB00
       .byte $66 ; | XX  XX |
       .byte $66 ; | XX  XX |
       .byte $66 ; | XX  XX |
       .byte $66 ; | XX  XX |
       .byte $66 ; | XX  XX |
       .byte $66 ; | XX  XX |
       .byte $3C ; |  XXXX  |
One:
       .byte $3C ; |  XXXX  |
       .byte $18 ; |   XX   |
       .byte $18 ; |   XX   |
       .byte $18 ; |   XX   |
       .byte $18 ; |   XX   |
       .byte $18 ; |   XX   |
       .byte $38 ; |  XXX   |
       .byte $18 ; |   XX   |
Two:
       .byte $7E ; | XXXXXX |
       .byte $60 ; | XX     |
       .byte $60 ; | XX     |
       .byte $3C ; |  XXXX  |
       .byte $06 ; |     XX |
       .byte $06 ; |     XX |
       .byte $46 ; | X   XX |
       .byte $3C ; |  XXXX  |
Three:
       .byte $3C ; |  XXXX  |
       .byte $46 ; | X   XX |
       .byte $06 ; |     XX |
       .byte $0C ; |    XX  |
       .byte $0C ; |    XX  |
       .byte $06 ; |     XX |
       .byte $46 ; | X   XX |
       .byte $3C ; |  XXXX  |
Four:
       .byte $0C ; |    XX  |
       .byte $0C ; |    XX  |
       .byte $0C ; |    XX  |
       .byte $7E ; | XXXXXX |
       .byte $4C ; | X  XX  |
       .byte $2C ; |  X XX  |
       .byte $1C ; |   XXX  |
       .byte $0C ; |    XX  |
Five:
       .byte $7C ; | XXXXX  |
       .byte $46 ; | X   XX |
       .byte $06 ; |     XX |
       .byte $06 ; |     XX |
       .byte $7C ; | XXXXX  |
       .byte $60 ; | XX     |
       .byte $60 ; | XX     |
       .byte $7E ; | XXXXXX |
Six:
       .byte $3C ; |  XXXX  |
       .byte $66 ; | XX  XX |
       .byte $66 ; | XX  XX |
       .byte $66 ; | XX  XX |
       .byte $7C ; | XXXXX  |
       .byte $60 ; | XX     |
       .byte $62 ; | XX   X |
       .byte $3C ; |  XXXX  |
Seven:
       .byte $18 ; |   XX   |
       .byte $18 ; |   XX   |
       .byte $18 ; |   XX   |
       .byte $18 ; |   XX   |
       .byte $0C ; |    XX  |
       .byte $06 ; |     XX |
       .byte $42 ; | X    X |
       .byte $7E ; | XXXXXX |
Eight:
       .byte $3C ; |  XXXX  |
       .byte $66 ; | XX  XX |
       .byte $66 ; | XX  XX |
       .byte $3C ; |  XXXX  |
       .byte $3C ; |  XXXX  |
       .byte $66 ; | XX  XX |
       .byte $66 ; | XX  XX |
       .byte $3C ; |  XXXX  |
Nine:
       .byte $3C ; |  XXXX  |
       .byte $46 ; | X   XX |
       .byte $06 ; |     XX |
       .byte $3E ; |  XXXXX |
       .byte $66 ; | XX  XX |
       .byte $66 ; | XX  XX |
       .byte $66 ; | XX  XX |
       .byte $3C ; |  XXXX  |
MaxOut:
       .byte $18 ; |   XX   |
       .byte $18 ; |   XX   |
       .byte $00 ; |        |
       .byte $18 ; |   XX   |
       .byte $18 ; |   XX   |
       .byte $18 ; |   XX   |
       .byte $18 ; |   XX   |
       .byte $18 ; |   XX   |
Space:
       .byte $00 ; |        |
Copyright0:
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $F7 ; |XXXX XXX|
       .byte $95 ; |X  X X X|
       .byte $87 ; |X    XXX|
       .byte $80 ; |X       |
       .byte $90 ; |X  X    |
       .byte $F0 ; |XXXX    |
Copyright1:
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $47 ; | X   XXX|
       .byte $41 ; | X     X|
       .byte $77 ; | XXX XXX|
       .byte $55 ; | X X X X|
       .byte $75 ; | XXX X X|
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
Copyright2:
       .byte $AD ; |X X XX X|
       .byte $A9 ; |X X X  X|
       .byte $E9 ; |XXX X  X|
       .byte $A9 ; |X X X  X|
       .byte $ED ; |XXX XX X|
       .byte $41 ; | X     X|
       .byte $0F ; |    XXXX|
       .byte $00 ; |        |
       .byte $03 ; |      XX|
       .byte $00 ; |        |
       .byte $4B ; | X  X XX|
       .byte $4A ; | X  X X |
       .byte $6B ; | XX X XX|
       .byte $00 ; |        |
       .byte $08 ; |    X   |
       .byte $00 ; |        |
Copyright3:
       .byte $50 ; | X X    |
       .byte $58 ; | X XX   |
       .byte $5C ; | X XXX  |
       .byte $56 ; | X X XX |
       .byte $53 ; | X X  XX|
       .byte $11 ; |   X   X|
       .byte $F0 ; |XXXX    |
       .byte $00 ; |        |
       .byte $80 ; |X       |
       .byte $80 ; |X       |
       .byte $AA ; |X X X X |
       .byte $AA ; |X X X X |
       .byte $BA ; |X XXX X |
       .byte $22 ; |  X   X |
       .byte $27 ; |  X  XXX|
       .byte $02 ; |      X |
Copyright4:
       .byte $BA ; |X XXX X |
       .byte $8A ; |X   X X |
       .byte $BA ; |X XXX X |
       .byte $A2 ; |X X   X |
       .byte $3A ; |  XXX X |
       .byte $80 ; |X       |
       .byte $FE ; |XXXXXXX |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $11 ; |   X   X|
       .byte $11 ; |   X   X|
       .byte $17 ; |   X XXX|
       .byte $15 ; |   X X X|
       .byte $17 ; |   X XXX|
       .byte $00 ; |        |
Copyright5:
       .byte $E9 ; |XXX X  X|
       .byte $AB ; |X X X XX|
       .byte $AF ; |X X XXXX|
       .byte $AD ; |X X XX X|
       .byte $E9 ; |XXX X  X|
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $77 ; | XXX XXX|
       .byte $54 ; | X X X  |
       .byte $77 ; | XXX XXX|
       .byte $51 ; | X X   X|
       .byte $77 ; | XXX XXX|

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

; these are the patterns, that are used to define the playfield:
PFPat0:
       .byte $00 ; |        | $FC00
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $01 ; |       X|
       .byte $03 ; |      XX|
       .byte $07 ; |     XXX|
       .byte $0F ; |    XXXX|
       .byte $1F ; |   XXXXX|
PFPat14:
       .byte $3F ; |  XXXXXX|
       .byte $3F ; |  XXXXXX|
       .byte $3F ; |  XXXXXX|
       .byte $3F ; |  XXXXXX|
       .byte $3F ; |  XXXXXX|
       .byte $3F ; |  XXXXXX|
       .byte $3F ; |  XXXXXX|
       .byte $3F ; |  XXXXXX|
       .byte $3F ; |  XXXXXX|
       .byte $3F ; |  XXXXXX|
       .byte $3F ; |  XXXXXX|
       .byte $3F ; |  XXXXXX|
       .byte $3F ; |  XXXXXX|
       .byte $3F ; |  XXXXXX|
       .byte $3F ; |  XXXXXX|
       .byte $3F ; |  XXXXXX|
       .byte $1F ; |   XXXXX|
       .byte $0F ; |    XXXX|
       .byte $07 ; |     XXX|
       .byte $03 ; |      XX|
       .byte $01 ; |       X|
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $01 ; |       X|
       .byte $03 ; |      XX|
       .byte $07 ; |     XXX|
       .byte $0F ; |    XXXX|
PFPat13:
       .byte $1F ; |   XXXXX|
       .byte $1F ; |   XXXXX|
       .byte $1F ; |   XXXXX|
       .byte $1F ; |   XXXXX|
       .byte $1F ; |   XXXXX|
       .byte $1F ; |   XXXXX|
       .byte $1F ; |   XXXXX|
       .byte $1F ; |   XXXXX|
       .byte $1f ; |   XXXXX|
       .byte $1F ; |   XXXXX|
       .byte $1F ; |   XXXXX|
       .byte $1F ; |   XXXXX|
       .byte $1F ; |   XXXXX|
       .byte $1F ; |   XXXXX|
       .byte $1F ; |   XXXXX|
       .byte $1F ; |   XXXXX|
       .byte $0F ; |    XXXX|
       .byte $07 ; |     XXX|
       .byte $03 ; |      XX|
       .byte $01 ; |       X|
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $01 ; |       X|
       .byte $03 ; |      XX|
       .byte $07 ; |     XXX|
PFPat12:
       .byte $0F ; |    XXXX|
       .byte $0F ; |    XXXX|
       .byte $0F ; |    XXXX|
       .byte $0F ; |    XXXX|
       .byte $0F ; |    XXXX|
       .byte $0F ; |    XXXX|
       .byte $0F ; |    XXXX|
       .byte $0F ; |    XXXX|
       .byte $0F ; |    XXXX|
       .byte $0F ; |    XXXX|
       .byte $0F ; |    XXXX|
       .byte $0F ; |    XXXX|
       .byte $0F ; |    XXXX|
       .byte $0F ; |    XXXX|
       .byte $0F ; |    XXXX|
       .byte $0F ; |    XXXX|
       .byte $07 ; |     XXX|
       .byte $03 ; |      XX|
       .byte $01 ; |       X|
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $01 ; |       X|
       .byte $03 ; |      XX|
PFPat11:
       .byte $07 ; |     XXX|
       .byte $07 ; |     XXX|
       .byte $07 ; |     XXX|
       .byte $07 ; |     XXX|
       .byte $07 ; |     XXX|
       .byte $07 ; |     XXX|
       .byte $07 ; |     XXX|
       .byte $07 ; |     XXX|
       .byte $07 ; |     XXX|
       .byte $07 ; |     XXX|
       .byte $07 ; |     XXX|
       .byte $07 ; |     XXX|
       .byte $07 ; |     XXX|
       .byte $07 ; |     XXX|
       .byte $07 ; |     XXX|
       .byte $07 ; |     XXX|
       .byte $03 ; |      XX|
       .byte $01 ; |       X|
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $01 ; |       X|
PFPat10:
       .byte $03 ; |      XX|
       .byte $03 ; |      XX|
       .byte $03 ; |      XX|
       .byte $03 ; |      XX|
       .byte $03 ; |      XX|
       .byte $03 ; |      XX|
       .byte $03 ; |      XX|
       .byte $03 ; |      XX|
       .byte $03 ; |      XX|
       .byte $03 ; |      XX|
       .byte $03 ; |      XX|
       .byte $03 ; |      XX|
       .byte $03 ; |      XX|
       .byte $03 ; |      XX|
       .byte $03 ; |      XX|
       .byte $03 ; |      XX|
       .byte $01 ; |       X|
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
PFPat9:
       .byte $01 ; |       X|
       .byte $01 ; |       X|
       .byte $01 ; |       X|
       .byte $01 ; |       X|
       .byte $01 ; |       X|
       .byte $01 ; |       X|
       .byte $01 ; |       X|
       .byte $01 ; |       X|
       .byte $01 ; |       X|
       .byte $01 ; |       X|
       .byte $01 ; |       X|
       .byte $01 ; |       X|
       .byte $01 ; |       X|
       .byte $01 ; |       X|
       .byte $01 ; |       X|
       .byte $01 ; |       X|
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
JetStraight:
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $2A ; |  X X X |
       .byte $3E ; |  XXXXX |
       .byte $1C ; |   XXX  |
       .byte $08 ; |    X   |
       .byte $49 ; | X  X  X|
       .byte $6B ; | XX X XX|
       .byte $7F ; | XXXXXXX|
       .byte $7F ; | XXXXXXX|
       .byte $3E ; |  XXXXX |
       .byte $1C ; |   XXX  |
       .byte $08 ; |    X   |
       .byte $08 ; |    X   |
       .byte $08 ; |    X   |
JetMove:
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $02 ; |      X |
       .byte $2E ; |  X XXX |
       .byte $3C ; |  XXXX  |
       .byte $18 ; |   XX   |
       .byte $08 ; |    X   |
       .byte $0A ; |    X X |
       .byte $2E ; |  X XXX |
       .byte $3E ; |  XXXXX |
       .byte $3E ; |  XXXXX |
       .byte $3C ; |  XXXX  |
       .byte $18 ; |   XX   |
       .byte $08 ; |    X   |
       .byte $08 ; |    X   |
       .byte $08 ; |    X   |
JetExplode:
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $02 ; |      X |
       .byte $08 ; |    X   |
       .byte $10 ; |   X    |
       .byte $00 ; |        |
       .byte $40 ; | X      |
       .byte $08 ; |    X   |
       .byte $21 ; |  X    X|
       .byte $44 ; | X   X  |
       .byte $10 ; |   X    |
       .byte $04 ; |     X  |
       .byte $08 ; |    X   |
       .byte $00 ; |        |

; 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
       .byte $C0 ; |XX      |
       .byte $E0 ; |XXX     |
       .byte $F0 ; |XXXX    |
       .byte $F8 ; |XXXXX   |
       .byte $FC ; |XXXXXX  |
       .byte $FE ; |XXXXXXX |
PFPat8:
       .byte $FF ; |XXXXXXXX|
       .byte $FF ; |XXXXXXXX|
       .byte $FF ; |XXXXXXXX|
       .byte $FF ; |XXXXXXXX|
       .byte $FF ; |XXXXXXXX|
       .byte $FF ; |XXXXXXXX|
       .byte $FF ; |XXXXXXXX|
       .byte $FF ; |XXXXXXXX|
       .byte $FF ; |XXXXXXXX|
       .byte $FF ; |XXXXXXXX|
       .byte $FF ; |XXXXXXXX|
       .byte $FF ; |XXXXXXXX|
       .byte $FF ; |XXXXXXXX|
       .byte $FF ; |XXXXXXXX|
       .byte $FF ; |XXXXXXXX|
       .byte $FF ; |XXXXXXXX|
       .byte $FE ; |XXXXXXX |
       .byte $FC ; |XXXXXX  |
       .byte $F8 ; |XXXXX   |
       .byte $F0 ; |XXXX    |
       .byte $E0 ; |XXX     |
       .byte $C0 ; |XX      |
       .byte $80 ; |X       |
       .byte $C0 ; |XX      |
       .byte $E0 ; |XXX     |
       .byte $F0 ; |XXXX    |
       .byte $F8 ; |XXXXX   |
       .byte $FC ; |XXXXXX  |
PFPat7:
       .byte $FE ; |XXXXXXX |
       .byte $FE ; |XXXXXXX |
       .byte $FE ; |XXXXXXX |
       .byte $FE ; |XXXXXXX |
       .byte $FE ; |XXXXXXX |
       .byte $FE ; |XXXXXXX |
       .byte $FE ; |XXXXXXX |
       .byte $FE ; |XXXXXXX |
       .byte $FE ; |XXXXXXX |
       .byte $FE ; |XXXXXXX |
       .byte $FE ; |XXXXXXX |
       .byte $FE ; |XXXXXXX |
       .byte $FE ; |XXXXXXX |
       .byte $FE ; |XXXXXXX |
       .byte $FE ; |XXXXXXX |
       .byte $FE ; |XXXXXXX |
       .byte $FC ; |XXXXXX  |
       .byte $F8 ; |XXXXX   |
       .byte $F0 ; |XXXX    |
       .byte $E0 ; |XXX     |
       .byte $C0 ; |XX      |
       .byte $80 ; |X       |
       .byte $C0 ; |XX      |
       .byte $E0 ; |XXX     |
       .byte $F0 ; |XXXX    |
       .byte $F8 ; |XXXXX   |
PFPat6:
       .byte $FC ; |XXXXXX  |
       .byte $FC ; |XXXXXX  |
       .byte $FC ; |XXXXXX  |
       .byte $FC ; |XXXXXX  |
       .byte $FC ; |XXXXXX  |
       .byte $FC ; |XXXXXX  |
       .byte $FC ; |XXXXXX  |
       .byte $FC ; |XXXXXX  |
       .byte $FC ; |XXXXXX  |
       .byte $FC ; |XXXXXX  |
       .byte $FC ; |XXXXXX  |
       .byte $FC ; |XXXXXX  |
       .byte $FC ; |XXXXXX  |
       .byte $FC ; |XXXXXX  |
       .byte $FC ; |XXXXXX  |
       .byte $FC ; |XXXXXX  |
       .byte $F8 ; |XXXXX   |
       .byte $F0 ; |XXXX    |
       .byte $E0 ; |XXX     |
       .byte $C0 ; |XX      |
       .byte $80 ; |X       |
       .byte $C0 ; |XX      |
       .byte $E0 ; |XXX     |
       .byte $F0 ; |XXXX    |
PFPat5:
       .byte $F8 ; |XXXXX   |
       .byte $F8 ; |XXXXX   |
       .byte $F8 ; |XXXXX   |
       .byte $F8 ; |XXXXX   |
       .byte $F8 ; |XXXXX   |
       .byte $F8 ; |XXXXX   |
       .byte $F8 ; |XXXXX   |
       .byte $F8 ; |XXXXX   |
       .byte $F8 ; |XXXXX   |
       .byte $F8 ; |XXXXX   |
       .byte $F8 ; |XXXXX   |
       .byte $F8 ; |XXXXX   |
       .byte $F8 ; |XXXXX   |
       .byte $F8 ; |XXXXX   |
       .byte $F8 ; |XXXXX   |
       .byte $F8 ; |XXXXX   |
       .byte $F0 ; |XXXX    |
       .byte $E0 ; |XXX     |
       .byte $C0 ; |XX      |
       .byte $80 ; |X       |
       .byte $C0 ; |XX      |
       .byte $E0 ; |XXX     |
PFPat4:
       .byte $F0 ; |XXXX    |
       .byte $F0 ; |XXXX    |
       .byte $F0 ; |XXXX    |
       .byte $F0 ; |XXXX    |
       .byte $F0 ; |XXXX    |
       .byte $F0 ; |XXXX    |
       .byte $F0 ; |XXXX    |
       .byte $F0 ; |XXXX    |
       .byte $F0 ; |XXXX    |
       .byte $F0 ; |XXXX    |
       .byte $F0 ; |XXXX    |
       .byte $F0 ; |XXXX    |
       .byte $F0 ; |XXXX    |
       .byte $F0 ; |XXXX    |
       .byte $F0 ; |XXXX    |
       .byte $F0 ; |XXXX    |
       .byte $E0 ; |XXX     |
       .byte $C0 ; |XX      |
       .byte $80 ; |X       |
       .byte $C0 ; |XX      |
PFPat3:
       .byte $E0 ; |XXX     |
       .byte $E0 ; |XXX     |
       .byte $E0 ; |XXX     |
       .byte $E0 ; |XXX     |
       .byte $E0 ; |XXX     |
       .byte $E0 ; |XXX     |
       .byte $E0 ; |XXX     |
       .byte $E0 ; |XXX     |
       .byte $E0 ; |XXX     |
       .byte $E0 ; |XXX     |
       .byte $E0 ; |XXX     |
       .byte $E0 ; |XXX     |
       .byte $E0 ; |XXX     |
       .byte $E0 ; |XXX     |
       .byte $E0 ; |XXX     |
       .byte $E0 ; |XXX     |
       .byte $C0 ; |XX      |
       .byte $80 ; |X       |
PFPat2:
       .byte $C0 ; |XX      |
       .byte $C0 ; |XX      |
       .byte $C0 ; |XX      |
       .byte $C0 ; |XX      |
       .byte $C0 ; |XX      |
       .byte $C0 ; |XX      |
       .byte $C0 ; |XX      |
       .byte $C0 ; |XX      |
       .byte $C0 ; |XX      |
       .byte $C0 ; |XX      |
       .byte $C0 ; |XX      |
       .byte $C0 ; |XX      |
       .byte $C0 ; |XX      |
       .byte $C0 ; |XX      |
       .byte $C0 ; |XX      |
       .byte $C0 ; |XX      |
PFPat1:
       .byte $80 ; |X       |
       .byte $80 ; |X       |
       .byte $80 ; |X       |
       .byte $80 ; |X       |
       .byte $80 ; |X       |
       .byte $80 ; |X       |
       .byte $80 ; |X       |
       .byte $80 ; |X       |
       .byte $80 ; |X       |
       .byte $80 ; |X       |
       .byte $80 ; |X       |
       .byte $80 ; |X       |
       .byte $80 ; |X       |
       .byte $80 ; |X       |
       .byte $80 ; |X       |
       .byte $80 ; |X       |

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

FuelTab0:
       .byte $7F ; | XXXXXXX| $FE00
       .byte $40 ; | X      |
       .byte $4F ; | X  XXXX|
       .byte $48 ; | X  X   |
       .byte $48 ; | X  X   |
       .byte $4E ; | X  XXX |
       .byte $48 ; | X  X   |
       .byte $48 ; | X  X   |
       .byte $4F ; | X  XXXX|
       .byte $40 ; | X      |
       .byte $40 ; | X      |
       .byte $4C ; | X  XX  |
       .byte $4C ; | X  XX  |
       .byte $4C ; | X  XX  |
       .byte $7F ; | XXXXXXX|

FuelTab1:
       .byte $FF ; |XXXXXXXX|
Explosion0:
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
FuelTab2:
       .byte $FF ; |XXXXXXXX|
       .byte $00 ; |        |
       .byte $03 ; |      XX|
       .byte $C2 ; |XX    X |
       .byte $63 ; | XX   XX|
       .byte $30 ; |  XX    |
       .byte $1B ; |   XX XX|
       .byte $EC ; |XXX XX  |
       .byte $46 ; | X   XX |
       .byte $43 ; | X    XX|
       .byte $C1 ; |XX     X|
       .byte $48 ; | X  X   |
       .byte $08 ; |    X   |
       .byte $08 ; |    X   |
FuelTab3:
       .byte $FF ; |XXXXXXXX|
       .byte $00 ; |        |
       .byte $80 ; |X       |
       .byte $00 ; |        |
       .byte $80 ; |X       |
       .byte $80 ; |X       |
       .byte $80 ; |X       |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $80 ; |X       |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
FuelTab4:
       .byte $FF ; |XXXXXXXX|
       .byte $01 ; |       X|
       .byte $81 ; |X      X|
       .byte $81 ; |X      X|
       .byte $81 ; |X      X|
       .byte $E1 ; |XXX    X|
       .byte $81 ; |X      X|
       .byte $81 ; |X      X|
       .byte $F1 ; |XXXX   X|
       .byte $01 ; |       X|
       .byte $01 ; |       X|
       .byte $19 ; |   XX  X|
       .byte $19 ; |   XX  X|
       .byte $19 ; |   XX  X|
       .byte $FF ; |XXXXXXXX|

; 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:
FuelA:
       .byte $FE ; |XXXXXXX |
       .byte $DE ; |XX XXXX |
       .byte $DE ; |XX XXXX |
       .byte $FE ; |XXXXXXX |
       .byte $DE ; |XX XXXX |
       .byte $DE ; |XX XXXX |
       .byte $FE ; |XXXXXXX |
       .byte $D6 ; |XX X XX |
       .byte $D6 ; |XX X XX |
       .byte $DE ; |XX XXXX |
       .byte $CE ; |XX  XXX |
FuelB:
       .byte $C6 ; |XX   XX |
       .byte $DE ; |XX XXXX |
       .byte $DE ; |XX XXXX |
       .byte $C6 ; |XX   XX |
       .byte $CE ; |XX  XXX |
       .byte $C6 ; |XX   XX |
       .byte $C6 ; |XX   XX |
       .byte $D6 ; |XX X XX |

       .byte $FE ; |XXXXXXX |
       .byte $DE ; |XX XXXX |
       .byte $DE ; |XX XXXX |
       .byte $7C ; | XXXXX  |
BridgeA:
       .byte $42 ; | X    X |
BridgeB:
       .byte $FF ; |XXXXXXXX|
       .byte $FF ; |XXXXXXXX|
       .byte $FF ; |XXXXXXXX|
       .byte $FF ; |XXXXXXXX|
       .byte $FF ; |XXXXXXXX|
       .byte $FF ; |XXXXXXXX|
       .byte $FF ; |XXXXXXXX|
       .byte $FF ; |XXXXXXXX|
       .byte $FF ; |XXXXXXXX|
       .byte $FF ; |XXXXXXXX|
       .byte $42 ; | X    X |
ShipB:
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $FC ; |XXXXXX  |
       .byte $FF ; |XXXXXXXX|
       .byte $30 ; |  XX    |
       .byte $10 ; |   X    |
PlaneA:
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $30 ; |  XX    |
       .byte $4F ; | X  XXXX|
       .byte $C6 ; |XX   XX |
       .byte $00 ; |        |
Heli1B:
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $0E ; |    XXX |
       .byte $8E ; |X   XXX |
       .byte $FF ; |XXXXXXXX|
       .byte $0E ; |    XXX |
       .byte $07 ; |     XXX|
Heli0A:
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $04 ; |     X  |
       .byte $FF ; |XXXXXXXX|
       .byte $9F ; |X  XXXXX|
       .byte $04 ; |     X  |
       .byte $07 ; |     XXX|
ShipA:
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $7C ; | XXXXX  |
       .byte $FE ; |XXXXXXX |
       .byte $78 ; | XXXX   |
       .byte $10 ; |   X    |
PlaneB:
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $38 ; |  XXX   |
       .byte $FF ; |XXXXXXXX|
       .byte $80 ; |X       |
Heli1A:
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $04 ; |     X  |
       .byte $FF ; |XXXXXXXX|
       .byte $9F ; |X  XXXXX|
       .byte $04 ; |     X  |
       .byte $1C ; |   XXX  |
Heli0B:
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $0E ; |    XXX |
       .byte $8E ; |X   XXX |
       .byte $FF ; |XXXXXXXX|
       .byte $0E ; |    XXX |
       .byte $1C ; |   XXX  |
Explosion1B:
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $10 ; |   X    |
       .byte $20 ; |  X     |
       .byte $40 ; | X      |
       .byte $10 ; |   X    |
Explosion1A:
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $04 ; |     X  |
       .byte $02 ; |      X |
       .byte $08 ; |    X   |
       .byte $04 ; |     X  |
       .byte $00 ; |        |
Explosion2B:
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $20 ; |  X     |
       .byte $02 ; |      X |
       .byte $41 ; | X     X|
       .byte $20 ; |  X     |
       .byte $02 ; |      X |
       .byte $04 ; |     X  |
Explosion2A:
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $04 ; |     X  |
       .byte $88 ; |X   X   |
       .byte $10 ; |   X    |
       .byte $04 ; |     X  |
       .byte $80 ; |X       |
       .byte $10 ; |   X    |
       .byte $00 ; |        |
       .byte $00 ; |        |
HouseB:
       .byte $00 ; |        |
       .byte $04 ; |     X  |
       .byte $1F ; |   XXXXX|
       .byte $0E ; |    XXX |
       .byte $04 ; |     X  |
       .byte $04 ; |     X  |
       .byte $00 ; |        |
       .byte $AA ; |X X X X |
       .byte $FE ; |XXXXXXX |
       .byte $7C ; | XXXXX  |
       .byte $00 ; |        |
HouseA:
       .byte $00 ; |        |
       .byte $04 ; |     X  |
       .byte $0E ; |    XXX |
       .byte $1F ; |   XXXXX|
       .byte $0E ; |    XXX |
       .byte $04 ; |     X  |
       .byte $00 ; |        |
       .byte $FE ; |XXXXXXX |
       .byte $AA ; |X X X X |
       .byte $FE ; |XXXXXXX |
       .byte $38 ; |  XXX   |
       .byte $00 ; |        |
       .byte $00 ; |        |
       .byte $00 ; |        |


;===============================================================================
; 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