c64-kb 0.17.0

package/templates/action-puzzle/src/gen_caves.h

@@ -0,0 +1,59 @@
+// gen_caves.h: written by tools/gen.py. Do not edit; edit tools/gen.py.
+#define CAVE_COUNT 2
+
+// FIRST DIG: 880 cells -> 316 bytes, fold 0xe964
+static const char cave0_rle[316] = {
+    0xa8, 0x03, 0x00, 0x01, 0x03, 0x8b, 0x01, 0x04, 0x04, 0x01, 0x01, 0x06, 0x89, 0x01, 0x01, 0x04,
+    0x8d, 0x01, 0x01, 0x03, 0x00, 0x03, 0x03, 0x01, 0x0a, 0x83, 0x01, 0x07, 0x06, 0x01, 0x01, 0x06,
+    0x01, 0x01, 0x06, 0x83, 0x01, 0x06, 0x06, 0x01, 0x01, 0x04, 0x00, 0x00, 0x8b, 0x01, 0x02, 0x04,
+    0x04, 0x84, 0x01, 0x01, 0x03, 0x00, 0x01, 0x03, 0x93, 0x01, 0x01, 0x06, 0x85, 0x01, 0x01, 0x04,
+    0x8c, 0x01, 0x01, 0x03, 0x00, 0x01, 0x03, 0x93, 0x01, 0x01, 0x06, 0x84, 0x01, 0x02, 0x04, 0x04,
+    0x8c, 0x01, 0x01, 0x03, 0x00, 0x01, 0x03, 0x94, 0x01, 0x02, 0x08, 0x03, 0x88, 0x01, 0x02, 0x04,
+    0x00, 0x86, 0x01, 0x01, 0x03, 0x00, 0x01, 0x03, 0x9a, 0x01, 0x85, 0x02, 0x01, 0x00, 0x86, 0x01,
+    0x01, 0x03, 0x00, 0x01, 0x03, 0x85, 0x01, 0x01, 0x04, 0xa0, 0x01, 0x01, 0x03, 0x00, 0x01, 0x03,
+    0x8e, 0x01, 0x84, 0x02, 0x87, 0x01, 0x84, 0x02, 0x89, 0x01, 0x01, 0x03, 0x00, 0x01, 0x03, 0x84,
+    0x01, 0x01, 0x06, 0x89, 0x01, 0x04, 0x02, 0x00, 0x00, 0x02, 0x87, 0x01, 0x04, 0x02, 0x00, 0x00,
+    0x02, 0x83, 0x01, 0x01, 0x06, 0x85, 0x01, 0x01, 0x03, 0x00, 0x01, 0x03, 0x8e, 0x01, 0x04, 0x02,
+    0x00, 0x0c, 0x02, 0x87, 0x01, 0x04, 0x02, 0x10, 0x00, 0x02, 0x89, 0x01, 0x01, 0x03, 0x00, 0x01,
+    0x03, 0x8e, 0x01, 0x04, 0x02, 0x00, 0x00, 0x02, 0x87, 0x01, 0x04, 0x02, 0x00, 0x00, 0x02, 0x89,
+    0x01, 0x01, 0x03, 0x00, 0x01, 0x03, 0x8e, 0x01, 0x84, 0x02, 0x87, 0x01, 0x84, 0x02, 0x89, 0x01,
+    0x01, 0x03, 0x00, 0x01, 0x03, 0x8b, 0x01, 0x90, 0x04, 0x8b, 0x01, 0x01, 0x03, 0x00, 0x02, 0x03,
+    0x01, 0xa4, 0x00, 0x02, 0x01, 0x03, 0x00, 0x01, 0x03, 0xa6, 0x01, 0x01, 0x03, 0x00, 0x01, 0x03,
+    0xa6, 0x01, 0x01, 0x03, 0x00, 0x01, 0x03, 0x8e, 0x01, 0x01, 0x06, 0x8a, 0x01, 0x85, 0x02, 0x88,
+    0x01, 0x01, 0x03, 0x00, 0x01, 0x03, 0x86, 0x01, 0x01, 0x04, 0x9f, 0x01, 0x01, 0x03, 0x00, 0x01,
+    0x03, 0x86, 0x01, 0x01, 0x06, 0x88, 0x01, 0x01, 0x04, 0x8e, 0x01, 0x01, 0x06, 0x87, 0x01, 0x01,
+    0x03, 0x00, 0x01, 0x03, 0xa6, 0x01, 0x01, 0x03, 0x00, 0xa8, 0x03, 0x00,
+};
+static const char cave0_name[16] = {
+    0x06, 0x09, 0x12, 0x13, 0x14, 0x20, 0x04, 0x09, 0x07, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+};
+// BOULDER HALL: 880 cells -> 293 bytes, fold 0xcb51
+static const char cave1_rle[293] = {
+    0xa8, 0x03, 0x00, 0x01, 0x03, 0x84, 0x01, 0x01, 0x04, 0x90, 0x01, 0x01, 0x04, 0x90, 0x01, 0x01,
+    0x03, 0x00, 0x01, 0x03, 0x8a, 0x01, 0x01, 0x04, 0x97, 0x01, 0x01, 0x04, 0x83, 0x01, 0x01, 0x03,
+    0x00, 0x04, 0x03, 0x01, 0x01, 0x0a, 0x8a, 0x01, 0x01, 0x06, 0x89, 0x01, 0x01, 0x06, 0x8e, 0x01,
+    0x01, 0x03, 0x00, 0x01, 0x03, 0x8f, 0x01, 0x01, 0x04, 0x85, 0x01, 0x01, 0x0c, 0x85, 0x00, 0x02,
+    0x01, 0x08, 0x89, 0x01, 0x01, 0x03, 0x00, 0x01, 0x03, 0x8b, 0x01, 0x85, 0x02, 0x96, 0x01, 0x01,
+    0x03, 0x00, 0x01, 0x03, 0x86, 0x01, 0x01, 0x06, 0x8e, 0x01, 0x01, 0x06, 0x87, 0x01, 0x01, 0x06,
+    0x88, 0x01, 0x01, 0x03, 0x00, 0x01, 0x03, 0x8b, 0x01, 0x01, 0x04, 0x8b, 0x01, 0x01, 0x04, 0x8e,
+    0x01, 0x01, 0x03, 0x00, 0x01, 0x03, 0x88, 0x01, 0x02, 0x00, 0x00, 0x9c, 0x01, 0x01, 0x03, 0x00,
+    0x01, 0x03, 0x86, 0x01, 0x85, 0x02, 0x8b, 0x01, 0x85, 0x02, 0x8b, 0x01, 0x01, 0x03, 0x00, 0x01,
+    0x03, 0x8b, 0x01, 0x01, 0x06, 0x84, 0x01, 0x01, 0x06, 0x89, 0x01, 0x01, 0x06, 0x8b, 0x01, 0x01,
+    0x03, 0x00, 0x01, 0x03, 0xa6, 0x01, 0x01, 0x03, 0x00, 0x01, 0x03, 0x88, 0x01, 0x01, 0x10, 0x85,
+    0x00, 0x98, 0x01, 0x01, 0x03, 0x00, 0x01, 0x03, 0x84, 0x01, 0x01, 0x04, 0x87, 0x01, 0x01, 0x04,
+    0x87, 0x01, 0x01, 0x04, 0x88, 0x01, 0x01, 0x04, 0x88, 0x01, 0x01, 0x03, 0x00, 0x01, 0x03, 0x84,
+    0x01, 0x01, 0x06, 0x87, 0x01, 0x01, 0x06, 0x87, 0x01, 0x01, 0x06, 0x88, 0x01, 0x01, 0x06, 0x88,
+    0x01, 0x01, 0x03, 0x00, 0x01, 0x03, 0xa6, 0x01, 0x01, 0x03, 0x00, 0x01, 0x03, 0x8a, 0x01, 0x84,
+    0x02, 0x8d, 0x01, 0x84, 0x02, 0x87, 0x01, 0x01, 0x03, 0x00, 0x01, 0x03, 0xa6, 0x01, 0x01, 0x03,
+    0x00, 0x01, 0x03, 0x83, 0x01, 0x01, 0x06, 0x92, 0x01, 0x01, 0x06, 0x89, 0x01, 0x01, 0x06, 0x85,
+    0x01, 0x01, 0x03, 0x00, 0x01, 0x03, 0xa6, 0x01, 0x01, 0x03, 0x00, 0x01, 0x03, 0xa6, 0x01, 0x01,
+    0x03, 0x00, 0xa8, 0x03, 0x00,
+};
+static const char cave1_name[16] = {
+    0x02, 0x0f, 0x15, 0x0c, 0x04, 0x05, 0x12, 0x20, 0x08, 0x01, 0x0c, 0x0c, 0x20, 0x20, 0x20, 0x20,
+};
+
+static const CaveInfo cave_info[CAVE_COUNT] = {
+    { cave0_rle, cave0_name, 6, 99, 0xe964 },
+    { cave1_rle, cave1_name, 8, 120, 0xcb51 },
+};

