game.s

; =============================================================================
; NES Diamond-Chase Game
; game.s  --  6502 assembly source (ca65 syntax)
;
; Controls : D-Pad moves the diamond sprite.
;            Guide it into the yellow target zone to trigger a win.
;            Press Start to play again.
; Easter egg: Up Up Down Down Left Right Left Right → 3-second colour flash.
;
; Mapper  : NROM-256 (mapper 0), 2×16 KB PRG, 1×8 KB CHR
; Audio   : Pulse 1 = background melody, Pulse 2 = sound effects
; =============================================================================

; ---------------------------------------------------------------------------
; iNES header
; ---------------------------------------------------------------------------
.segment "HEADER"
    .byte $4E,$45,$53,$1A       ; "NES" + MS-DOS EOF   (bytes 0-3)
    .byte 2                     ; byte 4: 2×16 KB PRG-ROM banks (32 KB)
    .byte 1                     ; byte 5: 1×8 KB CHR-ROM bank
    .byte $00                   ; byte 6: mapper 0, horizontal mirroring
    .byte $00                   ; byte 7: mapper 0 upper nibble, iNES 1.0
    .byte $00,$00,$00,$00,$00,$00,$00,$00   ; bytes 8-15: padding

; ---------------------------------------------------------------------------
; Zero-page variables
; ---------------------------------------------------------------------------
.segment "ZEROPAGE"
player_x:       .res 1      ; sprite X pixel position
player_y:       .res 1      ; sprite Y pixel position
game_state:     .res 1      ; 0 = playing, 1 = won
frame_ready:    .res 1      ; set by NMI, cleared by main loop
curr_btns:      .res 1      ; current controller bitmask
prev_btns:      .res 1      ; previous frame bitmask (edge detection)
new_dirs:       .res 1      ; newly-pressed directional bits this frame
win_text_state: .res 1      ; 0=idle, 1=draw win text, 2=clear win text

; audio
music_idx:      .res 1      ; current byte index into music_data
music_timer:    .res 1      ; frames remaining on current note
music_active:   .res 1      ; 1 = music is playing
sfx_active:     .res 1      ; 0=none, 1=move blip, 2=win chime
sfx_idx:        .res 1      ; current byte index into sfx data
sfx_timer:      .res 1      ; frames remaining on current SFX note

; easter egg
code_buf:       .res 8      ; ring buffer of last 8 directional inputs (1-4)
code_pos:       .res 1      ; ring-buffer write head (0-7)
easter_active:  .res 1      ; 1 = colour flash active
easter_timer:   .res 1      ; frames remaining (starts at 180)
easter_color:   .res 1      ; index into easter_colors table

; ---------------------------------------------------------------------------
; OAM shadow buffer at page $02 ($0200-$02FF)
; ---------------------------------------------------------------------------
.segment "OAM"
oam_buf: .res 256

; ---------------------------------------------------------------------------
; Hardware register equates
; ---------------------------------------------------------------------------
PPU_CTRL   = $2000
PPU_MASK   = $2001
PPU_STATUS = $2002
OAM_ADDR   = $2003
PPU_SCROLL = $2005
PPU_ADDR   = $2006
PPU_DATA   = $2007
OAM_DMA    = $4014

P1_CTRL    = $4000
P1_SWEEP   = $4001
P1_LO      = $4002
P1_HI      = $4003
P2_CTRL    = $4004
P2_SWEEP   = $4005
P2_LO      = $4006
P2_HI      = $4007
APU_STATUS = $4015
APU_FRAME  = $4017
CTRL1      = $4016

; Controller button bits (read order: A B Sel Start Up Down Left Right)
BTN_A      = $80
BTN_B      = $40
BTN_SEL    = $20
BTN_SRT    = $10
BTN_UP     = $08
BTN_DOWN   = $04
BTN_LEFT   = $02
BTN_RIGHT  = $01

; Game states
STATE_PLAY = 0
STATE_WIN  = 1

; Player starting position
PLAYER_X0  = 24
PLAYER_Y0  = 24

; Target zone: tile columns 12-15, tile rows 8-11
;   pixel rectangle  X: 96-127,  Y: 64-95
TGT_L      = 96
TGT_T      = 64
TGT_R      = 127
TGT_B      = 95

; Collision: 8×8 sprite overlaps target when
;   player_x in [TGT_L-7 .. TGT_R]  =>  [89 .. 127]
;   player_y in [TGT_T-7 .. TGT_B]  =>  [57 ..  95]
COL_XL     = 89
COL_XR     = 127
COL_YT     = 57
COL_YB     = 95

