Subversion Repositories NedoOS

 

 

 

 

 

 

 

        if Z80==0

       .index 8

       .mem 8

 

       .org $8000

        endif

 

 

Start:

        if Z80==0

             sei                          ;pretty standard 6502 type init here

             cld

             ldan ++%00010000               ;init PPU control register 1

             sta PPU_CTRL_REG1

             ldxn ++$ff                     ;reset stack pointer

             txs

VBlank1:     lda PPU_STATUS               ;wait two frames

         checka

             bpl VBlank1

VBlank2:     lda PPU_STATUS

         checka

             bpl VBlank2

        endif

             ldyn16 ++MEMDATA_end-AREADATA;ColdBootOffset          ;load default cold boot pointer

             ldxn ++$05                     ;this is where we check for a warm boot

WBootCheck:  

        if Z80==0

             ldax TopScoreDisplay,x        ;check each score digit in the top score

             cmpn ++10                      ;to see if we have a valid digit

              cmpcy

             bcs ColdBoot                 ;if not, give up and proceed with cold boot

             dex                      

             bpl WBootCheck

             lda WarmBootValidation       ;second checkpoint, check to see if

             cmpn ++$a5                     ;another location has a specific value

             bne ColdBoot  

             ldyn16 ++WARMMEMDATA_end-AREADATA;WarmBootOffset          ;if passed both, load warm boot pointer

        endif

ColdBoot:    jsr InitializeMemory         ;clear memory using pointer in Y

             sta SND_DELTA_REG+1          ;reset delta counter load register

             sta OperMode                 ;reset primary mode of operation

             ldan ++$a5                     ;set warm boot flag

             sta WarmBootValidation    

             sta PseudoRandomBitReg       ;set seed for pseudorandom register

             ldan ++%00001111

             sta SND_MASTERCTRL_REG       ;enable all sound channels except dmc

        if Z80==0

             ldan ++%00000110

             sta PPU_CTRL_REG2            ;turn off clipping for OAM and background

        endif

             jsr MoveAllSpritesOffscreen

             jsr InitializeNameTables     ;initialize both name tables

             inci DisableScreenFlag        ;set flag to disable screen output

        if Z80==0

             lda Mirror_PPU_CTRL_REG1

             oran ++%10000000               ;enable NMIs

             jsr WritePPUReg1

        endif

       

             call NonMaskableInterrupt

        call gettimer ;hl=timer

         ld (oldupdtimer),hl

         

EndlessLoop:

        if Z80

             call EmulatePPU

        call gettimer ;hl=timer

oldupdtimer=$+1

         ld de,oldupdtimer

         ld (oldupdtimer),hl

             or a

             sbc hl,de

        if FASTDEMOBEFOREBREAKPOINT

             ld c,1

             jr z,c_logic0

        else

             jr z,nologic

        endif

             ld c,8

             ld a,l

             cp c

             jr nc,$+3 ;сюы№°х с√трхЄ Єюы№ъю т сЁ ъяюшэЄрї

             ld c,l

c_logic0

            ld hl,logicframe

            ld (hl),c

             ld b,0

             ld d,b

logic0

             call NonMaskableInterrupt

            ld hl,logicframe

            dec (hl)

            jr nz,logic0

                jr logicq

nologic

        ;jr $ ;Ёхры№эю эх яюярфрхь ё■фр яЁш эюЁьры№эющ шуЁх

                YIELD;halt

             ld b,0

             ld d,b

logicq

        endif

             jmp EndlessLoop              ;endless loop, need I say more?

 

        if MUSICONINT

        include "smbsound.asm"

        include "smbmusic.asm"

        ;display $,"<=0x8000"

        endif

 

 

VRAM_AddrTable_Low:

      .db LOW VRAM_Buffer1, LOW WaterPaletteData, LOW GroundPaletteData

      .db LOW UndergroundPaletteData, LOW CastlePaletteData, LOW VRAM_Buffer1_Offset

      .db LOW VRAM_Buffer2, LOW VRAM_Buffer2, LOW BowserPaletteData

      .db LOW DaySnowPaletteData, LOW NightSnowPaletteData, LOW MushroomPaletteData

      .db LOW MarioThanksMessage, LOW LuigiThanksMessage, LOW MushroomRetainerSaved

      .db LOW PrincessSaved1, LOW PrincessSaved2, LOW WorldSelectMessage1

      .db LOW WorldSelectMessage2

 

VRAM_AddrTable_High:

      .db HIGH VRAM_Buffer1, HIGH WaterPaletteData, HIGH GroundPaletteData

      .db HIGH UndergroundPaletteData, HIGH CastlePaletteData, HIGH VRAM_Buffer1_Offset

      .db HIGH VRAM_Buffer2, HIGH VRAM_Buffer2, HIGH BowserPaletteData

      .db HIGH DaySnowPaletteData, HIGH NightSnowPaletteData, HIGH MushroomPaletteData

      .db HIGH MarioThanksMessage, HIGH LuigiThanksMessage, HIGH MushroomRetainerSaved

      .db HIGH PrincessSaved1, HIGH PrincessSaved2, HIGH WorldSelectMessage1

      .db HIGH WorldSelectMessage2

 

      if Z80

tpalettes

        dw waterpalette

        dw groundpalette

        dw undergroundpalette

        dw castlepalette

      endif

     

VRAM_Buffer_Offset:

      .db LOW VRAM_Buffer1_Offset, LOW VRAM_Buffer2_Offset

 

NonMaskableInterrupt:

        if Z80

               ;ldx VRAM_Buffer_AddrCtrl  ;load control for pointer to buffer contents

               ;ldax VRAM_AddrTable_High,x

               ;ld d,a

               ;ldax VRAM_AddrTable_Low,x

               ;ld e,a

               ;ex de,hl

               ;ld de,PPU_SPRLIST

               ;ld bc,0x100

               ;ldir

               ;ex de,hl

               ;ld d,b;0

               lda Mirror_PPU_CTRL_REG1  ;d0 = ёЄЁрэшЎр (фы  ёъЁюыыр)

               sta PPU_CTRL_REG1

        else

               lda Mirror_PPU_CTRL_REG1  ;disable NMIs in mirror reg

               andn ++%01111111            ;save all other bits

               sta Mirror_PPU_CTRL_REG1

               andn ++%01111110            ;alter name table address to be $2800 ;ўЄюс√ т√тюфшЄ№ тёхуфр ёЄЁрэшЎє ёю ёў╕Єюь

               sta PPU_CTRL_REG1         ;(essentially $2000) but save other bits

               lda Mirror_PPU_CTRL_REG2  ;disable OAM and background display by default

               andn ++%11100110

               ldy DisableScreenFlag     ;get screen disable flag

         checky

               bne ScreenOff             ;if set, used bits as-is

               lda Mirror_PPU_CTRL_REG2  ;otherwise reenable bits and save them

               oran ++%00011110

ScreenOff:     sta Mirror_PPU_CTRL_REG2  ;save bits for later but not in register at the moment

               andn ++%11100111            ;disable screen for now

               sta PPU_CTRL_REG2

               ldx PPU_STATUS            ;reset flip-flop and reset scroll registers to zero

               ldan ++$00

               jsr InitScroll ;яш°хЄ эєыш т ёъЁюыы√ (ўЄюс√ эх ёъЁюыышЄ№ ёў╕Є)

               sta PPU_SPR_ADDR          ;reset spr-ram address register

               ldan ++$02                  ;perform spr-ram DMA access on $0200-$02ff

               sta SPR_DMA

        endif

               ldx VRAM_Buffer_AddrCtrl  ;load control for pointer to buffer contents

               ldax VRAM_AddrTable_Low,x  ;set indirect at $00 to pointer

               sta SCRATCHPAD+$00

               ldax VRAM_AddrTable_High,x

               sta SCRATCHPAD+$01

              ;cp 0x03

              ;jr nz,$

               jsr UpdateScreen          ;update screen with buffer contents

               ldyn ++$00

               ldx VRAM_Buffer_AddrCtrl  ;check for usage of $0341 ;VRAM_Buffer2???

               cpxn ++$06

               bne InitBuffer

               iny                       ;get offset based on usage

InitBuffer:    ldxy VRAM_Buffer_Offset,y

               ldan ++$00                  ;clear buffer header at last location

               stax VRAM_Buffer1_Offset,x        

               stax VRAM_Buffer1,x

               sta VRAM_Buffer_AddrCtrl  ;reinit address control to $0301 ;VRAM_Buffer1???

        if Z80==0

               lda Mirror_PPU_CTRL_REG2  ;copy mirror of $2001 to register

               sta PPU_CTRL_REG2

        endif

          if MUSICONINT==0

               jsr SoundEngine           ;play sound

          else

soundenginepatch=$+1

               call SoundEngine_noint           ;play sound logically

          endif

               jsr ReadJoypads           ;read joypads

              if DEMO

              ld a,(readdemo_stopflag)

              or a

              jr nz,randomskip;PauseSkip

              endif

               jsr PauseRoutine          ;handle pause ;яюўхьє-Єю хёыш т√°х, Єю яюёых т√їюфр шч фхь√ тъы■ўрхЄ ярєчє

               jsr UpdateTopScore

               lda GamePauseStatus       ;check for pause status

               lsr

               bcs PauseSkip

              if Z80;OPT

               ld a,(TimerControl)          ;if master timer control not set, decrement

               or a

               jr z,DecTimers             ;all frame and interval timers

               dec a

               ld (TimerControl),a

               jr nz,NoDecTimers

DecTimers:     ;xor a

               ld b,21;ldxn ++$14                  ;load end offset for end of frame timers

               ld hl,IntervalTimerControl

               dec (hl) ;decrement interval timer control,

               ld hl,Timers+20

               jp p,DecTimersLoop         ;if not expired, only frame timers will decrement

               ld a,20

               ld (IntervalTimerControl),a  ;if control for interval timers expired, (21 frame rule???)

               ld b,36;ldxn ++$23                  ;interval timers will decrement along with frame timers

               ld hl,Timers+35

               xor a

DecTimersLoop: cp (hl);ldax Timers,x              ;check current timer

               jr z,SkipExpTimer          ;if current timer expired, branch to skip,

               dec (hl);decx Timers,x              ;otherwise decrement the current timer

SkipExpTimer:  dec hl ;dex                       ;move onto next timer

               djnz DecTimersLoop         ;do this until all timers are dealt with

NoDecTimers:   ld hl,FrameCounter

               inc (hl) ;increment frame counter

              else ;~Z80

               lda TimerControl          ;if master timer control not set, decrement

         checka

               beq DecTimers             ;all frame and interval timers

               deci TimerControl

               bne NoDecTimers

