Sprinter-SDCC/applications/PoP/roomtest/roomtest.c

/*
 * roomtest.c — проверка порта статического фона (Шаг 3): рисует комнату 1
 * уровня 1 реальной композицией слоёв (pop_bg.c) и держит на экране.
 * Сверять на MAME с эталоном applications/PoP/toolchain/1.1-2.png.
 */
#include <graphics.h>
#include <gfx.h>
#include <sprite.h>
#include <conio.h>
#include <stdio.h>
#include <kbd_raw.h>
#include "pop_bg.h"
#include "pop_kid.h"
#include "pop_ctrl.h"
#include "pop_map.h"
#include "pop_level.h"
#include "pop_trob.h"
#include "pop_redraw.h"
#include "pop_guard.h"
#include "pop_cheat.h"

__sfr __at (0xFE) io_border;

/* ПРОФИЛИРОВАНИЕ ПОЛОСАМИ БОРДЮРА (make PROF=1).  Цвет бордюра держится,
 * пока фаза считает, поэтому высота полосы на скриншоте = время фазы в
 * растровых строках (1 строка ≈ 224 такта Z80 при 3.5 МГц).  Это
 * единственный способ мерить здесь: мост MAME отвечает из фреймового
 * колбэка, поэтому выборка PC вырождается (100 % сэмплов в обработчике
 * прерывания).  Фазы:
 *   0 чёрный  — ожидание vsync (запас кадра)
 *   1 синий   — ввод + heal (стереть прошлые спрайты)
 *   2 красный — логика (kid_tick/физика/страж в банке)
 *   3 лиловый — слой фона (loose/trobs/redraw_needed/шов)
 *   4 зелёный — kid_draw
 *   5 циан    — guard_draw + fore поверх стража
 *   6 жёлтый  — fore поверх Kid + чистка бортов
 *   7 белый   — флип */
#ifdef PROF_BORDER
#define PROF(n) io_border = (n)
#else
#define PROF(n) ((void)0)
#endif

/* Сколько банков грузит crt0_banked (читает его стартовый код). */
const uint8_t n_banks = 1;

/* Режим читов (pop_cheat.h): на время разработки включаем в main. */
uint8_t pop_cheats;

/* seq_2_stand (types.h seqids) — Kid стоит, ждёт ввода. */
#define SEQ_STAND 2
#define ROOM_1    1
#define LINK_DOWN 3         /* сторона links: 0=L,1=R,2=U,3=D */

/* Тест-старт для отладки пик (Фаза S): комната 6 = тестовая (пики в col3/col4
 * row2, шахта col3).  Kid на полу row0 col1, идёт вправо → падает в шахту →
 * пики.  TODO: вернуть на pop_level_start_room (комната 1) после отладки. */
#define START_ROOM 1   /* обход комнат: старт с 1-й, дальше +/- (ROOMNAV) */
#define START_COL  3
#define START_ROW  0
#define RESPAWN_DELAY 400  /* авто-респавн (фолбэк), если не нажали ↑ */
#define RESPAWN_SETTLE 20  /* тиков до приёма ↑ (труп успел лечь) */

/* ОТЛАДОЧНЫЙ ОБХОД КОМНАТ: '+'/'-' (цифровой блок либо '='/'-' основного
 * ряда) — следующая/предыдущая комната уровня ПО НОМЕРУ (1..24, с обёрткой),
 * Kid ставится на первый попавшийся пол.  Нужен, чтобы пройти все комнаты и
 * собрать список багов отрисовки, включая недостижимые обычным путём.
 * Убирается закомментированием ОДНОЙ строки ниже. */
#define ROOMNAV 1

/* Рабочая копия ТЕКУЩЕЙ комнаты (W2, мутабельная: loose→empty) + срезы
 * соседей для кромок.  Заполняются pop_room_load из уровня.  File-scope,
 * чтобы enter_room переключал комнату без длинного списка параметров. */
static uint8_t room_fg[30], room_bg[30];
/* lcol_fg/rcol_fg — ШЕСТЬ записей: [0..2] кромочная колонка соседа (col9/col0),
 * [3..5] следующая за ней (col8/col1) для коллизии, когда Kid стоит В шве и
 * смотрит наружу (колонка −2 / 11).  См. pop_level.h. */