; Screen clamp limits (OAM pixel coords)
SCRL       = 0
SCRR       = 248            ; 256 - 8 (sprite width)
SCRT       = 8              ; first visible scanline (with top border)
SCRB       = 224            ; 240 - 8 - 8 (safe bottom)

; Background CHR tile indices (pattern table 0 = PPU $0000-$0FFF)
TILE_BLANK = $00
TILE_TGT   = $01
TILE_Y     = $02
TILE_O     = $03
TILE_U     = $04
TILE_W     = $05
TILE_I     = $06
TILE_N     = $07
TILE_EXCL  = $08
TILE_P     = $09
TILE_R     = $0A
TILE_E     = $0B
TILE_S     = $0C
TILE_T_LTR = $0D
TILE_A     = $0E
TILE_G     = $0F
TILE_L     = $10

; Sprite pattern table is at PPU $1000 (PPU_CTRL bit 3 = 1)
TILE_DIAM  = $00            ; diamond sprite tile index

; Nametable / attribute table base
AT0        = $23C0          ; attribute table for nametable 0

; Win-text nametable positions:
;   "YOU WIN!"   row 18, col 12 => $2000 + 18*32 + 12 = $224C
;   "PRESS START" row 20, col 10 => $2000 + 20*32 + 10 = $228A
WIN_HI     = $22
WIN_LO     = $4C
RST_HI     = $22
RST_LO     = $8A

; Konami code buffer length
KONAMI_LEN = 8

; APU envelope constants
P1_ENV     = $B8            ; Pulse1: 50% duty, length halt, const vol 8
P2_BLIP    = $34            ; Pulse2: 12.5% duty, length halt, const vol 4
P2_CHIME   = $BC            ; Pulse2: 50% duty, length halt, const vol 12

; ===========================================================================
; CODE segment
; ===========================================================================
.segment "CODE"

; ===========================================================================
; RESET — standard NES initialisation
; ===========================================================================
.proc reset_handler
    sei                         ; disable IRQs
    cld                         ; clear decimal mode
    ldx #$FF
    txs                         ; stack pointer = $01FF

    ; disable PPU rendering and NMI
    lda #$00
    sta PPU_CTRL
    sta PPU_MASK

    ; wait for first vblank
@vbl1:
    bit PPU_STATUS
    bpl @vbl1

    ; clear CPU RAM pages $00, $03-$07 (skip stack $01xx, skip OAM $02xx)
    lda #$00
    ldx #$00
@clr:
    sta $0000,x
    sta $0300,x
    sta $0400,x
    sta $0500,x
    sta $0600,x
    sta $0700,x
    inx
    bne @clr

    ; fill OAM shadow ($0200-$02FF) with $FF to hide all sprites
    lda #$FF
    ldx #$00
@oam:
    sta $0200,x
    inx
    bne @oam

    ; wait for second vblank (PPU fully warmed up)
@vbl2:
    bit PPU_STATUS
    bpl @vbl2

    ; silence APU
    lda #$00
    sta APU_STATUS              ; disable all channels
    lda #$40
    sta APU_FRAME               ; 4-step mode, disable frame IRQ
    lda #$30
    sta P1_CTRL                 ; silence pulse 1 ($30 = duty 0, length halt, const vol 0)
    sta P2_CTRL                 ; silence pulse 2 (same value)

    jmp game_init
.endproc

; ===========================================================================
; GAME_INIT — set up a fresh game (called once from reset_handler)
; ===========================================================================
.proc game_init
    ; initialise game-state variables
    lda #STATE_PLAY
    sta game_state
    lda #PLAYER_X0
    sta player_x
    lda #PLAYER_Y0
    sta player_y

    lda #$00
    sta frame_ready
    sta prev_btns
    sta curr_btns
    sta new_dirs
    sta win_text_state

    ; clear audio state
    sta music_idx
    sta music_timer
    sta music_active
    sta sfx_active
    sta sfx_idx
    sta sfx_timer

    ; clear easter-egg state
    sta code_pos
    sta easter_active
    sta easter_timer
    sta easter_color
    ldx #7
@clrbuf:
    sta code_buf,x
    dex
    bpl @clrbuf

    ; -----------------------------------------------------------------------
    ; load palettes: write 32 bytes to PPU $3F00
    ; -----------------------------------------------------------------------
    bit PPU_STATUS              ; reset PPU address latch
    lda #$3F
    sta PPU_ADDR
    lda #$00
    sta PPU_ADDR
    ldx #0
