c64-kb 0.17.0

package/templates/platformer/src/main.c

@@ -0,0 +1,306 @@
+// main.c: the platformer starter. The frame loop, the game's states, the
+// autopilot and its verdict. Each subsystem lives in its own file (game.h
+// lists them); this file only runs them in order.
+//
+// One frame, from raster line 251 (below the last display line):
+//   view_apply    the sprites for the picture about to be drawn
+//   music, sfx    the tune (KickAssembler) and the effects on voice 3
+//   the state     title, play, dying, game over, level clear
+//   hud_draw      score, coins, lives, high score on the HUD page
+//   view_publish  the next picture's page and XSCROLL, as one pair
+// Two raster IRQs in engine.asm set the registers: at line 212 the HUD's
+// $D016 and $D018, at line 251 the published playfield pair. In AUTOPILOT
+// builds the meter brackets every play frame.
+//
+// AUTOPILOT=1 replaces the joystick with a script that plays from the
+// title; after it the program grades itself ($02FF and the border).
+// FORCE_FAULT=1 makes a coin worth 20, so the score is wrong: the verdict
+// fails and the HUD shows a different score. TEAR_DEMO=1 scrolls the old
+// way, in place (view.c), for tools/tearcheck.py to catch.
+#include "game.h"
+#include "asm.h"
+#include "frame_meter.h"
+
+// ---- memory: the KickAssembler blob at its own address, code from $1000 ----
+#pragma section( asmcode, 0 )
+#pragma region( asmreg, ASM_ORG, 0x1000, , , { asmcode } )
+#pragma region( main, 0x1000, 0xa000, , , { code, data, bss, heap, stack } )
+#pragma data( asmcode )
+__export const char asm_blob[] = {
+#embed "asm.bin"
+};
+#pragma data( data )
+
+#define BLANK_TICKS (*(volatile char *)ASM_BLANK_TICKS)
+
+// PROF=n (a build define) meters one subsystem instead of the whole frame:
+// 1 player, 2 actors, 3 camera and scroll, 4 sprites + music + effects,
+// 5 HUD + sprite shadows. Each is a METER_START ... METER_PAUSE section,
+// summed per frame by meter_frame. README.md has the figures.
+#ifndef PROF
+#define PROF 0
+#endif
+static bool metering;               // this frame is a play frame
+#define PON(n)  if (PROF == n && metering) METER_START;
+#define POFF(n) if (PROF == n && metering) METER_PAUSE;
+
+enum State { ST_TITLE, ST_PLAY, ST_DYING, ST_OVER, ST_CLEAR, ST_GRADED };
+static char state, timer, prev_joy;
+unsigned events;
+char stomps;
+bool goal_reached;
+static char hurts;
+static unsigned frame;              // frames since power-on
+static unsigned late;               // play frames whose work ran past the next frame's line 251
+
+#define PLAY_HOLD 255               // play frames the meter records (its maximum)
+#define START_LIVES 3
+
+// ---- input -------------------------------------------------------------------------
+#if AUTOPILOT
+#include "autopilot.h"
+static char ap_step, ap_used;
+static char port_read(void)
+{
+    char out = 0xff;
+    if (ap_step < SCRIPT_STEPS)
+    {
+        out = script[ap_step][1];
+        if (++ap_used == script[ap_step][0])
+        {
+            ap_used = 0;
+            ap_step++;
+        }
+    }
+    return out;
+}
+#elif defined(JOY_SOURCE)
+// Headless driving of the normal game (make joy, tools/drive.py): the port
+// byte comes from RAM at JOY_SOURCE, which a VICE monitor writes. The
+// windowless VICE's joyport commands do not reach $DC00.
+static char port_read(void)
+{
+    return *(volatile char *)JOY_SOURCE;
+}
+#else
+static char port_read(void)
+{
+    return cia1.pra;                // control port 2, active low
+}
+#endif
+
+// The IRQ at line 251 counts the blanks (engine.asm); the frame starts
+// when the count moves. Work that runs long skips a blank, never splits one.
+static void wait_sync(void)
+{
+    char t = BLANK_TICKS;
+    while (BLANK_TICKS == t) ;
+}
+
+// ---- states --------------------------------------------------------------------
+static void title(void)
+{
+    state = ST_TITLE;
+    level_reset();
+    actors_reset();
+    camx = 0;
+    view_cut();
+    player_reset(start_x, start_y);
+    pinvuln = 0xff;                 // hidden on the title
+    hud_clear();
+    put_text(21, 7, "c64-kb platformer starter");
+    hud_hiscore();
+    put_text(24, 0, "press fire");
+}
+
+// A level from its start: the first, or again after the flag.
+static void level_start(void)
+{
+    goal_reached = false;
+    level_reset();
+    actors_reset();
+    camx = 0;
+    view_cut();
+    player_reset(start_x, start_y);
+    pinvuln = 0;
+    hud_clear();
+    hud_labels();
+    state = ST_PLAY;
+}
+
+static void new_game(void)
+{
+    for (char i = 0; i < 6; i++)
+        score[i] = 0;
+    lives = START_LIVES;
+    coins = stomps = hurts = 0;
+    events = 0;
+    level_start();
+}
+
+// Called by the player (a pit) and the actors (a touch).
+void player_hurt(void)
+{
+    if (state != ST_PLAY)
+        return;
+    lives--;
+    hurts++;
+    hud_dirty = true;
+    events |= EV_HURT;
+    sfx_play(SFX_HURT);
+    anim_set(&panim, an_hurt);
+    pjump = 4;                      // a hop, then down through everything
+    state = ST_DYING;
+    timer = 90;
+}
+
+static void play_frame(char joy, char pressed)
+{
+    PON(1)
+    player_update(joy, pressed);
+    POFF(1)
+    if (state != ST_PLAY)
+        return;
+    PON(2)
+    actors_update();
+    actors_collide();
+    POFF(2)
+    PON(3)
+    view_follow();
+    POFF(3)
+    if (goal_reached)
+    {
+        score_add(10, 0);           // 1,000 for the flag
+        put_text(21, 14, "level clear");
+        state = ST_CLEAR;
+        timer = 120;
+    }
+}
+
+static void dying_frame(void)
+{
+    char fy = py >> 8;
+    if (fy < 220)                   // the death hop, through the level
+    {
+        py += vy_tab[pjump];
+        if (pjump < JUMP_LEN - 1)
+            pjump++;
+    }
+    if (--timer)
+        return;
+    if (lives == 0)
+    {
+        put_text(21, 15, "game over");
+        state = ST_OVER;
+        timer = 150;
+        return;
+    }
+    player_reset(safe_x, safe_y);
+    pinvuln = 120;
+    events |= EV_RESPAWN;
+    state = ST_PLAY;
+}
+
+static void end_game(void)
+{
+    for (char i = 0; i < 6; i++)
+    {
+        if (score[i] != hiscore[i])
+        {
+            if (score[i] > hiscore[i])
+                for (char j = 0; j < 6; j++)
+                    hiscore[j] = score[j];
+            break;
+        }
+    }
+    title();
+}
+
+#if AUTOPILOT
+#include "verdict.h"
+#endif
+
+int main(void)
+{
+    __asm { sei }                   // the split IRQ is the only interrupt
+    cia1.pra = 0xff;                // no keyboard column selected: $DC00 reads port 2
+#if !AUTOPILOT && defined(JOY_SOURCE)
+    *(volatile char *)JOY_SOURCE = 0xff;    // nothing pressed until the monitor says so
+#endif
+    art_build();                    // leaves $01 = $35: BASIC and KERNAL out
+    __asm { jsr ASM_MUSIC_INIT }
+    view_init();                    // bank 3, colours, the split IRQ; CLI
+    meter_init((unsigned)HUDPAGE, 24, 20, VCOL_WHITE, PLAY_HOLD);
+    for (char i = 0; i < 6; i++)
+        hiscore[i] = 0;
+    prev_joy = 0xff;
+    title();
+
+    for (;;)
+    {
+        wait_sync();
+#if AUTOPILOT
+        autopilot_blank();          // the camera of the picture now drawn, on the HUD
+#endif
+        metering = state == ST_PLAY;
+        char ticks = BLANK_TICKS;
+        if (metering && !PROF)
+            METER_START;
+
+        PON(4)
+        view_apply();
+        __asm { jsr ASM_MUSIC_PLAY }
+        sfx_update();
+        POFF(4)
+
+        char joy = port_read();
+        char pressed = prev_joy & ~joy;
+        prev_joy = joy;
+        switch (state)
+        {
+        case ST_TITLE:
+            if (pressed & JOY_FIRE)
+                new_game();
+            break;
+        case ST_PLAY:
+            play_frame(joy, pressed);
+            break;
+        case ST_DYING:
+            dying_frame();
+            break;
+        case ST_OVER:
+        case ST_CLEAR:
+            if (--timer == 0)
+            {
+                if (state == ST_OVER)
+                    end_game();
+                else
+                    level_start();  // the same level again, score and lives kept
+            }
+            break;
+        }
+        PON(5)
+        if (state != ST_TITLE)
+            hud_draw();
+        view_sprites();
+        view_publish();
+        POFF(5)
+
+        if (metering)
+        {
+            if (BLANK_TICKS != ticks)
+                late++;             // this frame's work ran past the next line 251
+            if (PROF)
+                meter_frame();
+            else
+                METER_STOP;             // the frame's own work ends here
+        }
+#if AUTOPILOT
+        autopilot_frame();          // grading is bookkeeping: outside the bracket
+        if (!(frame & 31))
+            meter_print();          // it divides: not every frame
+#endif
+        frame++;
+    }
+    return 0;
+}

