c64-kb 0.17.0

package/templates/beat-em-up/src/art.c

@@ -0,0 +1,344 @@
+// art.c: every picture in the game, as text, turned into glyphs and sprite
+// blocks at start-up; the pose table that puts two blocks together into a
+// fighter (c64-kb multi_sprite_object); the hurt and hit boxes
+// (per_frame_hitbox). Original art. tools/flickercheck.py reads the
+// SPRITE-ART block and the mirror rule from this file.
+#include "game.h"
+#include <string.h>
+
+// Street glyphs, multicolour: four double-width pixels a row.
+// '.' $D021 grey, 'b' $D022 brown, 'k' colour RAM (the blue sky: rows 0-1
+// only). Every glyph used on rows 2-19 is '.' and 'b' alone, background
+// to the VIC's sprite priority, so $D01B hides a sprite behind the brute
+// and behind nothing else (game.h, the colours).
+static const char glyph_code[] = {
+    CH_SKY, CH_ROOF, CH_BRICK, CH_WIN_T, CH_WIN_B, CH_DOOR, CH_SIGN,
+    CH_PAVE, CH_KERB, CH_ROAD, CH_DASH, CH_LAMP, CH_POLE, CH_ALLEY
+};
+static const char glyph_art[][8][5] = {
+    { "kkkk", "kkkk", "kkkk", "kkkk", "kkkk", "kkkk", "kkkk", "kkkk" },   // sky (rows 0-1)
+    { "kkkk", "kkkk", "kkkk", "kkkk", "kkkk", "bbbb", "....", "bbbb" },   // roof edge (row 1)
+    { "bbb.", "bbb.", "....", "b.bb", "b.bb", "....", "bbb.", "bbb." },   // brick
+    { "bbbb", "b..b", "b..b", "bbbb", "b..b", "b..b", "b..b", "b..b" },   // window, top
+    { "b..b", "b..b", "bbbb", "bbbb", "....", "bbb.", "bbb.", "...." },   // window, bottom
+    { "b..b", "b..b", "b..b", "b..b", "b.bb", "b..b", "b..b", "b..b" },   // door
+    { "bbbb", "b.b.", "..bb", "bb.b", ".b.b", "bbbb", "....", "bbb." },   // shop sign
+    { "....", "....", "....", "b...", "....", "....", "....", "..b." },   // pavement
+    { "....", "....", "....", "bbbb", "bbbb", "....", "....", "...." },   // kerb
+    { "....", "....", "..b.", "....", "....", "b...", "....", "...." },   // road
+    { "....", "....", "....", "bbbb", "bbbb", "....", "....", "...." },   // centre line
+    { "....", ".bb.", "bbbb", "bbbb", ".bb.", "..b.", "..b.", "..b." },   // lamp
+    { "..b.", "..b.", "..b.", "..b.", "..b.", "..b.", "..b.", "..b." },   // lamp post
+    { "....", "....", "....", "....", "....", "....", "....", "...." },   // alley
+};
+
+// HUD bar glyphs, hires ('x' set): a full cell is two hit points.
+static const char bar_art[3][8][9] = {
+    { "........", "xxxxxxx.", "xxxxxxx.", "xxxxxxx.", "xxxxxxx.", "xxxxxxx.", "xxxxxxx.", "........" },
+    { "........", "xxx.....", "xxx.....", "xxx.....", "xxx.....", "xxx.....", "xxx.....", "........" },
+    { "........", "x.......", "........", "........", "........", "........", "x.......", "........" },
+};
+
+// Sprite blocks: 12 double-width pixels a row, 21 rows, facing right.
+// '.' transparent, 'a' $D025 skin, 'x' the sprite's own colour (a shirt
+// on a top part, trousers on legs), 'b' $D026 black. A fighter's origin
+// is 8 pixels in from a part's left edge (between columns 3 and 4); the
+// body is columns 0-6 and a fist or a foot reaches to column 11.
+// Mirroring reverses the twelve pixels of every row.
+// SPRITE-ART-BEGIN
+static const char sprite_art[][21][13] = {
+    {   // B_T_STAND: head and fists up
+        "..bbbb......", ".bbbbbb.....", ".bbaaab.....", ".baaaba.....", "..aaaaa.....",
+        "..aaaa......", "...aa.......", ".xxxxxx.....", "xxxxxxxaa...", "xxxxxxxaa...",
+        "xxxxxxx.....", "axxxxx......", "aaxxxx......", ".xxxxx......", ".xxxxx......",
+        ".xxxxx......", ".xxxxx......", ".xxxxx......", ".xxxxx......", ".bbbbb......",
+        ".bbbbb......",
+    },
+    {   // B_T_WIND: the fist drawn back
+        "..bbbb......", ".bbbbbb.....", ".bbaaab.....", ".baaaba.....", "..aaaaa.....",
+        "..aaaa......", "...aa.......", ".xxxxxx.....", "xxxxxaa.....", "xxxxxaa.....",
+        "xxxxxxx.....", "axxxxx......", "aaxxxx......", ".xxxxx......", ".xxxxx......",
+        ".xxxxx......", ".xxxxx......", ".xxxxx......", ".xxxxx......", ".bbbbb......",
+        ".bbbbb......",
+    },
+    {   // B_T_PUNCH: the arm out, the fist at columns 10-11
+        "..bbbb......", ".bbbbbb.....", ".bbaaab.....", ".baaaba.....", "..aaaaa.....",
+        "..aaaa......", "...aa.......", ".xxxxxx.....", "xxxxxxxxxxaa", "xxxxxxxxxxaa",
+        "xxxxxx......", "axxxxx......", "aaxxxx......", ".xxxxx......", ".xxxxx......",
+        ".xxxxx......", ".xxxxx......", ".xxxxx......", ".xxxxx......", ".bbbbb......",
+        ".bbbbb......",
+    },
+    {   // B_T_LEAN: leaning back for a kick
+        ".bbbb.......", "bbbbbb......", "bbaaab......", "baaaba......", ".aaaaa......",
+        ".aaaa.......", "..aa........", "xxxxxx......", "xxxxxxaa....", "xxxxxxaa....",
+        "axxxxx......", "aaxxxx......", ".xxxxx......", ".xxxxx......", ".xxxxx......",
+        ".xxxxx......", ".xxxxx......", ".xxxxx......", ".xxxxx......", ".bbbbb......",
+        ".bbbbb......",
+    },
+    {   // B_T_HURT: the head snapped back
+        "bbbb........", "bbbbbb......", "bbaaab......", "baaabaa.....", ".aaaaaa.....",
+        "..aaaa......", "...aa.......", ".xxxxxx.....", "axxxxxxxa...", "axxxxxxxaa..",
+        "..xxxxx..a..", ".xxxxxx.....", ".xxxxxx.....", ".xxxxx......", ".xxxxx......",
+        ".xxxxx......", ".xxxxx......", ".xxxxx......", ".xxxxx......", ".bbbbb......",
+        ".bbbbb......",
+    },
+    {   // B_T_JUMP: arms up
+        "..bbbb..aa..", ".bbbbbb.aa..", ".bbaaabxx...", ".baaabaxx...", "..aaaaaxx...",
+        "..aaaaxx....", "...aaxxx....", "aaxxxxxx....", "aaxxxxx.....", ".xxxxxx.....",
+        ".xxxxxx.....", ".xxxxx......", ".xxxxx......", ".xxxxx......", ".xxxxx......",
+        ".xxxxx......", ".xxxxx......", ".xxxxx......", ".xxxxx......", ".bbbbb......",
+        ".bbbbb......",
+    },
+    {   // B_L_STAND: feet apart
+        ".xxxxx......", ".xxxxx......", ".xxxxxx.....", "xxx.xxx.....", "xx...xx.....",
+        "xx...xx.....", "xx....xx....", "xx....xx....", "xx....xx....", "xx.....xx...",
+        "xx.....xx...", "xx.....xx...", "xx.....xx...", "xx.....xx...", "xx.....xx...",
+        "xx.....xx...", "xx.....xx...", "xx.....xx...", "xx.....xx...", "bbb....bbb..",
+        "bbb....bbbb.",
+    },
+    {   // B_L_WALK1: a long stride
+        ".xxxxx......", ".xxxxx......", ".xxxxxx.....", ".xx..xxx....", ".xx...xxx...",
+        ".xx....xx...", ".xx.....xx..", ".xx.....xx..", ".xx.....xx..", ".xx......xx.",
+        ".xx......xx.", ".xx......xx.", ".xx......xx.", ".xx......xx.", ".xx......xx.",
+        ".xx......xx.", ".xx......xx.", ".xx......xx.", ".xx......xx.", "bbb......bbb",
+        "bbb......bbb",
+    },
+    {   // B_L_WALK2: the legs passing
+        ".xxxxx......", ".xxxxx......", ".xxxxx......", ".xx.xx......", ".xx.xx......",
+        ".xx.xx......", ".xx.xx......", ".xx.xx......", ".xx.xx......", ".xx.xx......",
+        ".xx.xx......", ".xx.xx......", ".xx.xx......", ".xx.xx......", ".xx.xx......",
+        ".xx.xx......", ".xx.xx......", ".xx.xx......", ".xx.xx......", "bbb.bbbb....",
+        "bbb.bbbb....",
+    },
+    {   // B_L_CHAMBER: the knee up
+        ".xxxxx......", ".xxxxxxxx...", ".xxxxxxxxx..", ".xx...xxxx..", ".xx....xxx..",
+        ".xx....xx...", ".xx...bbb...", ".xx...bb....", ".xx.........", ".xx.........",
+        ".xx.........", ".xx.........", ".xx.........", ".xx.........", ".xx.........",
+        ".xx.........", ".xx.........", ".xx.........", ".xx.........", "bbb.........",
+        "bbb.........",
+    },
+    {   // B_L_KICK: the leg out, the foot at column 11
+        ".xxxxx......", ".xxxxxxxxxxb", ".xxxxxxxxxxb", ".xxxxxxxxxxb", ".xx.........",
+        ".xx.........", ".xx.........", ".xx.........", ".xx.........", ".xx.........",
+        ".xx.........", ".xx.........", ".xx.........", ".xx.........", ".xx.........",
+        ".xx.........", ".xx.........", ".xx.........", ".xx.........", "bbb.........",
+        "bbb.........",
+    },
+    {   // B_L_TUCK: knees up in a jump
+        ".xxxxx......", ".xxxxxx.....", ".xxxxxxx....", ".xx..xxx....", "xx....xx....",
+        "xx...bbb....", "xx...bb.....", "bbb.........", "bbb.........", "............",
+        "............", "............", "............", "............", "............",
+        "............", "............", "............", "............", "............",
+        "............",
+    },
+    {   // B_L_KNEEL: one knee down
+        "............", "............", "............", "............", "............",
+        "............", "............", "............", "............", "............",
+        ".xxxxx......", ".xxxxx......", ".xxxxxxxx...", ".xx...xxxx..", ".xx....xx...",
+        ".xx....xx...", ".xx....xx...", ".xx....xx...", "xxx...bbbb..", "xxxxxx......",
+        "bbbbbb......",
+    },
+    {   // B_D_HEAD: lying, the head half
+        "............", "............", "............", "............", "............",
+        "............", "............", "............", "............", "............",
+        "............", "............", "............", "............", "..bbb.......",
+        ".bbaab......", ".baaaaxxxxxx", ".baaaxxxxxxx", "..aa.xxxxxxx", ".....aaxxxxx",
+        "............",
+    },
+    {   // B_D_FEET: lying, the feet half
+        "............", "............", "............", "............", "............",
+        "............", "............", "............", "............", "............",
+        "............", "............", "............", "............", "............",
+        "............", "xbbxxxxxx...", "xbbxxxxxxxb.", "xxxxxxxxxxbb", "xxxx.....xbb",
+        "............",
+    },
+    {   // B_GO: the sign that says the stage is clear
+        "............", ".xxx..xxx...", "x....x...x..", "x.xx.x...x..", "x..x.x...x..",
+        ".xx...xxx...", "............", "......x.....", "......xx....", "xxxxxxxxx...",
+        "xxxxxxxxxx..", "xxxxxxxxx...", "......xx....", "......x.....", "............",
+        "............", "............", "............", "............", "............",
+        "............",
+    },
+    {   // B_FACE_HERO
+        "............", "...bbbbbb...", "..bbbbbbbb..", ".bbbbbbbbbb.", ".xxxxxxxxxx.",
+        ".baaaaaaaab.", ".aaaaaaaaaa.", ".aabbaabbaa.", ".aaaaaaaaaa.", ".aaaaaaaaaa.",
+        "..aaabbaaa..", "..aaaaaaaa..", "...abbbba...", "...aaaaaa...", "....aaaa....",
+        "..xxxxxxxx..", ".xxxxxxxxxx.", "xxxxxxxxxxxx", "xxxxxxxxxxxx", "xxxxxxxxxxxx",
+        "............",
+    },
+    {   // B_FACE_THUG
+        "............", "............", "...aaaaaa...", "..aaaaaaaa..", ".aaaaaaaaaa.",
+        ".abbbaabbba.", ".aaaaaaaaaa.", ".aabaaaabaa.", ".aaaaaaaaaa.", ".aaaabbaaaa.",
+        "..aaaaaaaa..", "..abbbbbba..", "...aaaaaa...", "....aaaa....", "...xxxxxx...",
+        "..xxxxxxxx..", ".xxxxxxxxxx.", "xxxxxxxxxxxx", "xxxxxxxxxxxx", "xxxxxxxxxxxx",
+        "............",
+    },
+    {   // B_FACE_BRUTE
+        ".....bb.....", "....bbbb....", "...abbbba...", "..aaabbaaa..", ".aaaaaaaaaa.",
+        ".abbaaaabba.", ".aaaaaaaaaa.", ".aaaaaaaaaa.", ".aaaabbaaaa.", ".abbbbbbbba.",
+        ".abbaaaabba.", "..bbbbbbbb..", "...bbbbbb...", "....aaaa....", "...xxxxxx...",
+        "..xxxxxxxx..", ".xxxxxxxxxx.", "xxxxxxxxxxxx", "xxxxxxxxxxxx", "xxxxxxxxxxxx",
+        "............",
+    },
+};
+// SPRITE-ART-END
+// sprite_art[i] is block i for i < B_FIGHTER_COUNT, then B_GO and the faces.
+
+// The brute, drawn in character cells (brute.c): 16 double-width pixels by
+// 48 lines, feet on the last. '.' shows the street, 'b' $D022 brown (hair,
+// beard, belt, boots), 's' $D023 skin, 'x' colour RAM, his body. One
+// picture serves both facings. Stand, slam (both fists up: every attack),
+// down.
+// BRUTE-ART-BEGIN
+const char brute_art[3][48][17] = {
+    {   // stand
+        ".......bb.......", "......bbbb......", "......ssss......", ".....ssssss.....",
+        ".....sbssbs.....", ".....ssssss.....", ".....sbbbbs.....", "......bbbb......",
+        ".......ss.......", "....xxxxxxxx....", "...xxxxxxxxxx...", "..sxxxxxxxxxxs..",
+        ".ssxxxxxxxxxxss.", ".ssxxxxxxxxxxss.", ".ss.xxxxxxxx.ss.", ".ss.xxxxxxxx.ss.",
+        ".ss.xxxxxxxx.ss.", ".ss.xxxxxxxx.ss.", ".ss.xxxxxxxx.ss.", ".ss.xxxxxxxx.ss.",
+        ".ss.xxxxxxxx.ss.", "..s.xxxxxxxx.s..", "....xxxxxxxx....", "....xxxxxxxx....",
+        "....bbbbbbbb....", "....bbbbbbbb....", "....xxxxxxxx....", "....xxxx.xxx....",
+        "....xxx..xxx....", "....xxx..xxx....", "....xxx..xxx....", "....xxx..xxx....",
+        "....xxx..xxx....", "....xxx..xxx....", "....xxx..xxx....", "....xxx..xxx....",
+        "....xxx..xxx....", "....xxx..xxx....", "....xxx..xxx....", "....xxx..xxx....",
+        "....xxx..xxx....", "....xxx..xxx....", "....xxx..xxx....", "....xxx..xxx....",
+        "....xxx..xxx....", "....xxx..xxx....", "...bbbb..bbbb...", "...bbbb..bbbb...",
+    },
+    {   // slam
+        ".......bb.......", ".ss...bbbb...ss.", ".ss...ssss...ss.", ".ss..ssssss..ss.",
+        ".ss..sbssbs..ss.", ".ss..ssssss..ss.", ".ss..sbbbbs..ss.", ".sss..bbbb..sss.",
+        "..ss...ss...ss..", "..sxxxxxxxxxxs..", "...xxxxxxxxxx...", "...xxxxxxxxxx...",
+        "...xxxxxxxxxx...", "...xxxxxxxxxx...", "....xxxxxxxx....", "....xxxxxxxx....",
+        "....xxxxxxxx....", "....xxxxxxxx....", "....xxxxxxxx....", "....xxxxxxxx....",
+        "....xxxxxxxx....", "....xxxxxxxx....", "....xxxxxxxx....", "....xxxxxxxx....",
+        "....bbbbbbbb....", "....bbbbbbbb....", "....xxxxxxxx....", "....xxxx.xxx....",
+        "....xxx..xxx....", "....xxx..xxx....", "...xxx...xxx....", "...xxx....xxx...",
+        "...xxx....xxx...", "...xxx....xxx...", "..xxx.....xxx...", "..xxx......xxx..",
+        "..xxx......xxx..", "..xxx......xxx..", "..xxx......xxx..", "..xxx......xxx..",
+        "..xxx......xxx..", "..xxx......xxx..", "..xxx......xxx..", "..xxx......xxx..",
+        "..xxx......xxx..", "..xxx......xxx..", ".bbbb......bbbb.", ".bbbb......bbbb.",
+    },
+    {   // down
+        "................", "................", "................", "................",
+        "................", "................", "................", "................",
+        "................", "................", "................", "................",
+        "................", "................", "................", "................",
+        "................", "................", "................", "................",
+        "................", "................", "................", "................",
+        "................", "................", "................", "................",
+        "................", "................", "................", "................",
+        "................", "................", "................", "................",
+        "................", "................", "................", "..bb............",
+        ".bssbxxxxxxx.bb.", "bsbsxxxxxxxxxbbb", "bsssxxxxxxxxxbbb", ".bssbxxxxbbxx.bb",
+        "..ss.xxxxxxxx...", "................", "................", "................",
+    },
+};
+// BRUTE-ART-END
+
+// POSES-BEGIN
+const struct Part pose_part[P_COUNT][2] = {
+    { { B_T_STAND, -8, -42 }, { B_L_STAND,   -8, -21 } },    // P_STAND
+    { { B_T_STAND, -8, -42 }, { B_L_WALK1,   -8, -21 } },    // P_WALK1
+    { { B_T_STAND, -8, -42 }, { B_L_WALK2,   -8, -21 } },    // P_WALK2
+    { { B_T_WIND,  -8, -42 }, { B_L_STAND,   -8, -21 } },    // P_WIND
+    { { B_T_PUNCH, -8, -42 }, { B_L_STAND,   -8, -21 } },    // P_PUNCH
+    { { B_T_LEAN,  -8, -42 }, { B_L_CHAMBER, -8, -21 } },    // P_CHAMBER
+    { { B_T_LEAN,  -8, -42 }, { B_L_KICK,    -8, -21 } },    // P_KICK
+    { { B_T_JUMP,  -8, -42 }, { B_L_TUCK,    -8, -21 } },    // P_JUMP
+    { { B_T_LEAN,  -8, -42 }, { B_L_KICK,    -8, -21 } },    // P_JKICK
+    { { B_T_HURT,  -8, -42 }, { B_L_STAND,   -8, -21 } },    // P_HURT
+    { { B_D_HEAD, -32, -21 }, { B_D_FEET,    -8, -21 } },    // P_DOWN
+    { { B_T_STAND, -8, -32 }, { B_L_KNEEL,   -8, -21 } },    // P_KNEEL
+};
+// POSES-END
+
+// Hurt boxes: the body, columns 0-6 of a part (x -8 to +5), feet to the
+// top of the head. Lying down has none: a fighter on the ground cannot be
+// hit. Kneeling is 10 pixels lower.
+const struct Box hurt_box[P_COUNT] = {
+    { -7, 5, 0, 40 }, { -7, 5, 0, 40 }, { -7, 5, 0, 40 }, { -7, 5, 0, 40 },
+    { -7, 5, 0, 40 }, { -7, 5, 0, 40 }, { -7, 5, 0, 40 }, { -7, 5, 0, 40 },
+    { -7, 5, 0, 40 }, { -7, 5, 0, 40 }, {  0, 0, 0,  0 }, { -7, 5, 0, 30 },
+};
+
+// Hit boxes, on attack frames only (anim.c): the fist at columns 10-11 of
+// the top part (heights 32-33), the foot at column 11 of the legs
+// (heights 17-19), with a margin of 2.
+const struct Box hit_box[HB_COUNT] = {
+    { 0, 0, 0, 0 },                 // HB_NONE
+    { 6, 16, 30, 35 },              // HB_PUNCH
+    { 6, 16, 15, 21 },              // HB_KICK
+    { 6, 16, 15, 21 },              // HB_JKICK: plus the jumper's height
+};
+
+static char mc_glyph(char c)
+{
+    return c == 'b' ? 1 : c == 'y' ? 2 : c == 'k' ? 3 : 0;
+}
+
+static char mc_sprite(char c)
+{
+    return c == 'a' ? 1 : c == 'x' ? 2 : c == 'b' ? 3 : 0;
+}
+
+// One block from its text; mirrored: the twelve pixels in reverse order.
+static void sprite_block(char *d, const char (*art)[13], bool mirror)
+{
+    for (char r = 0; r < 21; r++)
+    {
+        const char *row = art[r];
+        for (char k = 0; k < 3; k++)
+        {
+            char b = 0;
+            for (char p = 0; p < 4; p++)
+            {
+                char c = k * 4 + p;
+                b = (b << 2) | mc_sprite(row[mirror ? 11 - c : c]);
+            }
+            d[r * 3 + k] = b;
+        }
+    }
+    d[63] = 0;
+}
+
+void art_build(void)
+{
+    // The ROM's upper-case glyphs 0-63, for text and the meter. Bank 3 has
+    // no ROM font (c64-kb vic_bank_visibility_collision), so copy it.
+    memset(CHARSET, 0, 2048);
+    *(volatile char *)1 = 0x33;                 // character ROM in at $D000
+    for (unsigned i = 0; i < 512; i++)
+        CHARSET[i] = ((char *)0xd000)[i];
+    *(volatile char *)1 = 0x35;                 // I/O back; BASIC and KERNAL stay out
+
+    for (char i = 0; i < sizeof(glyph_code); i++)
+    {
+        char *g = CHARSET + glyph_code[i] * 8;
+        for (char r = 0; r < 8; r++)
+        {
+            const char *row = glyph_art[i][r];
+            g[r] = (mc_glyph(row[0]) << 6) | (mc_glyph(row[1]) << 4) | (mc_glyph(row[2]) << 2) | mc_glyph(row[3]);
+        }
+    }
+    for (char i = 0; i < 3; i++)
+    {
+        char *g = CHARSET + (CH_BAR_FULL + i) * 8;
+        for (char r = 0; r < 8; r++)
+        {
+            char b = 0;
+            for (char c = 0; c < 8; c++)
+                b = (b << 1) | (bar_art[i][r][c] == 'x');
+            g[r] = b;
+        }
+    }
+
+    // Fighter blocks and their mirrored twins, then the sign and the faces.
+    for (char i = 0; i < B_FIGHTER_COUNT; i++)
+    {
+        sprite_block(SPRMEM + i * 64, sprite_art[i], false);
+        sprite_block(SPRMEM + (i + B_MIRROR) * 64, sprite_art[i], true);
+    }
+    for (char i = 0; i < B_COUNT - B_GO; i++)
+        sprite_block(SPRMEM + (B_GO + i) * 64, sprite_art[B_FIGHTER_COUNT + i], false);
+}

