c64-kb 0.17.0

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

@@ -0,0 +1,40 @@
+// display.h: the character set, sprite shapes, text and the score panel.
+#ifndef DISPLAY_H
+#define DISPLAY_H
+
+#include "game.h"
+
+// Character codes. 0-63 are the ROM's letters, digits and punctuation, copied
+// so the panel, the title and check.py read them; 64 up are this game's.
+enum {
+    G_WATER = 32,               // the ROM space: all background colour
+    G_LAND = 64, G_GRASS, G_TREE, G_ROCK, G_EDGE_L, G_EDGE_R, G_SPARKLE,
+    G_LIFE = 96,                // hires: a ship, for the panel's lives
+    G_RULE,                     // hires: the panel's top rule
+    G_DOTS = 0xc0,              // $C0-$CF: an enemy dot over open water, pair * 4 + row / 2
+    G_BOLTS = 0xd0,             // $D0-$D3: a bolt over open water, by pair
+    G_BULLET = 0xf8             // $F8-$FB: one reserved glyph per bolt ($F2-$F7 the
+};                              // dots'); $FF stays blank ($BFFF is the idle byte)
+
+// Sprite frames: block SPR_BLOCK + frame.
+enum { F_SHIP, F_DART, F_SAUCER, F_BUG, F_BOOM1, F_BOOM2, SPR_FRAMES };
+
+// Playfield colours: background, $D022 (01), $D023 (10); colour RAM (11)
+// is yellow for every playfield cell, and bullets draw in it.
+#define PF_BG_COL   VCOL_BLUE
+#define PF_MC1      VCOL_BROWN
+#define PF_MC2      VCOL_GREEN
+#define PF_CRAM     0x0f        // multicolour + yellow
+#define TEXT_CRAM   VCOL_WHITE  // below 8: a hires cell inside the playfield
+
+void display_init(void);                                // VIC bank 2, charset, sprites
+void put_text(char *screen, char row, char col, const char *s);
+void text_colour(char row, char col, char n, char colour);
+void put_dec(char *p, unsigned v, char digits);
+void panel_draw(void);                                  // the whole panel
+void panel_add(char tens);                              // score digits, after add_score (shown by panel_update)
+void panel_update(void);                                // score digits and lives, when changed
+
+#pragma compile("display.c")
+
+#endif

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