DecTimers:     ldxn ++$14                  ;load end offset for end of frame timers

               deci IntervalTimerControl  ;decrement interval timer control,

               bpl DecTimersLoop         ;if not expired, only frame timers will decrement

               ldan ++$14

               sta IntervalTimerControl  ;if control for interval timers expired, (21 frame rule???)

               ldxn ++$23                  ;interval timers will decrement along with frame timers

DecTimersLoop: ldax Timers,x              ;check current timer

         checka

               beq SkipExpTimer          ;if current timer expired, branch to skip,

               decx Timers,x              ;otherwise decrement the current timer

SkipExpTimer:  dex                       ;move onto next timer

               bpl DecTimersLoop         ;do this until all timers are dealt with

NoDecTimers:   inci FrameCounter          ;increment frame counter

              endif

PauseSkip:     ldxn ++$00

               ldyn ++$07

               lda PseudoRandomBitReg    ;get first memory location of LSFR bytes

               andn ++%00000010            ;mask out all but d1

               sta SCRATCHPAD+$00                   ;save here

               lda PseudoRandomBitReg+1  ;get second memory location

               andn ++%00000010            ;mask out all but d1

               eori SCRATCHPAD+$00                   ;perform exclusive-OR on d1 from first and second bytes

               clc                       ;if neither or both are set, carry will be clear

               beq RotPRandomBit

               sec                       ;if one or the other is set, carry will be set

RotPRandomBit: rorx PseudoRandomBitReg,x  ;rotate carry into d7, and rotate last bit into carry

               inx                       ;increment to next byte

               dey                       ;decrement for loop

               bne RotPRandomBit

randomskip              

               lda Sprite0HitDetectFlag  ;check for flag here

         checka

               beq SkipSprite0

               

              if Z80==0

Sprite0Clr:    lda PPU_STATUS            ;wait for sprite 0 flag to clear, which will

               andn ++%01000000            ;not happen until vblank has ended

               bne Sprite0Clr

              endif

              if DEMO

              ld a,(readdemo_stopflag)

              or a

              jr nz,Sprite0Hit

              endif

               lda GamePauseStatus       ;if in pause mode, do not bother with sprites at all

               lsr

               bcs Sprite0Hit

               jsr MoveSpritesOffscreen ;3443t (3 Goomba + 2 юўъш + ╠рЁшю)

               jsr SpriteShuffler ;545t

Sprite0Hit:

              if Z80==0

               lda PPU_STATUS            ;do sprite ++0 hit detection

               andn ++%01000000

               beq Sprite0Hit ;цф╕ь, ъюуфр сєфхЄ ъЁрщ ьюэхЄъш эртхЁїє ¤ъЁрэр - ¤Єю ъюэхЎ эхёъЁюыышЁєхьющ чюэ√

               ldyn ++$14                  ;small delay, to wait until we hit horizontal blank time

HBlankDelay:   dey

               bne HBlankDelay

              endif

             

SkipSprite0:   lda HorizontalScroll      ;set scroll registers from variables

               sta PPU_SCROLL_REG_H

               lda VerticalScroll

               sta PPU_SCROLL_REG_V

              if Z80==0

               lda Mirror_PPU_CTRL_REG1  ;load saved mirror of $2000

               pha

               sta PPU_CTRL_REG1

              endif

              if DEMO

              ld a,(readdemo_stopflag)

              or a

              jr nz,SkipMainOper

              endif

               lda GamePauseStatus       ;if in pause mode, do not perform operation mode stuff

               lsr ;яюўхьє ь√ т Ёхцшьх ярєч√??? 1

               bcs SkipMainOper

               jsr OperModeExecutionTree ;otherwise do one of many, many possible subroutines ;49489t (3 Goomba + 2 юўъш + ╠рЁшю)

SkipMainOper:

              if Z80==0

               lda PPU_STATUS            ;reset flip-flop

               pla

               oran ++%10000000            ;reactivate NMIs

               sta PPU_CTRL_REG1

              endif

               rti                       ;we are done until the next frame!

 

 

PauseRoutine:

               lda OperMode           ;are we in victory mode?

               cmpn ++VictoryModeValue  ;if so, go ahead

               beq ChkPauseTimer

               cmpn ++GameModeValue     ;are we in game mode?

               bne ExitPause          ;if not, leave

               lda OperMode_Task      ;if we are in game mode, are we running game engine?

               cmpn ++$03

               bne ExitPause          ;if not, leave

ChkPauseTimer: lda GamePauseTimer     ;check if pause timer is still counting down

         checka

               beq ChkStart

               deci GamePauseTimer     ;if so, decrement and leave

               rts

ChkStart:      lda SavedJoypad1Bits   ;check to see if start is pressed

               andn ++Start_Button      ;on controller 1

               beq ClrPauseTimer

               lda GamePauseStatus    ;check to see if timer flag is set

               andn ++%10000000         ;and if so, do not reset timer (residual,

               bne ExitPause          ;joypad reading routine makes this unnecessary)

               ;jr $

               ldan ++$2b               ;set pause timer

               sta GamePauseTimer

               lda GamePauseStatus

               tay

               iny                    ;set pause sfx queue for next pause mode

               sty PauseSoundQueue

               eorn ++%00000001         ;invert d0 and set d7

               oran ++%10000000

               bne SetPause           ;unconditional branch

ClrPauseTimer: lda GamePauseStatus    ;clear timer flag if timer is at zero and start button

               andn ++%01111111         ;is not pressed

SetPause:      sta GamePauseStatus

ExitPause:     rts

 

 

SpriteShuffler:

        if Z80

        else

               ldy AreaType                ;load level type, likely residual code

               ldan ++$28                    ;load preset value which will put it at

               sta SCRATCHPAD+$00                     ;sprite #10

               ldxn ++$0e                    ;start at the end of OAM data offsets

               

ShuffleLoop:   ldax SprDataOffset,x         ;check for offset value against

               cmpi SCRATCHPAD+$00                     ;the preset value

              cmpcy

               bcc NextSprOffset           ;if less, skip this part

               ldy SprShuffleAmtOffset     ;get current offset to preset value we want to add

               clc

               adcy SprShuffleAmt,y         ;get shuffle amount, add to current sprite offset

               bcc StrSprOffset            ;if not exceeded $ff, skip second add

               clc

               adci SCRATCHPAD+$00                     ;otherwise add preset value $28 to offset

StrSprOffset:  stax SprDataOffset,x         ;store new offset here or old one if branched to here

NextSprOffset: dex                         ;move backwards to next one

               bpl ShuffleLoop

               

               ldx SprShuffleAmtOffset     ;load offset

               inx

               cpxn ++$03                    ;check if offset + 1 goes to 3

               bne SetAmtOffset            ;if offset + 1 not 3, store

               ldxn ++$00                    ;otherwise, init to 0

SetAmtOffset:  stx SprShuffleAmtOffset

        endif

               ldxn ++$08                    ;load offsets for values and storage

               ldyn ++$02

               

SetMiscOffset: lday SprDataOffset+5,y       ;load one of three OAM data offsets

               stax Misc_SprDataOffset-2,x  ;store first one unmodified, but

               clc                         ;add eight to the second and eight

               adcn ++$08                    ;more to the third one

               stax Misc_SprDataOffset-1,x  ;note that due to the way X is set up,

               clc                         ;this code loads into the misc sprite offsets

               adcn ++$08

               stax Misc_SprDataOffset,x        

               dex

               dex

               dex

               dey

               bpl SetMiscOffset           ;do this until all misc spr offsets are loaded (3 °Єєъш)

               rts

 

 

OperModeExecutionTree:

      lda OperMode     ;this is the heart of the entire program,

      jsr JumpEngine   ;most of what goes on starts here

 

      .dw TitleScreenMode

      .dw GameMode

      .dw VictoryMode

      .dw GameOverMode

 

 

MoveAllSpritesOffscreen:

              ldyn ++$00                ;this routine moves all sprites off the screen

              jr MoveSpritesOffscreen_go;.db $2c                 ;BIT instruction opcode

 

MoveSpritesOffscreen:

              ldyn ++$04                ;this routine moves all but sprite 0

MoveSpritesOffscreen_go

              ldan ++$f8                ;off the screen

SprInitLoop:  stay Sprite_Y_Position,y ;write 248 into OAM data's Y coordinate

              iny                     ;which will move it off the screen

              iny

              iny

              iny

              bne SprInitLoop

              rts

 

 

TitleScreenMode:

      lda OperMode_Task

      jsr JumpEngine

 

      .dw InitializeGame

      .dw ScreenRoutines

      .dw PrimaryGameSetup

      .dw GameMenuRoutine

 

 

WSelectBufferTemplate:

      .db $04, $20, $73, $01, $00, $00

 

GameMenuRoutine:

        ;jr $

              ldyn ++$00

              lda SavedJoypad1Bits        ;check to see if either player pressed

              orai SavedJoypad2Bits        ;only the start button (either joypad)

              cmpn ++Start_Button

              beq StartGame

              cmpn ++A_Button+Start_Button  ;check to see if A + start was pressed

              bne ChkSelect               ;if not, branch to check select button

StartGame:    

        ;jr $

                jmp ChkContinue             ;if either start or A + start, execute here

ChkSelect:    cmpn ++Select_Button          ;check to see if the select button was pressed

              beq SelectBLogic            ;if so, branch reset demo timer

              ldx DemoTimer               ;otherwise check demo timer

         checkx

              bne ChkWorldSel             ;if demo timer not expired, branch to check world selection

              sta SelectTimer             ;set controller bits here if running demo

              jsr DemoEngine              ;run through the demo actions

              bcs ResetTitle              ;if carry flag set, demo over, thus branch

        ;jr $ ;ё■фр яюярфрхь

              jmp RunDemo                 ;otherwise, run game engine for demo

ChkWorldSel:  ldx WorldSelectEnableFlag   ;check to see if world selection has been enabled

         checkx

              beq NullJoypad

              cmpn ++B_Button               ;if so, check to see if the B button was pressed

              bne NullJoypad

              iny                         ;if so, increment Y and execute same code as select

SelectBLogic: lda DemoTimer               ;if select or B pressed, check demo timer one last time

        ;jr $ ;ё■фр яюярфрхь яю select

         checka

              beq ResetTitle              ;if demo timer expired, branch to reset title screen mode

        ;jr $ ;ё■фр яюярфрхь яю select Єюы№ъю ё яЁртшы№э√ьш ЄрщьхЁрьш

              ldan ++$18                    ;otherwise reset demo timer

              sta DemoTimer

              lda SelectTimer             ;check select/B button timer

         checka

              bne NullJoypad              ;if not expired, branch

              ldan ++$10                    ;otherwise reset select button timer

              sta SelectTimer

              cpyn ++$01                    ;was the B button pressed earlier?  if so, branch

              beq IncWorldSel             ;note this will not be run if world selection is disabled

        ;jr $ ;ё■фр яюярфрхь яю select Єюы№ъю ё яЁртшы№э√ьш ЄрщьхЁрьш

              lda NumberOfPlayers         ;if no, must have been the select button, therefore

              eorn ++%00000001              ;change number of players and draw icon accordingly

              sta NumberOfPlayers

              jsr DrawMushroomIcon

              jmp NullJoypad

