c64-kb 0.17.0

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

@@ -0,0 +1,180 @@
+// hit.asm: the enemies' boxes against the ship's and the bolts', imported by
+// kernel.asm (technique per_frame_hitbox). hitbox.c writes the ship's and
+// the bolts' boxes (hb_*, slot 0 the ship, 1-4 the bolts) where they are
+// drawn; hit_scan reads each enemy from the multiplexer's actor table
+// (actors 1-12: what the display showed), takes its box from its sprite
+// frame (fb_*: an explosion's frame has none, a free enemy's Y is $FF), and
+// tests it against every box still on. A hit is put on the list hit_e /
+// hit_a (enemy, box slot) and that box goes off, so a bolt kills one enemy
+// and the ship is lost once a frame. In C this scan cost 2,700-3,100 cycles
+// on the staged heaviest frame (PROFILE build, VICE x64sc 3.10).
+//
+// Boxes are in half X and raster lines: four one-byte compares, no $D010.
+// An enemy whose lines miss the lines of every box that is on is passed
+// over before its X is worked out, and the boxes that are off are left out
+// of the list each enemy walks: with twelve enemies flying this scan is
+// much of the frame on NTSC.
+
+.const HB_N      = 5            // hitbox.h: BOX_ENEMY
+.const NE        = 12           // waves.h NE: actors 1-12
+.const SPR_BLOCK = 128          // game.h
+
+// Each sprite frame's box (display.h F_*): offset and size from the
+// sprite's first pixel pair and first line. w = 0: no box.
+fb_x:   .byte 3, 3, 1, 2, 0, 0
+fb_y:   .byte 4, 2, 1, 2, 0, 0
+fb_w:   .byte 6, 6, 10, 8, 0, 0    // the ship: its hull only
+fb_h:   .byte 10, 8, 7, 9, 0, 0
+
+hb_on:  .fill HB_N, 0
+hb_l:   .fill HB_N, 0
+hb_r:   .fill HB_N, 0               // exclusive
+hb_t:   .fill HB_N, 0
+hb_b:   .fill HB_N, 0               // exclusive
+
+hit_n:  .byte 0
+hit_e:  .fill NE, 0
+hit_a:  .fill NE, 0
+
+hs_e:   .byte 0
+hs_t:   .byte 0
+hs_b:   .byte 0
+hs_l:   .byte 0
+hs_r:   .byte 0
+hs_lo:  .byte 0
+hs_hi:  .byte 0
+hs_nl:  .byte 0
+hs_list: .fill HB_N, 0              // the slots on this frame, slot 0 last
+
+// The enemies' dots against the ship's box (slot 0): dot_hit = the first
+// dot inside it, or $FF. A dot is one pixel pair wide and two lines tall.
+// The same test in C cost about 25 cycles a dot more.
+dot_hit: .byte $ff
+
+dot_scan:
+        lda #$ff
+        sta dot_hit
+        lda hb_on
+        beq ds_done
+        ldx #0
+ds_loop:
+        lda eb_live,x
+        beq ds_next
+        lda eb_line,x           // y < b
+        cmp hb_b
+        bcs ds_next
+        adc #2                  // t < y + 2 (carry clear here)
+        cmp hb_t
+        beq ds_next
+        bcc ds_next
+        lda eb_hx,x             // x < r
+        cmp hb_r
+        bcs ds_next
+        adc #1                  // l < x + 1
+        cmp hb_l
+        beq ds_next
+        bcc ds_next
+        stx dot_hit
+        rts
+ds_next:
+        inx
+        cpx #NEB
+        bne ds_loop
+ds_done:
+        rts
+
+hit_scan:
+        lda #0
+        sta hit_n
+        lda #$ff                    // the lines any box that is on covers:
+        sta hs_lo                   // hs_lo to hs_hi (exclusive); and the
+        lda #0                      // boxes that are on, slot 0 last
+        sta hs_hi
+        ldx #0
+        ldy #HB_N-1
+hs_rng: lda hb_on,y
+        beq hs_rn
+        tya
+        sta hs_list,x
+        inx
+        lda hb_t,y
+        cmp hs_lo
+        bcs !+
+        sta hs_lo
+!:      lda hb_b,y
+        cmp hs_hi
+        bcc hs_rn
+        sta hs_hi
+hs_rn:  dey
+        bpl hs_rng
+        stx hs_nl
+        txa
+        bne !+
+        rts                         // no box is on
+!:      ldx #1                      // actor 1 = enemy 0
+        bne hs_loop
+hs_skip:
+        jmp hs_next
+hs_loop:
+        lda act_y,x
+        cmp #OFF_Y
+        beq hs_skip
+        ldy act_ptr,x
+        lda fb_w-SPR_BLOCK,y
+        beq hs_skip                 // an explosion: no box
+        lda act_y,x
+        sec                         // + 1: a sprite at Y starts on line Y + 1
+        adc fb_y-SPR_BLOCK,y
+        cmp hs_hi                   // below every box: next enemy
+        bcs hs_skip
+        sta hs_t
+        clc
+        adc fb_h-SPR_BLOCK,y
+        cmp hs_lo                   // above every box
+        bcc hs_skip
+        beq hs_skip
+        sta hs_b
+        lda act_hx,x
+        clc
+        adc fb_x-SPR_BLOCK,y
+        sta hs_l
+        clc
+        adc fb_w-SPR_BLOCK,y
+        sta hs_r
+        stx hs_e
+        ldx hs_nl                   // the boxes that were on, the ship first
+hs_box: dex
+        bmi hs_done
+        ldy hs_list,x
+        lda hs_t                    // t < hb_b
+        cmp hb_b,y
+        bcs hs_box
+        lda hb_t,y                  // hb_t < b
+        cmp hs_b
+        bcs hs_box
+        lda hs_l                    // l < hb_r
+        cmp hb_r,y
+        bcs hs_box
+        lda hb_l,y                  // hb_l < r
+        cmp hs_r
+        bcs hs_box
+        lda hb_on,y                 // spent by an earlier enemy this frame
+        beq hs_box
+        lda #0                      // a hit: the box is spent
+        sta hb_on,y
+        tya
+        ldy hit_n
+        sta hit_a,y
+        lda hs_e
+        sec
+        sbc #1
+        sta hit_e,y
+        inc hit_n
+hs_done:
+        ldx hs_e
+hs_next:
+        inx
+        cpx #NE+1
+        beq !+
+        jmp hs_loop
+!:      rts