static uint8_t lcol_fg[6], lcol_bg[3], rcol_fg[6], rcol_bg[3], below_fg[10];
static uint8_t above_fg[10], above_mod[10];   /* ряд 2 верхнего соседа (полоса кладки у потолка) */
static uint8_t cur_room;   /* номер ОТРИСОВАННОЙ комнаты (drawn_room) */
static uint8_t kid_room;   /* РЕАЛЬНАЯ комната Kid (S1: == cur_room; расходятся в S3 straddle) */

/* Рендер-смещение Kid по логической X (порт xpos_in_drawn_room): комната Kid
 * слева от отрисованной → −140 (спрайт за левой кромкой), справа → +140, та
 * же → 0.  Звать каждый кадр перед kid_draw. */
static void update_kid_render_dx(void)
{
    int dx = 0;
    if (kid_room != cur_room) {
        if (kid_room == pop_room_link(cur_room, 0)) dx = -140;      /* left neighbour */
        else if (kid_room == pop_room_link(cur_room, 1)) dx = 140;  /* right neighbour */
    }
    pop_kid_set_render_dx(dx);
}

/* Change-driven редрой ЛЕВОГО шва (ворота соседа room8 видны в col0): тяжёлый
 * draw_tile(0,0) в pop_room_redraw_seam_left зовём ТОЛЬКО когда openness гейта
 * реально изменился.  Пока Кид держит кнопку и гейт открыт — modifier стабилен
 * → 0 редроёв (раньше шов рисовался безусловно КАЖДЫЙ кадр, пока сосед активен
 * — тот же класс, что был у кнопки).  seam_redraw=2 = обе страницы дабл-буфера. */
static uint8_t seam_sig;      /* последняя нарисованная openness гейта в шве */
static uint8_t seam_redraw;   /* оставшиеся кадры редроя (обе страницы) */

/* Отладочный лейбл номера комнаты — рисуем только при смене (outtextxy тяжёлая):
 * sig = последняя показанная комната, redraw = остаток кадров (2 = обе страницы). */
static uint8_t room_label_sig = 0xFF;
static uint8_t room_label_redraw;

/* Персистентные переопределения тайлов уровня: упавший loose-кусок оставил
 * щебень (floor → debris), а на месте самой плиты — пусто (в т.ч. в комнате
 * СВЕРХУ: провалившийся потолок = колодец).  Минимальный per-room override:
 * живёт между переходами, применяется в enter_room поверх загруженных тайлов
 * (и для ряда 2 верхнего соседа).  (Полноценное per-room modifier-состояние —
 * в docs/gates_spikes_plan.md, P0.) */
#define TILE_DEBRIS     0x0E
#define TILE_EMPTY      0x00
#define TILE_FLOOR      0x01
#define OVR_MAX         8
static uint8_t ovr_room[OVR_MAX], ovr_pos[OVR_MAX], ovr_tile[OVR_MAX], ovr_cnt;

/* Поднятый предмет (меч): tilepos и счётчик «запечь пол» по страницам.
 * flash_on — вспышка фона активна (нулевая запись палитры подменена). */
static uint8_t item_pos, item_bake, flash_on;

/* Подмена НУЛЕВОЙ записи палитры на обеих страницах (do_flash/set_bg_attr).
 * Через функцию с параметрами, а не пятью литералами в месте вызова: на
 * gfx_pal_set(0,0,0,0,0) SDCC 4.5 выдаёт невалидный `ld hl, a`
 * (см. .sprinter-cc-roomtest/roomtest.asm) и ассемблер падает. */
static void flash_bg(uint8_t r, uint8_t g, uint8_t b)
{
    gfx_pal_set(0, 0, r, g, b);
    gfx_pal_set(1, 0, r, g, b);
}

static void add_tile_override(uint8_t room, uint8_t pos, uint8_t tile)
{
    uint8_t i;
    for (i = 0; i < ovr_cnt; i++)
        if (ovr_room[i] == room && ovr_pos[i] == pos) { ovr_tile[i] = tile; return; }
    if (ovr_cnt < OVR_MAX) {
        ovr_room[ovr_cnt] = room; ovr_pos[ovr_cnt] = pos;
        ovr_tile[ovr_cnt] = tile; ovr_cnt++;
    }
}

/* Применить переопределения комнаты room к массиву тайлов: base = tilepos
 * первого элемента (0 для полной комнаты, 20 для ряда 2 верхнего соседа). */