IncWorldSel:  ldx WorldSelectNumber       ;increment world select number

              inx

              txa

              andn ++%00000111              ;mask out higher bits

              sta WorldSelectNumber       ;store as current world select number

              jsr GoContinue

UpdateShroom: ldax WSelectBufferTemplate,x ;write template for world select in vram buffer

              stax VRAM_Buffer1-1,x        ;do this until all bytes are written

              inx

              cpxn ++$06

              bmi UpdateShroom

              ldy WorldNumber             ;get world number from variable and increment for

              iny                         ;proper display, and put in blank byte before

              sty VRAM_Buffer1+3          ;null terminator

NullJoypad:   ldan ++$00                    ;clear joypad bits for player 1

              sta SavedJoypad1Bits

RunDemo:      jsr GameCoreRoutine         ;run game engine

              lda GameEngineSubroutine    ;check to see if we're running lose life routine

              cmpn ++$06

              bne ExitMenu                ;if not, do not do all the resetting below

ResetTitle:   ldan ++$00                    ;reset game modes, disable

              sta OperMode                ;sprite 0 check and disable

              sta OperMode_Task           ;screen output

              sta Sprite0HitDetectFlag

              inci DisableScreenFlag

              rts

ChkContinue:  ldy DemoTimer               ;if timer for demo has expired, reset modes

         checky

                ;jr $

              beq ResetTitle ;яюўхьє ьх°рхЄ фхьрь??? хёыш чръюььхэЄшЁютрЄ№, Єю шч фхь√ яю Start яюярфрхь эх т ьхэ■, р т шуЁє, ё сюы№°шь ╠рЁшю, хёыш юэ єцх сюы№°ющ

              asl                         ;check to see if A button was also pushed

              bcc StartWorld1             ;if not, don't load continue function's world number

              lda ContinueWorld           ;load previously saved world number for secret

              jsr GoContinue              ;continue function when pressing A + start

StartWorld1:  jsr LoadAreaPointer

 

        ;jr $ ;ё■фр яюярфрхь яю start

              inci Hidden1UpFlag           ;set 1-up box flag for both players

              inci OffScr_Hidden1UpFlag

              inci FetchNewGameTimerFlag   ;set fetch new game timer flag

              inci OperMode                ;set next game mode

              lda WorldSelectEnableFlag   ;if world select flag is on, then primary

              sta PrimaryHardMode         ;hard mode must be on as well

              ldan ++$00

              sta OperMode_Task           ;set game mode here, and clear demo timer

              sta DemoTimer

              ldxn ++$17

              ldan ++$00

InitScores:   stax ScoreAndCoinDisplay,x   ;clear player scores and coin displays

              dex

              bpl InitScores

ExitMenu:     rts

GoContinue:   sta WorldNumber             ;start both players at the first area

              sta OffScr_WorldNumber      ;of the previously saved world number

              ldxn ++$00                    ;note that on power-up using this function

              stx AreaNumber              ;will make no difference

              stx OffScr_AreaNumber  

              rts

 

 

MushroomIconData:

      .db $07, $22, $49, $83, $ce, $24, $24, $00

 

DrawMushroomIcon:

              ldyn ++$07                ;read eight bytes to be read by transfer routine

IconDataRead: lday MushroomIconData,y  ;note that the default position is set for a

              stay VRAM_Buffer1-1,y    ;1-player game

              dey

              bpl IconDataRead

              lda NumberOfPlayers     ;check number of players

         checka

              beq ExitIcon            ;if set to 1-player game, we're done

              ldan ++$24                ;otherwise, load blank tile in 1-player position

              sta VRAM_Buffer1+3

              ldan ++$ce                ;then load shroom icon tile in 2-player position

              sta VRAM_Buffer1+5

ExitIcon:     rts

 

 

DemoActionData:

      .db $01, $80, $02, $81, $41, $80, $01

      .db $42, $c2, $02, $80, $41, $c1, $41, $c1

      .db $01, $c1, $01, $02, $80, $00

 

DemoTimingData:

      .db $9b, $10, $18, $05, $2c, $20, $24

      .db $15, $5a, $10, $20, $28, $30, $20, $10

      .db $80, $20, $30, $30, $01, $ff, $00

 

DemoEngine:

          ldx DemoAction         ;load current demo action

          lda DemoActionTimer    ;load current action timer

         checka

          bne DoAction           ;if timer still counting down, skip

          inx

          inci DemoAction         ;if expired, increment action, X, and

          sec                    ;set carry by default for demo over

          ldax DemoTimingData-1,x ;get next timer

        if Z80

        sec

        endif

          sta DemoActionTimer    ;store as current timer

         checka

          beq DemoOver           ;if timer already at zero, skip

DoAction: ldax DemoActionData-1,x ;get and perform action (current or next)

          sta SavedJoypad1Bits

          deci DemoActionTimer    ;decrement action timer

          clc                    ;clear carry if demo still going

DemoOver: rts

 

 

VictoryMode:

            jsr VictoryModeSubroutines  ;run victory mode subroutines

            lda OperMode_Task           ;get current task of victory mode

         checka

            beq AutoPlayer              ;if on bridge collapse, skip enemy processing

            ldxn ++$00

            stx ObjectOffset            ;otherwise reset enemy object offset

            jsr EnemiesAndLoopsCore     ;and run enemy code

AutoPlayer: jsr RelativePlayerPosition  ;get player's relative coordinates

            jmp PlayerGfxHandler        ;draw the player, then leave

 

VictoryModeSubroutines:

      lda OperMode_Task

      jsr JumpEngine

 

      .dw BridgeCollapse

      .dw SetupVictoryMode

      .dw PlayerVictoryWalk

      .dw PrintVictoryMessages

      .dw PlayerEndWorld

 

 

SetupVictoryMode:

      ldx ScreenRight_PageLoc  ;get page location of right side of screen

      inx                      ;increment to next page

      stx DestinationPageLoc   ;store here

      ldan ++EndOfCastleMusic

      sta EventMusicQueue      ;play win castle music

      jmp IncModeTask_B        ;jump to set next major task in victory mode

 

 

PlayerVictoryWalk:

             ldyn ++$00                ;set value here to not walk player by default

             sty VictoryWalkControl

             lda Player_PageLoc      ;get player's page location

             cmpi DestinationPageLoc  ;compare with destination page location

             bne PerformWalk         ;if page locations don't match, branch

             lda Player_X_Position   ;otherwise get player's horizontal position

             cmpn ++$60                ;compare with preset horizontal position

              cmpcy

             bcs DontWalk            ;if still on other page, branch ahead

PerformWalk: inci VictoryWalkControl  ;otherwise increment value and Y

             iny                     ;note Y will be used to walk the player

DontWalk:    tya                     ;put contents of Y in A and

             jsr AutoControlPlayer   ;use A to move player to the right or not

             lda ScreenLeft_PageLoc  ;check page location of left side of screen

             cmpi DestinationPageLoc  ;against set value here

             beq ExitVWalk           ;branch if equal to change modes if necessary

             lda ScrollFractional

             clc                     ;do fixed point math on fractional part of scroll

             adcn ++$80        

             sta ScrollFractional    ;save fractional movement amount

             ldan ++$01                ;set 1 pixel per frame

             adcn ++$00                ;add carry from previous addition

             tay                     ;use as scroll amount

             jsr ScrollScreen        ;do sub to scroll the screen

             jsr UpdScrollVar        ;do another sub to update screen and scroll variables

             inci VictoryWalkControl  ;increment value to stay in this routine

ExitVWalk:   lda VictoryWalkControl  ;load value set here

         checka

             beq IncModeTask_A       ;if zero, branch to change modes

             rts                     ;otherwise leave

 

 

PrintVictoryMessages:

               lda SecondaryMsgCounter   ;load secondary message counter

         checka

               bne IncMsgCounter         ;if set, branch to increment message counters

               lda PrimaryMsgCounter     ;otherwise load primary message counter

         checka

               beq ThankPlayer           ;if set to zero, branch to print first message

               cmpn ++$09                  ;if at 9 or above, branch elsewhere (this comparison

              cmpcy

               bcs IncMsgCounter         ;is residual code, counter never reaches 9)

               ldy WorldNumber           ;check world number

               cpyn ++World8

               bne MRetainerMsg          ;if not at world 8, skip to next part

               cmpn ++$03                  ;check primary message counter again

              cmpcy

               bcc IncMsgCounter         ;if not at 3 yet (world 8 only), branch to increment

              cmpcy

               sbcn ++$01                  ;otherwise subtract one

               jmp ThankPlayer           ;and skip to next part

MRetainerMsg:  cmpn ++$02                  ;check primary message counter

              cmpcy

               bcc IncMsgCounter         ;if not at 2 yet (world 1-7 only), branch

ThankPlayer:   tay                       ;put primary message counter into Y

         checka

               bne SecondPartMsg         ;if counter nonzero, skip this part, do not print first message

               lda CurrentPlayer         ;otherwise get player currently on the screen

         checka

               beq EvalForMusic          ;if mario, branch

               iny                       ;otherwise increment Y once for luigi and

               bne EvalForMusic          ;do an unconditional branch to the same place

SecondPartMsg: iny                       ;increment Y to do world 8's message

               lda WorldNumber

               cmpn ++World8               ;check world number

               beq EvalForMusic          ;if at world 8, branch to next part

               dey                       ;otherwise decrement Y for world 1-7's message

               cpyn ++$04                  ;if counter at 4 (world 1-7 only)

              cmpcy

               bcs SetEndTimer           ;branch to set victory end timer

               cpyn ++$03                  ;if counter at 3 (world 1-7 only)

              cmpcy

               bcs IncMsgCounter         ;branch to keep counting

EvalForMusic:  cpyn ++$03                  ;if counter not yet at 3 (world 8 only), branch

               bne PrintMsg              ;to print message only (note world 1-7 will only

               ldan ++VictoryMusic         ;reach this code if counter = 0, and will always branch)

               sta EventMusicQueue       ;otherwise load victory music first (world 8 only)

PrintMsg:      tya                       ;put primary message counter in A

               clc                       ;add $0c or 12 to counter thus giving an appropriate value,

               adcn ++$0c                  ;($0c-$0d = first), ($0e = world 1-7's), ($0f-$12 = world 8's)

               sta VRAM_Buffer_AddrCtrl  ;write message counter to vram address controller