@@ -0,0 +1,85 @@
+// game.h: what every module of shmup-vertical shares. Memory map, the
+// kernel's variables (build/asm.h, generated from src/kernel.asm), and the
+// game state. Each module's own header pulls its .c in with
+// #pragma compile: Oscar64 has no object linker.
+#ifndef GAME_H
+#define GAME_H
+
+#include <c64/vic.h>
+#include <c64/cia.h>
+#include "asm.h"                // ASM_<LABEL> for every label in src/*.asm
+
+#ifndef AUTOPILOT
+#define AUTOPILOT 0
+#endif
+#ifndef FORCE_FAULT
+#define FORCE_FAULT 0
+#endif
+
+// ---- memory map ------------------------------------------------------------
+// $0801-$087F Oscar64 startup      $0880-$1FFF the kernel blob (asm)
+// $2000-$7FFF C code, data, stack  $8000-$BFFF VIC bank 2:
+//   $8000 playfield screen 0, $8400 playfield screen 1, $8800 panel screen,
+//   $8C00 meter scratch row (AUTOPILOT), $A000 sprite shapes, $B800 characters.
+// The VIC sees the character ROM at $9000-$9FFF in bank 2, so nothing it
+// shows lives there; C keeps its level map there.
+#define PF0       ((char *)0x8000)
+#define PF1       ((char *)0x8400)
+#define PANEL     ((char *)0x8800)
+#define SCRATCH   ((char *)0x8c00)
+#define SPRITES   ((char *)0xa000)
+#define CHARSET   ((char *)0xb800)
+#define COLOUR    ((char *)0xd800)
+#define LEVEL_RAM ((char *)0x9000)
+#define SPR_BLOCK 128           // $A000 / 64 inside the bank
+#define D018_PF0  0x0e          // screen $8000, characters $B800
+#define D018_PF1  0x1e          // screen $8400
+#define RESULT    (*(volatile char *)0x02ff)   // $01 pass, $02 fail
+
+// ---- the kernel's variables (src/kernel.asm, mux.asm, sound.asm) -------------
+#define K_BYTE(a) (*(volatile char *)(a))
+#define K_WORD(a) (*(volatile unsigned *)(a))
+#define K_PF_D011    K_BYTE(ASM_PF_D011)
+#define K_PF_D018    K_BYTE(ASM_PF_D018)
+#define K_PF_BG      K_BYTE(ASM_PF_BG)
+#define K_FRAME_FLAG K_BYTE(ASM_FRAME_FLAG)
+#define K_FRAME_CNT  K_BYTE(ASM_FRAME_CNT)
+#define K_MTR_OPEN   K_BYTE(ASM_MTR_OPEN)
+#define K_IRQ_CNT    K_BYTE(ASM_IRQ_CNT)
+#define K_IRQ_CYC    K_WORD(ASM_IRQ_CYC)
+#define K_IRQ_CAL    K_BYTE(ASM_IRQ_CAL)
+#define K_SPLIT_PREV K_BYTE(ASM_SPLIT_PREV)
+#define K_MUX_READY  K_BYTE(ASM_MUX_READY)
+#define K_MUX_SHOWN  K_BYTE(ASM_MUX_SHOWN)
+#define K_MUX_PEAK   K_BYTE(ASM_MUX_PEAK)
+#define K_SFX_TAKEN  K_BYTE(ASM_SFX_TAKEN)
+// C writes the actor table and then calls mux_sort; the IRQs read only the
+// sorted copy mux_build makes, so the table need not be volatile.
+#define ACT_Y   ((char *)ASM_ACT_Y)
+#define ACT_HX  ((char *)ASM_ACT_HX)       // sprite X = 2 * hx
+#define ACT_PTR ((char *)ASM_ACT_PTR)
+#define ACT_COL ((char *)ASM_ACT_COL)
+#define N_ACTORS 13             // mux.asm's N: the ship and NE enemies
+#define OFF_Y    0xff           // mux.asm's OFF_Y: not shown
+#define MAX_SY   187            // mux.asm's MAX_SY: lowest sprite Y shown
+
+// ---- coordinates ---------------------------------------------------------
+// Horizontal positions are half X ("hx"): sprite X = 2 * hx, one byte for the
+// whole screen, and one hx is one multicolour pixel. Vertical positions are
+// sprite Y registers for sprites and raster lines for bullets; a sprite at Y
+// is drawn on lines Y + 1 to Y + 21.
+
+// ---- game state (main.c) ---------------------------------------------------
+enum { ST_TITLE, ST_PLAY, ST_OVER, ST_FROZEN };
+extern char state;
+extern char lives, deaths;
+extern unsigned score, hiscore;         // in tens of points: the panel adds a 0
+extern unsigned play_frames;
+
+#define START_LIVES 3
+
+void sfx(char n);                       // 1 shot, 2 explosion, 3 ship lost
+void add_score(char tens);
+
+
+#endif

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

