c64-kb 0.17.0

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

@@ -0,0 +1,169 @@
+// step.asm: the enemies' paths and one step for every flying enemy,
+// imported by kernel.asm. waves.c keeps the director, the spawner and the
+// path bytecode (its tables' addresses are in en_plo/en_phi). Each frame
+// en_paths counts the explosions down and, for each flying enemy whose MOVE
+// ran out, reads its path until the next MOVE (P_FIRE puts the enemy on
+// en_fire for waves.c; P_END frees it). Then en_step moves every flying
+// enemy one step. The scan and the path reads in C cost about 330 cycles an
+// enemy that needed a MOVE, and 40 more for every enemy, on the frames with
+// most enemies (PROFILE build, NTSC joystick play, VICE x64sc 3.10), where
+// sprite DMA slows every cycle.
+
+.const EN_FREE   = 0            // waves.h E_FREE
+.const EN_FLYING = 1            // waves.h E_FLYING
+.const EN_BOOM   = 2            // waves.h E_BOOM
+.const F_BOOM2   = 5            // display.h: the second explosion frame
+.const P_END     = $80          // waves.c: the path opcodes
+.const P_LOOP    = $81
+.const P_FIRE    = $82
+.const MAX_Y     = 187          // mux.asm MAX_SY: lower is off the playfield
+
+en_state: .fill NE, 0
+en_n:     .fill NE, 0           // steps left in the current MOVE
+en_dx:    .fill NE, 0           // signed half X a step
+en_dy:    .fill NE, 0           // signed lines a step
+en_timer: .fill NE, 0           // an explosion's frames left
+en_path:  .fill NE, 0           // path number
+en_pc:    .fill NE, 0           // offset of the next opcode
+en_lc:    .fill NE, 0           // loop count left
+en_plo:   .fill 6, 0            // each path's address (waves.c fills it)
+en_phi:   .fill 6, 0
+en_fire:  .fill NE, 0           // enemies whose path said FIRE this frame
+en_nf:    .byte 0
+
+en_paths:
+        lda #0
+        sta en_nf
+        ldx #0
+ep_loop:
+        lda en_state,x
+        cmp #EN_FLYING
+        bne ep_boom
+        lda en_n,x
+        bne ep_next
+        jsr en_fetch
+        jmp ep_next
+ep_boom:
+        cmp #EN_BOOM
+        bne ep_next
+        dec en_timer,x
+        lda en_timer,x
+        beq ep_free
+        cmp #8                  // half way: the second frame
+        bne ep_next
+        lda #SPR_BLOCK+F_BOOM2
+        sta act_ptr+1,x
+        jmp ep_next
+ep_free:
+        jsr en_free
+ep_next:
+        inx
+        cpx #NE
+        bne ep_loop
+        rts
+
+en_free:                        // as waves.c enemy_free
+        lda #EN_FREE
+        sta en_state,x
+        lda #OFF_Y
+        sta act_y+1,x
+        rts
+
+// Enemy X has no steps left: read opcodes until a MOVE, by waves.c's rules
+// for the bytecode. Every read is `lda path,y` with the path's address
+// patched in, y the offset.
+en_fetch:
+        ldy en_path,x
+        lda en_plo,y
+        sta ef_0+1
+        sta ef_1+1
+        sta ef_2+1
+        sta ef_3+1
+        sta ef_4+1
+        lda en_phi,y
+        sta ef_0+2
+        sta ef_1+2
+        sta ef_2+2
+        sta ef_3+2
+        sta ef_4+2
+ef_loop:
+        ldy en_pc,x
+ef_0:   lda $ffff,y
+        cmp #P_END
+        beq en_free
+        cmp #P_FIRE
+        beq ef_fire
+        cmp #P_LOOP
+        beq ef_rep
+        sta en_n,x              // MOVE n, dx, dy
+        iny
+ef_1:   lda $ffff,y
+        sta en_dx,x
+        iny
+ef_2:   lda $ffff,y
+        sta en_dy,x
+        iny
+        tya
+        sta en_pc,x
+        lda en_n,x              // a MOVE of 0 steps: read on
+        beq ef_loop
+        rts
+ef_fire:
+        ldy en_nf
+        txa
+        sta en_fire,y
+        inc en_nf
+        inc en_pc,x
+        jmp ef_loop
+ef_rep:                         // LOOP count, target
+        lda en_lc,x
+        bne !+
+        iny
+ef_3:   lda $ffff,y
+        dey
+        sta en_lc,x
+!:      dec en_lc,x
+        beq ef_out
+        iny
+        iny
+ef_4:   lda $ffff,y             // back to the target
+        sta en_pc,x
+        jmp ef_loop
+ef_out:
+        tya                     // done: past the LOOP
+        clc
+        adc #3
+        sta en_pc,x
+        jmp ef_loop
+
+en_step:
+        ldx #0
+es_loop:
+        lda en_state,x
+        cmp #EN_FLYING
+        bne es_next
+        dec en_n,x
+        lda act_hx+1,x
+        clc
+        adc en_dx,x
+        sta act_hx+1,x
+        cmp #4                  // off the sides: below 4 or above 170 (a
+        bcc es_free             // step left past 0 wraps high)
+        cmp #171
+        bcs es_free
+        lda act_y+1,x
+        clc
+        adc en_dy,x
+        sta act_y+1,x
+        cmp #MAX_Y+1
+        bcc es_next
+es_free:
+        lda #EN_FREE            // left the screen: no score
+        sta en_state,x
+        lda #OFF_Y
+        sta act_y+1,x
+es_next:
+        inx
+        cpx #NE
+        bne es_loop
+        rts

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

