c64-kb 0.17.0

package/templates/shmup-vertical/src/mux.asm

@@ -0,0 +1,321 @@
+// mux.asm: the sprite multiplexer, imported by kernel.asm.
+//
+// Mechanism from c64-kb's kickassembler/sprite-multiplex-game recipe
+// (technique sprite_multiplex_game): a persistent insertion sort by Y, a
+// sorted table built into the half the IRQs are not reading, zone IRQs that
+// reuse the eight hardware sprites further down, and a late guard. Changes
+// here: no zero page (Oscar64 owns $02-$52), thirteen actors, sprite
+// pointers written into both playfield screens, an enable mask for fewer
+// than eight sprites, and a cut-off Y below which nothing is shown, so no
+// sprite is on the lines where the panel split is timed.
+//
+// C fills act_y/act_hx/act_ptr/act_col (Y = OFF_Y hides an actor),
+// then calls mux_sort and mux_build once a frame, after mux_ready is 0.
+
+.const N       = 13        // actors: the ship and twelve enemies (16 cost
+                           // the sort 3 idle actors a frame)
+.const BUF     = 16        // offset of sorted half 1 (a multiple of 8)
+.const MIN_GAP = 21        // a reused slot's next Y must be >= its last Y + 21
+.const JOIN    = 4         // sprites within 4 lines of a zone's first join it
+.const LEAD    = 3         // zone IRQ line = first Y - LEAD - sprites in zone
+.const MARGIN  = 3         // late guard: within 3 lines of the next line? run it now
+// Lowest Y shown: its last line is 208. A sprite on line 214 breaks the
+// panel split (its DMA delays the split's writes: with 8 sprites there, 16 of
+// 16 PAL shots and 4 of 16 NTSC broke); sprites ending on line 213 left it
+// clean (0 of 16 on each model). Measured in VICE x64sc 3.10 in the review of
+// this starter. 187 keeps 5 lines of margin; 192 is the measured limit.
+.const MAX_SY  = 187
+.const OFF_Y   = $ff       // an actor with this Y is not shown
+
+// ---- the actor tables C writes ------------------------------------------
+act_y:     .fill N, OFF_Y
+act_hx:    .fill N, 0      // half X: sprite X = 2 * hx
+act_ptr:   .fill N, 0
+act_col:   .fill N, 0
+order:     .fill N, i
+mux_ready: .byte 0         // C sets nothing; build sets 1, the frame IRQ clears it
+mux_shown: .byte 0         // sprites accepted by the last build (for the verdict)
+mux_peak:  .byte 0         // most sprites accepted in one build since init
+mux_front: .byte 0         // 0 or BUF: the half the IRQs read
+
+// ---- sorted halves and zone tables (half 0 at 0, half 1 at BUF) ---------
+sy:      .fill 2*BUF, 0
+sx:      .fill 2*BUF, 0
+sptr:    .fill 2*BUF, 0
+scol:    .fill 2*BUF, 0
+sd010:   .fill 2*BUF, 0
+zstart:  .fill 2*BUF, 0
+zend:    .fill 2*BUF, 0
+zline:   .fill 2*BUF, 0
+zlast_b: .fill 2*BUF, 0
+en_b:    .fill 2*BUF, 0    // $D015 for the half: one bit per slot in use
+slot:    .fill 2*BUF, i & 7
+slot2:   .fill 2*BUF, (i & 7) * 2
+bitm:    .fill 2*BUF, 1 << (i & 7)
+bitc:    .fill 2*BUF, $ff ^ (1 << (i & 7))
+enmask:  .byte $00, $01, $03, $07, $0f, $1f, $3f, $7f, $ff
+
+// build's scratch
+bo:      .byte 0
+acc:     .byte 0
+bk:      .byte 0
+bo8:     .byte 0
+by:      .byte 0
+d010run: .byte 0
+zw:      .byte 0
+ybase:   .byte 0
+ylim:    .byte 0
+zn:      .byte 0
+key:     .byte 0
+cand:    .byte 0
+s_i:     .byte 0
+
+// ---------------------------------------------------------------------------
+// Persistent insertion sort: order[] keeps last frame's order, so an actor
+// that has not passed a neighbour costs one compare. Ties keep their order.
+// Aligned so both loop branches stay inside one page (a crossing costs a
+// cycle a branch: the recipe measured 611 against 656 cycles).
+// ---------------------------------------------------------------------------
+.align $100
+mux_sort:
+        ldx #1
+s_loop: ldy order,x
+        lda act_y,y
+        ldy order-1,x
+        cmp act_y,y
+        bcs s_next              // in place
+        sta key
+        lda order,x
+        sta cand
+        stx s_i
+s_shift:
+        lda order-1,x
+        sta order,x
+        dex
+        beq s_place
+        ldy order-1,x
+        lda act_y,y
+        cmp key
+        beq s_place
+        bcs s_shift             // still greater than the key
+s_place:
+        lda cand
+        sta order,x
+        ldx s_i
+s_next: inx
+        cpx #N
+        bne s_loop
+        rts
+
+// ---------------------------------------------------------------------------
+// Build the back half: accept each sorted actor that can be shown, keep a
+// running $D010, then group sprites 8 onward into zones. X stays the write
+// place and Y the actor, with the read place in bk: about 20 cycles an
+// actor fewer than swapping X between the two places, which this loop did
+// first (arithmetic from the cycle counts of its instructions).
+// ---------------------------------------------------------------------------
+mux_build:
+        lda mux_front
+        eor #BUF
+        sta bo
+        tax                     // X: where the next accepted actor goes
+        clc
+        adc #8
+        sta bo8                 // the first eight always fit
+        lda #0
+        sta d010run
+        sta bk                  // the next place in order[]
+b_loop: ldy bk
+        cpy #N
+        beq b_done
+        inc bk
+        lda order,y
+        tay                     // Y: the actor
+        lda act_y,y
+        cmp #MAX_SY+1
+        bcs b_done              // sorted: every later actor is lower still
+        cpx bo8
+        bcc b_accept
+        sta by
+        sec
+        sbc sy-8,x              // gap to the last sprite this slot showed
+        cmp #MIN_GAP
+        bcc b_loop              // too close: this actor is not shown this frame
+        lda by
+b_accept:
+        sta sy,x
+        lda act_ptr,y
+        sta sptr,x
+        lda act_col,y
+        sta scol,x
+        lda act_hx,y            // X = 2 * hx: bit 8 comes out in the carry
+        asl
+        sta sx,x
+        lda d010run
+        bcc b_clear
+        ora bitm,x
+        bcs b_store             // ora leaves the carry set
+b_clear:
+        and bitc,x
+b_store:
+        sta d010run
+        sta sd010,x
+        inx
+        jmp b_loop
+b_done:
+        stx acc                 // fewer than eight: the frame IRQ writes the
+                                // $D010 stored with entry 7, so fill up to it
+!:      txa
+        sec
+        sbc bo
+        cmp #8
+        bcs !+
+        lda d010run
+        sta sd010,x
+        inx
+        bne !-
+!:      lda acc                 // sprites shown, and the enable mask
+        sec
+        sbc bo
+        sta mux_shown
+        cmp mux_peak
+        bcc !+
+        sta mux_peak
+!:      ldx mux_shown
+        cpx #8
+        bcc !+
+        ldx #8
+!:      lda enmask,x
+        ldy bo
+        sta en_b,y
+
+        lda bo                  // zones over accepted sprites 8..acc-1
+        sta zw
+        clc
+        adc #8
+        tax
+z_loop: cpx acc
+        bcs z_done
+        ldy zw
+        txa
+        sta zstart,y
+        lda sy,x
+        sta ybase
+        clc
+        adc #JOIN
+        sta ylim
+        lda #0
+        sta zn
+z_in:   inx
+        inc zn
+        cpx acc
+        bcs z_close
+        lda sy,x
+        cmp ylim
+        bcc z_in
+        beq z_in
+z_close:
+        txa
+        sta zend,y
+        lda ybase
+        sec
+        sbc #LEAD
+        sbc zn
+        sta zline,y
+        inc zw
+        jmp z_loop
+z_done: ldy bo
+        lda zw
+        sta zlast_b,y
+        lda #1
+        sta mux_ready
+        rts
+
+// Zone body: write every sprite of zone zidx, Y first; then the next zone,
+// or the panel split after the last one (kernel.asm's arm_split).
+zone_body:
+        ldx zidx
+        lda zend,x
+        sta zend_tmp
+        ldy zstart,x
+zl:     ldx slot2,y
+        lda sy,y
+        sta $d001,x
+        lda sx,y
+        sta $d000,x
+        ldx slot,y
+        lda sptr,y
+        sta PTRS_A,x
+        sta PTRS_B,x
+        lda scol,y
+        sta $d027,x
+        lda sd010,y
+        sta $d010
+        iny
+        cpy zend_tmp
+        bne zl
+        ldx zidx
+        inx
+        stx zidx
+        cpx zlast
+        beq z_to_split
+        lda zline,x
+        jmp schedule
+z_to_split:
+        jsr arm_split           // the split's own vector and line
+        lda #SPLIT_LINE-MARGIN
+        cmp $d012
+        bcs on_time             // in time: return and let it fire
+        inc mux_late            // late: run it now; the ack at its end clears
+        inc split_late          // the match latched meanwhile
+        jmp split_body
+
+// schedule: A = next line. If the raster is already within MARGIN lines of
+// it, run the next body now instead of returning and missing it a frame.
+schedule:
+        sta $d012
+        sec
+        sbc #MARGIN
+        cmp $d012
+        bcs on_time
+        inc mux_late
+        jmp dispatch
+on_time:
+        lda #$01
+        sta $d019
+        jmp irq_exit
+
+zidx:     .byte 0
+zlast:    .byte 0
+zend_tmp: .byte 0
+mux_late: .byte 0          // times the late guard ran a zone at once (wraps)
+
+// The frame IRQ's sprite half: swap in a ready build, write the first eight.
+mux_frame:
+        lda mux_ready
+        beq !+
+        lda mux_front
+        eor #BUF
+        sta mux_front
+        lda #0
+        sta mux_ready
+!:      ldy mux_front
+        .for (var s = 0; s < 8; s++) {
+            lda sy + s, y
+            sta $d001 + s * 2
+            lda sx + s, y
+            sta $d000 + s * 2
+            lda sptr + s, y
+            sta PTRS_A + s
+            sta PTRS_B + s
+            lda scol + s, y
+            sta $d027 + s
+        }
+        lda sd010 + 7, y
+        sta $d010
+        lda en_b, y
+        sta $d015
+        sty zidx
+        lda zlast_b, y
+        sta zlast
+        rts

