c64-kb 0.17.0

package/templates/adventure/src/main.c

@@ -0,0 +1,439 @@
+// main.c: STARWATCH, the text-adventure starter. The states (title, play,
+// ending) and the frame loop; the game is in engine.c, the window printer and
+// input line in text.c, the pictures in picture.c, SAVE and LOAD in save.c,
+// sound in sound.c, and the world itself in tools/world.py.
+//
+// One frame does one bounded job: draw the room picture, or print one line
+// of the window, or take typed keys (and, on RETURN, parse and run the turn,
+// which only queues message numbers). Disk calls run on frames of their own,
+// outside the meter.
+//
+// AUTOPILOT=1 types tools/world.py's script into the KERNAL keyboard queue,
+// the bytes a real key puts there, and grades itself against tools/gen.py's
+// model: $02FF = $01 and a green border on pass, $02 and red on fail.
+// FORCE_FAULT=1 scores one point less at the end. DISKTEST=1 plays the script
+// up to its SAVE; DISKTEST=2 starts at its LOAD (make disktest).
+#include <c64/vic.h>
+#include <c64/cia.h>
+#include "frame_meter.h"            // templates/_harness/meter
+#include "engine.h"
+#include "text.h"
+#include "picture.h"
+#include "save.h"
+#include "sound.h"
+
+#ifndef AUTOPILOT
+#define AUTOPILOT 0
+#endif
+#ifndef DISKTEST
+#define DISKTEST 0
+#endif
+
+// Code and data below the character set at $3800, the rest from $4000.
+#pragma region( lower, 0x0880, 0x3800, , , { code, data } )
+#pragma region( main, 0x4000, 0xa000, , , { code, data, bss, heap, stack } )
+
+#if AUTOPILOT
+#include "gen_script.h"
+#endif
+
+#define RESULT  (*(volatile char *)0x02ff)   // $01 pass, $02 fail, $00 not reached
+#define KEYQ    ((volatile char *)0x0277)    // the KERNAL keyboard queue
+#define KEYN    (*(volatile char *)0x00c6)   // keys in it
+#define KEYMAX  10                           // its size ($0289)
+#define MODE    (*(volatile char *)0x0291)   // $80: SHIFT + C= does not switch case
+#define JOY_FIRE 0x10
+
+enum { ST_TITLE, ST_PLAY, ST_END };
+
+static char state, frame;
+static unsigned state_frames;
+static bool ntsc;
+static char pic_shown, pic_want;
+static bool pic_dirty;
+static unsigned play_frames;            // metered frames this game
+static char last_score;
+
+// ---- keyboard ------------------------------------------------------------------
+// The KERNAL IRQ is off, so the loop runs SCNKEY itself: it reads the matrix
+// and puts a new key in the queue. key_get() takes the first key out, as
+// GETIN's LP2 ($E5B4) does, but without the CLI that LP2 ends with.
+static void key_scan(void)
+{
+    __asm { jsr 0xff9f }
+}
+
+static char key_get(void)
+{
+    char n = KEYN;
+    if (!n)
+        return 0;
+    char k = KEYQ[0];
+    for (char i = 1; i < n; i++)
+        KEYQ[i - 1] = KEYQ[i];
+    KEYN = n - 1;
+    return k;
+}
+
+// Fire on port 2, read only on the title and the ending. make joy builds it
+// with -dJOY_SOURCE=0x02fe: the byte comes from RAM that tools/drive.py
+// writes, because the windowless VICE's joyport commands never reach $DC00
+// (templates/action-puzzle, README).
+static bool fire_was = true;            // held at power-on counts as held, not pressed
+
+static bool fire_pressed(void)
+{
+#if AUTOPILOT
+    return false;
+#elif defined(JOY_SOURCE)
+    return !(*(volatile char *)JOY_SOURCE & JOY_FIRE);
+#else
+    return !(cia1.pra & JOY_FIRE);
+#endif
+}
+
+#if AUTOPILOT
+static char ap_cmd, ap_pos;             // the script's command and byte to type next
+static unsigned text_fold, lines;
+static char save_code = 0xff, load_code = 0xff;
+
+// Up to ten bytes of the current command a frame, then its RETURN.
+static void autopilot_feed(void)
+{
+    const char *s = script[ap_cmd];
+    if (!s)
+        return;
+    while (KEYN < KEYMAX)
+    {
+        char c = s[ap_pos];
+        KEYQ[KEYN] = c ? c : 0x0d;
+        KEYN = KEYN + 1;
+        if (!c)
+        {
+            ap_cmd++;
+            ap_pos = 0;
+            return;
+        }
+        ap_pos++;
+    }
+}
+
+static unsigned fold16(unsigned f, char v)
+{
+    return (f ^ v) * 5 + 1;
+}
+#endif
+
+// ---- frame -------------------------------------------------------------------------
+// frame_sync_loop: line 250 is below the last badline on PAL and NTSC and
+// comes once a frame, so the 8-bit compare needs no ninth bit.
+static void wait_frame(void)
+{
+    while (vic.raster == 250) ;
+    while (vic.raster != 250) ;
+}
+
+// PAL has lines up to $137, NTSC (6567R8) up to $106.
+static bool detect_ntsc(void)
+{
+    for (unsigned i = 0; i < 12000; i++)
+        if ((vic.ctrl1 & 0x80) && vic.raster >= 0x36)
+            return false;
+    return true;
+}
+
+static void set_state(char s)
+{
+    state = s;
+    state_frames = 0xffff;              // the loop counts it up to 0 at the frame's end
+}
+
+// ---- title ---------------------------------------------------------------------------
+static void title_draw(void)
+{
+    picture_draw(TITLE_PIC);
+    clear_rows(PIC_ROWS, 24);
+    put_text(9, 15, "STARWATCH", 7);
+    put_text(11, 5, "A TEXT ADVENTURE IN TWELVE ROOMS", 3);
+    put_text(14, 2, "TYPE TWO-WORD COMMANDS: GO NORTH, N,", 1);
+    put_text(15, 2, "GET LAMP, OPEN CHEST, LOOK, INVENTORY.", 1);
+    put_text(16, 2, "SAVE AND LOAD USE THE DISK IN DRIVE 8.", 1);
+    put_text(19, 10, "PRESS RETURN OR FIRE", 7);
+}
+
+// ---- play ------------------------------------------------------------------------------
+// After a turn or a disk call: the status bar, the picture, the sounds.
+static void after_turn(void)
+{
+    status_draw();
+    pic_want = picture_now();
+    if (pic_want != pic_shown)
+        pic_dirty = true;
+    if (over == 1)
+        sound_fanfare();
+    else if (score > last_score)
+        sound_chime();
+    last_score = score;
+}
+
+static void play_start(void)
+{
+    clear_rows(PIC_ROWS, 24);
+    for (char i = 0; i < 40; i++)
+    {
+        SCREEN[40 * RULE_ROW + i] = 0x2d;       // a blue rule of '-' under the window
+        COLOUR[40 * RULE_ROW + i] = 6;
+    }
+    game_new();
+    status_init();
+    input_clear();
+    pic_want = picture_now();
+    pic_shown = 0xff;
+    pic_dirty = true;
+    last_score = 0;
+    play_frames = 0;
+    set_state(ST_PLAY);
+}
+
+// The input frame: the autopilot's keys, then every key in the queue until a RETURN.
+static void input_frame(void)
+{
+#if AUTOPILOT
+    autopilot_feed();
+#endif
+    for (;;)
+    {
+        char k = key_get();
+        if (!k)
+            break;
+        sound_click();
+        if (input_key(k))
+        {
+            game_command(input, input_len);
+            input_clear();
+            after_turn();
+            break;
+        }
+    }
+    input_cursor(frame);
+}
+
+// The disk clock: CIA2 timer A counts phi2 cycles and timer B counts timer
+// A's underflows, a 32-bit count (as oscar64/save-load-seq-file). Timer A is
+// the frame meter's, so the stop puts back what meter_init left: timer A
+// stopped with $FFFF in its latch, and no underflow flag in $DD0D, which the
+// meter would read as a frame of 65,535 cycles.
+static unsigned long save_cycles, load_cycles;
+
+static void disk_clock_start(void)
+{
+    cia2.cra = 0x00;
+    cia2.crb = 0x00;
+    cia2.ta = 0xffff;
+    cia2.tb = 0xffff;
+    cia2.crb = 0x51;                    // force load, start, count timer A underflows
+    cia2.cra = 0x11;                    // force load, start, count phi2
+}
+
+static unsigned long disk_clock_stop(void)
+{
+    cia2.cra = 0x00;
+    cia2.crb = 0x00;
+    unsigned long c = ((unsigned long)(0xffff - cia2.tb) << 16) | (0xffff - cia2.ta);
+    cia2.ta = 0xffff;                   // the meter's latch
+    char flags = cia2.icr;              // reading $DD0D clears the underflow flag
+    (void)flags;
+    return c;
+}
+
+// SAVE or LOAD, on a frame that is not a play frame.
+static void disk_frame(void)
+{
+    sound_mute(true);
+    out_reset();
+    disk_clock_start();
+    if (disk_req == DISK_SAVE)
+        game_save();
+    else
+        game_load();
+    __asm { sei }                       // the KERNAL's serial routines end in CLI
+    unsigned long c = disk_clock_stop();
+    if (disk_req == DISK_SAVE)
+        save_cycles = c;
+    else
+        load_cycles = c;
+#if AUTOPILOT
+    if (disk_req == DISK_SAVE)
+        save_code = disk_code;
+    else
+        load_code = disk_code;
+#endif
+    disk_req = 0;
+    sound_mute(false);
+    after_turn();
+}
+
+#if AUTOPILOT
+static void put_long(char row, char col, unsigned long v)   // eight digits
+{
+    char *d = SCREEN + 40 * row + col + 8;
+    for (char i = 0; i < 8; i++)
+    {
+        *--d = 0x30 + (char)(v % 10);
+        v /= 10;
+    }
+}
+
+// The verdict: real state read back against the model, outside the meter.
+static void verdict(void)
+{
+    unsigned lf = 0;
+    for (char i = 1; i < NITEM; i++)
+        lf = fold16(lf, loc[i]);
+    for (char i = 1; i < NITEM; i++)
+        lf = fold16(lf, opened[i]);
+    bool ok = room == EXPECT_ROOM && score == EXPECT_SCORE && turns == EXPECT_TURNS &&
+              flags == EXPECT_FLAGS && over == EXPECT_OVER && lf == EXPECT_LOCFOLD &&
+              text_fold == EXPECT_TEXTFOLD && lines == EXPECT_LINES &&
+              play_frames == EXPECT_FRAMES && save_code == EXPECT_SAVE_CODE &&
+              load_code == EXPECT_LOAD_CODE;
+    // The disk clock is plausible: every SAVE or LOAD the script made took
+    // between 0.1 and 30 million cycles (the README has the measured figures).
+    if (EXPECT_SAVE_CODE == 0 && (save_cycles < 100000 || save_cycles > 30000000))
+        ok = false;
+    if (EXPECT_LOAD_CODE == 0 && (load_cycles < 100000 || load_cycles > 30000000))
+        ok = false;
+    put_text(23, 0, "SAVE", 1);
+    put_long(23, 5, save_cycles);
+    put_text(23, 14, "LOAD", 1);
+    put_long(23, 19, load_cycles);
+    put_text(23, 28, "CYCLES", 1);
+    RESULT = ok ? 0x01 : 0x02;
+    vic.color_border = ok ? VCOL_GREEN : VCOL_RED;
+    put_text(24, 0, ok ? "RESULT 01 PASS " : "RESULT 02 FAIL ", 1);
+    unsigned f = text_fold;                     // the fold in hex, as screen codes
+    char *d = SCREEN + 40 * 24 + 18;
+    for (char i = 0; i < 4; i++)
+    {
+        char n = f & 15;
+        *d-- = n < 10 ? 0x30 + n : n - 9;
+        f >>= 4;
+    }
+}
+#endif
+
+// A frame that is not play: a disk call waiting, or the game is over, or
+// (autopilot) the script has run out.
+static bool between_frames(void)
+{
+#if AUTOPILOT
+    bool done = over || !script[ap_cmd];
+#else
+    bool done = over;
+#endif
+    return disk_req || done;
+}
+
+static void play_frame(void)
+{
+    METER_START;
+    bool printing = pic_dirty || printer_ready();
+    if (!printing && between_frames())
+    {
+        meter_read();                   // stops the timer: this frame is not recorded
+        if (disk_req)
+            disk_frame();
+        else
+        {
+            clear_rows(INPUT_ROW, INPUT_ROW);
+            set_state(ST_END);
+#if AUTOPILOT
+            verdict();
+#endif
+        }
+        return;
+    }
+    sound_update();
+    key_scan();
+    bool line = false;
+    if (pic_dirty)
+    {
+        picture_draw(pic_want);
+        pic_shown = pic_want;
+        pic_dirty = false;
+    }
+    else if (printing)
+    {
+        printer_line();
+        line = true;
+    }
+    else
+        input_frame();
+    METER_STOP;                         // the frame's own work ends here
+    play_frames++;
+#if AUTOPILOT
+    if (line)                           // the grading's own fold: outside the bracket
+    {
+        const char *row = SCREEN + 40 * WIN_BOTTOM;
+        for (char i = 0; i < 40; i++)
+            text_fold = fold16(text_fold, row[i]);
+        lines++;
+    }
+#endif
+}
+
+int main(void)
+{
+    __asm { sei }
+    cia1.icr = 0x7f;                    // no CIA1 interrupts: the KERNAL's CLIs find none
+    MODE = 0x80;
+    KEYN = 0;
+#if !AUTOPILOT && defined(JOY_SOURCE)
+    *(volatile char *)JOY_SOURCE = 0xff;        // nothing pressed until the monitor says so
+#endif
+    ntsc = detect_ntsc();
+    video_init();
+    sound_init(ntsc);
+    clear_rows(0, 24);
+#if AUTOPILOT
+    meter_init(0x0400, 24, 20, VCOL_WHITE, METER_HOLD);   // hold: the script's play frames
+#endif
+    title_draw();
+    set_state(ST_TITLE);
+
+    for (;;)
+    {
+        wait_frame();
+        frame++;
+        if (state == ST_PLAY)
+            play_frame();
+        else
+        {
+            sound_update();
+            key_scan();
+#if AUTOPILOT
+            if (state == ST_TITLE && state_frames == 2)
+            {
+                KEYQ[KEYN] = 0x0d;      // the title's RETURN, typed like the rest
+                KEYN = KEYN + 1;
+            }
+#endif
+            char k = key_get();
+            bool fire = fire_pressed();
+            bool go = k == 0x0d || (fire && !fire_was);     // joystick_edge_detect: a new press
+            fire_was = fire;
+            if (state == ST_TITLE && go)
+                play_start();
+            else if (state == ST_END && go && !AUTOPILOT)
+            {
+                title_draw();
+                set_state(ST_TITLE);
+            }
+        }
+#if AUTOPILOT
+        meter_print();
+#endif
+        state_frames++;
+    }
+    return 0;
+}