@pal:
    lda palette_data,x
    sta PPU_DATA
    inx
    cpx #32
    bne @pal

    ; -----------------------------------------------------------------------
    ; clear nametable 0 + 1 ($2000-$27FF, 2048 bytes) to TILE_BLANK
    ; -----------------------------------------------------------------------
    bit PPU_STATUS
    lda #$20
    sta PPU_ADDR
    lda #$00
    sta PPU_ADDR
    lda #$00
    ldx #$00
    ldy #$00
@clrnt:
    sta PPU_DATA
    inx
    bne @clrnt
    iny
    cpy #8                      ; 8 × 256 = 2048 bytes
    bne @clrnt

    ; -----------------------------------------------------------------------
    ; set entire attribute table to $55 (all tiles use BG palette 1)
    ; -----------------------------------------------------------------------
    bit PPU_STATUS
    lda #>AT0
    sta PPU_ADDR
    lda #<AT0
    sta PPU_ADDR
    lda #$55
    ldx #64
@attr:
    sta PPU_DATA
    dex
    bne @attr

    ; -----------------------------------------------------------------------
    ; draw target zone: 4×4 block of TILE_TGT at tile rows 8-11, cols 12-15
    ;   nametable row 8, col 12 => $2000 + 8*32 + 12 = $210C
    ;   row offsets (low bytes of nametable address within page $21):
    ;     row  8 col 12 => lo = $0C
    ;     row  9 col 12 => lo = $2C
    ;     row 10 col 12 => lo = $4C
    ;     row 11 col 12 => lo = $6C
    ; -----------------------------------------------------------------------
    ldx #3                      ; loop 4 rows (index 3 down to 0)
@trow:
    bit PPU_STATUS
    lda #$21
    sta PPU_ADDR
    lda tgt_row_lo,x
    sta PPU_ADDR
    lda #TILE_TGT
    sta PPU_DATA
    sta PPU_DATA
    sta PPU_DATA
    sta PPU_DATA
    dex
    bpl @trow

    ; -----------------------------------------------------------------------
    ; set up player sprite in OAM shadow ($0200-$0203)
    ; -----------------------------------------------------------------------
    lda #PLAYER_Y0-1            ; OAM Y = sprite top edge - 1
    sta $0200
    lda #TILE_DIAM
    sta $0201                   ; tile index
    lda #$00
    sta $0202                   ; attributes: palette 0, no flip
    lda #PLAYER_X0
    sta $0203                   ; X position

    ; -----------------------------------------------------------------------
    ; start background music and enable APU
    ; -----------------------------------------------------------------------
    lda #1
    sta music_active
    lda #$00
    sta music_idx
    sta music_timer
    lda #$03
    sta APU_STATUS              ; enable pulse 1 + pulse 2

    ; -----------------------------------------------------------------------
    ; enable PPU rendering and NMI
    ; -----------------------------------------------------------------------
    lda #$1E
    sta PPU_MASK                ; show BG + sprites, full screen

    ; PPU_CTRL: NMI enable | sprite pattern=$1000 | BG pattern=$0000
    ;   bit7=1 (NMI), bit3=1 (sprite PT at $1000) => $88
    lda #$88
    sta PPU_CTRL

    jmp main_loop
.endproc

; Target-zone nametable row low bytes (within nametable hi-page $21)
; Rows 8-11, column 12: addresses $210C, $212C, $214C, $216C
tgt_row_lo:
    .byte $6C, $4C, $2C, $0C    ; stored in reverse so index 3->0 draws 8->11

; ===========================================================================
; NMI HANDLER — called on every vblank (~60 Hz)
; ===========================================================================
.proc nmi_handler
    pha
    txa
    pha
    tya
    pha

    ; --- OAM DMA (sprite data from $0200 to OAM, 513 cycles) ---
    lda #$00
    sta OAM_ADDR
    lda #$02
    sta OAM_DMA

    ; --- nametable text updates (must happen during vblank) ---
    lda win_text_state
    beq @text_done
    cmp #1
    bne @clear_text
    jsr draw_win_text
    lda #0
    sta win_text_state
    jmp @text_done
@clear_text:
    jsr clear_win_text
    lda #0
    sta win_text_state
@text_done:

    ; --- easter-egg colour flash ---
    lda easter_active
    beq @easter_done
    ; write cycling colour to PPU $3F00 (universal background colour)
    bit PPU_STATUS
    lda #$3F
    sta PPU_ADDR
    lda #$00
    sta PPU_ADDR
    ldx easter_color
    lda easter_colors,x
    sta PPU_DATA
    ; advance colour index mod 8
    inx
    cpx #8
    bne @esave
    ldx #0