package/templates/shmup-vertical/src/hitbox.c

@@ -0,0 +1,59 @@
+// hitbox.c: boxes from the animation frame, pairs from group bits, after
+// c64-kb's oscar64/per-frame-hitbox recipe. Every box is in half X (one byte
+// across the whole screen, 2-pixel precision) and raster lines, so the test
+// is four one-byte compares and $D010 never enters it.
+//
+// The ship's box is emitted where it is drawn (actors_draw), the bolts' by
+// glyph.asm's bb_run, into hit.asm's tables. An enemy's box comes from the
+// multiplexer's actor table, which is what the display showed this frame,
+// and its sprite frame's box (hit.asm fb_*): an explosion's frame has none.
+// Enemies are tested only against the groups they can hurt (the ship and
+// the bolts), never against each other; the enemies' dots only against the
+// ship. hit.asm's dot_scan and hit_scan do the tests; this file turns their
+// hits into events.
+#include "hitbox.h"
+#include "display.h"
+#include "waves.h"
+#include "bullets.h"
+
+#define hb_on ((char *)ASM_HB_ON)
+#define hb_l  ((char *)ASM_HB_L)
+#define hb_r  ((char *)ASM_HB_R)
+#define hb_t  ((char *)ASM_HB_T)
+#define hb_b  ((char *)ASM_HB_B)
+#define fb_x  ((const char *)ASM_FB_X)
+#define fb_y  ((const char *)ASM_FB_Y)
+#define fb_w  ((const char *)ASM_FB_W)
+#define fb_h  ((const char *)ASM_FB_H)
+
+void box_off(char slot)
+{
+    hb_on[slot] = 0;
+}
+
+void box_ship(char hx, char sy)
+{
+    char l = hx + fb_x[F_SHIP], t = sy + 1 + fb_y[F_SHIP];
+    hb_l[BOX_PLAYER] = l;
+    hb_r[BOX_PLAYER] = l + fb_w[F_SHIP];
+    hb_t[BOX_PLAYER] = t;
+    hb_b[BOX_PLAYER] = t + fb_h[F_SHIP];
+    hb_on[BOX_PLAYER] = 1;
+}
+
+void collide(void)
+{
+    __asm { jsr ASM_DOT_SCAN }                  // the enemies' dots against the ship
+    char j = K_BYTE(ASM_DOT_HIT);
+    if (j != 0xff)
+        on_ship_shot(j);                        // its box goes off before the enemies' test
+    __asm { jsr ASM_HIT_SCAN }
+    char n = K_BYTE(ASM_HIT_N);
+    for (char k = 0; k < n; k++) {
+        char e = ((char *)ASM_HIT_E)[k], a = ((char *)ASM_HIT_A)[k];
+        if (a == BOX_PLAYER)
+            on_player_hit(e);
+        else
+            on_enemy_shot(e, a - BOX_SHOT);
+    }
+}