package/templates/platformer/src/player.c

@@ -0,0 +1,268 @@
+// player.c: the physics every body shares (walk, fall, land) and the
+// player on top of it. After c64-kb slope_collision (surface_walk, the
+// ground snap, the landing scan) and fixed-point-jump-velocity (one table
+// of 8.8 velocities, entered at 0 for a jump and at the apex for a fall).
+#include "game.h"
+
+// vy_tab[n] = min(-$380 + $24 * (n + 1), $210): launch at 3.5 pixels a
+// frame, gravity $24 a frame, falls capped at 2.06 pixels a frame, under
+// one cell. Arithmetic: a jump rises 42 pixels in 24 frames.
+const int vy_tab[JUMP_LEN] = {
+    -860, -824, -788, -752, -716, -680, -644, -608, -572, -536, -500,
+    -464, -428, -392, -356, -320, -284, -248, -212, -176, -140, -104,
+     -68,  -32,    4,   40,   76,  112,  148,  184,  220,  256,  292,
+     328,  364,  400,  436,  472,  508,  528,  528,  528,  528,  528
+};
+
+#define RUN_SUB 0x80                // 1.5 pixels a frame: 1, then 2, then 1 ...
+
+unsigned px, py;
+char pjump, psub, pdrop, pinvuln;
+bool pground, pleft;
+struct Anim panim;
+unsigned safe_x;
+char safe_y;
+
+// Ground row for a body whose feet were on fy, moved to column x: the cell
+// the feet are in, one up if that is ground too (walking up into the next
+// slope cell), one down if it is air (walking down). 0xff: no ground.
+char surface_walk(unsigned x, char fy)
+{
+    unsigned col = x >> 3;
+    char row = fy >> 3;
+    char a = cell_attr(col, row);
+    if (a & A_GROUND)
+    {
+        char b = cell_attr(col, row - 1);
+        if (b & A_GROUND)
+        {
+            a = b;
+            row--;
+        }
+    }
+    else
+    {
+        row++;
+        a = cell_attr(col, row);
+        if (!(a & A_GROUND))
+            return 0xff;
+    }
+    return surface_at(x, row, a);
+}
+
+// A wall cell in column x beside a body standing on fy: probed at the
+// feet, the middle and the head.
+bool wall_at(unsigned x, char fy, char height)
+{
+    unsigned col = x >> 3;
+    return ((cell_attr(col, (char)(fy - 4) >> 3) |
+             cell_attr(col, (char)(fy - (height >> 1)) >> 3) |
+             cell_attr(col, (char)(fy - height + 1) >> 3)) & A_WALL) != 0;
+}
+
+// One pixel sideways on the ground.
+char ground_step(unsigned *x, unsigned *y, signed char dx, char height)
+{
+    unsigned nx = *x + dx;
+    char fy = *y >> 8;
+    if (wall_at(dx > 0 ? nx + BODY_HALF : nx - BODY_HALF, fy, height))
+        return 1;
+    char s = surface_walk(nx, fy);
+    if (s != 0xff && s < fy && fy - s > MAX_RISE)
+        return 1;                           // too steep: a wall
+    *x = nx;
+    if (s != 0xff && (s <= fy || s - fy <= MAX_SNAP))
+    {
+        *y = (unsigned)s << 8;              // ground snap, up or down
+        return 0;
+    }
+    return 2;                               // off an edge
+}
+
+// One frame in the air. Rising, a wall cell over the head ends the rise;
+// falling, the first ground surface crossed in this column is a landing.
+// `drop` ignores one-way ledges (dropping through one).
+bool air_step(unsigned x, unsigned *y, char *jump, char height, bool drop)
+{
+    int vy = vy_tab[*jump];
+    if (*jump < JUMP_LEN - 1)
+        (*jump)++;
+    char fy = *y >> 8;
+    unsigned ny_fp = *y + vy;
+    char ny = ny_fp >> 8;
+    unsigned col = x >> 3;
+    if (vy < 0)
+    {
+        char head = (char)(ny - height) >> 3;
+        if ((cell_attr((x - BODY_HALF) >> 3, head) | cell_attr((x + BODY_HALF) >> 3, head)) & A_WALL)
+        {
+            *jump = JUMP_APEX;              // head bump: start falling
+            return false;
+        }
+        *y = ny_fp;
+        return false;
+    }
+    for (char row = fy >> 3; row <= (ny >> 3); row++)
+    {
+        char a = cell_attr(col, row);
+        if ((a & A_GROUND) && !(drop && (a & A_DROP)))
+        {
+            char s = surface_at(x, row, a);
+            if (s >= fy && s <= ny)
+            {
+                *y = (unsigned)s << 8;
+                return true;
+            }
+        }
+    }
+    *y = ny_fp;
+    return false;
+}
+
+void player_reset(unsigned x, char y)
+{
+    px = x;
+    py = (unsigned)y << 8;
+    psub = 0;
+    pjump = JUMP_APEX;
+    pground = false;
+    pleft = false;
+    pdrop = 0;
+    safe_x = x;
+    safe_y = y;
+    panim.seq = nullptr;
+    anim_set(&panim, an_jump);
+}
+
+// A coin or the goal in the cell at (x, y).
+static void touch(unsigned x, char y)
+{
+    unsigned col = x >> 3;
+    char row = y >> 3;
+    char a = cell_attr(col, row);
+    if ((a & A_COIN) && take_coin(col, row))
+    {
+        view_erase_tile(col, row);
+#if FORCE_FAULT
+        score_add(0, 2);                    // the fault: a coin counts 20, not 10
+#else
+        score_add(0, 1);
+#endif
+        coins++;                            // score_add marked the HUD dirty
+        events |= EV_COIN;
+        sfx_play(SFX_COIN);
+    }
+    if (a & A_GOAL)
+        goal_reached = true;
+}
+
+// One frame. joy is the port byte (active low); pressed the lines that went
+// low this frame (c64-kb joystick_edge_detect).
+void player_update(char joy, char pressed)
+{
+    signed char dir = 0;
+    if (!(joy & JOY_RIGHT))
+        dir = 1;
+    else if (!(joy & JOY_LEFT))
+        dir = -1;
+    if (dir)
+        pleft = dir < 0;
+
+    char fy = py >> 8;
+    if (pground && (pressed & JOY_FIRE))
+    {
+        if (!(joy & JOY_DOWN) && (cell_attr(px >> 3, fy >> 3) & A_DROP))
+        {
+            pdrop = 8;                      // down + fire on a ledge: drop through it
+            py += 0x100;
+        }
+        else
+        {
+            pjump = 0;
+            events |= EV_JUMP;
+            sfx_play(SFX_JUMP);
+        }
+        pground = false;
+        if (pdrop)
+            pjump = JUMP_APEX;
+    }
+
+    // Sideways, one pixel at a time, so no step skips a wall or a slope cell.
+    char steps = 0;
+    if (dir)
+    {
+        unsigned s = psub + RUN_SUB;
+        psub = s & 0xff;
+        steps = 1 + (s >> 8);
+    }
+    bool moved = false;
+    while (steps--)
+    {
+        if (pground)
+        {
+            char r = ground_step(&px, &py, dir, BODY_H);
+            if (r == 1)
+            {
+                events |= EV_BLOCKED;
+                break;
+            }
+            moved = true;
+            if (r == 2)
+            {
+                pground = false;            // walked off an edge: fall from the apex
+                pjump = JUMP_APEX;
+            }
+        }
+        else
+        {
+            unsigned nx = px + dir;
+            if (wall_at(dir > 0 ? nx + BODY_HALF : nx - BODY_HALF, py >> 8, BODY_H))
+                break;
+            px = nx;
+        }
+    }
+    if (px < 8)
+        px = 8;
+    else if (px > LEVEL_CW * 8 - 8)
+        px = LEVEL_CW * 8 - 8;
+
+    if (!pground && air_step(px, &py, &pjump, BODY_H, pdrop != 0))
+    {
+        pground = true;
+        events |= EV_LAND;
+        if (cell_attr(px >> 3, (char)(py >> 8) >> 3) & A_DROP)
+            events |= EV_LEDGE;
+    }
+    if (pdrop)
+        pdrop--;
+    if (pinvuln)
+        pinvuln--;
+
+    fy = py >> 8;
+    if (pground)
+    {
+        char a = cell_attr(px >> 3, fy >> 3);
+        if (a & A_SLOPE)
+            events |= EV_SLOPE;
+        else if (!(a & A_DROP) && !(cell_attr((px - 8) >> 3, fy >> 3) & A_SLOPE) &&
+                 (cell_attr((px - 8) >> 3, fy >> 3) & A_GROUND) && (cell_attr((px + 8) >> 3, fy >> 3) & A_GROUND) &&
+                 !enemy_near(px, 64))
+        {
+            safe_x = px;                    // flat ground both sides, no enemy near: a respawn point
+            safe_y = fy;
+        }
+    }
+    touch(px, fy - 6);
+    touch(px, fy - 14);
+
+    if (!pground)
+        anim_set(&panim, pjump >= JUMP_APEX ? an_fall : an_jump);
+    else if (moved)
+        anim_set(&panim, an_run);
+    else
+        anim_set(&panim, an_stand);
+    anim_step(&panim);
+
+    if (fy > 200 && fy < 240)
+        player_hurt();                      // fell into a pit
+}