static void apply_overrides(uint8_t room, uint8_t *tiles, uint8_t base, uint8_t n)
{
    uint8_t i;
    for (i = 0; i < ovr_cnt; i++)
        if (ovr_room[i] == room && ovr_pos[i] >= base && ovr_pos[i] < base + n)
            tiles[ovr_pos[i] - base] = ovr_tile[i];
}

/* Загрузить комнату room в рабочие массивы и отрисовать её фон в ОБЕ
 * страницы дабл-буфера (у каждой своя видео-ОЗУ/теневая копия).  Оставляет
 * активной страницу 1 — вызывающий восстанавливает нужную draw-страницу. */
static void enter_room(uint8_t room)
{
    uint8_t pg;
    uint8_t *room_mod;
    pop_room_load(room, room_fg, room_bg, lcol_fg, lcol_bg, rcol_fg, rcol_bg, below_fg);
    apply_overrides(room, room_fg, 0, 30);   /* щебень/пустота от упавших плит */
    pop_map_set(room_fg);
    pop_map_set_edges(pop_room_link(room, 0), pop_room_link(room, 1),
                      pop_room_link(room, 2), pop_room_link(room, 3),
                      lcol_fg, rcol_fg);
    pop_room_set_below(below_fg);
    /* Ряд 2 верхнего соседа → полоса кладки у потолка (row0).  fg — статика
     * уровня, mod — живой room_modif (ленивая инициализация). */
    {
        uint8_t up = pop_room_link(room, 2), c;
        if (up) {
            uint8_t *um = pop_trob_modif(up);
            pop_level_access_begin();
            for (c = 0; c < 10; c++) above_fg[c] = pop_level_tile_raw(up, (uint8_t)(20 + c));
            pop_level_access_end();
            apply_overrides(up, above_fg, 20, 10);   /* провалившийся потолок = колодец */
            for (c = 0; c < 10; c++) above_mod[c] = um[20 + c];
            pop_room_set_above(above_fg, above_mod);
            pop_map_set_above(above_fg);     /* плита-потолок: пробой снизу + провал */
        } else {
            pop_room_set_above(0, 0);        /* нет комнаты сверху → пол (кромка) */
            pop_map_set_above(0);
        }
    }
    pop_map_set_room(room);
    pop_loose_reset();                 /* loose-состояние не тянем из старой комнаты */
    pop_trob_room_changed();           /* отложенные перерисовки пик — не из старой комнаты */
    pop_trob_anim_room(room);          /* факелы/зелья: стартовая фаза + trob */
    pop_guard_enter(room);             /* страж комнаты (порт enter_guard) */
    /* Модификаторы тайлов (openness ворот, состояние пик) — ПЕРСИСТЕНТНЫЕ
     * per-room (room_modif живёт между входами); рисуем и коллидируем по ним,
     * а не по свежему backtable.  Фаза P0. */
    room_mod = pop_trob_modif(room);
    /* Модификаторы швов — из ЖИВОГО room_modif соседей (openness ворот,
     * видимых через шов, персистентен: ворота room8(0,9) видны в col0 room6).
     * pop_room_load заполнил lcol_bg/rcol_bg статикой уровня — перекрываем. */
    {
        uint8_t lft = pop_room_link(room, 0), rgt = pop_room_link(room, 1);
        if (lft) { uint8_t *m = pop_trob_modif(lft);
                   lcol_bg[0] = m[9];  lcol_bg[1] = m[19]; lcol_bg[2] = m[29];
                   seam_sig = m[9]; }   /* шов рисуется в обе страницы ниже — синхр. сигнатуру */
        if (rgt) { uint8_t *m = pop_trob_modif(rgt);
                   rcol_bg[0] = m[0];  rcol_bg[1] = m[10]; rcol_bg[2] = m[20]; }
    }
    seam_redraw = 0;                     /* шов свежий на обеих страницах — редрой не нужен */
    for (pg = 0; pg < 2; pg++) {
        gfx_set_draw_page(pg);
        setfillstyle(SOLID_FILL, BLACK);
        bar(0, 0, 319, 255);
        pop_room_draw(room, room_fg, room_mod, lcol_fg, lcol_bg);
    }
    cur_room = room;
    kid_room = room;      /* S1: комната Kid синхронна отрисованной (S3 разведёт) */
    pop_leave_timer = 2;  /* exit_room_timer: 2 кадра блокировки leave (анти-ping-pong/#4) */
}

