hposp0	equ		$d000
m0pf	equ		$d000
hposp1	equ		$d001
hposp2	equ		$d002
hposp3	equ		$d003
hposm0	equ		$d004
p0pf	equ		$d004
hposm1	equ		$d005
hposm2	equ		$d006
hposm3	equ		$d007
p3pf	equ		$d007
sizep0	equ		$d008
m0pl	equ		$d008
sizep1	equ		$d009
sizep2	equ		$d00a
m2pl	equ		$d00a
sizep3	equ		$d00b
sizem	equ		$d00c
p0pl	equ		$d00c
grafp0	equ		$d00d
p1pl	equ		$d00d
grafp1	equ		$d00e
p2pl	equ		$d00e
grafp2	equ		$d00f
p3pl	equ		$d00f
grafp3	equ		$d010
trig0	equ		$d010
grafm	equ		$d011
trig1	equ		$d011
colpm0	equ		$d012
colpm1	equ		$d013
colpm2	equ		$d014
colpm3	equ		$d015
colpf0	equ		$d016
colpf1	equ		$d017
colpf2	equ		$d018
colpf3	equ		$d019
colbk	equ		$d01a
prior	equ		$d01b
gractl	equ		$d01d
hitclr	equ		$d01e
consol	equ		$d01f
audf1	equ		$d200
audc1	equ		$d201
audf2	equ		$d202
audc2	equ		$d203
audf3	equ		$d204
audc3	equ		$d205
audf4	equ		$d206
audc4	equ		$d207
audctl	equ		$d208
kbcode	equ		$d209
stimer	equ		$d209
irqen	equ		$d20e
skctl	equ		$d20f
porta	equ		$d300
dmactl	equ		$d400
chactl	equ		$d401
dlistl	equ		$d402
dlisth	equ		$d403
hscrol	equ		$d404
vscrol	equ		$d405
pmbase	equ		$d407
chbase	equ		$d409
wsync	equ		$d40a
vcount	equ		$d40b
nmien	equ		$d40e

vdslst	equ		$0200

;Default 2600 Constants set up by dissasembler..
NUSIZ0  =  $04
NUSIZ1  =  $05
COLUP0  =  colpm0
COLUP1  =  colpm1
COLUPF  =  colpf0
COLUBK  =  colbk
CTRLPF  =  $0A
RESP0   =  $10
_audc0   =  $15
_audc1   =  $16
_audf0   =  $17
_audf1   =  $18
AUDV0   =  $19
AUDV1   =  $1A
GRP0    =  grafp0
GRP1    =  grafp1
ENAM0   =  $1D
ENAM1   =  $1E
ENABL   =  $1F
INPT4   =  $3C

pconsol	=	$40
dispptr	= $41
pfidx	= $43
pfdata0	= $44
pfdata1	= $45
pfdata2 = $46
spr0vpos	= $47
spr0vlen	= $48
spr1vpos	= $49
spr1vlen	= $4a
spr4vpos	= $4b
spr4vlen	= $4c
palmode	= $4d
statcnt	= $4e

;$80 = Room graphics pointer low
;$81 = Room graphics pointer high
;$86 = Object1 X
;$87 = Object1 Y
;$88 = Object2 X
;$89 = Object2 Y
;$8A = Room number
;$8B = Player X
;$8C = Player Y
;$8D = Adjusted player Y
;$93 = Room pointer low
;$94 = Room pointer high
;$95 = Object1 object
;$96 = Object2 object
;$9C = current object count
;$9D = carried object
;$A1 = Dot room
;$A2 = Dot X
;$A3 = Dot Y
;$A4 = Red dragon room
;$A5 = Red dragon X
;$A6 = Red dragon Y
;$A7 = Red dragon movement
;$A8 = Red dragon state
;$A9 = Yellow dragon room
;$AA = Yellow dragon X
;$AB = Yellow dragon Y
;$AC = Yellow dragon movement
;$AD = Yellow dragon state
;$AE = Green dragon room
;$AF = Green dragon X
;$B0 = Green dragon Y
;$B1 = Green dragon movement
;$B2 = Green dragon state
;$B3 = Magnet room
;$B4 = Magnet X
;$B5 = Magnet Y
;$B6 = Sword room
;$B7 = Sword X
;$B8 = Sword Y
;$B9 = Chalice room
;$BA = Chalice X
;$BB = Chalice Y
;$BC = Bridge room
;$BD = Bridge X
;$BE = Bridge Y
;$BF = Yellow key room
;$C0 = Yellow key X
;$C1 = Yellow key Y
;$C2 = White key room
;$C3 = White key X
;$C4 = White key Y
;$C5 = Black key room
;$C6 = Black key X
;$C7 = Black key Y
;$C8 = Portcullis #1 state
;$C9 = Portcullis #2 state
;$CA = Portcullis #3 state
;$CB = Bat room
;$CC = Bat X
;$CD = Bat Y
;$CF = Bat state
;$D8 = temporary
;$DC = Object2 state
;$DD = Level number state

