      processor 6502                                                                                               
;Default 2600 Constants set up by dissasembler..                                                                   
VSYNC   =  $00                                                                                                     
VBLANK  =  $01                                                                                                     
WSYNC   =  $02                                                                                                     
RSYNC   =  $03                                                                                                     
NUSIZ0  =  $04                                                                                                     
NUSIZ1  =  $05                                                                                                     
COLUP0  =  $06                                                                                                     
COLUP1  =  $07                                                                                                     
COLUPF  =  $08                                                                                                     
COLUBK  =  $09                                                                                                     
CTRLPF  =  $0A                                                                                                     
PF0     =  $0D                                                                                                     
PF1     =  $0E                                                                                                     
PF2     =  $0F                                                                                                     
RESP0   =  $10                                                                                                     
AUDC0   =  $15                                                                                                     
AUDF0   =  $17                                                                                                     
AUDV0   =  $19                                                                                                     
AUDV1   =  $1A                                                                                                     
GRP0    =  $1B                                                                                                     
GRP1    =  $1C                                                                                                     
ENAM0   =  $1D                                                                                                     
ENAM1   =  $1E                                                                                                     
ENABL   =  $1F                                                                                                     
HMP0    =  $20                                                                                                     
VDEL01  =  $26                                                                                                     
HMOVE   =  $2A                                                                                                     
HMCLR   =  $2B                                                                                                     
CXCLR   =  $2C                                                                                                     
CXP0FB  =  $32                                                                                                     
CXP1FB  =  $33                                                                                                     
CXM0FB  =  $34                                                                                                     
CXM1FB  =  $35                                                                                                     
CXBLPF  =  $36                                                                                                     
CXPPMM  =  $37                                                                                                     
INPT4   =  $3C                                                                                                     
SWCHA   =  $0280                                                                                                   
SWCHB   =  $0282                                                                                                   
INTIM   =  $0284                                                                                                   
TIM64T  =  $0296                                                                                                   
                                                                                                                   
       ORG $F000                                                                                                   
                                                                                                                   
START:                                                                                                             
       JMP    StartGame           ;Jump To Start Game                                                        ;3    
                                                                                                                   
                                                                                                                   
;Alternate Start                                                                                                   
      .byte $78,$D8,$4C,$06,$F3  ;Setup for 6507, Start with no Variable Initialisation.                      
                                                                                                                   
;Print Display                                                                                                     
PrintDisplay:                                                                                                             
       STA    HMCLR               ;Clear horzontal motion.                                                   ;3    
       LDA    $86                 ;Position Player00 Sprite To                                               ;3    
       LDX    #$00                ;      the X Coordinate of Object1.                                        ;2    
       JSR    PosSpriteX                                                                                     ;6    
                                                                                                                   
       LDA    $88                 ;Position Player01 Sprite to                                               ;3    
       LDX    #$01                ;      the X Coordinate of Object2.                                        ;2    
       JSR    PosSpriteX                                                                                     ;6    
                                                                                                                   
       LDA    $8B                 ;Position Ball Strite to                                                   ;3    
       LDX    #$04                ;      the X Coordinate of the Man.                                        ;2    
       JSR    PosSpriteX                                                                                     ;6    
                                                                                                                   
       STA    WSYNC               ;Wait for horizontal Blank.                                                ;3    
       STA    HMOVE               ;Apply Horizontal Motion.                                                  ;3    
       STA    CXCLR               ;Clear Collision Latches.                                                  ;3    
                                                                                                                   
       LDA    $8C                 ;Get the Y Coordinate of the Man.                                          ;3    
       SEC                                                                                                   ;2    
       SBC    #$04                ;And Adjust it (By Four Scan Lines)                                        ;2    
       STA    $8D                 ;      for printing (so Y Coordinate Specifies Middle)                     ;3    
                                                                                                                   
PrintDisplay_1: 
	 LDA    INTIM               ;Wait for end of the                                                       ;4    
       BNE    PrintDisplay_1      ;      current fame.                                                       ;2    
                                                                                                                   
       LDA    #$00                                                                                           ;2    
       STA    $90                 ;Set Player00 definition index.                                            ;3    
       STA    $91                 ;Set Player01 definition index.                                            ;3    
       STA    $8F                 ;Set room definition index.                                                ;3    
       STA    GRP1                ;Clear any graphics for Player01.                                          ;3    
       LDA    #$01                                                                                           ;2    
       STA    VDEL01              ;vertically delay Player 01                                                ;3    
       LDA    #$68                                                                                           ;2    
       STA    $8E                 ;Set Scan Lind Count.                                                      ;3    
                                                                                                                   
;Print top line of Room.                                                                                           
       LDY    $8F                 ;Get room definition index.                                                ;3    
       LDA    ($80),Y             ;Get first room definition byte.                                           ;5    
       STA    PF0                 ;      and display.                                                        ;3    
       INY                                                                                                   ;2    
       LDA    ($80),Y             ;Get Next room definition byte.                                            ;5    
       STA    PF1                 ;      and display.                                                        ;3    
       INY                                                                                                   ;2    
       LDA    ($80),Y             ;Get Last room defintion byte.                                             ;5    
       STA    PF2                 ;      and display.                                                        ;3    
       INY                                                                                                   ;2    
       STY    $8F                 ;Save for Next Time.                                                       ;3    
                                                                                                                   
       STA    WSYNC               ;Wait for Horizontal Blank.                                                ;3    
       LDA    #$00                                                                                           ;2    
       STA    VBLANK              ;Clear any Vertical Blank.                                                 ;3    
       JMP    PrintPlayer00                                                                                          ;3    
                                                                                                                   
                                                                                                                   
;Print Player01 (Object 02)                                                                                        
PrintPlayer01:
       LDA    $8E                 ;Get Current Scan Line.                                                    ;3    
       SEC                        ;Have we reached Object2's                                                 ;2    
       SBC    $89                 ;      Y Coordinate?                                                       ;3    
       STA    WSYNC               ;      Wait for Horzonal Blank.                                            ;3    
       BPL    PrintPlayer00       ;If Not, Branch.                                                           ;2    
                                                                                                                   
       LDY    $91                 ;Get the Player01 definition index.                                        ;3    
       LDA    ($84),Y             ;Get the Next Player01 Definition byte                                     ;5    
       STA    GRP1                ;      and display.                                                        ;3    
       BEQ    PrintPlayer00       ;If Zero then Definition finished.                                         ;2    
                                                                                                                   
       INC    $91                 ;Goto next Player01 definition byte.                                       ;5    
                                                                                                                   
;Print Player00 (Object01), Ball (Man) and Room.
PrintPlayer00:                                                                   
	 LDX    #$00                                                                                           ;2    
       LDA    $8E                 ;Get the Current Scan Line.                                                ;3    
       SEC                        ;Have we reached the Object1's                                             ;2    
       SBC    $87                 ;      Y coordinate?                                                       ;3    
       BPL    PrintPlayer00_1     ;If not then Branch.                                                       ;2    
                                                                                                                   
       LDY    $90                 ;Get Player00 definition index.                                            ;3    
       LDA    ($82),Y             ;Get the Next Player00 definition byte.                                    ;5    
       TAX                                                                                                   ;2    
       BEQ    PrintPlayer00_1     ;If Zero then Definition finished.                                         ;2    
                                                                                                                   
       INC    $90                 ;Go to Next Player00 definition byte.                                      ;5    

PrintPlayer00_1:                                                                                                                   
	 LDY    #$00                ;Disable Ball Graphic.                                                     ;2    
       LDA    $8E                 ;Get Scan line count.                                                      ;3    
       SEC                        ;Have we reached the Man's                                                 ;2    
       SBC    $8D                 ;      Y Coordinate?                                                       ;3    
       AND    #$FC                ;Mask value to four either side (getting depth of 8)                       ;2    
       BNE    PrintPlayer00_2     ;If Not, Branch.                                                           ;2    
                                                                                                                   
       LDY    #$02                ;Enable Ball Graphic.                                                      ;2    

PrintPlayer00_2:                                                                                                                   
       LDA    $8E                 ;Get Scan Line Count.                                                      ;3    
       AND    #$0F                ;Have we reached a sixteenth scan line.                                    ;2    
       BNE    PrintPlayer00_4     ;If not, Branch.                                                           ;2    
                                                                                                                   
       STA    WSYNC               ;Wait for Horzontal Blank.                                                 ;3    
       STY    ENABL               ;Enable Ball (If Wanted)                                                   ;3    
       STX    GRP0                ;Display Player 00 definition byte (if wanted)                             ;3    
                                                                                                                   
       LDY    $8F                 ;Get room definition index.                                                ;3    
       LDA    ($80),Y             ;Get first room definition byte,                                           ;5    
       STA    PF0                 ;      and display.                                                        ;3    
       INY                                                                                                   ;2    
       LDA    ($80),Y             ;Get next room definition byte,                                            ;5    
       STA    PF1                 ;      and display.                                                        ;3    
       INY                                                                                                   ;2    
       LDA    ($80),Y             ;Get next room definition byte,                                            ;5    
       STA    PF2                 ;      and display.                                                        ;3    
       INY                                                                                                   ;2    
       STY    $8F                 ;Save for Next Time.                                                       ;3    

PrintPlayer00_3:                                                                                                                   
       DEC    $8E                 ;Goto next scan line.                                                      ;5    
       LDA    $8E                 ;Get the scan line.                                                        ;3    
       CMP    #$08                ;Have we reached to within 8 scanlines of the bottom?                      ;2    
       BPL    PrintPlayer01       ;If not, Branch.                                                           ;2    
                                                                                                                   
       STA    VBLANK              ;Turn on VBLANK                                                            ;3    
       JMP    TidyUp                                                                                        ;3    
                                                                                                                   
;Print Player00 (Object 01) and Ball (Man)  
PrintPlayer00_4:                                                                       
       STA    WSYNC               ;Wait for Horzontal blank.                                                 ;3    
       STY    ENABL               ;Enable Ball (If Wanted.)                                                  ;3    
       STX    GRP0                ;Display Player00 definition byte (if Wanted).                             ;3    
       JMP    PrintPlayer00_3                                                                                          ;3    
                                                                                                                   
;Tidy Up                                                                                                           
TidyUp:
       LDA    #$00                                                                                           ;2    
       STA    GRP1                ;Clear any graphics for Player01                                           ;3    
       STA    GRP0                ;Clear any graphics for Player00                                           ;3    
       LDA    #$20                                                                                           ;2    
       STA    TIM64T              ;Stat Timing this frame using                                              ;4    
       RTS                        ;      the 64 bit counter.                                                 ;6    
                                                                                                                   
                                                                                                                   
;Position Sprite X horizontally.
PosSpriteX:                                                                                   
       LDY    #$02                ;Start with 10 clock cycles (to avoid HBLANK)                              ;2    
       SEC                        ;Divide the Coordinate.                                                    ;2    
PosSpriteX_1:
       INY                        ;      Wanted by Fifteen I.E.                                              ;2    
       SBC    #$0F                ;      Get Course Horizontal                                               ;2    
       BCS    PosSpriteX_1        ;      Value (In Multiples of 5 Clock Cycles                               ;2    
                                  ;      (Therefore giving 15 Color Cycles)                                      
       EOR    #$FF                ;Flip remanter to positive value (inverted).                               ;2    
       SBC    #$06                ;Convert to left or right of current position.                             ;2    
       ASL                                                                                                   ;2    
       ASL                        ;Move to high nybble for TIA                                               ;2    
       ASL                        ;      horizontal motion.                                                  ;2    
       ASL                                                                                                   ;2    
       STY    WSYNC               ;Wait for horozontal blank.                                                ;3    

PosSpriteX_2:                                                                                                                   
       DEY                        ;Count down the color                                                      ;2    
       BPL    PosSpriteX_2        ;      cycles (these are 5 machine/15 color cycles).                       ;2    
                                                                                                                   
       STA    RESP0,X             ;Reset the sprite, thus positioning it coursely.                           ;4    
       STA    HMP0,X              ;Set horizontal (fine) motion of sprite.                                   ;4    
       RTS                                                                                                   ;6    
                                                                                                                   
                                                                                                                   
;Preform VSYNC  
DoVSYNC:                                                                                                   
       LDA    INTIM               ;Get Timer Output                                                          ;4    
       BNE    DoVSYNC             ;Wait for Time-Out                                                         ;2    
       LDA    #$02                                                                                           ;2    
       STA    WSYNC               ;Wait for horizonal blank.                                                 ;3    
       STA    VBLANK              ;Start Vertical Blanking.                                                  ;3    
       STA    WSYNC               ;Wait for horizonal blank.                                                 ;3    
       STA    WSYNC               ;Wait for horizonal blank.                                                 ;3    
       STA    WSYNC               ;Wait for horizonal blank.                                                 ;3    
       STA    VSYNC               ;Start verticle sync.                                                      ;3    
       STA    WSYNC               ;Wait for horizonal blank.                                                 ;3    
       STA    WSYNC               ;Wait for horizonal blank.                                                 ;3    
       LDA    #$00                                                                                           ;2    
       STA    WSYNC               ;Wait for horizonal blank.                                                 ;3    
       STA    VSYNC               ;End Vertical sync.                                                        ;3    
       LDA    #$2A                ;Set clock interval to                                                     ;2    
       STA    TIM64T              ;Countdown next frame.                                                     ;4    
       RTS                                                                                                   ;6    
                                                                                                                   
;Setup a room for print.                                                                                           
SetupRoomPrint:
       LDA    $8A                 ;Get current room number.                                                  ;3    
       JSR    RoomNumToAddress    ;Convert it to an address.                                                 ;6    
       LDY    #$00                                                                                           ;2    
       LDA    ($93),Y             ;Get low pointer to room                                                   ;5    
       STA    $80                 ;      Graphics                                                            ;3    
       LDY    #$01                                                                                           ;2    
       LDA    ($93),Y             ;Get high pointer to room                                                  ;5    
       STA    $81                 ;      Graphics                                                            ;3    
                                                                                                                   
;Check B&W Switch for foom graphics.                                                                               
       LDA    SWCHB               ;Get console switches.                                                     ;4    
       AND    #$08                ;Check black and white switch                                              ;2    
       BEQ    UseBW               ;Branch if B&W.                                                            ;2    
                                                                                                                   
;Use Color                                                                                                         
       LDY    #$02                                                                                           ;2    
       LDA    ($93),Y             ;Get room color                                                            ;5    
       JSR    ChangeColor         ;Change if necessary                                                       ;6    
       STA    COLUPF              ;Put in Playfiled color register.                                          ;3    
       JMP    UseColor                                                                                          ;3    
                                                                                                                   
;Use B&W                                                                                                           
UseBW:
       LDY    #$03                                                                                           ;2    
       LDA    ($93),Y             ;Get B&W Color                                                             ;5    
       JSR    ChangeColor         ;Change if necessary                                                       ;6    
       STA    COLUPF              ;Put in the Playfield color register.                                      ;3    
                                                                                                                   
;Color Background.
UseColor:                                                                                                 
       LDA    #$08                ;Get light grey background                                                 ;2    
       JSR    ChangeColor         ;Change if necessary                                                       ;6    
       STA    COLUBK              ;Put it in the Background color register.                                  ;3    
                                                                                                                   
;Playfield Control.                                                                                                
       LDY    #$04                                                                                           ;2    
       LDA    ($93),Y             ;Get the playfield control value.                                          ;5    
       STA    CTRLPF              ;And put in the playfield control register.                                ;3    
       AND    #$C0                ;Get the "this wall" flag.                                                 ;2    
       LSR                                                                                                   ;2    
       LSR                                                                                                   ;2    
       LSR                        ;Get the first bit into position.                                          ;2    
       LSR                                                                                                   ;2    
       LSR                                                                                                   ;2    
       STA    ENAM1               ;Enable right hand thin wall. (if wanted - missile01)                      ;3    
       LSR                                                                                                   ;2    
       STA    ENAM0               ;Enable left hand thin wall (if wanted - missle00)                         ;3    
                                                                                                                   
;Get objects to display.                                                                                           
       JSR    CacheObjects        ;Get next two objects to display.                                          ;6    
                                                                                                                   
;Sort out their order.                                                                                             
       LDA    $95                 ;If the object1 is the                                                     ;3    
       CMP    #$00                ;Invisible surround                                                        ;2    
       BEQ    SwapPrintObjects    ;Then branch to swap (we want it as player01)                              ;2    
                                                                                                                   
       CMP    #$5A                ;If the first object is the bridge then                                    ;2    
       BNE    SetupObjectPrint    ;Swap the objects (we want it as player01)                                 ;2    
                                                                                                                   
       LDA    $96                 ;If the object2 is the                                                     ;3    
       CMP    #$00                ;Invisble surround then branch to leave                                    ;2    
       BEQ    SetupObjectPrint    ;it (we want it as player01)                                               ;2    

SwapPrintObjects:                                                                                                                   
       LDA    $95                                                                                            ;3    
       STA    $D8                                                                                            ;3    
       LDA    $96                                                                                            ;3    
       STA    $95                 ;Swap the objects to print.                                                ;3    
       LDA    $D8                                                                                            ;3    
       STA    $96                                                                                            ;3    
                                                                                                                   
;Setup Object1 to print.                                                                                           
SetupObjectPrint:
       LDX    $95                 ;Get Object1                                                               ;3    
       LDA    Store1,X             ;Get low pointer to it's dynamic information.                              ;4    
       STA    $93                                                                                            ;3    
       LDA    Store2,X             ;Get high pointer to it's dynamic informtion.                              ;4    
       STA    $94                                                                                            ;3    
                                                                                                                   
       LDY    #$01                                                                                           ;2    
       LDA    ($93),Y             ;Get Object1's X coordinate                                                ;5    
       STA    $86                 ;and Store for print.                                                      ;3    
       LDY    #$02                                                                                           ;2    
       LDA    ($93),Y             ;Get Object1's Y coordinate                                                ;5    
       STA    $87                 ;and Store for print.                                                      ;3    
                                                                                                                   
       LDA    Store3,X             ;Get low pointer to state value.                                           ;4    
       STA    $93                                                                                            ;3    
       LDA    Store4,X             ;Get high pointer to state value.                                          ;4    
       STA    $94                                                                                            ;3    
       LDY    #$00                                                                                           ;2    
       LDA    ($93),Y             ;Retrieve Object1's current state.                                         ;5    
       STA    $DC                                                                                            ;3    
                                                                                                                   
       LDA    Store5,X             ;Get low pointer to state information.                                     ;4    
       STA    $93                                                                                            ;3    
       LDA    Store6,X             ;Get high pointer to state information.                                    ;4    
       STA    $94                                                                                            ;3    
       JSR    GetObjectState      ;Find current state in the state information.                              ;6    
                                                                                                                   
       INY                        ;Index to the state's corresponding graphic pointer.                       ;2    
       LDA    ($93),Y             ;Get Object1's low graphic address                                         ;5    
       STA    $82                 ;and store for print.                                                      ;3    
       INY                                                                                                   ;2    
       LDA    ($93),Y             ;Get Object1's high graphic address                                        ;5    
       STA    $83                 ;and store for print.                                                      ;3    
                                                                                                                   
;Check B&W for object01                                                                                            
       LDA    SWCHB               ;Get console switches                                                      ;4    
       AND    #$08                ;Check B&W switches.                                                       ;2    
       BEQ    MakeObjectBW        ;Branch if B&W.                                                            ;2    
                                                                                                                   
;Colour                                                                                                            
       LDA    Store7,X             ;Get Object1's Color.                                                      ;4    
       JSR    ChangeColor         ;Change if necessary.                                                      ;6    
       STA    COLUP0              ;And set color luminance00.                                                ;3    
       JMP    ResizeObject                                                                                          ;3    
                                                                                                                   
;B&W
MakeObjectBW:                                                                                                               
       LDA    Store8,X             ;Get Object's B&W Color.                                                   ;4    
       JSR    ChangeColor         ;Change if necessary.                                                      ;6    
       STA    COLUP0              ;Set color luminance00.                                                    ;3    
                                                                                                                   
;Object1 Size 
ResizeObject:                                                                                                     
       LDA    Store9,X             ;Get Object1's Size                                                        ;4    
       ORA    #$10                ;And set to larger size if necessary.                                      ;2    
       STA    NUSIZ0              ;(Used by bridge and invisible surround)                                   ;3    
                                                                                                                   
;Setup Object 2 to Print.                                                                                          
       LDX    $96                 ;Get Object 2                                                              ;3    
       LDA    Store1,X                                                                                        ;4    
       STA    $93                 ;Get low pointer to it's dynamic information.                              ;3    
       LDA    Store2,X                                                                                        ;4    
       STA    $94                 ;Get high pointer to it's dynamic information.                             ;3    
       LDY    #$01                                                                                           ;2    
       LDA    ($93),Y             ;Get Object2's X coordinate                                                ;5    
       STA    $88                 ;and store for print.                                                      ;3    
       LDY    #$02                                                                                           ;2    
       LDA    ($93),Y             ;Get Object2's Y coordinate                                                ;5    
       STA    $89                 ;and store for print.                                                      ;3    
       LDA    Store3,X             ;Get low pointer to state value.                                           ;4    
       STA    $93                                                                                            ;3    
       LDA    Store4,X             ;Get high pointer to state value.                                          ;4    
       STA    $94                                                                                            ;3    
                                                                                                                   
                                                                                                                   
       LDY    #$00                                                                                           ;2    
       LDA    ($93),Y             ;Retrieve Object2's current state.                                         ;5    
       STA    $DC                                                                                            ;3    
       LDA    Store5,X             ;Get low pointer to state information.                                     ;4    
       STA    $93                                                                                            ;3    
       LDA    Store6,X             ;Get high pointer to state information.                                    ;4    
       STA    $94                                                                                            ;3    
       JSR    GetObjectState      ;Find the current state in the state information.                          ;6    
                                                                                                                   
       INY                        ;Index to the state's corresponding graphic pointer.                       ;2    
       LDA    ($93),Y                                                                                        ;5    
       STA    $84                 ;Get Object2's low graphic address.                                        ;3    
       INY                                                                                                   ;2    
       LDA    ($93),Y             ;Get Object2's high graphic address.                                       ;5    
       STA    $85                                                                                            ;3    
                                                                                                                   
;Check B&W for Object2                                                                                             
       LDA    SWCHB               ;Get Console Switches                                                      ;4    
       AND    #$08                ;Check B&W Switch.                                                         ;2    
       BEQ    MakeObject2BW       ;If B&W then Branch.                                                       ;2    
                                                                                                                   
;Color                                                                                                             
       LDA    Store7,X             ;Get Object2;s Color                                                       ;4    
       JSR    ChangeColor         ;Change if Necessary.                                                      ;6    
       STA    COLUP1              ;and set color luminance01.                                                ;3    
       JMP    ResizeObject2                                                                                  ;3    
                                                                                                                   
;B&W 
MakeObject2BW:                                                                                                              
       LDA    Store8,X             ;Get Object's B&W Color.                                                   ;4    
       JSR    ChangeColor         ;Change if Necessary.                                                      ;6    
       STA    COLUP1              ;and set color luminance01.                                                ;3    
                                                                                                                   
;Object2 Size                                                                                                      
ResizeObject2:
       LDA    Store9,X             ;Get Object2's Size                                                        ;4    
       ORA    #$10                ;And set to larger size if necessary.                                      ;2    
       STA    NUSIZ1              ;(Used by bridge and invisible surround)                                   ;3    
       RTS                                                                                                   ;6    
                                                                                                                   
;Fill cache with two objects in this room.                                                                         
CacheObjects:
       LDY    $9C                 ;Get Last Object                                                           ;3    
       LDA    #$A2                ;Set cache to                                                              ;2    
       STA    $95                 ;      no-ojects.                                                          ;3    
       STA    $96                                                                                            ;3    
MoveNextObject:
       TYA                                                                                                   ;2    
       CLC                        ;Goto the next object to                                                   ;2    
       ADC    #$09                ;check (add nine).                                                         ;2    
       CMP    #$A2                ;Check if over maximum.                                                    ;2    
       BCC    GetObjectsInfo                                                                                          ;2    
       LDA    #$00                ;If so, wrap to zero.                                                      ;2    
GetObjectsInfo:
       TAY                                                                                                   ;2    
       LDA    Store1,Y             ;Get low byte of object info.                                              ;4    
       STA    $93                                                                                            ;3    
       LDA    Store2,Y             ;Get high byte of object info.                                             ;4    
       STA    $94                                                                                            ;3    
       LDX    #$00                                                                                           ;2    
       LDA    ($93,X)             ;Get objects current room.                                                 ;6    
       CMP    $8A                 ;Is it in this room?                                                       ;3    
       BNE    CheckForMoreObjects ;If not lets try next object (branch)                                      ;2    
                                                                                                                   
       LDA    $95                 ;Check first slot.                                                         ;3    
       CMP    #$A2                ;If not default (no-object)                                                ;2    
       BNE    StoreObjectToPrint  ;then branch.                                                              ;2    
                                                                                                                   
       STY    $95                 ;Store this object's number to print                                       ;3    
       JMP    CheckForMoreObjects ;      and try for more.                                                   ;3    

StoreObjectToPrint:                                                                                                                   
       STY    $96                 ;Store this object's number to print.                                      ;3    
       JMP    StoreCount          ;      and then give up - no slots free.                                   ;3    
                                                                                                                   
CheckForMoreObjects:
       CPY    $9C                 ;Have we done all the objets?                                              ;3    
       BNE    MoveNextObject      ;If not, continue.                                                         ;2    

StoreCount:                                                                                                                   
       STY    $9C                 ;If so, store current count                                                ;3    
       RTS                        ;      for next time.                                                      ;6    
                                                                                                                   
;Convert room number to address.  
RoomNumToAddress:                                                                                 
       STA    $D8                 ;Strore room number wanted.                                                ;3    
       STA    $93                                                                                            ;3    
       LDA    #$00                ;Zero the high byte of the                                                 ;2    
       STA    $94                 ;      offset.                                                             ;3    
       CLC                                                                                                   ;2    
       ROL    $93                                                                                            ;5    
       ROL    $94                 ;Multiply room number by eight.                                            ;5    
       ROL    $93                                                                                            ;5    
       ROL    $94                                                                                            ;5    
       ROL    $93                                                                                            ;5    
       ROL    $94                                                                                            ;5    
                                                                                                                   
       LDA    $D8                 ;Get the original room number.                                             ;3    
       CLC                                                                                                   ;2    
       ADC    $93                                                                                            ;3    
       STA    $93                 ;And add it to the offset.                                                 ;3    
       LDA    #$00                                                                                           ;2    
       ADC    $94                 ;In effect the room number is                                              ;3    
       STA    $94                 ;      multiplied by nine.                                                 ;3    
                                                                                                            
       LDA    #<RoomDataTable                                                                                ;2    
       CLC                                                                                                   ;2    
       ADC    $93                 ;Add the room data base address                                            ;3    
       STA    $93                 ;to the offset therefore getting                                           ;3    
       LDA    #>RoomDataTable     ;      the final room data address.                                        ;2    
       ADC    $94                                                                                            ;3    
       STA    $94                                                                                            ;3    
       RTS                                                                                                   ;6    
                                                                                                                   
;Get pointer to current state.
GetObjectState:                                                                                     
       LDY    #$00                                                                                           ;2    
       LDA    $DC                 ;Get the current object state.                                             ;3    
GetObjectState_1:
       CMP    ($93),Y             ;Have we found it in the list of states.                                   ;5    
       BCC    GetObjectState_2    ;If nearing it then found it and return                                    ;2    
       BEQ    GetObjectState_2    ;If found it then return.                                                  ;2    
                                                                                                                   
       INY                                                                                                   ;2    
       INY                        ;Goto next state in list of states.                                        ;2    
       INY                                                                                                   ;2    
       JMP    GetObjectState_1                                                                               ;3    
GetObjectState_2:
       RTS                                                                                                   ;6    
                                                                                                                   
;Check for input.
CheckInput:                                                                                                  
	 INC    $E5                 ;Increment low count.                                                      ;5    
       BNE    GetJoystick                                                                                         ;2    
                                                                                                                   
       INC    $E6                 ;Increment hight count if                                                  ;5    
       BNE    GetJoystick         ;      needed.                                                             ;2    
                                                                                                                   
       LDA    #$80                ;Wrap the high count (indicating                                           ;2    
       STA    $E6                 ;      timeout) if needed.                                                 ;3    

