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"

__sfr __at (0xFE) io_border;

/* 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 6
#define START_COL  4
#define START_ROW  0
#define RESPAWN_DELAY 400  /* авто-респавн (фолбэк), если не нажали ↑ */
#define RESPAWN_SETTLE 20  /* тиков до приёма ↑ (труп успел лечь) */

/* Рабочая копия ТЕКУЩЕЙ комнаты (W2, мутабельная: loose→empty) + срезы
 * соседей для кромок.  Заполняются pop_room_load из уровня.  File-scope,
 * чтобы enter_room переключал комнату без длинного списка параметров. */
static uint8_t room_fg[30], room_bg[30];
static uint8_t lcol_fg[3], lcol_bg[3], rcol_fg[3], 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 OVR_MAX         8
static uint8_t ovr_room[OVR_MAX], ovr_pos[OVR_MAX], ovr_tile[OVR_MAX], ovr_cnt;

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();           /* отложенные перерисовки пик — не из старой комнаты */
    /* Модификаторы тайлов (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;

    if (pop_bg_load() != 0) {          /* атласы — ДО initgraph (снимает DSS-страницу W0) */
        puts("pop_bg_load failed");
        return 1;
    }
    if (pop_kid_load(28) != 0) {       /* ВСЕ страницы: бег+стоп+разворот+присед+прыжок */
        puts("kid atlas load failed");
        return 1;
    }
    if (pop_level_load("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.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. */

        io_border = 2; /* синий - начало */

        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;
        if (frozen) {
	    io_border = 0;                        /* черный: ждём vsync    */
            gfx_wait_vsync();
            continue;
        }

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

        pop_ctrl_tick();               /* ввод -> control(): смена seq */
        kid_heal();                    /* стереть прошлый кадр ЭТОЙ страницы */
        pop_fore_heal();               /* + следы оверлея (шире прямоугольника Kid) */
        kid_tick();                    /* play_seq: следующий кадр */
        pop_phys_tick();               /* K3: падение/приземление/стена */
        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);
            }
        }

        io_border = 4;                 /* зеленый */

        pop_loose_tick();              /* loose-полы: анимация + перерисовка (СЛОЙ ФОНА */
                                       /* — ДО Kid, чтобы Kid всегда был поверх плиты) */
        io_border = 6;                 /* голубой */
        pop_process_trobs(cur_room);   /* пики/ворота: продвинуть + перерисовать (тоже */
                                       /* слой фона — ДО Kid) */
        io_border = 2;                 /* синий   */
        {                              /* ворота соседа слева (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--;
                }
            }
        }
        io_border = 4;                 /* зеленый */
        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();
            }
        }
        io_border = 6;                 /* голубой */
        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;
	    io_border = 2;                 /* синий   */
            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;
        }
        io_border = 4;                 /* зеленый */
        update_kid_render_dx();        /* straddle: смещение спрайта, если kid_room≠cur_room */
        kid_draw();                    /* нарисовать новый кадр (детект выхода за поле) */
        pop_loose_mob_draw_over();     /* падающая плита НИЖЕ Kid → поверх него (y-порядок) */
        if (pop_kid_hurt) {            /* HP убавилось → «брызги» удара (draw_hurt_splash) */
            kid_draw_splash();
            pop_kid_hurt = 0;
        }
        io_border = 0;                 /* черный */
        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 паттерн). */

        io_border = 0;                        /* черный: ждём vsync    */

        /* Отладка: номер отрисованной комнаты в верхнем борте — рисуем ТОЛЬКО
         * при её смене (change-driven, счётчик 2 = обе страницы дабл-буфера),
         * а не каждый кадр (обход sdcc_z80_cmp_store_a_bug: сначала сохранить). */
        {
            uint8_t r = cur_room;
//            if (r != room_label_sig) { room_label_sig = r; room_label_redraw = 2; }
//            if (room_label_redraw) {
//                char roomLabel[] = "Room ##";
//                roomLabel[5] = (char)(r / 10 + '0');
//                roomLabel[6] = (char)(r % 10 + '0');
//                setcolor(WHITE);
//                outtextxy(100, 0, roomLabel);
//                room_label_redraw--;
//            }
        }

        gfx_wait_vsync();
        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_level_free();
    return 0;
}