@@ -0,0 +1,358 @@
+// glyph.asm: the character bullets, imported by kernel.asm. bb_run moves
+// and draws the ship's bolts, eb_run the enemies' dots (bullets.c fires
+// them and keeps the rules). For each bullet they set cb_r and cb_c (screen
+// row and column), cb_glyph (its reserved code), cb_mask (the pixel pair)
+// and cb_row / cb_n (the glyph rows to set), then call cb_draw. That saves
+// the code under the bullet, copies its glyph into the reserved one, ORs the
+// pair into the rows, writes the reserved code into the cell, and notes the
+// cell and the code it found on a list. cb_erase restores the list
+// backwards; cb_check then compares every cell on it with the map's code,
+// which cb_draw notes only when C sets cb_keep (the autopilot build, whose
+// verdict runs the check every frame). The same work in C cost about 380
+// cycles a bullet (PROFILE build, VICE x64sc 3.10). No zero page: the loops
+// patch their own operands. Over open water (code 32, blank) nothing needs
+// merging: the cell gets cb_fixed, one of the ready-made shot glyphs
+// display.c builds, and the reserved glyph is left alone. Most shots are
+// over the river.
+//
+// Before cb_begin, C sets cb_front (0 or 1: the screen now showing), cb_top
+// (the map row that screen shows in its row 0: cur_row + 20, 0-115) and
+// cb_y (the YSCROLL showing).
+
+.const CHARSET    = $b800
+.const LEVEL_RAM  = $9000       // level.c: map row m at LEVEL_RAM + 40 * (95 - m)
+.const LEVEL_ROWS = 96
+.const CB_MAX     = 10          // bullets.h NB + NEB
+.const G_WATER    = 32          // display.h: open water, a blank cell
+.const G_DOTS     = $c0         // display.h: 16 dots, $C0 + pair * 4 + row / 2
+.const G_BOLTS    = $d0         // display.h: 4 bolts, $D0 + pair
+
+cb_front: .byte 0
+cb_top:   .byte 0
+cb_r:     .byte 0
+cb_c:     .byte 0
+cb_glyph: .byte 0
+cb_mask:  .byte 0
+cb_row:   .byte 0
+cb_n:     .byte 0
+cb_dn:    .byte 0               // cells on the list
+cb_fault: .byte 0               // cb_check: 1 when a cell is not the map's
+cb_fixed: .byte 0               // the ready-made glyph for this shot over open water
+cb_keep:  .byte 0               // 1: note the map's code for cb_check (about 40 cycles a draw)
+
+cb_lo:    .fill CB_MAX, 0       // the list: cell address, code found, map code
+cb_hi_t:  .fill CB_MAX, 0
+cb_under: .fill CB_MAX, 0
+cb_map:   .fill CB_MAX, 0
+
+pf_lo:    .fill 21, <($8000 + 40 * i)
+          .fill 21, <($8400 + 40 * i)
+pf_hi:    .fill 21, >($8000 + 40 * i)
+          .fill 21, >($8400 + 40 * i)
+cg_lo:    .fill 256, <(CHARSET + 8 * i)     // each code's glyph address: shifting
+cg_hi:    .fill 256, >(CHARSET + 8 * i)     // it cost 35 cycles more a draw
+map_lo:   .fill LEVEL_ROWS, <(LEVEL_RAM + 40 * (LEVEL_ROWS - 1 - i))
+map_hi:   .fill LEVEL_ROWS, >(LEVEL_RAM + 40 * (LEVEL_ROWS - 1 - i))
+
+cb_begin:
+        lda #0
+        sta cb_dn
+        rts
+
+cb_draw:
+        ldx cb_r                // the cell: row r of the showing screen, column c
+        lda cb_front
+        beq !+
+        txa
+        clc
+        adc #21
+        tax
+!:      lda pf_lo,x
+        clc
+        adc cb_c
+        sta cb_rd+1
+        sta cb_wr+1
+        lda pf_hi,x
+        adc #0
+        sta cb_rd+2
+        sta cb_wr+2
+        ldy cb_dn               // on the list
+        lda cb_rd+1
+        sta cb_lo,y
+        lda cb_rd+2
+        sta cb_hi_t,y
+        lda cb_keep             // only for cb_check (the autopilot's verdict)
+        beq cb_rd
+        lda cb_top              // the map's code: map row cb_top - r, wrapped
+        sec
+        sbc cb_r
+        cmp #LEVEL_ROWS
+        bcc !+
+        sbc #LEVEL_ROWS
+!:      tax
+        lda map_lo,x
+        sta cb_mp+1
+        lda map_hi,x
+        sta cb_mp+2
+        ldx cb_c
+cb_mp:  lda $ffff,x
+        sta cb_map,y
+cb_rd:  lda $ffff               // the code under the bullet
+        sta cb_under,y
+        inc cb_dn
+        cmp #G_WATER            // open water: a ready-made glyph, no merge
+        bne cb_merge
+        lda cb_fixed
+        jmp cb_wr
+cb_merge:
+        tax                     // its glyph: CHARSET + code * 8, from tables
+        lda cg_lo,x
+        sta cb_ld+1
+        lda cg_hi,x
+        sta cb_ld+2
+        ldx cb_glyph            // the reserved glyph
+        lda cg_lo,x
+        sta cb_st+1
+        sta cb_or+1
+        sta cb_os+1
+        lda cg_hi,x
+        sta cb_st+2
+        sta cb_or+2
+        sta cb_os+2
+        ldx #7
+cb_ld:  lda $ffff,x
+cb_st:  sta $ffff,x
+        dex
+        bpl cb_ld
+        ldx cb_row
+        ldy cb_n
+cb_or:  lda $ffff,x
+        ora cb_mask
+cb_os:  sta $ffff,x
+        inx
+        dey
+        bne cb_or
+        lda cb_glyph
+cb_wr:  sta $ffff
+        rts
+
+// Restore the list backwards, so bullets sharing a cell unwind.
+cb_erase:
+        ldy cb_dn
+        beq cb_e_done
+cb_e:   dey
+        lda cb_lo,y
+        sta cb_ew+1
+        lda cb_hi_t,y
+        sta cb_ew+2
+        lda cb_under,y
+cb_ew:  sta $ffff
+        cpy #0
+        bne cb_e
+cb_e_done:
+        rts
+
+// After cb_erase: every cell on the list holds the map's code again. Reads
+// the screen back, so an erase that skipped a cell or ran in the wrong order
+// leaves a reserved code and sets cb_fault.
+cb_check:
+        ldy cb_dn
+        beq cb_c_done
+cb_cl:  dey
+        lda cb_lo,y
+        sta cb_cr+1
+        lda cb_hi_t,y
+        sta cb_cr+2
+cb_cr:  lda $ffff
+        cmp cb_map,y
+        beq !+
+        lda #1
+        sta cb_fault
+!:      cpy #0
+        bne cb_cl
+cb_c_done:
+        rts
+
+// ---- the ship's bolts ------------------------------------------------------
+// bullets.c fires them (bb_live/bb_hx/bb_line); bb_run, called once a frame
+// before eb_run with cb_y = the YSCROLL showing, moves each bolt 7 lines up,
+// drops it once its top row is in screen row 0 (half hidden) or it left
+// row 19, draws it with cb_draw on rows 2-5 of its cell, and writes its box
+// (hit.asm hb_*, slot 1 + bolt). In C this loop cost about 250 cycles a
+// bolt more (PROFILE build, VICE x64sc 3.10).
+.const NB       = 4             // bullets.h NB
+.const G_BULLET = $f8           // display.h: $F8-$FB, one per bolt
+
+bb_live:  .fill NB, 0
+bb_hx:    .fill NB, 0           // half X of the bolt's pixel pair
+bb_line:  .fill NB, 0           // raster line of the bolt's top row
+bb_j:     .byte 0
+
+bb_run:
+        ldx #0
+bb_loop:
+        lda bb_live,x
+        bne !+
+        jmp bb_next
+!:
+        lda bb_line,x
+        sec
+        sbc #7
+        sta bb_line,x
+        sec                     // t = line - 50 - YSCROLL = 8 * row
+        sbc #50
+        sec
+        sbc cb_y
+        tay
+        sec                     // row 0 (t < 8) or past row 19 (t >= 160,
+        sbc #8                  // or below 0, which wraps high): gone
+        cmp #152
+        bcc !+
+        jmp bb_kill
+!:      tya
+        lsr
+        lsr
+        lsr
+        sta cb_r
+        lda #2
+        sta cb_row
+        lda #4
+        sta cb_n
+        lda bb_hx,x             // x = hx - 12: column x / 4, pair x & 3
+        sta hb_l+1,x            // the box: one pixel pair, four lines
+        tay
+        iny
+        tya
+        sta hb_r+1,x
+        lda bb_line,x
+        sta hb_t+1,x
+        clc
+        adc #4
+        sta hb_b+1,x
+        lda #1
+        sta hb_on+1,x
+        lda bb_hx,x
+        sec
+        sbc #12
+        tay
+        lsr
+        lsr
+        sta cb_c
+        tya
+        and #3
+        tay
+        lda eb_mask,y
+        sta cb_mask
+        tya
+        clc
+        adc #G_BOLTS            // the bolt over open water
+        sta cb_fixed
+        txa
+        clc
+        adc #G_BULLET
+        sta cb_glyph
+        stx bb_j
+        jsr cb_draw
+        ldx bb_j
+        jmp bb_next
+bb_kill:
+        lda #0
+        sta bb_live,x
+        sta hb_on+1,x
+bb_next:
+        inx
+        cpx #NB
+        beq !+
+        jmp bb_loop
+!:      rts
+
+// ---- the enemies' bullets --------------------------------------------------
+// bullets.c fires them (eb_live/eb_hx/eb_line/eb_dx) and calls eb_run once a
+// frame after the bolts, with cb_y = the YSCROLL showing. eb_run moves each
+// dot 2 lines down and eb_dx pixel pairs across, drops it past line EB_LAST
+// or the screen's sides, and draws it with cb_draw: rows (t & 6) and the next
+// of its cell, t = line - 48 - YSCROLL.
+.const NEB       = 6            // bullets.h NEB
+.const G_EBULLET = $f2          // $F2-$F7
+.const EB_LAST   = 206          // a dot below line 206 is gone (screen row 19)
+
+eb_live:  .fill NEB, 0
+eb_hx:    .fill NEB, 0          // half X of the dot's pixel pair
+eb_line:  .fill NEB, 0          // raster line of the dot's top row
+eb_dx:    .fill NEB, 0          // -1, 0 or 1 pixel pair a frame
+cb_y:     .byte 0
+eb_j:     .byte 0
+eb_mask:  .byte $c0, $30, $0c, $03
+eb_p4:    .byte G_DOTS, G_DOTS + 4, G_DOTS + 8, G_DOTS + 12
+
+eb_run:
+        ldx #0
+eb_loop:
+        lda eb_live,x
+        bne !+
+        jmp eb_next
+!:
+        lda eb_line,x
+        clc
+        adc #2
+        sta eb_line,x
+        cmp #EB_LAST+1
+        bcc !+
+        jmp eb_kill
+!:
+        lda eb_hx,x
+        clc
+        adc eb_dx,x
+        sta eb_hx,x
+        cmp #12
+        bcc eb_kill
+        cmp #172
+        bcs eb_kill
+        sec                     // x = hx - 12: column x / 4, pair x & 3
+        sbc #12
+        tay
+        lsr
+        lsr
+        sta cb_c
+        tya
+        and #3
+        tay
+        lda eb_mask,y
+        sta cb_mask
+        lda eb_p4,y             // the dot over water: G_DOTS + pair * 4 + row / 2
+        sta cb_fixed
+        lda eb_line,x           // t = line - 48 - YSCROLL (line >= 84: no borrow
+        sec                     // from the first subtraction)
+        sbc #48
+        sbc cb_y
+        tay
+        lsr
+        lsr
+        lsr
+        sta cb_r
+        tya
+        and #6
+        sta cb_row
+        lsr
+        clc
+        adc cb_fixed
+        sta cb_fixed
+        lda #2
+        sta cb_n
+        txa
+        clc
+        adc #G_EBULLET
+        sta cb_glyph
+        stx eb_j
+        jsr cb_draw
+        ldx eb_j
+        jmp eb_next
+eb_kill:
+        lda #0
+        sta eb_live,x
+eb_next:
+        inx
+        cpx #NEB
+        beq !+
+        jmp eb_loop
+!:      rts

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

