;;;
;; Showcase different strategies for Random Number Generation (RNG).
;;
;; Refer to the README.md file for documentation. Here I have left comments
;; whenever there's something "new" if you are coming from the `basics/`
;; directory.

.segment "HEADER"
    .byte 'N', 'E', 'S', $1A
    .byte $02, $01
    .byte $00, $00

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

.segment "CHARS"
.incbin "../assets/alphanum.chr"

.segment "CODE"

.include "../shared/ppu.s"
.include "../shared/clear.s"
.include "../shared/joypad.s"

;; Different algorithms.
.include "linear.s"
.include "precalc.s"

;; Number of algorithms for this game.
ALGORITHM_SIZE = $02

;; See Vars::zp_button_timer.
KEY_TIMER = 15

;; Variables used by this game.
.scope Vars
    ;; 0: "Press start" state; 1: "number generation" state.
    zp_state = $30

    ;; Timer for key presses. A button press will only be considered if the
    ;; button timer is zero. Whenever that's the case, the code will reset the
    ;; timer to this new value, and decrement it whenever a new press is found.
    ;; Whenever we reach back to zero, then the button press will be considered
    ;; again. All of this is because whenever the player presses a button, it
    ;; actually presses it for more than one frame, and things can go crazy from
    ;; this fact.
    zp_button_timer = $31

    ;; Algorithm that has been selected.
    zp_algorithm = $32

    ;; The random seed for this game. As described in the README.md file, this
    ;; is actually a frame counter for the "Press start" state, and whenever the
    ;; player hits "Start", it will be paused. That is, our random seed is
    ;; simply the number of frames that the player took to press "Start" at the
    ;; beginning.
    ;;
    ;; NOTE: it's not going to be initialized to get a more random feeling on
    ;; real hardware from unknown RAM state.
    zp_seed = $33

    ;; The number to be displayed.
    zp_number = $34
.endscope

;; Main function, this takes care of reading input, changing the state, and
;; calling the relevant algorithm to get new numbers.
.proc main
    ;; Initialize all variables (except Vars::zp_seed as explained above).
    lda #0
    sta Vars::zp_state
    sta Vars::zp_button_timer
    sta Vars::zp_algorithm
    sta Vars::zp_number

    ;; Clear both screens. Yes, over the top, but it gets the job done.
    CLEAR_SCREENS $20, $28

    ;; Initialize palettes and show the "Press start" message.
    jsr init_palettes
    jsr show_init_screen

    cli
    lda #%10001000
    sta $2000                   ; PPUCTRL
    lda #%00011110
    sta $2001                   ; PPUMASK

@main_game_loop:
    ;; Should we actually read the joypad? This is handled via the button timer
    ;; as explained above.
    lda Vars::zp_button_timer
    beq @check_joypad
    dec Vars::zp_button_timer
    jmp @end

@check_joypad:
    ;; Yes! Then read the joypad.
    READ_JOYPAD1

    ;; What's the current game state?
    lda Vars::zp_state
    bne @check_change_algorithm

    ;; "Press start" state. If the player is not pressing "Start", ignore
    ;; everything and go to the end.
    lda Joypad::zp_buttons1
    and #Joypad::BUTTON_START
    beq @end

    ;; Reset the button timer.
    lda #KEY_TIMER
    sta Vars::zp_button_timer

    ;; The random seed has a proper value and we can use that as a first random
    ;; number.
    lda Vars::zp_seed
    sta Vars::zp_number

    ;; The 'linear' algorithm actually disregards any parameters and needs a
    ;; 16-bit register. Let's initialize this register with the current seed.
    sta Linear::zp_register_lo
    sta Linear::zp_register_hi

    ;; Move into the next state.
    inc Vars::zp_state

    jmp @end

@check_change_algorithm:
    ;; We are in a running state. Check if the player is asking to change the
    ;; algorithm.
    lda Joypad::zp_buttons1
    and #Joypad::BUTTON_SELECT
    beq @check_a_button

    ;; Reset the button timer.
    lda #KEY_TIMER
    sta Vars::zp_button_timer

    ;; The player asked to change the algorithm. Do it now and go generate a new
    ;; number with that.
    ldx Vars::zp_algorithm
    inx
    cpx #ALGORITHM_SIZE
    bne @store_algorithm
    ldx #0
@store_algorithm:
    stx Vars::zp_algorithm
    jmp @next_number

@check_a_button:
    ;; Is the player asking for a new number? If not go to the end.
    lda Joypad::zp_buttons1
    and #Joypad::BUTTON_A
    beq @end

    ;; Reset the button timer.
    lda #KEY_TIMER
    sta Vars::zp_button_timer

@next_number:
    ;; Setup parameters depending on the algorithm and actually call it.
    ldx Vars::zp_algorithm
    bne @precalc
    jsr linear_feedback_shift_register
    jmp @store_number
@precalc:
    lda Vars::zp_number
    jsr precalc
@store_number:
    sta Vars::zp_number

@end:
    ;; And wait for the render to happen as it's done in any other example.
    lda #%10000000
    ora $20
    sta $20
@wait_for_render:
    bit $20
    bmi @wait_for_render

    jmp @main_game_loop
.endproc

;; NMI code is pretty standard. I have added comments for the code which is
;; specific to this game.
.proc nmi
    bit $20
    bpl @next

    pha
    txa
    pha
    tya
    pha

    lda #$00
    sta $2003                   ; OAMADDR
    lda #$02
    sta $4014                   ; OAMDMA

    ;; What's the current game state?
    lda Vars::zp_state
    beq @seed_inc

    ;; Running state. Print the current algorithm and number.
    jsr print_algorithm
    jsr print_value

    ;; The running state is displayed on the other nametable. Update the PPU
    ;; control register for this (it's of course stupid to update it every time,
    ;; but I didn't feel like doing the proper thing of shadowing the PPU
    ;; control register and update only on changes, etc.).
    lda #%10001010
    sta $2000                   ; PPUCTRL
    bne @after_seed