package/templates/action-puzzle/src/gen_notes.h

@@ -0,0 +1,16 @@
+// gen_notes.h: written by tools/gen.py. Note n is C1 + n semitones; A4 = 440 Hz.
+// Frequency word = Hz * 16777216 / clock (PAL 985,248 Hz; NTSC 1,022,727 Hz).
+static const unsigned note_pal[60] = {
+    0x022d, 0x024e, 0x0271, 0x0296, 0x02be, 0x02e7, 0x0314, 0x0342, 0x0374, 0x03a9, 0x03e0, 0x041b,
+    0x045a, 0x049c, 0x04e2, 0x052d, 0x057b, 0x05cf, 0x0627, 0x0685, 0x06e8, 0x0751, 0x07c1, 0x0837,
+    0x08b4, 0x0938, 0x09c4, 0x0a59, 0x0af7, 0x0b9d, 0x0c4e, 0x0d0a, 0x0dd0, 0x0ea2, 0x0f81, 0x106d,
+    0x1167, 0x1270, 0x1389, 0x14b2, 0x15ed, 0x173b, 0x189c, 0x1a13, 0x1ba0, 0x1d45, 0x1f02, 0x20da,
+    0x22ce, 0x24e0, 0x2711, 0x2964, 0x2bda, 0x2e76, 0x3139, 0x3426, 0x3740, 0x3a89, 0x3e04, 0x41b4,
+};
+static const unsigned note_ntsc[60] = {
+    0x0218, 0x0238, 0x025a, 0x027e, 0x02a4, 0x02cc, 0x02f7, 0x0324, 0x0354, 0x0386, 0x03bc, 0x03f5,
+    0x0431, 0x0471, 0x04b4, 0x04fc, 0x0548, 0x0598, 0x05ed, 0x0648, 0x06a7, 0x070c, 0x0778, 0x07e9,
+    0x0862, 0x08e2, 0x0969, 0x09f8, 0x0a90, 0x0b30, 0x0bdb, 0x0c8f, 0x0d4e, 0x0e19, 0x0ef0, 0x0fd3,
+    0x10c4, 0x11c3, 0x12d1, 0x13f0, 0x151f, 0x1661, 0x17b6, 0x191e, 0x1a9d, 0x1c32, 0x1ddf, 0x1fa6,
+    0x2188, 0x2386, 0x25a3, 0x27e0, 0x2a3f, 0x2cc2, 0x2f6b, 0x323d, 0x353a, 0x3864, 0x3bbe, 0x3f4c,
+};

