c64-kb 0.17.0

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

@@ -0,0 +1,135 @@
+// hud.c: the HUD page (rows 21-24 on screen), the health bars and the
+// score. The score is six decimal digits added digit by digit, so printing
+// it is six stores and no division (c64-kb decimal_print). Text is screen
+// codes, not PETSCII (petscii_written_to_screen_ram).
+//
+//   row 21   [face] PLAYER               [face] THUG
+//   row 22   [face] ############         [face] ####
+//   row 23   [face] SCORE 000000         [face] STAGE 1  LIVES 3
+//   row 24   HI 000000            (AUTOPILOT builds: the meter, columns 20-39)
+#include "game.h"
+
+char score[6], hiscore[6];
+char lives;
+bool hud_dirty;                     // set by whatever changes a figure the HUD shows
+
+
+// Lower-case letters in the source become the ROM's upper-case glyphs.
+void put_text(char row, char col, const char *s)
+{
+    char *p = HUDPAGE + row * 40 + col;
+    while (*s)
+    {
+        char c = *s++;
+        *p++ = (c >= 'a' && c <= 'z') ? c - 'a' + 1 : c;
+    }
+}
+
+// What the HUD shows now, so hud_draw rewrites only what changed: a hit
+// moves one bar, not the whole HUD (a full redraw was 4,157 cycles at
+// worst, metered with PROF=4). 0xff: not drawn yet.
+static char shown_hp0, shown_hpe, shown_enemy, shown_stage, shown_lives;
+static bool shown_score;
+
+void hud_clear(void)
+{
+    for (unsigned i = HUD_ROW * 40; i < 1000; i++)
+        HUDPAGE[i] = CH_SPACE;
+    shown_hp0 = shown_hpe = shown_enemy = shown_stage = shown_lives = 0xff;
+    shown_score = false;
+}
+
+static void put_digits(char row, char col, const char *d, char n)
+{
+    char *p = HUDPAGE + row * 40 + col;
+    for (char i = 0; i < n; i++)
+        p[i] = '0' + d[i];
+}
+
+// A bar of `cells` cells for `hp` points: full, half, then empty cells.
+static void put_bar(char col, char hp, char cells)
+{
+    char *p = HUDPAGE + 22 * 40 + col;
+    for (char i = 0; i < 12; i++)
+    {
+        char left = hp > i * 2 ? hp - i * 2 : 0;
+        p[i] = i >= cells ? CH_SPACE : left >= 2 ? CH_BAR_FULL : left ? CH_BAR_HALF : CH_BAR_EMPTY;
+    }
+}
+
+// Only when something changed: most frames it costs one test, and then
+// only the figures that differ from what is on the page.
+void hud_draw(void)
+{
+    if (!hud_dirty)
+        return;
+    hud_dirty = false;
+    if (shown_lives == 0xff)
+    {
+        put_text(21, 3, "player");
+        put_text(23, 3, "score");
+        put_text(23, 23, "stage");
+        put_text(23, 32, "lives");
+        hud_hiscore();
+    }
+    if (fhp[0] != shown_hp0)
+    {
+        shown_hp0 = fhp[0];
+        put_bar(3, fhp[0], HP_HERO / 2);
+    }
+    if (!shown_score)
+    {
+        shown_score = true;
+        put_digits(23, 9, score, 6);
+    }
+    if (stage != shown_stage)
+    {
+        shown_stage = stage;
+        HUDPAGE[23 * 40 + 29] = '1' + stage;
+    }
+    if (lives != shown_lives)
+    {
+        shown_lives = lives;
+        HUDPAGE[23 * 40 + 38] = '0' + lives;
+    }
+    char f = face_enemy;
+    if (f >= NFIGHT || fmode[f] == M_OFF)
+        f = 0xfe;                                   // no enemy shown
+    char hp = f < NFIGHT ? fhp[f] : 0;
+    if (f != shown_enemy)
+    {
+        shown_enemy = f;
+        shown_hpe = 0xff;
+        put_text(21, 23, f >= NFIGHT ? "     " : fkind[f] == K_THUG ? "thug " : "brute");
+    }
+    if (hp != shown_hpe)
+    {
+        shown_hpe = hp;
+        put_bar(23, hp, f >= NFIGHT ? 0 : (fkind[f] == K_THUG ? HP_THUG : HP_BRUTE) / 2);
+    }
+}
+
+void hud_hiscore(void)
+{
+    put_text(24, 0, "hi");
+    put_digits(24, 3, hiscore, 6);
+}
+
+// score += hundreds * 100 + tens * 10, carried up the digits.
+void score_add(char hundreds, char tens)
+{
+    char carry = 0;
+    for (signed char i = 5; i >= 0; i--)
+    {
+        char d = score[i] + carry + (i == 4 ? tens : i == 3 ? hundreds : 0);
+        carry = 0;
+        while (d >= 10)
+        {
+            d -= 10;
+            carry++;
+        }
+        score[i] = d;
+    }
+    shown_score = false;
+    hud_dirty = true;
+}

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

