;;;
;; Divide the screen in three rows and make them move in different
;; directions/speed. This is achieved thanks to the MMC3 chip (check
;; `fx/blink.s` for further information on this chip). In particular, we are
;; using the scanline IRQ mechanism provided by this chip to react to different
;; parts of the screen being rendered:
;;
;;   1. The top of the screen moves fast on one direction.
;;   2. The center of the screen moves fast on the opposite direction.
;;   3. The bottom of the screen moves on the same direction as 1. but slower.
;;
;; This is achieved by setting an IRQ that hits on points 2. and 3., and then we
;; manipulate the PPU scroll register mid frame. That is, all you see are just
;; background elements being scrolled in different ways.
;;
;; This trick was used, for example, on Super Mario Bros. 3 for the roulette
;; mini-game. That being said, usually games used this capability to handle
;; scroll on the top part of the screen, and then resetting the scroll on the
;; lower part, so they could show a status section (again, as Super Mario Bros.
;; 3 does inside of a level, and in mmc3.s here).

;; Include helpful definitions.
.include "../shared/mmc3.s"

;; Variables used on this example.
.scope Vars
    zp_top_scroll    = $00
    zp_center_scroll = $01
    zp_bottom_scroll = $02
    zp_is_bottom     = $04         ; 0 -> scroll center; 1 -> scroll bottom
.endscope

.segment "HEADER"
    .byte 'N', 'E', 'S', $1A
    .byte $10
    .byte $10
    .byte $42, $08
    .res 8, 0

.segment "VECTORS"
    .addr nmi, reset, irq

;;; NOTE: lots of banks, all of them empty since we don't need them :)

.segment "PRG0_00"
.byte $FF
.segment "PRG0_01"
.byte $FF
.segment "PRG0_02"
.byte $FF
.segment "PRG0_03"
.byte $FF
.segment "PRG0_04"
.byte $FF
.segment "PRG0_05"
.byte $FF
.segment "PRG0_06"
.byte $FF
.segment "PRG0_07"
.byte $FF
.segment "PRG0_08"
.byte $FF
.segment "PRG0_09"
.byte $FF
.segment "PRG0_0A"
.byte $FF
.segment "PRG0_0B"
.byte $FF
.segment "PRG0_0C"
.byte $FF
.segment "PRG0_0D"
.byte $FF
.segment "PRG0_0E"
.byte $FF
.segment "PRG1_00"
.byte $FF
.segment "PRG1_01"
.byte $FF
.segment "PRG1_02"
.byte $FF
.segment "PRG1_03"
.byte $FF
.segment "PRG1_04"
.byte $FF
.segment "PRG1_05"
.byte $FF
.segment "PRG1_06"
.byte $FF
.segment "PRG1_07"
.byte $FF
.segment "PRG1_08"
.byte $FF
.segment "PRG1_09"
.byte $FF
.segment "PRG1_0A"
.byte $FF
.segment "PRG1_0B"
.byte $FF
.segment "PRG1_0C"
.byte $FF
.segment "PRG1_0D"
.byte $FF
.segment "PRG1_0E"
.byte $FF

;;; NOTE: the first fixed PRG bank will simply contain utilities for moving the
;;; player around.
.segment "FIXED"
.include "../shared/diskun.s"
.include "../shared/clear.s"

;;; NOTE: the main bulk of this example. Comments only for the parts which are
;;; specific to this example.
.segment "TAIL"
.include "../shared/ppu.s"

.proc reset
    sei
    cld

    ;; NOTE: as explained on the `basics/sprite.s` example, this is done to
    ;; disable the APU frame IRQ. This is usually done without giving it a
    ;; second thought, but it's specially relevant on the MMC3 chip because
    ;; disabling this allows the `irq` handler to be able to assume that the
    ;; only kind of IRQ available is a scanline one.
    ldx #$40
    stx $4017

    ldx #$FF
    txs

    inx
    stx $2000
    stx $2001
    stx $4010

    ;;;
    ;; NOTE: Setup MMC3. Nothing different from `fx/blink.s`. Take that example
    ;; as a reference on how to configure the MMC3 chip and bank switching on
    ;; it.

    lda #$00
    sta MMC3::MIRRORING
    sta MMC3::IRQ_DISABLE

    lda #$80
    sta MMC3::RAM_PROTECT

    BANK_REGISTER_SET 0, 0
    BANK_REGISTER_SET 1, 2
    BANK_REGISTER_SET 2, 4
    BANK_REGISTER_SET 3, 5
    BANK_REGISTER_SET 4, 6
    BANK_REGISTER_SET 5, 7
    BANK_REGISTER_SET 6, 0
    BANK_REGISTER_SET 7, 1