@esave:
    stx easter_color
    ; tick timer
    dec easter_timer
    bne @easter_done
    ; timer expired: restore black background, deactivate
    bit PPU_STATUS
    lda #$3F
    sta PPU_ADDR
    lda #$00
    sta PPU_ADDR
    lda #$0F
    sta PPU_DATA
    lda #0
    sta easter_active
@easter_done:

    ; --- background music update ---
    lda music_active
    beq @music_done
    jsr update_music
@music_done:

    ; --- SFX update ---
    lda sfx_active
    beq @sfx_done
    jsr update_sfx
@sfx_done:

    ; --- set scroll to (0,0) ---
    bit PPU_STATUS
    lda #$00
    sta PPU_SCROLL
    sta PPU_SCROLL

    ; --- signal main loop ---
    lda #1
    sta frame_ready

    pla
    tay
    pla
    tax
    pla
    rti
.endproc

; ===========================================================================
; IRQ HANDLER — unused
; ===========================================================================
.proc irq_handler
    rti
.endproc

; ===========================================================================
; MAIN LOOP
; ===========================================================================
.proc main_loop
@top:
    ; spin until NMI signals a new frame
    lda frame_ready
    beq @top
    lda #0
    sta frame_ready

    ; read controller into curr_btns / prev_btns
    jsr read_controller

    lda game_state
    cmp #STATE_WIN
    beq @won

    ; --- STATE: PLAYING ---
    jsr handle_movement
    jsr check_collision
    jmp @top

    ; --- STATE: WON ---
@won:
    ; detect newly-pressed Start button
    lda curr_btns
    and #BTN_SRT
    beq @top                    ; Start not pressed
    lda prev_btns
    and #BTN_SRT
    bne @top                    ; Start was already held, not a new press

    jsr restart_game
    jmp @top
.endproc

; ===========================================================================
; READ_CONTROLLER — strobe $4016, shift 8 bits into curr_btns
; ===========================================================================
.proc read_controller
    ; save current as previous
    lda curr_btns
    sta prev_btns
    ; strobe controller latch
    lda #1
    sta CTRL1
    lda #0
    sta CTRL1
    ; read 8 buttons (A B Sel Start Up Down Left Right)
    lda #0
    sta curr_btns
    ldx #8
@loop:
    lda CTRL1
    lsr a                       ; bit 0 → carry
    rol curr_btns               ; carry into bit 0, everything shifts left
    dex
    bne @loop
    rts
.endproc

; ===========================================================================
; HANDLE_MOVEMENT — move player with d-pad, clamp, track Konami code
; ===========================================================================
.proc handle_movement
    ; compute newly-pressed directional bits: new = curr & ~prev
    lda prev_btns
    eor #$FF                    ; ~prev
    and curr_btns
    and #(BTN_UP|BTN_DOWN|BTN_LEFT|BTN_RIGHT)
    sta new_dirs                ; save for Konami tracking and blip trigger

    ; ----- movement (uses HELD buttons for smooth motion) -----
    lda curr_btns
    and #BTN_UP
    beq @no_up
    lda player_y
    cmp #SCRT+1                 ; stop when player_y <= SCRT (bcc: player_y < SCRT+1)
    bcc @no_up
    dec player_y
@no_up:

    lda curr_btns
    and #BTN_DOWN
    beq @no_down
    lda player_y
    cmp #SCRB
    bcs @no_down                ; already at/past bottom edge
    inc player_y
@no_down:

    lda curr_btns
    and #BTN_LEFT
    beq @no_left
    lda player_x
    beq @no_left                ; already at left edge (SCRL=0)
    dec player_x
@no_left:

    lda curr_btns
    and #BTN_RIGHT
    beq @no_right
    lda player_x
    cmp #SCRR
    bcs @no_right               ; already at/past right edge
    inc player_x
@no_right:

    ; update OAM shadow with new position
    lda player_y
    sec
    sbc #1                      ; OAM Y = visible Y - 1
    sta $0200
    lda player_x
    sta $0203

    ; trigger move-blip SFX on first directional press (not while win chime plays)
    lda new_dirs
    beq @no_blip
    jsr trigger_blip
@no_blip:

    ; ----- Konami code tracking (newly-pressed directions only) -----
    lda new_dirs
    beq @done

    ; encode first direction found (priority: Up > Down > Left > Right)
    and #BTN_UP
    beq @ck_down
    lda #1
    jsr push_code
    jmp @done
