c64-kb 0.17.0

package/templates/adventure/src/save.h

@@ -0,0 +1,25 @@
+// save.h: SAVE and LOAD of the game state as the sequential file SAVEGAME on
+// drive 8 (c64-kb techniques kernal_file_write_seq, kernal_file_read_seq,
+// error_channel_check; the policy is oscar64/high-score-persist's).
+//
+// The record: 'S' 'W' version(2) room score turns(2) flags(2) loc[] opened[]
+// check. check is a fold of every byte before it. version is gen.py's
+// WORLD_VERSION, a hash of the rooms, items and flags, so a save from a build
+// with another world is refused ("FROM ANOTHER VERSION"), as is one of the
+// wrong size or fold, or naming a room or place this world lacks; nothing
+// is changed then.
+//
+// Both run on a frame outside the meter, with the sound muted. The KERNAL's
+// serial routines end in CLI; CIA1's interrupts are masked, so nothing runs
+// when they do, and the caller sets SEI again after.
+#ifndef SAVE_H
+#define SAVE_H
+
+extern char disk_code;          // the drive's two-digit reply; 99: no device answered
+
+void game_save(void);           // appends the reply to the output tokens
+void game_load(void);           // on success restores the state and appends a LOOK
+
+#pragma compile("save.c")
+
+#endif

package/templates/adventure/src/sound.c

@@ -0,0 +1,71 @@
+// sound.c: see sound.h. The SID registers are write-only (pitfall
+// sid_write_only_registers): nothing here reads them back.
+#include "sound.h"
+#include "gen_world.h"
+#include <c64/sid.h>
+
+#define NOTE_C5 0
+#define NOTE_E5 1
+#define NOTE_G5 2
+#define NOTE_C6 3
+#define NOTE_A4 4
+#define END     0xff
+
+static const unsigned *notes;                   // note_pal or note_ntsc (gen_world.h)
+static const char chime[] = { NOTE_G5, NOTE_C6, END };
+static const char fanfare[] = { NOTE_C5, NOTE_E5, NOTE_G5, NOTE_C6, NOTE_G5, NOTE_C6, END };
+static const char *tune;                        // voice 2's notes, 0 when idle
+static char tune_wait, click_wait;
+
+void sound_init(bool ntsc)
+{
+    notes = ntsc ? note_ntsc : note_pal;
+    sid.fmodevol = 0x0f;
+    sid.voices[0].ctrl = 0;
+    sid.voices[0].attdec = 0x00;                // click: instant attack, short decay
+    sid.voices[0].susrel = 0x00;
+    sid.voices[0].freq = 0x2000;
+    sid.voices[1].ctrl = 0;
+    sid.voices[1].attdec = 0x09;
+    sid.voices[1].susrel = 0x00;
+    sid.voices[1].pwm = 0x0800;
+    tune = nullptr;
+}
+
+void sound_click(void)
+{
+    sid.voices[0].ctrl = 0x81;                  // noise, gate on
+    click_wait = 1;
+}
+
+static void play(const char *t)
+{
+    tune = t;
+    tune_wait = 0;
+}
+
+void sound_chime(void) { play(chime); }
+void sound_fanfare(void) { play(fanfare); }
+
+void sound_update(void)
+{
+    if (click_wait && !--click_wait)
+        sid.voices[0].ctrl = 0x80;              // gate off
+    if (!tune || tune_wait--)
+        return;
+    if (*tune == END)
+    {
+        sid.voices[1].ctrl = 0x40;
+        tune = nullptr;
+        return;
+    }
+    sid.voices[1].ctrl = 0x40;                  // gate off, then on with the new pitch
+    sid.voices[1].freq = notes[*tune++];
+    sid.voices[1].ctrl = 0x41;                  // pulse, gate on
+    tune_wait = 6;
+}
+
+void sound_mute(bool on)
+{
+    sid.fmodevol = on ? 0 : 0x0f;
+}

package/templates/adventure/src/sound.h

