/* * roomtest.c — проверка порта статического фона (Шаг 3): рисует комнату 1 * уровня 1 реальной композицией слоёв (pop_bg.c) и держит на экране. * Сверять на MAME с эталоном applications/PoP/toolchain/1.1-2.png. */ #include #include #include #include #include #include #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_geom.h" /* pop_y_to_row, TILE_SIZEX — тайл объекта */ #include "pop_guard.h" #include "pop_cdraw.h" /* общая отрисовка персонажей (слоты Кид/соперник) */ #include "pop_cheat.h" #include "pop_tune.h" __sfr __at (0xFE) io_border; /* ПРОФИЛИРОВАНИЕ ПОЛОСАМИ БОРДЮРА (включено по умолчанию; make PROF=0 — * выключить). Цвет бордюра держится, пока фаза считает, поэтому высота * полосы на скриншоте = время фазы в растровых строках. Это единственный * способ смотреть профиль без дебаггера: выборка PC вырождается (мост MAME * отвечает из фреймового колбэка, все сэмплы падают в обработчик * прерывания); точные такты — breakpoint'ы с {printf totalcycles; g}. * * ЦВЕТА: у бордюра Sprinter бит 0 (красный) ИГНОРИРУЕТСЯ, работают только * бит 1 (синий) и бит 2 (зелёный) — значит различимых состояний ровно * ЧЕТЫРЕ, и значения обязаны быть чётными. Отсюда фазы сгруппированы по * четыре, а не по семь (нечётные номера раньше сливались с соседями и * полосы не читались): * 0 чёрный — ожидание vsync (запас кадра) * 2 синий — ввод, heal и ЛОГИКА (kid_tick/физика/страж) * 4 зелёный — слой ФОНА (loose/trobs/redraw_needed/шов) * 6 циан — СПРАЙТЫ (страж, Kid, fore поверх них) */ #ifndef PROF_BORDER #define PROF_BORDER 1 #endif #if PROF_BORDER #define PROF(n) io_border = (n) #else #define PROF(n) ((void)0) #endif /* Сколько банков грузит crt0_banked (читает его стартовый код). * 1 = guards (ИИ/боёвка), 2 = pop_bg (ГОРЯЧАЯ половина фона: fore-проход, * оверлеи, кладка), 3 = pop_map (коллизия/физика), 4 = pop_cdraw * (отрисовка персонажей + полоса HP), 5 = pop_ctrl (диспетчер управления), * 6 = pop_trob (ловушки/анимация тайлов), 7 = pop_room (ХОЛОДНАЯ половина * фона: полная отрисовка комнаты, точечные перерисовки, падающие плиты). * Отрисовка персонажей и холодная половина фона вынесены из банка 2 * отдельно: тот дважды подходил к 16 КБ вплотную, а расти ему ещё есть * куда — тайлы поздних уровней, чомперы, зеркало. * * ДЕРЖАТЬ В СОГЛАСИИ с числом --bank в Makefile. Забыть — это не ошибка * сборки, а зависание: crt0 выделит меньше страниц, _bank_pages[N] так и * останется нулём, и трамплин прыгнет по 0xC000 в мусор (см. шапку * runtime/bank.s). Проверено 2026-08-05: с n_banks=4 и пятым банком игра * доходила до конца загрузки ресурсов и вставала намертво в DSS. */ const uint8_t n_banks = 7; /* Режим читов (pop_cheat.h): на время разработки включаем в main. */ uint8_t pop_cheats; /* ПОТЕРЯ НАЖАТИЙ ПРИ ЗАЖАТОМ Shift — лечится ПЛОТНЫМ опросом клавиатуры. * * При зажатом Shift PS/2 обрамляет расширенный код «фиктивным шифтом», и * одно нажатие стрелки превращается в 5 байт вместо 2 (отпускание — тоже * 5). Приёмный FIFO SIO — 3 байта, а импульс запроса прерывания здесь * теряется примерно в 44 % случаев, поэтому байты копятся и один из * полусотни пропадает ДО чтения порта: нажатие «не срабатывает». * * Что НЕ помогает (замерено, TASKS_CLOSED.md/KBD-1): редкий опрос (несколько * вызовов за кадр — они попадают туда, где прерывания и так разрешены, и * лишь дублируют трамплин) и укорачивание DI-окон графики (в кадре вообще * без блитов потерь БОЛЬШЕ). Снимать `di` в accel-ядрах нельзя — машина * уходит в перезагрузку. * * Что помогает: опрос раз в ~0.5 мс. Столько времени берётся из ожидания * кадра — процессор всё равно крутит там ~42 мс из 60, ничего не делая. * Поэтому kbd_raw_poll вешается idle-хуком на gfx_wait_vsync (см. * kbd_idle ниже); полезной работы это не отнимает. Потолок приёма * подтверждён отдельно (tests/kbdpoll: 25 нажатий → 25, 250 байт из 250). */ /* Обёртка ради типа: хук — void(*)(void), а kbd_raw_poll возвращает * «было ли что вычерпано». Приводить указатель кастом не хочется. */ static void kbd_idle(void) { kbd_raw_poll(); } /* 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 */ #ifndef FIRST_LEVEL #define FIRST_LEVEL 1 /* с какого уровня начинается игра (-DFIRST_LEVEL=N) */ #endif #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[11]; 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. Звать каждый кадр перед отрисовкой персонажей. */ 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_char_set_render_dx(POP_CH_KID, dx); } /* ---- Порядок «Kid vs страж» (BUG-DRAWORDER-1) ----------------------- * * В оригинале никто не «поверх» по определению: и Кид, и страж попадают в * midtable при обработке СВОЕГО тайла (set_objtile_at_char, seg006:13F3), а * тайлы обходятся в фиксированном порядке — redraw_needed_tiles (seg008:1B06) * идёт рядами 2,1,0 и внутри ряда колонками 0..9. Кто нарисован ПОЗЖЕ — тот * поверх. Отсюда «Кид проходит ЗА телом стража»: тело лежит правее и/или * выше, его тайл в обходе позже. Совпали тайлы — решает sort_curr_objs * (seg008:203C): у обычных объектов (не тень, не плита) ниже по obj_y = позже. * * Мы рисовали страж→Кид всегда, то есть Кид был поверх безусловно. * * Ключ обхода: чем больше, тем позже. Ряды идут 2,1,0 → (2 - row). */ #define OBJ_ORDER_KEY(row, col) ((int)(2 - (row)) * 10 + (int)(col)) /* get_tile_div_mod (seg006:750): колонка комнаты по X (БЕЗ поправки −7). */ static int8_t tile_div_mod(int x) { int v = x - 58; /* pop_x_bump[FIRST_ONSCREEN_COLUMN] */ int c = v / TILE_SIZEX; if (v % TILE_SIZEX < 0) --c; return (int8_t)c; } /* char_x_left из set_char_collision (seg006:0723) — левая граница габарита. * ВАЖНО: величина НЕ утоньшённая; поправку THIN оригинал применяет только к * *_coll, а колонки char_col_left/right считает по этой. */ static int char_x_left_of(uint8_t x, int8_t dir, int8_t dx, uint8_t flags, uint16_t w) { int e = (int)x + ((dir < 0) ? -dx : dx); /* char_dx_forward */ uint8_t fl = flags; if (dir < 0) fl ^= 0x80; /* odd-pixel + усечение деления к нулю — та же поправка, что в pop_map */ if (!(fl & 0x80) && e <= 57) e++; if (dir >= 0) e -= (int)((w + 1) >> 1); /* char_width_half */ return e; } /* set_objtile_at_char (seg006:13F3) — ТАЙЛ ОБЪЕКТА персонажа. * * Ветка actions_1_run_jump обязательна, а не «упрощаемая» (как я решил * сначала): в беге оригинал берёт НЕ curr_row/curr_col, а нижний ряд и ЛЕВУЮ * колонку ГАБАРИТА. При беге вправо левая колонка меньше curr_col, поэтому * бегущий Кид уходит ЗА объекты справа от себя. Без этой ветки часть кадров * бега рисовала Кида поверх лежащего стража. Считаем одинаково для обоих: * enter_guard (seg002) тоже ставит стражу action = 1, и односторонний учёт * дал бы перекос в другую сторону. */ static void objtile_at_char(int8_t *row, int8_t *col, const pop_char_t *ch, int8_t dx, int8_t dy, uint8_t flags, uint16_t w) { int8_t r = ch->curr_row, c = ch->curr_col; if (ch->action == 1) { /* actions_1_run_jump */ int8_t br = pop_y_to_row((int16_t)((int)ch->y + dy)); if (br == -1) br = 3; /* char_bottom_row */ r = br; c = tile_div_mod(char_x_left_of(ch->x, ch->direction, dx, flags, w)); if (c < 0) c = 0; /* MAX(char_col_left, 0) */ } if ((ch->frame >= 135 && ch->frame < 149) || ch->action == 2 || ch->action == 3 || ch->action == 4 || ch->action == 6) c--; *row = r; *col = c; } /* 1 = страж рисуется ПОСЛЕ Кида (поверх). */ static uint8_t guard_over_kid(void) { int8_t kr, kc, gr, gc; int kk, gk; if (Guard.charid == 0 || Guard.room != cur_room) return 0; objtile_at_char(&kr, &kc, &Kid, kid_cur_dx(), kid_cur_dy(), kid_cur_flags(), pop_cd[POP_CH_KID].fpw); objtile_at_char(&gr, &gc, &Guard, pop_gframe.dx, pop_gframe.dy, pop_gframe.flags, pop_cd[POP_CH_OPP].fpw); kk = OBJ_ORDER_KEY(kr, kc); gk = OBJ_ORDER_KEY(gr, gc); if (gk != kk) return (uint8_t)(gk > kk); /* один тайл — ниже по obj_y рисуется позже (sort_curr_objs) */ return (uint8_t)((int)Guard.y + pop_gframe.dy > pop_cd[POP_CH_KID].fpy); } /* Change-driven редрой ЛЕВОГО шва (ворота соседа room8 видны в col0): тяжёлый * draw_tile(0,0) в pop_room_redraw_seam_left зовём ТОЛЬКО когда openness гейта * реально изменился. Пока Кид держит кнопку и гейт открыт — modifier стабилен * → 0 редроёв (раньше шов рисовался безусловно КАЖДЫЙ кадр, пока сосед активен * — тот же класс, что был у кнопки). seam_redraw=2 = обе страницы дабл-буфера. * * Сигнатура — ВСЕ ТРИ ряда колонки 9 соседа, а не только ряд 0: ворота в шве * бывают в любом ряду. На уровне 1 решётка соседа стояла в (0,9), и одного * байта хватало; на уровне 4 плита комнаты 1 открывает ворота (1,9) комнаты 8 * — изменение приходило в m[19], сигнатура его не видела, редрой не * заказывался, и открытые ворота оставались нарисованными закрытыми * (BUG-GATE-SEAM-ROW1). */ /* Кнопка в шве (SEAM-BUTTON-STALE). Сигнатурой служил ТОЛЬКО modif, а у * кнопки modif — это индекс LINKLOC, то есть константа уровня: нажатие живёт * в doorlinks2 (get_doorlink_timer, seg007:0BB6). Изменение в сигнатуру не * приходило, редрой не заказывался — и шов оставался нарисованным в том * состоянии, в каком был на входе в комнату: кнопка (1,9) комнаты 11, она же * (1,−1) комнаты 24, залипала нажатой (или отжатой), хотя связь срабатывала. * Видимой её делает draw_tile: нажатый opener рисуется как ПОЛ (seg008 * get_tile_to_draw), а у пола есть правая грань, у кнопки — нет. * Поэтому в сигнатуру ряда подмешиваем бит «кнопка нажата». */ static uint8_t seam_row_sig(const uint8_t *m, const uint8_t *lfg, uint8_t r) { uint8_t code = (uint8_t)(lfg[r] & 0x1F); uint8_t mod = m[9 + r * 10]; if (code == 0x0F || code == 0x06) /* opener / closer */ return (uint8_t)((pop_doorlink2(mod) & 0x1F) > 1); return mod; } static uint8_t seam_sig[3]; /* последняя нарисованная openness гейта в шве */ static uint8_t seam_rows; /* маска рядов, ждущих редроя (переживает 2 кадра) */ static uint8_t seam_redraw; /* оставшиеся кадры редроя (обе страницы) */ /* Отладочный лейбл номера комнаты — рисуем только при смене (outtextxy тяжёлая): * sig = последняя показанная комната, redraw = остаток кадров (2 = обе страницы). */ static uint8_t room_label_sig = 0xFF; static uint8_t room_label_redraw; /* Изменения тайлов (упавшая плита → пусто, щебень на месте приземления * куска, поднятый предмет → пол) пишутся ПРЯМО В УРОВЕНЬ — * pop_level_set_tile, как в оригинале (curr_room_tiles[…] = …). Раньше тут * жила таблица переопределений на 8 записей, и девятая правка молча * терялась: разбитые плиты и выпитые зелья «возвращались» при возврате в * комнату (BUG-LVLSTATE-1). */ #define TILE_DEBRIS 0x0E #define TILE_CLOSER 0x06 #define TILE_OPENER 0x0F #define TILE_TORCH 0x13 #define TILE_TORCH_DEBRIS 0x1E #define TILE_EMPTY 0x00 #define TILE_FLOOR 0x01 /* Поднятый предмет (меч): 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); } /* Загрузить комнату room в рабочие массивы и отрисовать её фон в ОБЕ * страницы дабл-буфера (у каждой своя видео-ОЗУ/теневая копия). Оставляет * активной страницу 1 — вызывающий восстанавливает нужную draw-страницу. */ /* side — куда ушёл КИД (0 left, 1 right, 2 up, 3 down); 0xFF = «не переход * за Кидом» (старт уровня, респавн, чит-навигация). От него зависит ровно * одно: пойдёт ли страж следом (pop_guard_follow, порт exit_room+ * follow_guard) или останется в прежней комнате. */ static void enter_room_side(uint8_t room, uint8_t side) { uint8_t pg; /* Страж идёт за Кидом? — решаем ДО того, как что-либо загрузим: функции * нужны и старая комната (Guard.room), и целевая. Пошёл — ни leave, ни * enter звать нельзя: он уже перенесён и живёт дальше как есть. */ uint8_t follow = (uint8_t)(side <= 3 ? pop_guard_follow(room, side) : 0); if (!follow) pop_guard_leave(); /* запомнить стража уходящей комнаты */ uint8_t *room_mod; pop_room_load(room, room_fg, room_bg, lcol_fg, lcol_bg, rcol_fg, rcol_bg, below_fg); pop_map_set(room_fg); /* Соседей слева/справа карта забирает из уровня САМА (целиком, см. * pop_map_set_edges) — отдельной копии в приложении нет. */ pop_map_set_edges(pop_room_link(room, 0), pop_room_link(room, 1), pop_room_link(room, 2), pop_room_link(room, 3)); /* Боковой переход: колонки сдвинулись ровно на 10 (x ∓140), флаги * перекрытия при этом инвариантны — историю перенумеровываем, а не * теряем. Без этого решётка шва не бампит на кадре входа и Кид с * разбега проходит сквозь закрытые ворота (BUG-GATE-PASS-1). */ if (side == 0) pop_coll_shift(+10); /* ушёл ВЛЕВО: col += 10 */ else if (side == 1) pop_coll_shift(-10); /* ушёл ВПРАВО: col −= 10 */ 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(); 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); /* Kid.room — как в оригинале: «комната персонажа». Полная модель * (Kid.room ≠ отрисованной у шва) ещё не портирована, но сравнение * Kid.room == Guard.room нужно уже сейчас: без него луч видимости * стража никогда не срабатывает. */ Kid.room = room; pop_loose_reset(); /* loose-состояние не тянем из старой комнаты */ pop_trob_room_changed(); /* отложенные перерисовки пик — не из старой комнаты */ pop_trob_anim_room(room); /* факелы/зелья: стартовая фаза + trob */ pop_start_chompers(room, Kid.curr_row); /* seg000:1288: чомперы РЯДА Кида */ /* check_shadow (seg002:0064) стоит ПЕРЕД enter_guard и на «шадоу»- * уровнях забирает слот соперника себе: вернула 1 — стража поднимать * НЕЛЬЗЯ (в комнате 24 уровня 5 он есть в данных, но оригинал его туда * не пускает). Порядок ровно как в оригинале, не «сначала страж, потом * заменим». */ if (!follow && !pop_check_shadow(room)) pop_guard_enter(room); /* страж комнаты (порт enter_guard) */ pop_hp_invalidate(); /* фон перерисован — полоса HP тоже */ /* Модификаторы тайлов (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), i; for (i = 0; i < 3; i++) { lcol_bg[i] = m[9 + i * 10]; /* шов рисуется в обе страницы ниже — синхр. сигнатуру */ seam_sig[i] = seam_row_sig(m, lcol_fg, i); } } 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; seam_rows = 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) */ } /* Вход в комнату БЕЗ перехода за Кидом: старт уровня, респавн, чит-обход. * Страж такой смены не «видит» — он остаётся в своей комнате. */ static void enter_room(uint8_t room) { enter_room_side(room, 0xFF); } /* start_level (seg003:0055) + do_startpos (seg003:01A3) + set_start_pos * (seg003:028A) — поставить Кида в стартовую позицию УРОВНЯ. Один вход и * для запуска, и для рестарта после смерти / выпадения из уровня: в * оригинале это буквально один и тот же путь (play_level_2 зовёт * start_level заново), поэтому и у нас не три копии четырёх строк. * * Позиция берётся ИЗ ДАННЫХ уровня (pop_level_start_*), а не из #define: * start_pos — тайл 0..29 (row*10+col), start_dir — направление, в котором * персонаж должен ОКАЗАТЬСЯ. * * Направление ИНВЕРТИРУЕТСЯ (`Char.direction = ~level.start_dir`): персонаж * ставится спиной и доворачивается кадрами позы входа. Сама поза — из * tbl_entry_pose (data.h:848 = {0,1,0,…,2,…}): * 1 (уровень 1) — падение внутрь (seq_7_fall) + нажатие кнопки room5(0,2); * это оно захлопывает решётку за спиной в первой комнате; * 2 (уровень 13) — вбегание (seq_84_run); * иначе — разворот на месте (seq_5_turn). * Таблица индексируется НОМЕРОМ УРОВНЯ — pop_level_entry_pose(). */ #define SEQ_TURN 5 #define SEQ_FALL 7 #define SEQ_RUN 84 #define ENTRY_POSE_FALL 1 /* tbl_entry_pose[1] */ #define ENTRY_POSE_RUN 2 /* tbl_entry_pose[13] */ #define TILE_LEVELDOOR_LEFT 16 /* tiles_16_level_door_left */ /* find_start_level_door (seg003:02E6): дверь уровня В СТАРТОВОЙ КОМНАТЕ — * это дверь, через которую Кид ВОШЁЛ, поэтому она открыта полностью * (modif = 43) и заводится trob'ом типа 3 (start_level_door, seg007:0D72). * Без этого на уровне 2 Кид материализуется внутри глухой закрытой створки: * его стартовый тайл (комната 5, ряд 1, колонка 3) — правая половина * той самой двери. */ static void find_start_level_door(uint8_t room) { uint8_t *m = pop_trob_modif(room); uint8_t tp; if (!m) return; /* Батч-доступ к странице уровня тут не нужен: функция отрабатывает раз * за уровень, а pop_add_trob сам лезет в W0. */ for (tp = 0; tp < 30; tp++) { if (pop_level_tile(room, tp) != TILE_LEVELDOOR_LEFT) continue; m[tp] = 43; /* створка поднята полностью */ pop_add_trob(room, tp, 3); /* ...и тут же поедет ВНИЗ (type>=3) */ } } /* checkpoint (seg000:270): взводится, когда Кид уходит ВЛЕВО в комнату 7 * уровня 3 (level3_set_chkp, seg002:0665); по нему do_startpos подменяет * стартовую позицию. Сбрасывается началом игры и прохождением уровня — * ровно как в оригинале (seg003:37 и seg003:413). */ static uint8_t pop_checkpoint; static void pop_start_level(void) { pop_leveldoor_open = 0; /* seg003:97 — дверь прошлого уровня не в счёт */ pop_feather = 0; /* seg003:189 — перо не переживает старт уровня */ uint8_t entry_pose = pop_level_entry_pose(pop_current_level); uint8_t start_room = pop_level_start_room(); uint8_t pos = pop_level_start_pos(); int8_t dir = (int8_t)~pop_level_start_dir(); uint8_t seq = SEQ_TURN; /* Особое событие: старт с чекпойнта (do_startpos, seg003:0141). * Числа — в pop_tune.h. Плиту снимаем ПОСЛЕ pop_level_reset_tiles() * ниже, иначе рестарт её вернёт. */ uint8_t chkp = (uint8_t)(pop_current_level == POP_CHKP_LEVEL && pop_checkpoint); if (chkp) { start_room = POP_CHKP_RESPAWN_ROOM; pos = POP_CHKP_RESPAWN_TILEPOS; dir = (int8_t)~POP_CHKP_RESPAWN_DIR; /* стартует в ПРОТИВОположную * и разворачивается seq_5 */ } /* Рестарт уровня = load_level() заново (play_level, seg003:57): в * исходное возвращаются И модификаторы (пики/ворота), И сами тайлы — * разбитые плиты целы, выпитые зелья на месте (BUG-RESPAWN-1), и * убитые стражи снова живы на своих тайлах (BUG-RESPAWN-2). */ pop_trob_reset(); pop_level_reset_tiles(); pop_level_reset_guards(); pop_guard_reset(); /* start_level: Guard.direction = none */ pop_loose_mob_reset(); /* start_level: mobs_count = 0 (seg003:88) */ /* «Особое событие: убрать loose-плиту» (do_startpos): без этого путь в * комнату-чекпойнт после респавна остался бы непройденным. */ if (chkp) pop_level_set_tile(POP_CHKP_CLEAR_ROOM, (uint8_t)(POP_CHKP_CLEAR_ROW * 10 + POP_CHKP_CLEAR_COL), TILE_EMPTY); /* Кнопку жмём ДО отрисовки комнаты — как в оригинале (do_startpos * отрабатывает раньше первого draw_room), иначе шов кадр показывал бы * ещё не тронутое состояние решётки. */ if (entry_pose == ENTRY_POSE_FALL) { /* get_tile(5,2,0) + trigger_button(0,0,-1) — «нажать» кнопку room5, * col2, row0 её же типом и модификатором (в оригинале и то и другое * берётся из curr_* после get_tile). */ uint8_t tp = 2; /* row0*10 + col2 */ pop_trigger_button(5, tp, pop_level_tile(5, tp), pop_trob_modif(5)[tp]); seq = SEQ_FALL; } else if (entry_pose == ENTRY_POSE_RUN) { seq = SEQ_RUN; } /* Тоже ДО отрисовки комнаты: дверь, через которую вошли, обязана быть * открыта уже в первом кадре (в оригинале find_start_level_door стоит * между do_startpos и draw_level_first). */ find_start_level_door(start_room); enter_room(start_room); kid_init(seq, (int8_t)(pos % 10), (int8_t)(pos / 10), dir); /* Спецсобытие «вход падением» (set_start_pos, seg003:0196): на 7-м * уровне Кид ставится в комнату 17, а экран тут же переводится на * комнату ПОД ней (`goto_other_room(3)`: y −= 189, ряд пересчитать) — * он влетает в неё сверху, продолжая падение с шестого уровня. */ if (pop_current_level == FALLING_ENTRY_LEVEL && start_room == FALLING_ENTRY_ROOM) { uint8_t below = pop_room_link(start_room, LINK_DOWN); if (below) { Kid.y = (uint8_t)(Kid.y - 189); Kid.curr_row = pop_y_to_row((int16_t)Kid.y); enter_room(below); } } Kid.sword = 0; /* set_start_pos: sword_0_sheathed */ /* play_level (seg003:106): have_sword = level >= have_sword_from_level * (=2) — начиная со второго уровня меч у Кида уже есть. */ pop_have_sword = (uint8_t)(pop_current_level >= 2); pop_kid_hp_reset(); } int main(void) { /* Дабл-буфер: front — видимая страница, back — куда рисуем. dbuf=1 * по умолчанию (без мерцания); SPACE переключает в однобуфер для * отладки багов рисования (edge по sp_prev, чтоб не дёргать). */ uint8_t front = 0, back, dbuf = 1, sp_prev = 0, frozen = 0; uint8_t skip = 0; /* маска «слот перерисовывать не надо» */ uint16_t dead_frames = 0; #ifdef ROOMNAV uint8_t nav_prev = 0; #endif uint8_t cheat_prev = 0, immo_prev = 0, sword_prev = 0, nlvl_prev = 0; uint8_t xdec_prev = 0, xinc_prev = 0; /* Набор фона — по типу СТАРТОВОГО уровня. Атласы грузятся ДО initgraph * (тот снимает DSS-страницу W0); уровень к этому моменту ещё не прочитан, * поэтому тип берём напрямую от номера. */ pop_current_level = FIRST_LEVEL; if (pop_bg_load(pop_level_type()) != 0) { 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_num(FIRST_LEVEL) != 0) { /* сырой уровень в EMM-страницу */ puts("level load failed"); return 1; } pop_next_level = pop_current_level; /* current_level = next_level (load_lev_spr) */ pop_kid_hp_newgame(); /* init_game: hitp_beg_lev = start_hitp */ pop_checkpoint = 0; /* init_game (seg003:37) */ 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 */ /* kid.pal — ЕДИНАЯ игровая палитра, собранная из VDUNGEON, и она только * что затёрла слоты тайлсета. Возвращаем цвета текущего набора: на * дворцовых уровнях без этого рисуется дворцовая геометрия подземельными * красками (сине-серое вместо песочного). */ pop_bg_pal_apply(); /* Фон комнаты рисуется в ОБЕ графические страницы: у каждой своя * ОЗУ-копия/видео-ОЗУ, а heal берёт чистый фон из ОЗУ-копии ТОЙ * страницы, в которую рисуем. Дальше каждый тик восстанавливаем * ТОЛЬКО прямоугольник Кида (pop_char_heal), а не весь экран. */ /* Извлечь и отрисовать стартовую комнату (в обе страницы). P0: сбросить * trob/room_modif (ленивая инициализация из уровня при первом входе). */ /* Старт — ПО ДАННЫМ УРОВНЯ (комната/тайл/направление/поза входа), см. * pop_start_level. Управление: ←/→ бег, ↓ присед, ↑+→ прыжок с места, * Shift шаг, ESC — выход. Карта коллизии задана внутри enter_room. */ pop_start_level(); gfx_set_draw_page(0); pop_char_draw(POP_CH_KID); pop_char_fore(POP_CH_KID); if (pop_ctrl_init() != 0) { /* raw-канал клавиатуры (забирает ввод у DSS) */ closegraph(); puts("kbd_raw open failed"); return 1; } gfx_set_idle_hook(kbd_idle); /* вычерпывать FIFO, пока ждём кадр */ while (!kbd_raw_down(KBD_ESC)) { /* SPACE — тумблер дабл-буфера (edge, чтоб одно нажатие = один * переключ). Выключение возвращает показ на страницу 0. */ PROF(2); /* ввод + 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 — убить стража; * I — бессмертие Кида (наш отладочный, в оригинале его нет: * иначе боёвку проверять получается ровно три раза); * S — выдать меч, не бегая за ним в комнату 15. Штатно меч * берётся с пола (pop_have_sword ставит подбор); * Shift+L — следующий уровень (seg000:698, ветка next_level = * current_level + 1). Единственный вменяемый способ * тестировать уровни 2..15. NB: L без Shift — отладочный * «осторожный шаг вправо» (pop_ctrl KBD_DBG_STEPR); с * Shift шаг тоже пройдёт, но уровень тут же сменится, так * что конфликта на практике нет; * [ / ] — подвинуть Кида на ПИКСЕЛЬ влево/вправо (seg000:1828, * `--Char.x` / `++Char.x`). Нужен потому, что мост MAME * теряет нажатия при быстрой отправке, и подогнать Кида в * нужную позу скриптом нельзя (на это упёрлись BUG-LOOSE-2 * и BUG-GATE-PASS-1). Пишем прямо в Kid.x: геометрию * персонажа в этом порте задаёт не диспетчер (грабли * L1-EXIT). Колонку не трогаем — её пересчитает физика * следующего кадра. */ uint8_t k = kbd_raw_down(KBD_CHEAT_KILL); uint8_t i = kbd_raw_down(KBD_CHEAT_IMMO); uint8_t s = kbd_raw_down(KBD_CHEAT_SWORD); uint8_t nl = (uint8_t)(kbd_raw_down(KBD_CHEAT_NEXTLVL) && (kbd_raw_down(KBD_LSHIFT) || kbd_raw_down(KBD_RSHIFT))); uint8_t xd = kbd_raw_down(KBD_CHEAT_XDEC); uint8_t xi = kbd_raw_down(KBD_CHEAT_XINC); if (pop_cheats && k && !cheat_prev) pop_guard_kill(); if (pop_cheats && i && !immo_prev) pop_immortal = !pop_immortal; if (pop_cheats && s && !sword_prev) pop_have_sword = 1; if (pop_cheats && nl && !nlvl_prev && pop_current_level < POP_LAST_LEVEL) pop_next_level = (uint8_t)(pop_current_level + 1); if (pop_cheats && xd && !xdec_prev) Kid.x = (uint8_t)(Kid.x - 1); if (pop_cheats && xi && !xinc_prev) Kid.x = (uint8_t)(Kid.x + 1); cheat_prev = k; immo_prev = i; sword_prev = s; nlvl_prev = nl; xdec_prev = xd; xinc_prev = xi; } if (frozen) { PROF(0); /* чёрный: ждём vsync */ gfx_wait_vsync(); continue; } #ifdef ROOMNAV /* Обход комнат по номеру: '+' (0x79 numpad / 0x55 '=') — вперёд, * '-' (0x7B / 0x4E) — назад. Edge по nav_prev: одно нажатие = одна * комната. * * Здесь БЫЛ pop_trob_reset() перед enter_room — «чтобы каждая комната * смотрелась в исходном состоянии». Убран: reset обнуляет room_seen, * и модификаторы перечитываются из уровня заново, то есть чит * ОТМАТЫВАЕТ МИР — открытые/закрытые ворота, выдвинутые пики, нажатые * кнопки. Пока ворота с bg=1 ошибочно стартовали закрытыми, откат был * не виден; после порта load_alter_mod он выглядит как баг «ворота * снова открылись» (уровень 1, решётка комнаты 5 (0,9), которую * закрывает стартовый триггер do_startpos). Навигация обязана только * телепортировать; исходное состояние даёт перезапуск уровня. */ { 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; /* Кид МЁРТВ: сначала честный рестарт уровня, потом телепорт. * Навигация только переставляет Кида (kid_init + сброс HP), * то есть «оживляет» его мимо start_level — а тот обязан * вернуть тайлы, модификаторы и ОЧИСТИТЬ слот соперника * (seg003:100: Guard.direction = dir_56_none). Без этого * после смерти оставался живой скелет рядом с вернувшейся * кучей костей. */ if (pop_kid_dead) { pop_start_level(); dead_frames = 0; } r = (nav & 1) ? (uint8_t)(r == 24 ? 1 : r + 1) : (uint8_t)(r == 1 ? 24 : r - 1); enter_room(r); /* Куда поставить Кида в новой комнате: пол С МАКСИМАЛЬНЫМ Y — * сначала НИЖНИЙ ряд (2), потом 1, и только потом 0 * (пользователь 2026-08-11). Раньше брался первый пол * подряд, то есть почти всегда (0,0) — верхний левый угол: * это и «прилёт» в проём/ворота, и, на уровне 5, посадка * вплотную к тени спецсобытия, которая ждёт в колонке −1 * ряда 0. Вместо сцены кражи зелья начиналась схватка, * которой в этой комнате быть не должно. Снизу вверх нужно * и самой навигации: в верхнем ряду пола чаще нет, и Кид * проваливается из комнаты сразу после телепорта. * * ИСКЛЮЧЕНИЕ — комната 14 уровня 7 (пользователь 2026-08-12): * её проходят СВЕРХУ ВНИЗ (с ряда 0 на ряд 2 через зацеп за * кромки), и с нижнего ряда этот спуск не проверить вовсе. * Пол в ряду 0 там есть, так что Кид не проваливается. * * В каждом ряду сначала ищем ОБЫЧНЫЙ пол, и только если его * там нет — любой проходимый tile_is_floor (seg001: всё, * кроме пустоты, верха колонны, верха двери, стены и * «половинок» 26..29). */ { int8_t row, step = -1, first = 2; if (pop_current_level == GRAB_DOWN_LEVEL && r == GRAB_DOWN_ROOM) { first = 0; step = 1; } for (row = first; row >= 0 && row <= 2 && any == 0xFF; row = (int8_t)(row + step)) { uint8_t fallback = 0xFF; for (i = (uint8_t)(row * 10); i < (uint8_t)(row * 10 + 10); i++) { c = (uint8_t)(room_fg[i] & 0x1F); if (c == 1) { any = i; break; } if (fallback == 0xFF && c && c != 9 && c != 12 && c != 20 && !(c >= 26 && c <= 29)) fallback = i; } if (any == 0xFF) any = fallback; } } 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; /* ВЫХОД ИЗ БОЯ (BUG-CHEAT-FIGHT-1). Телепорт с вынутым мечом * заклинивал управление намертво: pop_control при * Kid.sword == SWORD_2_DRAWN уходит в control_with_sword, а * там единственный выход — ветка «убрать меч» на кадре * FRAME_171_STAND_WITH_SWORD. После kid_init(SEQ_STAND) кадр * обычный, стража в новой комнате нет, swordfight не * запускается — и диспетчер каждый кадр не делает НИЧЕГО. * Это болезнь ЧИТА: в оригинале телепорта между комнатами * нет, попасть в режим боя без соперника нечем. Меч в * инвентаре (pop_have_sword) НЕ теряем — только состояние * схватки. */ Kid.sword = SWORD_0_SHEATHED; holding_sword = 0; offguard = 0; guard_refrac = 0; } nav_prev = nav; } #endif /* Рисуем в СКРЫТУЮ страницу (при dbuf); в однобуфере — в 0. */ back = dbuf ? (uint8_t)(front ^ 1) : 0; gfx_set_draw_page(back); pop_check_skel(); /* спецсобытие ур.3: скелет встаёт */ pop_check_can_guard_see_kid(); /* луч видимости — ДО логики персонажей */ pop_ctrl_tick(); /* ввод -> control(): смена seq */ /* Кто в этом кадре не изменился с прошлой отрисовки ЭТОЙ страницы — * тот на ней уже нарисован правильно: ни стирать, ни рисовать заново * не надо (DRAW-COST, контракт в pop_cdraw.h). Решение * перепроверяется перед самой отрисовкой — тик ещё впереди. */ skip = pop_char_skip_mask(); if (!(skip & 1)) pop_char_heal(POP_CH_KID); /* стереть прошлый кадр ЭТОЙ страницы */ if (!(skip & 2)) pop_char_heal(POP_CH_OPP); /* и прошлый кадр соперника */ /* Отражение в зеркале — свой heal: у него нет слота pop_cd и в * skip-маске он не участвует (рисуется/стирается безусловно, живёт * только пока Кид стоит на тайле зеркала). */ pop_mirror_heal(); pop_fore_heal(); /* + следы оверлея (шире прямоугольника Kid) */ PROF(2); /* логика (тот же синий) */ kid_tick(); /* play_seq: следующий кадр */ pop_phys_tick(); /* K3: падение/приземление/стена */ pop_guard_tick(); /* логика стража — В БАНКЕ (guards.c) */ pop_guard_phys_tick(); /* и его физика — та же, что у Кида (play_guard_frame) */ /* Боёвка, порядок как в play_frame (seg000:872): сначала пометить * попадания с обеих сторон, потом применить, потом свести HP. */ pop_check_sword_hurting(); pop_check_sword_hurt(); pop_do_delta_hp(); pop_guard_fallout(); /* страж провалился ниже комнаты — убрать (seg002:241) */ if (pop_fell_out) { /* Kid пересёк нижнюю границу комнаты */ uint8_t down = pop_room_link(cur_room, LINK_DOWN); pop_fell_out = 0; /* Спецсобытие «выход падением» (leave_room, seg002:0504 — * направление вниз даёт особый результат −2; разбор в главном * цикле, seg000:0893). Уровень 6 не заканчивается дверью: Кид * проваливается вниз из комнаты 1 и этим переходит на 7-й. * Проверка ОБЯЗАНА идти раньше связи вниз: у комнаты 1 сосед * снизу есть (шахта, комната 3), и без спецсобытия Кид улетал * туда, а оттуда — в рестарт уровня. */ if (pop_current_level == FALLING_EXIT_LEVEL && cur_room == FALLING_EXIT_ROOM) { Kid.y = 0xFF; /* seg000:0896 — Kid.y = −1 */ pop_next_level = (uint8_t)(pop_current_level + 1); } else if (down) { /* L2: переход в комнату снизу — продолжает падать */ enter_room(down); /* координаты Kid уже репроецированы pop_map */ gfx_set_draw_page(back); /* вернуть текущую back для отрисовки */ } else { /* выпал из уровня (нет комнаты снизу) — рестарт */ pop_start_level(); gfx_set_draw_page(back); } } else if (pop_leave_dir) { /* L3: уход вбок/вверх (координаты уже репроецированы) */ uint8_t nb = pop_room_link(cur_room, (uint8_t)(pop_leave_dir - 1)); uint8_t left = (uint8_t)(pop_leave_dir == 1); uint8_t pop_leave_dir_prev = pop_leave_dir; pop_leave_dir = 0; /* level3_set_chkp (seg002:0665). ВНИМАНИЕ на комнату: оригинал * зовёт его из leave_room ДО goto_other_room, то есть Char.room * там ещё СТАРАЯ. Значит условие `Char.room == 7` читается как * «Кид УХОДИТ ИЗ комнаты 7 влево» (в комнату 2), а не «входит в * неё». Смысл: чекпойнт даётся за то, что комната 7 пройдена * НАСКВОЗЬ, и респавн ставится туда, куда Кид только что попал. * * Сначала я поставил проверку на комнату НАЗНАЧЕНИЯ — и это * поймал пользователь прогоном в SDLPoP: он умер В комнате 7, но * влево из неё не выходил, и оригинал вернул его в стартовую * комнату 9, а плита осталась цела. Заодно тут запоминается * достигнутый потолок HP: смерть после чекпойнта его не отбирает. */ if (left && pop_current_level == POP_CHKP_LEVEL && cur_room == POP_CHKP_ROOM) { pop_checkpoint = 1; hitp_beg_lev = hitp_max; } if (nb) { /* side для pop_guard_follow — то же направление, по которому * ищем соседа (roomleave_result оригинала). */ enter_room_side(nb, (uint8_t)(pop_leave_dir_prev - 1)); gfx_set_draw_page(back); } } PROF(4); /* слой фона */ 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 i, changed = 0; /* Все ТРИ ряда колонки 9: ворота в шве бывают в любом из них * (BUG-GATE-SEAM-ROW1, см. объявление seam_sig). */ for (i = 0; i < 3; i++) { uint8_t g = seam_row_sig(m, lcol_fg, i), prev = seam_sig[i]; seam_sig[i] = g; /* СНАЧАЛА сохранить (обход SDCC z80 sub-store */ /* бага: `if(g!=s)s=g` эмитит store РАЗНОСТИ g-s, */ /* не g — sdcc_z80_cmp_store_a_bug) */ if (g != prev) changed |= (uint8_t)(1 << i); } if (changed) { /* openness изменился → обе страницы дабл-буфера */ /* Плюс ряд ВЫШЕ: верх решётки (draw_tile_anim_topright, * seg008:0568 — маска 68 + кадр DOOR_FRAM_TOP) рисует не * сам тайл ворот, а тайл над-справа от него, то есть у * нас (r−1, 0). Он тоже анимируется вместе с openness; * без этого чёрный треугольник над воротами оставался * статичным, пока бары ездили (BUG-GATE-SEAM-ROW1). */ seam_rows |= (uint8_t)(changed | (changed >> 1)); seam_redraw = 2; } if (seam_redraw) { lcol_bg[0] = m[9]; lcol_bg[1] = m[19]; lcol_bg[2] = m[29]; pop_room_redraw_seam_left(seam_rows); if (--seam_redraw == 0) seam_rows = 0; } } } if (pop_next_level != pop_current_level) { /* Порт play_level_2 (seg003:0386..0410) + play_level (seg003:81): * цикл уровня кончается, когда next_level разошёлся с * current_level (END_LEVEL после seq_70 в двери уровня либо чит * Shift+L), и play_level грузит следующий. * * HP переносится: hitp_beg_lev = hitp_max ДО загрузки — так * поднятая на уровне «жизнь» (большая склянка) переезжает * дальше, а урон — нет (do_startpos дольёт до потолка). */ hitp_beg_lev = hitp_max; pop_checkpoint = 0; /* уровень пройден (seg003:413) */ if (pop_level_load_num(pop_next_level) != 0) { pop_next_level = pop_current_level; /* файла нет — остаёмся */ } else { /* Набор спрайтов соперника у каждого уровня СВОЙ * (load_lev_spr, seg000:1092): уровень 3 — скелет, у него и * кадров меньше, чем у стража. Без перезагрузки соперник * рисуется чужим атласом: часть индексов уходит за его * пределы, и персонаж просто не виден. */ pop_guard_free(); pop_guard_load(); /* Тайлсет: подземелье <-> дворец (порт tbl_envir_ki, * seg000:1108). Внутри — no-op, если тип не менялся; * при смене выгружает старые атласы и правит 32 записи * палитры. Только на границе уровня, не в кадре. */ if (pop_bg_load(pop_level_type()) != 0) { puts("bg set load failed"); return 1; } /* Всё состояние прошлого уровня сносит сам pop_start_level: * pop_trob_reset обнуляет room_seen (модификаторы комнат * перечитаются из НОВОЙ страницы), тайлы/стражи приезжают * из неё же, loose чистит enter_room. */ pop_start_level(); } gfx_set_draw_page(back); } if (pop_kid_dead) { /* напоролся на пики: труп лежит; респавн по ↑ */ dead_frames++; if (dead_frames > RESPAWN_SETTLE && (kbd_raw_down(KBD_UP) || dead_frames > RESPAWN_DELAY)) { dead_frames = 0; pop_start_level(); gfx_set_draw_page(back); } } if (pop_loose_fell) { /* remove_loose: сама плита исчезла */ uint8_t fpos = (uint8_t)(pop_loose_fell - 1); pop_loose_fell = 0; pop_level_set_tile(cur_room, fpos, TILE_EMPTY); } if (pop_loose_exit) { /* кусок приземлился в НЕ отрисованной комнате */ /* Комнату и тайл посадки считает сам кусок (pop_room.c): он летит * через комнаты честным mob_down_a_row, а не «одним переходом * вниз», как было раньше. Здесь остаётся то, что положено * loose_land (seg007:11E8): щебень на месте посадки и КНОПКА * под ним. */ uint8_t lroom = pop_loose_exit_room; uint8_t lpos = (uint8_t)(pop_loose_exit - 1); uint8_t tt = pop_level_tile(lroom, lpos); pop_loose_exit = 0; /* На opener подставляется button_type = щебень, то есть «открыть * НАСОВСЕМ» (modifier 0xFF). Второе место того же порта: своя * комната — в pop_map.c. */ if (tt == TILE_OPENER || tt == TILE_CLOSER) pop_trigger_button(lroom, lpos, (uint8_t)(tt == TILE_OPENER ? TILE_DEBRIS : tt), pop_trob_modif(lroom)[lpos]); /* На факеле остаётся отдельный тайл «факел с щебнем» * (seg007:1067), а не обычный щебень. */ pop_level_set_tile(lroom, lpos, (uint8_t)((tt == TILE_TORCH || tt == TILE_TORCH_DEBRIS) ? TILE_TORCH_DEBRIS : 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) pop_level_set_tile(up, (uint8_t)(20 + ccol), TILE_EMPTY); /* колодец */ } if (pop_debris_at) { /* кусок лёг в ЭТОЙ комнате → щебень */ pop_level_set_tile(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; /* запечь на ОБЕИХ страницах */ /* Тайл в странице уровня ставит САМА do_pickup (pop_map.c): здесь * это было бы слишком поздно — между подбором и этим местом * успевает пройти pop_process_trobs (BUG-POTION-STRIPE). */ 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_color оригинала): меч — ярко-жёлтый, зелья * HP — красный, перо (медленное падение) — зелёный. */ if (pop_flash_color == POP_FLASH_RED) flash_bg(255, 0, 0); else if (pop_flash_color == POP_FLASH_GREEN) flash_bg(85, 255, 85); else flash_bg(255, 255, 85); pop_flash_time--; if (!pop_flash_time) pop_flash_color = POP_FLASH_YELLOW; flash_on = 1; } else if (pop_kid_hurt) { flash_bg(224, 0, 48); /* color_12: игра правит его на */ /* #E00030 (seg000:164), это не */ /* стандартный VGA brightred */ flash_on = 1; } update_kid_render_dx(); /* straddle: смещение спрайта, если kid_room≠cur_room */ PROF(6); /* спрайты: страж, Kid, fore поверх */ /* check_mirror (seg003:0798) — ПЕРВАЯ строка draw_people * (seg008:228A), до отрисовки кого бы то ни было: если Кид только что * пролетел сквозь зеркало, тень должна родиться ДО того, как слот * соперника пойдёт рисоваться, иначе кадр её проглотит. */ pop_check_mirror(); { /* Кто позже — тот поверх; порядок задаёт обход тайлов, а не роль * персонажа (см. guard_over_kid). Отрисовка одна на всех Char * (pop_cdraw.c), различает их только слот. */ uint8_t g_after = guard_over_kid(); /* Пересчёт после тика: слот, за который heal не платили, мог * всё-таки сдвинуться — тогда бит снимется, а прошлый кадр * сотрёт сам pop_char_draw (страховка cd_heal). */ skip = pop_char_skip_mask(); if (!g_after && !(skip & 2)) { pop_char_draw(POP_CH_OPP); pop_char_fore(POP_CH_OPP); } PROF(6); /* кадр Кида (тот же циан) */ if (!(skip & 1)) pop_char_draw(POP_CH_KID); /* спрайт + брызги + клинок */ if (g_after && !(skip & 2)) { pop_char_draw(POP_CH_OPP); pop_char_fore(POP_CH_OPP); } /* Брызги урона рисует сама отрисовка персонажа (порядок objtable: * сразу после него и до клинка), а флаги снимаем здесь: соперника * могло не оказаться в отрисованной комнате — тогда брызги просто * пропадают, как в оригинале. Снимаем ПО ФАКТУ, а не безусловно: * запись в кадре удара — готовая точка останова для отладки в * MAME (watchpoint), и лишней записи каждый кадр нет. */ if (pop_guard_hurt) pop_guard_hurt = 0; if (pop_kid_hurt) pop_kid_hurt = 0; } pop_loose_mob_draw_over(); /* падающая плита НИЖЕ Kid → поверх него (y-порядок) */ pop_hp_draw(); /* полоса HP — только при изменении */ PROF(6); /* fore поверх Kid + борта */ /* Fore-слой Кида — В КОНЦЕ, после плиты и полосы HP: окно fore-клипа * одно на всех, и его ставит каждый, кто рисовал персонажа, поэтому * pop_char_fore(KID) заодно возвращает окно Кида (при «соперник * поверх» в нём остался бы соперник, и передние грани у Кида * отсеклись бы целиком — он рисовался бы поверх столбов). */ if (!(skip & 1)) pop_char_fore(POP_CH_KID); /* Персонажи на этой странице приведены в порядок — след «фон трогали» * для неё снят. ПОСЛЕ отрисовки, а не до: слой фона этого же кадра * взводит бит и обязан быть учтён. Всё, что рисуется ниже * (mob поверх Кида, борта), взводит его заново само. */ pop_cd_clear(back); 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; } } gfx_set_idle_hook(0); /* снять хук ДО закрытия raw-канала */ pop_ctrl_close(); closegraph(); pop_bg_free(); pop_kid_free(); pop_guard_free(); pop_kid_data_free(); pop_level_free(); return 0; }