IncMsgCounter: lda SecondaryMsgCounter

               clc

               adcn ++$04                      ;add four to secondary message counter

               sta SecondaryMsgCounter

               lda PrimaryMsgCounter

               adcn ++$00                      ;add carry to primary message counter

               sta PrimaryMsgCounter

               cmpn ++$07                      ;check primary counter one more time

              cmpcy

SetEndTimer:

               bcc ExitMsgs                  ;if not reached value yet, branch to leave

               ldan ++$06

               sta WorldEndTimer             ;otherwise set world end timer

IncModeTask_A: inci OperMode_Task             ;move onto next task in mode

ExitMsgs:      rts                           ;leave

 

 

PlayerEndWorld:

               lda WorldEndTimer          ;check to see if world end timer expired

         checka

               bne EndExitOne             ;branch to leave if not

               ldy WorldNumber            ;check world number

               cpyn ++World8                ;if on world 8, player is done with game,

              cmpcy

               bcs EndChkBButton          ;thus branch to read controller

               ldan ++$00

               sta AreaNumber             ;otherwise initialize area number used as offset

               sta LevelNumber            ;and level number control to start at area 1

               sta OperMode_Task          ;initialize secondary mode of operation

               inci WorldNumber            ;increment world number to move onto the next world

               jsr LoadAreaPointer        ;get area address offset for the next area

               inci FetchNewGameTimerFlag  ;set flag to load game timer from header

               ldan ++GameModeValue

               sta OperMode               ;set mode of operation to game mode

EndExitOne:    rts                        ;and leave

EndChkBButton: lda SavedJoypad1Bits

               orai SavedJoypad2Bits       ;check to see if B button was pressed on

               andn ++B_Button              ;either controller

               beq EndExitTwo             ;branch to leave if not

               ldan ++$01                   ;otherwise set world selection flag

               sta WorldSelectEnableFlag

               ldan ++$ff                   ;remove onscreen player's lives

               sta NumberofLives

               jsr TerminateGame          ;do sub to continue other player or end game

EndExitTwo:    rts                        ;leave

 

 

FloateyNumTileData:

      .db $ff, $ff ;dummy

      .db $f6, $fb ; "100"

      .db $f7, $fb ; "200"

      .db $f8, $fb ; "400"

      .db $f9, $fb ; "500"

      .db $fa, $fb ; "800"

      .db $f6, $50 ; "1000"

      .db $f7, $50 ; "2000"

      .db $f8, $50 ; "4000"

      .db $f9, $50 ; "5000"

      .db $fa, $50 ; "8000"

      .db $fd, $fe ; "1-UP"

 

ScoreUpdateData:

      .db $ff ;dummy

      .db $41, $42, $44, $45, $48

      .db $31, $32, $34, $35, $38, $00

 

FloateyNumbersRoutine:

              ldax FloateyNum_Control,x     ;load control for floatey number

         checka

              beq EndExitOne               ;if zero, branch to leave

              cmpn ++$0b                     ;if less than $0b, branch

              cmpcy

              bcc ChkNumTimer

              ldan ++$0b                     ;otherwise set to $0b, thus keeping

              stax FloateyNum_Control,x     ;it in range

ChkNumTimer:  tay                          ;use as Y

              ldax FloateyNum_Timer,x       ;check value here

         checka

              bne DecNumTimer              ;if nonzero, branch ahead

              stax FloateyNum_Control,x     ;initialize floatey number control and leave

              rts

DecNumTimer:  decx FloateyNum_Timer,x       ;decrement value here

              cmpn ++$2b                     ;if not reached a certain point, branch  

              bne ChkTallEnemy

              cpyn ++$0b                     ;check offset for $0b

              bne LoadNumTiles             ;branch ahead if not found

              inci NumberofLives            ;give player one extra life (1-up)

              ldan ++Sfx_ExtraLife

              sta Square2SoundQueue        ;and play the 1-up sound

LoadNumTiles: lday ScoreUpdateData,y        ;load point value here

              lsr                          ;move high nybble to low

              lsr

              lsr

              lsr

              tax                          ;use as X offset, essentially the digit

              lday ScoreUpdateData,y        ;load again and this time

              andn ++%00001111               ;mask out the high nybble

              stax DigitModifier,x          ;store as amount to add to the digit

              jsr AddToScore               ;update the score accordingly

ChkTallEnemy: ldyx Enemy_SprDataOffset,x    ;get OAM data offset for enemy object

              ldax Enemy_ID,x               ;get enemy object identifier

              cmpn ++Spiny

              beq FloateyPart              ;branch if spiny

              cmpn ++PiranhaPlant

              beq FloateyPart              ;branch if piranha plant

              cmpn ++HammerBro

              beq GetAltOffset             ;branch elsewhere if hammer bro

              cmpn ++GreyCheepCheep

              beq FloateyPart              ;branch if cheep-cheep of either color

              cmpn ++RedCheepCheep

              beq FloateyPart

              cmpn ++TallEnemy

              cmpcy

              bcs GetAltOffset             ;branch elsewhere if enemy object =HIGH  $09

              ldax Enemy_State,x

              cmpn ++$02                     ;if enemy state defeated or otherwise

              cmpcy

              bcs FloateyPart              ;$02 or greater, branch beyond this part

GetAltOffset: ldx SprDataOffset_Ctrl       ;load some kind of control bit

              ldyx Alt_SprDataOffset,x      ;get alternate OAM data offset

              ldx ObjectOffset             ;get enemy object offset again

FloateyPart:  ldax FloateyNum_Y_Pos,x       ;get vertical coordinate for

              cmpn ++$18                     ;floatey number, if coordinate in the

              cmpcy

              bcc SetupNumSpr              ;status bar, branch

              cmpcy

              sbcn ++$01

              stax FloateyNum_Y_Pos,x       ;otherwise subtract one and store as new

SetupNumSpr:  ldax FloateyNum_Y_Pos,x       ;get vertical coordinate

             or a

              sbcn ++$08                     ;subtract eight and dump into the

              jsr DumpTwoSpr               ;left and right sprite's Y coordinates

              ldax FloateyNum_X_Pos,x       ;get horizontal coordinate

              stay Sprite_X_Position,y      ;store into X coordinate of left sprite

              clc

              adcn ++$08                     ;add eight pixels and store into X

              stay Sprite_X_Position+4,y    ;coordinate of right sprite

              ldan ++$02

              stay Sprite_Attributes,y      ;set palette control in attribute bytes

              stay Sprite_Attributes+4,y    ;of left and right sprites

              ldax FloateyNum_Control,x

              asl                          ;multiply our floatey number control by 2

              tax                          ;and use as offset for look-up table

              ldax FloateyNumTileData,x

              stay Sprite_Tilenumber,y      ;display first half of number of points

              ldax FloateyNumTileData+1,x

              stay Sprite_Tilenumber+4,y    ;display the second half

              ldx ObjectOffset             ;get enemy object offset and leave

              rts

 

 

ScreenRoutines:

      lda ScreenRoutineTask        ;run one of the following subroutines

      jsr JumpEngine

   

      .dw InitScreen ;0

      .dw SetupIntermediate ;1

      .dw WriteTopStatusLine ;2

      .dw WriteBottomStatusLine ;3

      .dw DisplayTimeUp ;4

      .dw ResetSpritesAndScreenTimer ;5

      .dw DisplayIntermediate ;6

      .dw ResetSpritesAndScreenTimer ;7

      .dw AreaParserTaskControl ;8

      .dw GetAreaPalette ;9

      .dw GetBackgroundColor ;10

      .dw GetAlternatePalette1 ;11

      .dw DrawTitleScreen ;12

      .dw ClearBuffersDrawIcon ;13

      .dw WriteTopScore ;14

 

 

InitScreen:

      jsr MoveAllSpritesOffscreen ;initialize all sprites including sprite ++0

      jsr InitializeNameTables    ;and erase both name and attribute tables

      lda OperMode

         checka

      beq NextSubtask             ;if mode still 0, do not load

      ldxn ++$03                    ;into buffer pointer

      jmp SetVRAMAddr_A

 

 

SetupIntermediate:

      lda BackgroundColorCtrl  ;save current background color control

      pha                      ;and player status to stack

      lda PlayerStatus

      pha

      ldan ++$00                 ;set background color to black

      sta PlayerStatus         ;and player status to not fiery

      ldan ++$02                 ;this is the ONLY time background color control

      sta BackgroundColorCtrl  ;is set to less than 4

      jsr GetPlayerColors

      pla                      ;we only execute this routine for

      sta PlayerStatus         ;the intermediate lives display

      pla                      ;and once we're done, we return bg

      sta BackgroundColorCtrl  ;color ctrl and player status from stack

      jmp IncSubtask           ;then move onto the next task

 

 

        if Z80==0

AreaPalette:

      .db $01, $02, $03, $04

        endif

 

GetAreaPalette:

        if Z80

                ld a,(AreaType)

                add a,a

                ld e,a

                ld hl,tpalettes

                add hl,de

                ld a,(hl)

                inc hl

                ld h,(hl)

                ld l,a

                ld (curpalette),hl

                jp IncSubtask           ;move onto next task

        else

               ldy AreaType             ;select appropriate palette to load

               ldxy AreaPalette,y        ;based on area type

        endif

SetVRAMAddr_A: stx VRAM_Buffer_AddrCtrl ;store offset into buffer control

NextSubtask:   jmp IncSubtask           ;move onto next task

 

 

BGColorCtrl_Addr:

      .db $00, $09, $0a, $04

 

BackgroundColors:

        if Z80BGCOLOR

        db 0xcc,0xcc,0xff,0xff ;used by area type if bg color ctrl not set

        db 0xff,0xcc,0xff,0xff ;used by background color control if set

        else

      .db $22, $22, $0f, $0f ;used by area type if bg color ctrl not set

      .db $0f, $22, $0f, $0f ;used by background color control if set

        endif

 

PlayerColors:

        if Z80MARIOCOLOR

      dw 0x3f3f,0xbdbd ;mario's colors

      dw 0x3f3f,0xefef ;luigi's colors

      dw 0x3f3f,0x0c0c ;fiery (used by both)

        else

      .db $22, $16, $27, $18 ;mario's colors

      .db $22, $30, $27, $19 ;luigi's colors

      .db $22, $37, $27, $16 ;fiery (used by both)

        endif

 

GetBackgroundColor:

           ldy BackgroundColorCtrl   ;check background color control

         checky

           beq NoBGColor             ;if not set, increment task and fetch palette

        if Z80BGCOLOR

        else

           lday BGColorCtrl_Addr-4,y  ;put appropriate palette into vram

           sta VRAM_Buffer_AddrCtrl  ;note that if set to 5-7, $0301 (VRAM_Buffer1) will not be read

        endif

NoBGColor: inci ScreenRoutineTask     ;increment to next subtask and plod on through

     