@@ -0,0 +1,16 @@
+// sound.h: a key click on voice 1 and short tunes on voice 2 (c64-kb technique
+// sid_voice_setup). One sound_update() a frame steps them. No music: text
+// adventures of the period mostly had none, and the frame is the printer's.
+#ifndef SOUND_H
+#define SOUND_H
+
+void sound_init(bool ntsc);
+void sound_click(void);
+void sound_chime(void);         // the score went up
+void sound_fanfare(void);       // the ending
+void sound_update(void);
+void sound_mute(bool on);       // around disk calls
+
+#pragma compile("sound.c")
+
+#endif

package/templates/adventure/src/text.c

@@ -0,0 +1,349 @@
+// text.c: see text.h. tools/gen.py's Printer class is a Python copy of the
+// printer here (the verdict compares a fold of every line); change both.
+#include "text.h"
+#include "engine.h"
+
+#define WIDTH  40
+#define CH_NL  0xf0             // next_char(): a paragraph ends
+#define CH_END 0xff             // next_char(): no more tokens
+
+enum { P_NONE, P_WORD, P_NL, P_END };
+
+char input[INPUT_MAX];
+char input_len;
+
+// ---- plain text ----------------------------------------------------------------
+static char to_screen(char c)                   // ASCII / PETSCII upper case to screen code
+{
+    return (c >= 0x41 && c <= 0x5a) ? c - 0x40 : c;
+}
+
+void put_text(char row, char col, const char *s, char colour)
+{
+    char *d = SCREEN + 40 * row + col;
+    char *t = COLOUR + 40 * row + col;
+    while (*s)
+    {
+        *d++ = to_screen(*s++);
+        *t++ = colour;
+    }
+}
+
+// A packed message straight to the screen: each byte below $40 is a screen
+// code, each byte from $40 a pair of codes expanded on a small stack.
+void put_msg(char row, char col, char m, char colour)
+{
+    char st[16], n = 0;
+    const char *p = text_bytes + msg_at[m];
+    char *d = SCREEN + 40 * row + col;
+    char *t = COLOUR + 40 * row + col;
+    while (*p)
+    {
+        st[n++] = *p++;
+        while (n)
+        {
+            char b = st[--n];
+            if (b < 0x40)
+            {
+                *d++ = b;
+                *t++ = colour;
+            }
+            else
+            {
+                st[n++] = pair_right[b - 0x40];
+                st[n++] = pair_left[b - 0x40];
+            }
+        }
+    }
+}
+
+// decimal_print, subtract-powers (oscar64/print-number): no division.
+static const unsigned pow10[4] = { 10000, 1000, 100, 10 };
+
+static char digits5(unsigned v, char *d)       // five digits into d[]; returns the first not 0
+{
+    for (char i = 0; i < 4; i++)
+    {
+        char c = 0x30;
+        while (v >= pow10[i])
+        {
+            v -= pow10[i];
+            c++;
+        }
+        d[i] = c;
+    }
+    d[4] = 0x30 + v;
+    char f = 0;
+    while (f < 4 && d[f] == 0x30)
+        f++;
+    return f;
+}
+
+// Right-aligned in `digits` cells (at most 5), leading zeros as spaces.
+void put_num(char row, char col, unsigned v, char digits, char colour)
+{
+    char d[5];
+    char f = digits5(v, d);
+    char *s = SCREEN + 40 * row + col;
+    char *t = COLOUR + 40 * row + col;
+    for (char i = 0; i < digits; i++)
+    {
+        char k = 5 - digits + i;
+        s[i] = k < f ? 0x20 : d[k];
+        t[i] = colour;
+    }
+}
+
+void clear_rows(char from, char to)
+{
+    for (char r = from; r <= to; r++)
+    {
+        char *d = SCREEN + 40 * r;
+        char *t = COLOUR + 40 * r;
+        for (char i = 0; i < 40; i++)
+        {
+            d[i] = 0x20;
+            t[i] = COL_TEXT;
+        }
+    }
+}
+
+// ---- the printer: tokens to characters ------------------------------------------------
+static char stk[16], sp;                        // right halves of pair codes still to print
+static const char *mp;                          // the message being read, 0 if none
+static char digit[5], nd, dn;                   // a number: digit[dn..4], nd of them left
+static bool back_nl;                            // a new line read one character early
+static char tpos;                               // next token in oq[]
+static char pr_style;                           // STYLE_TEXT, or STYLE_ECHO: reverse video
+static char word[WIDTH], wlen, pend;
+
+void printer_reset(void)
+{
+    tpos = sp = nd = 0;
+    mp = nullptr;
+    back_nl = false;
+    pend = P_NONE;
+}
+
+// The next screen code, CH_NL or CH_END. A pair code prints its left half
+// now and keeps its right half on the stack.
+static char next_char(void)
+{
+    if (back_nl)
+    {
+        back_nl = false;
+        return CH_NL;
+    }
+    for (;;)
+    {
+        char b;
+        if (sp)
+            b = stk[--sp];
+        else if (mp)
+        {
+            b = *mp;
+            if (!b)
+            {
+                mp = nullptr;
+                continue;
+            }
+            mp++;
+        }
+        else if (nd)
+        {
+            nd--;
+            return digit[dn++];
+        }
+        else if (tpos >= oq_len)
+            return CH_END;
+        else
+        {
+            char k = oq[tpos++];
+            if (k == TOK_NL)
+                return CH_NL;
+            if (k == TOK_CHR)
+                return oq[tpos++];
+            if (k == TOK_STYLE)
+                pr_style = oq[tpos++];
+            else if (k == TOK_NUM)
+            {
+                dn = digits5(oq[tpos] | (oq[tpos + 1] << 8), digit);
+                nd = 5 - dn;
+                tpos += 2;
+            }
+            else
+                mp = text_bytes + msg_at[k];
+            continue;
+        }
+        while (b >= 0x40)
+        {
+            stk[sp++] = pair_right[b - 0x40];
+            b = pair_left[b - 0x40];
+        }
+        return b;
+    }
+}
+
+// The next word, new line or end, into pend (and word[]).
+static void fetch(void)
+{
+    char c = next_char();
+    while (c == 0x20)
+        c = next_char();
+    if (c == CH_NL || c == CH_END)
+    {
+        pend = c == CH_NL ? P_NL : P_END;
+        return;
+    }
+    char n = 0;
+    for (;;)
+    {
+        if (n < WIDTH)
+            word[n++] = c;
+        c = next_char();
+        if (c == 0x20 || c == CH_END)
+            break;
+        if (c == CH_NL)
+        {
+            back_nl = true;
+            break;
+        }
+    }
+    wlen = n;
+    pend = P_WORD;
+}
+
+bool printer_ready(void)
+{
+    if (pend == P_NONE)
+        fetch();
+    return pend != P_END;
+}
+
+// Rows 9-21 move up one row and row 21 is cleared: one pass over the columns
+// with every row's move written out, so each move is an absolute,X load and
+// store. Screen codes only: the window's colour RAM stays white, and the typed
+// command is set apart by reverse video, which halves the moves.
+#define SROW(r) ((char *)(0x0400 + 40 * (r)))
+#define MV(r) SROW(r)[x] = SROW((r) + 1)[x];
+
+static void window_scroll(void)
+{
+    for (char x = 0; x < WIDTH; x++)
+    {
+        MV(8) MV(9) MV(10) MV(11) MV(12) MV(13) MV(14)
+        MV(15) MV(16) MV(17) MV(18) MV(19) MV(20)
+        SROW(21)[x] = 0x20;
+    }
+}
+
+// One line: words while they fit. A word that does not fit waits in word[]
+// for the next line.
+void printer_line(void)
+{
+    window_scroll();
+    char *row = SROW(WIN_BOTTOM);
+    char col = 0;
+    for (;;)
+    {
+        if (pend == P_NONE)
+            fetch();
+        if (pend == P_END)
+            break;
+        if (pend == P_NL)
+        {
+            pend = P_NONE;
+            break;
+        }
+        if (col + wlen + (col ? 1 : 0) > WIDTH)
+        {
+            if (col)
+                break;
+            wlen = WIDTH;                       // a word as wide as the window: cut it
+        }
+        if (col)
+            col++;
+        char *d = row + col;
+        for (char k = 0; k < wlen; k++)
+            d[k] = word[k];
+        col += wlen;
+        pend = P_NONE;
+    }
+    if (pr_style)
+        for (char i = 0; i < col; i++)
+            row[i] |= pr_style;
+}
+
+// ---- status bar and input line -----------------------------------------------------------
+// Only the fields that changed: a room name costs a decode, a number five
+// rounds of subtraction.
+static char shown_name, shown_score;
+static unsigned shown_turns;
+
+void status_draw(void)
+{
+    char name = lit() ? room_name[room] : M_DARKNAME;
+    if (name != shown_name)
+    {
+        char *d = SCREEN + 40 * STATUS_ROW;
+        for (char i = 1; i < 20; i++)
+            d[i] = 0x20;
+        put_msg(STATUS_ROW, 1, name, 7);
+        shown_name = name;
+    }
+    if (score != shown_score)
+        put_num(STATUS_ROW, 26, shown_score = score, 3, 1);
+    if (turns != shown_turns)
+        put_num(STATUS_ROW, 37, shown_turns = turns, 3, 1);
+}
+
+void status_init(void)
+{
+    put_msg(STATUS_ROW, 20, M_SCORELBL, 3);
+    put_msg(STATUS_ROW, 31, M_TURNSLBL, 3);
+    shown_name = 0;
+    shown_score = 0xff;
+    shown_turns = 0xffff;
+    status_draw();
+}
+
+void input_clear(void)
+{
+    clear_rows(INPUT_ROW, INPUT_ROW);
+    SCREEN[40 * INPUT_ROW] = 0x3e;              // '>'
+    COLOUR[40 * INPUT_ROW] = COL_ECHO;
+    input_len = 0;
+}
+
+// text_input_line: letters (shifted ones folded to plain), digits and space
+// are echoed; DEL takes one back; RETURN ends the line.
+bool input_key(char k)
+{
+    char *cell = SCREEN + 40 * INPUT_ROW + 1;
+    if (k == 0x0d)
+        return true;
+    if (k == 0x14)
+    {
+        if (input_len)
+        {
+            cell[input_len] = 0x20;             // the cursor's old cell
+            input_len--;
+        }
+        return false;
+    }
+    if (k >= 0xc1 && k <= 0xda)
+        k -= 0x80;
+    bool ok = (k >= 0x41 && k <= 0x5a) || (k >= 0x30 && k <= 0x39) || k == 0x20;
+    if (ok && input_len < INPUT_MAX)
+    {
+        input[input_len] = k;
+        cell[input_len] = to_screen(k);
+        input_len++;
+    }
+    return false;
+}
+
+void input_cursor(char frame)
+{
+    SCREEN[40 * INPUT_ROW + 1 + input_len] = (frame & 16) ? 0xa0 : 0x20;
+}