package/templates/adventure/src/picture.c

@@ -0,0 +1,83 @@
+// picture.c: see picture.h.
+#include "picture.h"
+#include "text.h"
+#include "gen_world.h"
+#include <c64/vic.h>
+
+// charset_copy_rom_to_ram: codes 0-63 (letters, digits, punctuation) and
+// 128-255 (their reverse) from the character ROM at $D000; codes 64-127 are
+// the picture glyphs from gen_world.h. The ROM is seen by the CPU only with
+// the I/O area switched out ($01 bit 2 clear), so no interrupt may run then
+// (pitfall irq_during_charen_window); the caller has interrupts off.
+static void charset_build(void)
+{
+    volatile char *port = (volatile char *)0x01;
+    const char *rom = (const char *)0xd000;
+    char save = *port;
+    *port = save & ~0x04;
+    for (unsigned i = 0; i < 512; i++)
+        CHARSET[i] = rom[i];
+    for (unsigned i = 1024; i < 2048; i++)
+        CHARSET[i] = rom[i];
+    *port = save;
+    for (unsigned i = 0; i < NGLYPH * 8; i++)
+        CHARSET[512 + i] = glyph_bytes[i];
+}
+
+void video_init(void)
+{
+    charset_build();
+    vic.color_border = VCOL_BLACK;
+    vic.color_back = VCOL_BLACK;                // %00 and the hires text background
+    vic.color_back1 = VCOL_MED_GREY;            // %01: stone
+    vic.color_back2 = VCOL_BROWN;               // %10: wood and earth
+    vic.memptr = 0x1e;                          // screen $0400, characters $3800
+    vic.ctrl2 = 0x18;                           // MCM on, 40 columns, XSCROLL 0: a whole value
+}
+
+// A picture is coded row by row, and nothing crosses the end of a row, so
+// the column and the offset in the row's bytes are single bytes. A byte n
+// below $80 is a run: n cells of the tile that follows. $80 + n is a literal:
+// n tiles follow, one a cell. A tile is a character code and its colour RAM
+// value (8 + a colour: multicolour). The first version coded runs only,
+// across rows, with a 16-bit count: the library, whose book rows are runs of
+// one cell, took 20,240 cycles, over the frame on PAL and NTSC (found in
+// review; the autopilot never entered the library, see the picture pass in
+// main.c).
+void picture_draw(char p)
+{
+    const char *s = pic_bytes + pic_at[p];
+    char *d = SCREEN;
+    char *t = COLOUR;
+    for (char r = 0; r < PIC_ROWS; r++)
+    {
+        char x = 0, i = 0;
+        do
+        {
+            char c = s[i++];
+            if (c & 0x80)
+            {
+                char e = x + (c & 0x7f);
+                do
+                {
+                    char tile = s[i++];
+                    d[x] = tile_char[tile];
+                    t[x] = tile_colour[tile];
+                } while (++x != e);
+            }
+            else
+            {
+                char tile = s[i++], e = x + c;
+                char ch = tile_char[tile], co = tile_colour[tile];
+                do
+                {
+                    d[x] = ch;
+                    t[x] = co;
+                } while (++x != e);
+            }
+        } while (x < 40);
+        s += i;
+        d += 40;
+        t += 40;
+    }
+}

