Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- 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
Add Comment
Please, Sign In to add comment