@seed_inc:
    ;; "Press start" state: just increase the frame counter which is used as a
    ;; seed.
    inc Vars::zp_seed

@after_seed:
    bit $2002                   ; PPUSTATUS
    lda #$00
    sta $2005                   ; PPUSCROLL
    sta $2005                   ; PPUSCROLL

    lda #%01111111
    and $20
    sta $20

    pla
    tay
    pla
    tax
    pla
@next:
    rti
.endproc

;; Show the "Alg: <algorithm>" message on screen.
.proc print_algorithm
    ;; "ALG: "
    WRITE_PPU_DATA $298B, $1A
    WRITE_PPU_DATA $298C, $25
    WRITE_PPU_DATA $298D, $20
    WRITE_PPU_DATA $298E, $34
    WRITE_PPU_DATA $298F, $00

    lda Vars::zp_algorithm
    beq @linear

    ;; "PRECALC"
    WRITE_PPU_DATA $2990, $29
    WRITE_PPU_DATA $2991, $2B
    WRITE_PPU_DATA $2992, $1E
    WRITE_PPU_DATA $2993, $1C
    WRITE_PPU_DATA $2994, $1A
    WRITE_PPU_DATA $2995, $25
    WRITE_PPU_DATA $2996, $1C
    rts

    ;; "LINEAR "
@linear:
    WRITE_PPU_DATA $2990, $25
    WRITE_PPU_DATA $2991, $22
    WRITE_PPU_DATA $2992, $27
    WRITE_PPU_DATA $2993, $1E
    WRITE_PPU_DATA $2994, $1A
    WRITE_PPU_DATA $2995, $2B
    WRITE_PPU_DATA $2996, $00
    rts
.endproc

;; Show the "Val: $<number>" message on screen.
.proc print_value
    ;; "VAL: $"
    WRITE_PPU_DATA $29AB, $2F
    WRITE_PPU_DATA $29AC, $1A
    WRITE_PPU_DATA $29AD, $25
    WRITE_PPU_DATA $29AE, $34
    WRITE_PPU_DATA $29AF, $00
    WRITE_PPU_DATA $29B0, $35

    ;; Set the high byte on the 'y' register, and the low byte on the 'x'
    ;; register.
    lda #$F0
    and Vars::zp_number
    lsr
    lsr
    lsr
    lsr
    clc
    adc #$10
    tay
    lda #$0F
    and Vars::zp_number
    clc
    adc #$10
    tax

    ;; Display the actual number.
    bit $2002
    lda #$29
    sta $2006
    lda #$B1
    sta $2006
    sty $2007
    stx $2007

    rts
.endproc

;; Show the "Press start" message.
.proc show_init_screen
    ;; "PRESS"
    WRITE_PPU_DATA $21AB, $29
    WRITE_PPU_DATA $21AC, $2B
    WRITE_PPU_DATA $21AD, $1E
    WRITE_PPU_DATA $21AE, $2C
    WRITE_PPU_DATA $21AF, $2C

    ;; "START"
    WRITE_PPU_DATA $21B1, $2C
    WRITE_PPU_DATA $21B2, $2D
    WRITE_PPU_DATA $21B3, $1A
    WRITE_PPU_DATA $21B4, $2B
    WRITE_PPU_DATA $21B5, $2D

    rts
.endproc

;; Initialize palettes. A bit over the top since only two colors are used.
.proc init_palettes
    lda #$3F
    sta $2006                   ; PPUADDR
    lda #$00
    sta $2006                   ; PPUADDR

    ldx #0
@load_palettes_loop:
    lda palettes, x
    sta $2007                   ; PPUDATA
    inx
    cpx #$20
    bne @load_palettes_loop
    rts
palettes:
    DEFAULT_COLOR = $0F

    ;; Background
    .byte DEFAULT_COLOR, $20, $FF, $FF
    .byte DEFAULT_COLOR, $20, $FF, $FF
    .byte DEFAULT_COLOR, $20, $FF, $FF
    .byte DEFAULT_COLOR, $20, $FF, $FF

    ;; Foreground
    .byte DEFAULT_COLOR, $20, $FF, $FF
    .byte DEFAULT_COLOR, $20, $FF, $FF
    .byte DEFAULT_COLOR, $20, $FF, $FF
    .byte DEFAULT_COLOR, $20, $FF, $FF

    rts
.endproc

;;;
;; NOTE: down below just boilerplate. Nothing special from the `basics/`
;; examples.

.proc reset
    sei
    cld

    ldx #$40
    stx $4017                   ; APU Frame Counter

    ldx #$FF
    txs

    inx
    stx $2000                   ; PPUCTRL
    stx $2001                   ; PPUMASK
    stx $4010                   ; APU DMC

    bit $2002                   ; PPUSTATUS
@vblankwait1:
    bit $2002                   ; PPUSTATUS
    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         ; if x overflows back to #00, then we are done.

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

    lda #$00
    sta $2003                   ; OAMADDR
    lda #$02
    sta $4014                   ; OAMDMA

@vblankwait2:
    bit $2002                   ; PPUSTATUS
    bpl @vblankwait2

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

    lda #$0F
    ldx #$20
@palettes_reset_loop:
    sta $2007                   ; PPUDATA
    dex
    bne @palettes_reset_loop

    jmp main
.endproc

.proc irq
    rti
.endproc