package/templates/adventure/src/picture.h

@@ -0,0 +1,16 @@
+// picture.h: the character set and the room picture strip (c64-kb techniques
+// mcm_text and charset_copy_rom_to_ram). Rows 0-6 are multicolour cells
+// (colour RAM 8-15); every other cell keeps a colour of 0-7 and stays hires,
+// so one $D016 value serves the whole screen and no raster split is needed.
+#ifndef PICTURE_H
+#define PICTURE_H
+
+#define CHARSET  ((char *)0x3800)
+#define PIC_ROWS 7
+
+void video_init(void);          // charset copy, glyphs, $D016/$D018/$D021-$D023
+void picture_draw(char p);      // RLE-decode picture p into rows 0-6
+
+#pragma compile("picture.c")
+
+#endif

package/templates/adventure/src/save.c

@@ -0,0 +1,159 @@
+// save.c: see save.h. tools/gen.py's Game.record() writes the same record.
+#include "save.h"
+#include "engine.h"
+#include <c64/kernalio.h>
+
+#define DRIVE   8
+#define RECLEN  (11 + 2 * (NITEM - 1))
+
+char disk_code;
+static char rec[RECLEN + 8];                    // read buffer: bigger than the record
+static char reply[40];
+
+static char fold8(const char *p, char n)
+{
+    char c = 0;
+    for (char i = 0; i < n; i++)
+        c = (c ^ p[i]) * 3 + 1;
+    return c;
+}
+
+// Send cmd on channel 15 ("" reads the status only) and keep the first two
+// digits of the reply. Named first: an empty-name OPEN cannot see an absent
+// drive, and the read after it would then hang (oscar64/high-score-persist).
+static void drive_reply(const char *cmd)
+{
+    disk_code = 99;
+    krnio_setnam(cmd);
+    bool ok = krnio_open(15, DRIVE, 15);
+    if (krnio_status() & KRNIO_NODEVICE)
+        ok = false;
+    if (ok && krnio_gets(15, reply, sizeof(reply)) >= 2)
+        disk_code = (reply[0] - '0') * 10 + (reply[1] - '0');
+    krnio_close(15);
+}
+
+// A failure in the drive's own words: "DISK ERROR: 74,DRIVE NOT READY." (its
+// reply up to the track and sector), or no drive at all. The first version
+// printed "THE DISK DID NOT ANSWER (74)" when the drive had answered.
+static void error_line(void)
+{
+    if (disk_code == 99)
+    {
+        out_msg(M_NODRIVE);
+        out_nl();
+        return;
+    }
+    out_msg(M_DISKFAIL);
+    char commas = 0;
+    for (char i = 0; reply[i] && reply[i] != 13 && i < 30; i++)
+    {
+        char c = reply[i];
+        if (c == ',' && ++commas == 2)
+            break;
+        out_chr((c >= 0x41 && c <= 0x5a) ? c - 0x40 : c);   // PETSCII to screen code
+    }
+    out_msg(M_DOT);
+    out_nl();
+}
+
+static void reply_line(char m)                  // "GAME SAVED (00)."
+{
+    out_msg(m);
+    out_chr('(');
+    out_chr('0' + disk_code / 10);
+    out_chr('0' + disk_code % 10);
+    out_msg(M_CLOSEP);
+    out_nl();
+}
+
+void game_save(void)
+{
+    char n = 0;
+    rec[n++] = 'S';
+    rec[n++] = 'W';
+    rec[n++] = WORLD_VERSION & 0xff;            // gen.py: a hash of rooms, items and flags
+    rec[n++] = WORLD_VERSION >> 8;
+    rec[n++] = room;
+    rec[n++] = score;
+    rec[n++] = turns & 0xff;
+    rec[n++] = turns >> 8;
+    rec[n++] = flags & 0xff;
+    rec[n++] = flags >> 8;
+    for (char i = 1; i < NITEM; i++)
+        rec[n++] = loc[i];
+    for (char i = 1; i < NITEM; i++)
+        rec[n++] = opened[i];
+    rec[n] = fold8(rec, n);
+
+    drive_reply("S0:SAVEGAME");                 // 01 FILES SCRATCHED, or 00 with none
+    if (disk_code < 20)                         // the drive answered and is ready
+    {
+        krnio_setnam("SAVEGAME,S,W");           // over a file that exists this is 63
+        if (krnio_open(2, DRIVE, 2))
+            krnio_write(2, rec, RECLEN);
+        krnio_close(2);
+        drive_reply("");
+    }
+    if (disk_code == 0)
+        reply_line(M_SAVED);
+    else
+        error_line();
+}
+
+// Every room and place in the record names one this world has.
+static bool places_ok(void)
+{
+    if (rec[4] == 0 || rec[4] >= NROOM)
+        return false;
+    for (char i = 0; i < NITEM - 1; i++)
+    {
+        char l = rec[10 + i];
+        if (l != CARRIED && ((l & 0x80) ? (l & 0x7f) >= NITEM : l >= NROOM))
+            return false;
+    }
+    return true;
+}
+
+void game_load(void)
+{
+    krnio_setnam("SAVEGAME,S,R");
+    bool ok = krnio_open(2, DRIVE, 2);
+    if (!ok && (krnio_status() & KRNIO_NODEVICE))
+    {
+        krnio_close(2);                         // nothing answered: leave the bus alone
+        disk_code = 99;
+        error_line();
+        return;
+    }
+    int n = ok ? krnio_read(2, rec, sizeof(rec)) : 0;
+    krnio_close(2);
+    drive_reply("");
+    if (disk_code == 62)
+        reply_line(M_NOSAVE);
+    else if (disk_code != 0)
+        error_line();
+    else if (n != RECLEN || rec[0] != 'S' || rec[1] != 'W' ||
+             rec[RECLEN - 1] != fold8(rec, RECLEN - 1))
+        reply_line(M_BADSAVE);
+    else if (rec[2] != (WORLD_VERSION & 0xff) || rec[3] != (WORLD_VERSION >> 8))
+        reply_line(M_OLDSAVE);                  // made by a build with another world
+    else if (!places_ok())
+        reply_line(M_BADSAVE);
+    else
+    {
+        char k = 4;
+        room = rec[k++];
+        score = rec[k++];
+        turns = rec[k] | (rec[k + 1] << 8);
+        flags = rec[k + 2] | (rec[k + 3] << 8);
+        k += 4;
+        for (char i = 1; i < NITEM; i++)
+            loc[i] = rec[k++];
+        for (char i = 1; i < NITEM; i++)
+            opened[i] = rec[k++];
+        over = 0;
+        reply_line(M_LOADED);
+        look();
+    }
+}