GetPlayerColors:

        if Z80MARIOCOLOR

               lda CurrentPlayer        ;check which player is on the screen

               ld de,PlayerColors

               or a

               beq ChkFiery

               ld de,PlayerColors+4;ldyn ++$04                 ;load offset for luigi

ChkFiery:      lda PlayerStatus         ;check player status

               cmpn ++$02

               bne StartClrGet          ;if fiery, load alternate offset for fiery player

               ld de,PlayerColors+8;ldyn ++$08

StartClrGet:

               ld hl,(curpalette)

               ld c,12*2

               add hl,bc

               ex de,hl

               ;c>=4

               ldi

               ldi

               inc de

               inc de

               ldi

               ldi

               ld (oldpalette),hl ;!=curpalette, ўЄюс√ ртЄюьрЄшўхёъш юсэютшырё№

 

               ld d,b

 

          if Z80BGCOLOR

               ldy BackgroundColorCtrl  ;if this value is four or greater, it will be set

         checky

               bne SetBGColor           ;therefore use it as offset to background color

               ldy AreaType             ;otherwise use area type bits from area offset as offset

SetBGColor:    lday BackgroundColors,y   ;to background color instead

               ;jr $

               ld hl,(curpalette)

               ld (hl),a

               inc hl

               ld (hl),a

          endif

 

                ret

        else

               ldx VRAM_Buffer1_Offset  ;get current buffer offset

               ldyn ++$00

               lda CurrentPlayer        ;check which player is on the screen

         checka

               beq ChkFiery

               ldyn ++$04                 ;load offset for luigi

ChkFiery:      lda PlayerStatus         ;check player status

               cmpn ++$02

               bne StartClrGet          ;if fiery, load alternate offset for fiery player

               ldyn ++$08

StartClrGet:   ldan ++$03                 ;do four colors

               sta SCRATCHPAD+$00

ClrGetLoop:    lday PlayerColors,y       ;fetch player colors and store them

               stax VRAM_Buffer1+3,x     ;in the buffer

               iny

               inx

               deci SCRATCHPAD+$00

               bpl ClrGetLoop

               ldx VRAM_Buffer1_Offset  ;load original offset from before

               ldy BackgroundColorCtrl  ;if this value is four or greater, it will be set

         checky

               bne SetBGColor           ;therefore use it as offset to background color

               ldy AreaType             ;otherwise use area type bits from area offset as offset

SetBGColor:    lday BackgroundColors,y   ;to background color instead

               stax VRAM_Buffer1+3,x

               ldan ++HIGH PPU_SPRPAL;++$3f                 ;set for sprite palette address

               stax VRAM_Buffer1,x       ;save to buffer

               ldan ++LOW PPU_SPRPAL;++$10

               stax VRAM_Buffer1+1,x

               ldan ++$04                 ;write length byte to buffer

               stax VRAM_Buffer1+2,x

               ldan ++$00                 ;now the null terminator

               stax VRAM_Buffer1+7,x

               txa                      ;move the buffer pointer ahead 7 bytes

               clc                      ;in case we want to write anything else later

               adcn ++$07

        endif

SetVRAMOffset: sta VRAM_Buffer1_Offset  ;store as new vram buffer offset

               rts

 

 

GetAlternatePalette1:

               lda AreaStyle            ;check for mushroom level style

               cmpn ++$01

               bne NoAltPal

               ldan ++$0b                 ;if found, load appropriate palette

SetVRAMAddr_B: sta VRAM_Buffer_AddrCtrl

NoAltPal:      jmp IncSubtask           ;now onto the next task

 

 

WriteTopStatusLine:

      ldan ++$00          ;select main status bar

      jsr WriteGameText ;output it

      jmp IncSubtask    ;onto the next task

 

 

WriteBottomStatusLine:

      jsr GetSBNybbles        ;write player's score and coin tally to screen

      ldx VRAM_Buffer1_Offset

      ldan ++$20                ;write address for world-area number on screen

      stax VRAM_Buffer1,x

      ldan ++$73

      stax VRAM_Buffer1+1,x

      ldan ++$03                ;write length for it

      stax VRAM_Buffer1+2,x

      ldy WorldNumber         ;first the world number

      iny

      tya

      stax VRAM_Buffer1+3,x

      ldan ++$28                ;next the dash

      stax VRAM_Buffer1+4,x

      ldy LevelNumber         ;next the level number

      iny                     ;increment for proper number display

      tya

      stax VRAM_Buffer1+5,x    

      ldan ++$00                ;put null terminator on

      stax VRAM_Buffer1+6,x

      txa                     ;move the buffer offset up by 6 bytes

      clc

      adcn ++$06

      sta VRAM_Buffer1_Offset

      jmp IncSubtask

 

 

DisplayTimeUp:

          lda GameTimerExpiredFlag  ;if game timer not expired, increment task

         checka

          beq NoTimeUp              ;control 2 tasks forward, otherwise, stay here

          ldan ++$00

          sta GameTimerExpiredFlag  ;reset timer expiration flag

          ldan ++$02                  ;output time-up screen to buffer

          jmp OutputInter

NoTimeUp: inci ScreenRoutineTask     ;increment control task 2 tasks forward

          jmp IncSubtask

 

 

DisplayIntermediate:

               lda OperMode                 ;check primary mode of operation

         checka

               beq NoInter                  ;if in title screen mode, skip this

               cmpn ++GameOverModeValue       ;are we in game over mode?

               beq GameOverInter            ;if so, proceed to display game over screen

               lda AltEntranceControl       ;otherwise check for mode of alternate entry

         checka

               bne NoInter                  ;and branch if found

               ldy AreaType                 ;check if we are on castle level

               cpyn ++$03                     ;and if so, branch (possibly residual)

               beq PlayerInter

               lda DisableIntermediate      ;if this flag is set, skip intermediate lives display

         checka

               bne NoInter                  ;and jump to specific task, otherwise

PlayerInter:   jsr DrawPlayer_Intermediate  ;put player in appropriate place for

               ldan ++$01                     ;lives display, then output lives display to buffer

OutputInter:   jsr WriteGameText

               jsr ResetScreenTimer

               ldan ++$00

               sta DisableScreenFlag        ;reenable screen output

               rts

GameOverInter: ldan ++$12                     ;set screen timer

               sta ScreenTimer

               ldan ++$03                     ;output game over screen to buffer

               jsr WriteGameText

               jmp IncModeTask_B

NoInter:       ldan ++$08                     ;set for specific task (AreaParserTaskControl) and leave

               sta ScreenRoutineTask

               rts

 

 

AreaParserTaskControl:

           inci DisableScreenFlag     ;turn off screen

TaskLoop:  jsr AreaParserTaskHandler ;render column set of current area

           lda AreaParserTaskNum     ;check number of tasks

         checka

           bne TaskLoop              ;if tasks still not all done, do another one

           deci ColumnSets            ;do we need to render more column sets?

           bpl OutputCol

           inci ScreenRoutineTask     ;if not, move on to the next task

OutputCol: ldan ++$06                  ;set vram buffer to output rendered column set

           sta VRAM_Buffer_AddrCtrl  ;on next NMI

           rts

 

 

 

DrawTitleScreen:

        ;jr $

            lda OperMode                 ;are we in title screen mode?

         checka

            bne IncModeTask_B            ;if not, exit

        if Z80

DrawTitleScreen_go

            ld hl,TitleScreen

            ld de,VRAM_Buffer1_Offset

            ld bc,TitleScreenDataSize ;0x13a = 314 (ёЄЁрээюх ўшёыю???)

            ldir

            ld d,b;0

        else

            ldan ++HIGH TitleScreenDataOffset  ;load address $1ec0 into

            sta PPU_ADDRESS              ;the vram address register

            ldan ++LOW TitleScreenDataOffset

            sta PPU_ADDRESS

            ldan ++$03                     ;put address $0300 into

            sta SCRATCHPAD+$01                      ;the indirect at $00

            ldyn ++$00

            sty SCRATCHPAD+$00

            lda PPU_DATA                 ;do one garbage read

OutputTScr: lda PPU_DATA                 ;get title screen from chr-rom

            stayindirect (SCRATCHPAD+$00),y                  ;store 256 bytes into buffer

            iny

            bne ChkHiByte                ;if not past 256 bytes, do not increment

            inci SCRATCHPAD+$01                      ;otherwise increment high byte of indirect

ChkHiByte:  lda SCRATCHPAD+$01                      ;check high byte?

            cmpn ++$04                     ;at $0400?

            bne OutputTScr               ;if not, loop back and do another

            cpyn ++$3a                     ;check if offset points past end of data

              cmpcy

            bcc OutputTScr               ;if not, loop back and do another

        endif

            ldan ++$05                     ;set buffer transfer control to $0300,

            jmp SetVRAMAddr_B            ;increment task and exit

 

 

ClearBuffersDrawIcon:

             lda OperMode               ;check game mode

         checka

             bne IncModeTask_B          ;if not title screen mode, leave

             ldxn ++$00                   ;otherwise, clear buffer space

TScrClear:   stax VRAM_Buffer1-1,x

             stax VRAM_Buffer1-1+$100,x ;??? яюўхьє Єръ ьэюую?

             dex

             bne TScrClear

             jsr DrawMushroomIcon       ;draw player select icon

IncSubtask:  inci ScreenRoutineTask      ;move onto next task

             rts

 

 

WriteTopScore:

               ldan ++$fa           ;run display routine to display top score on title

               jsr UpdateNumber

IncModeTask_B: inci OperMode_Task  ;move onto next mode

               rts

 

 

GameText:

TopStatusBarLine:

  .db $20, $43, $05,  $16, $0a, $1b, $12, $18 ; "MARIO"

  .db $20, $52, $0b,  $20, $18, $1b, $15, $0d ; "WORLD  TIME"

  .db $24, $24, $1d,  $12, $16, $0e

  .db $20, $68, $05,  $00, $24, $24, $2e, $29 ; score trailing digit and coin display

  .db $23, $c0,  $7f, $aa ; attribute table data, clears name table 0 to palette 2

  .db $23, $c2, $01,  $ea ; attribute table data, used for coin icon in status bar

  .db $ff ; end of data block

 

WorldLivesDisplay:

  .db $21, $cd, $07,  $24, $24 ; cross with spaces used on

  .db $29, $24, $24,  $24, $24 ; lives display

  .db $21, $4b, $09,  $20, $18 ; "WORLD  - " used on lives display

  .db $1b, $15, $0d, $24, $24, $28, $24

  .db $22, $0c,  $47, $24 ; possibly used to clear time up

  .db $23, $dc, $01,  $ba ; attribute table data for crown if more than 9 lives

  .db $ff

 

TwoPlayerTimeUp:

  .db $21, $cd, $05,  $16, $0a, $1b, $12, $18 ; "MARIO"

OnePlayerTimeUp:

  .db $22, $0c, $07,  $1d, $12, $16, $0e, $24, $1e, $19 ; "TIME UP"

  .db $ff

 