@ck_down:
    lda new_dirs
    and #BTN_DOWN
    beq @ck_left
    lda #2
    jsr push_code
    jmp @done
@ck_left:
    lda new_dirs
    and #BTN_LEFT
    beq @ck_right
    lda #3
    jsr push_code
    jmp @done
@ck_right:
    lda new_dirs
    and #BTN_RIGHT
    beq @done
    lda #4
    jsr push_code
@done:
    rts
.endproc

; ===========================================================================
; PUSH_CODE — add encoded direction (A) to ring buffer, then check sequence
; ===========================================================================
.proc push_code
    ldx code_pos
    sta code_buf,x
    inx
    cpx #KONAMI_LEN
    bne @ok
    ldx #0
@ok:
    stx code_pos
    jsr check_konami
    rts
.endproc

; ===========================================================================
; CHECK_KONAMI — compare ring buffer against konami_seq, activate easter egg
; ===========================================================================
.proc check_konami
    ; walk the ring starting at code_pos (oldest entry) and compare
    ldx code_pos
    ldy #0
@cmp:
    lda code_buf,x
    cmp konami_seq,y
    bne @no_match
    inx
    cpx #KONAMI_LEN
    bne @nowrap
    ldx #0
@nowrap:
    iny
    cpy #KONAMI_LEN
    bne @cmp
    ; full sequence matched — activate easter egg (ignore if already active)
    lda easter_active
    bne @no_match
    lda #1
    sta easter_active
    lda #180
    sta easter_timer
    lda #0
    sta easter_color
@no_match:
    rts
.endproc

; ===========================================================================
; TRIGGER_BLIP — queue a short high-pitch tick on Pulse 2
;                (skipped if the win chime is currently playing)
; ===========================================================================
.proc trigger_blip
    lda sfx_active
    cmp #2
    beq @skip                   ; win chime in progress, do not interrupt
    lda #P2_BLIP                ; 12.5% duty, length halt, vol 4
    sta P2_CTRL
    lda #$00
    sta P2_SWEEP
    lda #$50                    ; period lo  ($0050 ≈ ~1 kHz blip)
    sta P2_LO
    lda #$00
    sta P2_HI
    lda #1
    sta sfx_active
    lda #3
    sta sfx_timer
@skip:
    rts
.endproc

; ===========================================================================
; CHECK_COLLISION — AABB test of sprite against target zone
; ===========================================================================
.proc check_collision
    lda game_state
    cmp #STATE_WIN
    beq @done                   ; already won, skip

    lda player_x
    cmp #COL_XL
    bcc @done                   ; too far left
    cmp #COL_XR+1
    bcs @done                   ; too far right
    lda player_y
    cmp #COL_YT
    bcc @done                   ; too high
    cmp #COL_YB+1
    bcs @done                   ; too low

    ; ----- collision! -----
    lda #STATE_WIN
    sta game_state
    ; stop background music
    lda #0
    sta music_active
    lda #$30
    sta P1_CTRL                 ; silence pulse 1
    ; start win-chime SFX
    lda #2
    sta sfx_active
    lda #0
    sta sfx_idx
    sta sfx_timer               ; update_sfx will load first note next NMI
    ; request win-text draw (NMI will handle it)
    lda #1
    sta win_text_state
@done:
    rts
.endproc

; ===========================================================================
; RESTART_GAME — reset player and game state for a new round
; ===========================================================================
.proc restart_game
    ; request nametable clear of win text
    lda #2
    sta win_text_state
    ; reset player position
    lda #PLAYER_X0
    sta player_x
    lda #PLAYER_Y0
    sta player_y
    ; update OAM shadow immediately
    lda #PLAYER_Y0-1
    sta $0200
    lda #PLAYER_X0
    sta $0203
    ; go back to playing
    lda #STATE_PLAY
    sta game_state
    ; restart music
    lda #0
    sta music_idx
    sta music_timer
    lda #1
    sta music_active
    ; clear SFX
    lda #0
    sta sfx_active
    sta sfx_timer
    sta sfx_idx
    lda #$30
    sta P2_CTRL                 ; silence pulse 2
    rts
.endproc