package/templates/adventure/src/text.h

@@ -0,0 +1,40 @@
+// text.h: the screen's text parts. The printer turns the engine's output
+// tokens into word-wrapped lines of the scrolling window, one line a frame;
+// the packed messages are decoded as they print. Also the status bar, the
+// input line and plain text for the title (c64-kb techniques
+// adventure_database_engine, text_input_line, decimal_print,
+// petscii_screen_code_conversion).
+#ifndef TEXT_H
+#define TEXT_H
+
+#define SCREEN ((char *)0x0400)
+#define COLOUR ((char *)0xd800)
+
+#define STATUS_ROW 7
+#define WIN_TOP    8            // the window: rows 8 to 21
+#define WIN_BOTTOM 21
+#define RULE_ROW   22
+#define INPUT_ROW  23
+#define INPUT_MAX  36           // typed characters; the cursor takes the next cell
+
+extern char input[INPUT_MAX];
+extern char input_len;
+
+void put_text(char row, char col, const char *s, char colour);   // ASCII upper case
+void put_msg(char row, char col, char m, char colour);            // a packed message
+void put_num(char row, char col, unsigned v, char digits, char colour);
+void clear_rows(char from, char to);
+
+void printer_reset(void);       // a new token list starts at oq[0]; the colour carries on
+bool printer_ready(void);       // true when a line is waiting (reads ahead one word)
+void printer_line(void);        // scroll the window, print the next line at the bottom
+
+void status_init(void);        // the labels and every field
+void status_draw(void);        // the fields that changed
+void input_clear(void);
+bool input_key(char k);         // PETSCII from the keyboard queue; true on RETURN
+void input_cursor(char frame);
+
+#pragma compile("text.c")
+
+#endif