@@ -0,0 +1,195 @@
+// waves.c: attack waves triggered by scroll distance, after c64-kb's
+// oscar64/wave-director recipe (techniques wave_director, object_pool).
+// A list of wave records sorted by map row is read through a cursor; each
+// names a path, an enemy type, a count, a spawn spacing in frames and a
+// formation (first half X and step). Enemies live in a fixed pool of twelve.
+// Each runs a path written as bytecode: MOVE n steps of (dx, dy), LOOP, END.
+// Because the waves wait for the scroll, not a frame count, a level that
+// stops or slows keeps its waves where the map put them.
+#include "waves.h"
+#include "display.h"
+#include "level.h"
+
+static char e_type[NE];
+// Running the paths and the step are step.asm's (en_paths, en_step); its
+// tables hold each enemy's path state, step and explosion timer.
+#define e_n  ((char *)ASM_EN_N)
+#define e_dx ((signed char *)ASM_EN_DX)
+#define e_dy ((signed char *)ASM_EN_DY)
+#define e_timer ((char *)ASM_EN_TIMER)          // an explosion's frames left
+#define e_path  ((char *)ASM_EN_PATH)
+#define e_pc    ((char *)ASM_EN_PC)
+#define e_lc    ((char *)ASM_EN_LC)
+char waves_started;
+char kills_by_type[3];
+
+// ---- paths -----------------------------------------------------------------
+// A byte below $80 is MOVE: that many steps of signed dx (half X) and dy
+// (lines). P_LOOP count, target jumps back count - 1 times. P_FIRE fires a
+// bullet at the ship (on_enemy_fire; only from sprite Y 72 to 140). P_END
+// frees the enemy. Nothing else takes a frame. step.asm runs the bytecode
+// (en_fetch) and holds the same three values.
+#define P_END  0x80
+#define P_LOOP 0x81
+#define P_FIRE 0x82
+#define S(n) ((char)(signed char)(n))
+
+static const char path_dive[]   = { 16, 0, 3,  P_FIRE,  111, 0, 3, P_END };   // fires at Y 72
+static const char path_weave[]  = { 8, 1, 2,  16, S(-1), 2,  8, 1, 2,   // one sway, 32 steps
+                                    P_FIRE,                             // Y 88, then 152 (too low)
+                                    P_LOOP, 3, 0,
+                                    127, 0, 3, P_END };
+static const char path_swoop[]  = { 16, 0, 3,  P_FIRE,  10, 1, 2,  12, 2, 1,  80, 2, 0, P_END };
+static const char path_swoopl[] = { 16, 0, 3,  P_FIRE,  10, S(-1), 2,  12, S(-2), 1,  80, S(-2), 0, P_END };
+// The parade: down to a row, hold there, then dive. Row A stops at Y 72, row
+// B at Y 102: 30 lines apart, so the multiplexer can reuse all five slots.
+static const char path_parade_a[] = { 16, 0, 3,  127, 0, 0,  60, 0, 0,  127, 0, 3, P_END };
+static const char path_parade_b[] = { 26, 0, 3,  127, 0, 0,  50, 0, 0,  127, 0, 3, P_END };
+
+enum { PA_DIVE, PA_WEAVE, PA_SWOOP, PA_SWOOPL, PA_PARADE_A, PA_PARADE_B };
+static const char * const paths[6] = {
+    path_dive, path_weave, path_swoop, path_swoopl, path_parade_a, path_parade_b
+};
+
+// ---- enemy types -----------------------------------------------------------
+enum { T_DART, T_SAUCER, T_BUG };
+static const char type_frame[3]  = { F_DART, F_SAUCER, F_BUG };
+static const char type_colour[3] = { VCOL_RED, VCOL_CYAN, VCOL_PURPLE };
+static const char type_points[3] = { 5, 10, 15 };      // tens of points
+
+// ---- the wave list, sorted by map row ------------------------------------------
+// Row: the map row (cur_pos modulo LEVEL_ROWS) that starts the wave.
+// Spawn line Y_ENTRY is in the top border; enemy k appears at hx0 + k * step.
+#define Y_ENTRY 24
+struct Wave { char row, path, type, count, spacing, hx0; signed char step; };
+#define NWAVES 11
+static const struct Wave wave[NWAVES] = {
+    {  1, PA_DIVE,     T_DART,   5,  8,  40,  20 },
+    {  6, PA_WEAVE,    T_SAUCER, 5, 10,  86,   0 },
+    { 20, PA_PARADE_A, T_BUG,    5,  2,  30,  24 },
+    { 22, PA_PARADE_B, T_BUG,    5,  2,  30,  24 },
+    { 32, PA_SWOOP,    T_DART,   4,  6,  30,   6 },
+    { 40, PA_SWOOPL,   T_DART,   5,  6, 140,  -6 },
+    { 48, PA_WEAVE,    T_SAUCER, 6,  8,  50,   0 },
+    { 56, PA_DIVE,     T_DART,   6,  4,  30,  24 },
+    { 64, PA_SWOOP,    T_BUG,    5,  8,  30,   8 },
+    { 72, PA_WEAVE,    T_SAUCER, 6,  8, 120,   0 },
+    { 84, PA_DIVE,     T_DART,   6,  6, 150, -22 },
+};
+
+static char cursor, loop, last_row;
+static const struct Wave *sp_w;               // the one active spawner: its wave,
+static char sp_left, sp_timer, sp_hx;         // enemies to come, frames to the next, its X
+
+static void enemy_free(char e)
+{
+    e_state[e] = E_FREE;
+    e_y[e] = OFF_Y;
+}
+
+void waves_reset(void)
+{
+    for (char i = 0; i < 6; i++) {             // where step.asm reads each path
+        ((char *)ASM_EN_PLO)[i] = (unsigned)paths[i] & 0xff;
+        ((char *)ASM_EN_PHI)[i] = (unsigned)paths[i] >> 8;
+    }
+    for (char e = 0; e < NE; e++)
+        enemy_free(e);
+    cursor = loop = last_row = 0;
+    sp_left = 0;
+    waves_started = 0;
+    kills_by_type[0] = kills_by_type[1] = kills_by_type[2] = 0;
+}
+
+unsigned waves_due(unsigned pos)
+{
+    unsigned n = 0;
+    for (char w = 0; w < NWAVES; w++)
+        if (wave[w].row <= pos)
+            n++;
+    return n;
+}
+
+// One enemy of wave wv at half X hx. The spawner works through a pointer
+// and adds the formation step to X, where it indexed the wave table and
+// multiplied: a spawn frame is often a heavy one.
+static void spawn(const struct Wave *wv, char hx)
+{
+    for (char e = 0; e < NE; e++) {
+        if (e_state[e] == E_FREE) {
+            char t = wv->type;
+            e_state[e] = E_FLYING;
+            e_hx[e] = hx;
+            e_y[e] = Y_ENTRY;
+            e_path[e] = wv->path;
+            e_pc[e] = e_n[e] = e_lc[e] = 0;
+            e_type[e] = t;
+            e_ptr[e] = SPR_BLOCK + type_frame[t];
+            e_colour[e] = type_colour[t];
+            return;
+        }
+    }                                           // pool full: this one is dropped
+}
+
+// Start every wave whose row the scroll has reached: >= and not ==, so a
+// scroll that moves more than one row a frame cannot skip one.
+static void director(char row)
+{
+    if (row < last_row) {                       // the level looped
+        cursor = 0;
+        loop++;
+    }
+    last_row = row;
+    while (cursor < NWAVES && row >= wave[cursor].row) {
+        sp_w = wave + cursor;
+        sp_left = sp_w->count;
+        sp_hx = sp_w->hx0;
+        sp_timer = 0;
+        waves_started++;
+        cursor++;
+    }
+}
+
+static void spawner(void)
+{
+    if (sp_left == 0)
+        return;
+    if (sp_timer) {
+        sp_timer--;
+        return;
+    }
+    const struct Wave *wv = sp_w;
+    spawn(wv, sp_hx);
+    sp_hx += wv->step;
+    sp_left--;
+    char gap = wv->spacing;
+    if (loop)                                   // later loops: closer together
+        gap >>= loop > 2 ? 2 : loop;
+    sp_timer = gap ? gap - 1 : 0;
+}
+
+void enemy_explode(char e)
+{
+    e_state[e] = E_BOOM;
+    e_timer[e] = 16;
+    e_ptr[e] = SPR_BLOCK + F_BOOM1;
+    e_colour[e] = VCOL_YELLOW;
+}
+
+char enemy_points(char e)
+{
+    char t = e_type[e];
+    kills_by_type[t]++;
+    return type_points[t];
+}
+
+void waves_update(char row)
+{
+    director(row);
+    spawner();
+    __asm { jsr ASM_EN_PATHS }                  // explosions, and new MOVEs from the paths
+    char n = K_BYTE(ASM_EN_NF);
+    for (char k = 0; k < n; k++)
+        on_enemy_fire(((char *)ASM_EN_FIRE)[k]);
+    __asm { jsr ASM_EN_STEP }                   // every flying enemy: one step, or off
+}

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