; ===========================================================================
; DRAW_WIN_TEXT — write tile indices to nametable (called inside NMI vblank)
; ===========================================================================
.proc draw_win_text
    ; "YOU WIN!" at row 18, col 12  (nametable $224C)
    bit PPU_STATUS
    lda #WIN_HI
    sta PPU_ADDR
    lda #WIN_LO
    sta PPU_ADDR
    lda #TILE_Y
    sta PPU_DATA
    lda #TILE_O
    sta PPU_DATA
    lda #TILE_U
    sta PPU_DATA
    lda #TILE_BLANK
    sta PPU_DATA
    lda #TILE_W
    sta PPU_DATA
    lda #TILE_I
    sta PPU_DATA
    lda #TILE_N
    sta PPU_DATA
    lda #TILE_EXCL
    sta PPU_DATA

    ; "PRESS START" at row 20, col 10  (nametable $228A)
    bit PPU_STATUS
    lda #RST_HI
    sta PPU_ADDR
    lda #RST_LO
    sta PPU_ADDR
    lda #TILE_P
    sta PPU_DATA
    lda #TILE_R
    sta PPU_DATA
    lda #TILE_E
    sta PPU_DATA
    lda #TILE_S
    sta PPU_DATA
    lda #TILE_S
    sta PPU_DATA
    lda #TILE_BLANK
    sta PPU_DATA
    lda #TILE_S
    sta PPU_DATA
    lda #TILE_T_LTR
    sta PPU_DATA
    lda #TILE_A
    sta PPU_DATA
    lda #TILE_R
    sta PPU_DATA
    lda #TILE_T_LTR
    sta PPU_DATA
    rts
.endproc

; ===========================================================================
; CLEAR_WIN_TEXT — overwrite win/restart text with blank tiles (inside NMI)
; ===========================================================================
.proc clear_win_text
    bit PPU_STATUS
    lda #WIN_HI
    sta PPU_ADDR
    lda #WIN_LO
    sta PPU_ADDR
    lda #TILE_BLANK
    ldx #8
@l1:
    sta PPU_DATA
    dex
    bne @l1

    bit PPU_STATUS
    lda #RST_HI
    sta PPU_ADDR
    lda #RST_LO
    sta PPU_ADDR
    lda #TILE_BLANK
    ldx #11
@l2:
    sta PPU_DATA
    dex
    bne @l2
    rts
.endproc

; ===========================================================================
; UPDATE_MUSIC — advance Pulse-1 melody one frame (called from NMI)
; ===========================================================================
.proc update_music
    lda music_timer
    beq @load                   ; timer expired → load next note
    dec music_timer
    rts

@load:
    ldx music_idx
    lda music_data,x            ; load byte: note index, $FE=rest, $FF=loop
    cmp #$FF
    bne @not_loop
    ; loop marker: reset to beginning
    lda #0
    sta music_idx
    ldx #0
    lda music_data,x            ; reload first byte (same as music_data[0])
@not_loop:
    cmp #$FE
    bne @play
    ; rest: silence pulse 1
    lda #$30
    sta P1_CTRL
    lda music_data+1,x          ; duration in frames
    sta music_timer
    lda music_idx
    clc
    adc #2
    sta music_idx
    rts

@play:
    ; A = note index, X = music_idx
    tay
    lda note_lo,y
    sta P1_LO
    lda note_hi,y
    sta P1_HI
    lda #P1_ENV
    sta P1_CTRL
    lda #$00
    sta P1_SWEEP
    lda music_data+1,x          ; duration
    sta music_timer
    lda music_idx
    clc
    adc #2
    sta music_idx
    rts
.endproc

; ===========================================================================
; UPDATE_SFX — advance Pulse-2 sound effects one frame (called from NMI)
; ===========================================================================
.proc update_sfx
    lda sfx_active
    cmp #1
    beq @blip
    cmp #2
    beq @chime
    rts

@blip:
    ; count down the short blip timer
    lda sfx_timer
    beq @silence
    dec sfx_timer
    rts
@silence:
    lda #$30
    sta P2_CTRL
    lda #0
    sta sfx_active
    rts

@chime:
    ; count down current chime note duration
    lda sfx_timer
    beq @chime_next
    dec sfx_timer
    rts

@chime_next:
    ldx sfx_idx
    lda win_sfx,x               ; note index or $FF (end)
    cmp #$FF
    bne @chime_play
    ; chime finished
    lda #$30
    sta P2_CTRL
    lda #0
    sta sfx_active
    rts

@chime_play:
    tay
    lda note_lo,y
    sta P2_LO
    lda note_hi,y
    sta P2_HI
    lda #P2_CHIME
    sta P2_CTRL
    lda #$00
    sta P2_SWEEP
    lda win_sfx+1,x             ; duration
    sta sfx_timer
    lda sfx_idx
    clc
    adc #2
    sta sfx_idx
    rts
.endproc

; ===========================================================================
; RODATA — read-only constant data
; ===========================================================================
.segment "RODATA"