package/templates/adventure/tools/disk_check.py

@@ -0,0 +1,128 @@
+#!/usr/bin/env python3
+"""disk_check.py HARNESS_DIR BUILD_DIR [pal|ntsc]: grade `make disktest`.
+disk_check.py --make-bad BUILD_DIR: write the three bad saves the test loads.
+
+What each part must show comes from tools/gen.py's model, not from here:
+
+  the file    build/savegame.seq, read back by c1541 after the DISKTEST=1 run,
+              equals the record the model makes at the script's SAVE, byte for
+              byte; the directory holds one SAVEGAME
+  disk-save   DISKTEST=1: its own verdict (green), the window ends with
+              GAME SAVED (00), the status bar is the saved room, score, turns
+  disk-load   DISKTEST=2, after a cold start on the same disk: it typed LOAD
+              first, so its green verdict and the ending on screen need the
+              saved state back
+  disk-boot   the release PRG booted from the D64 with LOAD"*",8,1, then
+              RETURN, LOAD, SCORE and I typed into the keyboard queue: every
+              window line and the status bar as the model prints them
+  bad-fold    the release PRG LOADs the good save with one byte changed:
+              refused as damaged, the game still at the start
+  bad-room    a save with a valid fold that names room 200: refused as damaged
+              (save.c's range check; without it the fold would let it in)
+  bad-world   a save with a valid fold made by another world (its version
+              bytes differ): refused as from another version
+  no-disk     the release PRG types SAVE to a drive with no disk: the drive's
+              own words, "DISK ERROR: 74,DRIVE NOT READY."
+"""
+import os
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, HERE)
+import gen  # noqa: E402
+
+BOOT_KEYS = ["LOAD", "SCORE", "I"]      # the Makefile's -keybuf, after the title's RETURN
+
+
+def window(lines):
+    """The window's 14 rows at the end, as check.read_text reads them."""
+    rows = [gen.row_text(r) for r in lines[-14:]]
+    return [" " * 40] * (14 - len(rows)) + rows
+
+
+def status(g):
+    name = gen.MSGS[gen.ROOM_NAME[gen.ROOM_KEYS[g.room - 1]]] if g.lit() else gen.W.MESSAGES["DARKNAME"]
+    return (" " + name).ljust(20) + "SCORE" + str(g.score).rjust(4) + "  TURNS" + str(g.turns).rjust(4)
+
+
+def refold(rec):
+    return rec[:-1] + bytes([gen.fold8(rec[:-1])])
+
+
+def make_bad(build):
+    good = open(os.path.join(build, "savegame.seq"), "rb").read()
+    bad_fold = bytearray(good)
+    bad_fold[10] ^= 0x01                        # one item's place, the fold left as it was
+    bad_room = bytearray(good)
+    bad_room[4] = 200                           # a room this world does not have
+    bad_world = bytearray(good)
+    bad_world[2] ^= 0xFF                        # another world's version
+    for name, rec in (("bad-fold", bytes(bad_fold)), ("bad-room", refold(bytes(bad_room))),
+                      ("bad-world", refold(bytes(bad_world)))):
+        open(os.path.join(build, name + ".seq"), "wb").write(rec)
+        print(f"disk_check: {name}.seq {rec.hex()}")
+
+
+def main():
+    if sys.argv[1] == "--make-bad":
+        make_bad(sys.argv[2])
+        return
+    harness, build = sys.argv[1:3]
+    model = sys.argv[3] if len(sys.argv) > 3 else "pal"
+    sys.path.insert(0, harness)
+    import check
+
+    fails = []
+    split = gen.W.SCRIPT.index("SAVE")
+    part1 = gen.play(gen.W.SCRIPT[:split + 1], stop_after="SAVE")
+    part2 = gen.play(gen.W.SCRIPT[gen.W.SCRIPT.index("LOAD"):], disk_saved=part1[4])
+    boot = gen.play(BOOT_KEYS, disk_saved=part1[4])
+    start = gen.play([])[0]                     # a new game: where a refused LOAD leaves it
+
+    got = open(os.path.join(build, "savegame.seq"), "rb").read()
+    print(f"disk_check: SAVEGAME {len(got)} bytes, the model's record {len(part1[4])}")
+    if got != part1[4]:
+        fails.append(f"SAVEGAME is {got.hex()}, the model says {part1[4].hex()}")
+    listing = open(os.path.join(build, "disktest-dir.txt")).read()
+    n = sum('"savegame"' in line for line in listing.splitlines())
+    print(f"disk_check: {n} SAVEGAME entry in the directory")
+    if n != 1:
+        fails.append(f"the directory holds {n} SAVEGAME entries, want 1")
+
+    glyphs = check.load_glyphs()
+    damaged = gen.W.MESSAGES["BADSAVE"] + "(00)."
+    want = {
+        "disk-save": (True, [(7, status(part1[0]))] + rows_at(window(part1[1])[-1:])),
+        "disk-load": (True, [(7, status(part2[0]))] + rows_at(window(part2[1])[-4:])),
+        "disk-boot": (False, [(7, status(boot[0]))] + rows_at(window(boot[1]))),
+        "bad-fold": (False, [(7, status(start)), (20, ">LOAD"), (21, damaged)]),
+        "bad-room": (False, [(7, status(start)), (20, ">LOAD"), (21, damaged)]),
+        "bad-world": (False, [(7, status(start)), (20, ">LOAD"),
+                              (21, gen.W.MESSAGES["OLDSAVE"] + "(00).")]),
+        "no-disk": (False, [(20, ">SAVE"), (21, "DISK ERROR: 74,DRIVE NOT READY.")]),
+    }
+    for pic, (graded, items) in want.items():
+        shot = check.Shot(os.path.join("shots", pic + ".png"), model)
+        if graded:
+            ok = shot.index(*check.BORDER_SAMPLE) == 5
+            print(f"{'PASS' if ok else 'FAIL'} {pic} border green (its own verdict)")
+            if not ok:
+                fails.append(f"{pic}: border not green")
+        for row, text in items:
+            text = text.rstrip() or " "
+            read = check.read_text(shot, glyphs, row, 0, len(text))
+            ok = read == text
+            print(f"{'PASS' if ok else 'FAIL'} {pic} row {row:2}: '{read}'")
+            if not ok:
+                fails.append(f"{pic} row {row}: '{read}', want '{text}'")
+    print("disk_check: PASS" if not fails else f"disk_check: {len(fails)} FAILED: {fails}")
+    sys.exit(1 if fails else 0)
+
+
+def rows_at(rows):
+    """Window rows ending at row 21."""
+    return [(22 - len(rows) + k, r) for k, r in enumerate(rows)]
+
+
+if __name__ == "__main__":
+    main()