package/templates/action-puzzle/src/hiscore.c

@@ -0,0 +1,152 @@
+// hiscore.c: the table and its file. The disk policy is the
+// oscar64/high-score-persist recipe's: the named OPEN for read is also the
+// device test; the drive's reply on channel 15 decides first run (62),
+// loaded (00) or saving off (anything else); a file is replaced by scratch,
+// then write, because OPEN ...,S,W over an existing name fails with 63.
+#include "hiscore.h"
+#include <c64/kernalio.h>
+#include <string.h>
+
+#ifndef FORCE_FAULT
+#define FORCE_FAULT 0
+#endif
+
+#define DRIVE   8
+#define VERSION 1
+
+HiTable hi;
+char hi_state, hi_code;
+bool hi_saving, hi_verified;
+
+static char back[64];                           // read buffer, bigger than the file
+static char reply[40];                          // one line from channel 15
+
+// Original default names and scores, as screen codes.
+static const HiTable defaults = {
+    { 'C', 'R' }, VERSION,
+    {
+        { { 4, 9, 7 },    400 },                // DIG
+        { { 18, 15, 24 }, 300 },                // ROX
+        { { 7, 5, 13 },   200 },                // GEM
+        { { 13, 21, 4 },  100 },                // MUD
+        { { 15, 18, 5 },   50 }                 // ORE
+    }
+};
+
+void hi_defaults(void)
+{
+    hi = defaults;
+}
+
+// The first row whose score is strictly lower: a tie goes below the holder.
+char hi_rank(unsigned long score)
+{
+    char r = 0;
+    while (r < HI_ROWS && hi.row[r].score >= score)
+        r++;
+    return r;
+}
+
+// Shift the rows below `rank` down one, dropping the last, and write the new row.
+void hi_insert(char rank, const char *name, unsigned long score)
+{
+    if (rank >= HI_ROWS)
+        return;
+    for (char r = HI_ROWS - 1; r > rank; r--)
+        hi.row[r] = hi.row[r - 1];
+    for (char k = 0; k < 3; k++)
+        hi.row[rank].name[k] = name[k];
+    hi.row[rank].score = score;
+}
+
+// Send `cmd` on channel 15 ("" to read the status only), read one reply
+// line from the same open channel, close it. Sets hi_code from its first
+// two digits. Only called after a named OPEN has answered, because an
+// empty-name OPEN cannot see an absent drive and the CHKIN inside
+// krnio_gets would then hang (the recipe measured it).
+static void drive_reply(const char *cmd)
+{
+    reply[0] = 0;
+    hi_code = 99;
+    krnio_setnam(cmd);
+    if (krnio_open(15, DRIVE, 15))
+    {
+        int n = krnio_gets(15, reply, sizeof(reply));
+        if (n >= 2)
+            hi_code = (reply[0] - '0') * 10 + (reply[1] - '0');
+        krnio_close(15);
+    }
+}
+
+// Read HISCORE into back[] (filled with $FF first, so a short read cannot
+// pass on old bytes). Returns the byte count; hi_code holds the drive's
+// reply, 99 when no device answered the named OPEN.
+static int read_file(void)
+{
+    memset(back, 0xff, sizeof(back));
+    krnio_setnam("HISCORE,S,R");
+    bool ok = krnio_open(2, DRIVE, 2);
+    if (!ok && (krnio_status() & KRNIO_NODEVICE))
+    {
+        krnio_close(2);                         // nothing answered: leave the bus alone
+        hi_code = 99;
+        return 0;
+    }
+    int n = 0;
+    if (ok)
+        n = krnio_read(2, back, sizeof(back));
+    krnio_close(2);
+    drive_reply("");
+    return n;
+}
+
+void hi_load(void)
+{
+    hi_defaults();
+    hi_saving = false;
+    hi_state = HI_OFF;
+    int n = read_file();
+    const HiTable *got = (const HiTable *)back;
+    if (hi_code == 0 && n == sizeof(HiTable) && got->magic[0] == 'C' &&
+        got->magic[1] == 'R' && got->version == VERSION)
+    {
+        hi = *got;
+        hi_state = HI_LOADED;
+        hi_saving = true;
+    }
+    else if (hi_code == 0 && n > 0)
+    {
+        hi_state = HI_OLD;                      // right name, wrong layout: replaced on save
+        hi_saving = true;
+    }
+    else if (hi_code == 62)
+    {
+        hi_state = HI_FIRST;
+        hi_saving = true;
+    }
+}
+
+bool hi_save(void)
+{
+    if (!hi_saving)
+        return false;
+    drive_reply("S0:HISCORE");                  // 01 FILES SCRATCHED, count 00 when absent
+    krnio_setnam("HISCORE,S,W");
+    if (krnio_open(2, DRIVE, 2))
+        krnio_write(2, (const char *)&hi, sizeof(HiTable));
+    krnio_close(2);
+    drive_reply("");
+    hi_saving = hi_code == 0;
+    hi_verified = false;
+    if (!hi_saving)
+        return false;
+    // Read the file back and compare it with what was written: the drive's
+    // 00 says the write was accepted, not that these bytes are on the disk.
+    int n = read_file();
+#if FORCE_FAULT
+    back[3] ^= 1;                               // the self-test: a bad read-back must fail
+#endif
+    hi_verified = hi_code == 0 && n == sizeof(HiTable) &&
+                  memcmp(back, &hi, sizeof(HiTable)) == 0;
+    return hi_verified;
+}