int main(void)
{
    /* Дабл-буфер: front — видимая страница, back — куда рисуем.  dbuf=1
     * по умолчанию (без мерцания); SPACE переключает в однобуфер для
     * отладки багов рисования (edge по sp_prev, чтоб не дёргать). */
    uint8_t front = 0, back, dbuf = 1, sp_prev = 0, frozen = 0;
    uint16_t dead_frames = 0;
#ifdef ROOMNAV
    uint8_t nav_prev = 0;
#endif
    uint8_t cheat_prev = 0;

    if (pop_bg_load() != 0) {          /* атласы — ДО initgraph (снимает DSS-страницу W0) */
        puts("pop_bg_load failed");
        return 1;
    }
    pop_cheats = 1;                    /* режим разработки: читы включены */
    pop_guard_reset();
    if (pop_kid_data_load("KID\\kid_data.bin") != 0) {   /* кадры+seqtbl в EMM-странице */
        printf("kid_data.bin load failed\n");
        return 1;
    }
    pop_sword_load();                  /* меч в руке (без него кадры 229+ без клинка) */
    pop_guard_load();                  /* атласы стража (GUARD\\g0..g4) */
    if (pop_kid_load(28) != 0) {       /* ВСЕ страницы: бег+стоп+разворот+присед+прыжок */
        puts("kid atlas load failed");
        return 1;
    }
    if (pop_level_load("LEVELS\\res2001.bin") != 0 &&   /* сырой уровень 1 в EMM-страницу */
        pop_level_load("a:\\res2001.bin") != 0) {
        puts("level load failed");
        return 1;
    }

    initgraph();
    gfx_set_visible_page(0);
    if (gfx_pal_fload(0, "KID\\kid.pal") < 0)   /* единая игровая палитра */
        gfx_pal_fload(0, "a:\\kid.pal");
    gfx_pal_sync();                        /* палитра 0 -> плоскость 1 */

    /* Фон комнаты рисуется в ОБЕ графические страницы: у каждой своя
     * ОЗУ-копия/видео-ОЗУ, а heal берёт чистый фон из ОЗУ-копии ТОЙ
     * страницы, в которую рисуем.  Дальше каждый тик восстанавливаем
     * ТОЛЬКО прямоугольник Кида (kid_heal), а не весь экран. */
    /* Извлечь и отрисовать стартовую комнату (в обе страницы).  P0: сбросить
     * trob/room_modif (ленивая инициализация из уровня при первом входе). */
    pop_trob_reset();
    enter_room(START_ROOM);
    gfx_set_draw_page(0);

    /* K2b: Kid стоит на уступе (row1), управляется с клавиатуры.
     * ←/→ бег, ↓ присед, ↑+→ прыжок с места, Shift шаг (K3).  ESC — выход.
     * Карта коллизии (pop_map_set) уже задана в enter_room. */
    kid_init(SEQ_STAND, START_COL, START_ROW, 0);
    pop_kid_hp_reset();
    kid_draw();
    pop_fore_over_kid(kid_fp_obj_x(), kid_fp_obj_y(),
                      kid_fp_width(), kid_fp_height(),
                      Kid.direction, Kid.frame, Kid.action);

    if (pop_ctrl_init() != 0) {        /* raw-канал клавиатуры (забирает ввод у DSS) */
        closegraph();
        puts("kbd_raw open failed");
        return 1;
    }

    while (!kbd_raw_down(KBD_ESC)) {
        /* SPACE — тумблер дабл-буфера (edge, чтоб одно нажатие = один
         * переключ).  Выключение возвращает показ на страницу 0. */

        PROF(1);                       /* ввод + heal */

        uint8_t sp = kbd_raw_down(KBD_SPACE);
        if (sp && !sp_prev) {
            dbuf ^= 1;
            if (!dbuf) {
                gfx_set_visible_page(0);
                front = 0;
            }
        }
        sp_prev = sp;

        /* Отладочный стоп-кадр: '1' (PS/2 0x16) — заморозить, '2' (0x1E) —
         * продолжить.  В заморозке пропускаем весь tick/draw/flip: картинка
         * стоит, можно спокойно разбирать позу Kid и окклюзию. */
        if (kbd_raw_down(0x16)) frozen = 1;
        if (kbd_raw_down(0x1E)) frozen = 0;
        {   /* Читы (seg000: switch под if (cheats_enabled)).  K — убить
             * стража; по фронту нажатия, чтобы не срабатывало каждый кадр. */
            uint8_t k = kbd_raw_down(KBD_CHEAT_KILL);
            if (pop_cheats && k && !cheat_prev) pop_guard_kill();
            cheat_prev = k;
        }
        if (frozen) {
	    PROF(0);                              /* чёрный: ждём vsync    */
            gfx_wait_vsync();
            continue;
        }

#ifdef ROOMNAV
        /* Обход комнат по номеру: '+' (0x79 numpad / 0x55 '=') — вперёд,
         * '-' (0x7B / 0x4E) — назад.  Edge по nav_prev: одно нажатие = одна
         * комната.  pop_trob_reset ДО enter_room — каждая комната смотрится в
         * исходном состоянии (пики убраны, ворота закрыты). */
        {
            uint8_t nav = (uint8_t)((kbd_raw_down(0x79) || kbd_raw_down(0x55)) |
                                    ((kbd_raw_down(0x7B) || kbd_raw_down(0x4E)) << 1));
            if (nav && !nav_prev) {
                uint8_t r = cur_room, i, c, pos = 20, any = 0xFF;
                r = (nav & 1) ? (uint8_t)(r == 24 ? 1 : r + 1)
                              : (uint8_t)(r == 1 ? 24 : r - 1);
                pop_trob_reset();
                enter_room(r);
                /* Предпочитаем обычный пол; иначе — любой tile_is_floor
                 * (seg001): всё, кроме пустоты/стены/верхов колонны и двери. */
                for (i = 0; i < 30; i++) {
                    c = (uint8_t)(room_fg[i] & 0x1F);
                    if (c == 1) { any = i; break; }
                    if (any == 0xFF && c && c != 9 && c != 12 && c != 20 &&
                        !(c >= 26 && c <= 29)) any = i;
                }
                if (any != 0xFF) pos = any;
                kid_init(SEQ_STAND, (int8_t)(pos % 10), (int8_t)(pos / 10), 0);
                pop_kid_hp_reset();
                dead_frames = 0;
            }
            nav_prev = nav;
        }
#endif

        /* Рисуем в СКРЫТУЮ страницу (при dbuf); в однобуфере — в 0. */
        back = dbuf ? (uint8_t)(front ^ 1) : 0;
        gfx_set_draw_page(back);

        pop_ctrl_tick();               /* ввод -> control(): смена seq */
        kid_heal();                    /* стереть прошлый кадр ЭТОЙ страницы */
        pop_guard_heal();              /* и прошлый кадр стража */
        pop_fore_heal();               /* + следы оверлея (шире прямоугольника Kid) */
        PROF(2);                       /* логика */
        kid_tick();                    /* play_seq: следующий кадр */
        pop_phys_tick();               /* K3: падение/приземление/стена */
        pop_guard_tick();              /* логика стража — В БАНКЕ (guards.c) */
        if (pop_fell_out) {            /* Kid пересёк нижнюю границу комнаты */
            uint8_t down = pop_room_link(cur_room, LINK_DOWN);
            pop_fell_out = 0;
            if (down) {                /* L2: переход в комнату снизу — продолжает падать */
                enter_room(down);      /* координаты Kid уже репроецированы pop_map */
                gfx_set_draw_page(back);   /* вернуть текущую back для kid_draw */
            } else {                   /* выпал из уровня (нет комнаты снизу) — респавн */
                pop_trob_reset();      /* рестарт уровня: пики/ворота в исходное */
                enter_room(START_ROOM);
                gfx_set_draw_page(back);
                kid_init(SEQ_STAND, START_COL, START_ROW, 0);
                pop_kid_hp_reset();
            }
        } else if (pop_leave_dir) {    /* L3: уход вбок/вверх (координаты уже репроецированы) */
            uint8_t nb = pop_room_link(cur_room, (uint8_t)(pop_leave_dir - 1));
            pop_leave_dir = 0;
            if (nb) {
                enter_room(nb);
                gfx_set_draw_page(back);
            }
        }

        PROF(3);                       /* слой фона */

        pop_loose_tick();              /* loose-полы: анимация + перерисовка (СЛОЙ ФОНА */
                                       /* — ДО Kid, чтобы Kid всегда был поверх плиты) */
        pop_process_trobs(cur_room);   /* пики/ворота/дверь: продвинуть СОСТОЯНИЕ (порт */
                                       /* process_trobs — рисования внутри нет) */
        pop_redraw_needed();           /* и разобрать пометки перерисовки тайлов (порт */
                                       /* redraw_needed, seg008:0178) — СЛОЙ ФОНА, до Kid */
        {                              /* ворота соседа слева (room8) видны в col0 — */
            uint8_t lft = pop_room_link(cur_room, 0);   /* редрой шва ТОЛЬКО при изменении openness */
            if (lft) {
                uint8_t *m = pop_trob_modif(lft);
                uint8_t g = m[9], prev = seam_sig;
                seam_sig = g;                    /* СНАЧАЛА сохранить (обход SDCC z80 sub-store */
                                                 /* бага: `if(g!=s)s=g` эмитит store РАЗНОСТИ g-s, */
                                                 /* не g — sdcc_z80_cmp_store_a_bug) */
                if (g != prev) seam_redraw = 2;  /* openness изменился → обе страницы дабл-буфера */
                if (seam_redraw) {
                    lcol_bg[0] = m[9]; lcol_bg[1] = m[19]; lcol_bg[2] = m[29];
                    pop_room_redraw_seam_left();
                    seam_redraw--;
                }
            }
        }
        if (pop_kid_dead) {            /* напоролся на пики: труп лежит; респавн по ↑ */
            dead_frames++;
            if (dead_frames > RESPAWN_SETTLE &&
                (kbd_raw_down(KBD_UP) || dead_frames > RESPAWN_DELAY)) {
                dead_frames = 0;
                pop_trob_reset();      /* рестарт уровня: пики/ворота в исходное */
                enter_room(START_ROOM);
                gfx_set_draw_page(back);
                kid_init(SEQ_STAND, START_COL, START_ROW, 0);
                pop_kid_hp_reset();
            }
        }
        if (pop_loose_fell) {          /* упавший кусок → debris в комнате снизу */
            uint8_t fpos = (uint8_t)(pop_loose_fell - 1);
            uint8_t fcol = (uint8_t)(fpos % 10);
            uint8_t down = pop_room_link(cur_room, LINK_DOWN);
            pop_loose_fell = 0;
            add_tile_override(cur_room, fpos, TILE_EMPTY);   /* сама плита исчезла */
            if (down) {
                int8_t lrow = pop_room_col_landing(down, fcol);
                if (lrow >= 0) add_tile_override(down, (uint8_t)(lrow * 10 + fcol), TILE_DEBRIS);
            }
        }
        if (pop_ceil_fell) {           /* провалилась плита-ПОТОЛОК (ряд 2 комнаты сверху) */
            uint8_t ccol = (uint8_t)(pop_ceil_fell - 1);
            uint8_t up = pop_room_link(cur_room, 2);
            pop_ceil_fell = 0;
            if (up) add_tile_override(up, (uint8_t)(20 + ccol), TILE_EMPTY);  /* колодец */
        }
        if (pop_debris_at) {           /* кусок лёг в ЭТОЙ комнате → щебень */
            add_tile_override(cur_room, (uint8_t)(pop_debris_at - 1), TILE_DEBRIS);
            pop_debris_at = 0;
        }
        if (pop_item_taken) {          /* предмет поднят → тайл стал полом */
            item_pos  = (uint8_t)(pop_item_taken - 1);
            item_bake = 2;             /* запечь на ОБЕИХ страницах */
            add_tile_override(cur_room, item_pos, TILE_FLOOR);
            pop_add_trob(cur_room, item_pos, -1);   /* меч убран — блеска больше нет */
            pop_item_taken = 0;
        }
        if (item_bake) {               /* стереть спрайт меча из фона страницы */
            pop_floor_bake(item_pos / 10, item_pos % 10);
            item_bake--;
        }
        /* Вспышка фона — порт flash_if_hurt/remove_flash_if_hurt (seg003:0AFC):
         * do_flash(color) = set_bg_attr(0, color), т.е. подмена НУЛЕВОЙ записи
         * палитры (вспыхивает всё чёрное поле).  Оригинал ставит цвет и СНИМАЕТ
         * его В ТОМ ЖЕ кадре, поэтому пока идёт flash_time видно СТРОБ
         * «жёлтый/чёрный», а не одну длинную заливку.  Снятие — после первого
         * gfx_wait_vsync (ниже): цвет держится ~1 растровый кадр из трёх.
         * Приоритет как в оригинале: активный flash_time > кадр урона
         * (hitp_delta<0 -> ярко-красный, ровно на один кадр). */
        if (pop_flash_time) {
            flash_bg(255, 255, 85);            /* color_14_brightyellow */
            pop_flash_time--;
            flash_on = 1;
        } else if (pop_kid_hurt) {
            flash_bg(255, 85, 85);             /* color_12_brightred */
            flash_on = 1;
        }
        update_kid_render_dx();        /* straddle: смещение спрайта, если kid_room≠cur_room */
        PROF(5);                       /* страж: спрайт + fore поверх него */
        pop_guard_draw();              /* страж — ДО Kid (порядок как в оригинале) */
        PROF(4);                       /* kid_draw */
        kid_draw();                    /* нарисовать новый кадр (детект выхода за поле) */
        pop_loose_mob_draw_over();     /* падающая плита НИЖЕ Kid → поверх него (y-порядок) */
        if (pop_kid_hurt) {            /* HP убавилось → «брызги» удара (draw_hurt_splash) */
            kid_draw_splash();
            pop_kid_hurt = 0;
        }
        PROF(6);                       /* fore поверх Kid + борта */
        pop_fore_over_kid(kid_fp_obj_x(), kid_fp_obj_y(),
                          kid_fp_width(), kid_fp_height(),
                          Kid.direction, Kid.frame, Kid.action);
        pop_room_clip_borders();       /* почистить борта — только в кадрах падения (гейт) */

        /* Пейсинг 3 кадра, затем tear-free флип на vblank: draw уже
         * сделан (скрытая страница), wait_vsync ловит начало кадра,
         * set_visible_page переключает во время бланка (gfx.h паттерн). */

        PROF(0);                              /* чёрный: ждём vsync    */

        /* Отладка: номер отрисованной комнаты в верхнем борте — рисуем ТОЛЬКО
         * при её смене (change-driven, счётчик 2 = обе страницы дабл-буфера),
         * а не каждый кадр (обход sdcc_z80_cmp_store_a_bug: сначала сохранить). */
#ifdef ROOMNAV
        {
            uint8_t r = cur_room, prev = room_label_sig;
            room_label_sig = r;              /* СНАЧАЛА сохранить (sdcc_z80_cmp_store_a_bug) */
            if (r != prev) room_label_redraw = 2;
            if (room_label_redraw) {
                /* Номер ПАЛОЧКАМИ, а не outtextxy: текст тянет системный
                 * знакогенератор (_gfx_font_buf, 2 КБ статики в W2) и сажает
                 * кучу с 3867 до 576 Б.  Слева десятки, справа единицы:
                 * ||  |||| = 24.  bar/setfillstyle уже используются. */
                uint8_t i;
                setfillstyle(SOLID_FILL, BLACK);
                bar(100, 0, 175, 5);
                /* 0x57, а НЕ WHITE: палитра игровая, запись 15 в ней чёрная
                 * (kid.pal: 0x0F = 0,0,0; чистый белый = 0x57). */
                setfillstyle(SOLID_FILL, 0x57);
                for (i = 0; i < (uint8_t)(r / 10); i++) bar(100 + i * 5, 0, 101 + i * 5, 5);
                for (i = 0; i < (uint8_t)(r % 10); i++) bar(130 + i * 5, 0, 131 + i * 5, 5);
                room_label_redraw--;
            }
        }
#endif

        gfx_wait_vsync();
        if (flash_on) {                /* строб: цвет держался один кадр растра */
            flash_bg(0, 0, 0);
            flash_on = 0;
        }
        gfx_wait_vsync();
        gfx_wait_vsync();
        if (dbuf) {
            gfx_set_visible_page(back);
            front = back;
        }
    }

    pop_ctrl_close();
    closegraph();
    pop_bg_free();
    pop_kid_free();
    pop_guard_free();
    pop_kid_data_free();
    pop_level_free();
    return 0;
}