@@ -0,0 +1,33 @@
+// waves.h: enemies in a fixed pool, attack waves keyed to scroll distance,
+// and the path bytecode each enemy runs (wave_director, object_pool).
+#ifndef WAVES_H
+#define WAVES_H
+
+#include "game.h"
+
+#define NE 12                   // enemy slots: actors 1-12 of the multiplexer
+
+enum { E_FREE, E_FLYING, E_BOOM };
+
+#define e_state ((char *)ASM_EN_STATE)  // E_*; step.asm reads it
+
+// An enemy's position, sprite and colour live in the multiplexer's actor
+// table, as actor e + 1: the kernel sorts them where waves.c writes them,
+// with no copy. A free enemy's Y is OFF_Y, which the multiplexer skips.
+#define e_hx     (ACT_HX + 1)   // half X
+#define e_y      (ACT_Y + 1)    // sprite Y
+#define e_ptr    (ACT_PTR + 1)  // sprite block: SPR_BLOCK + frame (display.h F_*)
+#define e_colour (ACT_COL + 1)
+extern char waves_started;      // triggers since waves_reset (for the verdict)
+extern char kills_by_type[3];   // enemies shot, by type: dart, saucer, bug
+
+void waves_reset(void);
+void waves_update(char row);           // map row now showing: director, spawner, paths, explosions
+void enemy_explode(char e);            // shot or rammed: explode, then free
+char enemy_points(char e);             // score, in tens of points
+unsigned waves_due(unsigned pos);      // wave records whose position pos has reached
+void on_enemy_fire(char e);            // a path said FIRE; main.c decides what that does
+
+#pragma compile("waves.c")
+
+#endif