package/templates/beat-em-up/src/autopilot.h

@@ -0,0 +1,154 @@
+// autopilot.h: the joystick for AUTOPILOT builds, a bot that reads the
+// game's state (c64-kb headless-verify's synthetic port byte, computed
+// instead of scripted: a changed wave or AI still gets played through).
+// Active low, as $DC00 reads it. Included by main.c only.
+//
+// On the title it presses fire. In play it picks the nearest enemy on the
+// screen that can be hit, lines up in his lane, closes to punch range and
+// attacks in a fixed pattern: punch, punch, punch (the third knocks down),
+// kick, jump kick. When the stage is clear it walks right. In stage 2,
+// from its first wave until a life is lost, it stands still and takes the
+// blows, so the knock-down, the KO and the respawn run.
+#define AP_IDLE  0xff
+#ifndef AP_GIVE_UP
+#define AP_GIVE_UP 0                // 1 (make gameover): never fight; three lives go, GAME OVER shows
+#endif
+
+static const char ap_pattern[] = { A_PUNCH, A_PUNCH, A_PUNCH, A_KICK, A_JUMP };
+static char ap_move, ap_last;
+static bool ap_cross;               // the one cross-lane punch has been thrown
+static unsigned ap_frames;
+
+// Which 255 play frames the meter records (-dMETER_WINDOW=n), each from a
+// point the run reaches, so every window is 255 play frames of the run:
+// 0, the default: from the second stage's lock: the brute in characters,
+//    two thugs, the hero's KO (the run's worst window, measured: README.md);
+// 1: from the third stage's lock: three thugs, eight sprites in the band;
+// 2: from the first stage clear, the walk: every frame scrolls;
+// 3: from the first stage's lock: two thugs, then the brute;
+// 4: every play frame, for the whole run's worst (main.c, run_worst; the
+//    meter itself still records only the first 255).
+#ifndef METER_WINDOW
+#define METER_WINDOW 0
+#endif
+static bool ap_recording(void)
+{
+    switch (METER_WINDOW)
+    {
+    case 1:  return locks >= 3;
+    case 2:  return (events & EV_UNLOCK) != 0;
+    case 3:  return locks >= 1;
+    case 4:  return true;
+    default: return locks >= 2;
+    }
+}
+
+static bool ap_target_ok(char f)
+{
+    char m = fmode[f];
+    return (m == M_FREE || m == M_ATTACK || m == M_HURT || m == M_JUMP) &&
+           fx[f] > camx + 8 && fx[f] < camx + 312;
+}
+
+static char ap_nearest(void)
+{
+    char best = 0;
+    unsigned bd = 0xffff;
+    for (char f = 1; f < NFIGHT; f++)
+    {
+        if (!ap_target_ok(f))
+            continue;
+        int d = (int)fx[f] - (int)fx[0];
+        unsigned a = (d < 0 ? -d : d) + (fy[f] > fy[0] ? fy[f] - fy[0] : fy[0] - fy[f]) * 2;
+        if (a < bd)
+        {
+            bd = a;
+            best = f;
+        }
+    }
+    return best;
+}
+
+static char ap_fight(void)
+{
+    char out = AP_IDLE;
+    if (fmode[0] == M_JUMP)
+        return farc[0] == ARC_JUMP + 5 ? AP_IDLE ^ JOY_FIRE : AP_IDLE;   // the kick, early in the arc
+    if (fmode[0] != M_FREE)
+        return AP_IDLE;
+    char t = ap_nearest();
+    if (!t)
+        return stage_clear ? AP_IDLE ^ JOY_RIGHT : AP_IDLE;
+    // Once, the lane gate on purpose: a punch at an enemy 9 to 17 lines
+    // away, close enough in x that the boxes touch on the screen. fighter.c
+    // must call it a miss (EV_LANE_MISS); the verdict wants that event.
+    if (!ap_cross)
+    {
+        for (char f = 1; f < NFIGHT; f++)
+        {
+            char d = fy[f] > fy[0] ? fy[f] - fy[0] : fy[0] - fy[f];
+            if (ap_target_ok(f) && d > WIN + 2 && d < 3 * WIN)
+            {
+                int cx = (int)fx[f] - (int)fx[0];
+                int acx = cx < 0 ? -cx : cx;
+                bool fc = (cx < 0) == (fface[0] == FACE_LEFT);
+                if (acx > 16)
+                    return AP_IDLE ^ (cx < 0 ? JOY_LEFT : JOY_RIGHT);
+                if (acx < 10)
+                    return AP_IDLE ^ (cx < 0 ? JOY_RIGHT : JOY_LEFT);
+                if (!fc)
+                    return AP_IDLE ^ (cx < 0 ? JOY_LEFT : JOY_RIGHT);
+                if (!(ap_last & JOY_FIRE))
+                    return AP_IDLE;
+                ap_cross = true;
+                return AP_IDLE ^ JOY_FIRE;
+            }
+        }
+    }
+    int dx = (int)fx[t] - (int)fx[0];
+    int ady = fy[t] > fy[0] ? fy[t] - fy[0] : fy[0] - fy[t];
+    int adx = dx < 0 ? -dx : dx;
+    char toward = dx < 0 ? JOY_LEFT : JOY_RIGHT;
+    char away = dx < 0 ? JOY_RIGHT : JOY_LEFT;
+    bool facing = (dx < 0) == (fface[0] == FACE_LEFT);
+
+    if (ady > 2)
+    {
+        out ^= fy[t] > fy[0] ? JOY_DOWN : JOY_UP;
+        if (adx < 12)
+            out ^= away;                    // not in reach while crossing lanes
+    }
+    else if (adx > 18)
+        out ^= toward;
+    else if (adx < 8)
+        out ^= away;
+    else if (!facing)
+        out ^= toward;
+    else if (ap_last & JOY_FIRE)            // released last frame: press now
+    {
+        char m = ap_pattern[ap_move];
+        ap_move = ap_move + 1 < sizeof(ap_pattern) ? ap_move + 1 : 0;
+        out ^= JOY_FIRE;
+        if (m == A_KICK)
+            out ^= toward;
+        else if (m == A_JUMP)
+            out ^= JOY_UP ^ toward;
+    }
+    return out;
+}
+
+static char autopilot_port(void)
+{
+    char out = AP_IDLE;
+    ap_frames++;
+    if (state == ST_TITLE)
+        out = ap_frames == 20 ? AP_IDLE ^ JOY_FIRE : AP_IDLE;
+    else if (state == ST_PLAY && !AP_GIVE_UP)
+    {
+        bool take_blows = stage == 1 && wave >= 1 && !(events & EV_LIFE_LOST);
+        if (!take_blows)
+            out = ap_fight();
+    }
+    ap_last = out;
+    return out;
+}