TwoPlayerGameOver:

  .db $21, $cd, $05,  $16, $0a, $1b, $12, $18 ; "MARIO"

OnePlayerGameOver:

  .db $22, $0b, $09,  $10, $0a, $16, $0e, $24 ; "GAME OVER"

  .db $18, $1f, $0e, $1b

  .db $ff

 

WarpZoneWelcome:

  .db $25, $84, $15,  $20, $0e, $15, $0c, $18, $16 ; "WELCOME TO WARP ZONE!"

  .db $0e, $24, $1d, $18, $24, $20, $0a, $1b, $19

  .db $24, $23, $18, $17, $0e, $2b

  .db $26, $25, $01,  $24         ; placeholder for left pipe

  .db $26, $2d, $01,  $24         ; placeholder for middle pipe

  .db $26, $35, $01,  $24         ; placeholder for right pipe

  .db $27, $d9,  $46, $aa         ; attribute data

  .db $27, $e1,  $45, $aa

  .db $ff

 

LuigiName:

  .db $15, $1e, $12, $10, $12    ; "LUIGI", no address or length

 

WarpZoneNumbers:

  .db $04, $03, $02, $00         ; warp zone numbers, note spaces on middle

  .db $24, $05, $24, $00         ; zone, partly responsible for

  .db $08, $07, $06, $00         ; the minus world

 

GameTextOffsets:

  .db TopStatusBarLine-GameText, TopStatusBarLine-GameText

  .db WorldLivesDisplay-GameText, WorldLivesDisplay-GameText

  .db TwoPlayerTimeUp-GameText, OnePlayerTimeUp-GameText

  .db TwoPlayerGameOver-GameText, OnePlayerGameOver-GameText

  .db WarpZoneWelcome-GameText, WarpZoneWelcome-GameText

 

WriteGameText:

               pha                      ;save text number to stack

               asl

               tay                      ;multiply by 2 and use as offset

               cpyn ++$04                 ;if set to do top status bar or world/lives display,

              cmpcy

               bcc LdGameText           ;branch to use current offset as-is

               cpyn ++$08                 ;if set to do time-up or game over,

              cmpcy

               bcc Chk2Players          ;branch to check players

               ldyn ++$08                 ;otherwise warp zone, therefore set offset

Chk2Players:   lda NumberOfPlayers      ;check for number of players

         checka

               bne LdGameText           ;if there are two, use current offset to also print name

               iny                      ;otherwise increment offset by one to not print name

LdGameText:    ldxy GameTextOffsets,y    ;get offset to message we want to print

               ldyn ++$00

GameTextLoop:  ldax GameText,x           ;load message data

               cmpn ++$ff                 ;check for terminator

               beq EndGameText          ;branch to end text if found

               stay VRAM_Buffer1,y       ;otherwise write data to buffer

               inx                      ;and increment increment

               iny

               bne GameTextLoop         ;do this for 256 bytes if no terminator found

EndGameText:   ldan ++$00                 ;put null terminator at end

               stay VRAM_Buffer1,y

               pla                      ;pull original text number from stack

               tax

               cmpn ++$04                 ;are we printing warp zone?

              cmpcy

               bcs PrintWarpZoneNumbers

               dex                      ;are we printing the world/lives display?

               bne CheckPlayerName      ;if not, branch to check player's name

               lda NumberofLives        ;otherwise, check number of lives

               clc                      ;and increment by one for display

               adcn ++$01

               cmpn ++10                  ;more than 9 lives?

              cmpcy

               bcc PutLives

              cmpcy

               sbcn ++10                  ;if so, subtract 10 and put a crown tile

               ldyn ++$9f                 ;next to the difference...strange things happen if

               sty VRAM_Buffer1+7       ;the number of lives exceeds 19

PutLives:      sta VRAM_Buffer1+8

               ldy WorldNumber          ;write world and level numbers (incremented for display)

               iny                      ;to the buffer in the spaces surrounding the dash

               sty VRAM_Buffer1+19

               ldy LevelNumber

               iny

               sty VRAM_Buffer1+21      ;we're done here

               rts

 

CheckPlayerName:

             lda NumberOfPlayers    ;check number of players

         checka

             beq ExitChkName        ;if only 1 player, leave

             lda CurrentPlayer      ;load current player

             dex                    ;check to see if current message number is for time up

             bne ChkLuigi

             ldy OperMode           ;check for game over mode

             cpyn ++GameOverModeValue

             beq ChkLuigi

             eorn ++%00000001         ;if not, must be time up, invert d0 to do other player

ChkLuigi:    lsr

             bcc ExitChkName        ;if mario is current player, do not change the name

             ldyn ++$04

NameLoop:    lday LuigiName,y        ;otherwise, replace "MARIO" with "LUIGI"

             stay VRAM_Buffer1+3,y

             dey

             bpl NameLoop           ;do this until each letter is replaced

ExitChkName: rts

 

PrintWarpZoneNumbers:

            or a

             sbcn ++$04               ;subtract 4 and then shift to the left

             asl                    ;twice to get proper warp zone number

             asl                    ;offset

             tax

             ldyn ++$00

WarpNumLoop: ldax WarpZoneNumbers,x  ;print warp zone numbers into the

             stay VRAM_Buffer1+27,y  ;placeholders from earlier

             inx

             iny                    ;put a number in every fourth space

             iny

             iny

             iny

             cpyn ++$0c

              cmpcy

             bcc WarpNumLoop

             ldan ++$2c               ;load new buffer pointer at end of message

             jmp SetVRAMOffset

 

 

ResetSpritesAndScreenTimer:

         lda ScreenTimer             ;check if screen timer has expired

         checka

         bne NoReset                 ;if not, branch to leave

         jsr MoveAllSpritesOffscreen ;otherwise reset sprites now

 

ResetScreenTimer:

         ldan ++$07                    ;reset timer again

         sta ScreenTimer

         inci ScreenRoutineTask       ;move onto next task

NoReset: rts

 

 

RenderAreaGraphics:

           if Z80OPT4

            ;lda CurrentColumnPos         ;store LSB of where we're at

            ;andn ++$01

            ;sta SCRATCHPAD+$05

            ldy VRAM_Buffer2_Offset      ;store vram buffer offset

            ld ix,VRAM_Buffer2

            add ix,de

            ld a,(CurrentNTAddr_Low)        ;get current name table address we're supposed to render

            ld (ix+1),a;stay VRAM_Buffer2+1,y

            ld a,(CurrentNTAddr_High)

            ld (ix+0),a;stay VRAM_Buffer2,y

            ld a,++$9a                     ;store length byte of 26 here with d7 set

            ld (ix+2),a;stay VRAM_Buffer2+2,y         ;to increment by 32 (in columns)            

            ld bc,MetatileBuffer;ld c,0                    ;row

            ld hy,13

DrawMTLoop:

        ;ld hl,MetatileBuffer

        ;add hl,bc

        ld a,(bc);(hl);ldax MetatileBuffer,x         ;get first metatile number ;%xx000000 - attribute table bits, %00xxxxxx - metatile number

            ld e,d;0

            add a,a ;*2

            rl e

            add a,a ;*4

            rl e ;e=0..3

            ld hl,AreaParserTaskNum        ;get current task number for level processing and

            bit 0,(hl) ;get current task number for level processing and mask out all but LSB

            jr nz,$+4

             add a,2 ;multiply by 2, then add to the tile offset so we can draw either side of the metatiles

            ld hl,MetatileGraphics_Low

            add hl,de ;e=0..3

            add a,(hl);l,(iy)

            inc hl

            inc hl

            inc hl

            inc hl

           ;ld e,a

           ;adc a,(hl)

           ;sub e

           ;ld h,a

           ;ld l,e ;23t

              ld h,(hl);(iy+MetatileGraphics_High-MetatileGraphics_Low) ;get address to graphics table from here

              jr nc,$+3

              inc h

              ld l,a ;20.5t

             ld a,(hl);ldayindirect (SCRATCHPAD+$06),y ;get first tile number (top left or top right) and store

             ld (ix+3),a

             inc hl

             ld a,(hl) ;now get the second (bottom left or bottom right) and store

             ld (ix+4),a;stax VRAM_Buffer2+4,x

             inc ix;inci SCRATCHPAD+$00                      ;increment vram buffer offset by 2

             inc ix;inci SCRATCHPAD+$00

            inc bc ;next row                        

            ;ld a,c

            dec hy ;cp $0d ;check for the bottom of the screen

            jp nz,DrawMTLoop ;jp c,DrawMTLoop               ;if not there yet, loop back

            ld b,d;0

 

            ld (ix+3),b;0       ;put null terminator at end of data for name table

            ld a,(VRAM_Buffer2_Offset)

            add a,13*2+3

            ld (VRAM_Buffer2_Offset),a ;store new buffer offset

            ld hl,CurrentNTAddr_Low

            inc (hl);inci CurrentNTAddr_Low        ;increment name table address low

            ld a,(hl);lda CurrentNTAddr_Low        ;check current low byte

            and ++%00011111               ;if no wraparound, just skip this part

            jr nz,ExitDrawM

            ;ld a,++$80                     ;if wraparound occurs, make sure low byte stays

            ld (hl),$80;sta CurrentNTAddr_Low        ;just under the status bar

            ld hl,CurrentNTAddr_High

            ld a,(hl);lda CurrentNTAddr_High       ;and then invert d2 of the name table address high

            xor ++%00000100               ;to move onto the next appropriate name table

            ld (hl),a;sta CurrentNTAddr_High

ExitDrawM:  ;jmp SetVRAMCtrl              ;jump to set buffer to $0341 (VRAM_Buffer2) and leave

             ldan ++$06

             sta VRAM_Buffer_AddrCtrl ;set buffer to $0341 (VRAM_Buffer2) and leave

             ret

 

           else ;~Z80

 

            lda CurrentColumnPos         ;store LSB of where we're at

            andn ++$01

            sta SCRATCHPAD+$05          

            ldy VRAM_Buffer2_Offset      ;store vram buffer offset

             sty SCRATCHPAD+$00

            lda CurrentNTAddr_Low        ;get current name table address we're supposed to render

            stay VRAM_Buffer2+1,y

            lda CurrentNTAddr_High

            stay VRAM_Buffer2,y

            ldan ++$9a                     ;store length byte of 26 here with d7 set

            stay VRAM_Buffer2+2,y         ;to increment by 32 (in columns)

            ldan ++$00                     ;init attribute row

            sta SCRATCHPAD+$04 ;current attribute row

            tax ;x=row