@@ -0,0 +1,341 @@
+// main.c: the brawler starter. The frame loop, the game's states, the
+// autopilot hooks. Each subsystem lives in its own file (game.h lists
+// them); this file runs them in order.
+//
+// One frame, from raster line 251 (below the last display line):
+//   music, sfx      the tune (KickAssembler) and the effects on voice 3
+//   the state       title, play, game over, street clear
+//     play:         the hero's joystick, the enemies' AI, every fighter's
+//                   move, the hits, the waves, the camera and the scroll
+//   hud_draw        bars, score, stage, lives, when something changed
+//   view_sprites    the three sprite bands, back half, depth-sorted
+//   view_publish    the next picture's page, XSCROLL and sprite set, as one
+// The IRQ chain in engine.asm writes them: line 251 the street's $D016 and
+// $D018 and the sign band, line 76 the fighter band, line 212 the HUD's
+// registers and the face band. In AUTOPILOT builds the meter brackets the
+// play frames, and the IRQs that land outside the bracket are added in.
+//
+// AUTOPILOT=1 replaces the joystick with a bot (autopilot.h) that plays
+// from the title; then the program grades itself ($02FF and the border,
+// verdict.h). FORCE_FAULT=1 makes a punch worth 20: the verdict fails and
+// the HUD score differs. FLICKER_DEMO=1 drops a fighter part (view.c) for
+// tools/flickercheck.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 hero, AI, moves and hits; 2 camera and scroll; 3 the sprite bands and
+// publish; 4 music, effects and HUD; 6 the brute's cells and glyphs (the
+// switch at the frame start, the build at the end); 5 the three IRQs alone (no main-loop
+// bracket, so every IRQ times itself on CIA2 timer B). README.md has the
+// figures. The whole-frame figure (PROF=0) holds the IRQs too.
+#ifndef PROF
+#define PROF 0
+#endif
+static bool metering;               // this frame is a recorded 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_OVER, ST_CLEAR, ST_GRADED };
+static char state, timer, prev_joy;
+unsigned events;
+char hits_punch, hits_kick, hits_jkick, kos_thug, kos_brute, locks;
+static unsigned frame;              // frames since power-on
+static unsigned late;               // AUTOPILOT: play frames whose work ran past the next line 251
+static unsigned slow;               // AUTOPILOT: play frames the whole loop overran (a blank missed)
+static bool photo;                  // AUTOPILOT: the game is held for a picture (verdict.h)
+
+#define PLAY_HOLD 255               // play frames the meter records (its maximum)
+#define START_LIVES 3
+#define HERO_X    60
+#define HERO_Y    176
+
+// ---- input -------------------------------------------------------------------------
+#if AUTOPILOT
+// The bot's byte for this frame, worked out at the end of the last one
+// (main loop, after the meter): the bot is not the game's work.
+static char ap_next = 0xff;
+static char port_read(void)
+{
+    return ap_next;
+}
+#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 street_start(void)
+{
+    camx = 0;
+    view_cut();
+    waves_reset();
+    fighter_spawn(0, K_HERO, HERO_X, HERO_Y, FACE_RIGHT);
+    face_enemy = 0xff;
+    go_sign = false;
+}
+
+static void title(void)
+{
+    state = ST_TITLE;
+    street_start();
+    hud_clear();
+    put_text(21, 7, "c64-kb beat-em-up starter");
+    put_text(23, 15, "press fire");
+    hud_hiscore();
+}
+
+static void new_game(void)
+{
+    for (char i = 0; i < 6; i++)
+        score[i] = 0;
+    lives = START_LIVES;
+    hits_punch = hits_kick = hits_jkick = kos_thug = kos_brute = locks = 0;
+    events = 0;
+    street_start();
+    hud_clear();
+    hud_dirty = true;
+    state = ST_PLAY;
+}
+
+// The hero's KO has run its course (fighter.c): a life, and up again where
+// he fell, blinking and safe for two seconds, or the game is over.
+void hero_hurt(void)
+{
+    lives--;
+    events |= EV_LIFE_LOST;
+    hud_dirty = true;
+    if (lives)
+    {
+        fighter_spawn(0, K_HERO, fx[0], fy[0], fface[0]);
+        finvuln[0] = 100;
+        return;
+    }
+    fmode[0] = M_OFF;
+    hud_draw();                     // LIVES 0 now: no HUD redraw may follow the message
+    put_text(21, 15, "game over");
+    state = ST_OVER;
+    timer = 150;
+}
+
+static void play_frame(char joy, char pressed)
+{
+    PON(1)
+    player_control(joy, pressed);
+    enemies_update();
+    fighters_step();
+    hits_resolve();
+    waves_update();
+    POFF(1)
+    PON(2)
+    view_follow();
+    POFF(2)
+    if (stage_clear && stage == NSTAGE - 1 && state == ST_PLAY)
+    {
+        hud_draw();
+        put_text(21, 13, "street clear");
+        state = ST_CLEAR;
+        timer = 150;
+    }
+}
+
+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();
+}
+
+// The IRQs that landed outside the meter's brackets since the last frame
+// (engine.asm times them on CIA2 timer B). meter_add subtracts the empty
+// C bracket once, so it is added back: timer B's own start-stop cost is a
+// few cycles, not the C bracket's.
+static unsigned fold_irq_time(bool add)
+{
+    __asm { sei }
+    unsigned c = *(volatile unsigned *)ASM_IRQ_CYC;
+    *(volatile unsigned *)ASM_IRQ_CYC = 0;
+    *(volatile char *)ASM_IRQ_CNT = 0;
+    __asm { cli }
+    if (add && c)
+        meter_add(c + meter_zero);
+    return add ? c : 0;
+}
+
+// The worst frame of every metered play frame, not only the 255 the meter
+// records: with -dMETER_WINDOW=4 every play frame is metered, and the
+// verdict prints this on row 24 ("RUN nnnnn").
+static unsigned run_worst;
+
+#if AUTOPILOT
+#include "autopilot.h"
+#include "verdict.h"
+#endif
+
+int main(void)
+{
+    __asm { sei }                   // the IRQ chain 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
+    street_init();
+    art_build();                    // leaves $01 = $35: BASIC and KERNAL out
+    brute_build();                  // his pictures at the four shifts
+    __asm { jsr ASM_MUSIC_INIT }
+    view_init();                    // bank 3, colours, the IRQ chain; CLI
+    meter_init((unsigned)HUDPAGE, 24, 20, VCOL_WHITE, PLAY_HOLD);
+#if FRAME_METER
+    cia2.icr = 0x02;                // timer B's NMI masked (bit 7 clear: clear this bit only)
+    cia2.crb = 0x00;
+    cia2.tb = 0xffff;               // the latch the IRQs force-load
+    *(volatile char *)ASM_IRQ_METER = 1;
+#endif
+#if AUTOPILOT
+    *(volatile char *)ASM_SNAP_ON = 1;      // band 1's registers copied back each frame (verdict.h)
+#endif
+    for (char i = 0; i < 6; i++)
+        hiscore[i] = 0;
+    prev_joy = 0xff;
+    title();
+
+    for (;;)
+    {
+        wait_sync();
+        char ticks = BLANK_TICKS;
+        bool play = state == ST_PLAY && !photo;    // this frame began in play
+#if AUTOPILOT
+        metering = state == ST_PLAY && !photo && ap_recording();
+#else
+        metering = state == ST_PLAY;
+#endif
+        if (metering && !PROF)
+            METER_START;
+
+        PON(6)
+        brute_draw();               // first: it must beat the beam to the brute's top row
+        POFF(6)
+        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:
+            if (!photo)
+                play_frame(joy, pressed);
+            break;
+        case ST_OVER:
+        case ST_CLEAR:
+            if (--timer == 0)
+            {
+                if (state == ST_OVER)
+                    end_game();
+                else
+                {
+                    street_start();         // the street again, score and lives kept
+                    hud_clear();
+                    hud_dirty = true;
+                    state = ST_PLAY;
+                }
+            }
+            break;
+        }
+        PON(4)
+        __asm { jsr ASM_MUSIC_PLAY }
+        sfx_update();
+        POFF(4)
+        PON(6)
+        brute_prepare();            // the brute's next picture, half a frame at a time
+        POFF(6)
+        PON(4)
+        if (state == ST_PLAY)       // game over and street clear keep their message
+            hud_draw();
+        POFF(4)
+        PON(3)
+        view_sprites();
+        view_publish();
+        POFF(3)
+#if AUTOPILOT
+        if (play && BLANK_TICKS != ticks)
+            late++;                 // a play frame whose work ran past the next line 251
+                                    // (not the frame fire starts a game: it draws both pages)
+#endif
+
+#if FRAME_METER
+        if (metering)
+        {
+            unsigned sum = 0;
+            if (!PROF)
+            {
+                unsigned r = meter_read();  // METER_PAUSE, keeping the figure
+                meter_add(r);
+                sum = r - meter_zero;       // the main loop's share
+            }
+            sum += fold_irq_time(!PROF || PROF == 5);  // the IRQs' share outside it
+            if (sum > run_worst)
+                run_worst = sum;
+            meter_frame();          // the frame's own work ends here
+        }
+        else
+            fold_irq_time(false);
+#endif
+#if AUTOPILOT
+        if (BLANK_TICKS == ticks)   // (past the next blank the half just built may be the one shown)
+            vic_compare();          // what the IRQ at line 76 wrote, read back (verdict.h)
+        vic_expect();               // what the half just built must show, worked out on its own
+        ap_next = autopilot_port(); // next frame's joystick byte
+        autopilot_frame();          // grading and pictures are bookkeeping: outside the bracket
+        if (!(frame & 31))
+            meter_print();          // it divides: not every frame
+#endif
+#if AUTOPILOT
+        if (play && BLANK_TICKS != ticks)
+            slow++;                 // the loop, bookkeeping and all, missed a blank
+#endif
+        frame++;
+    }
+    return 0;
+}

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