package/templates/shmup-vertical/src/sound.asm

@@ -0,0 +1,255 @@
+// sound.asm: a three-voice music player with sound effects inside it,
+// imported by kernel.asm. The split IRQ calls music_play once a frame.
+//
+// Mechanism from c64-kb's kickassembler/sfx-in-player recipe (technique
+// sfx_in_player) and the init + play convention of oscar64/sid-music-player
+// (sid_play_routine_pattern). The player writes a 25-byte shadow of the SID
+// and copies it to $D400-$D418 once a frame. An effect takes voice 3 for its
+// length; the music keeps advancing underneath and, while it owns a voice,
+// writes that voice's whole instrument every frame, so the frame an effect
+// ends the tune's voice 3 is back at once. No zero page: the pattern and
+// effect reads patch their own operands. The tune is original.
+//
+// On NTSC the play routine skips one call in six, so the tune keeps its PAL
+// tempo (pitfall pal_ntsc_tempo_mismatch), and music_init loads the NTSC
+// frequency table, so it keeps its pitch.
+
+.const PAL_CLOCK  = 985248
+.const NTSC_CLOCK = 1022727
+
+// Instruments, one per voice: bass (pulse), lead (sawtooth), drums (noise).
+ilen:   .byte 12, 6, 12            // frames a note lasts
+iwave:  .byte $40, $20, $80        // waveform, gate bit clear
+iad:    .byte $09, $08, $02
+isr:    .byte $a8, $64, $00
+ipw:    .byte $04, $08, $08        // pulse width, high byte
+patlo:  .byte <pat_bass, <pat_lead, <pat_drum
+pathi:  .byte >pat_bass, >pat_lead, >pat_drum
+voff:   .byte 0, 7, 14             // voice register offsets
+
+vpos:   .fill 3, 0                 // next byte of the pattern
+vtime:  .fill 3, 0                 // frames into the note
+vnote:  .fill 3, 0                 // the note, 0 = rest
+
+sfx_pending: .byte 0               // highest effect requested since the last play
+sfx_num:     .byte 0               // effect on voice 3, 0 = none
+sfx_pos:     .byte 0               // next byte of its data
+sfx_taken:   .byte 0               // effects started (for the verdict)
+ntsc_cnt:    .byte 4
+tempo_ntsc:  .byte 0
+
+ghost:  .fill 25, 0                // the SID as the player wants it
+
+// A = 0 for PAL, 1 for NTSC.
+music_init:
+        sta tempo_ntsc
+        beq mi_pal
+        ldx #95
+!:      lda ntsc_lo,x
+        sta freq_lo,x
+        lda ntsc_hi,x
+        sta freq_hi,x
+        dex
+        bpl !-
+mi_pal: ldx #2
+!:      lda #0
+        sta vpos,x
+        sta vtime,x
+        dex
+        bpl !-
+        sta sfx_pending
+        sta sfx_num
+        ldx #24
+!:      sta ghost,x
+        dex
+        bpl !-
+        lda #$0f
+        sta ghost+24               // volume 15, no filter
+        rts
+
+// A = effect number 1-3. A higher number wins; call with interrupts off.
+sfx_request:
+        cmp sfx_pending
+        bcc !+
+        sta sfx_pending
+!:      rts
+
+music_play:
+        lda tempo_ntsc
+        beq mp_run
+        dec ntsc_cnt
+        bpl mp_run
+        lda #4                     // every sixth NTSC frame: no step
+        sta ntsc_cnt
+        rts
+mp_run: lda sfx_pending            // start the queued effect unless a
+        beq mp_fx                  // higher one is playing
+        cmp sfx_num
+        bcc mp_drop
+        sta sfx_num
+        tax
+        lda fx_lo-1,x
+        sta sfx_pos
+        inc sfx_taken
+        jsr fx_header
+        lda #0                     // gate off for one frame, so the next row's
+        sta ghost+14+4             // gate on restarts the envelope
+        sta sfx_pending
+        jmp mp_music
+mp_drop:
+        lda #0
+        sta sfx_pending
+mp_fx:  lda sfx_num
+        beq mp_music
+        jsr fx_row
+mp_music:
+        ldx #2
+!:      jsr voice
+        dex
+        bpl !-
+        .for (var r = 24; r >= 0; r--) {   // ghost copy: every register, once a
+            lda ghost + r               // frame, top down as the loop did; unrolled,
+            sta $d400 + r               // 200 cycles against 350
+        }
+        rts
+
+// One voice, X = 0-2. The music advances every frame, owned or not.
+voice:  lda vtime,x
+        bne v_gate
+        lda patlo,x                // first frame of a note: fetch it
+        sta v_rd+1
+        sta v_rd2+1
+        lda pathi,x
+        sta v_rd+2
+        sta v_rd2+2
+        ldy vpos,x
+v_rd:   lda $ffff,y
+        cmp #$ff
+        bne v_got
+        ldy #0                     // end of pattern: loop
+v_rd2:  lda $ffff,y
+v_got:  sta vnote,x
+        iny
+        tya
+        sta vpos,x
+v_gate: ldy #0                     // gate on for all but a note's last two frames
+        lda vnote,x
+        beq v_off
+        lda vtime,x
+        clc
+        adc #2
+        cmp ilen,x
+        bcs v_off
+        iny
+v_off:  sty v_g+1
+        inc vtime,x
+        lda vtime,x
+        cmp ilen,x
+        bne !+
+        lda #0
+        sta vtime,x
+!:      cpx #2                     // voice 3 while an effect owns it: leave it
+        bne v_write
+        lda sfx_num
+        beq v_write
+        rts
+v_write:
+        ldy voff,x
+        lda vnote,x
+        beq !+
+        stx v_x+1
+        tax
+        lda freq_lo,x
+        sta ghost+0,y
+        lda freq_hi,x
+        sta ghost+1,y
+v_x:    ldx #0
+!:      lda #0
+        sta ghost+2,y
+        lda ipw,x
+        sta ghost+3,y
+        lda iwave,x
+v_g:    ora #0
+        sta ghost+4,y
+        lda iad,x
+        sta ghost+5,y
+        lda isr,x
+        sta ghost+6,y
+        rts
+
+// Effect data: AD, SR, pulse high, then rows of (control, frequency high),
+// one row a frame, ended by a control byte of 0. Voice 3 is ghost+14.
+fx_header:
+        jsr fx_byte
+        sta ghost+14+5
+        jsr fx_byte
+        sta ghost+14+6
+        jsr fx_byte
+        sta ghost+14+3
+        lda #0
+        sta ghost+14+2
+        sta ghost+14+0
+        rts
+
+fx_row: jsr fx_byte
+        beq fx_end
+        sta ghost+14+4
+        jsr fx_byte
+        sta ghost+14+1
+        rts
+fx_end: sta sfx_num                // A = 0: the music takes voice 3 back this frame
+        rts
+
+fx_byte:
+        ldx sfx_pos
+        lda fx_data,x
+        inc sfx_pos
+        cmp #0
+        rts
+
+// ---- data ---------------------------------------------------------------
+// Notes: octave * 12 + semitone, C = 0 (A4 = 57). 0 is a rest, $FF loops.
+pat_bass:
+        .byte 33, 33, 45, 33,  31, 31, 43, 31,  29, 29, 41, 29,  28, 28, 40, 28
+        .byte $ff
+pat_lead:
+        .byte 57, 60, 64, 69, 64, 60, 57, 0
+        .byte 55, 59, 62, 67, 62, 59, 55, 0
+        .byte 53, 57, 60, 65, 60, 57, 53, 0
+        .byte 52, 56, 59, 64, 59, 56, 52, 0
+        .byte 57, 64, 69, 72, 69, 64, 60, 64
+        .byte 55, 62, 67, 71, 67, 62, 59, 62
+        .byte 53, 60, 65, 69, 65, 60, 57, 60
+        .byte 52, 59, 64, 68, 64, 59, 56, 0
+        .byte $ff
+pat_drum:
+        .byte 84, 0, 72, 0, 84, 84, 72, 0
+        .byte $ff
+
+// Effects: 1 shot, 2 explosion, 3 the player's ship lost.
+fx_lo:  .byte fx_shot - fx_data, fx_boom - fx_data, fx_dead - fx_data
+fx_data:
+fx_shot:
+        .byte $00, $a0, $08
+        .byte $41, $30, $41, $28, $41, $20, $40, $18, $40, $10
+        .byte 0
+fx_boom:
+        .byte $00, $f9, $08
+        .byte $81, $28, $81, $20, $81, $18, $81, $14, $81, $10, $81, $0c
+        .byte $80, $0a, $80, $08, $80, $06, $80, $05
+        .byte 0
+fx_dead:
+        .byte $00, $fa, $08
+        .byte $21, $40, $21, $38, $21, $30, $21, $28, $81, $30, $81, $28
+        .byte $81, $20, $81, $1c, $81, $18, $81, $14, $81, $10, $81, $0e
+        .byte $80, $0c, $80, $0a, $80, $08, $80, $06, $80, $05, $80, $04
+        .byte 0
+.assert "effect data fits one index byte", * - fx_data < 256, true
+
+// Frequency tables, notes 0-95: f = 440 * 2^((n - 57) / 12) Hz and
+// register = f * 2^24 / clock (arithmetic, rounded; the top notes clamp at
+// $FFFF on PAL).
+freq_lo: .fill 96, <min(65535, round(440 * pow(2, (i - 57) / 12) * 16777216 / PAL_CLOCK))
+freq_hi: .fill 96, >min(65535, round(440 * pow(2, (i - 57) / 12) * 16777216 / PAL_CLOCK))
+ntsc_lo: .fill 96, <min(65535, round(440 * pow(2, (i - 57) / 12) * 16777216 / NTSC_CLOCK))
+ntsc_hi: .fill 96, >min(65535, round(440 * pow(2, (i - 57) / 12) * 16777216 / NTSC_CLOCK))