package/templates/action-puzzle/src/hiscore.h

@@ -0,0 +1,41 @@
+// hiscore.h: the five-row table, the insert, and the file on drive 8
+// (c64-kb techniques high_score_table_insert, kernal_file_read_seq,
+// kernal_file_write_seq, error_channel_check; the policy is
+// oscar64/high-score-persist's).
+#ifndef HISCORE_H
+#define HISCORE_H
+
+#define HI_ROWS 5
+
+typedef struct {
+    char name[3];               // screen codes 1..26
+    unsigned long score;        // stored low byte first
+} HiEntry;
+
+typedef struct {
+    char magic[2];              // 'C', 'R'
+    char version;               // bump when the layout changes
+    HiEntry row[HI_ROWS];
+} HiTable;                      // 38 bytes: Oscar64 packs structs with no padding
+
+// What the start-up load found; hi_code keeps the drive's two-digit reply
+// (99: no device answered).
+#define HI_LOADED 0             // 00 and a record of the right size and version
+#define HI_FIRST  1             // 62: no file yet; saving is on
+#define HI_OLD    2             // a file of another layout: replaced at the next save
+#define HI_OFF    3             // anything else (74: no disk): saving off this session
+
+extern HiTable hi;
+extern char hi_state, hi_code;
+extern bool hi_saving;
+extern bool hi_verified;                // the last save read back byte for byte
+
+void hi_defaults(void);
+char hi_rank(unsigned long score);      // row a score goes in (a tie goes below), HI_ROWS if none
+void hi_insert(char rank, const char *name, unsigned long score);
+void hi_load(void);                     // KERNAL calls: the caller mutes, and SEIs after
+bool hi_save(void);                     // scratch, write, read the reply, read the file back; true when it matches
+
+#pragma compile("hiscore.c")
+
+#endif