; ---------------------------------------------------------------------------
; Palette: 32 bytes written to PPU $3F00
;   BG palette 1  col1=$28 (yellow) used for target-border tiles
;                 col2=$30 (white)  used for win-text tiles
;   Sprite palette 0  col1=$20 (white) for diamond sprite
; ---------------------------------------------------------------------------
palette_data:
    ; BG palettes (16 bytes)
    .byte $0F               ; $3F00 universal BG = black
    .byte $0F,$0F,$0F       ; BG pal 0: all black  (blank tiles)
    .byte $0F               ; $3F04 (mirrors $3F00)
    .byte $28,$30,$0F       ; BG pal 1: yellow / white / black
    .byte $0F               ; $3F08
    .byte $0F,$0F,$0F       ; BG pal 2 (unused)
    .byte $0F               ; $3F0C
    .byte $0F,$0F,$0F       ; BG pal 3 (unused)
    ; Sprite palettes (16 bytes)
    .byte $0F               ; $3F10 (mirrors $3F00)
    .byte $20,$2C,$0F       ; Sprite pal 0: white / yellow / black (diamond)
    .byte $0F               ; $3F14
    .byte $0F,$0F,$0F       ; Sprite pal 1 (unused)
    .byte $0F               ; $3F18
    .byte $0F,$0F,$0F       ; Sprite pal 2 (unused)
    .byte $0F               ; $3F1C
    .byte $0F,$0F,$0F       ; Sprite pal 3 (unused)

; ---------------------------------------------------------------------------
; Note period tables  (NES APU: period = CPU_CLK/(16*f) - 1 ≈ 1789773/(16*f)-1)
; Index: 0=C4  1=D4  2=E4  3=F4  4=G4  5=A4  6=B4  7=C5  8=E5  9=G5
; ---------------------------------------------------------------------------
note_lo:
    .byte $AA,$7B,$52,$3F,$1C,$FD,$E1,$D4,$A8,$8D
note_hi:
    .byte $01,$01,$01,$01,$01,$00,$00,$00,$00,$00

; ---------------------------------------------------------------------------
; Background music data: pairs of (note_index, duration_frames)
;   $FE = rest,  $FF = loop back to start
; ---------------------------------------------------------------------------
music_data:
    .byte 0, 12     ; C4  200ms
    .byte 2, 12     ; E4
    .byte 4, 12     ; G4
    .byte 7, 12     ; C5
    .byte 4,  8     ; G4
    .byte 2,  8     ; E4
    .byte 5, 12     ; A4
    .byte 6, 12     ; B4
    .byte 7, 24     ; C5 (held)
    .byte $FE, 8    ; rest
    .byte $FF       ; loop

; ---------------------------------------------------------------------------
; Win-chime SFX: (note_index, duration_frames), $FF = end
; ---------------------------------------------------------------------------
win_sfx:
    .byte 7,  8     ; C5
    .byte 8,  8     ; E5
    .byte 9, 12     ; G5
    .byte $FF

; ---------------------------------------------------------------------------
; Easter-egg colour table (8 vivid NES colours for background flash)
; ---------------------------------------------------------------------------
easter_colors:
    .byte $15,$25,$35,$19,$29,$1A,$2A,$11

; ---------------------------------------------------------------------------
; Konami sequence: 1=Up  2=Down  3=Left  4=Right
; ---------------------------------------------------------------------------
konami_seq:
    .byte 1,1,2,2,3,4,3,4

; ---------------------------------------------------------------------------
; VECTORS — must be placed at $FFFA
; ---------------------------------------------------------------------------
.segment "VECTORS"
    .word nmi_handler
    .word reset_handler
    .word irq_handler

; ===========================================================================
; CHARS — 8 KB CHR-ROM
;
;   Bytes    0 –  4095 : background pattern table (PPU $0000-$0FFF)
;   Bytes 4096 –  8191 : sprite pattern table     (PPU $1000-$1FFF)
;
; Each tile = 16 bytes: 8 bytes plane-0 then 8 bytes plane-1
;   pixel colour = (plane1_bit<<1) | plane0_bit
;   0 = transparent/BG  1 = palette col1  2 = palette col2
;
; Background tiles use plane-0 data for colour-1 (yellow target border)
;                  and plane-1 data for colour-2 (white text letters).
; Sprite tile uses plane-0 data for colour-1 (white diamond, sprite pal 0).
; ===========================================================================
.segment "CHARS"

; ---- Tile $00 : BLANK -------------------------------------------------------
    .byte $00,$00,$00,$00,$00,$00,$00,$00   ; plane 0
    .byte $00,$00,$00,$00,$00,$00,$00,$00   ; plane 1