package/templates/shmup-vertical/stage-expect.json

@@ -0,0 +1,6 @@
+{
+  "checks": [
+    { "name": "staged run's own verdict: no overrun, every bullet cell restored", "type": "verdict" },
+    { "name": "frame meter, play frames 150-399 of the staged run", "type": "meter", "row": 13, "col": 10, "frames": 250 }
+  ]
+}

package/templates/shmup-vertical/tools/drive.py

@@ -0,0 +1,152 @@
+#!/usr/bin/env python3
+"""drive.py PRG STEP...: play the `make joy` build headless over VICE's binary monitor.
+
+    python3 tools/drive.py build/shmup-vertical-joy.prg "until:PUSH FIRE" tap:fire \
+        "until:SCORE" hold:fire "until:GAME OVER" "until:PUSH FIRE" print
+
+Taken from templates/platformer/tools/drive.py; only the screens it reads
+differ: this game's text is on the two playfield screens ($8000, $8400,
+rows 0-20) and the panel ($8800, rows 21-23). The joy build reads its port
+byte from $02FE (JOY_SOURCE) instead of $DC00, because the windowless
+VICE's joyport commands never reach $DC00. Steps:
+  hold:DIR     hold up, down, left, right or fire (DIR+DIR for two); hold:none releases
+  tap:DIR      press for 0.05 s of run time, then release for 0.1 s
+  run:SECONDS  let the machine run (warp) that long in real time
+  until:TEXT   run until TEXT is on a playfield screen or the panel (300 s limit)
+  peek:ADDR    print the byte at hex ADDR (ADDR,ADDR for several)
+  print        print the panel's rows and the non-blank text rows of the screen on display
+The machine is left with the monitor's quit command, so the drive's writes reach the .d64.
+Set DRIVE_DISK to a .d64 to attach it as drive 8, DRIVE_MODEL=ntsc for a 6567R8.
+The monitor port is DRIVE_PORT, or a free one picked for each machine (an
+earlier version always took 6581, so two drives collided). Exit 1 when an
+until: step times out.
+"""
+import os
+import socket
+import struct
+import subprocess
+import sys
+import time
+
+X64SC = os.environ.get("X64SC", os.path.expanduser("~/Developer/c64/vice-headless/bin/x64sc"))
+
+
+def free_port():
+    """A port nothing listens on now, so two drives at once do not collide."""
+    with socket.socket() as s:
+        s.bind(("127.0.0.1", 0))
+        return s.getsockname()[1]
+
+
+SCREENS = (0x8000, 0x8400)                            # src/game.h PF0, PF1
+PANEL = 0x8800
+BITS = {"none": 0, "up": 1, "down": 2, "left": 4, "right": 8, "fire": 16}
+
+
+def text(c):
+    c &= 0x7f
+    return chr(c + 64) if 1 <= c <= 26 else (chr(c) if 32 <= c < 64 else "~")
+
+
+class Vice:
+    def __init__(self, prg, disk=None, model=None):
+        """disk and model default to DRIVE_DISK and DRIVE_MODEL (pal or ntsc)."""
+        disk = disk or os.environ.get("DRIVE_DISK")
+        model = model or os.environ.get("DRIVE_MODEL", "pal")
+        port = int(os.environ.get("DRIVE_PORT") or free_port())
+        self.proc = subprocess.Popen(
+            [X64SC, "-default", "-warp"] + (["-model", "ntsc"] if model == "ntsc" else [])
+            + ["+sound", "-autostartprgmode", "1", "-binarymonitor",
+             "-binarymonitoraddress", f"ip4://127.0.0.1:{port}"]
+            + (["-8", disk] if disk else []) + ["-autostart", prg],
+            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        for _ in range(100):
+            try:
+                self.sock = socket.create_connection(("127.0.0.1", port))
+                break
+            except OSError:
+                time.sleep(0.1)
+        else:
+            sys.exit("drive: no monitor")
+        self.rid = 0
+
+    def _read(self, n):
+        b = b""
+        while len(b) < n:
+            b += self.sock.recv(n - len(b)) or sys.exit("drive: monitor closed")
+        return b
+
+    def cmd(self, code, body=b""):
+        """One binary-monitor command (it stops the machine); returns the reply's body."""
+        self.rid += 1
+        self.sock.sendall(struct.pack("<BBIIB", 2, 2, len(body), self.rid, code) + body)
+        while True:
+            _, _, n, _, _, rid = struct.unpack("<BBIBBI", self._read(12))
+            data = self._read(n)
+            if rid == self.rid:
+                return data
+
+    def mem(self, start, n):
+        return self.cmd(0x01, struct.pack("<BHHBH", 0, start, start + n - 1, 0, 0))[2:]
+
+    def joy(self, bits):                                  # active low, as $DC00 reads
+        self.cmd(0x02, struct.pack("<BHHBH", 0, 0x02fe, 0x02fe, 0, 0) + bytes([0xff & ~bits]))
+
+    def run(self, seconds):
+        self.cmd(0xaa)                                    # exit the monitor: the machine runs
+        time.sleep(seconds)
+
+    def rows(self):
+        """Panel rows 21-23 and rows 0-20 of both playfield screens, as text."""
+        out = []
+        for base in SCREENS:
+            d = self.mem(base, 21 * 40)
+            out += ["".join(text(c) for c in d[r * 40:r * 40 + 40]) for r in range(21)]
+        d = self.mem(PANEL + 21 * 40, 3 * 40)
+        out += ["".join(text(c) for c in d[r * 40:r * 40 + 40]) for r in range(3)]
+        return out
+
+    def quit(self):
+        try:
+            self.cmd(0xbb)                                # quit: VICE flushes the disk image
+            self.proc.wait(10)
+        except Exception:
+            self.proc.kill()
+
+
+def main():
+    vice = Vice(sys.argv[1])
+    try:
+        vice.joy(0)
+        for step in sys.argv[2:]:
+            name, _, arg = step.partition(":")
+            if name in ("hold", "tap"):
+                vice.joy(sum(BITS[d] for d in arg.split("+")))
+                if name == "tap":
+                    vice.run(0.05)
+                    vice.joy(0)
+                    vice.run(0.1)
+            elif name == "run":
+                vice.run(float(arg))
+            elif name == "until":
+                t0 = time.time()
+                while not any(arg in row for row in vice.rows()):
+                    if time.time() - t0 > 300:
+                        sys.exit(f"drive: '{arg}' never appeared")
+                    vice.run(0.1)
+                print(f"drive: '{arg}' on screen")
+            elif name == "peek":
+                for a in arg.split(","):
+                    print(f"peek {a}: {vice.mem(int(a, 16), 1)[0]}")
+            elif name == "print":
+                rows = vice.rows()
+                front = 1 if vice.mem(0x0881, 1)[0] == 0x1e else 0   # kernel.asm pf_d018
+                for row in rows[front * 21:front * 21 + 21] + rows[42:]:
+                    if row.strip("~ "):
+                        print("|" + row + "|")
+    finally:
+        vice.quit()
+
+
+if __name__ == "__main__":
+    main()