@vblankwait1:
    bit $2002
    bpl @vblankwait1

    ldx #0
    lda #0
@ram_reset_loop:
    sta $000, x
    sta $100, x
    sta $300, x
    sta $400, x
    sta $500, x
    sta $600, x
    sta $700, x
    inx
    bne @ram_reset_loop

    lda #$EF
@sprite_reset_loop:
    sta $200, x
    inx
    bne @sprite_reset_loop

    lda #$00
    sta $2003
    lda #$02
    sta $4014

@vblankwait2:
    bit $2002
    bpl @vblankwait2

    lda #$3F
    sta $2006
    lda #$00
    sta $2006

    lda #$0F
    ldx #$20
@palettes_reset_loop:
    sta $2007
    dex
    bne @palettes_reset_loop
    jmp main
.endproc

;; The main function is used here only for further initialization purposes.
.proc main
    ;; Clear both screens to avoid funky business, as we are not doing anything
    ;; specially clever here.
    CLEAR_SCREENS $20, $24

    ;; Initialize both the palettes and the nametables.
    jsr Diskun::init_palettes
    jsr init_nametables

    ;; NOTE: enable back interrupts so we can set them up later on `nmi` code.
    cli

    lda #%10001000
    sta $2000
    lda #%00011110
    sta $2001

@main_game_loop:
    ;; NOTE: nothing :D

    lda #%10000000
    ora $20
    sta $20
@wait_for_render:
    bit $20
    bmi @wait_for_render

    ;; NOTE: no game logic, everything happens on NMI and IRQ handlers.

    jmp @main_game_loop
.endproc