package/templates/shmup-vertical/src/hitbox.h

@@ -0,0 +1,25 @@
+// hitbox.h: collision boxes per animation frame, tested only for the pairs
+// that can hurt each other (per_frame_hitbox).
+#ifndef HITBOX_H
+#define HITBOX_H
+
+#include "game.h"
+
+// Boxes that enemies can hit: the ship, then the bullets.
+#define BOX_PLAYER 0
+#define BOX_SHOT   1            // 1-4, bullets 0-3
+#define BOX_ENEMY  5            // the count of the above
+
+void box_off(char slot);
+void box_ship(char hx, char sy);        // where the ship is drawn
+void collide(void);                     // enemy bullets against the ship, then enemies
+                                        // from the actor table against these
+
+// What collide() reports; main.c decides what a hit does.
+void on_enemy_shot(char e, char bullet);
+void on_player_hit(char e);            // enemy e rammed the ship
+void on_ship_shot(char j);             // enemy bullet j hit the ship
+
+#pragma compile("hitbox.c")
+
+#endif

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

@@ -0,0 +1,330 @@
+// kernel.asm: the display and sound kernel of shmup-vertical. The harness
+// assembles it (with mux.asm and sound.asm) to build/asm.bin, a raw blob
+// from $0880, and writes build/asm.h so C can reach every label below as
+// ASM_<LABEL>. C places the blob with #pragma region and calls it with jsr.
+//
+// It owns the raster IRQ. One chain runs every frame:
+//
+//   line 252  frame IRQ   playfield $D011/$D018/$D016/$D021, first eight
+//                         sprites, frame_flag = 1 for the C main loop
+//   zones     zone IRQs   reuse the eight sprites further down (mux.asm)
+//   line 212  split IRQ   the panel: $D011, $D018, $D016 from line 214's
+//                         right border, $D021 after the panel's badline;
+//                         sprites off; then the music (sound.asm)
+//
+// The split is c64-kb's kickassembler/scroll-panel-split recipe (technique
+// scroll_panel_split): the panel starts on line 215 with YSCROLL 7, and the
+// wait before the writes comes from a table indexed by the playfield's
+// YSCROLL, short at YSCROLL 6, where line 214 is a badline. The playfield
+// here is multicolour and 40 columns; the delays are the recipe's. Changed:
+// $D016 is written last, not first (see split_stores), and the split has
+// its own vector entry (see arm_split).
+//
+// Nothing here uses zero page: Oscar64 owns $02-$52. KERNAL and BASIC are
+// banked out ($01 = $35), so the vectors are $FFFE and $FFFA.
+//
+// Frame meter: CIA2 timer B adds up the time of every IRQ that does not land
+// inside the C main loop's own bracket (mtr_open = 0); an IRQ inside it is
+// already in that bracket's wall time. The frame IRQ hands the sum of the
+// frame that just ended to C (irq_cyc, irq_cnt start/stop pairs). C sets
+// mtr_open to 1 for good in a build without the meter. The split IRQ starts
+// timer B only after its panel writes, so its timing stays the recipe's;
+// split_prev tells C to add those first cycles (a constant it measured).
+
+.const PF_A       = $8000     // playfield screen 0 (VIC bank 2, $8000-$BFFF)
+.const PF_B       = $8400     // playfield screen 1
+.const PANEL      = $8800     // panel screen
+.const PTRS_A     = PF_A + $3f8
+.const PTRS_B     = PF_B + $3f8
+.const PF_D016    = $d8       // multicolour, 40 columns, XSCROLL 0
+.const PANEL_D016 = $c8       // hires, 40 columns
+.const PANEL_D011 = $1f       // DEN, RSEL = 1, YSCROLL 7: panel badlines 215, 223, ...
+.const PANEL_D018 = $2e       // screen $8800, characters $B800
+.const PANEL_BG   = 11        // dark grey
+.const LAST_PF    = 214       // last playfield line at every YSCROLL
+.const SPLIT_LINE = 212       // split IRQ fires here and polls for LAST_PF
+.const BOTTOM     = 252       // frame IRQ, below the panel
+
+* = $0880 "kernel"
+
+// ---- shared with C --------------------------------------------------------
+pf_d011:    .byte $13         // $D011 for the next frame: DEN, 24 rows, YSCROLL
+pf_d018:    .byte $0e         // $D018 for the next frame: which playfield screen
+pf_bg:      .byte 6           // $D021 for the playfield
+frame_flag: .byte 0           // the frame IRQ sets 1; the main loop clears it
+frame_cnt:  .byte 0           // frame IRQs taken (wraps)
+cur_y:      .byte 0           // the YSCROLL the frame IRQ applied
+mtr_open:   .byte 1           // 1: IRQs do not time themselves
+mtr_on:     .byte 0           // 1: a meter build (C sets it once)
+irq_own:    .byte 1
+irq_n:      .byte 0           // start/stop pairs of timer B this frame
+irq_cnt:    .byte 0           // ... of the frame that just ended
+irq_cyc:    .word 0           // timer B count of the frame that just ended
+irq_cal:    .byte 0           // timer B count of one empty start/stop pair
+save_a:     .byte 0
+save_x:     .byte 0
+save_y:     .byte 0
+next_hnd:   .word bottom_body
+count:      .byte 0
+
+// Called once from C with interrupts off. A = 0 PAL, 1 NTSC.
+kernel_init:
+        jsr music_init
+        lda #$7f
+        sta $dc0d               // no CIA interrupts
+        sta $dd0d
+        lda $dc0d
+        lda $dd0d
+        lda #$35                // KERNAL and BASIC out, I/O in
+        sta $01
+        lda #<irq_entry
+        sta $fffe
+        lda #>irq_entry
+        sta $ffff
+        lda #<nmi
+        sta $fffa
+        lda #>nmi
+        sta $fffb
+        lda #$ff                // timer B: latch $FFFF, loaded, stopped
+        sta $dd06
+        sta $dd07
+        lda #$10
+        sta $dd0f
+        lda #$01                // one empty start/stop pair, for irq_cal
+        sta $dd0f
+        lda #$00
+        sta $dd0f
+        lda #$ff
+        sec
+        sbc $dd06
+        sta irq_cal
+        lda #$10
+        sta $dd0f
+        lda #<bottom_body
+        sta next_hnd
+        lda #>bottom_body
+        sta next_hnd+1
+        lda #BOTTOM
+        sta $d012
+        lda pf_d011             // bit 7 clear: the compare line is below 256
+        sta $d011
+        lda #$01
+        sta $d01a
+        sta $d019
+        rts
+
+// ---- IRQ entry and exit ---------------------------------------------------
+irq_entry:
+        sta save_a
+        lda mtr_open            // inside the main loop's bracket: already timed
+        sta irq_own
+        bne !+
+        lda #$01
+        sta $dd0f               // timer B resumes from its count
+        inc irq_n
+!:      stx save_x
+        sty save_y
+        cld
+dispatch:
+        jmp (next_hnd)
+
+irq_exit:
+        lda irq_own
+        bne !+
+        lda #$00
+        sta $dd0f
+!:      ldy save_y
+        ldx save_x
+        lda save_a
+nmi:    rti
+
+// ---- frame IRQ, line 252 --------------------------------------------------
+bottom_body:
+        lda mtr_on              // a build without the meter skips the hand-over
+        beq bb_regs             // (60 cycles a frame)
+        lda #$00                // the frame ends here: hand its IRQ time to C
+        sta $dd0f
+        lda #$ff
+        sec
+        sbc $dd06
+        sta irq_cyc
+        lda #$ff
+        sbc $dd07
+        sta irq_cyc+1
+        lda irq_n
+        sta irq_cnt
+        lda split_self
+        sta split_prev
+        lda #0
+        sta split_self
+        lda #$10
+        sta $dd0f               // reload $FFFF, stopped
+        lda #0
+        sta irq_n
+        lda irq_own
+        bne !+
+        lda #$01                // the rest of this IRQ counts in the new frame
+        sta $dd0f
+        inc irq_n
+!:
+bb_regs:
+        lda pf_d011
+        sta $d011
+        and #7
+        sta cur_y
+        lda pf_d018
+        sta $d018
+        lda #PF_D016            // whole-register store: MCM and CSEL set on purpose
+        sta $d016
+        lda pf_bg
+        sta $d021
+        jsr mux_frame
+        lda #1
+        sta frame_flag
+        inc frame_cnt
+        ldx zidx
+        cpx zlast
+        beq no_zones
+        lda #<zone_body
+        sta next_hnd
+        lda #>zone_body
+        sta next_hnd+1
+        lda zline,x
+        jmp arm
+no_zones:
+        jsr arm_split
+        jmp on_time
+arm:    sta $d012               // next frame's lines: no late check across the wrap
+        jmp on_time
+
+// The split has its own vector entry, so the poll starts early in line 212
+// as in the recipe. Through irq_entry it started about 30 cycles later, and
+// at YSCROLL 5 on PAL (line 213 a badline) the panel's writes then landed in
+// line 215 in 4 frames of every 12, following the music's cost: the panel's
+// first row showed playfield characters (measured in VICE, then fixed so).
+arm_split:
+        lda #<split_irq
+        sta $fffe
+        lda #>split_irq
+        sta $ffff
+        lda #SPLIT_LINE
+        sta $d012
+        rts
+
+// ---- split IRQ, line 212 --------------------------------------------------
+// Poll for line 214, wait delay_tbl[YSCROLL] passes, switch to the panel.
+split_irq:
+        sta save_a              // 12 cycles, like the recipe's three pushes
+        stx save_x
+        sty save_y
+split_body:                     // a late zone jumps here, registers saved
+        ldx cur_y
+        lda delay_tbl,x
+        sta count
+        ldx #PANEL_D018         // everything loaded before the poll, so after
+        ldy #PANEL_D016         // a badline stall only the stores remain
+        lda #LAST_PF-1
+waitline:
+        cmp $d012               // until $D012 > 213: never waits a whole frame
+        bcs waitline
+        lda #PANEL_D011
+delay:  dec count               // absolute: 9 cycles a pass, 8 on the way out
+        bpl delay
+// The writes start between cycle 58 of line 214 and cycle 0 of line 215 on
+// PAL (58 to 64 on NTSC), the poll's jitter, measured under the VICE
+// monitor at every YSCROLL. In the recipe's order ($D016 first) the $D018
+// write came a cycle from too late at the far end: a run with it at cycle
+// 12 of line 215 showed playfield characters in the panel's first row.
+// $D016 last buys four cycles; it only switches multicolour off, and the
+// panel's first pixels are background in both modes.
+split_stores:
+        sta $d011               // before cycle 12 of line 215, the panel's badline
+        stx $d018               // before that badline's first screen fetch
+        sty $d016               // last: the panel's first pixels are blank either way
+        lda #LAST_PF
+waitpanel:
+        cmp $d012               // until $D012 > 214
+        bcs waitpanel
+        nop                     // reads across cycle 12 of line 215: the panel's
+        nop                     // badline holds the CPU until cycle 55 at every
+        nop                     // phase, which removes the poll jitter
+        nop
+        lda #PANEL_BG
+        sta $d021               // right border of line 215
+        lda #0
+        sta $d015               // no sprite under the panel
+        cld
+        lda split_late          // came from a late zone: its entry started timer B
+        bne !+
+        lda mtr_open            // came through the vector: time the rest, as
+        sta irq_own             // irq_entry does for every other IRQ
+        bne !+
+        lda #$01
+split_tb_on:
+        sta $dd0f
+        inc irq_n
+        inc split_self          // C adds the untimed start of this IRQ
+!:      lda #0
+        sta split_late
+        jsr music_play
+        lda #<irq_entry
+        sta $fffe
+        lda #>irq_entry
+        sta $ffff
+        lda #<bottom_body
+        sta next_hnd
+        lda #>bottom_body
+        sta next_hnd+1
+        lda #BOTTOM
+        sta $d012
+        jmp on_time
+
+split_late: .byte 0
+split_self: .byte 0             // this frame's split started timer B late ...
+split_prev: .byte 0             // ... and the frame that just ended
+
+// Delay passes per playfield YSCROLL (dec abs / bpl: 9 cycles a pass).
+delay_tbl:
+        .byte 5, 5, 5, 5, 5, 5, 0, 5
+
+// copy_rows: three playfield rows, 120 bytes from row_src to row_dst, for
+// level.c. C writes both addresses; the patch step points each of three
+// load/store pairs at one row (+0, +40, +80), and the loop moves a column of
+// three bytes a pass: 32 cycles a column, 1,280 a call, against 12.5 a byte
+// (about 1,500) for the two-byte loop it replaces (arithmetic). The idea is
+// the other #39 version's copy3.
+row_src: .word 0
+row_dst: .word 0
+copy_rows:
+        .for (var k = 0; k < 3; k++) {
+            lda row_src
+            clc
+            adc #40 * k
+            sta cr_ld + 6 * k + 1
+            lda row_src+1
+            adc #0
+            sta cr_ld + 6 * k + 2
+            lda row_dst
+            clc
+            adc #40 * k
+            sta cr_ld + 6 * k + 4
+            lda row_dst+1
+            adc #0
+            sta cr_ld + 6 * k + 5
+        }
+        ldx #39
+cr_loop:
+cr_ld:
+        .for (var k = 0; k < 3; k++) {
+            lda $ffff,x         // patched above
+            sta $ffff,x
+        }
+        dex
+        bpl cr_loop
+        rts
+
+#import "mux.asm"
+#import "sound.asm"
+#import "glyph.asm"
+#import "hit.asm"
+#import "step.asm"