c64-kb 0.17.0

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

@@ -0,0 +1,384 @@
+// fighter.c: what every fighter shares, player or enemy. A fighter is an
+// origin (foot column fx, ground line fy, height fh), a mode, and an
+// animation; view.c turns the pose into two sprites. Hits follow c64-kb
+// lane_depth_engine: the ground lines within WIN first (one byte compare,
+// fails for most pairs), then the attack frame's hit box against the
+// target's hurt box (per_frame_hitbox), with x mirrored by facing.
+#include "game.h"
+
+char fmode[NFIGHT], fkind[NFIGHT], fface[NFIGHT], fhp[NFIGHT], ftimer[NFIGHT];
+unsigned fx[NFIGHT];
+char fy[NFIGHT], fh[NFIGHT], farc[NFIGHT];
+signed char fvx[NFIGHT];
+char fcombo[NFIGHT];
+bool flanded[NFIGHT];
+struct Anim fanim[NFIGHT];
+char finvuln[NFIGHT];
+static char fstep[NFIGHT];          // walk frames, for the half-speed depth move
+static bool fjkicked[NFIGHT];       // this jump has already kicked
+
+// Heights by frame (jump_arc_table): a jump from ARC_JUMP, 24 frames, 18
+// pixels at the top; a knock-down flight from ARC_FLY, 12 frames. $FF ends
+// an arc: the fighter is on the ground again. 18 is the most a top part
+// may rise: from ground line 150 its first line is 91, after the fighter
+// band's IRQ at line 76 has finished (engine.asm).
+const char arc[] = {
+    0, 3, 6, 8, 10, 12, 14, 15, 16, 17, 18, 18, 18, 18, 17, 16, 15, 14, 12, 10, 8, 6, 3, 0xff,
+    0, 0,
+    0, 3, 5, 7, 8, 9, 9, 8, 7, 5, 3, 0xff,
+};
+
+// Damage by hit box, and the knock-down rule: a kick, a jump kick, the third
+// punch in a row, or the last hit point.
+static const char damage[HB_COUNT] = { 0, 2, 3, 4 };
+
+void fighter_spawn(char f, char kind, unsigned x, char y, char face)
+{
+    fkind[f] = kind;
+    fx[f] = x;
+    fy[f] = y;
+    fh[f] = 0;
+    fface[f] = face;
+    fmode[f] = M_FREE;
+    fhp[f] = kind == K_HERO ? HP_HERO : kind == K_THUG ? HP_THUG : HP_BRUTE;
+    fcombo[f] = 0;
+    finvuln[f] = 0;
+    flanded[f] = false;
+    anim_start(&fanim[f], an_stand);
+}
+
+bool fighter_can_act(char f)
+{
+    return fmode[f] == M_FREE;
+}
+
+// A step in x (a pixel) and in depth (a line every other step): the depth
+// move is slower, as a street seen from the side is foreshortened.
+void fighter_walk(char f, signed char dx, signed char dy)
+{
+    if (fmode[f] != M_FREE)
+        return;
+    if (dx || dy)
+    {
+        fx[f] += dx;
+        if (dx)
+            fface[f] = dx < 0 ? FACE_LEFT : FACE_RIGHT;
+        if (dy && (++fstep[f] & 1))
+        {
+            char y = fy[f] + dy;
+            if (y >= PLANE_TOP && y <= PLANE_BOT)
+            {
+                fy[f] = y;
+                events |= EV_DEPTH;
+            }
+        }
+        anim_set(&fanim[f], an_walk);
+    }
+    else
+        anim_set(&fanim[f], an_stand);
+}
+
+void fighter_attack(char f, char move)
+{
+    if (fmode[f] == M_JUMP)
+    {
+        if (!fjkicked[f])                   // one kick a jump
+        {
+            fjkicked[f] = true;
+            flanded[f] = false;
+            anim_start(&fanim[f], an_jkick);
+            sfx_play(SFX_SWING);
+        }
+        return;
+    }
+    if (fmode[f] != M_FREE)
+        return;
+    flanded[f] = false;
+    if (move == A_JUMP)
+    {
+        fmode[f] = M_JUMP;
+        farc[f] = ARC_JUMP;
+        fjkicked[f] = false;
+        anim_start(&fanim[f], an_jump);
+        sfx_play(SFX_JUMP);
+        return;
+    }
+    fmode[f] = M_ATTACK;
+    anim_start(&fanim[f], move == A_PUNCH ? an_punch : an_kick);
+    sfx_play(SFX_SWING);
+}
+
+// Keep a fighter on the screen while he flies or is pushed.
+static void keep_on_screen(char f)
+{
+    if (fx[f] < camx + 12)
+        fx[f] = camx + 12;
+    else if (fx[f] > camx + 300)
+        fx[f] = camx + 300;
+}
+
+// One step along an arc; true when it has landed.
+static bool arc_step(char f)
+{
+    char h = arc[++farc[f]];
+    if (h == 0xff)
+    {
+        fh[f] = 0;
+        return true;
+    }
+    fh[f] = h;
+    fx[f] += fvx[f];
+    return false;
+}
+
+static void step_one(char f)
+{
+    anim_step(&fanim[f]);
+    if (finvuln[f])
+        finvuln[f]--;
+    switch (fmode[f])
+    {
+    case M_ATTACK:
+        if (anim_done(&fanim[f]))
+        {
+            fmode[f] = M_FREE;
+            anim_start(&fanim[f], an_stand);
+        }
+        break;
+    case M_JUMP:
+        if (arc_step(f))
+        {
+            fmode[f] = M_FREE;
+            anim_start(&fanim[f], an_stand);
+        }
+        break;
+    case M_HURT:
+        if (ftimer[f])
+        {
+            ftimer[f]--;
+            fx[f] += fvx[f];
+            keep_on_screen(f);
+        }
+        if (anim_done(&fanim[f]))
+        {
+            fmode[f] = M_FREE;
+            anim_start(&fanim[f], an_stand);
+        }
+        break;
+    case M_FLY:
+        if (arc_step(f))
+        {
+            anim_start(&fanim[f], an_down);
+            if (fhp[f] == 0)
+            {
+                fmode[f] = M_KO;
+                ftimer[f] = 60;
+                sfx_play(SFX_KO);
+            }
+            else
+            {
+                fmode[f] = M_DOWN;
+                ftimer[f] = 40;
+            }
+        }
+        keep_on_screen(f);
+        break;
+    case M_DOWN:
+        if (--ftimer[f] == 0)
+        {
+            fmode[f] = M_KNEEL;
+            anim_start(&fanim[f], an_kneel);
+        }
+        break;
+    case M_KNEEL:
+        if (anim_done(&fanim[f]))
+        {
+            fmode[f] = M_FREE;
+            anim_start(&fanim[f], an_stand);
+            if (f)
+                events |= EV_GETUP;
+        }
+        break;
+    case M_KO:
+        if (--ftimer[f] == 0)
+        {
+            if (f)
+                enemy_ko(f);
+            else
+                hero_hurt();
+        }
+        break;
+    }
+}
+
+void fighters_step(void)
+{
+    for (char f = 0; f < NFIGHT; f++)
+        if (fmode[f] != M_OFF)
+            step_one(f);
+}
+
+// A box in world x for fighter f facing his way: [*l, *r].
+static void box_x(char f, const struct Box *b, int *l, int *r)
+{
+    int x = fx[f];
+    if (fface[f] == FACE_RIGHT)
+    {
+        *l = x + b->x0;
+        *r = x + b->x1;
+    }
+    else
+    {
+        *l = x - b->x1;
+        *r = x - b->x0;
+    }
+}
+
+static bool can_be_hit(char t)
+{
+    char m = fmode[t];
+    return (m == M_FREE || m == M_ATTACK || m == M_JUMP || m == M_HURT) && !finvuln[t];
+}
+
+static void land_hit(char a, char t, char hb)
+{
+    char d = damage[hb];
+    fhp[t] = fhp[t] > d ? fhp[t] - d : 0;
+    bool knock = hb != HB_PUNCH || ++fcombo[t] >= 3 || fhp[t] == 0 || fh[t] > 0;
+    fface[t] = fx[a] < fx[t] ? FACE_LEFT : FACE_RIGHT;          // turn to the blow
+    signed char away = fx[a] < fx[t] ? 1 : -1;
+    if (a == 0)
+    {
+        if (hb == HB_PUNCH)
+        {
+            hits_punch++;
+            events |= EV_PUNCH_HIT;
+            score_add(0, FORCE_FAULT ? 2 : 1);                 // FORCE_FAULT: a punch scores 20
+        }
+        else if (hb == HB_KICK)
+        {
+            hits_kick++;
+            events |= EV_KICK_HIT;
+            score_add(0, 2);
+        }
+        else
+        {
+            hits_jkick++;
+            events |= EV_JKICK_HIT;
+            score_add(0, 3);
+        }
+        face_enemy = t;
+        ai_state[t] = AI_RETREAT;           // a hit enemy backs off once he is up
+        ai_timer[t] = 20;
+    }
+    else
+        events |= EV_HERO_HIT;
+    hud_dirty = true;
+    if (knock)
+    {
+        fcombo[t] = 0;
+        fmode[t] = M_FLY;
+        farc[t] = ARC_FLY;
+        fvx[t] = away * 2;
+        anim_start(&fanim[t], an_fly);
+        sfx_play(SFX_DOWN);
+        events |= t ? EV_KNOCKDOWN : EV_HERO_DOWN;
+    }
+    else
+    {
+        fmode[t] = M_HURT;
+        ftimer[t] = 4;                      // pushed a pixel a frame for 4 frames
+        fvx[t] = away;
+        anim_start(&fanim[t], an_hurt);
+        sfx_play(SFX_HIT);
+    }
+}
+
+// Every attacker on an active frame against the other side: the hero
+// against the enemies, an enemy against the hero. One hit an attack. A
+// target more than three windows away is skipped on one byte compare
+// (lane_depth_engine's order); nearer, the boxes, then the lane window:
+// two fighters a lane apart can overlap on the screen, and that is a miss,
+// counted as EV_LANE_MISS so the verdict sees the gate work.
+void hits_resolve(void)
+{
+    for (char a = 0; a < NFIGHT; a++)
+    {
+        char m = fmode[a];
+        if ((m != M_ATTACK && m != M_JUMP) || flanded[a])
+            continue;
+        char hb = anim_hit(&fanim[a]);
+        if (hb == HB_NONE)
+            continue;
+        const struct Box *h = &hit_box[hb];
+        int hl, hr;
+        box_x(a, h, &hl, &hr);
+        char hy0 = fh[a] + h->y0, hy1 = fh[a] + h->y1;
+        char t0 = a ? 0 : 1, t1 = a ? 1 : NFIGHT;
+        for (char t = t0; t < t1; t++)
+        {
+            if (!can_be_hit(t))
+                continue;
+            char dy = fy[a] > fy[t] ? fy[a] - fy[t] : fy[t] - fy[a];
+            if (dy > 3 * WIN)
+                continue;                   // far off the lane: not even a near miss
+            const struct Box *u = &hurt_box[anim_pose(&fanim[t])];
+            if (u->y1 == 0)
+                continue;
+            int ul, ur;
+            box_x(t, u, &ul, &ur);
+            char uy0 = fh[t] + u->y0, uy1 = fh[t] + u->y1;
+            if (!(hl <= ur && ul <= hr && hy0 <= uy1 && uy0 <= hy1))
+                continue;                   // the boxes do not touch
+            if (dy > WIN)
+            {
+                events |= EV_LANE_MISS;     // they touch on the screen, a lane apart: no hit
+                continue;
+            }
+            {
+#if AUTOPILOT
+                check_hit(a, t, hb);        // verdict.h: the same hit, recomputed its own way
+#endif
+                land_hit(a, t, hb);
+                flanded[a] = true;
+                break;
+            }
+        }
+    }
+}
+
+// The joystick: left and right walk, up and down change lane. Fire alone
+// punches; fire with left or right kicks that way; fire with up jumps
+// (with left or right, forward); fire in the air kicks.
+void player_control(char joy, char pressed)
+{
+    signed char dx = !(joy & JOY_RIGHT) ? 1 : !(joy & JOY_LEFT) ? -1 : 0;
+    signed char dy = !(joy & JOY_DOWN) ? 1 : !(joy & JOY_UP) ? -1 : 0;
+    if (pressed & JOY_FIRE)
+    {
+        if (fmode[0] == M_JUMP)
+            fighter_attack(0, A_KICK);
+        else if (fmode[0] == M_FREE)
+        {
+            fcombo[0] = 0;
+            if (dy < 0)
+            {
+                fvx[0] = dx;
+                fighter_attack(0, A_JUMP);
+            }
+            else if (dx)
+            {
+                fface[0] = dx < 0 ? FACE_LEFT : FACE_RIGHT;
+                fighter_attack(0, A_KICK);
+            }
+            else
+                fighter_attack(0, A_PUNCH);
+        }
+    }
+    else
+        fighter_walk(0, dx, dy);
+    if (fx[0] < camx + 16)                  // the hero stays on the screen
+        fx[0] = camx + 16;
+    else if (fx[0] > camx + 296)
+        fx[0] = camx + 296;
+}

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