GetJoystick:                                                                                                                   
	 LDA    SWCHA               ;Get joystick values.                                                      ;4    
       CMP    #$FF                ;If any movement then branch.                                              ;2    
       BNE    GetJoystick_2                                                                                          ;2    
                                                                                                                   
       LDA    SWCHB               ;Get the consol switches                                                   ;4    
       AND    #$03                ;Mast for the reset/select switchs.                                        ;2    
       CMP    #$03                ;Have either of them been used?                                            ;2    
       BEQ    GetJoystick_3       ;If not branch.                                                            ;2    

GetJoystick_2:                                                                                                                   
	 LDA    #$00                ;Zero the high count of the                                                ;2    
       STA    $E6                 ;      switches or joystick have been used.                                ;3    
GetJoystick_3:
	 RTS                                                                                                   ;6    
                                                                                                                   
;Change color if necessary.                                                                                        
ChangeColor:
	 LSR                        ;If bit 0 of the color is set                                              ;2    
       BCC    ChangeColor_2       ;      then the room is to flash.                                          ;2    
                                                                                                                   
       TAY                        ;Use color as an index (usually E5- the low counter).                      ;2    
       LDA.wy $0080,Y             ;Get flash color (usually the low counter.)                                ;4    

ChangeColor_2:                                                                                                                   
       LDY    $E6                 ;Get the input counter.                                                    ;3    
       BPL    ChangeColor_3       ;If console/joystick moved reciently then branch.                          ;2    
                                                                                                                   
       EOR    $E6                 ;Merge the high counter with the color wanted.                             ;3    
       AND    #$FB                ;Keep this color bug merge down the luminance.                             ;2    

ChangeColor_3:                                                                                                                   
       ASL                        ;And restore original color if necessary.                                  ;2    
       RTS                                                                                                   ;6    
                                                                                                                   
;Get the address of the dynamic information for an object.                                                         
GetObjectAddress:
       LDA    Store1,X                                                                                        ;4    
       STA    $93                 ;Get and store the low address.                                            ;3    
       LDA    Store2,X                                                                                        ;4    
       STA    $94                 ;Get and store the high address.                                           ;3    
       RTS                                                                                                   ;6    
                                                                                                                   
;Game Start
StartGame:                                                                                                        
	 SEI                        ;Set Interupts Off                                                         ;2    
       CLD                                                                                                   ;2    
       LDX    #$28                ;Clear TIA Registers                                                       ;2    
       LDA    #$00                ;&04-&2C i.e. blank                                                        ;2    
ResetAll:
       STA    NUSIZ0,X            ;Everything And Turn.                                                      ;4    
       DEX                        ;Everything Off.                                                           ;2    
       BPL    ResetAll                                                                                          ;2    
       TXS                        ;Reset Stack                                                               ;2    
SetupVars:
       STA    VSYNC,X             ;Clear &80 to &FF User Vars.                                               ;4    
       DEX                                                                                                   ;2    
       BMI    SetupVars                                                                                          ;2    
       JSR    ThinWalls           ;Position the thin walls (missiles)                                        ;6    
       JSR    SetupRoomObjects    ;Setup objects rooms and positions.                                        ;6    
MainGameLoop:
       JSR    CheckGameStart      ;Check for Game Start                                                      ;6    
       JSR    MakeSound           ;Make noise if necessary                                                   ;6    
       JSR    CheckInput          ;Check for input.                                                          ;6    
       LDA    $DE                 ;Is The Game Active?                                                       ;3    
       BNE    NonActiveLoop       ;If Not Branch..                                                           ;2    
       LDA    $B9                 ;Get the room the Chalise is in.                                           ;3    
       CMP    #$12                ;Is it in the yellow castle?                                               ;2    
       BNE    MainGameLoop_2      ;If Not Branch..                                                           ;2    
       LDA    #$FF                                                                                           ;2    
       STA    $DF                 ;Set the note count to maximum.                                            ;3    
       STA    $DE                 ;Set the game to inactive.                                                 ;3    
       LDA    #$00                ;Set the noise type to end-noise.                                          ;2    
       STA    $E0                                                                                            ;3    
MainGameLoop_2:
	 LDY    #$00                ;Allow joystick read - all movement.                                       ;2    
       JSR    BallMovement        ;Check ball collisions and move ball.                                      ;6    
       JSR    MoveCarriedObject   ;Move the Carried Object                                                   ;6    
       JSR    DoVSYNC             ;Wait for VSYNC                                                            ;6    
       JSR    SetupRoomPrint      ;Setup the room and objects for display.                                   ;6    
       JSR    PrintDisplay        ;Display the room and objects.                                             ;6    
       JSR    PickupPutdown       ;Deal with object pickup and putdown.                                      ;6    
       LDY    #$01                ;Dissalow joystick read - move vertically only.                            ;2    
       JSR    BallMovement        ;Check ball collisions and move ball.                                      ;6    
       JSR    Surround            ;Deal With Invisible Surround Moving.                                      ;6    
       JSR    DoVSYNC             ;Wait for VSYNC                                                            ;6    
       JSR    MoveBat             ;Move and deal with bat.                                                   ;6    
       JSR    Portals             ;Move and deal with portcullises.                                          ;6    
       JSR    PrintDisplay        ;Display the room and objects.                                             ;6    
       JSR    MoveGreenDragon     ;Move and deal with the green dragon.                                      ;6    
       JSR    MoveYellowDragon    ;Move and deal with the yellow dragon.                                     ;6    
       JSR    DoVSYNC             ;Wait for VSYNC.                                                           ;6    
       LDY    #$02                ;Dissalow joystic read/bridge check - move horrizonally only.              ;2    
       JSR    BallMovement        ;Check ball collisions and move ball.                                      ;6    
       JSR    MoveRedDragon       ;Move and deal with red dragon.                                            ;6    
       JSR    Mag_1               ;Deal with the magnet.                                                     ;6    
       JSR    PrintDisplay        ;Display the room and objects.                                             ;6    
       JMP    MainGameLoop                                                                                 ;3    
                                                                                                                   
;Non Active Game Loop.                                                                                             
NonActiveLoop:
	 JSR    DoVSYNC             ;Wait for VSYNC                                                            ;6    
       JSR    PrintDisplay        ;Display the room and objects.                                             ;6    
       JSR    SetupRoomPrint      ;Set up room and objects for display.                                      ;6    
       JMP    MainGameLoop                                                                                 ;3    
                                                                                                                   
;Position missiles to "thin wall" areas.
ThinWalls:                                                                           
       LDA    #$0D                ;Position missile 00 to                                                    ;2    
       LDX    #$02                ;(0D,00) - left thin wall.                                                 ;2    
       JSR    PosSpriteX                                                                                     ;6    
       LDA    #$96                ;Position missile 01 to                                                    ;2    
       LDX    #$03                ;(96,00) - right thin wall.                                                ;2    
       JSR    PosSpriteX                                                                                     ;6    
       STA    WSYNC                     ;Wait for horizonal blank.                                           ;3    
       STA    HMOVE                     ;Apply the horizonal move.                                           ;3    
       RTS                                                                                                   ;6    

CheckGameStart:                                                                                                                   
       LDA    SWCHB               ;Get the console switches.                                                 ;4    
       EOR    #$FF                ;Flip (as reset active low).                                               ;2    
       AND    $92                       ;Compare with what was before                                        ;3    
       AND    #$01                      ;And check only the reset switch                                     ;2    
       BEQ    CheckReset          ;If no reset then branch.                                                  ;2    
       LDA    $DE                 ;Has the Game Started?                                                     ;3    
       CMP    #$FF                ;If not then branch.                                                       ;2    
       BEQ    SetupRoomObjects                                                                               ;2    
       LDA    #$11                ;Get the yellow castle room.                                               ;2    
       STA    $8A                       ;Make it the current room.                                           ;3    
       STA    $E2                       ;Make it the previous room.                                          ;3    
       LDA    #$50                ;Get the X coordinate.                                                     ;2    
       STA    $8B                       ;Make it the current ball X coordinate.                              ;3    
       STA    $E3                       ;Make it the previous ball X coordinate.                             ;3    
       LDA    #$20                ;Get the Y coordinate.                                                     ;2    
       STA    $8C                       ;Make it the current ball Y coordinate.                              ;3    
       STA    $E4                       ;Make it the previous ball Y coordinate.                             ;3    
       LDA    #$00                                                                                           ;2    
       STA    $A8                 ;Set the red dragon's state to OK.                                         ;3    
       STA    $AD                 ;Set the yellow dragon's state to OK.                                      ;3    
       STA    $B2                 ;Set the green dragon's state to OK.                                       ;3    
       STA    $DF                 ;Set the note count to zero.. (ops!??)                                     ;3    
       LDA    #$A2                                                                                           ;2    
       STA    $9D                 ;Set no object being carried.                                              ;3    
CheckReset:
       LDA    SWCHB               ;Get the console switches.                                                 ;4    
       EOR    #$FF                ;Flip (as select active low)                                               ;2    
       AND    $92                 ;Compare with what was before.                                             ;3    
       AND    #$02                ;And check only the select switch.                                         ;2    
       BEQ    StoreSwitches       ;Branch if select not being used.                                          ;2    
       LDA    $8A                 ;Get the Current Room.                                                     ;3    
       CMP    #$00                ;Is it the "Number" room?                                                  ;2    
       BNE    SetupRoomObjects    ;Branch if not.                                                            ;2    
       LDA    $DD                 ;Increment the level.                                                      ;3    
       CLC                        ;Number (by two).                                                          ;2    
       ADC    #$02                                                                                           ;2    
       CMP    #$06                ;Have we reached the maximum?                                              ;2    
       BCC    ResetSetup                                                                                     ;2    
       LDA    #$00                ;If yep then set back to zero.                                             ;2    
ResetSetup:
       STA    $DD                 ;Store the new level number.                                               ;3    