;; NOTE: everything displayed on this example only happens on the background.
;; Moreover, to give a more accurate illusion of the scrolling, the same
;; background elements are repeated on the other nametable. That's why we have
;; to set the data twice on each section: once for each nametable.
.proc init_nametables
    ;; Top left
    WRITE_PPU_DATA $20A6, $01
    WRITE_PPU_DATA $20C6, $11
    WRITE_PPU_DATA $20A7, $02
    WRITE_PPU_DATA $20C7, $12

    WRITE_PPU_DATA $24A6, $01
    WRITE_PPU_DATA $24C6, $11
    WRITE_PPU_DATA $24A7, $02
    WRITE_PPU_DATA $24C7, $12

    ;; Top center
    WRITE_PPU_DATA $20AF, $01
    WRITE_PPU_DATA $20CF, $11
    WRITE_PPU_DATA $23CB, %01000100
    WRITE_PPU_DATA $20B0, $02
    WRITE_PPU_DATA $20D0, $12
    WRITE_PPU_DATA $23CC, %00010001

    WRITE_PPU_DATA $24AF, $01
    WRITE_PPU_DATA $24CF, $11
    WRITE_PPU_DATA $27CB, %01000100
    WRITE_PPU_DATA $24B0, $02
    WRITE_PPU_DATA $24D0, $12
    WRITE_PPU_DATA $27CC, %00010001

    ;; Top right
    WRITE_PPU_DATA $20B8, $01
    WRITE_PPU_DATA $20D8, $11
    WRITE_PPU_DATA $23CE, %00100010
    WRITE_PPU_DATA $20B9, $02
    WRITE_PPU_DATA $20D9, $12

    WRITE_PPU_DATA $24B8, $01
    WRITE_PPU_DATA $24D8, $11
    WRITE_PPU_DATA $27CE, %00100010
    WRITE_PPU_DATA $24B9, $02
    WRITE_PPU_DATA $24D9, $12

    ;; Center left
    WRITE_PPU_DATA $21E6, $01
    WRITE_PPU_DATA $2206, $11
    WRITE_PPU_DATA $21E7, $02
    WRITE_PPU_DATA $2207, $12

    WRITE_PPU_DATA $25E6, $01
    WRITE_PPU_DATA $2606, $11
    WRITE_PPU_DATA $25E7, $02
    WRITE_PPU_DATA $2607, $12

    ;; Center center
    WRITE_PPU_DATA $21EF, $01
    WRITE_PPU_DATA $220F, $11
    WRITE_PPU_DATA $21F0, $02
    WRITE_PPU_DATA $2210, $12
    WRITE_PPU_DATA $23DB, %01000000
    WRITE_PPU_DATA $23E3, %00000100
    WRITE_PPU_DATA $23DC, %00010000
    WRITE_PPU_DATA $23E4, %00000001

    WRITE_PPU_DATA $25EF, $01
    WRITE_PPU_DATA $260F, $11
    WRITE_PPU_DATA $25F0, $02
    WRITE_PPU_DATA $2610, $12
    WRITE_PPU_DATA $27DB, %01000000
    WRITE_PPU_DATA $27E3, %00000100
    WRITE_PPU_DATA $27DC, %00010000
    WRITE_PPU_DATA $27E4, %00000001

    ;; Center right
    WRITE_PPU_DATA $21F8, $01
    WRITE_PPU_DATA $2218, $11
    WRITE_PPU_DATA $21F9, $02
    WRITE_PPU_DATA $2219, $12
    WRITE_PPU_DATA $23DE, %00100000
    WRITE_PPU_DATA $23E6, %00000010

    WRITE_PPU_DATA $25F8, $01
    WRITE_PPU_DATA $2618, $11
    WRITE_PPU_DATA $25F9, $02
    WRITE_PPU_DATA $2619, $12
    WRITE_PPU_DATA $27DE, %00100000
    WRITE_PPU_DATA $27E6, %00000010

    ;; Bottom left
    WRITE_PPU_DATA $2326, $01
    WRITE_PPU_DATA $2327, $02
    WRITE_PPU_DATA $2346, $11
    WRITE_PPU_DATA $2347, $12

    WRITE_PPU_DATA $2726, $01
    WRITE_PPU_DATA $2727, $02
    WRITE_PPU_DATA $2746, $11
    WRITE_PPU_DATA $2747, $12

    ;; Bottom center
    WRITE_PPU_DATA $232F, $01
    WRITE_PPU_DATA $234F, $11
    WRITE_PPU_DATA $2330, $02
    WRITE_PPU_DATA $2350, $12
    WRITE_PPU_DATA $23F3, %01000100
    WRITE_PPU_DATA $23F4, %00010001

    WRITE_PPU_DATA $272F, $01
    WRITE_PPU_DATA $274F, $11
    WRITE_PPU_DATA $2730, $02
    WRITE_PPU_DATA $2750, $12
    WRITE_PPU_DATA $27F3, %01000100
    WRITE_PPU_DATA $27F4, %00010001

    ;; Bottom right
    WRITE_PPU_DATA $2338, $01
    WRITE_PPU_DATA $2358, $11
    WRITE_PPU_DATA $2339, $02
    WRITE_PPU_DATA $2359, $12
    WRITE_PPU_DATA $23F6, %00100010

    WRITE_PPU_DATA $2738, $01
    WRITE_PPU_DATA $2758, $11
    WRITE_PPU_DATA $2739, $02
    WRITE_PPU_DATA $2759, $12
    WRITE_PPU_DATA $27F6, %00100010

    rts
.endproc