@@ -0,0 +1,44 @@
+// sound.c: hit 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.
+// A new effect cuts the last one.
+#include "game.h"
+#include <c64/sid.h>
+
+struct Effect { char freq_hi, wave, frames, attdec, susrel; signed char slide; };
+
+static const struct Effect effect[] = {
+    { 0x30, SID_CTRL_NOISE,  4, 0x00, 0x40, -4 },   // swing: a short hiss
+    { 0x08, SID_CTRL_NOISE,  8, 0x00, 0x90, -1 },   // hit: a low thump
+    { 0x20, SID_CTRL_SAW,   20, 0x00, 0xa0, -1 },   // knock-down: a falling saw
+    { 0x10, SID_CTRL_RECT,  10, 0x00, 0x90,  3 },   // jump: a rising square
+    { 0x06, SID_CTRL_NOISE, 40, 0x00, 0xa9,  0 },   // KO: a long crash
+};
+
+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
+}

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

@@ -0,0 +1,93 @@
+// street.c: the street as text, its 2 x 2 metatiles, the cell lookups the
+// scroll asks, and the three stage locks (c64-kb tile_map_render).
+#include "game.h"
+
+// One character per metatile, ten rows of 64: rooftops, four rows of
+// facades (brick, lit windows, doors, signs; the gaps are dark alleys
+// with lamps), then pavement, the kerb and the road. The fighters stand
+// on tile rows 6-9 (ground lines 150-204). Edit freely: a tile key must
+// be in tile_key below.
+static const char level_text[LEVEL_TH][LEVEL_TW + 1] = {
+    "rrrrrr.rrrrrrrr.rrrrr.rrrrrrr.rrrrrr.rrrrrrrr.rrrrr.rrrrrrr.rrrr",
+    "BWWWWBaBWBWBWBWaBBBBBaBWWWWWBaBWBWBWaBBBBBBBBaBWWWBaBWBWBWBaBBBB",
+    "BBBBBBLBWBWBWBWLBWBBWLBBBBBBBLBWBWBWLBWBBWBBWLBBBBBLBWBWBWBLBWBB",
+    "BWWWWBlBSSSSSSBlBBBBBlBWWWWWBlBSSSSBlBBBBBBBBlBWWWBlBSSSSSBlBBBB",
+    "BWWDWBlWDWWWWDWlBDBWBlBWWDWWBlWDWWDWlBDBWBWBWlBWDWBlWDWWWDWlBDBW",
+    "PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP",
+    "PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP",
+    "KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK",
+    "RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR",
+    "================================================================",
+};
+
+// Metatiles: key, then the glyphs top-left, top-right, bottom-left,
+// bottom-right. A tile sits on character rows 2ty and 2ty + 1.
+static const char tile_key[] = ".rBWDSLlPKR=a";
+static const char tile_glyph[][4] = {
+    { CH_SKY,   CH_SKY,   CH_SKY,   CH_SKY   },   // .  sky (tile row 0 only: 'k' is blue there)
+    { CH_SKY,   CH_SKY,   CH_ROOF,  CH_ROOF  },   // r  a roof edge
+    { CH_BRICK, CH_BRICK, CH_BRICK, CH_BRICK },   // B  brick
+    { CH_WIN_T, CH_WIN_T, CH_WIN_B, CH_WIN_B },   // W  a lit window
+    { CH_DOOR,  CH_DOOR,  CH_DOOR,  CH_DOOR  },   // D  a door
+    { CH_SIGN,  CH_SIGN,  CH_BRICK, CH_BRICK },   // S  a shop sign over brick
+    { CH_LAMP,  CH_ALLEY, CH_POLE,  CH_ALLEY },   // L  an alley lamp
+    { CH_POLE,  CH_ALLEY, CH_POLE,  CH_ALLEY },   // l  its post
+    { CH_PAVE,  CH_PAVE,  CH_PAVE,  CH_PAVE  },   // P  pavement
+    { CH_PAVE,  CH_PAVE,  CH_KERB,  CH_KERB  },   // K  pavement over the kerb
+    { CH_ROAD,  CH_ROAD,  CH_ROAD,  CH_ROAD  },   // R  road
+    { CH_ROAD,  CH_ROAD,  CH_DASH,  CH_ROAD  },   // =  road with the centre line
+    { CH_ALLEY, CH_ALLEY, CH_ALLEY, CH_ALLEY },   // a  a dark alley between buildings
+};
+
+// The camera stops at each lock until that stage's waves are beaten. The
+// last is the end of the street (CAM_MAX).
+const unsigned stage_lock[NSTAGE] = { 0, 352, CAM_MAX };
+
+static char level[LEVEL_TH][LEVEL_TW];         // tile index per cell
+
+void street_init(void)
+{
+    for (char ty = 0; ty < LEVEL_TH; ty++)
+    {
+        for (char tx = 0; tx < LEVEL_TW; tx++)
+        {
+            char t = 0;
+            for (char i = 0; i < sizeof(tile_key) - 1; i++)
+                if (tile_key[i] == level_text[ty][tx])
+                    t = i;
+            level[ty][tx] = t;
+        }
+    }
+}
+
+char cell_char(unsigned col, char row)
+{
+    char t = level[row >> 1][col >> 1];
+    return tile_glyph[t][((row & 1) << 1) | (col & 1)];
+}
+
+// The street's glyphs under a block 5 cells wide and 6 high whose top left
+// is world cell (wcol, row), row by row: what the brute covers (brute.c).
+void street_block(char *dst, char wcol, char row)
+{
+    for (char r = row; r < row + 6; r++)
+    {
+        const char *lv = level[r >> 1];
+        char b = (r & 1) << 1;
+        for (char c = wcol; c < wcol + 5; c++)
+            *dst++ = tile_glyph[lv[c >> 1]][b | (c & 1)];
+    }
+}
+
+// One page column: the 20 street glyphs of world column col, 40 apart.
+void level_column(char *dst, unsigned col)
+{
+    char tx = col >> 1, half = col & 1;
+    for (char ty = 0; ty < LEVEL_TH; ty++)
+    {
+        const char *g = tile_glyph[level[ty][tx]];
+        dst[0] = g[half];
+        dst[40] = g[2 + half];
+        dst += 80;
+    }
+}