@@ -0,0 +1,269 @@
+// game.h: what the modules share. One header, so an agent sees the whole
+// game's state in one place. Each module's .c is pulled in by the
+// #pragma compile lines at the end (Oscar64 has no object linker).
+#ifndef GAME_H
+#define GAME_H
+
+#include <c64/vic.h>
+#include <c64/cia.h>
+
+#ifndef AUTOPILOT
+#define AUTOPILOT 0
+#endif
+#ifndef FORCE_FAULT
+#define FORCE_FAULT 0
+#endif
+#ifndef FLICKER_DEMO
+#define FLICKER_DEMO 0              // 1: the fighter band drops its last part (tools/flickercheck.py must see it)
+#endif
+
+// ---- memory: VIC bank 3 ($C000-$FFFF) -----------------------------------
+#define PAGE0     ((char *)0xc000)  // street pages (rows 0-19 used, 20 blank)
+#define PAGE1     ((char *)0xc400)
+#define HUDPAGE   ((char *)0xc800)  // the HUD rows 21-24 are read from here
+#define CHARSET   ((char *)0xe000)  // RAM under the KERNAL, which is banked out
+#define CHARSET2  ((char *)0xe800)  // the same set but for the brute's glyphs (brute.c)
+#define SPRMEM    ((char *)0xf000)  // sprite blocks 192-254
+#define COLOUR    ((char *)0xd800)
+#define SPR_BLOCK 192               // block number of SPRMEM in bank 3
+#define D018_PAGE0 0x08             // screen $C000, characters $E000
+#define D018_PAGE1 0x18             // screen $C400
+#define D018_CS1   0x02             // | this: characters $E800 instead
+#define D016_PLAY  0x10             // multicolour, 38 columns; | XSCROLL
+#define RESULT    (*(volatile char *)0x02ff)   // $01 pass, $02 fail
+
+#define PF_ROWS    20               // street character rows
+#define HUD_ROW    21               // first HUD row
+
+// ---- colours ------------------------------------------------------------------
+// On street rows 2-19 the street uses bit pairs 00 and 01 only: the VIC
+// counts both as background, so a sprite with its $D01B bit set goes behind
+// the brute's 10 and 11 pixels and nothing else. Pairs 10 and 11 belong to
+// the brute there (colour RAM holds his body colour); rows 0-1, above every
+// fighter, use 11 for the sky.
+#define COL_ROAD   VCOL_DARK_GREY   // $D021: pavement, road, window glass
+#define COL_BRICK  VCOL_BROWN       // $D022: bricks, kerb, road marks; the brute's belt
+#define COL_BSKIN  VCOL_LT_RED      // $D023: the brute's skin
+#define COL_BBODY  VCOL_PURPLE      // colour RAM, rows 2-20: the brute's body (0-7 only)
+#define COL_SKIN   VCOL_LT_RED      // $D025: sprite pixels 01
+#define COL_INK    VCOL_BLACK       // $D026: sprite pixels 11 (hair, outline, shoes)
+
+// ---- joystick (active low, as $DC00 reads it) --------------------------------
+#define JOY_UP    0x01
+#define JOY_DOWN  0x02
+#define JOY_LEFT  0x04
+#define JOY_RIGHT 0x08
+#define JOY_FIRE  0x10
+
+// ---- the street (street.c) ----------------------------------------------------
+#define LEVEL_TW  64                // tiles across; a tile is 2 x 2 characters
+#define LEVEL_TH  10                // tiles down: the 20 street rows
+#define LEVEL_CW  (LEVEL_TW * 2)    // characters across
+#define CAM_MAX   ((LEVEL_CW - 40) * 8)
+#define NSTAGE    3
+extern const unsigned stage_lock[NSTAGE];      // the camera stops here until the stage is clear
+void street_init(void);                        // decode the text into tile indices, once
+char cell_char(unsigned col, char row);        // glyph at a world character cell
+void level_column(char *dst, unsigned col);    // 20 glyphs down one page column
+void street_block(char *dst, char wcol, char row);  // 30 glyphs under a 5 x 6 block
+
+// Glyphs. 0-63 are the ROM's upper-case set (text, digits, the meter);
+// the street's own glyphs start at CH_FIRST. The HUD's bar glyphs follow.
+#define CH_SPACE   32
+#define CH_FIRST   64
+#define CH_SKY     64
+#define CH_ROOF    65
+#define CH_BRICK   66
+#define CH_WIN_T   67
+#define CH_WIN_B   68
+#define CH_DOOR    69
+#define CH_SIGN    70
+#define CH_PAVE    71
+#define CH_KERB    72
+#define CH_ROAD    73
+#define CH_DASH    74
+#define CH_LAMP    75
+#define CH_POLE    76
+#define CH_BAR_FULL  77             // hires, HUD only
+#define CH_BAR_HALF  78
+#define CH_BAR_EMPTY 79
+#define CH_ALLEY   80               // the dark gap between buildings, rows 2-9
+#define CH_COUNT   17
+#define CH_BRUTE   128              // the brute's 30 glyphs, 128-157, in each set (brute.c)
+
+// ---- art (art.c) ----------------------------------------------------------------
+// Sprite blocks, facing right; each fighter block has a mirrored twin at
+// + B_MIRROR (built at start-up). B_GO and the faces are not mirrored.
+enum Block {
+    B_T_STAND, B_T_WIND, B_T_PUNCH, B_T_LEAN, B_T_HURT, B_T_JUMP,
+    B_L_STAND, B_L_WALK1, B_L_WALK2, B_L_CHAMBER, B_L_KICK, B_L_TUCK, B_L_KNEEL,
+    B_D_HEAD, B_D_FEET,
+    B_FIGHTER_COUNT,
+    B_MIRROR = B_FIGHTER_COUNT,
+    B_GO = 2 * B_FIGHTER_COUNT, B_FACE_HERO, B_FACE_THUG, B_FACE_BRUTE,
+    B_COUNT
+};
+
+// A pose: two parts, each a block and an offset from the fighter's origin
+// (his foot column, the ground line under him). dx is the part's left edge
+// from the origin facing right; dy is its Y register from the ground line.
+enum Pose {
+    P_STAND, P_WALK1, P_WALK2, P_WIND, P_PUNCH, P_CHAMBER, P_KICK,
+    P_JUMP, P_JKICK, P_HURT, P_DOWN, P_KNEEL,
+    P_COUNT
+};
+struct Part { char block; signed char dx, dy; };
+extern const struct Part pose_part[P_COUNT][2];
+
+// Boxes in pixels from the origin, facing right; y is height above the
+// ground line (0 at the feet). A hurt box per pose; a hit box per attack.
+struct Box { signed char x0, x1; char y0, y1; };
+extern const struct Box hurt_box[P_COUNT];     // y1 = 0: none (cannot be hit)
+enum HitBox { HB_NONE, HB_PUNCH, HB_KICK, HB_JKICK, HB_COUNT };
+extern const struct Box hit_box[HB_COUNT];
+void art_build(void);                          // charset and sprite blocks into bank 3
+extern const char brute_art[3][48][17];        // the brute: stand, slam, down; 16 x 48
+
+// ---- the brute in character cells (brute.c) --------------------------------------
+extern char b_wcol, b_row, b_fy;    // the picture on screen: world column, top row, ground line
+extern bool b_drawn;
+extern char b_cs;                   // the character set on screen: 0 $E000, 1 $E800
+extern unsigned brute_late;         // switches that finished after his top row began
+void brute_build(void);             // the pre-shifted pictures, once
+void brute_reset(void);             // the pages were redrawn: nothing of him is on them
+void brute_prepare(void);           // end of a frame: build the next picture, half a frame at a time
+void brute_draw(void);              // start of a frame: move his cells to match the set just switched
+void brute_patch(char p, char row0, char n);   // after a scroll slice wrote column 39
+char brute_code_at(unsigned wcol, char row);   // his code at a world cell, or 0
+
+// ---- animation (anim.c) ----------------------------------------------------------
+// A sequence is (pose, frames, hit box) triples ending in AN_LOOP n (go to
+// triple n), AN_HOLD (stay on the last) or AN_END (done: the fighter's
+// move is over). Only the attack frames carry a hit box.
+struct Anim { const char *seq; char pos, count; };
+extern const char an_stand[], an_walk[], an_punch[], an_kick[], an_jump[], an_jkick[];
+extern const char an_hurt[], an_fly[], an_down[], an_kneel[];
+void anim_set(struct Anim *a, const char *seq);   // restarts only if it is a new sequence
+void anim_start(struct Anim *a, const char *seq); // always restarts
+void anim_step(struct Anim *a);
+char anim_pose(const struct Anim *a);
+char anim_hit(const struct Anim *a);              // the hit box of this frame, HB_NONE mostly
+bool anim_done(const struct Anim *a);             // an AN_END sequence has finished
+
+// ---- fighters (fighter.c) -----------------------------------------------------------
+// Slot 0 is the player, 1-3 the enemies (an object pool of three).
+#define NFIGHT   4
+#define NENEMY   3
+#define PLANE_TOP 150               // ground lines a fighter may stand on
+#define PLANE_BOT 204
+#define WIN       6                 // a hit needs the ground lines within 6 (lane_depth_engine)
+enum Kind { K_HERO, K_THUG, K_BRUTE };          // the brute is drawn in characters (brute.c)
+#define HP_HERO   24                // hit points; a HUD bar cell is two
+#define HP_THUG   8
+#define HP_BRUTE  12
+enum Mode { M_OFF, M_FREE, M_ATTACK, M_JUMP, M_HURT, M_FLY, M_DOWN, M_KNEEL, M_KO };
+extern char fmode[NFIGHT], fkind[NFIGHT], fface[NFIGHT], fhp[NFIGHT], ftimer[NFIGHT];
+extern unsigned fx[NFIGHT];         // foot column, world pixels, below 32,768 (enemy.c: #30 fault 8)
+extern char fy[NFIGHT];             // ground line (raster line of the feet)
+extern char fh[NFIGHT];             // height above the ground, pixels
+extern char farc[NFIGHT];           // index into the arc table while airborne
+extern signed char fvx[NFIGHT];     // pixels a frame while airborne or pushed
+extern char fcombo[NFIGHT];         // punches landed in a row
+extern bool flanded[NFIGHT];        // this attack has already hit
+extern struct Anim fanim[NFIGHT];
+extern char finvuln[NFIGHT];        // frames of blinking after a respawn
+#define FACE_RIGHT 0
+#define FACE_LEFT  1
+void fighter_spawn(char f, char kind, unsigned x, char y, char face);
+void fighter_walk(char f, signed char dx, signed char dy);
+void fighter_attack(char f, char move);          // A_PUNCH, A_KICK, A_JUMP
+enum Move { A_PUNCH, A_KICK, A_JUMP };
+void fighters_step(void);                        // animation, flight, timers
+void hits_resolve(void);                         // attacks against the other side
+bool fighter_can_act(char f);
+extern const char arc[];                         // height by frame of a jump or a fall
+#define ARC_JUMP   0                             // arc start indices
+#define ARC_FLY    26
+void player_control(char joy, char pressed);
+
+// ---- enemies (enemy.c) --------------------------------------------------------------
+enum AiState { AI_ENTER, AI_APPROACH, AI_WAIT, AI_ATTACK, AI_RETREAT };
+extern char ai_state[NFIGHT], ai_timer[NFIGHT];
+extern char stage;                  // 0-2
+extern char wave;                   // the stage's next wave
+extern bool stage_clear;            // every wave of this stage beaten
+void waves_reset(void);
+void waves_update(void);            // the wave director: spawns at the lock
+void enemies_update(void);          // the AI
+
+// ---- view (view.c) ------------------------------------------------------------------
+#define NPAGES 2
+extern unsigned camx;               // world pixel at the window's left edge (XSCROLL 7)
+extern unsigned shown_col;          // first world column on the page on display
+extern char shown_page;
+extern int page_col[NPAGES];
+extern char page_rows[NPAGES];
+extern char order[NFIGHT];          // fighters far to near (the depth sort)
+extern char parts_dropped;          // fighter parts that found no sprite (never, by design)
+extern char sprites_half;           // the table half view_sprites last filled (0 or 1)
+extern bool sprites_fresh;          // view_sprites filled it this frame (it skips a frame the IRQ has not swapped)
+extern bool go_sign;                // blink the GO sign
+extern bool faces_off;              // AUTOPILOT photo stops: no faces over the HUD text
+extern char face_enemy;             // the enemy whose face and bar the HUD shows, or 0xff
+void view_init(void);               // VIC, bank, colours, IRQ chain
+void view_cut(void);                // draw both pages at camx; no scrolling
+void view_follow(void);             // move the camera after the player; prepare the hidden page
+void view_sprites(void);            // the three bands' back tables from the model
+void view_publish(void);            // the next picture's page and XSCROLL, for the IRQ at 251
+int part_vic_x(char f, char k);     // sprite X of fighter f's part k, as the band tables hold it
+char *page_ptr(char page);
+
+// ---- HUD, score, sound (hud.c, sound.c) -----------------------------------------------
+extern char score[6], hiscore[6];   // decimal digits, most significant first
+extern char lives;
+extern bool hud_dirty;
+void put_text(char row, char col, const char *s);
+void hud_clear(void);
+void hud_draw(void);
+void hud_hiscore(void);
+void score_add(char hundreds, char tens);
+
+enum Sfx { SFX_SWING, SFX_HIT, SFX_DOWN, SFX_JUMP, SFX_KO };
+void sfx_play(char id);
+void sfx_update(void);
+
+// ---- events and counts the verdict checks (main.c) -----------------------------------
+#define EV_PUNCH_HIT 0x0001
+#define EV_KICK_HIT  0x0002
+#define EV_JKICK_HIT 0x0004
+#define EV_KNOCKDOWN 0x0008         // an enemy went down
+#define EV_GETUP     0x0010         // and got up again
+#define EV_KO        0x0020
+#define EV_HERO_HIT  0x0040
+#define EV_HERO_DOWN 0x0080
+#define EV_LIFE_LOST 0x0100
+#define EV_LOCK      0x0200         // the camera stopped at a stage lock
+#define EV_UNLOCK    0x0400         // a stage was cleared
+#define EV_SCROLL    0x0800         // the camera crossed a column
+#define EV_DEPTH     0x1000         // a fighter changed ground line
+#define EV_LANE_MISS 0x2000         // an attack's boxes touched a fighter a lane away: no hit
+#define EV_ALL       0x3fff
+extern unsigned events;
+extern char hits_punch, hits_kick, hits_jkick, kos_thug, kos_brute, locks;
+void hero_hurt(void);               // main.c owns lives and the state machine
+void enemy_ko(char f);
+#if AUTOPILOT
+void check_hit(char a, char t, char hb);   // verdict.h: each hit recomputed on its own
+#endif
+
+#pragma compile("street.c")
+#pragma compile("art.c")
+#pragma compile("brute.c")
+#pragma compile("anim.c")
+#pragma compile("fighter.c")
+#pragma compile("enemy.c")
+#pragma compile("view.c")
+#pragma compile("hud.c")
+#pragma compile("sound.c")
+
+#endif