;;;
;; NOTE: for this example the NMI is a bit different than on other examples. It
;; has to do mainly two things:
;;   1. Set up a scanline IRQ so the scroll at the center/bottom is different.
;;   2. Set the scroll for the top region.
.proc nmi
    bit $20
    bpl @next

    pha
    txa
    pha
    tya
    pha

    ;; NOTE: no DMA transfer as usual since there are no sprites involved.

    ;;;
    ;; NOTE: setting up IRQs for scanline counting.

    ;; Disable scanline IRQs and acknowledge any previous one. Technically
    ;; speaking this is not needed because the only times we set up an IRQ we
    ;; know it's going to be acknowledge where it is needed. That being said,
    ;; let's be safe.
    ldx #$00
    stx MMC3::IRQ_DISABLE

    ;; The screen is made up of 240 visible scan lines. Since we are dividing
    ;; the screen by 3: 240 / 3 = 80. Hence, the next IRQ should happen on
    ;; scanline 80, where we would need to update the scroll value through the
    ;; `{center/bottom}_scroll` values instead. Moreover, note that
    ;; `MMC3::IRQ_ENABLE` accepts any value, so the same value as the two other
    ;; registers is just fine.
    lda #80
    sta MMC3::IRQ_LATCH
    sta MMC3::IRQ_RELOAD
    sta MMC3::IRQ_ENABLE

    ;; The IRQ for scanline 80 has been set up. Now proceed with the scroll for
    ;; the top section. The scroll will only happen on the X axis and it's going
    ;; to be a bit fast.
    bit $2002
    lda Vars::zp_top_scroll
    clc
    adc #2
    sta Vars::zp_top_scroll
    sta $2005
    lda #$00
    sta $2005

    ;; NOTE: the rest as usual.

    lda #%01111111
    and $20
    sta $20

    pla
    tay
    pla
    tax
    pla
@next:
    rti
.endproc

;;;
;; NOTE: handle a scanline IRQ.
;;
;; Notice that we cannot at first glance know what kind of IRQ is hitting at the
;; moment, but we have disabled the frame counter on our `reset` code, so on the
;; context of the MMC3 chip the only thing left are scanline IRQs, which we have
;; set up on `nmi` code.
.proc irq
    ;; Save current context.
    pha
    txa
    pha
    tya
    pha

    ;; Disable IRQs and acknowledge the current one.
    ldx #$00
    stx MMC3::IRQ_DISABLE

    ;; What are we trying to scroll, exactly?
    lda Vars::zp_is_bottom
    beq @scroll_right

    ;; We are scrolling the bottom section, which scrolls in the same direction
    ;; as the top one but a bit slower at that. Load the next scroll value on
    ;; the `a` register and `Vars::zp_bottom_scroll`.
    lda Vars::zp_bottom_scroll
    clc
    adc #1
    sta Vars::zp_bottom_scroll
    ldy #0
    sty Vars::zp_is_bottom
    jmp @do_scroll

@scroll_right:
    ;; We are scrolling the center, which works by going on the opposite
    ;; direction as the top and bottom sections. Load the next scroll value on
    ;; the `a` register and `Vars::zp_center_scroll`.
    lda Vars::zp_center_scroll
    sec
    adc #$FD
    sta Vars::zp_center_scroll
    ldy #1
    sty Vars::zp_is_bottom

    ;; We are at the center, but there is still the bottom section to be
    ;; scrolled differently. Hence, set a new scanline IRQ 80 lines ahead of
    ;; where we are now. This is done in pretty much the same way as we did in
    ;; `nmi` code.
    ldx #80
    stx MMC3::IRQ_LATCH
    stx MMC3::IRQ_RELOAD
    stx MMC3::IRQ_ENABLE

@do_scroll:
    ;; Regardless of the path, the `a` register contains the value for the
    ;; scroll on the X axis. Store this value now and leave.
    sta $2005
    lda #$00
    sta $2005

    ;; Restore previous context.
    pla
    tay
    pla
    tax
    pla

    rti
.endproc

;;; NOTE: pretty much the same as `fx/blink.s`.

.segment "CHARS"
.incbin "../assets/diskun0.chr"
.incbin "../assets/diskun1.chr"
.res $1000, $00

;; The 15 other 8KB portions are left empty.
.res $2000, $00
.res $2000, $00
.res $2000, $00
.res $2000, $00
.res $2000, $00
.res $2000, $00
.res $2000, $00
.res $2000, $00
.res $2000, $00
.res $2000, $00
.res $2000, $00
.res $2000, $00
.res $2000, $00
.res $2000, $00
.res $2000, $00