; ---- Tile $01 : TARGET BORDER (colour 1 = yellow) --------------------------
;   Solid bordered 8×8 square
    .byte $FF,$81,$81,$81,$81,$81,$81,$FF   ; plane 0
    .byte $00,$00,$00,$00,$00,$00,$00,$00   ; plane 1

; ---- Tile $02 : 'Y' (colour 2 = white) -------------------------------------
;   plane-0 = $00, pixel data in plane-1
    .byte $00,$00,$00,$00,$00,$00,$00,$00
    .byte $88,$88,$50,$20,$20,$20,$20,$00

; ---- Tile $03 : 'O' ---------------------------------------------------------
    .byte $00,$00,$00,$00,$00,$00,$00,$00
    .byte $38,$44,$82,$82,$82,$44,$38,$00

; ---- Tile $04 : 'U' ---------------------------------------------------------
    .byte $00,$00,$00,$00,$00,$00,$00,$00
    .byte $82,$82,$82,$82,$82,$44,$38,$00

; ---- Tile $05 : 'W' ---------------------------------------------------------
    .byte $00,$00,$00,$00,$00,$00,$00,$00
    .byte $82,$82,$82,$92,$AA,$C6,$82,$00

; ---- Tile $06 : 'I' ---------------------------------------------------------
    .byte $00,$00,$00,$00,$00,$00,$00,$00
    .byte $FE,$10,$10,$10,$10,$10,$FE,$00

; ---- Tile $07 : 'N' ---------------------------------------------------------
    .byte $00,$00,$00,$00,$00,$00,$00,$00
    .byte $82,$C2,$A2,$92,$8A,$86,$82,$00

; ---- Tile $08 : '!' ---------------------------------------------------------
    .byte $00,$00,$00,$00,$00,$00,$00,$00
    .byte $10,$10,$10,$10,$00,$00,$10,$00

; ---- Tile $09 : 'P' ---------------------------------------------------------
    .byte $00,$00,$00,$00,$00,$00,$00,$00
    .byte $FC,$82,$82,$FC,$80,$80,$80,$00

; ---- Tile $0A : 'R' ---------------------------------------------------------
    .byte $00,$00,$00,$00,$00,$00,$00,$00
    .byte $FC,$82,$82,$FC,$A0,$90,$8C,$00

; ---- Tile $0B : 'E' ---------------------------------------------------------
    .byte $00,$00,$00,$00,$00,$00,$00,$00
    .byte $FE,$80,$80,$FC,$80,$80,$FE,$00

; ---- Tile $0C : 'S' ---------------------------------------------------------
    .byte $00,$00,$00,$00,$00,$00,$00,$00
    .byte $7C,$82,$80,$7C,$02,$82,$7C,$00

; ---- Tile $0D : 'T' ---------------------------------------------------------
    .byte $00,$00,$00,$00,$00,$00,$00,$00
    .byte $FE,$10,$10,$10,$10,$10,$10,$00

; ---- Tile $0E : 'A' ---------------------------------------------------------
    .byte $00,$00,$00,$00,$00,$00,$00,$00
    .byte $38,$44,$82,$FE,$82,$82,$82,$00

; ---- Tile $0F : 'G' ---------------------------------------------------------
    .byte $00,$00,$00,$00,$00,$00,$00,$00
    .byte $7C,$80,$80,$8E,$82,$82,$7C,$00

; ---- Tile $10 : 'L' ---------------------------------------------------------
    .byte $00,$00,$00,$00,$00,$00,$00,$00
    .byte $80,$80,$80,$80,$80,$80,$FE,$00

; ---- Tiles $11-$FF : blank (linker fills the rest of 4 KB with $00) --------
; Pad from current position (17 tiles × 16 bytes = 272) to 4096 bytes
    .res (4096 - 17 * 16)       ; 3824 bytes of zero padding

; ---- Sprite Tile $00 : DIAMOND (PPU $1000, sprite pattern table tile 0) ----
;   Diamond shape using plane-0 (colour 1 = white via sprite palette 0)
;   ...XX...   $18
;   ..XXXX..   $3C
;   .XXXXXX.   $7E
;   XXXXXXXX   $FF
;   XXXXXXXX   $FF
;   .XXXXXX.   $7E
;   ..XXXX..   $3C
;   ...XX...   $18
    .byte $18,$3C,$7E,$FF,$FF,$7E,$3C,$18   ; plane 0
    .byte $00,$00,$00,$00,$00,$00,$00,$00   ; plane 1