package/templates/platformer/src/sound.c

@@ -0,0 +1,42 @@
+// sound.c: sound effects on SID voice 3, which the tune never touches
+// (c64-kb sfx_engine_beside_music). An effect is a waveform, a start pitch
+// and a pitch slide a frame; sfx_update runs once a frame after the tune.
+#include "game.h"
+#include <c64/sid.h>
+
+struct Effect { char freq_hi, wave, frames, attdec, susrel; signed char slide; };
+
+static const struct Effect effect[] = {
+    { 0x10, SID_CTRL_RECT, 10, 0x00, 0x90,  3 },    // jump: a rising square
+    { 0x38, SID_CTRL_TRI,   8, 0x00, 0x90,  6 },    // coin: a quick high chirp
+    { 0x0c, SID_CTRL_NOISE, 8, 0x00, 0x90, -1 },    // stomp: a noise thump
+    { 0x28, SID_CTRL_SAW,  40, 0x00, 0xa0, -1 },    // hurt: a falling saw
+};
+
+static char sfx_left, sfx_hi, sfx_wave;
+static signed char sfx_slide;
+
+void sfx_play(char id)
+{
+    const struct Effect *e = &effect[id];
+    sid.voices[2].ctrl = 0;                     // gate off: the new effect restarts the envelope
+    sid.voices[2].freq = (unsigned)e->freq_hi << 8;
+    sid.voices[2].pwm = 0x0800;
+    sid.voices[2].attdec = e->attdec;
+    sid.voices[2].susrel = e->susrel;
+    sid.voices[2].ctrl = e->wave | SID_CTRL_GATE;
+    sfx_left = e->frames;
+    sfx_hi = e->freq_hi;
+    sfx_wave = e->wave;
+    sfx_slide = e->slide;
+}
+
+void sfx_update(void)
+{
+    if (!sfx_left)
+        return;
+    sfx_hi += sfx_slide;
+    sid.voices[2].freq = (unsigned)sfx_hi << 8;
+    if (--sfx_left == 0)
+        sid.voices[2].ctrl = sfx_wave;          // gate off: release
+}