package/templates/action-puzzle/src/level.c

@@ -0,0 +1,64 @@
+// level.c: decode a cave from its RLE row streams (tools/gen.py packs them).
+#include "level.h"
+#include "cave.h"
+#include <c64/cia.h>
+
+#include "gen_caves.h"
+
+char level_count = CAVE_COUNT;
+unsigned level_cycles;
+bool level_ok = true;
+
+// The level-rle-decoder recipe's C decoder with the row loop folded in.
+// Returns the number of cells written, which must be CW * CH.
+static unsigned rle_decode(const char *src, char *dst)
+{
+    unsigned n = 0;
+    for (char y = 0; y < CH; y++)
+    {
+        for (;;)
+        {
+            char c = *src++;
+            if (c == 0)
+                break;
+            if (c & 0x80)
+            {
+                char v = *src++;
+                c &= 0x7f;
+                for (char k = 0; k < c; k++)
+                    dst[n++] = v;
+            }
+            else
+            {
+                for (char k = 0; k < c; k++)
+                    dst[n++] = *src++;
+            }
+        }
+    }
+    return n;
+}
+
+void level_load(char index)
+{
+    const CaveInfo *ci = cave_info + index;
+    // CIA1 timer B times the decode. The KERNAL IRQ is off while the game
+    // runs, so nothing else uses the timer here.
+    cia1.crb = 0x00;
+    cia1.tb = 0xffff;
+    char flags = cia1.icr;                          // reading clears a stale underflow
+    cia1.crb = 0x11;                                // force load, start, count phi2
+    unsigned n = rle_decode(ci->rle, cave);
+    cia1.crb = 0x00;                                // stop before reading
+    level_cycles = 0xffff - cia1.tb;
+    flags = cia1.icr;
+    if (flags & 0x02)
+        level_cycles = 0xffff;                      // timer B passed zero: more than 65,535
+    if (n != CW * CH || cave_fold(0) != ci->fold)
+        level_ok = false;
+    cave_start(ci->need, ci->time);
+}
+
+const char *level_name(char index)
+{
+    return cave_info[index].name;
+}

package/templates/action-puzzle/src/level.h

@@ -0,0 +1,24 @@
+// level.h: the caves, stored as RLE row streams and decoded between caves
+// (c64-kb technique tile_map_render, the decode half; the format and the
+// decoder are oscar64/level-rle-decoder's).
+#ifndef LEVEL_H
+#define LEVEL_H
+
+typedef struct {
+    const char *rle;            // 22 row streams: 0x80+n then a byte = n copies; 1..127 = that many literals; 0 = end of row
+    const char *name;           // 16 screen codes
+    char need;                  // gems that open the exit
+    char time;                  // time counter at the start
+    unsigned fold;              // tools/gen.py's fold of the decoded cave
+} CaveInfo;
+
+extern char level_count;
+extern unsigned level_cycles;   // CIA1 timer B: cycles the last decode took (65,535 = more)
+extern bool level_ok;           // false once any decode missed its fold or length
+
+void level_load(char index);    // decode cave `index` into cave[], then cave_start
+const char *level_name(char index);
+
+#pragma compile("level.c")
+
+#endif