@@ -0,0 +1,141 @@
+// hiscore.c: the high score in the sequential file HISCORE on drive 8, with
+// the policy of c64-kb's oscar64/high-score-persist recipe: the first named
+// OPEN is also the device test (no drive: saving off, the bus is never
+// touched again); the drive's reply separates 62 (no file: first run, write
+// it) from 00 (a file: check its size, magic and version) from anything else
+// (saving off). A file is replaced by scratch, then write.
+//
+// The game runs with the KERNAL banked out and its own raster IRQ chain.
+// Around every file call the chain is stopped with $D01A = 0 (not SEI: the
+// KERNAL's serial routines end in CLI) and the KERNAL is banked in; after,
+// the KERNAL is banked out, SEI again, and the chain restarted. The screen
+// holds still meanwhile: saving happens on the game-over screen.
+//
+// Sprites go off too. With the autopilot's eleven sprites left on, the
+// KERNAL's serial transfers hung: NTSC in 3 of 3 runs (the clock wait in
+// ACPTR), PAL in 1 of 3 (the EOI handshake in ISOUR). The review of this
+// starter isolated the cause with a minimal program: sprite DMA on badline
+// lines during the transfer. It hung with 3 to 8 sprites on screen, not with
+// the sprites above the display (no badlines), not with the screen blanked,
+// not with 0 or 1 sprite; and this game with sprites on but the screen
+// blanked passed 3 of 3 on each model. Measured in VICE x64sc 3.10 with the
+// true 1541; real hardware not measured.
+//
+// A splat file (the drive answers 60, WRITE FILE OPEN: a save cut off by a
+// reset or power-off) is scratched and written again, as a missing one is.
+
+#include "hiscore.h"
+#include <c64/kernalio.h>
+
+#define DRIVE   8
+#define VERSION 1
+
+bool disk_on = true;
+char disk_code = 99;
+
+static char record[5];                  // 'S', 'V', version, hiscore low, high
+static char back[8];
+static char reply[40];
+static char saved_01, saved_d01a;
+
+static void io_begin(void)
+{
+    __asm { sei }
+    saved_d01a = vic.intr_enable;
+    vic.intr_enable = 0;                // no raster IRQ during the serial calls
+    vic.spr_enable = 0;                 // no sprite DMA either (see the top of this file)
+    saved_01 = *(volatile char *)0x01;
+    *(volatile char *)0x01 = 0x36;      // KERNAL and I/O in
+}
+
+static void io_end(void)
+{
+    __asm { sei }                       // the serial routines left CLI behind
+    *(volatile char *)0x01 = saved_01;
+    cia1.icr = 0x7f;                    // no CIA1 interrupt, whatever the KERNAL set
+    char c = cia1.icr;
+    (void)c;
+    vic.intr_ctrl = 0x0f;               // drop a raster match latched meanwhile
+    vic.intr_enable = saved_d01a;
+    if (saved_d01a & 0x01)              // the chain was running: let it run again
+        __asm { cli }
+}
+
+// Send cmd on the command channel ("" only reads the status) and read the
+// reply line on the same open channel; disk_code = its two digits.
+static void drive_reply(const char *cmd)
+{
+    disk_code = 99;
+    krnio_setnam(cmd);
+    if (krnio_open(15, DRIVE, 15)) {
+        int n = krnio_gets(15, reply, sizeof(reply));
+        if (n >= 2)
+            disk_code = (reply[0] - '0') * 10 + (reply[1] - '0');
+        krnio_close(15);
+    }
+}
+
+static void write_record(void)
+{
+    record[0] = 'S';
+    record[1] = 'V';
+    record[2] = VERSION;
+    record[3] = (char)hiscore;
+    record[4] = (char)(hiscore >> 8);
+    drive_reply("S0:HISCORE");          // a missing file answers 01, harmless
+    krnio_setnam("HISCORE,S,W");
+    if (krnio_open(2, DRIVE, 2))
+        krnio_write(2, record, sizeof(record));
+    krnio_close(2);
+    drive_reply("");
+    disk_on = disk_code == 0;
+}
+
+void hiscore_load(void)
+{
+    if (!disk_on)
+        return;
+    io_begin();
+    krnio_setnam("HISCORE,S,R");
+    bool ok = krnio_open(2, DRIVE, 2);
+    if (!ok && (krnio_status() & KRNIO_NODEVICE)) {
+        krnio_close(2);                 // nothing answered: never CHKIN (no timeout)
+        disk_on = false;
+        disk_code = 99;
+        io_end();
+        return;
+    }
+    int n = ok ? krnio_read(2, back, sizeof(back)) : 0;
+    krnio_close(2);
+    drive_reply("");
+    if (disk_code == 0 && n == sizeof(record) && back[0] == 'S' && back[1] == 'V' && back[2] == VERSION)
+        hiscore = back[3] | (back[4] << 8);
+    else if (disk_code == 62 || disk_code == 0 || disk_code == 60)
+        write_record();                 // first run, an old layout or a splat: write ours
+    else
+        disk_on = false;                // 74 no disk, or anything unexpected
+    io_end();
+}
+
+void hiscore_save(void)
+{
+    if (!disk_on)
+        return;
+    io_begin();
+    write_record();
+    io_end();
+}
+
+void hiscore_forget(void)
+{
+    io_begin();
+    krnio_setnam("HISCORE,S,R");        // the device test, as in hiscore_load
+    bool ok = krnio_open(2, DRIVE, 2);
+    bool none = !ok && (krnio_status() & KRNIO_NODEVICE);
+    krnio_close(2);
+    if (none)
+        disk_on = false;
+    else
+        drive_reply("S0:HISCORE");
+    io_end();
+}

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

@@ -0,0 +1,16 @@
+// hiscore.h: the high score in a file on drive 8.
+#ifndef HISCORE_H
+#define HISCORE_H
+
+#include "game.h"
+
+extern bool disk_on;            // drive 8 answered: saving is on this session
+extern char disk_code;          // the drive's last reply: 0 OK, 62 no file, 99 none
+
+void hiscore_load(void);        // read HISCORE into hiscore; first run: write it
+void hiscore_save(void);        // replace HISCORE with hiscore (scratch, write)
+void hiscore_forget(void);      // scratch HISCORE (the autopilot's fresh start)
+
+#pragma compile("hiscore.c")
+
+#endif