DrawMTLoop:

            stx SCRATCHPAD+$01                      ;store init value of 0 or incremented offset for buffer

            ldax MetatileBuffer,x         ;get first metatile number, and mask out all but 2 MSB

            andn ++%11000000

            sta SCRATCHPAD+$03                      ;store attribute table bits here

            asl                          ;note that metatile format is:

            rol                          ;%xx000000 - attribute table bits,

            rol                          ;%00xxxxxx - metatile number

            tay                          ;rotate bits to d1-d0 and use as offset here            

            lday MetatileGraphics_Low,y   ;get address to graphics table from here

            sta SCRATCHPAD+$06

            lday MetatileGraphics_High,y

            sta SCRATCHPAD+$07

            ldax MetatileBuffer,x         ;get metatile number again

            asl                          ;multiply by 4 and use as tile offset

            asl

            sta SCRATCHPAD+$02

            lda AreaParserTaskNum        ;get current task number for level processing and

            andn ++%00000001               ;mask out all but LSB, then invert LSB, multiply by 2

            eorn ++%00000001               ;to get the correct column position in the metatile,

            asl                          ;then add to the tile offset so we can draw either side

            adci SCRATCHPAD+$02                      ;of the metatiles

            tay

            ldx SCRATCHPAD+$00                      ;use vram buffer offset from before as X

            ldayindirect (SCRATCHPAD+$06),y

            stax VRAM_Buffer2+3,x         ;get first tile number (top left or top right) and store

            iny

            ldayindirect (SCRATCHPAD+$06),y                  ;now get the second (bottom left or bottom right) and store

            stax VRAM_Buffer2+4,x

 

            ldy SCRATCHPAD+$04                      ;get current attribute row

            lda SCRATCHPAD+$05                      ;get LSB of current column where we're at, and

         checka

            bne RightCheck               ;branch if set (clear = left attrib, set = right)

            lda SCRATCHPAD+$01                      ;get current row we're rendering

            lsr                          ;branch if LSB set (clear = top left, set = bottom left)

            bcs LLeft

            roli SCRATCHPAD+$03                      ;rotate attribute bits 3 to the left

            roli SCRATCHPAD+$03                      ;thus in d1-d0, for upper left square

            roli SCRATCHPAD+$03

            jmp SetAttrib

RightCheck: lda SCRATCHPAD+$01                      ;get LSB of current row we're rendering

            lsr                          ;branch if set (clear = top right, set = bottom right)

            bcs NextMTRow

            lsri SCRATCHPAD+$03                      ;shift attribute bits 4 to the right

            lsri SCRATCHPAD+$03                      ;thus in d3-d2, for upper right square

            lsri SCRATCHPAD+$03

            lsri SCRATCHPAD+$03

            jmp SetAttrib

LLeft:      lsri SCRATCHPAD+$03                      ;shift attribute bits 2 to the right

            lsri SCRATCHPAD+$03                      ;thus in d5-d4 for lower left square

NextMTRow:  inci SCRATCHPAD+$04                      ;move onto next attribute row  

SetAttrib:  lday AttributeBuffer,y        ;get previously saved bits from before

            orai SCRATCHPAD+$03                      ;if any, and put new bits, if any, onto

            stay AttributeBuffer,y        ;the old, and store

             inci SCRATCHPAD+$00                      ;increment vram buffer offset by 2

             inci SCRATCHPAD+$00

            ldx SCRATCHPAD+$01                      ;get current gfx buffer row, and check for

            inx                          ;the bottom of the screen

            cpxn ++$0d

              cmpcy

            bcc DrawMTLoop               ;if not there yet, loop back

           

            ldy SCRATCHPAD+$00                      ;get current vram buffer offset, increment by 3

            iny                          ;(for name table address and length bytes)

            iny

            iny

            ldan ++$00

            stay VRAM_Buffer2,y           ;put null terminator at end of data for name table

            sty VRAM_Buffer2_Offset      ;store new buffer offset

           

            inci CurrentNTAddr_Low        ;increment name table address low

            lda CurrentNTAddr_Low        ;check current low byte

            andn ++%00011111               ;if no wraparound, just skip this part

            bne ExitDrawM

            ldan ++$80                     ;if wraparound occurs, make sure low byte stays

            sta CurrentNTAddr_Low        ;just under the status bar

            lda CurrentNTAddr_High       ;and then invert d2 of the name table address high

            eorn ++%00000100               ;to move onto the next appropriate name table

            sta CurrentNTAddr_High

ExitDrawM:  jmp SetVRAMCtrl              ;jump to set buffer to $0341 (VRAM_Buffer2) and leave

           endif

 

             if Z80OPT4==0 ;фы  Z80 эх эєцэю ЇюЁьшЁютрЄ№ рЄЁшсєЄ√ - тёх Єрщы√ єцх яхЁхъЁр°хэ√

RenderAttributeTables:

             lda CurrentNTAddr_Low    ;get low byte of next name table address

             andn ++%00011111           ;to be written to, mask out all but 5 LSB,

             secsub                      ;subtract four

             sbcn ++$04

              cmpcy

        if Z80

        push af

        endif

             andn ++%00011111           ;mask out bits again and store

             sta SCRATCHPAD+$01

        if Z80

        pop af

        endif

             lda CurrentNTAddr_High   ;get high byte and branch if borrow not set

             bcs SetATHigh

             eorn ++%00000100           ;otherwise invert d2

SetATHigh:   andn ++%00000100           ;mask out all other bits

             oran ++$23                 ;add $2300 to the high byte and store

             sta SCRATCHPAD+$00

             lda SCRATCHPAD+$01                  ;get low byte - 4, divide by 4, add offset for

             lsr                      ;attribute table and store

             lsr

             adcn ++$c0                 ;we should now have the appropriate block of

             sta SCRATCHPAD+$01                  ;attribute table in our temp address

             ldxn ++$00

             ldy VRAM_Buffer2_Offset  ;get buffer offset

AttribLoop:  lda SCRATCHPAD+$00

             stay VRAM_Buffer2,y       ;store high byte of attribute table address

             lda SCRATCHPAD+$01

             clc                      ;get low byte, add 8 because we want to start

             adcn ++$08                 ;below the status bar, and store

             stay VRAM_Buffer2+1,y

             sta SCRATCHPAD+$01                  ;also store in temp again

             ldax AttributeBuffer,x    ;fetch current attribute table byte and store

             stay VRAM_Buffer2+3,y     ;in the buffer

             ldan ++$01

             stay VRAM_Buffer2+2,y     ;store length of 1 in buffer

             lsr

             stax AttributeBuffer,x    ;clear current byte in attribute buffer

             iny                      ;increment buffer offset by 4 bytes

             iny

             iny

             iny

             inx                      ;increment attribute offset and check to see

             cpxn ++$07                 ;if we're at the end yet

              cmpcy

             bcc AttribLoop

             stay VRAM_Buffer2,y       ;put null terminator at the end

             sty VRAM_Buffer2_Offset  ;store offset in case we want to do any more

SetVRAMCtrl: ldan ++$06

             sta VRAM_Buffer_AddrCtrl ;set buffer to $0341 (VRAM_Buffer2) and leave

             rts

            endif

 

 

 

ColorRotatePalette:

        if Z80COINCYCLECOLOR

        db 0xa1,0xa1,0xa1,0x31,0xf1,0x31

        else

       .db $27, $27, $27, $17, $07, $17

        endif

 

BlankPalette:

       .db $3f, $0c, $04, $ff, $ff, $ff, $ff, $00

 

Palette3Data:

       .db $0f, $07, $12, $0f

       .db $0f, $07, $17, $0f

       .db $0f, $07, $17, $1c

       .db $0f, $07, $17, $00

 

ColorRotation:

              lda FrameCounter         ;get frame counter

              andn ++$07                 ;mask out all but three LSB

        if Z80COINCYCLECOLOR

                ret nz

              ;lda AreaType             ;get area type

              ;asl                      ;multiply by 4 to get proper offset

              ;asl

              ;tay                      ;save as offset here

              ;lday Palette3Data,y       ;fetch palette to be written based on area type

               

              ldy ColorRotateOffset    ;get color cycling offset

              lday ColorRotatePalette,y

                ld hl,(curpalette)

                ld e,11*2

                add hl,de

                ld (hl),a

                inc hl

                ld (hl),a

             

              inci ColorRotateOffset    ;increment color cycling offset

              lda ColorRotateOffset

              cmpn ++$06                 ;check to see if it's still in range

              ;cmpcy

              ret c;bcc ExitColorRot         ;if so, branch to leave

              xor a;ldan ++$00

              sta ColorRotateOffset    ;otherwise, init to keep it in range

                ret

        else

              bne ExitColorRot         ;branch if not set to zero to do this every eighth frame

              ldx VRAM_Buffer1_Offset  ;check vram buffer offset

              cpxn ++$31

              cmpcy

              bcs ExitColorRot         ;if offset over 48 bytes, branch to leave

              tay                      ;otherwise use frame counter's 3 LSB as offset here

GetBlankPal:  lday BlankPalette,y       ;get blank palette for palette 3

              stax VRAM_Buffer1,x       ;store it in the vram buffer

              inx                      ;increment offsets

              iny

              cpyn ++$08

              cmpcy

              bcc GetBlankPal          ;do this until all bytes are copied

              ldx VRAM_Buffer1_Offset  ;get current vram buffer offset

              ldan ++$03

              sta SCRATCHPAD+$00                  ;set counter here

              lda AreaType             ;get area type

              asl                      ;multiply by 4 to get proper offset

              asl

              tay                      ;save as offset here

GetAreaPal:   lday Palette3Data,y       ;fetch palette to be written based on area type

              stax VRAM_Buffer1+3,x     ;store it to overwrite blank palette in vram buffer

              iny

              inx

              deci SCRATCHPAD+$00                  ;decrement counter

              bpl GetAreaPal           ;do this until the palette is all copied

              ldx VRAM_Buffer1_Offset  ;get current vram buffer offset

              ldy ColorRotateOffset    ;get color cycling offset

              lday ColorRotatePalette,y

              stax VRAM_Buffer1+4,x     ;get and store current color in second slot of palette

              lda VRAM_Buffer1_Offset

              clc                      ;add seven bytes to vram buffer offset

              adcn ++$07

              sta VRAM_Buffer1_Offset

              inci ColorRotateOffset    ;increment color cycling offset

              lda ColorRotateOffset

              cmpn ++$06                 ;check to see if it's still in range

              cmpcy

              bcc ExitColorRot         ;if so, branch to leave

              ldan ++$00

              sta ColorRotateOffset    ;otherwise, init to keep it in range

ExitColorRot: rts                      ;leave

        endif

 

 

BlockGfxData:

       .db $45, $45, $47, $47

       .db $47, $47, $47, $47

       .db $57, $58, $59, $5a

       .db $24, $24, $24, $24 ;blank metatile

       .db y26, y26, y26, y26 ;water/lava ;blank metatile for water

 