SetupRoomObjects:
       LDA    #$00                ;Set the current room to the                                               ;2    
       STA    $8A                 ;"Number" room.                                                            ;3    
       STA    $E2                 ;And the previous room.                                                    ;3    
       LDA    #$00                ;Set the ball's Y coordinate to zero.                                      ;2    
       STA    $8C                 ;And the previous Y coordinate.                                            ;3    
       STA    $E4                 ;(So can't be seen.)                                                       ;3    
       LDY    $DD                 ;Get the level number.                                                     ;3    
       LDA    Loc_4,Y              ;Get the low pointer to object locations.                                  ;4    
       STA    $93                                                                                            ;3    
       LDA    Loc_5,Y             ;Get the high pointer to object locations.                                 ;4    
       STA    $94                                                                                            ;3    
       LDY    #$30                ;Copy all the objects dynamic information.                                 ;2    
SetupRoomObjects_2:
       LDA    ($93),Y             ;(the rooms and positions) into                                            ;5    
       STA.wy $00A1,Y             ;the working area.                                                         ;5    
       DEY                                                                                                   ;2    
       BPL    SetupRoomObjects_2                                                                                          ;2    
       LDA    $DD                 ;Get the level number.                                                     ;3    
       CMP    #$04                ;Branch if level one.                                                      ;2    
       BCC    SignalGameStart     ;Or two (Where all objects are in defined areas.)                          ;2    
       JSR    RandomizeLevel3     ;Put some objects in random rooms.                                         ;6    
       JSR    DoVSYNC             ;Wait for VSYNC                                                            ;6    
       JSR    PrintDisplay        ;Display rooms and objects.                                                ;6    
SignalGameStart:
       LDA    #$00                ;Signal that the game has started.                                         ;2    
       STA    $DE                                                                                            ;3    
       LDA    #$A2                ;Set no object being carried.                                              ;2    
       STA    $9D                                                                                            ;3    
StoreSwitches:
       LDA    SWCHB               ;Store the current console switches                                        ;4    
       STA    $92                                                                                            ;3    
       RTS                                                                                                   ;6    
                                                                                                                   
;Put objects in random rooms for level 3.                                                                          
RandomizeLevel3:
       LDY    #$1E                ;For each of the eleven objects..                                          ;2    
RandomizeLevel3_2:
       LDA    $E5                 ;Get the low input counter as seed.                                        ;3    
       LSR                                                                                                   ;2    
       LSR                                                                                                   ;2    
       LSR                        ;Generate a psudo-random                                                   ;2    
       LSR                        ;room number.                                                              ;2    
       LSR                                                                                                   ;2    
       SEC                                                                                                   ;2    
       ADC    $E5                 ;Store the low input counter.                                              ;3    
       STA    $E5                                                                                            ;3    
       AND    #$1F                ;Trim so represents a room value.                                          ;2    
       CMP    Loc_2,Y             ;If it is less than the                                                    ;4    
       BCC    RandomizeLevel3_2   ;lower bound for object then get another.                                  ;2    
       CMP    Loc_3,Y             ;If it equals or is                                                        ;4    
       BEQ    RandomizeLevel3_3   ;Less than the higher bound for object                                     ;2    
       BCS    RandomizeLevel3_2   ;Then continue (branch if higher)                                          ;2    
RandomizeLevel3_3:
       LDX    Loc_1,Y             ;Get the dynamic data index for this object                                ;4    
       STA    VSYNC,X             ;Store the new room value.                                                 ;4    
       DEY                                                                                                   ;2    
       DEY                        ;Goto the next object.                                                     ;2    
       DEY                                                                                                   ;2    
       BPL    RandomizeLevel3_2   ;Untill all done                                                           ;2    
       RTS                                                                                                   ;6    
                                                                                                                   
;Room Bounds Data.                                                                                                 
;Ex. the chalise at location &B9 can only exist in rooms 13-1A for                                                 
;     level 3.                                                                                                     
Loc_1:                                                                                                                   
       .byte $B9                    ;                                                                          
Loc_2:
       .byte $13                    ;Chalise                                                                   
Loc_3:
       .byte $1A                    ;                                                                          
       .byte $A4,$01,$1D            ;Red Dragon                                                                    
       .byte $A9,$01,$1D            ;Yellow Dragon                                                                 
       .byte $AE,$01,$1D            ;Green Dragon                                                                  
       .byte $B6,$01,$1D            ;Sword                                                                         
       .byte $BC,$01,$1D            ;Bridge                                                                        
       .byte $BF,$01,$1D            ;Yellow Key                                                                    
       .byte $C2,$01,$16            ;White Key                                                                     
       .byte $C5,$01,$12            ;Black Key                                                                     
       .byte $CB,$01,$1D            ;Bat                                                                           
       .byte $B3,$01,$1D            ;Magnet                                                                        

Loc_4:                                                                                                                   
       .byte <Game1Objects                    ;Pointer to object locations for game 01.                                  
Loc_5:
       .byte >Game1Objects                    ;      --continued.                                                        
       .byte <Game2Objects,>Game2Objects                ;Pointer to object locations for game 02.                                    
       .byte <Game2Objects,>Game2Objects                ;Pointer to object locations for game 03.                                    
                                                                                                                   
;Object locations (room and coordinate) for game 01.                                                               
Game1Objects:
       .byte $15,$51,$12            ;Black dot (Room, X, Y)                                                        
       .byte $0E,$50,$20,$00,$00    ;Red Dragon (Room, X, Y, Movement, State)                                    
       .byte $01,$50,$20,$00,$00    ;Yellow Dragon (Room, X, Y, Movement, State)                                 
       .byte $1D,$50,$20,$00,$00    ;Green Dragon (Room, X, Y, Movement, State)                                  
       .byte $1B,$80,$20            ;Magnet (Room,X,Y)                                                             
       .byte $12,$20,$20            ;Sword (Room,X,Y)                                                              
       .byte $1C,$30,$20            ;Challise (Room,X,Y)                                                           
       .byte $04,$29,$37            ;Bridge (Room,X,Y)                                                             
       .byte $11,$20,$40            ;Yellow Key (Room,X,Y)                                                         
       .byte $0E,$20,$40            ;White Key (Room,X,Y)                                                          
       .byte $1D,$20,$40            ;Black Key (Room,X,Y)                                                          
       .byte $1C                    ;Portcullis State                                                          
       .byte $1C                    ;Portcullis State                                                          
       .byte $1C                    ;Portcullis State                                                          
       .byte $1A,$20,$20,$00,$00    ;Bat (Room, X, Y, Movement, State)                                          
       .byte $78,$00                ;Bat (Carrying, Fed-Up)                                                      
                                                                                                                   
;Object locations (room and coordinate) for Games 02 and 03.                                                       
Game2Objects:
       .byte $15,$51,$12            ;Black Dot (Room,X,Y)                                                          
       .byte $14,$50,$20,$A0,$00    ;Red Dragon (Room,X,Y,Movement,State)                                        
       .byte $19,$50,$20,$A0,$00    ;Yellow Dragon (Room,X,Y,Movement,State)                                     
       .byte $04,$50,$20,$A0,$00    ;Green Dragon (Room,X,Y,Movement,State)                                      
       .byte $0E,$80,$20            ;Magnet (Room,X,Y)                                                             
       .byte $11,$20,$20            ;Sword (Room,X,Y)                                                              
       .byte $14,$30,$20            ;Chalise (Room,X,Y)                                                            
       .byte $0B,$40,$40            ;Bridge (Room,X,Y)                                                             
       .byte $09,$20,$40            ;Yellow Key (Room,X,Y)                                                         
       .byte $06,$20,$40            ;White Key (Room,X,Y)                                                          
       .byte $19,$20,$40            ;Black Key (Room,X,Y)                                                          
       .byte $1C                    ;Portcullis State                                                          
       .byte $1C                    ;Portcullis State                                                          
       .byte $1C                    ;Portcullis State                                                          
       .byte $02,$20,$20,$90,$00    ;Bat (Room,X,Y,Movement,State)                                               
       .byte $78,$00                ;Bat (Carrying, Fed-Up)                                                      
                                                                                                                   
;Check ball collisions and move ball.                                                                              
BallMovement:
       LDA    CXBLPF                                                                                         ;3    
       AND    #$80                ;Get ball-playfield collision                                              ;2    
       BNE    PlayerCollision     ;Branch if collision (Player-Wall)                                         ;2    
                                                                                                                   
       LDA    CXM0FB                                                                                         ;3    
       AND    #$40                ;Get ball-missile00 collision.                                             ;2    
       BNE    PlayerCollision     ;Branch if collision. (Player-Left Thin)                                   ;2    
                                                                                                                   
       LDA    CXM1FB                                                                                         ;3    
       AND    #$40                ;Get ball-missile01 collision.                                             ;2    
       BEQ    BallMovement_2      ;Branch if no collision.                                                   ;2    
                                                                                                                   
       LDA    $96                 ;If object2 (to print) is                                                  ;3    
       CMP    #$87                ;      not the black dot then collide.                                     ;2    
       BNE    PlayerCollision                                                                                ;2    
BallMovement_2:                                                                                                                   
       LDA    CXP0FB                                                                                         ;3    
       AND    #$40                ;Get ball-player00 collision.                                              ;2    
       BEQ    BallMovement_3      ;If no collision then branch.                                              ;2    
                                                                                                                   
       LDA    $95                 ;If object1 (to print) is                                                  ;3    
       CMP    #$00                ;      not the invisible surround then                                     ;2    
       BNE    PlayerCollision     ;      branch (collision)                                                  ;2    

BallMovement_3:                                                                                                                   
       LDA    CXP1FB                                                                                         ;3    
       AND    #$40                ;Get ball-player01 collision.                                              ;2    
       BEQ    NoCollision         ;If no collision then branch.                                              ;2    
                                                                                                                   
       LDA    $96                 ;If player01 to print is                                                   ;3    
       CMP    #$00                ;      not the invisible surround then                                     ;2    
       BNE    PlayerCollision     ;      branch (collision)                                                  ;2    
                                                                                                                   
       JMP    NoCollision         ;No collision - branch.                                                    ;3    
                                                                                                                   
;Player collided (with something)                                                                                  
PlayerCollision:
       CPY    #$02                ;Are we checking for the bridge?                                           ;2    
       BNE    ReadStick           ;If not, branch.                                                           ;2    
                                                                                                                   
       LDA    $9D                 ;Get the object being carried.                                             ;3    
       CMP    #$5A                ;      Branch if it is the bridge.                                         ;2    
       BEQ    ReadStick                                                                                      ;2    
                                                                                                                   
       LDA    $8A                 ;Get the current room.                                                     ;3    
       CMP    $BC                 ;Is the bridge in this room.                                               ;3    
       BNE    ReadStick           ;If not branch.                                                            ;2    
                                                                                                                   
;Check going through the bridge.                                                                                   
       LDA    $8B                 ;Get the ball's X coordinate.                                              ;3    
       SEC                                                                                                   ;2    
       SBC    $BD                 ;Subtract the bridge's X coordinate.                                       ;3    
       CMP    #$0A                ;If less than &0A then forget it.                                          ;2    
       BCC    ReadStick                                                                                      ;2    
                                                                                                                   
       CMP    #$17                ;If more than &17 then forget it.                                          ;2    
       BCS    ReadStick                                                                                      ;2    
                                                                                                                   
       LDA    $BE                 ;Get the bridge's Y coordinate.                                            ;3    
       SEC                                                                                                   ;2    
       SBC    $8C                 ;Subtrac the ball's Y coordinate.                                          ;3    
       CMP    #$FC                                                                                           ;2    
       BCS    NoCollision         ;If more than &FC then going through bridge.                               ;2    
                                                                                                                   
       CMP    #$19                ;If more than &19 then forget it.                                          ;2    
       BCS    ReadStick                                                                                      ;2    
                                                                                                                   
;No collision (and going through bridge)                                                                           
NoCollision:
       LDA    #$FF                ;Reset the joystick input.                                                 ;2    
       STA    $99                                                                                            ;3    
       LDA    $8A                 ;Get the current room.                                                     ;3    
       STA    $E2                 ;      and store temporarily.                                              ;3    
       LDA    $8B                 ;Get the ball's X coordinate.                                              ;3    
       STA    $E3                 ;      and store temporarily.                                              ;3    
       LDA    $8C                 ;Get the ball's Y coordinate.                                              ;3    
       STA    $E4                 ;And Store Temporarily.                                                    ;3    
                                                                                                                   
;Read Sticks                                                                                                            
ReadStick:
       CPY    #$00                ;???Is game in first phase?                                                ;2    
       BNE    ReadStick_2         ;If not, don't bother with joystick read.                                  ;2    
                                                                                                                   
       LDA    SWCHA               ;Read joysticks.                                                           ;4    
       STA    $99                 ;      and store value.                                                    ;3    

ReadStick_2:                                                                                                                   
       LDA    $E2                 ;Get Temporary room.                                                       ;3    
       STA    $8A                 ;      and make it the current room.                                       ;3    
       LDA    $E3                 ;Get temporary X coordinate                                                ;3    
       STA    $8B                 ;      and make it the man's X coordinate.                                 ;3    
       LDA    $E4                 ;Get temporary Y coordinate                                                ;3    
       STA    $8C                 ;      and make it the man's Y coordinate.                                 ;3    
                                                                                                                   
       LDA    $99                 ;Get the Joystick position.                                                ;3    
       ORA    ReadStick_3,Y             ;Merge out movement not allowed in this phase.                             ;4    
       STA    $9B                 ;And store cooked movement.                                                ;3    
                                                                                                                   
       LDY    #$03                ;Set the delta for the ball.                                               ;2    
       LDX    #$8A                ;Point to ball's coordiates.                                               ;2    
       JSR    MoveGroundObject     ;Move the ball                                                             ;6    
       RTS                                                                                                   ;6    
                                                                                                                   
;Joystick Merge Values                                                                                             
ReadStick_3:
       .byte $00,$C0,$30            ;No change, No horizontal, No vertical.                                        
                                                                                                                   
;Deal with object pickup and putdown. 
PickupPutdown:                                                                             
       ROL    INPT4               ;Get joystick trigger.                                                     ;5    
       ROR    $D7                 ;Merget into joystick record.                                              ;5    
       LDA    $D7                 ;Get joystick record.                                                      ;3    
       AND    #$C0                ;Merget out previous presses.                                              ;2    
       CMP    #$40                ;Was it previously pressed?                                                ;2    
       BNE    PickupPutdown_2     ;If not branch.                                                            ;2    
                                                                                                                   
       LDA    #$A2                                                                                           ;2    
       CMP    $9D                 ;If nothing is being carried                                               ;3    
       BEQ    PickupPutdown_2     ;      then branch.                                                        ;2    
                                                                                                                   
       STA    $9D                 ;Drop object.                                                              ;3    
       LDA    #$04                ;Set noise type to four.                                                   ;2    
       STA    $E0                                                                                            ;3    
       LDA    #$04                ;Set noise count to four.                                                  ;2    
       STA    $DF                                                                                            ;3    

PickupPutdown_2:                                                                                                                   
       LDA    #$FF                ;????                                                                      ;2    
       STA    $98                                                                                            ;3    
                                                                                                                   
;Check for collision.                                                                                              
       LDA    CXP0FB                                                                                         ;3    
       AND    #$40                ;Get Ball-Player00 collision.                                              ;2    
       BEQ    PickupPutdown_3     ;If nothing occured then branch.                                           ;2    
                                                                                                                   
;With Player00                                                                                                     
       LDA    $95                 ;Get type of Player00                                                      ;3    
       STA    $97                 ;And Store.                                                                ;3    
       JMP    CollisionDetected   ;Deal with collision.                                                      ;3    

PickupPutdown_3:                                                                                                                   
       LDA    CXP1FB                                                                                         ;3    
       AND    #$40                ;Get Ball-Player01 collision.                                              ;2    
       BEQ    PickupPutdown_4     ;If nothing has happened, branch.                                          ;2    
                                                                                                                   
       LDA    $96                 ;Get type of Player01                                                      ;3    
       STA    $97                 ;      and store.                                                          ;3    
       JMP    CollisionDetected   ;Deal with collision.                                                      ;3    

PickupPutdown_4:                                                                                                                   
       JMP    NoObject            ;Deal with no collision (return).                                          ;3    
                                                                                                                   
;Collision occured.    
CollisionDetected:                                                                                            
       LDX    $97                 ;Get the object collided with.                                             ;3    
       JSR    GetObjectAddress    ;Get it's dynamic information.                                             ;6    
       LDA    $97                 ;Get the object collided with.                                             ;3    
       CMP    #$51                ;Is it carriable?                                                          ;2    
       BCC    NoObject            ;If not, branch.                                                           ;2    
                                                                                                                   
       LDY    #$00                                                                                           ;2    
       LDA    ($93),Y             ;Get the object's room.                                                    ;5    
       CMP    $8A                 ;Is it in the current room?                                                ;3    
       BNE    NoObject            ;If not, branch.                                                           ;2    
                                                                                                                   
       LDA    $97                 ;Get the object collided with.                                             ;3    
       CMP    $9D                 ;Is it the object being carried?                                           ;3    
       BEQ    PickupObject        ;If so, branch (and actually pick it up.)                                  ;2    
                                                                                                                   
       LDA    #$05                ;Set noise type to five.                                                   ;2    
       STA    $E0                                                                                            ;3    
       LDA    #$04                ;Set noise type to four.                                                   ;2    
       STA    $DF                                                                                            ;3    

PickupObject:                                                                                                                   
       LDA    $97                 ;Set the object as being                                                   ;3    
       STA    $9D                 ;      carried.                                                            ;3    
                                                                                                                   
       LDX    $93                 ;Get the dynamice address low byte.                                        ;3    
       LDY    #$06                                                                                           ;2    
       LDA    $99                 ;????                                                                      ;3    
       JSR    MoveObjectDelta     ;????                                                                      ;6    
                                                                                                                   
       LDY    #$01                                                                                           ;2    
       LDA    ($93),Y             ;Get the object's X coordinate.                                            ;5    
       SEC                                                                                                   ;2    
       SBC    $8B                 ;Subtract the ball's X coordinate.                                         ;3    
       STA    $9E                 ;      and store the difference.                                           ;3    
       LDY    #$02                                                                                           ;2    
       LDA    ($93),Y             ;Get the object's Y coordinate.                                            ;5    
       SEC                                                                                                   ;2    
       SBC    $8C                 ;Subtract the Ball's Y coordinate.                                         ;3    
       STA    $9F                 ;      and store the difference.                                           ;3    
                                                                                                                   
;No collision
NoObject:                                                                                                      
       RTS                                                                                                   ;6    
                                                                                                                   
                                                                                                                   
;Move the carried object
MoveCarriedObject:                                                                                           
       LDX    $9D                 ;Get the object being carried.                                             ;3    
       CPX    #$A2                ;If nothing then branch (return)                                           ;2    
       BEQ    MoveCarriedObject_2                                                                            ;2    
                                                                                                                   
       JSR    GetObjectAddress    ;Get it's dynamic information.                                             ;6    
       LDY    #$00                                                                                           ;2    
                                                                                                                   
       LDA    $8A                 ;Get the current room.                                                     ;3    
       STA    ($93),Y             ;      and stroe the object's current room.                                ;6    
       LDY    #$01                                                                                           ;2    
                                                                                                                   
       LDA    $8B                 ;Get the ball's X coordinate.                                              ;3    
       CLC                                                                                                   ;2    
       ADC    $9E                 ;Add the X difference.                                                     ;3    
       STA    ($93),Y             ;      and store as the object's X coordinate.                             ;6    
       LDY    #$02                                                                                           ;2    
       LDA    $8C                 ;Get the ball's Y coordinate.                                              ;3    
       CLC                                                                                                   ;2    
       ADC    $9F                 ;Add the Y difference.                                                     ;3    
       STA    ($93),Y             ;      and store as the object's Y coordinate.                             ;6    
                                                                                                                   
       LDY    #$00                ;Set no delta.                                                             ;2    
       LDA    #$FF                ;Set no movement.                                                          ;2    
       LDX    $93                 ;Get the object's dynamic address.                                         ;3    
       JSR    MoveGroundObject     ;Move the object.                                                          ;6    
MoveCarriedObject_2:
       RTS                                                                                                   ;6    
                                                                                                                   
;Move the object. 
MoveGroundObject:                                                                         
       JSR    MoveObjectDelta     ;Move the object by delta.                                                 ;6    
       LDY    #$02                ;Set to do the three                                                       ;2    
MoveGroundObject_2:
       STY    $9A                 ;      portcullises.                                                       ;3    
       LDA.wy $00C8,Y             ;Get the portal state.                                                     ;4    
       CMP    #$1C                ;Is it in a closed state?                                                  ;2    
       BEQ    GetPortal           ;If not, next portal.                                                      ;2    
                                                                                                                   
;Deal with object moving out of a castle.                                                                          
       LDY    $9A                 ;Get port number.                                                          ;3    
       LDA    VSYNC,X             ;Get object's room number.                                                 ;4    
       CMP    EntryRoomOffsets,Y  ;Is it in a castle entry room.                                             ;4    
       BNE    GetPortal           ;If not, next portal.                                                      ;2    
                                                                                                                   
       LDA    WSYNC,X             ;Get the object's Y coordinate.                                            ;4    
       CMP    #$0D                ;Is it above &OD i.e at the bottom.                                        ;2    
       BPL    GetPortal           ;If so then branch.                                                        ;2    
                                                                                                                   
       LDA    CastleRoomOffsets,Y ;Get the castle room.                                                      ;4    
       STA    VSYNC,X             ;And put the object in the castle room.                                    ;4    
       LDA    #$50                                                                                           ;2    
       STA    VBLANK,X            ;Set the object's new X coordinate.                                        ;4    
       LDA    #$2C                                                                                           ;2    
       STA    WSYNC,X             ;Set the new object's Y coordinate.                                        ;4    
       LDA    #$01                                                                                           ;2    
       STA.wy $00C8,Y             ;Set the portcullis state to 01.                                           ;5    
       RTS                                                                                                   ;6    

GetPortal:                                                                                                                   
       LDY    $9A                 ;Get the portcullis number.                                                ;3    
       DEY                        ;      goto next,                                                          ;2    
       BPL    MoveGroundObject_2   ;      and continue.                                                       ;2    
                                                                                                                   
;Check and Deal with Up.                                                                                           
       LDA    WSYNC,X             ;Get the object's Y coordinate.                                            ;4    
       CMP    #$6A                ;Has it reched above the top.                                              ;2    
       BMI    DealWithLeft        ;If not, branch.                                                           ;2    
                                                                                                                   
       LDA    #$0D                ;Set new Y coordinate to bottom.                                           ;2    
       STA    WSYNC,X                                                                                        ;4    
       LDY    #$05                ;Get the direction wanted.                                                 ;2    
       JMP    GetNewRoom          ;Go and get new room.                                                      ;3    
                                                                                                                   
;Check and Deal with Left.
DealWithLeft:                                                                                         
       LDA    VBLANK,X            ;Get the object's X coordinate.                                            ;4    
       CMP    #$03                ;Is it Three or less?                                                      ;2    
       BCC    DealWithLeft_2      ;IF so, branch.  (off to left)                                             ;2    
                                                                                                                   
       CMP    #$F0                ;Is it's &F0 or more.                                                      ;2    
       BCS    DealWithLeft_2      ;If so, branch.  (off to right)                                            ;2    
                                                                                                                   
       JMP    DealWithDown                                                                                          ;3    

DealWithLeft_2:                                                                                                                   
       CPX    #$8A                ;Are we dealling with the ball?                                            ;2    
       BEQ    DealWithLeft_3      ;If so Branch.                                                             ;2    
                                                                                                                   
       LDA    #$9A                ;Set new X coordinate for the others.                                      ;2    
       JMP    DealWithLeft_4                                                                                          ;3    

DealWithLeft_3:                                                                                                                   
       LDA    #$9E                ;Set new X coordinate for the ball.                                        ;2    

DealWithLeft_4:                                                                                                                   
       STA    VBLANK,X            ;Store the next X coordinate.                                              ;4    
       LDY    #$08                ;And get the direction wanted.                                             ;2    
       JMP    GetNewRoom          ;Go and get new room.                                                      ;3    
                                                                                                                   
;Check and Deal with Down.                                                                                         
DealWithDown:
       LDA    WSYNC,X             ;Get object's Y coordinate.                                                ;4    
       CMP    #$0D                ;If it's greater than &0D then                                             ;2    
       BCS    DealWithRight       ;Branch.                                                                   ;2    
                                                                                                                   
       LDA    #$69                ;Set new Y coordinate.                                                     ;2    
       STA    WSYNC,X                                                                                        ;4    
       LDY    #$07                ;Get the direction wanted.                                                 ;2    
       JMP    GetNewRoom          ;Go and get new room.                                                      ;3    
                                                                                                                   
;Check and Deal with Right.  
DealWithRight:
       LDA    VBLANK,X            ;Get the object's X coordinate.                                            ;4    
       CPX    #$8A                ;Are we dealing with the ball.                                             ;2    
       BNE    DealWithRight_2     ;Branch if not.                                                            ;2    
                                                                                                                   
       CMP    #$9F                ;Has the object reached the right?                                         ;2    
       BCC    MovementReturn      ;Branch if not.                                                            ;2    
                                                                                                                   
       LDA    VSYNC,X             ;Get the Ball's Room.                                                      ;4    
       CMP    #$03                ;Is it room #3 (Right to secret room)                                      ;2    
       BNE    DealWithRight_3     ;Branch if not.                                                            ;2    
                                                                                                                   
       LDA    $A1                 ;Check the room of the black dot.                                          ;3    
       CMP    #$15                ;Is it in the hidden room area?                                            ;2    
       BEQ    DealWithRight_3     ;If so, Branch.                                                            ;2    
                                                                                                                   
;Manually change to secret room.                                                                                   
       LDA    #$1E                ;Set room to secret room.                                                  ;2    
       STA    VSYNC,X             ;And make it current.                                                      ;4    
       LDA    #$03                ;Set the X coordinate.                                                     ;2    
       STA    VBLANK,X                                                                                       ;4    
       JMP    MovementReturn      ;And Exit.                                                                 ;3    

DealWithRight_2:                                                                                                                   
       CMP    #$9B                ;Has the object reached the right of the screen?                           ;2    
       BCC    MovementReturn      ;Branch if not (no room change)                                            ;2    

DealWithRight_3:                                                                                                                   
       LDA    #$03                ;Set the next X coordinate.                                                ;2    
       STA    VBLANK,X                                                                                       ;4    
       LDY    #$06                ;And get the direction wanted.                                             ;2    
       JMP    GetNewRoom          ;Get the new room.                                                         ;3    
                                                                                                                   
;Get new room 
GetNewRoom:                                                                                                     
       LDA    VSYNC,X             ;Get the object's room.                                                    ;4    
       JSR    RoomNumToAddress    ;Convert it to an address.                                                 ;6    
       LDA    ($93),Y             ;Get the adjacent room.                                                    ;5    
       JSR    AdjustRoomLevel     ;Deal with the level differences.                                          ;6    
       STA    VSYNC,X             ;      and store as new object's room.                                     ;4    

MovementReturn:                                                                                                                   
       RTS                                                                                                   ;6    
                                                                                                                   
;Move the object in direction by delta.                                                                            
MoveObjectDelta:
       STA    $9B                 ;Stored direction wanted.                                                  ;3    
MoveObjectDelta_2:
       DEY                        ;Count down the delta.                                                     ;2    
       BMI    MoveObjectDelta_7                                                                              ;2    
                                                                                                                   
       LDA    $9B                 ;Get direction wanted.                                                     ;3    
       AND    #$80                ;Check for right move.                                                     ;2    
       BNE    MoveObjectDelta_3   ;If no move right then branch.                                             ;2    
                                                                                                                   
       INC    VBLANK,X            ;Increment the X coordinate.                                               ;6    

MoveObjectDelta_3:                                                                                                                   
       LDA    $9B                 ;Get the direction wanted.                                                 ;3    
       AND    #$40                ;Check for left move.                                                      ;2    
       BNE    MoveObjectDelta_4   ;If no move left then branch.                                              ;2    
                                                                                                                   
       DEC    VBLANK,X            ;Decrement the X coordinate.                                               ;6    

MoveObjectDelta_4:                                                                                                                   
       LDA    $9B                 ;Get the direction wanted.                                                 ;3    
       AND    #$10                ;Check for move up.                                                        ;2    
       BNE    MoveObjectDelta_5   ;If no move up then branch.                                                ;2    
       INC    WSYNC,X                                                                                        ;6    

MoveObjectDelta_5:                                                                                                                   
       LDA    $9B                 ;Get direction wanted.                                                     ;3    
       AND    #$20                ;Check for move down.                                                      ;2    
       BNE    MoveObjectDelta_6   ;If no move down the branch.                                               ;2    
                                                                                                                   
       DEC    WSYNC,X             ;Decrement the Y coordinate.                                               ;6    
     
MoveObjectDelta_6:                                                                                                              
       JMP    MoveObjectDelta_2   ;Keep going until delta finished.                                          ;3    
MoveObjectDelta_7:
       RTS                                                                                                   ;6    
                                                                                                                   
                                                                                                                   
;Adjust room for different levels.                                                                                 
AdjustRoomLevel:
       CMP    #$80                ;Is the room number                                                        ;2    
       BCC    AdjustRoomLevel_2   ;      above &80?                                                          ;2    
                                                                                                                   
       SEC                                                                                                   ;2    
       SBC    #$80                ;Remove the &80 flag and                                                   ;2    
       STA    $D8                 ;      store the room number.                                              ;3    
       LDA    $DD                 ;Get the level number.                                                     ;3    
       LSR                        ;Devide it by two.                                                         ;2    
       CLC                                                                                                   ;2    
       ADC    $D8                 ;Add to the original room.                                                 ;3    
       TAY                                                                                                   ;2    
       LDA    RoomDiffs,Y             ;Use as an offset to get the next room.                                    ;4    
AdjustRoomLevel_2:                                                                                                                   
       RTS                                                                                                   ;6    
                                                                                                                   
                                                                                                                   
;Get player-ball collision.                                                                                        
PBCollision:
       CMP    $95                 ;Is it the rist object?                                                    ;3    
       BEQ    PBCollision_2       ;YES - Then Branch.                                                        ;2    
                                                                                                                   
       CMP    $96                 ;Is it the second object?                                                  ;3    
       BEQ    PBCollision_3       ;YES - Then Branch.                                                        ;2    
                                                                                                                   
       LDA    #$00                ;Otherewise nothing.                                                       ;2    
       RTS                                                                                                   ;6    

PBCollision_2:                                                                                                                   
       LDA    CXP0FB              ;Get player00-ball collision.                                              ;3    
       AND    #$40                                                                                           ;2    
       RTS                                                                                                   ;6    
PBCollision_3:                                                                                                                   
       LDA    CXP1FB              ;Get player01-ball collision.                                              ;3    
       AND    #$40                                                                                           ;2    
       RTS                                                                                                   ;6    
                                                                                                                   
                                                                                                                   
;Find which object has hit object wanted. 
FindObjHit:                                                                         
       LDA    CXPPMM              ;Get Player00-Player01                                                     ;3    
       AND    #$80                ;      collision.                                                          ;2    
       BEQ    FindObjHit_2        ;If nothing, Branch.                                                       ;2    
                                                                                                                   
       CPX    $95                 ;Is object 1 the one being hit?                                            ;3    
       BEQ    FindObjHit_3        ;If so, Branch.                                                            ;2    
                                                                                                                   
       CPX    $96                 ;Is object 2 the one being hit?                                            ;3    
       BEQ    FindObjHit_4        ;If so, Branch.                                                            ;2    
FindObjHit_2:                                                                                                                   
       LDA    #$A2                ;Therefore select the other.                                               ;2    
       RTS                                                                                                   ;6    
FindObjHit_3:                                                                                                                   
       LDA    $96                 ;Therefore select the other.                                               ;3    
       RTS                                                                                                   ;6    
FindObjHit_4:                                                                                                                   
       LDA    $95                 ;Therefore select the other.                                               ;3    
       RTS                                                                                                   ;6    
                                                                                                                   
                                                                                                                   
;Move object.
MoveGameObject:                                                                                                      
       JSR    GetLinkedObject     ;Get liked object and movement.                                            ;6    
       LDX    $D5                 ;Get dynamic data address.                                                 ;3    
       LDA    $9B                 ;Get Movement.                                                             ;3    
       BNE    MoveGameObject_2    ;If movement then branch.                                                  ;2    
                                                                                                                   
       LDA    RSYNC,X             ;Use old movement.                                                         ;4    

MoveGameObject_2:                                                                                                                   
       STA    RSYNC,X             ;Stoe the new movement.                                                    ;4    
       LDY    $D4                 ;Get the object's Delta.                                                   ;3    
       JSR    MoveGroundObject     ;Move the object.                                                          ;6    
       RTS                                                                                                   ;6    
                                                                                                                   
                                                                                                                   
;Find liked object and get movement.
GetLinkedObject:                                                                               
       LDA    #$00                ;Set index to zero.                                                        ;2    
       STA    $E1                                                                                            ;3    
GetLinkedObject_2:                                                                                                                   
       LDY    $E1                 ;Get index.                                                                ;3    
       LDA    ($D2),Y             ;Get first object.                                                         ;5    
       TAX                                                                                                   ;2    
       INY                                                                                                   ;2    
       LDA    ($D2),Y             ;Get second object.                                                        ;5    
       TAY                                                                                                   ;2    
       LDA    VSYNC,X             ;Get object1;s room.                                                       ;4    
       CMP.wy $0000,Y             ;Combare with object2's room.                                              ;4    
       BNE    GetLinkedObject_3   ;If not the same room then branch.                                         ;2    
                                                                                                                   
       CPY    $D6                 ;Have we matched the second object                                         ;3    
       BEQ    GetLinkedObject_3   ;      for difficulty (if so, carry on).                                   ;2    
                                                                                                                   
       CPX    $D6                 ;Have we matched the first object                                          ;3    
       BEQ    GetLinkedObject_3   ;      for difficulty (if so, carry on).                                   ;2    
                                                                                                                   
       JSR    GetLinkedObject_4   ;Get object's movement.                                                    ;6    
       RTS                                                                                                   ;6    
GetLinkedObject_3:                                                                                                                   
       INC    $E1                 ;Increment the index.                                                      ;5    
       INC    $E1                                                                                            ;5    
       LDY    $E1                 ;Get the index number.                                                     ;3    
       LDA    ($D2),Y             ;Check for end of sequence.                                                ;5    
       BNE    GetLinkedObject_2   ;If not branch.                                                            ;2    
                                                                                                                   
       LDA    #$00                ;Set no move if no                                                         ;2    
       STA    $9B                 ;      liked object is found.                                              ;3    
       RTS                                                                                                   ;6    
                                                                                                                   
                                                                                                                   
;Work out object's movement.                                                                                       
GetLinkedObject_4:
       LDA    #$FF                ;Set object movement to none.                                              ;2    
       STA    $9B                                                                                            ;3    
                                                                                                                   
       LDA.wy $0000,Y             ;Get oject2's room.                                                        ;4    
       CMP    VSYNC,X             ;Compare it with object's room.                                            ;4    
       BNE    GetLinkedObject_8   ;If not the same, forget it.                                               ;2    
                                                                                                                   
       LDA.wy $0001,Y             ;Get Object2's X coordinate.                                               ;4    
       CMP    VBLANK,X            ;Get Object1;s X coordinate.                                               ;4    
       BCC    GetLinkedObject_5   ;If Object2 to left of Object1 then Branch.                                ;2    
       BEQ    GetLinkedObject_6   ;If Object2 on Object1 then Branch.                                        ;2    
                                                                                                                   
       LDA    $9B                 ;Get Object Movement.                                                      ;3    
       AND    #$7F                ;Signal a move right.                                                      ;2    
       STA    $9B                                                                                            ;3    
       JMP    GetLinkedObject_6   ;Now try Vertical.                                                         ;3    
GetLinkedObject_5:                                                                                                                   
       LDA    $9B                 ;Get object movent.                                                        ;3    
       AND    #$BF                ;Signal a move left.                                                       ;2    
       STA    $9B                                                                                            ;3    

GetLinkedObject_6:                                                                                                                   
       LDA.wy $0002,Y             ;Get Object2's Y Coordinate.                                               ;4    
       CMP    WSYNC,X             ;Get Object1's X Coordinate.                                               ;4    
       BCC    GetLinkedObject_7   ;If Object2 Below Object1 Then Branch.                                     ;2    
       BEQ    GetLinkedObject_8   ;If Object2 on Object1 Then Branch.                                        ;2    
                                                                                                                   
       LDA    $9B                 ;Get Object Movement.                                                      ;3    
       AND    #$EF                ;Signal a move up.                                                         ;2    
       STA    $9B                                                                                            ;3    
       JMP    GetLinkedObject_8   ;Jump to Finish.                                                           ;3    

GetLinkedObject_7:                                                                                                                   
       LDA    $9B                 ;Get Object Movement.                                                      ;3    
       AND    #$DF                ;Signal a move down.                                                       ;2    
       STA    $9B                                                                                            ;3    

GetLinkedObject_8:                                                                                                                   
       LDA    $9B                 ;Get the Move.                                                             ;3    
       RTS                                                                                                   ;6    
                                                                                                                   
                                                                                                                   
;Move the Red Dragon                                                                                               
MoveRedDragon:
       LDA    #<RedDragMatrix                                                                                           ;2    
       STA    $D2                 ;Set the Low address of Object Store.                                      ;3    
       LDA    #>RedDragMatrix                                                                                           ;2    
       STA    $D3                 ;Set the High address of Object Store.                                     ;3    
       LDA    #$03                                                                                           ;2    
       STA    $D4                 ;Set the Dragon's Delta                                                    ;3    
       LDX    #$36                ;Select Dragon #1 : Red                                                    ;2    
       JSR    MoveDragon                                                                                     ;6    
       RTS                                                                                                   ;6    
                                                                                                                   
;Red Dragon Object Matrix                                                                                          
RedDragMatrix:
       .byte $B6,$A4                  ;Sword, Red Dragon                                                           
       .byte $A4,$8A                  ;Red Dragon, Ball                                                            
       .byte $A4,$B9                  ;Red Dragon, Chalise                                                         
       .byte $A4,$C2                  ;Red Dragon, White Key                                                       
       .byte $00                                                                                                   
                                                                                                                   
;Move the Yellow Dragon.                                                                                           
MoveYellowDragon:
       LDA    #<YelDragMatrix                                                                                           ;2    
       STA    $D2                 ;Set the Low Address of Object Store.                                      ;3    
       LDA    #>YelDragMatrix                                                                                           ;2    
       STA    $D3                 ;Set the High Address of Object Store.                                     ;3    
       LDA    #$02                                                                                           ;2    
       STA    $D4                 ;Set the Yellow Dragon's Delta.                                            ;3    
       LDX    #$3F                                                                                           ;2    
       JSR    MoveDragon          ;Select Dragon #2 : Yellow.                                                ;6    
       RTS                                                                                                   ;6    
                                                                                                                   
;Yellow Dragon's Object Matrix                                                                                     
YelDragMatrix:
	 .byte $B6,$A9                  ;Sword, Yellow Dragon                                                        
       .byte $BF,$A9                  ;Yellow Key, Yellow Dragon                                                   
       .byte $A9,$8A                  ;Yellow Dragon, Ball                                                         
       .byte $A9,$B9                  ;Yellow Dragon, Chalise                                                      
       .byte $00                                                                                                   
                                                                                                                   
                                                                                                                   
;Move the Green Dragon                                                                                             
MoveGreenDragon:
       LDA    #<GreenDragonMatrix                                                                                           ;2    
       STA    $D2                 ;Set Low Address of Object Store.                                          ;3    
       LDA    #>GreenDragonMatrix                                                                                           ;2    
       STA    $D3                 ;Set High Address of Object Store.                                         ;3    
       LDA    #$02                                                                                           ;2    
       STA    $D4                 ;Set the Green Dragon's Delta.                                             ;3    
       LDX    #$48                ;Select Dragon #3 : Green                                                  ;2    
       JSR    MoveDragon                                                                                     ;6    
       RTS                                                                                                   ;6    
                                                                                                                   
;Green Dragon's Object Matrix                                                                                      
GreenDragonMatrix:
       .byte $B6,$AE                  ;Sword, Green Dragon                                                         
       .byte $AE,$8A                  ;Green Dragon, Ball                                                          
       .byte $AE,$B9                  ;Green Dragon Chalise                                                        
       .byte $AE,$BC                  ;Green Dragon, Bridge                                                        
       .byte $AE,$B3                  ;Green Dragon, Magnet                                                        
       .byte $AE,$C5                  ;Green Dragon, Black Key                                                     
       .byte $00                                                                                                   
                                                                                                                   
                                                                                                                   
;Move A Dragon
MoveDragon:                                                                                                       
       STX    $A0                 ;Save Object were dealing with.                                            ;3    
       LDA    Store1,X             ;Get the Object's Dynamic Data.                                            ;4    
       TAX                                                                                                   ;2    
       LDA    NUSIZ0,X            ;Get the Object's State.                                                   ;4    
       CMP    #$00                ;Is it in State 00 (Normal #1)                                             ;2    
       BNE    MoveDragon_6        ;Branch if not.                                                            ;2    
                                                                                                                   
;Dragon Normal (State 1)                                                                                           
       LDA    SWCHB               ;Read console switches.                                                    ;4    
       AND    #$80                ;Check for P1 difficulty.                                                  ;2    
       BEQ    MoveDragon_2        ;If Amateur Branch.                                                        ;2    
                                                                                                                   
       LDA    #$00                ;Set Hard - Ignore Nothing                                                 ;2    
       JMP    MoveDragon_3                                                                                   ;3    

MoveDragon_2:                                                                                                                   
       LDA    #$B6                ;Set Easy - Ignore Sword.                                                  ;2    

MoveDragon_3:                                                                                                                   
       STA    $D6                 ;Store Difficulty                                                          ;3    
       STX    $D5                 ;Store Dynamic Data Address.                                               ;3    
       JSR    MoveGameObject                                                                                 ;6    
                                                                                                                   
       LDA    $A0                 ;Get Object                                                                ;3    
       JSR    PBCollision         ;      And get the Player-Ball collision.                                  ;6    
       BEQ    MoveDragon_4        ;If None Then Branch.                                                      ;2    
                                                                                                                   
       LDA    SWCHB               ;Get Console Switched.                                                     ;4    
       ROL                        ;Move P0 difficulty to                                                     ;2    
       ROL                        ;      bit 01 position.                                                    ;2    
       ROL                                                                                                   ;2    
       AND    #$01                ;Mask it out.                                                              ;2    
       ORA    $DD                 ;Merget in the Level Number.                                               ;3    
       TAY                        ;Create Lookup.                                                            ;2    
       LDA    DragonDiff,Y             ;Get New State.                                                            ;4    
       STA    NUSIZ0,X            ;Store as Dragon's State (Open Mouthed).                                   ;4    
       LDA    $E3                                                                                            ;3    
       STA    VBLANK,X            ;Get Temp Ball X Coord and Store as Dragon's.                              ;4    
       LDA    $E4                                                                                            ;3    
       STA    WSYNC,X             ;Get Temp Ball Y Coord and Store as Dragon's                               ;4    
       LDA    #$01                                                                                           ;2    
       STA    $E0                 ;Set Noise Type to 01                                                      ;3    
       LDA    #$10                                                                                           ;2    
       STA    $DF                 ;Set Noise Count to 10 i.e. make roar noise.                               ;3    

MoveDragon_4:                                                                                                                  
       STX    $9A                 ;Store Object's Dynamic Data Address.                                      ;3    
       LDX    $A0                 ;Get the Object Number.                                                    ;3    
       JSR    FindObjHit          ;See if anoher object has hit the dragon.                                  ;6    
       LDX    $9A                 ;Get the Object Address.                                                   ;3    
       CMP    #$51                ;Has the Sword hit the Dragon?                                             ;2    
       BNE    MoveDragon_5        ;If Not, Branch.                                                           ;2    
                                                                                                                   
       LDA    #$01                ;Set the State to 01 (Dead)                                                ;2    
       STA    NUSIZ0,X                                                                                       ;4    
       LDA    #$03                ;Set Sound Three.                                                          ;2    
       STA    $E0                                                                                            ;3    
       LDA    #$10                ;Set a Noise count of &10.                                                 ;2    
       STA    $DF                                                                                            ;3    

MoveDragon_5:                                                                                                                   
       JMP    MoveDragon_9        ;Jump to Finish.                                                           ;3    

MoveDragon_6:                                                                                                                   
       CMP    #$01                ;Is it in State 01 (Dead)                                                  ;2    
       BEQ    MoveDragon_9        ;Branch if So (Return)                                                     ;2    
                                                                                                                   
       CMP    #$02                ;Is it int State 02 (Normal #2)                                            ;2    
       BNE    MoveDragon_7        ;Branch if Not.                                                            ;2    
                                                                                                                   
;Normal Dragon State 2 (Eaten Ball)                                                                                
       LDA    VSYNC,X             ;Get the Dragon's Current Room.                                            ;4    
       STA    $8A                 ;Store as the Ball's Current Room                                          ;3    
       STA    $E2                 ;      and Previous Room.                                                  ;3    
       LDA    VBLANK,X            ;Get the Dragon's X Coordinate.                                            ;4    
       CLC                                                                                                   ;2    
       ADC    #$03                ;Adjust                                                                    ;2    
       STA    $8B                 ;      and store as the ball's X coordinate.                               ;3    
       STA    $E3                 ;      and previous X coordinate.                                          ;3    
       LDA    WSYNC,X             ;Get the Dragon's Y coordinate.                                            ;4    
       SEC                                                                                                   ;2    
       SBC    #$0A                ;Adjust                                                                    ;2    
       STA    $8C                 ;      and store as the ball's Y coordinate.                               ;3    
       STA    $E4                 ;      and the previous Y coordinate.                                      ;3    
       JMP    MoveDragon_9                                                                                   ;3    
                                                                                                                   
                                                                                                                   
;Dragon Roaring.                                                                                                   
MoveDragon_7:
       INC    NUSIZ0,X            ;Increment the Dragon's State.                                             ;6    
       LDA    NUSIZ0,X            ;Get it's State.                                                           ;4    
       CMP    #$FC                ;Is it near the end?                                                       ;2    
       BCC    MoveDragon_9        ;If Not, Branch.                                                           ;2    
                                                                                                                   
       LDA    $A0                 ;Get the Dragon's Number.                                                  ;3    
       JSR    PBCollision         ;Check if the Ball is colliding.                                           ;6    
       BEQ    MoveDragon_9        ;If not, Branch.                                                           ;2    
                                                                                                                   
       LDA    #$02                ;Set the State to State 02 : Eaten                                         ;2    
       STA    NUSIZ0,X                                                                                       ;4    
       LDA    #$02                ;Set noise two.                                                            ;2    
       STA    $E0                                                                                            ;3    
       LDA    #$10                ;Set the Count of Noise to &10.                                            ;2    
       STA    $DF                                                                                            ;3    
       LDA    #$9B                ;Get the Maximum X Coordinate.                                             ;2    
       CMP    VBLANK,X            ;Compare with the Dragon's X Coordinate.                                   ;4    
       BEQ    MoveDragon_8                                                                                          ;2    
       BCS    MoveDragon_8                                                                                          ;2    
                                                                                                                   
       STA    VBLANK,X            ;If too large then Use It.                                                 ;4    

MoveDragon_8:                                                                                                                   
       LDA    #$17                ;Set Minimum Y Coordinate.                                                 ;2    
       CMP    WSYNC,X             ;Compare with the Dragon's Y Coordinate.                                   ;4    
       BCC    MoveDragon_9                                                                                   ;2    
                                                                                                                   
       STA    WSYNC,X             ;If Too Small, set as Dragon's Y coordinate.                               ;4    
MoveDragon_9:                                                                                                                   
       RTS                                                                                                   ;6    
                                                                                                                   
;Dragon Difficulty                                                                                                 
DragonDiff:
       .byte $D0,$E8                  ;Level 1 : Am, Pro                                                           
       .byte $F0,$F6                  ;Level 2 : Am, Pro                                                           
       .byte $F0,$F6                  ;Level 3 : Am, Pro                                                           
                                                                                                                   
;Move Bat                                                                                                          
MoveBat:
       INC    $CF                 ;Put Bat in the Next State.                                                ;5    
       LDA    $CF                 ;Get the Bat State.                                                        ;3    
       CMP    #$08                ;Has it Reached the Maximum?                                               ;2    
       BNE    MoveBat_2                                                                                      ;2    
                                                                                                                   
       LDA    #$00                ;If So, Reset the Bat State.                                               ;2    
       STA    $CF                                                                                            ;3    
MoveBat_2:                                                                                                                  
       LDA    $D1                 ;Get the Bat Fed-Up Value.                                                 ;3    
       BEQ    MoveBat_3           ;If Bat Fed-Up then Branch.                                                ;2    
                                                                                                                   
       INC    $D1                 ;Increment its value for next time.                                        ;5    
       LDA    $CE                 ;Get the Bat's Movement.                                                   ;3    
       LDX    #$CB                ;Position to Bat.                                                          ;2    
       LDY    #$03                ;Get the Bat's Deltas.                                                     ;2    
       JSR    MoveGroundObject    ;Move the Bat.                                                             ;6    
       JMP    MoveBat_4           ;Update the Bat's Object.                                                  ;3    
                                                                                                                   
;Bat Fed-Up 
MoveBat_3:                                                                                                       
       LDA    #$CB                ;Store the Bat's Dynamic Data Address                                      ;2    
       STA    $D5                                                                                            ;3    
       LDA    #$03                ;Set the Bat's Delta.                                                      ;2    
       STA    $D4                                                                                            ;3    
       LDA    #<BatMatrix         ;Set the Low Address of Object Store.                                      ;2    
       STA    $D2                                                                                            ;3    
       LDA    #>BatMatrix         ;Set the High Address of Object Store.                                     ;2    
       STA    $D3                                                                                            ;3    
       LDA    $D0                 ;Get Object being Carried by Bat,                                          ;3    
       STA    $D6                 ;      And Copy.                                                           ;3    
       JSR    MoveGameObject      ;Move the Bat.                                                             ;6    
                                                                                                                   
       LDY    $E1                 ;Get Object Liked Index.                                                   ;3    
       LDA    ($D2),Y             ;Look up the Object Found in the Table.                                    ;5    
       BEQ    MoveBat_4           ;If nothing found then Forget it.                                          ;2    
                                                                                                                   
       INY                                                                                                   ;2    
       LDA    ($D2),Y             ;Get the Object Wanted.                                                    ;5    
       TAX                                                                                                   ;2    
       LDA    VSYNC,X             ;Get the Object's Room.                                                    ;4    
       CMP    $CB                 ;Is it the Same as the Bats?                                               ;3    
       BNE    MoveBat_4           ;If not Forget it.                                                         ;2    
                                                                                                                   
;See if Bat Can pick up Object.                                                                                    
       LDA    VBLANK,X            ;Get the Object's X Coordinate.                                            ;4    
       SEC                                                                                                   ;2    
       SBC    $CC                 ;Find the differenct with the Bat's                                        ;3    
       CLC                        ;X coordinate.                                                             ;2    
       ADC    #$04                ;Adjust so Bat in middle of object.                                        ;2    
       AND    #$F8                ;Is Bat within Seven Pixels?                                               ;2    
       BNE    MoveBat_4           ;If not, no pickup possible.                                               ;2    
                                                                                                                   
       LDA    WSYNC,X             ;Get the Object's Y Coordinate.                                            ;4    
       SEC                                                                                                   ;2    
       SBC    $CD                 ;Find the Difference with the Bat's                                        ;3    
       CLC                        ;      Y Coordinate.                                                       ;2    
       ADC    #$04                ;Adjust.                                                                   ;2    
       AND    #$F8                ;Is the Bat within Seven Pixels?                                           ;2    
       BNE    MoveBat_4           ;If not, No Pickup Possible.                                               ;2    
                                                                                                                   
;Get Object                                                                                                        
       STX    $D0                 ;Store Object as Being Carried.                                            ;3    
       LDA    #$10                ;Reset the Bat Fed Up Time.                                                ;2    
       STA    $D1                                                                                            ;3    
                                                                                                                   
;Move Object Being Carried by Bat.                                                                                 
MoveBat_4:
       LDX    $D0                 ;Get Object Being Carried by Bat.                                          ;3    
       LDA    $CB                 ;Get the Bat's Room.                                                       ;3    
       STA    VSYNC,X             ;Store this as the Object's Room.                                          ;4    
       LDA    $CC                 ;Get the Bat's X coordinate.                                               ;3    
       CLC                                                                                                   ;2    
       ADC    #$08                ;Adjust to the Right.                                                      ;2    
       STA    VBLANK,X            ;Make it the Object's X coordinate.                                        ;4    
       LDA    $CD                 ;Get the Bat's Y Coordinate.                                               ;3    
       STA    WSYNC,X             ;Store it as the Object's Y Coordinate.                                    ;4    
       LDA    $D0                 ;Get the Object Being Carried by the Bat.                                  ;3    
       LDY    $9D                 ;Get the Object Being Carried by the Ball.                                 ;3    
       CMP    Store1,Y             ;Are the the Same?                                                         ;4    
       BNE    MoveBat_5           ;If not Branch.                                                            ;2    
                                                                                                                   
       LDA    #$A2                ;Set Nothing Being                                                         ;2    
       STA    $9D                 ;      Carried.                                                            ;3    
MoveBat_5:                                                                                                                   
       RTS                                                                                                   ;6    
                                                                                                                   
                                                                                                                   
;Bat Object Matrix.
BatMatrix:                                                                                                
       .byte $CB,$B9                  ;Bat,Chalise                                                                 
       .byte $CB,$B6                  ;Bat,Sword                                                                   
       .byte $CB,$BC                  ;Bat,Bridge                                                                  
       .byte $CB,$BF                  ;Bat,Yellow Key                                                              
       .byte $CB,$C2                  ;Bat,White Key                                                               
       .byte $CB,$C5                  ;Bat,Black Key                                                               
       .byte $CB,$A4                  ;Bat,Red Dragon                                                              
       .byte $CB,$A9                  ;Bat,Yellow Dragon                                                           
       .byte $CB,$AE                  ;Bat,Green Dragon                                                            
       .byte $CB,$B3                  ;Bat,Magnet                                                                  
       .byte $00                                                                                                   
                                                                                                                   
                                                                                                                   
;Deal with Portcullis and Collisions.    
Portals:                                                                          
       LDY    #$02                ;For Each Portcullis.                                                      ;2    
Portals_2:
       LDX    PortOffsets,Y             ;Get the Portcullises offset number.                                       ;4    
       JSR    FindObjHit          ;See if an Object Collided with it.                                        ;6    
       STA    $97                 ;      Store that Object.                                                  ;3    
       CMP    KeyOffsets,Y             ;Is it the Associated Key?                                                 ;4    
       BNE    Portals_3           ;If not then Branch.                                                       ;2    
                                                                                                                   
       TYA                        ;Get the Portcullis Number                                                 ;2    
       TAX                                                                                                   ;2    
       INC    $C8,X               ;Change it's state to open it.                                             ;6    
Portals_3:                                                                                                                   
       TYA                        ;Get the Porcullis number.                                                 ;2    
       TAX                                                                                                   ;2    
       LDA    $C8,X               ;Get the State.                                                            ;4    
       CMP    #$1C                ;Is it Closed?                                                             ;2    
       BEQ    Portals_7           ;Yes - then Branch.                                                        ;2    
                                                                                                                   
       LDA    PortOffsets,Y             ;Get Portcullis number.                                                    ;4    
       JSR    PBCollision         ;Get the Player-Ball Collision.                                            ;6    
       BEQ    Portals_4           ;If Not Then Branch.                                                      ;2    
                                                                                                                   
       LDA    #$01                ;Set the Portcullis to Closed.                                             ;2    
       STA    $C8,X                                                                                          ;4    
       LDX    #$8A                ;Set to the Castle.                                                        ;2    
       JMP    Portals_6           ;Put the Ball in the Castle.                                               ;3    

Portals_4:                                                                                                                   
       LDA    $97                 ;Get the Object that hit the Portcullis.                                   ;3    
       CMP    #$A2                ;Is it nothing?                                                            ;2    
       BEQ    Portals_5           ;If so, Branch.                                                            ;2    
                                                                                                                   
       LDX    $97                 ;Get Object.                                                               ;3    
       STY    $9A                 ;Save Y                                                                    ;3    
       JSR    GetObjectAddress    ;And find it's Dynamic Address.                                            ;6    
       LDY    $9A                 ;Retrieve Y                                                                ;3    
       LDX    $93                 ;Get Object's Address.                                                     ;3    
       JMP    Portals_6           ;Put Object In the Castle.                                                 ;3    
     
Portals_5:                                                                                                              
       JMP    Portals_7                                                                                      ;3    

Portals_6:                                                                                                                   
       LDA    EntryRoomOffsets,Y ;Look up Castle endry room for this port.                                        ;4    
       STA    VSYNC,X       ;Make it the object's Room.                                                      ;4    
       LDA    #$10          ;Give the Object a new Y coordinate.                                             ;2    
       STA    WSYNC,X                                                                                        ;4    
Portals_7:                                                                                                                   
       TYA                  ;Get the Portcullis number.                                                      ;2    
       TAX                                                                                                   ;2    
       LDA    $C8,X         ;Get its State.                                                                  ;4    
       CMP    #$01          ;Is it Open?                                                                     ;2    
       BEQ    Portals_8     ;Yes - Then Branch.                                                              ;2    
                                                                                                                   
       CMP    #$1C          ;Is it Closed?                                                                   ;2    
       BEQ    Portals_8     ;Yes - Then Branch.                                                              ;2    
                                                                                                                   
       INC    $C8,X         ;Increment it's State.                                                           ;6    
       LDA    $C8,X         ;Get the State.                                                                  ;4    
       CMP    #$38          ;Has it reached the maximum state.                                               ;2    
       BNE    Portals_8     ;If not, Branch.                                                                 ;2    
                                                                                                                   
       LDA    #$01          ;Set to Closed                                                                   ;2    
       STA    $C8,X         ;      State.                                                                    ;4    

Portals_8:                                                                                                                   
       DEY                  ;Goto the next portcullis.                                                       ;2    
       BMI    Portals_9     ;Branch if Finished.                                                             ;2    
       JMP    Portals_2     ;Do next Protcullis.                                                             ;3    
Portals_9:
       RTS                                                                                                   ;6    



                                                                                                                   
;Portcullis #1, #2, #3
PortOffsets:                                                                                             
	 .byte $09,$12,$1B                                                                                           
                                                                                                                   
;Keys #1, #2, #3  (Yellow, White, Black)                                                                           
KeyOffsets:
	 .byte $63,$6C,$75                                                                                           
                                                                                                                   
;Castle Entry Rooms (Yellow, White, Black)
EntryRoomOffsets:                                                                         
	 .byte $12,$1A,$1B                                                                                           
                                                                                                                   
;Castle Rooms (Yellow, White, Black)                                                                               
CastleRoomOffsets:
	 .byte $11,$0F,$10                                                                                           
                                                                                                                   
                                                                                                                   
;Deal With Magnet.                                                                                                 
Mag_1: 
	 LDA    $B5                 ;Get Magnet's Y Coordinate.                                                ;3    
       SEC                                                                                                   ;2    
       SBC    #$08                ;Adjust to it's "Poles".                                                   ;2    
       STA    $B5                                                                                            ;3    
       LDA    #$00                ;Con Difficulty!                                                           ;2    
       STA    $D6                                                                                            ;3    
       LDA    #<MagnetMatrix                ;Set Low Address of Object Store.                                          ;2    
       STA    $D2                                                                                            ;3    
       LDA    #>MagnetMatrix                ;Set High Address of Object Store.                                         ;2    
       STA    $D3                                                                                            ;3    
       JSR    GetLinkedObject     ;Get Liked Object and Set Movement.                                        ;6    
       LDA    $9B                 ;Get Movement.                                                             ;3    
       BEQ    Mag_2               ;If None, then Forget It.                                                  ;2    
                                                                                                                   
       LDY    #$01                ;Set Delta to One.                                                         ;2    
       JSR    MoveGroundObject     ;Move Object.                                                              ;6    
                                                                                                                   
Mag_2: 
	 LDA    $B5                 ;Reset the Magnet's                                                        ;3    
       CLC                        ;      Y Coordinate.                                                       ;2    
       ADC    #$08                                                                                           ;2    
       STA    $B5                                                                                            ;3    
       RTS                                                                                                   ;6    
                                                                                                                   
;Magnet Object Matrix.                                                                                             
MagnetMatrix:
       .byte $BF,$B3                  ;Yellow Key, Magnet                                                          
       .byte $C2,$B3                  ;White Key, Magnet                                                           
       .byte $C5,$B3                  ;Black Key, Magnet                                                           
       .byte $B6,$B3                  ;Sword, Magnet                                                               
       .byte $BC,$B3                  ;Bridge, Magnet                                                              
       .byte $B9,$B3                  ;Chalise, Magnet                                                             
       .byte $00                                                                                                   
                                                                                                                   
                                                                                                                   
                                                                                                                   
;Deal with Invisible Surround Moving.                                                                              
Surround: 
	 LDA    $8A                 ;Get the Current Room.                                                     ;3    
       JSR    RoomNumToAddress    ;Convert it to an Address.                                                 ;6    
       LDY    #$02                                                                                           ;2    
       LDA    ($93),Y             ;Get the Room's Color.                                                     ;5    
       CMP    #$08                ;Is it Invisible?                                                          ;2    
       BEQ    Surround_2          ;If So Branch.                                                             ;2    
                                                                                                                   
       LDA    #$00                ;If not, signal the                                                        ;2    
       STA    $DB                 ;      Invisible surround not                                              ;3    
       JMP    Surround_4          ;      Wanted.                                                             ;3    

Surround_2:                                                                                                                   
       LDA    $8A                 ;Get the Current Room.                                                     ;3    
       STA    $D9                 ;And store as the Invisible Surrounds.                                     ;3    
       LDA    $8B                 ;Get the Ball's X Coordinate.                                              ;3    
       SEC                                                                                                   ;2    
       SBC    #$0E                ;Adjust for Surround,                                                      ;2    
       STA    $DA                 ;      and store as surround's X coordinate.                               ;3    
       LDA    $8C                 ;Get the Ball's Y Coordinate.                                              ;3    
       CLC                                                                                                   ;2    
       ADC    #$0E                ;Adjust for Surround.                                                      ;2    
       STA    $DB                 ;      and store as surround's Y coordinate.                               ;3    
       LDA    $DA                 ;Get the Surround's X cordinate.                                           ;3    
       CMP    #$F0                ;Is it close to the right edge?                                            ;2    
       BCC    Surround_3          ;Branch if not.                                                            ;2    
                                                                                                                   
       LDA    #$01                ;Flick surround to the                                                     ;2    
       STA    $DA                 ;      otherside of the screen.                                            ;3    
       JMP    Surround_4                                                                                     ;3    

Surround_3:                                                                                                                   
       CMP    #$82                ;???                                                                       ;2    
       BCC    Surround_4          ;???                                                                       ;2    
                                                                                                                   
       LDA    #$81                ;???                                                                       ;2    
       STA    $DA                 ;???                                                                       ;3    
Surround_4:
       RTS                                                                                                   ;6    
                                                                                                                   
                                                                                                                   
;Make A Noise.                                                                                                     
MakeSound:
	 LDA    $DF                 ;Check Not Count.                                                          ;3    
       BNE    MakeSound_2         ;Branch if Noise to be made.                                               ;2    
                                                                                                                   
       STA    AUDV0               ;Turn off the Volume.                                                      ;3    
       STA    AUDV1                                                                                          ;3    
       RTS                                                                                                   ;6    

MakeSound_2:                                                                                                                   
       DEC    $DF                 ;Goto the Next Note.                                                       ;5    
       LDA    $E0                 ;Get the Noise Type.                                                       ;3    
       BEQ    NoiseGameOver       ;Game Over                                                                 ;2    
                                                                                                                   
       CMP    #$01                ;Roar                                                                      ;2    
       BEQ    NoiseRoar                                                                                      ;2    
                                                                                                                   
       CMP    #$02                ;Man Eaten.                                                                ;2    
       BEQ    EatenNoise                                                                                     ;2    
                                                                                                                   
       CMP    #$03                ;Dying Dragon.                                                             ;2    
       BEQ    DragDieNoise                                                                                   ;2    
                                                                                                                   
       CMP    #$04                ;Dropping Object.                                                          ;2    
       BEQ    NoiseDropObject                                                                                          ;2    
                                                                                                                   
       CMP    #$05                ;Picking up Object.                                                        ;2    
       BEQ    NoiseGetObject                                                                                          ;2    
                                                                                                                   
       RTS                                                                                                   ;6    
                                                                                                                   
                                                                                                                   
;Noise 0 : Game Over                                                                                               
NoiseGameOver:
       LDA    $DF                                                                                            ;3    
       STA    COLUPF              ;Color-Luminance Playfield.                                                ;3    
       STA    AUDC0               ;Audio-Control 00                                                          ;3    
       LSR                                                                                                   ;2    
       STA    AUDV0               ;Audio-Volume 00                                                           ;3    
       LSR                                                                                                   ;2    
       LSR                                                                                                   ;2    
       STA    AUDF0               ;Audio-Frequency 00                                                        ;3    
       RTS                                                                                                   ;6    
                                                                                                                   
;Noise 1 : Roar                                                                                                    
NoiseRoar:
       LDA    $DF                 ;Get noise count.                                                          ;3    
       LSR                                                                                                   ;2    
       LDA    #$03                ;If it was even then                                                       ;2    
       BCS    SetVolume           ;Branch.                                                                   ;2    
                                                                                                                   
       LDA    #$08                ;Get a differnt audio control value.                                       ;2    

SetVolume:                                                                                                                   
       STA    AUDC0               ;Set Audio Control 00.                                                     ;3    
       LDA    $DF                 ;Set the Volume to the Noise Count.                                        ;3    
       STA    AUDV0                                                                                          ;3    
       LSR                        ;Divide by Four.                                                           ;2    
       LSR                                                                                                   ;2    
       CLC                                                                                                   ;2    
       ADC    #$1C                ;Set the Frequency.                                                        ;2    
       STA    AUDF0                                                                                          ;3    
       RTS                                                                                                   ;6    
                                                                                                                   
                                                                                                                   
;Noise 2 : Man Eaten                                                                                               
EatenNoise:
       LDA    #$06                                                                                           ;2    
       STA    AUDC0               ;Audio-Control 00                                                          ;3    
       LDA    $DF                                                                                            ;3    
       EOR    #$0F                                                                                           ;2    
       STA    AUDF0               ;Audio-Frequency 00                                                        ;3    
       LDA    $DF                                                                                            ;3    
       LSR                                                                                                   ;2    
       CLC                                                                                                   ;2    
       ADC    #$08                                                                                           ;2    
       STA    AUDV0               ;Audio-Volume 00                                                           ;3    
       RTS                                                                                                   ;6    
                                                                                                                   
                                                                                                                   
;Noise 3 : Dyning Dragon                                                                                           
DragDieNoise:
       LDA    #$04                ;Set the Audio Control                                                     ;2    
       STA    AUDC0                                                                                          ;3    
       LDA    $DF                 ;Put the Note Count In                                                     ;3    
       STA    AUDV0               ;      the Volume.                                                         ;3    
       EOR    #$1F                                                                                           ;2    
       STA    AUDF0               ;Flip the Count as store                                                   ;3    
       RTS                        ;      as the frequency.                                                   ;6    
                                                                                                                   
                                                                                                                   
;Noise 4 : Dropping Object.                                                                                        
NoiseDropObject:
       LDA    $DF                 ;Get Not Count                                                             ;3    
       EOR    #$03                ;Reverse it as noise does up.                                              ;2    
NoiseDropObject_2:
       STA    AUDF0               ;Store in Frequency for Channel 00.                                        ;3    
       LDA    #$05                                                                                           ;2    
       STA    AUDV0               ;Set Volume on Channel 00.                                                 ;3    
       LDA    #$06                                                                                           ;2    
       STA    AUDC0               ;Set a Noise on Channel 00.                                                ;3    
       RTS                                                                                                   ;6    
                                                                                                                   
                                                                                                                   
;Noise 5 : Picking up an Object.                                                                                   
NoiseGetObject:
       LDA    $DF                 ;Get Not Count.                                                            ;3    
       JMP    NoiseDropObject_2   ;      and Make Same noise as Drop.                                        ;3    
                                                                                                                   
                                                                                                                   
;Left of Name Room                                                                                                 
LeftOfName:
       .byte $F0,$FF,$FF          ;XXXXXXXXXXXXXXXXXXXXRRRRRRRRRRRRRRRRRRRRRRRR                                  
       .byte $00,$00,$00                                                                                           
       .byte $00,$00,$00                                                                                           
       .byte $00,$00,$00                                                                                           
       .byte $00,$00,$00                                                                                           
       .byte $00,$00,$00                                                                                           

;Below Yellow Castle                                                                                               
BelowYellowCastle:
       .byte $F0,$FF,$0F          ;XXXXXXXXXXXXXXXX        RRRRRRRRRRRRRRRRRRRR   **Line Shared With Above Room ----^                               
       .byte $00,$00,$00                                                                                           
       .byte $00,$00,$00                                                                                           
       .byte $00,$00,$00                                                                                           
       .byte $00,$00,$00                                                                                           
       .byte $00,$00,$00                                                                                           
       .byte $F0,$FF,$FF          ;XXXXXXXXXXXXXXXXXXXXRRRRRRRRRRRRRRRRRRRRRRRR                                  
                                                                                                                   
                                                                                                                   
;Side Corridor                                                                                                     
SideCorridor:
       .byte $F0,$FF,$0F          ;XXXXXXXXXXXXXXXX        RRRRRRRRRRRRRRRR                                      
       .byte $00,$00,$00                                                                                           
       .byte $00,$00,$00                                                                                           
       .byte $00,$00,$00                                                                                           
       .byte $00,$00,$00                                                                                           
       .byte $00,$00,$00                                                                                           
       .byte $F0,$FF,$0F          ;XXXXXXXXXXXXXXXX        RRRRRRRRRRRRRRRR                                      
                                                                                                                   
                                                                                                                   
;Number Room Definition                                                                                            
NumberRoom:
       .byte $F0,$FF,$FF          ;XXXXXXXXXXXXXXXXXXXXRRRRRRRRRRRRRRRRRRRR                                      
       .byte $30,$00,$00          ;XX                                    RR                                      
       .byte $30,$00,$00          ;XX                                    RR                                      
       .byte $30,$00,$00          ;XX                                    RR                                      
       .byte $30,$00,$00          ;XX                                    RR                                      
       .byte $30,$00,$00          ;XX                                    RR                                      
       .byte $F0,$FF,$0F          ;XXXXXXXXXXXXXXXXXXXXRRRRRRRRRRRRRRRRRRRR                                      
                                                                                                                   
                                                                                                                   
;Object #1 States (Portcullis)                                                                                     
PortStates:
       .byte $04,<GfxPort07,>GfxPort07          ;State 04 at FB24 -Open                                                        
       .byte $08,<GfxPort06,>GfxPort06          ;State 08 at FB22                                                              
       .byte $0C,<GfxPort05,>GfxPort05          ;State 0C at FB20                                                              
       .byte $10,<GfxPort04,>GfxPort04          ;State 10 at FB1E                                                              
       .byte $14,<GfxPort03,>GfxPort03          ;State 14 at FB1C                                                             
       .byte $18,<GfxPort02,>GfxPort02          ;State 18 at FB1A                                                              
LFB03: .byte $1C,<GfxPort01,>GfxPort01          ;State 1C at FB18 -Closed                                               
       .byte $20,<GfxPort02,>GfxPort02          ;State 20 at FB1A                                                              
       .byte $24,<GfxPort03,>GfxPort03          ;State 24 at FB1C                                                              
       .byte $28,<GfxPort04,>GfxPort04          ;State 28 at FB1E                                                              
       .byte $2C,<GfxPort05,>GfxPort05          ;State 2C at FB20                                                              
       .byte $30,<GfxPort06,>GfxPort06          ;State 30 at FB22                                                              
LFB15: .byte $FF,<GfxPort07,>GfxPort07          ;State FF at FB24 -Open                                                        
                                                                                                                   
                                                                                                                   
;Object #1 States 940FF (Graphic)                                                                                  
GfxPort01:
       .byte $FE                  ;XXXXXXX                                                                   
       .byte $AA                  ;X X X X                                                                   
GfxPort02:
       .byte $FE                  ;XXXXXXX                                                                   
       .byte $AA                  ;X X X X                                                                   
GfxPort03:
       .byte $FE                  ;XXXXXXX                                                                   
       .byte $AA                  ;X X X X                                                                   
GfxPort04:
       .byte $FE                  ;XXXXXXX                                                                   
       .byte $AA                  ;X X X X                                                                   
GfxPort05:
       .byte $FE                  ;XXXXXXX                                                                   
       .byte $AA                  ;X X X X                                                                   
GfxPort06:
       .byte $FE                  ;XXXXXXX                                                                   
       .byte $AA                  ;X X X X                                                                   
GfxPort07:
       .byte $FE                  ;XXXXXXX                                                                   
       .byte $AA                  ;X X X X                                                                   
GfxPort08:
       .byte $FE                  ;XXXXXXX                                                                   
       .byte $AA                  ;X X X X                                                                   
GfxPort09:
       .byte $00                                                                                                   
                                                                                                                   
;Two Exit Room                                                                                                     
TwoExitRoom:
       .byte $F0,$FF,$0F          ;XXXXXXXXXXXXXXXX        RRRRRRRRRRRRRRRR                                      
       .byte $30,$00,$00          ;XX                                    RR                                      
       .byte $30,$00,$00          ;XX                                    RR                                      
       .byte $30,$00,$00          ;XX                                    RR                                      
       .byte $30,$00,$00          ;XX                                    RR                                      
       .byte $30,$00,$00          ;XX                                    RR                                      
       .byte $F0,$FF,$0F          ;XXXXXXXXXXXXXXXX        RRRRRRRRRRRRRRRR                                      
                                                                                                                   
                                                                                                                   
;Top of Blue Maze                                                                                                  
BlueMazeTop:
       .byte $F0,$FF,$0F          ;XXXXXXXXXXXXXXXX        RRRRRRRRRRRRRRRR                                      
       .byte $00,$0C,$0C          ;        XX    XX        RR    RR                                              
       .byte $F0,$0C,$3C          ;XXXX    XX    XXXX    RRRR    RR    RRRR                                      
       .byte $F0,$0C,$00          ;XXXX    XX                    RR    RRRR                                      
       .byte $F0,$FF,$3F          ;XXXXXXXXXXXXXXXXXX    RRRRRRRRRRRRRRRRRR                                      
       .byte $00,$30,$30          ;      XX        XX    RR        RR                                            
       .byte $F0,$33,$3F          ;XXXX  XX  XXXXXXXX    RRRRRRRR  RR  RRRR                                      
                                                                                                                 
;Blue Maze #1                                                                                                      
BlueMaze1:
       .byte $F0,$FF,$FF          ;XXXXXXXXXXXXXXXXXXXXRRRRRRRRRRRRRRRRRRRR                                      
       .byte $00,$00,$00          ;                                                                              
       .byte $F0,$FC,$FF          ;XXXXXXXXXX  XXXXXXXXRRRRRRRR  RRRRRRRRRR                                      
       .byte $F0,$00,$C0          ;XXXX              XXRR              RRRR                                      
       .byte $F0,$3F,$CF          ;XXXX  XXXXXXXXXX  XXRR  RRRRRRRRRR  RRRR                                      
       .byte $00,$30,$CC          ;      XX      XX  XXRR  RR      RR                                            
       .byte $F0,$F3,$CC          ;XXXXXXXX  XX  XX  XXRR  RR  RR  RRRRRRRR                                      
                                                                                                                   
;Bottom of Blue Maze                                                                                               
BlueMazeBottom:
       .byte $F0,$F3,$0C          ;XXXXXXXX  XX  XX        RR  RR  RRRRRRRR                                      
       .byte $00,$30,$0C          ;      XX      XX        RR      RR                                           
       .byte $F0,$3F,$0F          ;XXXX  XXXXXXXXXX        RRRRRRRRRR  RRRR                                      
       .byte $F0,$00,$00          ;XXXX                                RRRR                                      
       .byte $F0,$F0,$00          ;XXXXXXXX                        RRRRRRRR                                      
       .byte $00,$30,$00          ;      XX                        RR                                            
       .byte $F0,$FF,$FF          ;XXXXXXXXXXXXXXXXXXXXRRRRRRRRRRRRRRRRRRRR                                      
                                                                                                                   
;Center of Blue Maze                                                                                               
BlueMazeCenter:
       .byte $F0,$33,$3F          ;XXXX  XX  XXXXXXXX    RRRRRRRR  RR  RRRR                                      
       .byte $00,$30,$3C          ;      XX      XXXX    RRRR      RR                                            
       .byte $F0,$FF,$3C          ;XXXXXXXXXXXX  XXXX    RRRR  RRRRRRRRRRRR                                      
       .byte $00,$03,$3C          ;          XX  XXXX    RRRR  RR                                                
       .byte $F0,$33,$3C          ;XXXX  XX  XX  XXXX    RRRR  RR  RR  RRRR                                      
       .byte $00,$33,$0C          ;      XX  XX  XX        RR  RR  RR                                            
       .byte $F0,$F3,$0C          ;XXXXXXXX  XX  XX        RR  RR  RRRRRRRR                                      
                                                                                                                   
;Blue Maze Entry                                                                                                   
BlueMazeEntry:
       .byte $F0,$F3,$CC          ;XXXXXXXX  XX  XX  XXRR  RR  RR  RRRRRRRR                                      
       .byte $00,$33,$0C          ;      XX  XX  XX        RR  RR  RR                                            
       .byte $F0,$33,$FC          ;XXXX  XX  XX  XXXXXXRRRRRR  RR  RR  RRRR                                      
       .byte $00,$33,$00          ;      XX  XX                RR  RR                                            
       .byte $F0,$F3,$FF          ;XXXXXXXX  XXXXXXXXXXRRRRRRRRRR  RRRRRRRR                                      
       .byte $00,$00,$00          ;                                                                              
       .byte $F0,$FF,$0F          ;XXXXXXXXXXXXXXXX        RRRRRRRRRRRRRRRR                                      
                                                                                                                   
;Maze Middle                                                                                                       
MazeMiddle:
       .byte $F0,$FF,$CC          ;XXXXXXXXXXXX  XX  XXRR  RR  RRRRRRRRRRRR                                      
       .byte $00,$00,$CC          ;              XX  XXRR  RR                                                    
       .byte $F0,$03,$CF          ;XXXX      XXXXXX  XXRR  RRRRRR      RRRR                                      
       .byte $00,$03,$00          ;          XX                RR                                                
       .byte $F0,$F3,$FC          ;XXXXXXXX  XX  XXXXXXRRRRRR  RR  RRRRRRRR                                     
       .byte $00,$33,$0C          ;      XX  XX  XX        RR  RR  RR                                            

;Maze Side 
MazeSide:                                                                                                        
       .byte $F0,$33,$CC          ;XXXX  XX  XX  XX  XXRR  RR  RR  RR  RRRR     **Line Shared With Above Room ----^                                         
       .byte $00,$30,$CC          ;      XX      XX  XXRR  RR      RR                                            
       .byte $00,$3F,$CF          ;      XXXXXX  XX  XXRR  RR  RRRRRR                                            
       .byte $00,$00,$C0          ;                  XXRR                                                        
       .byte $00,$3F,$C3          ;      XXXXXXXX    XXRR    RRRRRRRR                                            
       .byte $00,$30,$C0          ;      XX          XXRR          RR                                            
       .byte $F0,$FF,$FF          ;XXXXXXXXXXXXXXXXXXXXRRRRRRRRRRRRRRRRRRRR                                      
                                                                                                                   
;Maze Entry                                                                                                        
MazeEntry:
       .byte $F0,$FF,$0F          ;XXXXXXXXXXXXXXXX        RRRRRRRRRRRRRRRR                                      
       .byte $00,$30,$00          ;      XX                        RR                                            
       .byte $F0,$30,$FF          ;XXXX  XX    XXXXXXXXRRRRRRRRR   RR  RRRR                                      
       .byte $00,$30,$C0          ;      XX          XXRR          RR                                            
       .byte $F0,$F3,$C0          ;XXXXXXXX  XX      XXRR      RR  RRRRRRRR                                      
       .byte $00,$03,$C0          ;          XX      XXRR      RR                                                
       .byte $F0,$FF,$CC          ;XXXXXXXXXXXX  XX  XXRR  RR  RRRRRRRRRRRR                                      
                                                                                                                   
;Castle Definition                                                                                                 
CastleDef:
       .byte $F0,$FE,$15          ;XXXXXXXXXXX X X X      R R R RRRRRRRRRRR                                      
       .byte $30,$03,$1F          ;XX        XXXXXXX      RRRRRRR        RR                                      
       .byte $30,$03,$FF          ;XX        XXXXXXXXXXRRRRRRRRRR        RR                                      
       .byte $30,$00,$FF          ;XX          XXXXXXXXRRRRRRRR          RR                                      
       .byte $30,$00,$3F          ;XX          XXXXXX    RRRRRR          RR                                      
       .byte $30,$00,$00          ;XX                                    RR                                      
       .byte $F0,$FF,$0F          ;XXXXXXXXXXXXXX            RRRRRRRRRRRRRR                                      
                                                                                                                   
;Object Data                                                                                                       
;Offset 0 : Room number of object.                                                                                 
;Offset 1 : X Coordinate of object.                                                                                
;Offset 2 : Y Coordinate of object.                                                                                
                                                                                                                   
;Object #1 : Portcullis                                                                                            
PortInfo1:
       .byte $11,$4D,$31          ;Room 11, (4D, 31)                                                             
;Object #2 : Portcullis                                                                                          
PortInfo2:
       .byte $0F,$4D,$31          ;Room 0F, (4D, 31)                                                             
;Object #3 : Portcullis                                                                                           
PortInfo3:
       .byte $10,$4D,$31          ;Room 10, (4D, 31                                                              
                                                                                                                   
;Object #0 : State                                                                                                 
SurroundCurr:
       .byte $00                                                                                                   
                                                                                                                   
;Object #1 : State List                                                                                            
SurroundStates:
       .byte $FF,<GfxSurround,>GfxSurround          ;State FF as FC05                                                              
                                                                                                                   
;Object #1 : Graphic                                                                                               
GfxSurround:
       .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 $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 $00                                                                                                   
                                                                                                                   
;Red Maze #1                                                                                                       
RedMaze1:
       .byte $F0,$FF,$FF          ;XXXXXXXXXXXXXXXXXXXXRRRRRRRRRRRRRRRRRRRR                                      
       .byte $00,$00,$00          ;                                                                              
       .byte $F0,$FF,$0F          ;XXXXXXXXXXXXXXXX        RRRRRRRRRRRRRRRR                                      
       .byte $00,$00,$0C          ;                  XX        RR                                                
       .byte $F0,$FF,$0C          ;XXXXXXXXXXXX  XX        RR  RRRRRRRRRRRR                                      
       .byte $F0,$03,$CC          ;XXXX      XX  XX  XXRR  RR  RR      RRRR                                      

;Bottom of Red Maze                                                                                                
RedMazeBottom:
       .byte $F0,$33,$CF          ;XXXX  XX  XXXXXX  XXRR  RRRRRR  RR  RRRR     **Line Shared With Above Room ----^  
       .byte $F0,$30,$00          ;XXXX  XX                        RR  RRRR                                      
       .byte $F0,$33,$FF          ;XXXX  XX  XXXXXXXXXXRRRRRRRRRR  RR  RRRR                                      
       .byte $00,$33,$00          ;      XX  XX                RR  RR  RRRR                                      
       .byte $F0,$FF,$00          ;XXXXXXXXXXXX                RRRRRRRRRRRR                                      
       .byte $00,$00,$00          ;                                                                              
       .byte $F0,$FF,$0F          ;XXXXXXXXXXXXXXXX        RRRRRRRRRRRRRRRR                                      
                                                                                                                   
;Top of Red Maze                                                                                                   
RedMazeTop:
       .byte $F0,$FF,$FF          ;XXXXXXXXXXXXXXXXXXXXRRRRRRRRRRRRRRRRRRRR                                      
       .byte $00,$00,$C0          ;                  XXRR                                                        
       .byte $F0,$FF,$CF          ;XXXXXXXXXXXXXXXX  XXRR  RRRRRRRRRRRRRRRR                                      
       .byte $00,$00,$CC          ;              XX  XXRR  RR                                                    
       .byte $F0,$33,$FF          ;XXXX  XX  XXXXXXXXXXRRRRRRRRRR  RR  RRRR                                      
       .byte $F0,$33,$00          ;XXXX  XX  XX                RR  RR  RRRR                                      

;White Castle Entry                                                                                                
WhiteCastleEntry:
       .byte $F0,$3F,$0C          ;XXXX  XXXXXX  XX        RR  RRRRRR  RRRR     **Line Shared With Above Room ----^  
       .byte $F0,$00,$0C          ;XXXX          XX        RR          RRRR                                      
       .byte $F0,$FF,$0F          ;XXXXXXXXXXXXXXXX        RRRRRRRRRRRRRRRR                                      
       .byte $00,$30,$00          ;      XX                        RR                                            
       .byte $F0,$30,$00          ;XXXX  XX                        RR  RRRR                                      
       .byte $00,$30,$00          ;      XX                        RR                                            
       .byte $F0,$FF,$0F          ;XXXXXXXXXXXXXXXX        RRRRRRRRRRRRRRRR                                      
                                                                                                                   
;Top Entry Room  
TopEntryRoom:                                                                                                  
       .byte $F0,$FF,$0F          ;XXXXXXXXXXXXXXXX        RRRRRRRRRRRRRRRR                                      
       .byte $30,$00,$00          ;XX                                    RR                                      
       .byte $30,$00,$00          ;XX                                    RR                                      
       .byte $30,$00,$00          ;XX                                    RR                                      
       .byte $30,$00,$00          ;XX                                    RR                                      
       .byte $30,$00,$00          ;XX                                    RR                                      
       .byte $F0,$FF,$FF          ;XXXXXXXXXXXXXXXXXXXXRRRRRRRRRRRRRRRRRRRR                                      
                                                                                                                   
;Black Maze #1                                                                                                     
BlackMaze1:
       .byte $F0,$F0,$FF          ;XXXXXXXX    XXXXXXXXRRRRRRRR    RRRRRRRR                                      
       .byte $00,$00,$03          ;            XX            RR                                                  
       .byte $F0,$FF,$03          ;XXXXXXXXXXXXXX            RRRRRRRRRRRRRR                                      
       .byte $00,$00,$00          ;                                                                              
       .byte $30,$3F,$FF          ;XX    XXXXXXXXXXXXXXRRRRRRRRRRRRRR    RR                                      
       .byte $00,$30,$00          ;      XX                        RR                                            

;Black Maze #3                                                                                                     
BlackMaze3:
       .byte $F0,$F0,$FF          ;XXXXXXXX    XXXXXXXXRRRRRRRR    RRRRRRRR    **Line Shared With Above Room ----^ (Mirrored Not Reversed)  
       .byte $30,$00,$00          ;XX                  MM                                                        
       .byte $30,$3F,$FF          ;XX    XXXXXXXXXXXXXXMM    MMMMMMMMMMMMMM                                      
       .byte $00,$30,$00          ;      XX                  MM                                                  
       .byte $F0,$F0,$FF          ;XXXXXXXX    XXXXXXXXMMMMMMMM    MMMMMMMM                                      
       .byte $30,$00,$03          ;XX          XX      MM          MM                                            
       .byte $F0,$F0,$FF          ;XXXXXXXX    XXXXXXXXMMMMMMMM    MMMMMMMM                                      
                                                                                                                   
;Black Maze #2                                                                                                     
BlackMaze2:
       .byte $F0,$FF,$FF          ;XXXXXXXXXXXXXXXXXXXXMMMMMMMMMMMMMMMMMMMM                                      
       .byte $00,$00,$C0          ;                  XX                  MM                                      
       .byte $F0,$FF,$CF          ;XXXXXXXXXXXXXXXX  XXMMMMMMMMMMMMMMMM  MM                                      
       .byte $00,$00,$0C          ;                  XX                  MM                                      
       .byte $F0,$0F,$FF          ;XXXX    XXXXXXXXXXXXMMMM    MMMMMMMMMMMM                                      
       .byte $00,$0F,$C0          ;        XXXX      XX        MMMM      MM                                      

;Black Maze Entry                                                                                                  
BlackMazeEntry:
       .byte $30,$CF,$CC          ;XX  XX  XXXX  XX  XXMM  MM  MMMM  MM  MM  **Line Shared With Above Room ----^ (Reversed Not Mirrored)                                    
       .byte $00,$C0,$CC          ;        XX        XX  XXRR  RR        RR                                      
       .byte $F0,$FF,$0F          ;XXXXXXXXXXXXXXXX        RRRRRRRRRRRRRRRR                                      
       .byte $00,$00,$00          ;                                                                              
       .byte $F0,$FF,$0F          ;XXXXXXXXXXXXXXXX        RRRRRRRRRRRRRRRR                                      
       .byte $00,$00,$00          ;                                                                              
       .byte $F0,$FF,$0F          ;XXXXXXXXXXXXXXXX        RRRRRRRRRRRRRRRR                                      
                                                                                                                   
;Objtect #0A : State  
BridgeCurr:                                                                                             
       .byte $00                                                                                                   
                                                                                                                   
;Object #0A : List of States  
BridgeStates:                                                                                     
       .byte $FF,<GfxBridge,>GfxBridge          ;State FF at &FCDB                                                             
                                                                                                                   
;Object #0A : State FF : Graphic                                                                                   
GfxBridge:
       .byte $C3                  ;XX    XX                                                                  
       .byte $C3                  ;XX    XX                                                                  
       .byte $C3                  ;XX    XX                                                                  
       .byte $C3                  ;XX    XX                                                                  
       .byte $42                  ; X    X                                                                   
       .byte $42                  ; X    X                                                                   
       .byte $42                  ; X    X                                                                   
       .byte $42                  ; X    X                                                                   
       .byte $42                  ; X    X                                                                   
       .byte $42                  ; X    X                                                                   
       .byte $42                  ; X    X                                                                   
       .byte $42                  ; X    X                                                                   
       .byte $42                  ; X    X                                                                   
       .byte $42                  ; X    X                                                                   
       .byte $42                  ; X    X                                                                   
       .byte $42                  ; X    X                                                                   
       .byte $42                  ; X    X                                                                   
       .byte $42                  ; X    X                                                                   
       .byte $42                  ; X    X                                                                   
       .byte $42                  ; X    X                                                                   
       .byte $C3                  ;XX    XX                                                                  
       .byte $C3                  ;XX    XX                                                                  
       .byte $C3                  ;XX    XX                                                                  
       .byte $C3                  ;XX    XX                                                                  
       .byte $00                                                                                                   
                                                                                                                   
;Object #5 State #1 Graphic :'1'                                                                                   
GfxNum1:
       .byte $04                  ; X                                                                        
       .byte $0C                  ;XX                                                                        
       .byte $04                  ; X                                                                        
       .byte $04                  ; X                                                                        
       .byte $04                  ; X                                                                        
       .byte $04                  ; X                                                                        
       .byte $0E                  ;XXX                                                                       
       .byte $00                                                                                                   
                                                                                                                   
;Object #0B : State                                                                                                
KeyCurr:
       .byte $00                                                                                                   
                                                                                                                   
;Object #0B : List of States                                                                                       
KeyStates:
       .byte $FF,<GfxKey,>GfxKey                                                                                           
                                                                                                                   
;Object #0B : State FF : Graphic                                                                                   
GfxKey:
       .byte $07                  ;     XXX                                                                  
       .byte $FD                  ;XXXXXX X                                                                  
       .byte $A7                  ;X X  XXX                                                                  
       .byte $00                                                                                                   
                                                                                                                   
;Object #5 State #2 Grphic : '2'                                                                                   
GfxNum2:
       .byte $0E                  ; XXX                                                                      
       .byte $11                  ;X   X                                                                     
       .byte $01                  ;    X                                                                     
       .byte $02                  ;   X                                                                      
       .byte $04                  ;  X                                                                       
       .byte $08                  ; X                                                                        
       .byte $1F                  ;XXXXX                                                                     
       .byte $00                                                                                                   
                                                                                                                   
;Object #5 State #3 Graphic :'3'                                                                                   
GfxNum3:
       .byte $0E                  ; XXX                                                                      
       .byte $11                  ;X   X                                                                     
       .byte $01                  ;    X                                                                     
       .byte $06                  ;  XX                                                                      
       .byte $01                  ;    X                                                                     
       .byte $11                  ;X   X                                                                     
       .byte $0E                  ; XXX                                                                      
       .byte $00                                                                                                   
                                                                                                                   
                                                                                                                   
;Object #0E : List of States   
BatStates:                                                                                    
       .byte $03,<GfxBat1,>GfxBat1          ;State 03 at &FD1A                                                             
LFD17: .byte $FF,<GfxBat2,>GfxBat2          ;State FF as &FD22                                                             
                                                                                                                   
;Object #0E : State 03 : Graphic                                                                                   
GfxBat1:
       .byte $81                  ;X      X                                                                  
       .byte $81                  ;X      X                                                                  
       .byte $C3                  ;XX    XX                                                                  
       .byte $C3                  ;XX    XX                                                                  
       .byte $FF                  ;XXXXXXXX                                                                  
       .byte $5A                  ; X XX X                                                                   
       .byte $66                  ; XX  XX                                                                   
       .byte $00                                                                                                   
                                                                                                                   
;Object #0E : State FF : Graphic                                                                                   
GfxBat2:
       .byte $01                  ;       X                                                                  
       .byte $80                  ;X                                                                         
       .byte $01                  ;       X                                                                  
       .byte $80                  ;X                                                                         
       .byte $3C                  ;  XXXX                                                                    
       .byte $5A                  ; X XX X                                                                   
       .byte $66                  ; XX  XX                                                                   
       .byte $C3                  ;XX    XX                                                                  
       .byte $81                  ;X      X                                                                  
       .byte $81                  ;X      X                                                                  
       .byte $81                  ;X      X                                                                  
       .byte $00                                                                                                   
                                                                                                                   
;Object #6 : States
DragonStates:                                                                                                
       .byte $00,<GfxDrag0,>GfxDrag0          ;State 00 at &FD3A                                                             
LFD31: .byte $01,<GfxDrag2,>GfxDrag2          ;State 01 at &FD66                                                             
LFD34: .byte $02,<GfxDrag0,>GfxDrag0          ;State 02 at &FD3A                                                             
LFD37: .byte $FF,<GfxDrag1,>GfxDrag1          ;State FF at &FD4F                                                             
                                                                                                                   
;Object #6 : State #00 : Graphic                                                                                   
GfxDrag0:
       .byte $06                  ;     XX                                                                   
       .byte $0F                  ;    XXXX                                                                  
       .byte $F3                  ;XXXX  XX                                                                  
       .byte $FE                  ;XXXXXXX                                                                   
       .byte $0E                  ;    XXX                                                                   
       .byte $04                  ;     X                                                                    
       .byte $04                  ;     X                                                                    
       .byte $1E                  ;   XXXX                                                                   
       .byte $3F                  ;  XXXXXX                                                                  
       .byte $7F                  ; XXXXXXX                                                                  
       .byte $E3                  ;XXX   XX                                                                  
       .byte $C3                  ;XX    XX                                                                  
       .byte $C3                  ;XX    XX                                                                  
       .byte $C7                  ;XX   XXX                                                                  
       .byte $FF                  ;XXXXXXXX                                                                  
       .byte $3C                  ;  XXXX                                                                    
       .byte $08                  ;    X                                                                     
       .byte $8F                  ;X   XXXX                                                                  
       .byte $E1                  ;XXX    X                                                                  
       .byte $3F                  ;  XXXXXX                                                                  
       .byte $00                                                                                                   
                                                                                                                   
;Object 6 : State FF : Graphic                                                                                     
GfxDrag1:
       .byte $80                  ;X                                                                         
       .byte $40                  ; X                                                                        
       .byte $26                  ;  X  XX                                                                   
       .byte $1F                  ;   XXXXX                                                                  
       .byte $0B                  ;    X XX                                                                  
       .byte $0E                  ;    XXX                                                                   
       .byte $1E                  ;   XXXX                                                                   
       .byte $24                  ;  X  X                                                                    
       .byte $44                  ; X   X                                                                    
       .byte $8E                  ;X   XXX                                                                   
       .byte $1E                  ;   XXXX                                                                  
       .byte $3F                  ;  XXXXXX                                                                  
       .byte $7F                  ; XXXXXXX                                                                  
       .byte $7F                  ; XXXXXXX                                                                  
       .byte $7F                  ; XXXXXXX                                                                  
       .byte $7F                  ; XXXXXXX                                                                  
       .byte $3E                  ;  XXXXX                                                                   
       .byte $1C                  ;   XXX                                                                    
       .byte $08                  ;    X                                                                     
       .byte $F8                  ;XXXXX                                                                     
       .byte $80                  ;X                                                                         
       .byte $E0                  ;XXX                                                                       
       .byte $00                                                                                                   
                                                                                                                   
;Object 6 : State 02 : Graphic                                                                                     
GfxDrag2:
       .byte $0C                  ;    XX                                                                    
       .byte $0C                  ;    XX                                                                    
       .byte $0C                  ;    XX                                                                    
       .byte $0E                  ;    XXX                                                                   
       .byte $1B                  ;   XX X                                                                   
       .byte $7F                  ; XXXXXXX                                                                  
       .byte $CE                  ;XX  XXX                                                                   
       .byte $80                  ;X                                                                         
       .byte $FC                  ;XXXXXX                                                                    
       .byte $FE                  ;XXXXXXX                                                                   
       .byte $FE                  ;XXXXXXX                                                                   
       .byte $7E                  ; XXXXXX                                                                   
       .byte $78                  ; XXXX                                                                     
       .byte $20                  ;  X                                                                       
       .byte $6E                  ; XX XXX                                                                   
       .byte $42                  ; X    X                                                                   
       .byte $7E                  ; XXXXXX                                                                   
       .byte $00                                                                                                   
                                                                                                                   
;Object #9 : Current State   
SwordCurr:                                                                                              
       .byte $00                                                                                                   
                                                                                                                   
;Object #9 : List of States                                                                                        
SwordStates:
       .byte $FF,<GfxSword,>GfxSword          ;State FF at &FD7C                                                             
                                                                                                                   
;Object #9 : State FF : Graphics                                                                                   
GfxSword:
       .byte $20                  ;  X                                                                       
       .byte $40                  ; X                                                                        
       .byte $FF                  ;XXXXXXXX     
       .byte $40                  ; X                                                                        
       .byte $20                  ;  X                                                                       
       .byte $00                                                                                                   
                                                                                                                   
;Object #0F : State  
DotCurr:                                                                                              
       .byte $00                                                                                                   
                                                                                                                   
;Object #0F : List of States                                                                                       
DotStates:
       .byte $FF,<GfxDot,>GfxDot          ;State FF at FD86                                                              
                                                                                                                   
;Object #0F : State FF : Graphic                                                                                   
GfxDot:
       .byte $80                  ;X                                                                         
       .byte $00                                                                                                   
                                                                                                                   
;Object #4 : State FF : Graphic                                                                                    
GfxAuthor:
       .byte $F0                  ;XXXX                                                                      
       .byte $80                  ;X                                                                         
       .byte $80                  ;X                                                                         
       .byte $80                  ;X                                                                         
       .byte $F4                  ;XXXX X                                                                    
       .byte $04                  ;     X                                                                    
       .byte $87                  ;X    XXX                                                                  
       .byte $E5                  ;XXX  X X                                                                  
       .byte $87                  ;X    XXX                                                                  
       .byte $80                  ;X                                                                         
       .byte $05                  ;     X X                                                                  
       .byte $E5                  ;XXX  X X                                                                 
       .byte $A7                  ;X X  XXX                                                                  
       .byte $E1                  ;XXX    X                                                                  
       .byte $87                  ;X    XXX                                                                  
       .byte $E0                  ;XXX                                                                       
       .byte $01                  ;       X                                                                  
       .byte $E0                  ;XXX                                                                       
       .byte $A0                  ;X X                                                                       
       .byte $F0                  ;XXXX                                                                      
       .byte $01                  ;       X                                                                  
       .byte $40                  ; X                                                                        
       .byte $E0                  ;XXX                                                                       
       .byte $40                  ; X                                                                       
       .byte $40                  ; X                                                                        
       .byte $40                  ; X                                                                        
       .byte $01                  ;       X                                                                  
       .byte $E0                  ;XXX                                                                       
       .byte $A0                  ;X X                                                                       
       .byte $E0                  ;XXX                                                                       
       .byte $80                  ;X                                                                         
       .byte $E0                  ;XXX                                                                       
       .byte $01                  ;       X                                                                  
       .byte $20                  ;  X                                                                       
       .byte $20                  ;  X                                                                       
       .byte $E0                  ;XXX                                                                       
       .byte $A0                  ;X X                                                                       
       .byte $E0                  ;XXX                                                                       
       .byte $01                  ;       X                                                                  
       .byte $01                  ;       X                                                                  
       .byte $01                  ;       X                                                                  
       .byte $88                  ;   X   X                                                                  
       .byte $A8                  ;X X X                                                                     
       .byte $A8                  ;X X X                                                                     
       .byte $A8                  ;X X X                                                                     
       .byte $F8                  ;XXXXX                                                                     
       .byte $01                  ;       X                                                                  
       .byte $E0                  ;XXX                                                                       
       .byte $A0                  ;X X                                                                       
       .byte $F0                  ;XXXX                                                                      
       .byte $01                  ;       X                                                                  
       .byte $80                  ;X                                                                         
       .byte $E0                  ;XXX                                                                       
       .byte $8F                  ;X   XXXX                                                                 
       .byte $89                  ;X   X  X                                                                  
       .byte $0F                  ;    XXXX                                                                  
       .byte $8A                  ;X   X X                                                                   
       .byte $E9                  ;XXX X  X                                                                  
       .byte $80                  ;X                                                                         
       .byte $8E                  ;X   XXX                                                                   
       .byte $0A                  ;    X X                                                                   
       .byte $EE                  ;XXX XXX                                                                   
       .byte $A0                  ;X X                                                                      
       .byte $E8                  ;XXX X                                                                     
       .byte $88                  ;X   X                                                                     
       .byte $EE                  ;XXX XXX                                                                   
       .byte $0A                  ;    X X                                                                   
       .byte $8E                  ;X   XXX                                                                   
       .byte $E0                  ;XXX                                                                       
       .byte $A4                  ;X X  X                                                                    
       .byte $A4                  ;X X  X                                                                    
       .byte $04                  ;     X                                                                    
       .byte $80                  ;X                                                                         
       .byte $08                  ;    X                                                                     
       .byte $0E                  ;    XXX                                                                   
       .byte $0A                  ;    X X                                                                   
       .byte $0A                  ;    X X                                                                   
       .byte $80                  ;X                                                                         
       .byte $0E                  ;    XXX                                                                   
       .byte $0A                  ;    X X                                                                   
       .byte $0E                  ;    XXX                                                                   
       .byte $08                  ;    X                                                                     
       .byte $0E                  ;    XXX                                                                   
       .byte $80                  ;X                                                                         
       .byte $04                  ;     X                                                                    
       .byte $0E                  ;    XXX                                                                   
       .byte $04                  ;     X                                                                    
       .byte $04                  ;     X                                                                    
       .byte $04                  ;     X                                                                    
       .byte $80                  ;X                                                                         
       .byte $04                  ;     X                                                                    
       .byte $0E                  ;    XXX                                                                   
       .byte $04                  ;     X                                                                    
       .byte $04                  ;     X                                                                    
       .byte $04                  ;     X                                                                    
       .byte $00                                                                                                   
                                                                                                                   
;Object $4 : Author's Name   
AuthorInfo:                                                                                      
       .byte $1E,$50,$69          ;Room 1E, (50, 69)                                                             
                                                                                                                   
;Object #4 : Current State  
AuthorCurr:                                                                                       
       .byte $00                                                                                                   
                                                                                                                   
;Object #4 : States                                                                                                
AuthorStates:
       .byte $FF,<GfxAuthor,>GfxAuthor          ;State FF at &FD88                                                             
                                                                                                                   
;Object #10 : State                                                                                                
ChalliseCurr:
       .byte $00                                                                                                   
                                                                                                                   
;Object #10 : List of States                                                                                       
ChalliseStates:
       .byte $FF,<GfxChallise,>GfxChallise          ;State FF at &FDF3                                                            
                                                                                                                   
;Object #10 : State FF : Graphic                                                                                   
GfxChallise:
       .byte $81                  ;X      X                                                                  
       .byte $81                  ;X      X                                                                  
       .byte $C3                  ;XX    XX                                                                  
       .byte $7E                  ; XXXXXX                                                                   
       .byte $7E                  ; XXXXXX                                                                  
       .byte $3C                  ;  XXXX                                                                    
       .byte $18                  ;   XX                                                                     
       .byte $18                  ;   XX                                                                     
       .byte $7E                  ; XXXXXX                                                                   
       .byte $00                                                                                                   
                                                                                                                   
;Object #12 : State                                                                                                
NullCurr:
       .byte $00                                                                                                   
                                                                                                                   
;Object #12 : List of States                                                                                       
NullStates:
       .byte $FF,<GfxNull,>GfxNull                                                                                           
                                                                                                                   
;Object #12 " State FF : Graphic                                                                                   
GfxNull:
       .byte $00                                                                                                   
                                                                                                                   
;Object #5 Number.     
NumberInfo:                                                                                            
       .byte $00,$50,$40          ;#5 Number: Room 00, (50,40)                                                  
                                                                                                                   
;Object #5 States.                                                                                                 
NumberStates:
       .byte $01,<GfxNum1,>GfxNum1          ;State 1 as FCF4                                                               
LFE08: .byte $03,<GfxNum2,>GfxNum2          ;State 3 as FD04                                                               
LFE0B: .byte $FF,<GfxNum3,>GfxNum3          ;State FF as FD0C                                                              
                                                                                                                   
;Object #11 : State                                                                                                
MagnetCurr:
       .byte $00                                                                                                   
                                                                                                                   
;Object #11 : List of States                                                                                       
MagnetStates:
       .byte $FF,<GfxMagnet,>GfxMagnet          ;State FF at FE12                                                              
                                                                                                                   
;Object #11 : State FF : Graphic                                                                                   
GfxMagnet:
       .byte $3C                  ;  XXXX                                                                    
       .byte $7E                  ; XXXXXX                                                                   
       .byte $E7                  ;XXX  XXX                                                                  
       .byte $C3                  ;XX    XX                                                                  
       .byte $C3                  ;XX    XX                                                                  
       .byte $C3                  ;XX    XX                                                                  
       .byte $C3                  ;XX    XX                                                                  
       .byte $C3                  ;XX    XX                                                                  
       .byte $00                                                                                                   
                                                                                                                   
                                                                                                                   
;Room Data                                                                                                         
;Offset 0 : Low byte foom graphics data.                                                                           
;Offset 1 : High byte room graphics data                                                                           
;Offset 2 : Color                                                                                                  
;Offset 3 : B&W Color                                                                                              
;Offset 4 : Bits 5-0 : Playfield Control                                                                           
;            Bit 6 : True if right thin wall wanted.                                                               
;            Bit 7 : True if left thin wall wanted.                                                                
;Offset 5 : Room Above                                                                                             
;Offset 6 : Room Left                                                                                              
;Offset 7 : Room Down                                                                                              
;Offset 8 : Room Right                                                                                             

RoomDataTable:                                                                                                                   
LFE1B:  .byte <NumberRoom,>NumberRoom,                $66,$0A,$21,$00,$00,$00,$00      ;00; 'Number Room.                          Purple           
LFE24:  .byte <BelowYellowCastle,>BelowYellowCastle,  $D8,$0A,$A1,$08,$02,$80,$03      ;01; (Top Acess) Reflected/8 Clock Ball                      
LFE2D:  .byte <BelowYellowCastle,>BelowYellowCastle,  $C8,$0A,$21,$11,$03,$83,$01      ;02; (Top Access)                         Green              
LFE36:  .byte <LeftOfName,>LeftOfName,                $E8,$0A,$61,$06,$01,$86,$02      ;03; Left of Name                                            
LFE3F:  .byte <BlueMazeTop,>BlueMazeTop,              $86,$0A,$21,$10,$05,$07,$06      ;04; Top of Blue Maze                         Blue           
LFE48:  .byte <BlueMaze1,>BlueMaze1,                  $86,$0A,$21,$1D,$06,$08,$04      ;05; Blue Maze #1                                Blue        
LFE51:  .byte <BlueMazeBottom,>BlueMazeBottom,        $86,$0A,$21,$07,$04,$03,$05      ;06; Bottom of Blue Maze                  Blue               
LFE5A:  .byte <BlueMazeCenter,>BlueMazeCenter,        $86,$0A,$21,$04,$08,$06,$08      ;07; Center of Blue Maze                  Blue               
LFE63:  .byte <BlueMazeEntry,>BlueMazeEntry,          $86,$0A,$21,$05,$07,$01,$07      ;08; Blue Maze Entry                        Blue             
LFE6C:  .byte <MazeMiddle,>MazeMiddle,                $08,$08,$25,$0A,$0A,$0B,$0A      ;09; Maze Middle                               Invisible     
LFE75:  .byte <MazeEntry,>MazeEntry,                  $08,$08,$25,$03,$09,$09,$09      ;0A; Maze Entry                              Invisible       
LFE7E:  .byte <MazeSide,>MazeSide,                    $08,$08,$25,$09,$0C,$1C,$0D      ;0B; Maze Side                              Invisible      Re
LFE87:  .byte <SideCorridor,>SideCorridor,            $98,$0A,$61,$1C,$0D,$1D,$0B      ;0C; (Side Corridor)                                         
LFE90:  .byte <SideCorridor,>SideCorridor,            $B8,$0A,$A1,$0F,$0B,$0E,$0C      ;0D; (Side Corridor)                                         
LFE99:  .byte <TopEntryRoom,>TopEntryRoom,            $A8,$0A,$21,$0D,$10,$0F,$10      ;0E; (Top Entry Room)                                        
LFEA2:  .byte <CastleDef,>CastleDef,                  $0C,$0C,$21,$0E,$0F,$0D,$0F      ;0F; White Castle                              White         
LFEAB:  .byte <CastleDef,>CastleDef,                  $00,$02,$21,$01,$1C,$04,$1C      ;10; Black Castle                              Black         
LFEB4:  .byte <CastleDef,>CastleDef,                  $1A,$0A,$21,$06,$03,$02,$01      ;11; Yellow Castle                        Yellow             
LFEBD:  .byte <NumberRoom,>NumberRoom,                $1A,$0A,$21,$12,$12,$12,$12      ;12; Yellow Castle Entry                   Yellow            
LFEC6:  .byte <BlackMaze1,>BlackMaze1,                $08,$08,$25,$15,$14,$15,$16      ;13; Black Maze #1                          Invisible      Re
LFECF:  .byte <BlackMaze2,>BlackMaze2,                $08,$08,$24,$16,$15,$16,$13      ;14; Black Maze #2                        Invisible      Dupl
LFED8:  .byte <BlackMaze3,>BlackMaze3,                $08,$08,$24,$13,$16,$13,$14      ;15; Black Maze #3                        Invisible      Dupl
LFEE1:  .byte <BlackMazeEntry,>BlackMazeEntry,        $08,$08,$25,$14,$13,$1B,$15      ;16; Black Maze Entry                        Invisible      R
LFEEA:  .byte <RedMaze1,>RedMaze1,                    $36,$0A,$21,$19,$18,$19,$18      ;17; Red Maze #1                              Red            
LFEF3:  .byte <RedMazeTop,>RedMazeTop,                $36,$0A,$21,$1A,$17,$1A,$17      ;18; Top of Red Maze                        Red              
LFEFC:  .byte <RedMazeBottom,>RedMazeBottom,          $36,$0A,$21,$17,$1A,$17,$1A      ;19; Bottom of Red Maze                        Red           
LFF05:  .byte <WhiteCastleEntry,>WhiteCastleEntry,    $36,$0A,$21,$18,$19,$18,$19      ;1A; White Castle Entry                        Red           
LFF0E:  .byte <TwoExitRoom,>TwoExitRoom,              $36,$0A,$21,$89,$89,$89,$89      ;1B; Black Castle Entry                        Red           
LFF17:  .byte <NumberRoom,>NumberRoom,                $66,$0A,$21,$1D,$07,$8C,$08      ;1C; Other Purple Room                         Purple        
LFF20:  .byte <TopEntryRoom,>TopEntryRoom,            $36,$0A,$21,$8F,$01,$10,$03      ;1D; (Top Entry Room)                        Red             
LFF29:  .byte <BelowYellowCastle,>BelowYellowCastle,  $66,$0A,$21,$06,$01,$06,$03      ;1E; Name Room                              Purple           
                                                                                                                   
                                                                                                                   
;Room differences for different levels (level 1,2,3)  
RoomDiffs:                                                             
LFF32: .byte $10,$0F,$0F            ;Down from Room 01                                                             
LFF35: .byte $05,$11,$11            ;Down from Room 02                                                             
LFF38: .byte $1D,$0A,$0A            ;Down from Room 03                                                             
LFF3B: .byte $1C,$16,$16            ;U/L/R/D from Room 1B (Black Castle Room)                                      
LFF3E: .byte $1B,$0C,$0C            ;Down from Room 1C                                                             
LFF41: .byte $03,$0C,$0C            ;Up from Room 1D (Top Entry Room)                                              
                                                                                                                   
;Objects                                                                                                           
;Offset 0 : Low byte object information (moveable stuff)                                                           
;Offset 1 : High byte object information (moveable stuff)                                                          
;Offset 2 : Low byte to object's current state                                                                     
;Offset 3 : High byte to object's current state                                                                    
;Offset 4 : Low byte list of states                                                                                
;Offset 5 : High byte list of states                                                                               
;Offset 6 : Colour                                                                                                 
;Offset 7 : Colour in B&W.                                                                                         
;Offset 8 : Size of object                                                                                         

Store1:                                                                                                                   
       .byte $D9                        ;0      ;#0 Invisible Surround Offsets..      00                           
Store2:
       .byte $00                        ;1                                                                         
Store3:
       .byte <SurroundCurr              ;2                                                                         
Store4:
       .byte >SurroundCurr              ;3                                                                         
Store5:
       .byte <SurroundStates            ;4                                                                         
Store6:
       .byte >SurroundStates            ;5                                                                         
Store7:
       .byte $28                        ;6                                                                         
Store8:
       .byte $0C                        ;7                                                                         
Store9:
       .byte $07                        ;8                                                                         
                                                                                                                   
LFF4D:       .byte <PortInfo1,>PortInfo1,    $C8,$00,                      <PortStates,>PortStates,          $00,$00,$00      ;#1 Portcullis #1       Black            09                  
LFF56:       .byte <PortInfo2,>PortInfo2,    $C9,$00,                      <PortStates,>PortStates,          $00,$00,$00      ;#2 Portcullis #2       Black            12             
LFF5F:       .byte <PortInfo3,>PortInfo3,    $CA,$00,                      <PortStates,>PortStates,          $00,$00,$00      ;#3 Portcullis #3       Black            1B             
LFF68:       .byte <AuthorInfo,>AuthorInfo,  <AuthorCurr,>AuthorCurr,      <AuthorStates,>AuthorStates,      $CB,$00,$00      ;#4 Name                Flash            24                
LFF71:       .byte <NumberInfo,>NumberInfo,  $DD,$00,                      <NumberStates,>NumberStates,      $C8,$00,$00      ;#5 Number              Green            2D              
LFF7A:       .byte $A4,$00,                  $A8,$00,                      <DragonStates,>DragonStates,      $36,$0E,$00      ;#6 Dragon #1           Red              36                   
LFF83:       .byte $A9,$00,                  $AD,$00,                      <DragonStates,>DragonStates,      $1A,$06,$00      ;#7 Dragon #2           Yellow           3F                      
LFF8C:       .byte $AE,$00,                  $B2,$00,                      <DragonStates,>DragonStates,      $C8,$00,$00      ;#8 Dragon #3           Green            48                 
LFF95:       .byte $B6,$00,                  <SwordCurr,>SwordCurr,        <SwordStates,>SwordStates,        $1A,$06,$00      ;#9 Sword               Yellow           51                    
LFF9E:       .byte $BC,$00,                  <BridgeCurr,>BridgeCurr,      <BridgeStates,>BridgeStates,      $66,$02,$07      ;#0A Bridge             Purple           5A                  
LFFA7:       .byte $BF,$00,                  <KeyCurr,>KeyCurr,            <KeyStates,>KeyStates,            $1A,$06,$00      ;#0B Key #01            Yellow           63                       
LFFB0:       .byte $C2,$00,                  <KeyCurr,>KeyCurr,            <KeyStates,>KeyStates,            $0E,$0E,$00      ;#0C Key #02            White            6C                  
LFFB9:       .byte $C5,$00,                  <KeyCurr,>KeyCurr,            <KeyStates,>KeyStates,            $00,$00,$00      ;#0D Key #03            Black            75                  
LFFC2:       .byte $CB,$00,                  $CF,$00,                      <BatStates,>BatStates,            $00,$00,$00      ;#0E Bat                Black            7E                
LFFCB:       .byte $A1,$00,                  <DotCurr,>DotCurr,            <DotStates,>DotStates,            $08,$08,$00      ;#0F Black Dot          Light Gray       87                 
LFFD4:       .byte $B9,$00,                  <ChalliseCurr,>ChalliseCurr,  <ChalliseStates,>ChalliseStates,  $CB,$06,$00      ;#10 Challise           Flash            90                 
LFFDD:       .byte $B3,$00,                  <MagnetCurr,>MagnetCurr,      <MagnetStates,>MagnetStates,      $00,$06,$00      ;#11 Magnet             Black            99             
LFFE6:       .byte $BC,$00,                  <NullCurr,>NullCurr,          <NullStates,>NullStates,          $00,$00,$00      ;#12 Null               Black            A2               
                                                                                                                   
;Not Used                                                                                                          
LFFEF: .byte $00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00                                                     
                                                                                                                   
;6502 Vectors (Not Used??                                                                                          
LFFFA:  .byte $00,$F0                                                                                               
LFFFC:  .byte $00,$F0                                                                                               
LFFFE:  .byte $00,$F0                                                                                               