SWCHA   =  $0280
SWCHB   =  $0282
INTIM   =  $0284


SPRITE_HOFFSET = $2F

;==========================================================================
		org		$2000
playfield:

		org		$2046
playfield_status:

		org		$2180
missile_data:

		org		$2200
player0_data:

		org		$2280
player1_data:

		org		$2300
player2_data:

		org		$2380
player3_data:

		org		$2700
dlist:
		dta		$70
		dta		$70
		dta		$C2, a(playfield_status)
		dta		$48, a(playfield), $48, a(playfield)
		.rept	5
		dta		$48, a(playfield+10*(#+1))
		dta		$48, a(playfield+10*(#+1))
		dta		$48, a(playfield+10*(#+1))
		dta		$48, a(playfield+10*(#+1))
		.endr
		dta		$48, a(playfield+10*6)
		dta		$C8, a(playfield+10*6)

		dta		$41, a(dlist)

		org		$2800

;==========================================================================
revtab:
		:256 dta [(#&$80)/$80]+[(#&$40)/$20]+[(#&$20)/$08]+[(#&$10)/$02]+[(#&$08)*$02]+[(#&$04)*$08]+[(#&$02)*$20]+[(#&$01)*$80]

expandhi:
		:256 dta [((#&$80)/$02)+((#&$40)/$04)+((#&$20)/$08)+((#&$10)/$10)]*1

expandlo:
		:256 dta [((#&$08)*$08)+((#&$04)*$04)+((#&$02)*$02)+((#&$01)*$01)]*1

;==========================================================================
		.pages 1
audio_tabs:
audio_lotab:
		:32 dta <((#+1)*57-7)
		:32 dta >((#+1)*57-7)

audio_lotab6:
		:32 dta <((#+1)*57*3-7)
		:32 dta >((#+1)*57*3-7)

audio_lotab31:
		:32 dta <(((#+1)*57*31)/2-7)
		:32 dta >(((#+1)*57*31)/2-7)
		.endpg

;==========================================================================
.proc	UpdateAudio
		lda		_audc0
		and		#$0f
		tax
		lda		_audf0
		and		#$1f
		ora		audio_dtab,x
		tax
		mva		audio_tabs,x audf1
		mva		audio_tabs+$20,x audf2

		lda		_audc1
		and		#$0f
		tax
		lda		_audf1
		and		#$1f
		ora		audio_dtab,x
		tax
		mva		audio_tabs,x audf3
		mva		audio_tabs+$20,x audf4
		
		lda		_audc0
		and		#$0f
		tax
		lda		audv0
		and		#$0f
		ora		audio_ctab,x
		sta		audc2		

		lda		_audc1
		and		#$0f
		tax
		lda		audv1
		and		#$0f
		ora		audio_ctab,x
		sta		audc4
		rts
.endp

audio_ctab:
		dta		$10
		dta		$10
		dta		$20
		dta		$30
		dta		$a0		;$4: pure tone
		dta		$a0		;$5: pure tone
		dta		$a0		;$6: pure tone
		dta		$70
		dta		$80
		dta		$90
		dta		$A0
		dta		$B0
		dta		$a0		;$C: pure tone, div 6
		dta		$D0
		dta		$E0
		dta		$20		;$F: 5-bit poly, div 6
		
audio_dtab:
		dta		<audio_lotab
		dta		<audio_lotab
		dta		<audio_lotab
		dta		<audio_lotab
		dta		<audio_lotab
		dta		<audio_lotab
		dta		<audio_lotab31
		dta		<audio_lotab
		dta		<audio_lotab
		dta		<audio_lotab
		dta		<audio_lotab
		dta		<audio_lotab
		dta		<audio_lotab6
		dta		<audio_lotab
		dta		<audio_lotab
		dta		<audio_lotab6

;==========================================================================
.proc UpdateInput
		lda		trig0
		ror
		ror
		sta		inpt4

		lda		porta
		asl
		rol
		rol
		rol
		sta		swcha
		and		#$07
		adc		swcha
		sta		swcha

		;copy START and SELECT into game reset/select switches
		lda		consol
		eor		swchb
		and		#3
		eor		swchb
		sta		swchb
		
		;check for OPTION and flip difficulty switches
		lda		consol
		tax
		eor		#$04
		and		pconsol
		stx		pconsol
		ldy		#0
		and		#$04
		seq:ldy	#$c0
		tya
		eor		swchb
		sta		swchb
		rts
.endp
;==========================================================================
.proc DrawPlayfield
		;check for inverted priority
		ldx		#$11
		lda		ctrlpf
		and		#$04
		seq:ldx	#$14
		stx		prior

		mwa		#playfield dispptr

		ldx		#0
		ldy		#0
		sty		pfidx

		lda		ctrlpf
		lsr
		bne		reflect_draw_loop

draw_loop:
		;load up playfield bytes
		ldy		pfidx
		lda		($80),y+
		sta		pfdata0
		lda		($80),y+
		sta		pfdata1
		lda		($80),y+
		sta		pfdata2
		sty		pfidx

		;copy to playfield
		ldy		pfdata2
		lda		revtab,y
		tay
		lda		expandhi,y
		sta		playfield+3,x
		sta		playfield+8,x
		lda		expandlo,y
		sta		playfield+4,x
		sta		playfield+9,x

		ldy		pfdata1
		lda		expandhi,y
		sta		playfield+1,x
		sta		playfield+6,x
		lda		expandlo,y
		sta		playfield+2,x
		sta		playfield+7,x

		ldy		pfdata0
		lda		expandhi,y
		lda		revtab,y
		tay
		lda		expandlo,y
		sta		playfield+0,x
		sta		playfield+5,x

		;advance to next line
		txa
		clc
		adc		#10
		tax
		cpx		#130
		bne		draw_loop
		rts

reflect_draw_loop:
		;load up playfield bytes
		ldy		pfidx
		lda		($80),y+
		sta		pfdata0
		lda		($80),y+
		sta		pfdata1
		lda		($80),y+
		sta		pfdata2
		sty		pfidx

		;copy to playfield
		ldy		pfdata2
		lda		expandhi,y
		sta		playfield+5,x
		lda		expandlo,y
		sta		playfield+6,x
		lda		revtab,y
		tay
		lda		expandhi,y
		sta		playfield+3,x
		lda		expandlo,y
		sta		playfield+4,x

		ldy		pfdata1
		lda		expandhi,y
		sta		playfield+1,x
		lda		expandlo,y
		sta		playfield+2,x
		lda		revtab,y
		tay
		lda		expandhi,y
		sta		playfield+7,x
		lda		expandlo,y
		sta		playfield+8,x

		ldy		pfdata0
		lda		expandhi,y
		sta		playfield+9,x
		lda		revtab,y
		tay
		lda		expandlo,y
		sta		playfield+0,x

		;advance to next line
		txa
		clc
		adc		#10
		tax
		cpx		#70
		bne		reflect_draw_loop
		rts
.endp

;==========================================================================
.proc DrawSprites
		;draw player 0
		lda		#$79
		sec
		sbc		$87
		tax
		stx		spr0vpos
		ldy		#0
player0_loop:
		lda		($82),y
		beq		player0_done
		iny
		sta		player0_data,x+
		bpl		player0_loop
player0_done:
		sty		spr0vlen

		;draw player 1
		lda		#$79
		sec
		sbc		$89
		tax
		stx		spr1vpos
		ldy		#0
player1_loop:
		lda		($84),y
		beq		player1_done
		iny
		sta		player1_data,x+
		bpl		player1_loop
player1_done:
		sty		spr1vlen

		;get adjusted player position
		lda		#$75
		sec
		sbc		$8D

		;draw player
		tay
		sty		spr4vlen
		lda		#$02
		ldx		#4
		stx		spr4vpos
player_loop:
		sta		missile_data,y+
		dex
		bne		player_loop

		;all done
		rts
.endp

;==========================================================================
.proc EraseSprites
		lda		#0

		;clear player 0
		ldy		spr0vlen
		beq		no_spr0
		ldx		spr0vpos
spr0_loop:
		sta		player0_data,x+
		dey
		bne		spr0_loop
		sty		spr0vlen
no_spr0:

		;clear player 1
		ldy		spr1vlen
		beq		no_spr1
		ldx		spr1vpos
spr1_loop:
		sta		player1_data,x+
		dey
		bne		spr1_loop
		sty		spr1vlen
no_spr1:

		;clear missiles
		ldy		spr4vlen
		beq		no_spr4
		ldx		spr4vpos
spr4_loop:
		sta		missile_data,x+
		dey
		bne		spr4_loop
		sty		spr4vlen
no_spr4:
		rts
.endp

;==========================================================================
.proc DliHandler
		pha
		lda		vcount
		cmp		#$60
		bcc		dli_1

		;disable sprite DMA
		lda		#0
		sta		gractl
		
		;clear sprite registers
		sta		wsync
		sta		grafp0
		sta		grafp1
		sta		grafp2
		sta		grafp3
		sta		grafm
		pla
		rti

dli_1:
		;enable sprite DMA
		lda		#3
		sta		gractl
		pla
		rti
.endp

;==========================================================================
.proc PollKeyboard
		lda		irqen
		and		#$40
		beq		got_key
		rts

got_key:
		lda		#$bf
		sta		irqen
		lda		#$40
		sta		irqen

		lda		kbcode
		cmp		#$BA		;Ctrl+D
		bne		not_ctrl_d
		jmp		KillDragons

not_ctrl_d:
		cmp		#$1F		;1
		bne		not_1
		jmp		ToggleDifficultyA
not_1:
		cmp		#$1E		;2
		bne		not_2

		jmp		ToggleDifficultyB

not_2:
		cmp		#$15		;B
		bne		not_b

		jmp		ToggleBlackWhite

not_b:
		rts
.endp

;==========================================================================
.proc UpdateStatus
		lda		statcnt
		beq		no_status
		dec		statcnt
		bne		no_status
.def :ClearStatus
		lda		#0
		ldx		#37
		sta:rpl	playfield_status,x-
no_status:
		rts
.endp

;==========================================================================
.proc KillDragons
		;kill all three dragons
		lda		#$01
		sta		$a8			;red 
		sta		$ad			;yellow
		sta		$b2			;green

		;play slay sound
		lda		#$03
		sta		$e0
		lda		#$10
		sta		$df
		rts
.endp

;==========================================================================
.proc ToggleDifficultyA
		lda		#"1"
		sta		msg_diff_num
		lda		swchb
		eor		#$40
		sta		swchb
		and		#$40
update_status:
		ldx		#"B"
		tay
		seq:ldx	#"A"
		stx		msg_diff_result

		jsr		ClearStatus
		ldx		#msg_diff_end-msg_diff-1
		mva:rpl	msg_diff,x playfield_status+2,x-

		lda		#60
		sta		statcnt
		rts
.endp

;==========================================================================
.proc ToggleDifficultyB
		lda		#"2"
		sta		msg_diff_num
		lda		swchb
		eor		#$80
		sta		swchb
		and		#$80
		jmp		ToggleDifficultyA.update_status
.endp

;==========================================================================
.proc ToggleBlackWhite
		lda		swchb
		eor		#$08
		sta		swchb
		rts		
.endp

;==========================================================================
msg_diff:
		dta		"Difficulty "
msg_diff_num:
		dta		"1"
		dta		" set to "
msg_diff_result:
		dta		"A."
msg_diff_end:

;==========================================================================

START:
		sei
		lda		#0
		sta		nmien

		;clear page 0
		tax
		sta:rne	0,x+

		;clear display pages
clear_loop:
		sta		playfield,x
		sta		missile_data-$80,x
		sta		player0_data,x
		sta		player2_data,x
		inx
		bne		clear_loop

		;detect PAL ANTIC (not PAL GTIA!)
		lda:rpl	vcount
paltest_loop:
		tax
		lda		vcount
		bmi		paltest_loop

		ldy		#0
		cpx		#140
		scc:ldy	#$40
		sty		palmode

		;wait for VBLANK
		ldx		#248/2
		cpx:rne	vcount

		mwa		#DliHandler vdslst
		mva		#$80 nmien

		lda		#0
		sta		dmactl
		sta		gractl

		lda		#$11
		sta		prior

		lda		#$ff
		sta		sizem

		mva		#$08 colpf2
		mva		#$00 colpf1

		;preset sprites 2 and 3
		ldx		#0
		lda		#$80
		sta:rne	player2_data,x+
		lda		#$01
		sta		sizep2
		sta		sizep3

		lda		#$08
		sta		swchb

		mva		#$f8 audctl
		mva		#8 consol
		mva		consol pconsol

		mwa		#dlist dlistl
		mva		#$2e dmactl
		mva		#$03 gractl
		mva		#>missile_data pmbase

		;enable keyboard
		lda		#$03
		sta		skctl
		lda		#0
		sta		irqen
		lda		#$40
		sta		irqen

		JMP    StartGame           ;Jump To Start Game                                                        ;3

;Print Display
PrintDisplay:
		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    hitclr				;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

		jsr		EraseSprites
		jsr		DrawSprites
		jsr		DrawPlayfield
		jsr		PollKeyboard
		jsr		UpdateStatus

		;wait for vertical blank
		lda		#248/2
		cmp:rne	vcount

		RTS


;Position Sprite X horizontally.
PosSpriteX:
		clc
		adc		#SPRITE_HOFFSET
		sta		hposp0,x
		rts

;Preform VSYNC
DoVSYNC:
		jsr		UpdateAudio
		jsr		UpdateInput
		rts

;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
		sta		colpf3
		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
		sta		colpf3

;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

		;position players 2 and 3 as left and right thin walls
		asl
		ldy		#SPRITE_HOFFSET+$0d
		scs:ldy	#0
		sty		hposp2
		asl
		ldy		#SPRITE_HOFFSET+$96
		scs:ldy	#0
		sty		hposp3

;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
		sta		colpm2
		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
		sta		colpm2

;Object1 Size
ResizeObject:
		ldy		#0
		LDA    Store9,X             ;Get Object1's Size                                                        ;4
		seq:ldy	#3
		sta		sizep0				;(Used by bridge and invisible surround)

;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
		sta		colpm3
		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
		sta		colpm3

;Object2 Size
ResizeObject2:
		ldy		#0
		LDA    Store9,X             ;Get Object2's Size                                                        ;4
		seq:ldy	#3
		sta		sizep1				;(Used by bridge and invisible surround)
		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.w  $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    4,X            ;Everything And Turn.                                                      ;4
		DEX                        ;Everything Off.                                                           ;2
		BPL    ResetAll                                                                                          ;2
		TXS                        ;Reset Stack                                                               ;2
SetupVars:
		STA    0,X             ;Clear &80 to &FF User Vars.                                               ;4
		DEX                                                                                                   ;2
		BMI    SetupVars                                                                                          ;2
		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:
		JSR    DoVSYNC             ;Wait for VSYNC                                                            ;6
		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    SetupRoomPrint      ;Setup the room and objects for display.                                   ;6
		JSR    PrintDisplay        ;Display the room and objects.                                             ;6
		JSR    DoVSYNC             ;Wait for VSYNC                                                            ;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    MoveBat             ;Move and deal with bat.                                                   ;6
		JSR    Portals             ;Move and deal with portcullises.                                          ;6
		JSR    PrintDisplay        ;Display the room and objects.                                             ;6
		JSR    DoVSYNC             ;Wait for VSYNC.                                                           ;6
		JSR    MoveGreenDragon     ;Move and deal with the green dragon.                                      ;6
		JSR    MoveYellowDragon    ;Move and deal with the yellow dragon.                                     ;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

		;check if we are in PAL mode
		lda		palmode
		beq		do_display3

		;flip phase and check if we should skip a frame
		eor		#$80
		sta		palmode
		bpl		skip_display3

do_display3:
		JSR    PrintDisplay        ;Display the room and objects.                                             ;6
skip_display3:
		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


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.w  $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    0,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    m0pf                                                                                         ;3
		AND    #$01                ;Get ball-playfield collision                                              ;2
		BNE    PlayerCollision     ;Branch if collision (Player-Wall)                                         ;2

		LDA    m0pl                                                                                         ;3
		AND    #$04                ;Get ball-missile00 collision.                                             ;2
		BNE    PlayerCollision     ;Branch if collision. (Player-Left Thin)                                   ;2

		LDA    m0pl
		AND    #$08                ;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    m0pl                                                                                         ;3
		AND    #$01                ;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    m0pl
		AND    #$02                ;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    m0pl                                                                                         ;3
		AND    #$01                ;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    m0pl
		AND    #$02                ;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.w  $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    0,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    2,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    0,X             ;And put the object in the castle room.                                    ;4
		LDA    #$50                                                                                           ;2
		STA    1,X            ;Set the object's new X coordinate.                                        ;4
		LDA    #$2C                                                                                           ;2
		STA    2,X             ;Set the new object's Y coordinate.                                        ;4
		LDA    #$01                                                                                           ;2
		STA.w  $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    2,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    2,X                                                                                        ;4
		LDY    #$05                ;Get the direction wanted.                                                 ;2
		JMP    GetNewRoom          ;Go and get new room.                                                      ;3

;Check and Deal with Left.
DealWithLeft:
		LDA    1,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    1,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    2,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    2,X                                                                                        ;4
		LDY    #$07                ;Get the direction wanted.                                                 ;2
		JMP    GetNewRoom          ;Go and get new room.                                                      ;3

;Check and Deal with Right.
DealWithRight:
		LDA    1,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    0,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    0,X             ;And make it current.                                                      ;4
		LDA    #$03                ;Set the X coordinate.                                                     ;2
		STA    1,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    1,X                                                                                       ;4
		LDY    #$06                ;And get the direction wanted.                                             ;2
		JMP    GetNewRoom          ;Get the new room.                                                         ;3

;Get new room
GetNewRoom:
		LDA    0,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    0,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    1,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    1,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    2,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    2,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    m0pl                ;Get player00-ball collision.                                              ;3
		AND    #$01
		RTS                                                                                                   ;6
PBCollision_3:
		LDA    m0pl                ;Get player01-ball collision.                                              ;3
		AND    #$02                                                                           ;2
		RTS                                                                                                   ;6


;Find which object has hit object wanted.
FindObjHit:
		LDA    p0pl                ;Get Player00-Player01                                                     ;3
		AND    #$02                ;      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    3,X             ;Use old movement.                                                         ;4

MoveGameObject_2:
		STA    3,X             ;Stoe the new movement.                                                    ;4
		LDY    $D4                 ;Get the object's Delta.                                                   ;3
		jmp    MoveGroundObject     ;Move the object.                                                          ;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    0,X             ;Get object1;s room.                                                       ;4
		CMP.w  $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
		bne    GetLinkedObject_4   ;Get object's movement.                                                    ;6
                                                                                                   ;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.w  $0000,Y             ;Get oject2's room.                                                        ;4
		CMP    0,X             ;Compare it with object's room.                                            ;4
		BNE    GetLinkedObject_8   ;If not the same, forget it.                                               ;2

		LDA.w  $0001,Y             ;Get Object2's X coordinate.                                               ;4
		CMP    1,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.w  $0002,Y             ;Get Object2's Y Coordinate.                                               ;4
		CMP    2,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
		jmp    MoveDragon

;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
		jmp    MoveDragon          ;Select Dragon #2 : Yellow.                                                ;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
		jmp    MoveDragon                                                                                     ;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    4,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    4,X            ;Store as Dragon's State (Open Mouthed).                                   ;4
		LDA    $E3                                                                                            ;3
		STA    1,X            ;Get Temp Ball X Coord and Store as Dragon's.                              ;4
		LDA    $E4                                                                                            ;3
		STA    2,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    4,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    0,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    1,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    2,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    4,X            ;Increment the Dragon's State.                                             ;6
		LDA    4,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    4,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    1,X            ;Compare with the Dragon's X Coordinate.                                   ;4
		BEQ    MoveDragon_8                                                                                          ;2
		BCS    MoveDragon_8                                                                                          ;2

		STA    1,X            ;If too large then Use It.                                                 ;4

MoveDragon_8:
		LDA    #$17                ;Set Minimum Y Coordinate.                                                 ;2
		CMP    2,X             ;Compare with the Dragon's Y Coordinate.                                   ;4
		BCC    MoveDragon_9                                                                                   ;2

		STA    2,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    0,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    1,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    2,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    0,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    1,X            ;Make it the Object's X coordinate.                                        ;4
		LDA    $CD                 ;Get the Bat's Y Coordinate.                                               ;3
		STA    2,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    0,X       ;Make it the object's Room.                                                      ;4
		LDA    #$10          ;Give the Object a new Y coordinate.                                             ;2
		STA    2,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		colpf3
		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


		run start