RemoveCoin_Axe:

              ldyn ++$41                 ;set low byte so offset points to $0341

              ldan ++$03                 ;load offset for default blank metatile

              ldx AreaType             ;check area type

         checkx

              bne WriteBlankMT         ;if not water type, use offset

              ldan ++$04                 ;otherwise load offset for blank metatile used in water

WriteBlankMT: jsr PutBlockMetatile     ;do a sub to write blank metatile to vram buffer

              ldan ++$06

              sta VRAM_Buffer_AddrCtrl ;set vram address controller to $0341 (VRAM_Buffer2) and leave

              rts

 

ReplaceBlockMetatile:

       jsr WriteBlockMetatile    ;write metatile to vram buffer to replace block object

       inci Block_ResidualCounter ;increment unused counter (residual code)

       decx Block_RepFlag,x       ;decrement flag (residual code)

       rts                       ;leave

 

DestroyBlockMetatile:

       ldan ++$00       ;force blank metatile if branched/jumped to this point

 

WriteBlockMetatile:

             ldyn ++$03                ;load offset for blank metatile

             cmpn ++$00                ;check contents of A for blank metatile

             beq UseBOffset          ;branch if found (unconditional if branched from 8a6b)

             ldyn ++$00                ;load offset for brick metatile w/ line

             cmpn ++$58

             beq UseBOffset          ;use offset if metatile is brick with coins (w/ line)

             cmpn ++$51

             beq UseBOffset          ;use offset if metatile is breakable brick w/ line

             iny                     ;increment offset for brick metatile w/o line

             cmpn ++$5d

             beq UseBOffset          ;use offset if metatile is brick with coins (w/o line)

             cmpn ++$52

             beq UseBOffset          ;use offset if metatile is breakable brick w/o line

             iny                     ;if any other metatile, increment offset for empty block

UseBOffset:  tya                     ;put Y in A

             ldy VRAM_Buffer1_Offset ;get vram buffer offset

             iny                     ;move onto next byte

             jsr PutBlockMetatile    ;get appropriate block data and write to vram buffer

MoveVOffset: dey                     ;decrement vram buffer offset

             tya                     ;add 10 bytes to it

             clc

             adcn ++10

             jmp SetVRAMOffset       ;branch to store as new vram buffer offset

 

PutBlockMetatile:

            stx SCRATCHPAD+$00               ;store control bit from SprDataOffset_Ctrl

            sty SCRATCHPAD+$01               ;store vram buffer offset for next byte

            asl

            asl                   ;multiply A by four and use as X

            tax

            ldyn ++$20              ;load high byte for name table 0

            lda SCRATCHPAD+$06               ;get low byte of block buffer pointer

            cmpn ++$d0              ;check to see if we're on odd-page block buffer

              cmpcy

            bcc SaveHAdder        ;if not, use current high byte

            ldyn ++$24              ;otherwise load high byte for name table 1

SaveHAdder: sty SCRATCHPAD+$03               ;save high byte here

            andn ++$0f              ;mask out high nybble of block buffer pointer

            asl                   ;multiply by 2 to get appropriate name table low byte

            sta SCRATCHPAD+$04               ;and then store it here

            ldan ++$00

            sta SCRATCHPAD+$05               ;initialize temp high byte

            lda SCRATCHPAD+$02               ;get vertical high nybble offset used in block buffer routine

            clc

            adcn ++$20              ;add 32 pixels for the status bar

            asl

            roli SCRATCHPAD+$05               ;shift and rotate d7 onto d0 and d6 into carry

            asl

            roli SCRATCHPAD+$05               ;shift and rotate d6 onto d0 and d5 into carry

            adci SCRATCHPAD+$04               ;add low byte of name table and carry to vertical high nybble

            sta SCRATCHPAD+$04               ;and store here

            lda SCRATCHPAD+$05               ;get whatever was in d7 and d6 of vertical high nybble

            adcn ++$00              ;add carry

            clc

            adci SCRATCHPAD+$03               ;then add high byte of name table

            sta SCRATCHPAD+$05               ;store here

            ldy SCRATCHPAD+$01               ;get vram buffer offset to be used

RemBridge:  ldax BlockGfxData,x    ;write top left and top right

            stay VRAM_Buffer1+2,y  ;tile numbers into first spot

            ldax BlockGfxData+1,x

            stay VRAM_Buffer1+3,y

            ldax BlockGfxData+2,x  ;write bottom left and bottom

            stay VRAM_Buffer1+7,y  ;right tiles numbers into

            ldax BlockGfxData+3,x  ;second spot

            stay VRAM_Buffer1+8,y

            lda SCRATCHPAD+$04

            stay VRAM_Buffer1,y    ;write low byte of name table

            clc                   ;into first slot as read

            adcn ++$20              ;add 32 bytes to value

            stay VRAM_Buffer1+5,y  ;write low byte of name table

            lda SCRATCHPAD+$05               ;plus 32 bytes into second slot

            stay VRAM_Buffer1-1,y  ;write high byte of name

            stay VRAM_Buffer1+4,y  ;table address to both slots

            ldan ++$02

            stay VRAM_Buffer1+1,y  ;put length of 2 in

            stay VRAM_Buffer1+6,y  ;both slots

            ldan ++$00

            stay VRAM_Buffer1+9,y  ;put null terminator at end

            ldx SCRATCHPAD+$00               ;get offset control bit here

            rts                   ;and leave

 

 

MetatileGraphics_Low:

  .db LOW Palette0_MTiles, LOW Palette1_MTiles, LOW Palette2_MTiles, LOW Palette3_MTiles

 

MetatileGraphics_High:

  .db HIGH Palette0_MTiles, HIGH Palette1_MTiles, HIGH Palette2_MTiles, HIGH Palette3_MTiles

 

  if Z80ATTR

xa0=0xec

xa1=0xed

xa2=0xee

xa3=0xef

x27=0xf0

xba=0xf1

xbb=0xf2

x86=0xf3

x87=0xf4

x8a=0xf5

x8b=0xf6

x8e=0xf7

x8f=0xf8

y25=0xf9

y26=0xfa

y35=0xfb

y36=0xfc

y37=0xfd

y38=0xfe

w26=10+('X'-'A')

x91=10+('J'-'A');0x91

x92=10+('F'-'A');0x92

  else

xa0=0xa0

xa1=0xa1

xa2=0xa2

xa3=0xa3

x27=0x27

xba=0xba

xbb=0xbb

x86=0x86

x87=0x87

x8a=0x8a

x8b=0x8b

x8e=0x8e

x8f=0x8f

y25=0x25

y26=0x26

y35=0x35

y36=0x36

y37=0x37

y38=0x38

w26=0x26

x91=0x91

x92=0x92

  endif

 

Palette0_MTiles:

  .db $24, $24, $24, $24 ;blank

  .db $27, $27, $27, $27 ;black metatile

  .db $24, $24, $24, $35 ;bush left

  .db $36, $25, $37, $25 ;bush middle

  .db $24, $38, $24, $24 ;bush right

  .db $24, $30, $30, w26 ;mountain left

  .db w26, w26, $34, w26 ;mountain left bottom/middle center

  .db $24, $31, $24, $32 ;mountain middle top

  .db $33, w26, $24, $33 ;mountain right

  .db $34, w26, w26, w26 ;mountain right bottom

  .db w26, w26, w26, w26 ;mountain middle bottom

  .db $24, $c0, $24, $c0 ;bridge guardrail

  .db $24, $7f, $7f, $24 ;chain

  .db $b8, $ba, $b9, $bb ;tall tree top, top half

  .db $b8, $bc, $b9, $bd ;short tree top

  .db $ba, $bc, $bb, $bd ;tall tree top, bottom half

  .db $60, $64, $61, $65 ;warp pipe end left, points up

  .db $62, $66, $63, $67 ;warp pipe end right, points up

  .db $60, $64, $61, $65 ;decoration pipe end left, points up

  .db $62, $66, $63, $67 ;decoration pipe end right, points up

  .db $68, $68, $69, $69 ;pipe shaft left

  .db w26, w26, $6a, $6a ;pipe shaft right

  .db $4b, $4c, $4d, $4e ;tree ledge left edge

  .db $4d, $4f, $4d, $4f ;tree ledge middle

  .db $4d, $4e, $50, $51 ;tree ledge right edge

  .db $6b, $70, $2c, $2d ;mushroom left edge

  .db $6c, $71, $6d, $72 ;mushroom middle

  .db $6e, $73, $6f, $74 ;mushroom right edge

  .db $86, $8a, $87, $8b ;sideways pipe end top ;$1c?

  .db $88, $8c, $88, $8c ;sideways pipe shaft top

  .db $89, $8d, $69, $69 ;sideways pipe joint top

  .db $8e, $91, $8f, $92 ;sideways pipe end bottom

  .db w26, $93, w26, $93 ;sideways pipe shaft bottom

  .db $90, $94, $69, $69 ;sideways pipe joint bottom

  .db $a4, $e9, $ea, $eb ;seaplant ;яюўхьє т 0-щ ярышЄЁх???

  .db $24, $24, $24, $24 ;blank, used on bricks or blocks that are hit

  .db $24, $2f, $24, $3d ;flagpole ball

  .db $a2, $a2, $a3, $a3 ;flagpole shaft

  .db $24, $24, $24, $24 ;blank, used in conjunction with vines

 

 

Palette1_MTiles:

  .db xa2, xa2, xa3, xa3 ;vertical rope

  .db $99, $24, $99, $24 ;horizontal rope

  .db $24, xa2, $3e, $3f ;left pulley

  .db $5b, $5c, $24, xa3 ;right pulley

  .db $24, $24, $24, $24 ;blank used for balance rope

  .db $9d, $47, $9e, $47 ;castle top

  .db $47, $47, x27, x27 ;castle window left

  .db $47, $47, $47, $47 ;castle brick wall

  .db x27, x27, $47, $47 ;castle window right

  .db $a9, $47, $aa, $47 ;castle top w/ brick

  .db $9b, x27, $9c, x27 ;entrance top

  .db x27, x27, x27, x27 ;entrance bottom

  .db $52, $52, $52, $52 ;green ledge stump

  .db $80, xa0, $81, xa1 ;fence

  .db $be, $be, $bf, $bf ;tree trunk

  .db $75, xba, $76, xbb ;mushroom stump top

  .db xba, xba, xbb, xbb ;mushroom stump bottom

  .db $45, $47, $45, $47 ;breakable brick w/ line

  .db $47, $47, $47, $47 ;breakable brick

  .db $45, $47, $45, $47 ;breakable brick (not used)

  .db $b4, $b6, $b5, $b7 ;cracked rock terrain

  .db $45, $47, $45, $47 ;brick with line (power-up)

  .db $45, $47, $45, $47 ;brick with line (vine)

  .db $45, $47, $45, $47 ;brick with line (star)