PoP: скелет уровня 3, цвета стражей, окклюзия соперника; кэш соседних комнат

Скелет (L3-SKEL, ассеты + механика): - pop_pack_guard.py получил параметр набора (GUARD/SKEL): атлас скелета poc/res/skel/g0..g3.atl (28 кадров), палитра — из его res750.pal (на ур. 3 curr_guard_color = 0, оригинал палитру не подменяет); - pop_guard_load выбирает набор по tbl_guard_type и перезагружается ПРИ СМЕНЕ УРОВНЯ (load_lev_spr, seg000:1092) — без этого скелет рисовался атласом стража и был невидим; - load_frame: charid_4_skeleton идёт по таблице стража (seg006:529), тень — только в кадрах 150..189. Пока ветка была одна (charid_2_guard), скелет получал image из таблицы Кида (180 при 28 спрайтах) и не рисовался; - check_skel (seg002:1042), ветка charid_4 в enter_guard, возрождение в комнате 3 при падении (seg002:252), autocontrol_skeleton; - leveldoor_open (seg007:456) — новый флаг, сбрасывается стартом уровня. Цвета стражей (BUG-GUARD-COLOR-1, закрыт): - все 7 палитр res10.bin -> pop_guard_pal.h, заливка 16 слотов по guards_color комнаты перед отрисовкой (set_chtab_palette, seg003:257). Проверено в MAME: ур. 2 комн. 11 = цвет 1, комн. 7 = цвет 3, полоса HP меняется вместе со стражем. Грабля: gfx_pal_load отдаёт указатель в BIOS, а тот читает только #4000-#BFFF — таблицу из банка копируем в стек. Кэш соседних комнат (BUG-SWORD-GHOST-1, закрыт): - pop_map кэширует fg соседей слева/справа ЦЕЛИКОМ и резолвит col -10..19. Было -2..11, дальше мнимая стена: луч видимости упирался в неё (страж после follow_guard в col 12), Кид прятал меч посреди боя и не мог достать обратно. +48 байт W2. Окклюзия соперника: - pop_fore_over_char получил проход other_overlay_tile (порядок midtable, seg008:1B06) и расширение перебора объединённым прямоугольником «персонаж + клинок + брызги» — падающий скелет больше не рисуется поверх кладки и верхней грани пола; - клип полем 192 строк (reset_obj_clip, seg006:0507) для спрайта, клинка (общий pop_sword_draw) и брызг — спрайт не залезает на полосу HP; - ROOMNAV после смерти Кида делает честный pop_start_level: телепорт «оживлял» мёртвого мимо старта уровня, оставляя живого скелета рядом с вернувшейся кучей костей. Ассеты чомпера (под L3-CHOMP): весь набор кадров в атласе явным списком (101-105 низ, 111-113 верх, 106-110 фронт, 114-123 кровь mono-силуэтом) — render_room анимированные тайлы пропускает, и в атласе не было ни одного. Число EMM-страниц не изменилось. Тесты: tests-host все 5 наборов зелёные, t_char вырос до 65 проверок (резолв колонок за краем комнаты, возрождение скелета); в testkit добавлен гард «код наехал на данные» (DATA_LOC). Доски: TASKS.md разнесён на TASKS_OPEN/TASKS_CLOSED, закрытые баги с разбором корней — в bug_closed.md; заведены DRAW-CHAR (отрисовка одна на всех Char, как физика после GUARD-PHYS) и L3-COLOR (зелёная кладка уровня 3: level_var_palettes = ресурс 20, есть в MSDOS/PRINCE.DAT). В roomtest.c временно оставлен автостоп на падении соперника (отладка падений скелета) — помечен ВРЕМЕННО. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
TASKS: зацеп в прыжке — в список на финальную приёмку уровней 1-3
2026-08-07 22:11:03 +03:00 · 2026-08-06 00:59:59 +03:00 · 2026-08-06 00:57:51 +03:00 · 2026-08-05 22:50:26 +03:00 · 2026-08-05 22:41:20 +03:00 · 2026-08-05 21:55:38 +03:00
247 changed files with 39174 additions and 2493 deletions
@@ -113,3 +113,10 @@ mame/

 # Claude Code local settings (per-machine, not for the repo)
 .claude/
+
+# Тяжёлые справочные материалы, НЕ версионируются: docs/extra — архивы
+# исходников (~570 МБ, четыре почти одинаковых bad_apple), docs/sources —
+# клоны чужих репозиториев (Sprinter-BIOS, Estex-DSS, SaymanNsk) со своими
+# .git внутри (в коммите стали бы битыми gitlink-ссылками).
+docs/extra/
+docs/sources/
@@ -1,10 +1,14 @@
 # Sprinter C Compiler — top-level Makefile
 #
-#   make             build host tools, libc archive, all tests, all apps
+#   make             build host tools, libc archive, all tests
 #   make tools       build only host tools (mkexe)
 #   make lib         build lib/sprinter.lib (libc) + lib/bgi256.lib (libbgi)
 #   make tests       build all libc feature tests under tests/
-#   make examples    build all real applications under examples/
+#   make examples    build all real applications under examples/ (НЕ входит
+#                    в `make all`: это регрессная сборка, а examples/ —
+#                    крупные приложения, которые её только замедляют
+#                    (mdview компилируется минутами) и ничего нового про
+#                    libc не показывают.  Собирать явно перед `make floppy`.)
 #   make floppy      package every .exe + test fixtures into mame/v306/IMG/mc.img
 #   make check       run mkexe unit tests
 #   make clean       remove all build artefacts
@@ -39,9 +43,9 @@ DATA_FILES := \
    examples/mdview/SAMPLE.MD

 .PHONY: all tools lib tests examples check clean sdcc floppy \
-        size-check size-baseline $(TESTS) $(APPS)
+        size-check size-baseline host-tests $(TESTS) $(APPS)

-all: tools lib tests examples
+all: tools lib tests

 tools:
 	$(MAKE) -C toolchain/mkexe
@@ -73,6 +77,14 @@ floppy: tests examples tests/seek/big.txt
 	@echo "Floppy ready: $(FLOPPY_IMG)"
 	@echo "Run:  cd $(MAME_DIR) && ./run_mame.sh"

+# Модульные тесты под ucsim_z80.  Обвязка — testkit/, сами наборы лежат
+# рядом с кодом, который проверяют.  MAME не нужна, идут за секунды;
+# ucsim идёт в комплекте нашего SDCC.
+HOST_TEST_DIRS := testkit applications/PoP/roomtest/tests-host
+
+host-tests:
+	@for d in $(HOST_TEST_DIRS); do $(MAKE) -C $$d || exit 1; done
+
 # Размерный регресс: сверить _CODE всех программ с docs/size_baseline.tsv.
 size-check:
 	python3 toolchain/size_check.py
@@ -59,11 +59,16 @@ Princed для DAT v1.0 (контейнер/индекс/чек-сумма, ко

 ## Структура папки

- `docs/` — планы и форматы: `PORT_PLAN.md` (общий план фаз),
-  `KID_PLAN.md`, `double_buffer_plan.md`, `loose_floors_plan.md`, форматы
-  ресурсов.  Начинать чтение отсюда.
- `roomtest/` — **активная разработка**: комната 1 + Kid (анимация, ввод,
-  коллизия, падение, зацеп, fore-окклюзия, loose-полы).  Свой `CLAUDE.md`.
+- `docs/` — планы и форматы; **индекс с отметками актуальности —
+  `docs/README.md`**, начинать чтение оттуда.  Ключевое:
+  `levels_plan.md` (следующий этап), `layout_plan_v2.md` (раскладка кода по
+  окнам/банкам + скорость отрисовки), `PORT_PLAN.md` (карта фаз со
+  статусами).
+- `roomtest/` — **активная разработка**: уровень 1 целиком (Kid, стражи,
+  ловушки, ворота, loose-полы).  Свой `CLAUDE.md`; текущие задачи —
+  `roomtest/TASKS_OPEN.md` (закрытые с протоколами —
+  `roomtest/TASKS_CLOSED.md`), открытые баги — `roomtest/bug_list.md`,
+  закрытые с разбором корней — `roomtest/bug_closed.md`.
 - `poc/` — ранний proof-of-concept (снег/атлас/kbd_raw); ассеты в `poc/res/`.
 - `bgtest/`, `coltest/` — отдельные проверки фона/коллизии.
 - `toolchain/` — python-упаковщики ассетов + эталонные PNG (`1.1-2.png`).
@@ -4,15 +4,22 @@
 target-слоя SDCC (sprinter-cc / libc / libbgi).  Цель — 320×256×256 (режим
 0x81), VGA-256 ассеты оригинала переносятся почти впрямую.

-Общий план и статус фаз — [`docs/PORT_PLAN.md`](docs/PORT_PLAN.md).
-Правила работы для ИИ-сессий — [`CLAUDE.md`](CLAUDE.md).
+**Состояние (2026-08-01): играется весь уровень 1** — комнаты и переходы,
+Kid со всем набором действий, ловушки, ворота, дверь уровня, меч и бой,
+стражи с ИИ, HP и зелья.  Нет: перехода на следующий уровень, звука,
+таймера/HUD, сохранений.
+
+- Что в работе прямо сейчас — [`roomtest/TASKS_OPEN.md`](roomtest/TASKS_OPEN.md).
+- Следующий этап (уровни 2+) — [`docs/levels_plan.md`](docs/levels_plan.md).
+- Общий план и статус фаз — [`docs/PORT_PLAN.md`](docs/PORT_PLAN.md).
+- Правила работы для ИИ-сессий — [`CLAUDE.md`](CLAUDE.md).

 ## Что где

 | Папка | Назначение |
 |-------|-----------|
-| `roomtest/` | **Активная разработка.** Комната 1 уровня 1 живой композицией тайлов + Kid: анимация (seqtbl), управление с клавиатуры, коллизия, падение, зацеп/подтягивание, fore-окклюзия, проваливающиеся полы. Свой README/CLAUDE. |
-| `docs/` | Планы (`PORT_PLAN`, `KID_PLAN`, `double_buffer_plan`, `loose_floors_plan`) и разбор форматов ресурсов Apple II / DOS. |
+| `roomtest/` | **Активная разработка.** Уровень 1 целиком: фон композицией тайлов, Kid (seqtbl-анимация, ввод, коллизия, падение, зацеп, окклюзия), ловушки, ворота, стражи, бой. Свой README/CLAUDE/TASKS. |
+| `docs/` | Планы и разбор форматов ресурсов Apple II / DOS — см. индекс в [`docs/README.md`](docs/README.md). |
 | `toolchain/` | Python-упаковщики ассетов под Sprinter (рендер комнат, атласы тайлов/Kid, извлечение данных анимации) + эталонные скриншоты. |
 | `poc/` | Ранний proof-of-concept (снег, атлас, raw-клавиатура). Ассеты в `poc/res/`. |
 | `bgtest/`, `coltest/` | Точечные проверки фона и коллизии. |
@@ -1,6 +1,21 @@
 # Prince of Persia — Kid (персонаж): анализ и план

-Статус: план (2026-07-16).  Опирается на разбор `SDLPoP/src/seg006.c`
+> **Статус: РЕАЛИЗОВАНО (2026-08-01).**  Kid играется целиком: интерпретатор
+> `seqtbl` + `frame_table` (`roomtest/pop_kid.c`), диспетчер `control()`
+> (`pop_ctrl.c`), коллизия/физика/зацеп (`pop_map.c`), бой и HP.  Модель
+> персонажа стала общей: `Char`-окно (`pop_state.c`) обслуживает и Кида, и
+> стражей.  Таблицы кадров и `seqtbl` уехали из `_CODE` в EMM-страницу
+> (`kid_data.bin`, см. `layout_plan_v2.md` шаг 1).
+>
+> Отступление от §2.1 плана: выбран ПАДДИНГ кадров (общий канвас), а не
+> per-frame offset — компромисс зафиксирован в `PORT_PLAN.md §6.1`.
+>
+> **Документ оставлен как СПРАВОЧНИК по модели персонажа** (`char_type`,
+> категории `actions_*`, устройство `play_seq`, объём спрайтов) — он нужен
+> при портировании остальных акторов (скелет, тень, визирь).  Текущие
+> задачи — `../roomtest/TASKS_OPEN.md`.
+
+Составлен 2026-07-16.  Опирается на разбор `SDLPoP/src/seg006.c`
 (ядро физики/управления Kid), `seqtbl.c` (таблицы последовательностей),
 `types.h` (char_type, seq_*, SEQ_*, actions_*), `SDLPoP/data/KID` (спрайты).
 Фон уже готов и проверен на MAME (`applications/PoP/roomtest`, см.
@@ -1,8 +1,29 @@
 # Prince of Persia на ZX Sprinter — план порта

-Статус: план (2026-07-15).  §2 (A: kbd_mod_state / B: kbd_raw) —
-РЕАЛИЗОВАНО и частично проверено в MAME (tests/kbdraw, 2026-07-15,
-подробности в §2.2); PoC (§5) и остальные фазы — не начаты.  Опирается на
+## СТАТУС (обновлено 2026-08-01)
+
+Документ составлен 2026-07-15 как план «с нуля» и с тех пор во многом
+исполнен.  Читать его надо так:
+
+| Раздел | Что с ним сейчас |
+|--------|------------------|
+| §1 возможности библиотек | актуально как обзор, но **спрайтовый движок `sprite.h` для персонажей НЕ используется**: Kid/страж рисуются прямыми блитами атласов (`gfx_blit_cols_part*`) с ручным heal — так требует модель оригинала (§6) |
+| §2 held-state клавиатуры | **сделано** (`kbd_mod_state`, `<kbd_raw.h>`).  Открытая проблема — потеря байт при аккордах Shift+стрелка; диагноз и план в `../roomtest/TASKS_CLOSED.md` (KBD-1) |
+| §3 форматы данных | актуально; уровень читается живьём (`roomtest/pop_level.c`) |
+| §4 стратегия фона | **сделано** — тайловый рендерер в рантайме (`roomtest/pop_bg.c`) |
+| §5 PoC | **закрыт и превзойдён.**  `poc/` (плейсхолдер-персонаж) — история; активная разработка ушла в `roomtest/` с настоящей графикой |
+| §6 модель движения | **сделано**: `play_seq` + `frame_table` оригинала, не физика с нуля |
+| §7 фазы | см. отметки статуса прямо в разделе |
+| §8 риски | п.1 закрыт, п.3 закрыт (28 страниц-атласов Кида), п.2/п.4 — см. отметки в разделе |
+| §10 режим памяти | **сделано и переросло план**: `huge` + четыре банка кода; актуальная раскладка — `layout_plan_v2.md` |
+
+**Где смотреть текущее состояние, а не план:** `../roomtest/README.md`
+(что играется), `../roomtest/TASKS_OPEN.md` (что в работе), `levels_plan.md`
+(следующие уровни), `layout_plan_v2.md` (раскладка кода по окнам и банкам).
+
+---
+
+Опирается на
 `APPLEII_RESOURCE_FORMAT.md` / `MSDOS_RESOURCE_FORMAT.md` / `README.md` в
 этой папке, на текущий sprinter-cc/libc/libbgi (см. §1) и на локальные копии
 `applications/PoP/SDLPoP` (github.com/NagyD/SDLPoP, GPLv3) и
@@ -227,6 +248,13 @@ dirty-биты, heal против фона через ОЗУ-копию); `room_

 ## 5. Proof-of-Concept — цель: доказать, что порт вообще ощущается как PoP

+> **Закрыт (исторический раздел).**  PoC в `poc/` свою задачу выполнил и
+> дальше не развивается: управление ощущается как PoP, held-state работает.
+> Всё, что ниже про плейсхолдер-персонажа и приблизительную дугу прыжка,
+> — уже неправда для активной ветки: в `roomtest/` стоит настоящая графика
+> Кида и авторские таблицы кадров (§6).  Раздел оставлен ради истории
+> решений (в частности §5.1 — почему сначала был плейсхолдер).
+
 **Объём**: одна комната (например Level 1, экран старта Кида), без
 переходов между экранами, без стражников (стретч-цель, не обязательна).

@@ -364,45 +392,53 @@ memory/png_strip_padding_tradeoff.
 ## 7. Полноценное приложение — фазы (после PoC)

 Порядок — по риску и зависимостям, не по геймплейной важности.
+**Отметки статуса — на 2026-08-01.**

-**Фаза 0 — инфраструктура порта** (расширяет PoC, не переписывает):
- Хелд-стейт клавиатуры — финальное решение и реализация по §2 (после
-  подтверждения пользователем).
- Полный конвертер уровней (все 15 файлов `levels.dat`/`LEVELn`) → бинарный
-  формат приложения (можно 1-в-1 raw dump, читать по офсетам в рантайме —
-  не обязательно разворачивать в C-struct с указателями).
- Полный конвертер фона (24 экрана × N уровней) в растры + конвертер
-  спрайт-лент Кид/стражник/скелет/тень/Джаффар в атласы `.atl` (расширение
-  `conv_sprites.py`/формата `.atl`, если частот кадров/атласов на актора не
-  хватит текущего лимита — см. риск в §8).
+**Фаза 0 — инфраструктура порта** — **СДЕЛАНА**, но иначе, чем задумано:
+- Хелд-стейт клавиатуры по §2 — сделан.
+- Конвертер уровней не понадобился: `res200N.bin` из `SDLPoP/data/LEVELS`
+  кладётся на образ как есть и читается по офсетам в рантайме
+  (`roomtest/pop_level.c`), уровень живёт в EMM-странице.
+- Конвертер фона в растры **отменён осознанно** (§4): фон собирается
+  тайлами в рантайме.  Спрайты — `toolchain/pop_pack_bg.py` /
+  `pop_pack_kid.py` / `pop_pack_guard.py` → атласы `.atl` (Kid — 28
+  страниц, риск §8 п.3 закрыт).

-**Фаза 1 — Кид, полный набор действий**: стоять/идти/бежать/тормозить/
-разворот/прыжок (на месте, вперёд, «прыжок с разбега»)/повисание на
-краю/подтягивание/спуск по свисанию/приседание/питьё зелья/смерть от
-провала. Переходы между экранами (`MAP`-граф, `INFO.KidStartScrn`).
+**Фаза 1 — Кид, полный набор действий** — **СДЕЛАНА**: стоять/идти/бежать/
+тормозить/разворот/прыжки/повисание/подтягивание/спуск/приседание/
+осторожный шаг/питьё зелья/смерть от провала и от пик; переходы между
+комнатами во все четыре стороны.  Осталось: **старт по данным уровня**
+(`pop_level_start_*` реализованы, но не подключены) — задача L1-START в
+`../roomtest/TASKS_OPEN.md`.

-**Фаза 2 — мир и ловушки**: нажимные плиты/двери через граф
-`LINKLOC`/`LINKMAP` (см. `APPLEII_RESOURCE_FORMAT.md` §1.2), шипы
-(выдвижение/втягивание/заклинивание), шаткие плиты (loose, обрушение),
-зелья (эффект по `BLUESPEC×32`), стартовые позиции по `INFO`.
+**Фаза 2 — мир и ловушки** — **СДЕЛАНА**: кнопки/ворота через
+`LINKLOC`/`LINKMAP`, шипы, loose-полы (тряска, обрушение, щебень, пробой
+потолка), зелья, дверь уровня (открывается), факелы.  Подробности и
+справочник — `gates_spikes_plan.md`.

-**Фаза 3 — бой**: подбор/выхватывание меча, состояние стойки, парирование/
-удар, коллизия клинков — по логике `AUTO.S`/`seg003-006.c` (референс, не
-копия). Стражник: базовое AI-поведение по `GdStartProg` (несколько
-шаблонов программ), Y-сортировка слоями уже есть в движке для «кто
-спереди/сзади».
+**Фаза 3 — бой** — **СДЕЛАНА в объёме обычного стражника**: подбор и
+выхватывание меча, стойка, удар/парирование, коллизия клинков, HP обеих
+сторон, смерть; ИИ стража (замечает Кида, подходит, боевые ветки),
+персистентность трупа между комнатами.

-**Фаза 4 — разнообразие противников**: скелет, тень (копия анимации Кида —
-подтверждено побайтовым совпадением данных, см. `MSDOS_RESOURCE_FORMAT.md`
-§3), толстый стражник/визирь (общая база анимации с визирем).
+**Фаза 4 — разнообразие противников** — **НЕ НАЧАТА**.  Скелет нужен на
+уровне 3, толстый — на 6, тень — на 12, визирь — на 13; привязка
+«уровень → тип стража» (`tbl_guard_type`) описана в `levels_plan.md` §1.

-**Фаза 5 — звук**: CBL-эффекты (шаги, удары, двери, падение) из
-`digisnd*.dat`→PCM; PC-спикер тройки (`ibm_snd*.dat`) как опциональный
-дешёвый бипер без CBL, если формат подтвердится простым парсингом.
+**Фаза 5 — звук** — **НЕ НАЧАТА**: CBL-эффекты (шаги, удары, двери,
+падение) из `digisnd*.dat`→PCM; PC-спикер тройки (`ibm_snd*.dat`) как
+опциональный дешёвый бипер без CBL, если формат подтвердится простым
+парсингом.  Опкод `SOUND` в `play_seq` пока просто съедает свой аргумент —
+точки вызова уже на месте.

-**Фаза 6 — оболочка**: титры, меню/выбор уровня, HUD (таймер/жизни),
-сохранение прогресса (FILE*), финальные катсцены — по минимуму,
-геймплейно не критично.
+**Фаза 6 — оболочка** — **НЕ НАЧАТА**: титры, меню/выбор уровня, HUD
+(таймер/жизни), сохранение прогресса (FILE*), финальные катсцены — по
+минимуму, геймплейно не критично.  Полоса HP — единственное, что уже есть.
+
+**Между Фазами 4 и 5 вклинивается то, чего в этом плане не было:
+переход между УРОВНЯМИ** (загрузка следующего уровня, второй тайлсет
+palace, потабличные различия уровней).  Отдельный документ —
+`levels_plan.md`.

 **Фаза 7 — стабилизация**: полный прогон всех 14 уровней в MAME
 (`mame_interactive.py`), затем на реальном железе; профилирование бюджета
@@ -418,23 +454,33 @@ tiny/small.

 (по правилу `defer_unexplained_quirks` — не гадать, проверять)

-1. **Held-state клавиатуры** (§2) — блокирует даже PoC, если решать
-   «правильно»; иначе PoC на компромиссном варианте 2 (таймаут-эвристика).
-2. **Бюджет спрайтов на насыщенный экран** — сцена с 2+ стражниками +
-   несколько анимированных ловушек может приблизиться к лимиту
-   ~21 спрайт/кадр (`sprite_engine_perf`) — нужна прикидка по реальным
-   уровням (сколько объектов одновременно активно в худшем экране).
-3. **Ёмкость одного атласа/страницы EMM на актора** — у Кида ~220 кадров
-   (все действия) против 4×12 у `rpgwalk` — потребуется либо несколько
-   атласов на актора с переключением по фазе действия (стоять/идти отдельно
-   от боя), либо расширение формата `.atl`/загрузчика на мульти-страничные
-   атласы — оценить фактический байтовый вес конвертированных кадров Кида
-   прежде чем проектировать.
-4. **Тайминг оригинала** — сверить логическую частоту кадров анимации
-   оригинала (Apple II ~60 Гц NTSC / DOS — фиксированный таймер) с 50 Гц
-   Sprinter; если оригинал считался на другой частоте — потребуется
-   коэффициент пересчёта смещений кадров (§6), иначе прыжки/бег будут
-   визуально быстрее/медленнее эталона.
+1. ~~**Held-state клавиатуры** (§2)~~ — **закрыт** (`<kbd_raw.h>`).  Открытый
+   остаток — не «есть ли held-state», а потеря байт при аккордах
+   Shift+стрелка: `../roomtest/TASKS_CLOSED.md`, KBD-1.
+2. **Бюджет кадра** — риск подтвердился, но не в том виде, в каком ожидался:
+   спрайтовый движок для персонажей не используется, поэтому лимит
+   «~21 спрайт/кадр» неприменим.  Реальный бюджет упирается в heal+блиты и
+   перерисовку тайлов; замер 2026-07-30 — типичный кадр ~371 К тактов
+   (~86 % периода).  Инструмент замера уже в коде: полосы бордюра `PROF()`
+   в `roomtest.c`.  План выжимания — `../roomtest/TASKS_CLOSED.md` (CLIP-1) и
+   `../roomtest/bug_list.md` (T-1/T-2).
+3. ~~**Ёмкость атласа на актора**~~ — **закрыт**: Kid разложен на 28
+   атласов-страниц по 8 спрайтов (`pop_pack_kid.py`), страж — на 5;
+   мульти-страничного формата `.atl` не потребовалось.  Побочно
+   подтвердился компромисс паддинга (§6.1).
+4. **Тайминг оригинала** — **ОТКРЫТ, и сверка 2026-08-01 показывает
+   расхождение.**  Цифры оригинала (SDLPoP): базовый таймер `BASE_FPS = 60`
+   (`types.h:1373`), логический кадр игры — `base_speed = 5` тиков
+   (`data.h:869`), то есть **83.3 мс (12 лог. кадров/с)**; в бою
+   `fight_speed = 6` → **100 мс (10/с)**.  У нас (`roomtest.c`) — три
+   ожидания `gfx_wait_vsync()` на итерацию, то есть **60 мс (16.7/с)** и
+   без отдельной скорости боя.  Значит **игра идёт примерно на 39 %
+   быстрее эталона**.  Точное соответствие даёт 4 ожидания vsync (80 мс
+   против 83.3) и 5 в бою (100 мс — совпадает точно).
+   Проверять не «на глаз», а секундомером по одинаковому отрезку
+   (SDLPoP рядом на том же экране), и только после того, как кадр
+   перестанет иногда вылезать за период (см. п.2) — иначе замедление
+   спрячет проблему бюджета вместо того, чтобы её показать.

 ---

@@ -1,4 +1,40 @@
-# Форматы ресурсов Prince of Persia — сводка
+# `applications/PoP/docs` — индекс + сводка по форматам ресурсов
+
+## Индекс документов (актуальность на 2026-08-01)
+
+**Живые планы — читать перед работой:**
+
+| Документ | О чём |
+|----------|-------|
+| [`../roomtest/TASKS_OPEN.md`](../roomtest/TASKS_OPEN.md) | **Что берётся в работу сейчас** (не в этой папке, но входная точка) |
+| [`../roomtest/bug_list.md`](../roomtest/bug_list.md) | Открытые баги roomtest (закрытые — в `bug_closed.md` рядом) |
+| [`levels_plan.md`](levels_plan.md) | Следующий этап: уровни 2+, второй тайлсет, читы SDLPoP |
+| [`layout_plan_v2.md`](layout_plan_v2.md) | Раскладка кода по окнам/банкам/страницам + замеры скорости отрисовки |
+| [`room_model_plan.md`](room_model_plan.md) | `kid_room ≠ drawn_room` (straddle): сделан S1, остальное впереди |
+| [`host_tests_plan.md`](host_tests_plan.md) | Модульные тесты движка под ucsim_z80: два шва, регрессии из `bug_closed.md`, дифф против SDLPoP |
+| [`ideas_backlog.md`](ideas_backlog.md) | Осознанно отложенные гипотезы (мышь, PRNG) |
+| [`prng_alternatives.md`](prng_alternatives.md) | Запасные генераторы, если упрёмся в бюджет кадра |
+
+**Исполненные планы, оставленные как справочники:**
+
+| Документ | Чем ещё полезен |
+|----------|-----------------|
+| [`PORT_PLAN.md`](PORT_PLAN.md) | Общая карта фаз со статусами; §6 (модель движения), §10 (режим памяти) |
+| [`KID_PLAN.md`](KID_PLAN.md) | Модель персонажа: `char_type`, `actions_*`, устройство `play_seq` — нужна для скелета/тени/визиря |
+| [`gates_spikes_plan.md`](gates_spikes_plan.md) | Раскладка объектов уровня 1 по комнатам, декод `LINKLOC`/`LINKMAP`, точные ссылки на seg-код |
+
+**Форматы ресурсов** (ниже по этому файлу): `POP-DAT-FormatSpecifications.pdf`
+/ `.txt` (первоисточник), `APPLEII_RESOURCE_FORMAT.md`,
+`MSDOS_RESOURCE_FORMAT.md`.
+
+Удалены 2026-08-01 как полностью исполненные и перекрытые кодом:
+`clip_char_plan.md`, `double_buffer_plan.md`, `loose_floors_plan.md`,
+`size_optimization_plan.md` (его §8 про скорость отрисовки перенесён в
+`layout_plan_v2.md` §9).  Ищутся в истории git, если понадобятся.
+
+---
+
+## Форматы ресурсов — сводка

 **Каноническая спецификация форматов** — `POP-DAT-FormatSpecifications.pdf`
 (+ текстовая конверсия `POP-DAT-FormatSpecifications.txt` для grep/цитирования):
@@ -70,7 +106,11 @@ DOS-упаковщика). Это значит: раскладку `BLUETYPE`/`B
 дворца/подземелий) практичнее взять их оттуда напрямую, чем писать свой
 декодер сжатия пикселей DOS `.DAT`. 

-## Что дальше (не сделано в этом заходе)
+## Что дальше по форматам (не сделано и пока не нужно)
+
+Порт читает уровень напрямую из `res200N.bin` (`roomtest/pop_level.c`), а
+графику берёт из распакованных PNG `SDLPoP/data/` — поэтому ни один пункт
+ниже сейчас не блокирует работу.

 1. Точный кодек сжатия пикселей спрайтов в сыром DOS `.DAT` (нужен только
   если понадобится читать именно нашу локальную копию `MSDOS/*.dat`
@@ -1,112 +0,0 @@
-# План: порт `clip_char()` — обрезка спрайта персонажа
-
-Статус: в работе с 2026-07-28.  Контекст: баг «спуск Кида с кнопки в комнате 8»
-(Kid просвечивает в щель между кнопкой и ближним столбом, мусор на кромке).
-
-## Симптом
-
-room 8, Kid спускается (climbdown) с тайла-кнопки у ближней колонны.  Спрайт
-Кида нарисован ЦЕЛИКОМ, включая часть, которая в оригинале обрезана по линии
-пола: видно «просвет» Кида в щели между кнопкой и колонной и мусор на кромке.
-
-## Корень
-
-Не портирован `clip_char()` (SDLPoP `seg006.c:1749`, вызывается из
-`add_kid_to_objtable`/`add_guard_to_objtable`, `seg008.c:1671/1690`, ПОСЛЕ
-`set_char_collision`/`set_objtile_at_char`/`redraw_at_char*` и ПЕРЕД
-`add_objtable`).  Оригинал кладёт в objtable не только позицию спрайта, но и
-прямоугольник клипа `obj_clip_{top,bottom,left,right}`; блиттер рисует только
-внутри него.  Мы рисуем без клипа вообще.
-
-## Что делает оригинал (дословно)
-
-`reset_obj_clip()` → `left=0, top=0, right=320, bottom=192`.
-
-Дальше (упрощая C-трюк с глобалью `curr_tile2`, которую ставит каждый
-`get_tile`: `X == wall || tile_is_floor(curr_tile2)` — это «тайл X = стена
-ИЛИ пол»):
-
-```
-T_L = get_tile(room, char_col_left,  char_top_row)
-T_R = get_tile(room, char_col_right, char_top_row)
-if (T_L — стена или пол) &&
-   ( (action == stand && (frame == 79 || frame == 81))   /* прыжок вверх / зацеп */
-     || (T_R — стена или пол) )
-{
-    clip_row = Char.curr_row + 1;
-    clip_y   = y_clip[clip_row];          /* y_clip[] = {-60, 3, 66, 129, 192} */
-    if (clip_row == 1 || (clip_y < obj_y && clip_y - 15 < char_top_y))
-        obj_clip_top = char_top_y = clip_y;
-}
-```
-
-Смысл: `y_clip[row+1]` — верхняя граница СВОЕЙ полосы ряда.  Если над головой
-пол/стена — всё, что выше этой линии, не рисуется (персонаж «уходит под пол»).
-Для ряда 0 (`clip_row == 1`) клип применяется БЕЗУСЛОВНО.
-
-Метрики из `set_char_collision` (seg006:0723):
- `char_x_left  = obj_x/2 + 58` (и `-= char_width_half`, если смотрит вправо)
- `char_x_right = char_x_left + char_width_half`, `char_width_half = (w+1)/2`
- `char_top_y   = obj_y - h + 1`; если `>= 192` → `0`
- `char_top_row = y_to_row_mod4(char_top_y)`
- `char_col_left = MAX(get_tile_div_mod(char_x_left), 0)`,
-  `char_col_right = MIN(get_tile_div_mod(char_x_right), 9)`
-
-Второй блок `clip_char` — `obj_clip_right` (doortop / стена / зеркало для
-виса-полёта-подъёма при взгляде влево, кадры 137..139) и ветка кадров 224..228
-(выход в дверь уровня).  **Фаза 2**, не в этом заходе.
-
-## Наши точки касания
-
- `roomtest/pop_kid.c` `kid_draw()` — сам считает `obj_x/obj_y/w/h` и блитит
-  через `gfx_blit_cols(bx, top + POP_YOFF, img, flip)`; запоминает
-  прямоугольник в `kid_l{x,y,w,h}[page]` для `kid_heal()`.
- `roomtest/pop_map.c` — там `get_tile()`, `tile_is_floor()`, `y_to_row()`,
-  `get_tile_div_mod_m7()`, Kid-структура.  Аналогичный расчёт габарита уже
-  есть в `check_spike_below()` (строка ~1198) — брать за образец.
- `libbgi/common/gfx_blit_cols.c` — клип по экрану есть (при `y < 0`
-  пропускает `sy` верхних строк колонки), но произвольной верхней границы нет.
-
-## Шаги
-
-1. **libbgi**: `gfx_blit_cols_part(int x, int y, const void *img, uint8_t flip,
-   int sy, int h)` — «пропустить `sy` верхних строк спрайта, нарисовать `h`».
-   Реализация = тело `gfx_blit_cols` с предустановленными `sy`/`h` (источник
-   `+= sy`, экранный `y += sy`).  Прототип в `libbgi/include/gfx.h`.
-   Стоимость: 0 в общем пути (обычный `gfx_blit_cols` вызывает то же ядро).
-2. **pop_map.c**: `int pop_clip_char_top(int obj_x, int obj_y, uint16_t w,
-   uint16_t h)` — порт первого блока `clip_char`; возвращает КОМНАТНЫЙ y
-   (0 = клипа нет).  Экспорт в `pop_map.h`.
-3. **pop_kid.c**: в `kid_draw()` после расчёта `top` —
-   `ct = pop_clip_char_top(...)`; если `ct > top` → `sy = ct - top`,
-   рисовать `gfx_blit_cols_part(bx, ct + POP_YOFF, img, flip, sy, h - sy)`;
-   в `kid_l*[page]` класть ОБРЕЗАННЫЙ прямоугольник (иначе heal чистит лишнее
-   и стирает кромку пола).  То же для `kid_draw_splash` — там оригинал делает
-   `reset_obj_clip()`, т.е. splash НЕ клипится (ничего не менять).
-4. **Сборка**: `make -C libbgi`, `make -C applications/PoP/roomtest`,
-   `make size-check`; вывести свободное место в W2/W3 (порог 512 Б).
-5. **Проверка в MAME** (`mame_hdd_test_disk`, полный рестарт после
-   пересборки образа): комната 6 → переход в 8 → влезть на кнопку → спуск.
-   Сверять с эталоном: живой SDLPoP той же позой (см. `pop_check_sdlpop_first`).
-
-## Риски / что проверить отдельно
-
- `char_top_row` считается `y_to_row_mod4` — у нас `y_to_row()` даёт −1 для
-  полосы у потолка; `get_tile(row −1)` уже умеет ряд 2 верхнего соседа.
- Kid ниже комнаты (`char_top_y >= 192` → `0`) — обязателен ресет, иначе клип
-  прыгнет.
- `clip_row == 1` (ряд 0) — клип БЕЗУСЛОВНЫЙ: проверить, что не режет Кида в
-  обычной стойке на ряду 0 (условие внешнего `if` про пол/стену над головой
-  должно отсекать).
- Клип меняет прямоугольник heal → возможен «хвост» на второй странице
-  дабл-буфера: проверять оба кадра (SPACE — выключить дабл-буфер).
-
-## Дальше (Фаза 2, отдельно)
-
-`obj_clip_right` (doortop/стена/зеркало) — нужен для виса и подъёма при
-взгляде влево; и `obj_clip_left` для зеркала (уровень 4).  Требует клипа по
-колонкам в `gfx_blit_cols` (обрезка справа = уменьшить `w`) — дёшево, но
-без тестовой сцены проверять нечем.
-
-См. memory: `pop_clip_char_todo`, `pop_backtable_vs_midtable`,
-`pop_check_sdlpop_first`, `gfx_blit_noclip_fast`.
@@ -1,69 +0,0 @@
-# Double buffer (два экрана + флип) — план
-
-Цель: убрать мерцание/тиринг при перерисовке слоёв (Kid ↔ fore/пол-оверлей)
-и гарантировать, что на экране ВСЕГДА готовый кадр с правильным порядком
-слоёв.  Нужно для отладки fore-слоя (видно момент композиции, а не
-промежуточные состояния heal-рендера).  **Тумблер обязателен** —
-однобуферный режим удобнее для отладки багов рисования.
-
-## Что уже готово (libbgi — трогать НЕ нужно)
-
- Две графических страницы 0/1: `gfx_set_draw_page(p)` (двигает
-  `_gfx_addr_base` 0xC000/0xC140 — рисуют все примитивы),
-  `gfx_set_visible_page(p)` (ESTEX $54 SELPAGE — display-учёт DSS).
- `gfx_wait_vsync()` — луч (bit5 порта 0xFE), момент без разрывов.
- Паттерн из gfx.h: `set_draw_page(hidden); draw(); wait_vsync();
-  set_visible_page(hidden);`
- Замечание gfx.h: у каждой страницы СВОЯ плоскость палитры
-  (page0→pal0, page1→pal1) — для seamless грузить одну палитру в ОБЕ.
-
-## Текущая модель рендера roomtest (однобуфер)
-
-`roomtest.c`: `draw_page=0`, `visible_page=0` фиксированы.  Фон комнаты
-рисуется ОДИН раз в видео-ОЗУ + теневую копию (GFX_BANK_TRANSPARENT).
-Цикл: 3× `gfx_wait_vsync` (пейсинг) → `pop_ctrl_tick` → `kid_heal()`
-(восстановить прямоугольник Кида из тени) → `kid_tick`/`pop_phys_tick`
-→ `kid_draw` → `pop_fore_over_kid`.  Мерцание = heal+draw+fore длиннее
-бланка, луч ловит промежуток.
-
-## Работа на стороне PoP
-
-1. **Инициализация обеих страниц**: `pop_room_draw` в page 0 И page 1
-   (теневая копия одна — общая, из неё heal'ит любая страница).
-2. **Палитра в обе плоскости**: сейчас `gfx_pal_fload(0,...)` + sync.
-   Продублировать в plane 1 (проверить сигнатуру gfx_pal_fload/sync —
-   plane-параметр).
-3. **Per-page heal-история** (ядро): вынести `kid_lx/ly/lw/lh` в
-   массивы `[2]`, индекс = страница, в которую рисуем.  `kid_heal(page)`
-   восстанавливает СВОЙ прошлый прямоугольник (кадр -2, т.к. рисуем
-   через страницу).  То же для fore/пол-оверлея, если они рисуют вне
-   футпринта Кида.
-4. **Ping-pong в цикле**:
-   ```
-   uint8_t back = dbuf ? (front ^ 1) : 0;
-   gfx_set_draw_page(back);
-   kid_heal(back); kid_tick; phys; kid_draw; fore;
-   gfx_wait_vsync();
-   if (dbuf) { gfx_set_visible_page(back); front = back; }
-   ```
-5. **Тумблер** `dbuf`: off → draw==visible==0, без флипа, heal[0] —
-   бит-в-бит текущее поведение.  Управление — клавишей (напр. F2) или
-   compile-флагом.
-6. **Пейсинг**: сейчас 3× vsync/лог.кадр.  При флипе — один vsync перед
-   свопом; недостающий пейсинг добрать `gfx_set_fps_div(3)` или ручным
-   счётом кадров, чтобы скорость игры не изменилась.
-
-## Порядок
-
- D1: обе страницы + палитра в обе плоскости; ping-pong без per-page
-  heal (проверить, что флип работает, фон корректен на обеих).
- D2: per-page heal-история (kid_l*[2]) — убрать «хвост» Кида.
- D3: тумблер dbuf + сверка однобуферного пути с текущим (регресс-нет).
- D4: пейсинг (fps_div) — вернуть исходную скорость.
-
-## Связанные
-
-Рендер-модель — [[pop_fore_layer]], [[pop_background_strategy]];
-heal — kid_heal/gfx_heal.  Будущие динамические слои (loose-floors
-[[двойной буфер требует их per-page перерисовки]]) должны рисоваться в
-обе страницы по той же дисциплине.
@@ -1,8 +1,23 @@
 # Интерактивные объекты (кнопки/гейты/пики) + HP/смерть — ПОДРОБНЫЙ план

-Статус: **план** (2026-07-20).  Реализация — отдельной сессией.  Документ
-самодостаточный: рассчитан на старт «с чистого листа» (пустой контекст).
-Всё сверено с `applications/PoP/SDLPoP/src/` и данными `res2001.bin`.
+> **Статус: РЕАЛИЗОВАНО (2026-08-01).**  Все фазы плана (P0 персистентный
+> per-room `room_modif`, S пики, B кнопки+ворота) сделаны и играются:
+> `roomtest/pop_trob.c` (trob-диспетчер, `LINKLOC`/`LINKMAP`, ворота, дверь
+> уровня, факелы, зелья), `pop_map.c` (HP, смерть на пиках, урон падения),
+> `pop_redraw.c` (пометки перерисовки вместо прямых блитов).  Ограничения
+> из §0 закрыты: тайлы персистентны, HP/смерть есть, loose обобщён в trob;
+> L3-вверх (climb-up в комнату сверху) тоже сделан (`pop_leave_dir = 3`).
+> Из §5 остаётся открытым только **переход на следующий уровень через дверь
+> уровня** — он вынесен в `levels_plan.md`.
+>
+> **Документ оставлен как СПРАВОЧНИК**, а не как план: §1 (раскладка
+> объектов уровня 1 по комнатам, декод связей кнопка→цель) и §2 (точные
+> ссылки на механику SDLPoP) продолжают экономить время при отладке.
+> Текущие задачи — `../roomtest/TASKS_OPEN.md`.
+
+Составлен 2026-07-20.  Документ самодостаточный: рассчитан на старт
+«с чистого листа» (пустой контекст).  Всё сверено с
+`applications/PoP/SDLPoP/src/` и данными `res2001.bin`.

 Правило проекта (см. `applications/PoP/CLAUDE.md`): **SDLPoP — источник истины**,
 перед кодингом читать соответствующий код seg*.c, не гадать.
@@ -0,0 +1,142 @@
+# План: модульные тесты движка roomtest под ucsim_z80
+
+Обвязка общая — `testkit/` в корне репозитория (там же объяснение, почему
+прогон именно под z80, а не хостовым gcc). Наборы лежат в
+`../roomtest/tests-host/`.
+
+Задача плана: **перестать чинить одно и то же дважды**. За два прогона
+уровня 1 (2026-08-03) закрыто восемь корней, и часть из них — регрессии
+соседней механики, внесённые предыдущим фиксом. Такие вещи ловятся тестом
+за миллисекунды, а в MAME — часами ручного вождения Кида.
+
+## Что уже есть
+
+| набор | модуль | статус |
+|-------|--------|--------|
+| `t_geom` | `pop_geom.c` | 39 проверок, включая побитовую сверку asm-LCG с 32-битной формулой на 128 шагах |
+
+`pop_geom.c` выбран первым, потому что не тянет ничего за собой. Дальше
+начинаются швы.
+
+## Фаза 1. Два шва (блокирует всё остальное)
+
+### 1.1 Доступ к странице уровня
+
+`pop_level.c` ходит по абсолютным адресам: `gfx_w0_map(lvl_page)`, затем
+разыменование `(uint8_t *)(LVL_DATA_OFF + …)`. В тестовом бинаре это
+обращение в никуда.
+
+Нужен макрос `W0PTR(off)`:
+
+- на таргете — `((uint8_t *)(off))`, то есть ровно как сейчас;
+- в тестах — смещение в обычном массиве-подложке.
+
+Правка механическая и компайл-таймовая, на размер продукта не влияет.
+Заодно снимает магию абсолютных констант из тела функций.
+
+Тестовая подложка должна уметь: загрузить синтетическую комнату (10×3
+байта fg + mod) и целый синтетический уровень на 24 комнаты, чтобы
+проверять межкомнатные вещи.
+
+### 1.2 Журналирующий рендерер
+
+Вместо `pop_bg.c`/`pop_gdraw.c` в тестовый бинарь линкуется модуль с теми
+же прототипами, который **не рисует, а записывает вызовы**: какой тайл
+помечен к перерисовке, каким кодом, с каким счётчиком страниц.
+
+Это не обход проблемы, а самостоятельная ценность: `BUG-GATE-ANIM-1` был
+ровно такой формы — ворота меняли состояние, но пометка на перерисовку не
+ставилась. Проверяется утверждением, а не глазами.
+
+Минимум, который надо перехватывать: `pop_set_redraw`,
+`pop_set_redraw_above`, `pop_loose_mob_spawn`, `pop_gate_redraw`.
+
+## Фаза 2. Регрессионные кейсы из `bug_closed.md`
+
+После швов `bug_closed.md` превращается в готовую спецификацию: у каждой
+записи есть симптом и ожидаемое поведение. Кандидаты, которые ловятся
+логикой (без отрисовки и без железа):
+
+| баг | что закрепить тестом |
+|-----|----------------------|
+| `BUG-LVLSTATE-1` | запись тайла переживает выход из комнаты |
+| `BUG-RESPAWN-1` | рестарт уровня возвращает ВСЕ тайлы из эталонной копии |
+| `BUG-RESPAWN-2` | рестарт возвращает таблицу стражей; убитый снова жив |
+| `BUG-GATE-ANIM-1` | смена состояния ворот ставит пометку `POP_RD_GATE`; закрывающиеся — на обе страницы, открывающиеся — на одну |
+| `BUG-COLL-1` | `check_collisions` сканирует ряд справа налево и выбирает НАИМЕНЬШУЮ занятую колонку |
+| `BUG-STANDUP-1` | `bumped_floor` у трупа (`alive >= 0`) только выравнивает и не трогает последовательность |
+| `BUG-DEATH-1` | `hitp_curr == 0` при живом Киде переводит его в «умирает» ровно один раз |
+| `BUG-LOOSE-2` | кусок, начавший падать, долетает и кладёт щебень ПОСЛЕ смены комнаты |
+| `BUG-CEIL-2` | loose-плита ряда 2 верхнего соседа живёт как «ряд −1» |
+
+`BUG-LOOSE-2` стоит взять первым: он до сих пор помечен в `bug_list.md`
+как непроверенный именно потому, что гонку «уйти из комнаты раньше, чем
+долетит плита» через мост MAME воспроизвести не удалось. На уровне логики
+это несколько строк — заспавнить кусок, сменить комнату, тикать до
+приземления, проверить щебень в данных уровня.
+
+Не берутся (нужна картинка либо железо): `BUG-DOOR-CLIP`, `BUG-CEIL-1`,
+`BUG-CEIL-3`, `BUG-OCCL-1`, `BUG-KBD-4`, `BUG-3`.
+
+## Фаза 3. Сценарные тесты
+
+Сейчас шаг кадра размазан по `main()` в `roomtest.c`. Вынести его в
+`pop_frame_tick()` — тогда появляются тесты вида «поставить Кида в
+известное состояние, скормить N тиков ввода, проверить итог»:
+
+```
+дано:  комната 5, Кид на кнопке (0,6)
+когда: 40 тиков без ввода
+тогда: комната по-прежнему 5, Кид на полу ряда 2
+```
+
+Это тот самый BUG-STANDUP-1, который ловили потиковой трассой в MAME.
+
+Ввод подаётся не через `kbd_raw_down()`, а через подменяемый источник —
+это же даст возможность проигрывать записанные сценарии.
+
+## Фаза 4. Дифф против SDLPoP
+
+`SDLPoP/src/` лежит в дереве, собирается на хосте, и там **уже стоят
+отладочные трассы** (`DBG kidobj tilepos=…` в seg008, `DBG make_loose_fall`
+в seg007). Значит эталон можно заставить печатать потиковую трассу
+автоматически.
+
+Схема: общий формат скрипта ввода и общий формат трассы (тик, frame, x, y,
+room, col, row, action, alive, hp). Гоняем обе реализации, диффим, первое
+расхождение — номер тика и есть баг. Это ровно то, что делалось руками
+через MAME, только бесплатно и повторяемо: `BUG-COLL-1` и `BUG-STANDUP-1`
+такой дифф нашёл бы за секунды.
+
+**Лицензия.** SDLPoP — GPLv3, правило подпроекта — читать и переписывать,
+не линковать. Оракул обязан быть **отдельным исполняемым файлом**,
+общающимся через файлы трасс, а не слинкованным с нашим кодом в один
+бинарь.
+
+Требование к детерминизму: сиды PRNG должны совпадать. У нас
+`POP_PRANDOM_EXACT` даёт ту же последовательность, что в оригинале, и это
+уже закреплено тестом `geom_lcg_matches_reference`.
+
+## Чего эти тесты не поймают
+
+Отрисовку, банки и W-окна, тайминги, клавиатуру — за этим остаётся MAME.
+
+И отдельный класс: **баги порядка вызовов**. Свежий пример — окно
+fore-клипа (`pop_fore_set_clip`) одно на всех, и его ставит каждый, кто
+рисует персонажа; когда порядок «Кид/страж» стал переменным, окно осталось
+стражьим, и Кид нарисовался поверх передних столбов. Это не «функция
+вернула не то», unit-тест такое не видит. Ловится инвариантом,
+вкомпилированным в safe-сборку: «в момент `pop_fore_over_kid` окно клипа
+принадлежит Киду». Отдельный инструмент, дополняющий тесты.
+
+## Порядок работ
+
+1. Шов `W0PTR` + подложка уровня.
+2. Журналирующий рендерер.
+3. `BUG-LOOSE-2` — закрыть висящий вопрос.
+4. Остальные кейсы из таблицы фазы 2.
+5. `pop_frame_tick()` + сценарные тесты.
+6. Дифф против SDLPoP.
+
+Правило приёмки: тест не считается написанным, пока не проверен мутацией —
+сломать проверяемое место и убедиться, что набор краснеет.
@@ -0,0 +1,91 @@
+# Идеи и вопросы «на подумать» (PoP)
+
+Не план работ, а список того, что осознанно отложено: каждая запись —
+гипотеза с причиной, по которой её стоит проверить, и с тем, что мешает
+сделать это прямо сейчас.
+
+## Зелье «переворот экрана» (upside-down)
+
+**Вопрос пользователя (2026-08-01).**  Тайлы фона у нас лежат строками, а
+кадры Кида/стражей — КОЛОНКАМИ (`transpose_cols` в `pop_pack_kid.py`, ради
+бесплатного горизонтального зеркала).  Значит вертикальный переворот для
+персонажей заметно сложнее, чем для фона.  Верно; но прежде чем это чинить,
+надо знать три факта.
+
+**Факт 1 — когда оно вообще нужно.**  Зелье переворота — тип 4
+(`proc_get_object`, `seg006.c:1885` → `toggle_upside()`).  Скан всех уровней
+по данным (`res200N.bin`, тайл 10 = зелье, тип в backtable): тип 4
+встречается **впервые на уровне 9** (две склянки), и больше нигде.  Тип 3
+(перо, медленное падение) — уровень 7.  То есть **до уровня 9 механика не
+нужна вообще**, и «на первом этапе просто не реализовывать» — не компромисс,
+а точное соответствие данным уровней 1..8.
+
+**Факт 2 — что именно делает оригинал.**  НЕ переворачивает спрайты.
+`flip_screen` (`seg009.c:1042`) → `flip_not_ega` (`seg009.c:1023`) меняет
+местами СТРОКИ готового offscreen-буфера (top↔bottom, порядок пикселей
+внутри строки не трогает — это вертикальное зеркало, не поворот на 180°).
+Вызывается вокруг отрисовки кадра целиком (`seg003.c:296..301`): перевернул
+буфер → дорисовал → перевернул обратно.  Так что в оригинале это
+post-process всего экрана, и вопрос «как перевернуть колоночный спрайт»
+там просто не возникает.
+
+**Факт 3 — почему нам этот приём не подходит как есть.**  У нас нет шага
+«готовый offscreen → экран»: рисуем прямо в видеостраницу, а heal берёт фон
+из ОЗУ-копии этой же страницы.  Переворот всей страницы построчно — это
+320×192 Б копирования КАЖДЫЙ кадр, что мимо бюджета на порядок.
+
+**Варианты, которые надо будет взвесить (не сейчас):**
+1. **Предпечённые перевёрнутые атласы.**  Второй набор кадров
+   Кида/стража, перевёрнутый по вертикали ещё в `pop_pack_kid.py` (там уже
+   есть транспонирование — добавляется одной строкой).  Рантайм: выбор
+   набора + зеркальная арифметика Y.  Память: ещё ~28 страниц EMM при
+   бюджете ~3.3 МБ — не проблема.  Похоже, самый дешёвый по тактам путь.
+2. **Фон рисовать с обратным Y** — для row-major тайлов строка остаётся
+   непрерывным accel-прогоном, меняется только адрес назначения; цена —
+   вызов на строку вместо вызова на тайл.  Померить, прежде чем закладывать.
+3. **Аппаратная помощь** — до проектирования проверить, есть ли у
+   акселератора направление копирования «вниз» (обратный инкремент адреса);
+   если есть, вариант 1 может и не понадобиться.  Смотреть
+   `docs/new/06-accel.md` и `docs/reference/accel_r.txt`.
+
+**Почему не сейчас.**  Уровни 1..8 этого не требуют, а к уровню 9 у нас уже
+будет ответ на вопрос «сколько стоит кадр» (задачи CLIP-1/T-2) — без него
+выбирать между вариантами выше бессмысленно.
+
+## Заменить генератор псевдослучайных чисел
+
+Сейчас стоит LCG оригинала, шаг на ассемблере (~1 020 тактов), бит-в-бит
+совместимый с SDLPoP.  Есть более дешёвые Z80-генераторы (86–148 тактов),
+но потолок выигрыша — 2 814 тактов за кадр, 0.65 %, и он растворяется в
+обёртках вызова.  Тексты процедур, разбор качества и порядок действий —
+`prng_alternatives.md`.  Первый шаг там не про генератор: слить приведение
+к диапазону в ту же asm-процедуру, чтобы на вызов был один `call`, а не три.
+
+## Отключать мышь на время игры
+
+**Гипотеза.** Мышь на Sprinter — источник прерываний (обёртки RST 30h,
+см. memory `mouse_api`).  Игре она не нужна вообще: управление —
+raw-клавиатура (`<kbd_raw.h>`), которую мы и так забираем у DSS целиком.
+Значит каждое мышиное прерывание за кадр — украденные такты в бюджете,
+который у нас и без того занят на 86 %.
+
+**Откуда взялось (2026-07-30).** При замере бюджета по 100 кадрам три
+кадра выбились до 552–647 К тактов (1.28–1.51 кадра) при типичных 371 К.
+Причиной оказалось движение мыши на ХОСТЕ: при неподвижной мыши 225
+кадров подряд прошли без единого превышения.  То есть эффект реальный и
+измеримый, просто в тесте он был наведён извне.
+
+**Что проверить.**
+1. Есть ли у драйвера мыши (RST 30h) функция «выключить/включить» —
+   разобрать список из 14 обёрток; если нет явной, посмотреть, что делает
+   «hide cursor» и снимает ли она обработчик.
+2. Сколько тактов реально стоит одно мышиное прерывание на нашем железе
+   (замер: breakpoint на входе ISR + totalcycles, при движении мыши).
+3. Не ломает ли отключение выход в DSS: состояние обязано
+   восстанавливаться при `exit`, включая аварийный (atexit).
+
+**Почему не сейчас.** Выигрыш проявляется только когда игрок реально
+двигает мышью, то есть в норме его нет; а риск оставить систему без мыши
+после выхода — заметный.  Делать после того, как закроем стражей и
+займёмся бюджетом всерьёз (там же, где батчинг кроссбанковых вызовов и
+возможный возврат `pop_bg` в резидент `--w3`).
@@ -0,0 +1,513 @@
+# roomtest — план v2: размер кода и раскладка по окнам/банкам/страницам
+
+> **Замер 2026-08-01 (актуальная сборка).**  `_CODE` 25 119 Б, `_DATA` 3 709,
+> куча ~2.4 КБ.  Банки: 1 (`guards.c`) 1 896, 2 (`pop_bg.c`) 13 792,
+> 3 (`pop_map.c`) 6 331, 4 (`pop_gdraw.c`) 2 236 — все из 16 384.
+> **Резидента `--w3` больше нет**: отрисовка уехала в банк 2, и это сняло
+> главное ограничение резидента (из банка его было не достать) — банк→банк
+> работает, трамплин сохраняет страницу окна на стеке.  Отрисовка стража
+> вынесена из банка 2 в собственный банк 4, потому что банк 2 подошёл к
+> потолку (16 021 из 16 384) — коммит `2f3e854`.
+>
+> **Свободного места в банке 2 осталось ~2.6 КБ**, а туда же просятся
+> чомперы, зеркало и второй тайлсет (palace).  Прежде чем начинать
+> `levels_plan.md` §3 — посчитать, куда это ляжет.  Свободные номера банков
+> есть, гранулярность — файл.
+>
+> Из плана ниже **не сделаны шаги 5 (данные: `room_modif`, `dl1/dl2`,
+> `_kbdraw_down`; потенциал ~1.5 КБ) и 7 (дедуп `draw_tile`, отложен по
+> решению пользователя)**.
+
+Статус: **план для отдельной сессии**, составлен 2026-07-29 по свежему замеру.
+Заменял `size_optimization_plan.md` (v1, 2026-07-21) — тот удалён 2026-08-01
+как полностью перекрытый этим документом.  Документ самодостаточный
+— рассчитан на старт с пустого контекста.
+
+Повод: перед стражами и боёвкой (новый код ~5–8 КБ) надо понять, куда он
+поместится, и заранее развести код так, чтобы банкованные модули не упёрлись в
+ограничения окна W3.
+
+---
+
+## СТАТУС ВЫПОЛНЕНИЯ (обновлено 2026-07-29, коммит ecf5ecf)
+
+| Шаг | Статус | Факт |
+|-----|--------|------|
+| 1. `kid_data.h` → EMM-страница + `load_frame`/`cur_frame` | **сделан** | `_CODE` −3 247 Б; попутно найден и обойдён баг кодогенерации SDCC (см. ниже) |
+| 2. `pop_geom.c` (дедуп геометрии + PRNG) | **сделан** | −41 Б `_CODE`, −11 Б W3; ценность — не байты, а bank-safe слой |
+| 3. `pop_map` без вызовов графики | **сделан** (фазы 1a/1b) | через пометки перерисовки, см. ниже |
+| 4. Разгрузка/перебалансировка W3 | **сделан** | резидент = `pop_bg` + `pop_gdraw` (отрисовка стража, 2026-07-29); W3 14 376 → 12 819 (свободно 3 565 Б) |
+| 5. Данные (`room_modif`, `dl1/dl2`, `_kbdraw_down`) | не начат | потенциал ~1.5 КБ |
+| 6. Контракт банка стражей + пробник | **пробник сделан** | `tests/w3bankgfx` — модель подтверждена в MAME, см. ниже |
+| 7. Дедуп семейства `draw_tile` | отложен по решению пользователя | «мороки много, выгода не так велика» |
+
+**Замер сейчас против замера §1:** `_CODE` 24 881 → 24 421, куча W2 2 076 → 2 592 Б,
+W3-резидент 14 376 → 11 632 (свободно 2 008 → 4 752 Б).  Сумма кода упала
+на ~3.2 КБ (данные Kid уехали в EMM), остальное — перераспределение.
+
+**Замер 2026-07-29 (после стража).**  Появление стража съело кучу до 805 Б;
+разгрузка — вынос ОТРИСОВКИ стража в резидент (`pop_gdraw.c`, `--w3`), логика
+и состояние остались в W1/W2, чтобы банк `guards.c` их видел (R2).  Итог:
+`_CODE` 26 149 → 25 703, куча **805 → 1 245 Б**, W3-резидент 11 656 → 12 819
+(свободно 4 728 → 3 565 Б), банк 1 — 236 / 16 384 Б.  Граница «что резидент»
+теперь формулируется одним правилом: **резидент = только то, что рисует и
+зовётся исключительно из главного цикла**; всё, что может понадобиться банку,
+остаётся в W1/W2.
+
+### Что сделано вместо §5.3 (вынос loose в W3)
+
+Вместо переноса кода между окнами выбран (по обсуждению с пользователем)
+**порт архитектуры оригинала**: логика ставит пометку, отрисовка идёт
+отдельным проходом — `set_redraw_*` (seg007) + `redraw_needed` (seg008:0178).
+Появился `pop_redraw.c/.h`; `pop_trob` и `pop_map` больше не рисуют тайлы.
+Наши самодельные счётчики (`spike_rest`, `button_rest`, `ldoor_rest`,
+`loose_bake`, `loose_rest`, `ceil_rest`, `ceil_bake`, `land_bake`) удалены —
+их роль (вторая страница дабл-буфера) взял счётчик страниц в пометке.
+
+**Два исключения остались** (обе — функции ТОЛЬКО главного цикла, звать из
+банка нельзя):
+- `pop_process_trobs` — пламя факела и пузырёк зелья (покадровый оверлей);
+- `pop_loose_tick` — падающий кусок (mob): spawn/tick/pos.  В оригинале это
+  отдельная подсистема (`mobs` + `draw_moving`), разделение на логику и
+  отрисовку — задел следующей фазы.
+
+### Пробник банка (2026-07-29): модель ПОДТВЕРЖДЕНА
+
+`tests/w3bankgfx` (huge + `--w3 res.c` + `--bank 1=bank1.c`, графика 256):
+
+- банк рисует примитивом libbgi НАПРЯМУЮ — работает; страница W3 внутри
+  банка до блита, после блита и после возврата из вызванной им W1/W2-функции
+  одна и та же (0xF0), резидент — 0xF3.  То есть `_bgi_begin`/`_bgi_end`
+  корректно возвращают ИМЕННО банковую страницу (правило R4);
+- вызов W1/W2-функции из банка работает, и она тоже может рисовать;
+- резидент W3 жив и вызывается после возврата из банка (R3).
+
+**Дополнительно выяснено (важно для стражей):** писучие статики
+`__banked`-модуля линкуются В СТРАНИЦУ БАНКА (0x1C000+) — снаружи их не
+прочитать, из W1/W2 по 0xC000 видна резидентная страница.  Значит всё
+состояние банкованного кода (позиции стражей, таймеры боя) обязано жить в
+W1/W2 как обычные глобалы, а банк — только код.
+
+Ещё одна мина, найденная там же: инлайновый `in a,(#0xE2)` посреди тела
+функции затирает A, куда SDCC уже положил параметр (у нас из-за этого цвет
+заливки стал номером страницы, и «резидент не рисовал»).  Читать порт
+отдельной `__naked`-функцией.
+
+### Найденная по дороге ловушка компилятора
+
+`(const T *)КОНСТАНТА + var*K` SDCC 4.5 может собрать неверно: умножение
+делает в 16 битах, а потом берёт только младший байт (`ld c,l` / `inc b`).
+Кадры Kid с индексом ≥ 52 читались из чужой строки таблицы, у бега/шага
+пропадал `FRAME_NEEDS_FLOOR` и персонаж проваливался сквозь пол.  Лечение —
+считать адрес в `uint16_t` и кастовать один раз.  Тот же паттерн в
+`pop_level.c` компилируется ПРАВИЛЬНО, т.е. полагаться на «у соседа
+работает» нельзя.  Подробности: memory `sdcc_z80_const_ptr_index_bug`.
+
+---
+
+## 0. Что уже сделано из v1 (не повторять)
+
+- `--opt-code-size` и `--max-allocs 100000` **уже включены по умолчанию** в
+  `bin/sprinter-cc` (v1 §2.1 закрыт, выигрыш получен).
+- Лишние блиты переднего слоя убраны (v1 §7 п.0): `fore_tile` больше не рисует
+  `bottom_id`, `_CODE` −388 Б.
+- `gfx_blit_noclip` в libbgi (v1 §8 шаг 1): фоновые блиты в 2.9× дешевле.
+- `--w3` как резидент окна 3 реализован и обкатан (memory `w3_resident_code`).
+
+---
+
+## 1. ЗАМЕР (сборка 2026-07-29, коммит 1214785)
+
+Команда: `--memory small --gfx 256 --w3 pop_trob.c pop_map.c --w3 pop_bg.c`.
+
+### 1.1 Окна
+
+| Область | Занято | Свободно | Примечание |
+|---|---|---|---|
+| W1+W2 `_CODE` | 24 881 Б | — | 0x4100…0xA231 |
+| W1+W2 `_HOME`+`_GSINIT`+`_DATA`+`_BSS` | ~4 240 Б | — | до 0xB2E4 |
+| **W1+W2 куча** | 0 (никто не malloc'ит) | **2 076 Б** | 0xB2E4…0xBB00 |
+| W1+W2 стек | — | 1 279 Б | 0xBB00…0xBFFE |
+| **W3 резидент** | 14 376 Б | **2 008 Б** | 0xC000…0xF828 |
+| EMM-страницы | 37 атласов + 1 уровень | ~215 страниц свободно | `sprinter_emm_budget` |
+
+**Итого запаса до стены: ≈ 4 КБ** (2 КБ в W1/W2 + 2 КБ в W3).  Стражи туда
+не влезут.
+
+### 1.2 Код по модулям (точно, из `.rel`)
+
+```
+W1/W2 (_CODE 24 881):            W3 резидент (_W3CODE 14 376):
+  pop_kid      6 963               pop_bg     11 643
+  pop_map      6 157               pop_trob    2 733
+  roomtest     2 583
+  pop_level    1 425
+  pop_ctrl     1 145
+  crt0           333
+  libc+libbgi ~6 275
+```
+
+### 1.3 Крупнейшие функции/данные (из `.lst`)
+
+```
+pop_bg   : draw_tile 3080, other_overlay_tile 1146, wall_pattern 944,
+           mob_render 720, mob_tick_one 661, overlay_mid_tile 498,
+           fore_only_tile 409, climb_overlay_tile 391, tile_table 371
+pop_map  : check_loose_fall_on_kid 674, check_bumped 567, jump_up_or_grab 413,
+           get_tile 266, do_knock 243, check_press 238, check_leave 212
+pop_kid  : kid_seqtbl 2310 + kid_frames 1205 + kid_seq_off 230 = 3745 Б ДАННЫХ
+           (в _CODE!), собственно кода ~3.2 КБ
+roomtest : enter_room+main ~2.1 КБ
+pop_level: room_bg_ptr 1084 (+ 515 Б таблиц LINKLOC/LINKMAP в _DATA)
+```
+
+### 1.4 `_DATA` (3 710 Б)
+
+```
+pop_trob 963  (room_modif[24][30] = 720 + trobs + rest-массивы)
+pop_level 515 (копии LINKLOC/LINKMAP уровня)
+pop_map 163, roomtest 141, pop_kid 130, pop_bg 115, pop_ctrl 13
+libc: _irq_state 818, _kbdraw_state 515, _gfx_pal_buf 256, прочее ~200
+```
+
+### 1.5 Находки замера (мелкие, но чинить)
+
+1. **`--w3` берёт ОДИН файл на флаг.**  В `Makefile` написано
+   `--w3 pop_trob.c pop_map.c --w3 pop_bg.c`, и это значит «W3 = pop_trob и
+   pop_bg», а `pop_map.c` компилируется как обычный исходник в W1/W2.  Судя по
+   `.sprinter-cc-roomtest/w3_pop_map.rel` (устаревший артефакт), когда-то
+   pop_map был в W3.  **Решить осознанно** (см. §4) и записать явно:
+   `--w3 pop_trob.c --w3 pop_bg.c`.
+2. `libc` тянет `_irq_state` 818 Б + `_kbdraw_state` 515 Б в `_DATA`.
+   `__irq_vec_buf` (513 Б) — таблица векторов IM2; `__kbdraw_down` (512 Б) —
+   битмап клавиш на 512 скан-кодов.  Оба можно ужать (см. §5.4), это ~0.7 КБ
+   в самом дефицитном окне.
+
+---
+
+## 2. ПРАВИЛА ПЛАТФОРМЫ, ОТ КОТОРЫХ ПЛЯШЕТ РАСКЛАДКА
+
+Это главное, что изменилось по сравнению с v1: модель банкинга уточнена по
+`bin/sprinter-cc` (справка `--w3`/`--bank`) и по коду libbgi.
+
+**(R1) Резидент W3 (`--w3`) и банки W3 (`--bank`) делят одно окно.**
+Резидент лежит на своей странице 0xC000…0xFFFF; трамплин на время вызова
+`__banked` подменяет страницу W3 на банковую и возвращает резидентную назад.
+
+**(R2) Из банка резидент W3 НЕДОСТИЖИМ — и транзитивно тоже.**
+Пока исполняется банк, резидентной страницы в адресном пространстве нет.
+Значит нельзя не только `bank → pop_bg()`, но и `bank → pop_map() → pop_bg()`.
+**Это ключевое ограничение при выборе, что делать банком.**
+
+**(R3) Резидент → банк работает** (через трамплин в W1), резидент → W1/W2 —
+тоже.
+
+**(R4) Графические примитивы libbgi звать можно откуда угодно.**
+`_bgi_begin` читает текущую страницу W3 из порта 0xE2, а `_bgi_end` её
+возвращает — то есть скобка корректна и из банка, и из резидента.  Нельзя
+только одно: **звать `_bgi_begin`/`_bgi_end` ИЗ кода, который сам лежит в W3**
+(после подмены страницы исчезнет исполняемый код — проверено, белый экран).
+Поэтому `pop_bg` (резидент W3) обязан пользоваться готовыми примитивами
+(`gfx_blit*`, `bar`, …), а батчинг скобки на весь `draw_tile` (v1 §8 шаг 1)
+для него **невозможен** без переноса самого `draw_tile` в W1/W2.
+
+**(R5) `--w3` кладёт в W3 код И rodata модуля** (`--codeseg/--constseg
+W3CODE`), а писучие статики оставляет в `_DATA` (W2).  То есть `const`-таблицы
+переносятся в W3 бесплатно вместе с модулем (так уже лежит `tile_table` 371 Б).
+
+**(R6) Данные в EMM-странице читаются, только пока страница в окне.**
+`gfx_w0_map(page)` / `gfx_w0_unmap()` — окно W0 (0x0000…0x3FFF), первые 0x100
+занимает ISR-стаб.  Так уже работает `pop_level`.  Цена — пара `OUT` на
+маппинг, поэтому годится для «пачками», а не для чтения по байту в горячем
+цикле.
+
+---
+
+## 3. ЧТО ДЕЛАТЬ НЕЛЬЗЯ (анти-паттерны, чтобы не потерять время)
+
+- **Нельзя банковать `pop_bg`.**  Он вызывается из pop_map, pop_trob, roomtest,
+  pop_kid — то есть из главного цикла на каждом кадре; плюс он сам держит
+  `tile_table` и всю отрисовку.  Банк дал бы трамплин на каждый блит.
+- **Нельзя банковать `pop_map`, пока `pop_map` зовёт `pop_bg`** (R2).  Сейчас
+  зовёт: `pop_loose_tick` и компания (~30 вызовов графики).
+- **Нельзя тащить `kid_frames` в EMM «в лоб»**: он читается несколько раз за
+  кадр из коллизии (`kid_cur_dx`/`kid_cur_flags` → `dx_weight`,
+  `char_x_forward_edge`, …).  Нужен кэш кадра (см. §5.1) — иначе маппинг
+  страницы окажется в горячем пути.
+- **Нельзя «причёсывать» семейство `draw_tile` ради экономии, не имея
+  пиксельного теста.**  Мы неделю выравнивали слои по SDLPoP; любой рефактор
+  этой зоны проверять диффом страниц (заморозка кадра клавишей `1` + сравнение
+  VRAM обеих страниц, приём из memory `mame_mcp_bridge`).
+
+---
+
+## 4. ЦЕЛЕВАЯ РАСКЛАДКА
+
+Принцип: **W3-резидент = «толстая графика, которую зовёт только главный цикл»;
+W1/W2 = ядро, которое должно быть достижимо ОТОВСЮДУ (включая банки); банки =
+новая холодная логика (стражи, боёвка, будущие уровни)**.
+
+```
+W1/W2 (всегда отображено)          W3 резидент (стр. 0xC000)      Банки W3
+──────────────────────────         ─────────────────────────      ─────────
+libc + libbgi                      pop_bg   (отрисовка тайлов)    guards.c
+pop_kid  (интерпретатор+рисование)  pop_trob (анимации тайлов)     fight.c
+pop_map  (коллизия/физика/предметы) pop_loose.c (loose+потолок)    debug/roomnav
+pop_geom (общая геометрия/тайлы)    enter_room-часть roomtest?
+pop_ctrl (ввод/диспетчер)
+roomtest (главный цикл)
+```
+
+Почему так:
+
+- **`pop_map` остаётся в W1/W2** — его зовут и главный цикл, и (в будущем)
+  банк стражей; в W3 его класть нельзя именно из-за R2.  Для этого из него надо
+  вынести графическую часть (loose/потолок) — она уезжает в W3 к `pop_bg`
+  (§5.3).  После выноса `pop_map` становится **чистой логикой без единого
+  вызова графики** — тот самый bank-safe API.
+- **`pop_kid` остаётся в W1/W2**: `play_seq`/`kid_set_seq`/`Kid` нужны и
+  стражам (у стражей ТА ЖЕ seqtbl), а `kid_draw` зовёт только libbgi (R4).
+- **`pop_trob` остаётся резидентом**: его зовёт только главный цикл, и он сам
+  зовёт `pop_bg` — идеальный житель W3.
+- **Банк стражей не зовёт ничего из W3.**  Рисование стражей — либо через
+  libbgi напрямую (R4), либо (лучше) резидентный `guard_draw()` в W1/W2 рядом
+  с `kid_draw`, а банк только считает состояние.  Тот же приём мы уже
+  используем для `pop_item_taken`/`pop_loose_fell`/`pop_ceil_fell`: банк
+  выставляет флаг — резидент рисует.
+
+---
+
+## 5. ПЛАН РАБОТ
+
+Порядок выбран так, чтобы каждый шаг был проверяем отдельно и давал место
+следующему.
+
+### Шаг 1. `kid_data.h` (3 745 Б) → EMM-страница + порт `load_frame` — **самый большой выигрыш**
+
+Сейчас `kid_seqtbl` (2310) + `kid_frames` (1205) + `kid_seq_off` (230) лежат в
+`_CODE` окна W1/W2 — это 15 % всего дефицитного пространства.
+
+Как переносить:
+
+1. `pop_extract_kid_data.py` дополнительно пишет `kid_data.bin` (те же три
+   таблицы подряд, фиксированные смещения).
+2. Грузим её в отдельную EMM-страницу тем же способом, что уровень
+   (`pop_level_load` — готовый образец), хэндл держим в `pop_kid`.
+3. **Порт `load_frame` (seg006) и глобала `cur_frame`** — в оригинале ровно
+   так и сделано: раз за тик кадр копируется в структуру, а весь остальной код
+   читает `cur_frame`, а не таблицу.  У нас `kid_cur_dx()/kid_cur_flags()`
+   станут чтением из `cur_frame` (5 байт в `_DATA`).
+4. `play_seq` оборачивается в один `gfx_w0_map(kid_data_page)` … `unmap` на
+   вызов (в тике, не в отрисовке — конфликта с атласом в W0 нет).
+
+Выигрыш: **−3 745 Б из W1/W2**, цена — один маппинг страницы за тик и 5 байт
+`_DATA`.  Дополнительный бонус: `load_frame`/`cur_frame` — шаг К СХОДСТВУ с
+оригиналом, а не отход от него.
+
+Риск: сломать `play_seq` (сердце анимации).  Проверка: прогон по комнатам с
+эталонными позами (вис, подтягивание, прыжки, подъём меча).
+
+### Шаг 2. Модуль `pop_geom.c` — дедуп + bank-safe фундамент
+
+Сейчас продублировано между модулями:
+
+| что | где | сколько |
+|---|---|---|
+| `y_to_row`/`y_to_row_mod4` | pop_bg + pop_map | 2 копии |
+| `char_dx_forward` | pop_kid + pop_map | 2 копии |
+| `x_bump[20]` | pop_kid (uint8) + pop_map (int16) | 20 + 40 Б, РАЗНЫЕ типы |
+| `y_land[5]` | pop_kid + pop_map | 10 + 10 Б |
+| `tile_is_floor` | pop_map (+ проверка кодов в roomtest) | 2 места |
+| 32-битный LCG `prandom` | pop_bg (`prandom`) + pop_trob (`trob_prandom`) | 2 копии по ~60 Б + 2 сида |
+
+Собрать в один W1/W2-модуль `pop_geom.c`: таблицы `x_bump/y_land/dir_front/
+dir_behind`, `y_to_row`, `char_dx_forward`, `get_tile_div_mod(_m7)`,
+`tile_is_floor`, `prandom`.  Выигрыш прямой — сотни байт (оценка 250–400 Б),
+но главное — **это и есть тот «чистый» API, который потом сможет звать банк**
+(R2): вся геометрия оказывается в W1/W2 по определению.
+
+Осторожно: `prandom` у pop_bg и pop_trob — РАЗНЫЕ последовательности с разными
+сидами (стены vs фазы факелов).  Объединять функцию можно, **сиды — нет**:
+передавать сид указателем/по индексу, иначе поедет раскладка кладки.
+
+### Шаг 3. Вынести loose/потолок из `pop_map` в W3
+
+`pop_map` — единственный модуль W1/W2, который зовёт графику, и делает это
+ровно в одном логическом блоке: `pop_loose_tick` + `check_press` + `do_knock` +
+`fell_on_your_head` + `check_loose_fall_on_kid` + плита-потолок (~1.4–2 КБ).
+
+Вынести их в `pop_loose.c`, собираемый `--w3` рядом с `pop_bg`/`pop_trob`.
+Тогда:
+
+- `pop_map` = чистая логика (bank-safe, R2 соблюдён);
+- W1/W2 худеет ещё на ~1.5–2 КБ;
+- W3 растёт на столько же — а место там появится после шага 4.
+
+### Шаг 4. Перебалансировка резидента W3
+
+После шага 3 в W3 будет тесно (14.4 + 2 ≈ 16.4 КБ > 16 КБ).  Разгружаем:
+
+1. **`wall_pattern` (944 Б) + `mob_render`/`mob_tick_one` (1381 Б)** — кандидаты
+   на переезд в W1/W2: их зовёт только `pop_bg`/`pop_loose`, но сами они уже
+   пользуются только libbgi (R4), значит из W1/W2 работают и остаются
+   достижимыми из банка.
+2. `tile_table` и мелкие const-таблицы pop_bg (371 + ~300 Б) можно унести в
+   EMM-страницу **уровня** (там ~13.8 КБ свободно) — но только если чтение
+   происходит под уже замапленной страницей.  Сейчас `draw_tile` читает
+   `tile_table` ВНЕ W0-контекста → потребуется явный маппинг на тайл.  **Не
+   делать раньше замера**: 30 тайлов на входе в комнату × map/unmap — терпимо,
+   а вот в покадровых редроях (пики/loose/кнопка) — уже горячий путь.
+3. Если и этого мало — `enter_room` (~2.1 КБ, зовётся только при смене комнаты)
+   переносится в резидент W3 или в БАНК (он вызывается из главного цикла =
+   резидента, значит банк допустим по R3).
+
+### Шаг 5. Данные
+
+1. **`room_modif[24][30]` = 720 Б** (pop_trob, `_DATA`).  Нужен произвольный
+   доступ каждый кадр (анимации, ворота) — в EMM не годится.  Но 24 комнаты ×
+   30 байт хранятся ЦЕЛИКОМ, хотя одновременно живут modif'ы только текущей
+   комнаты и соседей по швам.  Вариант: хранить полный массив в EMM-странице
+   уровня, а в `_DATA` держать кэш на 2–3 комнаты (свою + левого/правого
+   соседа) с записью обратно при смене комнаты.  Выигрыш ~600 Б, цена —
+   аккуратность на швах (кнопка в одной комнате открывает ворота в другой).
+   **Делать последним** — это самая «тонкая» правка по семантике.
+2. **`dl1[256]`+`dl2[256]` = 512 Б** (pop_level, `_DATA` — копии LINKLOC/
+   LINKMAP уровня) — читаются при нажатии кнопки
+   и при отрисовке нажатой кнопки.  Кандидат на чтение прямо из страницы
+   уровня (она и так маппится) — но проверить, что `pop_doorlink2` не зовётся
+   из отрисовки в тот момент, когда в W0 атлас.  Выигрыш ~500 Б.
+3. **`_kbdraw_down[512]` 512 Б** (libc): проверено — это **байт на скан-код**
+   (`libc/kbd/_kbdraw_state.c`), хотя комментарий называет его битовой картой.
+   Упаковка в биты даёт −448 Б, но добавляет сдвиг/маску в ISR-трамплин и в
+   `kbd_raw_down`.  Трогать осторожно: raw-клавиатура уже дважды была
+   источником залипаний (memory `kbd_raw_fifo_drain`,
+   `kbd_overrun_wipe_modifiers`) — правку сопровождать прогоном docs/kbd-games.
+4. **`__irq_vec_buf` 513 Б** (libc IM2): таблица векторов обязана быть
+   выровнена и полна — не трогать.
+
+### Шаг 6. Контракт банка стражей (проектируется ДО написания кода)
+
+Когда дойдём до стражей:
+
+- `guards.c` собирается `--bank 1=guards.c`, режим `huge` (или `big` с
+  `BANKED=W1`, если W3 окажется тесен для трамплинов).
+- **Банк зовёт только:** `pop_map` (чистая логика после шага 3), `pop_kid`
+  (`play_seq`, `kid_set_seq`, `cur_frame`), `pop_geom`, libc/libbgi.
+- **Банк НЕ зовёт:** `pop_bg`, `pop_trob`, `pop_loose` (резидент W3) — ни
+  прямо, ни через промежуточные функции.  Нужна отрисовка — выставляет флаг,
+  рисует резидент (идиома `pop_item_taken`).
+- Первым делом — **пробник** (`tests/` или `--bank` на пустышке): банк зовёт
+  `pop_map`-функцию, та зовёт libbgi-примитив; убедиться в MAME, что скобка
+  W3 корректно возвращает банковую страницу (R4) — это проверка модели, а не
+  веры в неё.
+
+### Шаг 7. Мелкий дедуп в `pop_bg` (после того, как появится тест страниц)
+
+- Пять функций-редроев (`pop_spike_redraw`, `pop_loose_shake_draw`,
+  `pop_floor_bake`, `pop_button_redraw`, `pop_leveldoor_redraw`) отличаются
+  только прямоугольником heal, банком и набором тайлов — свести к одному
+  параметризованному хелперу (оценка −150…250 Б).
+- `env_b/wall_b/fore_b/pot_b` — четыре одинаковых обёртки над `blit_b`
+  (оставить: экономия единицы байт, читаемость дороже).
+- `overlay_mid_tile` / `fore_only_tile` / `climb_overlay_tile` / `draw_tile`
+  — общая структура «взять code/lcode, посчитать x/dmy/dby, разобрать слои».
+  Тут экономия потенциально сотни байт, но это **та самая зона риска из §3** —
+  только с пиксельным диффом до/после и по одному слою за раз.
+
+---
+
+## 6. Ожидаемый итог
+
+| Шаг | W1/W2 | W3 | Риск |
+|---|---|---|---|
+| 1. kid_data → EMM + load_frame | **−3 745** | — | средний (сердце анимации) |
+| 2. pop_geom (дедуп) | −250…400 | — | низкий |
+| 3. loose → W3 | −1 500…2 000 | +1 500…2 000 | низкий (перенос как есть) |
+| 4. разгрузка W3 (wall_pattern, mob) | +2 300 | −2 300 | низкий |
+| 5. данные (room_modif, LINKLOC, kbd) | −1 000…1 600 | — | средний/высокий |
+| 7. дедуп редроев pop_bg | — | −150…250 | средний |
+
+Суммарно: **W1/W2 освобождается ~4.5–6 КБ**, W3 остаётся примерно в нынешнем
+объёме, но становится «правильно заполненным» — в нём только то, что банк
+никогда не позовёт.  Плюс открывается путь к банкам: стражи и боёвка получают
+до 16 КБ на банк, не трогая резидент.
+
+---
+
+## 7. Как мерить и проверять (обязательно к каждому шагу)
+
+1. **До/после по `.rel`** — точные размеры на модуль:
+   `for f in .sprinter-cc-roomtest/*.rel; do grep '^A ' $f; done`
+   (области `_CODE`/`_W3CODE`/`_DATA`).  Итоги окон печатает сам `sprinter-cc`.
+2. **Функции** — из `.lst` (метки `_name:` и адреса), скрипт в истории этой
+   сессии; полезно ловить «функция распухла после рефактора».
+3. **MAME**: любой перенос кода между окнами/страницами — это класс «молча
+   ломается» (`sprinter_memory_modes`).  Минимум: комната 1 (loose), 12
+   (вис/подтягивание), 15 (меч), 9 (дверь уровня), 6 (кнопка/ворота).
+4. **Пиксельный дифф** для правок отрисовки: заморозить кадр (`1`), сравнить
+   обе страницы дабл-буфера через `vram` (см. memory `mame_mcp_bridge`) и/или
+   сверить с эталонным рендером `render_room.py`.
+5. **Скорость** — после шагов 1 и 4 замерить кадр маркерами в порт 0xFE
+   (приём из v1 §8), чтобы маппинг страницы за тик не съел бюджет.
+
+## 8. Ссылки
+
+- `bin/sprinter-cc` — справка по `--w3`, `--bank`, `--memory`, `--memory-manual`.
+- `runtime/crt0_banked.s`, `runtime/bank.s` — трамплины и захват резидентной
+  страницы W3.
+- `libbgi/common/_bgi_begin.c` / `_bgi_end.c` — механика скобки W3 (R4).
+- memory: `w3_resident_code`, `pop_banking_architecture`, `sdcc_banking`,
+  `bank_local_data_pattern`, `sprinter_memory_modes`, `memory_modes_implemented`,
+  `sprinter_emm_budget`, `mame_mcp_bridge`, `avoid_32bit_arith_z80`,
+  `libc_one_function_per_module`.
+- `applications/PoP/roomtest/TASKS_OPEN.md` — что из этого берётся в работу сейчас.
+
+---
+
+## 9. Скорость отрисовки: замеры и запас
+
+Перенесено из удалённого `size_optimization_plan.md` §8 (замер 2026-07-27) —
+единственная его часть, которая не была перекрыта этим документом.
+Профилирование в MAME: маркеры в порт 0xFE + `wpiset … totalcycles` (приём из
+memory `mame_mcp_bridge`); в самом `roomtest.c` для этого уже стоят полосы
+бордюра `PROF()`.  Кадр Sprinter = **430 080 тактов**.
+
+**Стоимость блита почти НЕ зависит от размера** — платим за проход по цепочке
+`gfx_blit → gfx_blit_part → _gfx_blit_full` (16-битная арифметика, клип,
+пересчёт src, нарезка полос >256), а не за пиксели:
+
+| путь (спрайт 32×3) | тактов |
+|---|---|
+| `gfx_blit` (общее ядро, с клипом) | 13 288 |
+| линейное ядро без клипа | 4 617 |
+
+Отсюда `draw_tile(0,0)` тайла шва (9 блитов) стоил **183 690 тактов = 43 %
+кадра**; сам `bar` — только 13 308.
+
+**Сделано:** `gfx_blit_noclip()` в libbgi, фоновые блиты `pop_bg` уходят на
+него, когда спрайт целиком на экране (~2.9×, подтверждено в MAME).  Позже
+тем же приёмом закрыты спрайты персонажей (`gfx_blit_cols_part_noclip`).
+**Не закрыт heal** — задача CLIP-1 в `../roomtest/TASKS_CLOSED.md`.
+
+**ВАЖНО:** W3-скобку (`_bgi_begin`/`_bgi_end`) ставит САМА libbgi — вызывать
+её из модуля, собранного с `--w3`, нельзя: после `_bgi_begin` окно W3 занято
+видеобанком и код вызывающего исчезает из адресного пространства (проверено:
+белый экран).
+
+**Запас, когда перестанет хватать бюджета кадра:**
+
+1. **Батчинг W3-скобки** — одна `_bgi_begin`/`_bgi_end` на весь `draw_tile`
+   вместо скобки на блит; нужен публичный batch-API в libbgi.
+   **Осторожно, и это стало важнее, чем было:** между begin/end стоит `DI`,
+   длинная серия задержит кадровое прерывание — а по разбору KBD-1
+   (`../roomtest/TASKS_CLOSED.md`) длинные DI-окна и есть причина потери байт
+   клавиатуры.  Батчинг эту проблему УХУДШИТ, если делать его вслепую.
+2. **Решётка ворот одним спрайтом** — `draw_gate_back` рисует бары по одному
+   (до 7 блитов).  Сгенерировать в атласе «столб решётки» и выводить одним
+   `gfx_blit_part` с обрезкой по фазе `gate_bot_y & 7`: 7 блитов → 1.
+3. **Не перерисовывать статичные части шва** — грань ворот, пол и кромка при
+   анимации решётки не меняются (см. OPT-1 в `../roomtest/bug_closed.md` —
+   решено не делать, стоимость транзиентная).
+4. **T-1 / T-2** (`../roomtest/bug_list.md`) — перерисовка пик по причине и
+   idle-skip Кида: самый большой оставшийся резерв, потому что убирает работу
+   целиком, а не удешевляет её.
@@ -0,0 +1,197 @@
+# План: от одного уровня к нескольким (загрузка, переходы, тайлсеты)
+
+Статус: план, 2026-08-01.  Продолжает `PORT_PLAN.md` §7 (Фаза 1: «переходы
+между экранами» → теперь между УРОВНЯМИ).  Текущая точка: `roomtest` играет
+уровень 1 целиком в одной комнате-за-комнатой модели, но уровень нельзя
+ни выбрать, ни закончить.
+
+Источник истины — `../SDLPoP/src/` (правило `../CLAUDE.md`).  Ключевые
+места: `seg000.c: load_lev_spr/play_level_2/init_game`, `seg005.c:
+up_pressed/go_up_leveldoor`, `seg006.c: play_seq → SEQ_END_LEVEL`,
+`seg002.c` (спецсобытия уровней), `data.h:835..850` (потабличные различия
+уровней).
+
+---
+
+## 0. Что уже готово (не проектировать заново)
+
+- **Формат и загрузчик уровня.**  `pop_level.c/.h` читает сырой
+  `res200N.bin` (2305 Б) в отдельную EMM-страницу; путь — параметр
+  `pop_level_load(const char *)`.  Мультиуровневость здесь стоит одной
+  функции формирования имени.
+- **Стартовая позиция уровня** уже разобрана: `pop_level_start_room()`,
+  `pop_level_start_pos()`, `pop_level_start_dir()` — реализованы и пока
+  НЕ вызываются (см. `../roomtest/TASKS_CLOSED.md` L1-START).
+- **Страж по данным уровня**: `pop_level_guard()` (порт `enter_guard`),
+  сохранение состояния между комнатами (`pop_guard_state_save`).
+- **Палитра разложена по слотам ровно как в оригинале** (`pop_pack_kid.py`
+  `build_palette`): env 0x50, wall 0x60, pot 0x40, kid 0x70, меч 0x80,
+  страж 0x90.  Это тот же раскрой, что `set_pal_arr(0x50/0x60)` в
+  `seg000.c:1140..1148`, — значит смена тайлсета не требует переиндексации
+  спрайтов Кида (см. §3).
+- **Все 16 файлов уровней распакованы**: `../SDLPoP/data/LEVELS/res2000..
+  res2015.bin` (0 — демо-уровень).
+
+---
+
+## 1. Что реально различается между уровнями (замер по данным, не по памяти)
+
+Таблицы из `../SDLPoP/src/data.h:840..847` + инвентарь тайлов, снятый прямо
+с `res200N.bin` (маска `fg & 0x1F`):
+
+| Ур. | Тайлсет | Страж | Новое против предыдущих |
+|-----|---------|-------|--------------------------|
+| 1 | dungeon | обычный | — (текущая база) |
+| **2** | **dungeon** | **обычный** | **ничего нового: тот же набор объектов минус меч** |
+| 3 | dungeon | СКЕЛЕТ | чомперы |
+| 4 | palace | обычный | **тайлсет palace**, зеркало (спецсобытие `mirror_level`) |
+| 5 | palace | обычный | — |
+| 6 | palace | ТОЛСТЫЙ | падение на входе (спецсобытие) |
+| 7 | dungeon | обычный | — |
+| 8, 9 | dungeon | обычный | — |
+| 10, 11 | palace | обычный | — |
+| 12 | dungeon | ТЕНЬ | seamless-выход (комната 23), исчезающий меч |
+| 13 | dungeon | ВИЗИРЬ | мышь, особый выход |
+| 14 | palace | нет | — |
+| 15 | dungeon | нет | финал |
+
+Прямое следствие для порядка работ: **уровень 2 не требует ни одного нового
+ассета и ни одной новой механики** — он проверяет ровно машинерию перехода.
+Это и есть первый шаг.
+
+Прочие потабличные различия, которые придётся завести массивами по 16:
+`tbl_level_type` (тайлсет), `tbl_guard_type` (−1 = стражей нет),
+`tbl_guard_hp`, `tbl_level_color` (вариантные палитры, 1.3), `tbl_entry_pose`.
+
+---
+
+## 2. Шаг 1 — машинерия перехода (цель: уровни 1 → 2 → 3) — **СДЕЛАН 2026-08-04**
+
+> **Итог.**  Всё в этом разделе портировано и проверено в MAME: уровень 1 →
+> Shift+L → уровень 2 (комната 5, дверь захлопывается за спиной, большие
+> колонны рисуются) → уровень 3.  Разбор что именно сделано и что по
+> уровню 2 осталось — `../roomtest/TASKS_CLOSED.md`, запись **L2**.
+>
+> Сверх плана пришлось доделать две вещи, без которых уровень 2 не играется:
+> **`find_start_level_door`** (стартовый тайл уровня 2 — это правая половина
+> двери уровня) и **большую склянку** `add_life` (тип зелья 2, комната 20).
+
+Порядок именно такой; каждый пункт проверяем в MAME отдельно.
+
+**2.1 Выход с уровня.**  Портировать `up_pressed()` ветку двери
+(`seg005.c:410..423`) + `go_up_leveldoor()` (`seg005.c:497`): дверь рядом
+(при/за/перед персонажем) И `drawn_room != level.start_room` И створка
+открыта полностью (`curr_room_modif >= 42` — вариант `fix_exit_door`) →
+`Char.x = x_bump[...] + 10`, направление влево, `seq_70_go_up_on_level_door`.
+Затем оживить опкод `0xF1 END_LEVEL` в `play_seq` (`../roomtest/pop_kid.c:418`
+— сейчас пустой `break`): `++pop_next_level`, как `seg006.c:662`.
+
+**2.2 Цикл уровня.**  В `main()` после тика: `if (pop_next_level !=
+pop_current_level) → load_level(pop_next_level)`.  Порядок сноса/подъёма
+состояния (порт `load_lev_spr` + `play_level_2`):
+`pop_level_free` → `pop_level_load("LEVELS\\res200%d.bin")` →
+`pop_trob_reset` → `pop_guard_reset` → сброс tile-override'ов
+(`ovr_*` в `roomtest.c`) → `enter_room(pop_level_start_room())` →
+`kid_init(поза/позиция/направление из данных уровня)`.
+**HP через уровень переносится** (в оригинале `hitp_beg_lev`), не сбрасывать
+в максимум — сверить с `seg000.c` `init_game`/`play_level_2`.
+
+**2.3 Стражи по уровню.**  Завести `tbl_guard_type[16]`/`tbl_guard_hp[16]`;
+`-1` = стражей на уровне нет (уровни 14, 15) — `pop_guard_enter` обязан это
+понимать, иначе на 14-м полезут стражи из мусора.  Для шага 1 (уровни 2, 3)
+достаточно обычного стража, но проверку `-1` заложить сразу.
+
+**2.4 Чит «следующий уровень» (Shift+L).**  Реализуется ровно тем же
+`pop_next_level` — и без него отладка уровней превращается в прохождение
+игры руками.  Делать в этом же шаге, не позже (см. §4).
+
+**Приёмка шага 1:** дверь уровня 1 → уровень 2 играется целиком → его дверь
+→ уровень 3 стартует (чомперы могут быть ещё не портированы — тогда
+фиксируем как известное ограничение, а не «баг»).
+
+---
+
+## 3. Шаг 2 — второй тайлсет (palace, уровни 4+)
+
+**Ассеты.**  `toolchain/pop_pack_bg.py` уже читает PNG каскадом
+VDUNGEON→VPALACE (та же логика, что в игре), но печёт ОДИН набор атласов
+(`pop_env0..4.atl`, `pop_wall.atl`, `pop_fore.atl` ≈ 75 КБ).  Нужен второй
+набор из VPALACE (`pal_env*.atl` / `pal_wall.atl`), плюс `torch_debris` —
+тайл, который встречается только на palace-уровнях.  По EMM это ещё ~6
+страниц при бюджете ~3.3 МБ — не проблема.
+
+**Палитра — главный технический вопрос, и он уже решён раскроем.**
+Тайлсет живёт в слотах `0x50..0x5F` (env) и `0x60..0x6F` (wall); Кид, меч,
+страж, склянки — в других слотах.  Значит смена тайлсета = перезапись 32
+записей палитры (`gfx_pal_set` на обе страницы, как `flash_bg` в
+`roomtest.c`), а НЕ перезагрузка `kid.pal` и не переиндексация спрайтов.
+Сделать `pal_dungeon.bin` / `pal_palace.bin` (по 32 записи) и грузить при
+смене типа уровня.  Проверить артефактом: скриншот palace-комнаты против
+рендера `render_room.py` для того же уровня.
+
+**Вариантные цвета уровней** (`tbl_level_color`, `level_var_palettes` — это
+уже 1.3, в 1.0 их нет): по той же механике, тот же диапазон слотов.  Решение
+на будущее — сначала базовые два тайлсета, потом при желании цвета.
+
+**Выбор набора в коде.**  `pop_bg_load()` сейчас грузит фиксированные имена;
+превратить в `pop_bg_load(type)` с двумя таблицами имён + выгрузка старых
+атласов при смене типа (`atlas_free`).  Переключение — только на границе
+уровня, не в кадре.
+
+---
+
+## 4. Читы SDLPoP: что взять на следующем этапе
+
+Из `../SDLPoP/README.md` (раздел Cheats).  У нас уже есть: **K** — убить
+стража, **I** — бессмертие (наш, в оригинале нет), **S** — выдать меч (наш),
+**+/−** — обход комнат (`ROOMNAV`, наш).
+
+**Брать сразу вместе с переходами уровней** (без них отладка дороже самой
+работы):
+
+| Чит | Что даёт | Цена |
+|-----|----------|------|
+| **Shift+L — следующий уровень** | единственный вменяемый способ тестировать уровни 2..15 | тривиально: `++pop_next_level` из §2.2 |
+| **R — воскресить Кида** | у нас респавн по ↑ + таймаут; порт `resurrect` ближе к оригиналу и не мешает управлению | низкая |
+| **Shift+S / Shift+T — +1 HP / +максимум** | отладка боёвки без «ровно трёх попыток»; честная замена нашему читу бессмертия | низкая, HP-машинерия уже есть |
+| **[ и ] — сдвинуть Кида на пиксель** (debug-чит SDLPoP) | прямо бьёт в наш класс багов «окклюзия/шов на один пиксель» — воспроизведение позы без ловли момента | тривиально |
+
+**Брать во вторую очередь:**
+
+| Чит | Почему позже |
+|-----|--------------|
+| **H / J / U / N + Ctrl+B — смотреть соседние комнаты** | требует честной модели `drawn_room ≠ Kid.room` (наш S3-straddle, каркас есть: `update_kid_render_dx`).  Зато потом заменяет самодельный `ROOMNAV` и попутно закрывает straddle-задачу |
+| **Shift+W — медленное падение (feather)** | ветка `JMP_IF_FEATHER` (опкод `0xF7`) в `play_seq` уже есть, но не проверена ничем — чит станет её единственным тестом |
+| **C / Shift+C — номера комнат** | у нас номер рисуется палочками именно потому, что текст тянет 2 КБ знакогенератора в W2 (`roomtest.c`).  Ждёт своего шрифта |
+
+**Не брать:** `Shift+I` (переворот экрана), `Shift+B` (blind mode) —
+развлекательные, к отладке порта отношения не имеют.  `−/+` (время) — нужен
+таймер уровня, которого у нас нет (Фаза 6).
+
+**Отдельно, дорого, но очень ценно — `F6`/`F9` (quicksave/quickload точного
+состояния).**  Это сериализация `Char` + `room_modif` всех комнат + trob'ов +
+состояния стражей.  Даёт то, чего нам сейчас сильно не хватает:
+воспроизводимый регресс в MAME («вот кадр, где баг») вместо ручного подхода
+к позиции.  Кандидат сразу после того, как заработают уровни.
+
+---
+
+## 5. Риски и что проверить артефактом до кодинга
+
+1. **Размер кода.**  Замер сборки 2026-08-01: `_CODE` 25 119 Б,
+   куча ~2.4 КБ, банк 2 (`pop_bg`) 13 792 / 16 384, банк 3 (`pop_map`)
+   6 331, банк 1 (`guards`) 1 896, банк 4 (`pop_gdraw`) 2 236.  Чомперы,
+   зеркало, скелет и второй тайлсет пойдут в банк 2 — там осталось 2.6 КБ.
+   **Прежде чем начинать §3, посчитать, куда лягут новые тайлы**, иначе
+   повторится история «банк 2 упёрся в потолок» (коммит 2f3e854).  Свободные
+   номера банков есть (5+), гранулярность — файл.
+2. **Спецсобытия уровней** (`seg002.c`: `level3_set_chkp`, `sword_disappears`,
+   `Jaffar_exit`, зеркало, мышь) — их НЕ надо портировать заранее.  Для
+   уровней 2 и 3 нужен только чекпойнт уровня 3.  Остальное — по мере
+   подхода к уровню.
+3. **Чомперы** (уровень 3 и почти все дальше) — отдельная механика
+   (`animate_chomper` + коллизия + смерть); шаблон работы тот же, что у
+   пик/ворот, см. `gates_spikes_plan.md`.
+4. **`tbl_guard_type = -1`** на уровнях 14/15: без проверки страж
+   «появится» из неинициализированных данных.
+5. **Уровень 0 (демо)** существует в данных, но в скоуп не входит.
@@ -1,143 +0,0 @@
-# Loose floors (проваливающиеся полы) — план порта
-
-Разбор SDLPoP (seg007 loose/trob/mob, seg008 draw_loose).  ПЛАН, ещё не
-реализовано.  Тайл в комнате 1: `[2,6] = 0x0B = tiles_11_loose`.
-
-## 1. Хранение состояния
-
- **Тип тайла**: `curr_room_tiles[tilepos] & 0x1F == 11` (tiles_11_loose).
-  Бит `0x20` = «solid» loose (авто-падающий вариант, ур.13 — от шага НЕ
-  падает).  После падения тайл → `0` (tiles_0_empty).
- **Модификатор** `curr_room_modif[tilepos]` = состояние анимации:
-  - `0` — покой (обычный loose-пол);
-  - `0x80..0x83` — **трясётся** (бит7); за ~4 кадра затухает обратно в 0;
-  - `1..11` — **обратный отсчёт до падения** (на нём что-то стоит);
-    достигает `loose_floor_delay = 11` → падает.
-
-## 2. Анимация тряски (shake) — когда включается
-
- **Триггер = do_knock** (seg007:0FE0): на ЖЁСТКОМ приземлении в кадрах
-  посадки играет `SEQ_KNOCK_DOWN` → взводит `knock` → `check_knock()` →
-  `do_knock(room, curr_row − (knock>0))`.
- `do_knock(room, row)`: по всем колонкам ряда — если тайл loose →
-  `loose_make_shake()`.
- `loose_make_shake()` (seg007:0FB4): если `modif==0` (и не ур.13) →
-  `modif = 0x80`, `add_trob(type 1)`.
- **Отсюда кейс пользователя**: Kid падает/приземляется на `[2,4]` →
-  do_knock трясёт ВСЕ loose-тайлы ряда 2 → `[2,6]` трясётся.  (Через
-  knock-смещение ряда может задеть и соседний ряд.)
- `animate_loose` (кадрово): `++modif`; при бите7 трясёт до `>=0x84` →
-  сброс в 0, `trob.type=-1`.  `loose_shake()` играет звук
-  (sound 20/21/22) по таблице `loose_sound[]`.
-
-## 3. Анимация падения (fall) — когда включается
-
- **Триггер = make_loose_fall(1)** (seg007:0EF6), вызывается когда:
-  - Kid СТОИТ на loose-тайле — `check_press()` (seg006): кадр с
-    FRAME_NEEDS_FLOOR над loose → make_loose_fall(1);
-  - зацеп/подтягивание на loose (`check_grab`, `check_jump_up`);
-  - пробой сверху: кадр 79 (jumphang) над loose → make_loose_fall(1);
-  - авто-падающие (ур.13) — `make_loose_fall(-(prandom&0x0F))`.
- `make_loose_fall(modifier)`: если НЕ solid (`tiles & 0x20 == 0`) и
-  `(sbyte)modif <= 0` → `modif = modifier`, `add_trob(type 0)`.
- `animate_loose`: `++modif`; когда `modif >= 11` (loose_floor_delay) →
-  `remove_loose()` (тайл → empty) + `add_mob()` (спавн падающего куска).
-
-## 4. Падающий кусок (mob)
-
- `add_mob()` кладёт `curmob` в `mobs[]` (до 14).  `do_mobs()` каждый
-  кадр: `move_mob()` (гравитация, y растёт) + `check_loose_fall_on_kid()`
-  (урон Киду/страже, если попал).
- Приземление куска → тайл под ним `curr_room_tiles[...] = tiles_14_debris`
-  (seg007 move_mob:1053).  Т.е. **loose(11) упал → сверху empty(0), снизу
-  debris(14)**.
-
-## 5. Отрисовка по статусу
-
- Куски тайла: `loose_fram_left[]={41,69,41,70,70,41,41,41,70,70,70,0}`,
-  `loose_fram_right[]={42,71,...}`, `loose_fram_bottom[]={43,73,...}`
-  (env-спрайты, seg008:518/596/608).
- Индекс кадра = `get_loose_frame(modifier)` (seg008): `0` = ровный
-  (41/42/43); `1..10` = дрожащие варианты (69–74); при бите7/большой
-  задержке — низкие индексы.
- **До падения**: рисуем loose с `get_loose_frame(modif)` (0 = ровно,
-  иначе колеблется).  **После**: сверху empty, снизу debris(14) — обычная
-  статическая отрисовка (у нас уже есть tile 0x0E/14 debris в tile_table).
-
-## 6. Что нужно в нашем движке (сейчас НЕТ)
-
-Наш `pop_bg` рисует комнату СТАТИЧЕСКИ один раз.  Loose-полы требуют
-**динамического тайлового слоя**:
-1. **Массив модификаторов** `room_modif[30]` (у нас есть `bg[30]` — можно
-   переиспользовать/рядом) — состояние каждого тайла.
-2. **Очередь trob** (список анимируемых тайлов) + `animate_loose` пер-кадр
-   → перерисовка ТОЛЬКО изменившихся тайлов (как heal-прямоугольник Kid).
-3. **make_loose_fall / do_knock / loose_make_shake** — триггеры (из
-   физики Kid: приземление→knock, стойка на loose→fall).
-4. **mob-система** (падающий кусок): минимум 1–2 mob'а, гравитация,
-   приземление → debris.  Урон Киду (`check_loose_fall_on_kid`) — можно
-   Фазой 2.
-5. **Перерисовка тайла**: `draw_tile(row,col)` у нас уже умеет loose
-   (`code==11`, `loose_fram_*` в env) — нужно вызывать его выборочно с
-   текущим модификатором (сейчас draw_tile берёт статический bg).
-
-**Порядок реализации (предложение):**
- L1: room_modif[] + выборочная перерисовка тайла по модификатору
-  (draw_loose с get_loose_frame) — статика→динамика одного тайла.
- L2: trob-очередь + animate_loose (тряска по do_knock на приземлении).
- L3: make_loose_fall (стойка на loose) + отсчёт + remove → empty.
- L4: mob (падающий кусок → debris снизу).
- L5: урон Киду от падающего куска.
-
-## Конкретика из SDLPoP (сверено 2026-07-18, готово к реализации)
-
-Таблицы (seg008.c), индекс = `get_loose_frame(modif)`:
- `loose_fram_left[]  = {41,69,41,70,70,41,41,41,70,70,70,0}`
- `loose_fram_right[] = {42,71,42,72,72,42,42,42,72,72,72,0}`
- `loose_fram_bottom[]= {43,73,43,74,74,43,43,43,74,74,74,0}`
- `get_loose_frame(m)`: если `(m&0x80)` (или delay>11) → `m&=0x7F; if(m>10) return 1;` → `return m;`
- `y_loose_land[] = {2,65,128,191,254}` (mob), `loose_floor_delay = 11`.
-
-Триггеры (call-sites):
- **make_loose_fall(modifier=1)** — из `check_press()` (seg006): когда Kid
-  СТОИТ на тайле (FRAME_NEEDS_FLOOR, action < hang_climb / turn / bumped) и
-  `get_tile_at_char()==11`; ИЛИ `frame==79` (прыжок вверх) и
-  `get_tile_above_char()==11` (пробой сверху).  `tile_is_floor(11)==1` —
-  Kid стоит на loose (start_fall НЕ зовётся).  Тело:
-  `if(!(tile&0x20) && (sbyte)modif<=0){ modif=modifier; add_trob(type0); }`
- **do_knock(row)** — на ЖЁСТКОМ приземлении (SEQ_KNOCK_DOWN→check_knock,
-  seg003): по всем колонкам ряда `if(tile==11) loose_make_shake()`
-  (`if(modif==0){ modif=0x80; add_trob(type1); }`).
- **animate_loose** (каждый кадр, seg007:816): `++modif`; если `&0x80`
-  (тряска): `if(modif>=0x84){modif=0; trob=-1;}`; иначе (отсчёт):
-  `if(modif>=11){ remove_loose(tile→0); trob=-1; add_mob(); } else shake`.
-
-## Интеграция в наш движок (roomtest) — подход
-
-Наш движок ПЕКЁТ комнату один раз (двойной буфер: своя ОЗУ-копия на
-страницу).  Loose требует динамики + общего состояния pop_map↔pop_bg:
-1. **Общая МУТАБЕЛЬНАЯ копия комнаты**: roomtest.c держит `uint8_t
-   room_fg[30]` (копия room1_fg) и передаёт ОДИН указатель и в
-   `pop_room_draw`, и в `pop_map_set` → мутации loose видны обоим.
-   (Сейчас g_fg — `const`; сделать неконстантным.)
-2. **Состояние**: `uint8_t pop_loose_modif[30]` (0 / 0x80.. / 1..11).
-3. **Модель** (pop_map): `check_press()` в `pop_phys_tick` (make_loose_fall
-   при стоянии на 11), `animate` каждый кадр.
-4. **Перерисовка** (pop_bg, на back-странице каждый кадр):
-   - тряска/отсчёт (код всё ещё 11): `gfx_heal(tile rect)` (вернуть
-     печёный фон) + нарисовать loose-кадр (left/right/bottom по
-     get_loose_frame) банком SPRITE;
-   - падение (11→0): mutate `g_fg[pos]=0` + «запечь пустоту» на ОБЕИХ
-     страницах (bake-счётчик 2: чёрный bar + draw_tile empty банком NORMAL
-     на текущей странице 2 кадра подряд) → дальше heal показывает пусто.
-5. **L4 mob**: падающий кусок → debris(14) снизу (y_loose_land); пока
-   отложено — упавший loose = пусто.  **L5** урон — позже.
-
-Риск: перерисовка динамического тайла в двойном буфере (per-page heal +
-bake) — единственное тонкое место; остальное — прямой порт логики выше.
-
-## Связанные
-
-Триггеры завязаны на физику Kid ([[pop_hang_state]] check_press/check_grab,
-приземление land/SEQ_KNOCK_DOWN).  Отрисовка — [[pop_fore_layer]] /
-[[pop_background_strategy]] (draw_tile уже знает loose_fram_*).
@@ -0,0 +1,148 @@
+# Генераторы псевдослучайных чисел: запасные варианты
+
+Что сейчас стоит в порте, какие есть альтернативы и сколько на них реально
+можно выиграть.  Заготовка на случай, если упрёмся в бюджет кадра —
+**сейчас менять ничего не нужно**.
+
+## Что стоит сейчас
+
+`pop_geom.c`, ветка `POP_PRANDOM_EXACT=1` (по умолчанию) — LCG оригинала
+`s = s*214013 + 2531011`, шаг написан на Z80-ассемблере (единственное такое
+место в порте).  Схема Горнера по разреженной записи константы:
+
+```
+214013 = ((((1<<1)+1)<<2 + 1)<<4 + 1)<<10 - 3
+```
+
+17 удвоений, три сложения, одно вычитание; величина `3*s`, нужная в конце,
+попадается по дороге на втором шаге.  Тело — **≈1 020 тактов** по статическому
+подсчёту.  Бит-в-бит совместим с SDLPoP, поэтому по картинке можно сверяться
+с эталоном.
+
+Вторая ветка, `POP_PRANDOM_EXACT=0` — xorshift16 + шаг Вейля на C.
+Совместимость теряется.
+
+Замер в MAME, комната 3, 175 кадров (медиана кадра):
+
+| вариант | кадр | prandom → torch_draw |
+|---|---|---|
+| C, бит-в-бит (16-битные половины) | 403 632 | 10 933 |
+| C, xorshift16 + Вейль | 397 986 | 7 927 |
+| **asm, бит-в-бит (сейчас)** | **400 800** | **9 331** |
+
+## Вариант A — комбинированный LFSR + LCG, ~148 тактов
+
+Период > 4 млрд (lcm(65536, 65535) ≈ 4.29e9), младшие биты не вырождены.
+
+```z80
+prng16:
+    seed1=$+1
+    ld hl, 9999
+    ld b, h
+    ld c, l
+    add hl, hl
+    add hl, hl
+    inc l
+    add hl, bc
+    ld (seed1), hl
+    seed2=$+1
+    ld hl, 987
+    add hl, hl
+    sbc a, a
+    and 101101b
+    xor l
+    ld l, a
+    ld (seed2), hl
+    add hl, bc
+    ret
+```
+
+Устройство: `seed1` — LCG `x = 5x + 1` (по модулю 2^16; `inc l` вместо
+`inc hl` — экономия байта, на период не влияет).  `seed2` — 16-битный
+LFSR Галуа: сдвиг влево, и если выехала единица, XOR младшего байта с маской
+`0x2D` (примитивный многочлен `x^16 + x^5 + x^3 + x^2 + 1`).  На выходе
+сумма обоих состояний — она и разрушает регулярность младших бит LCG.
+
+**Что мешает взять как есть:** сиды зашиты в код (SMC), а нам нужны ДВЕ
+независимые последовательности — раскладка кладки и анимация тайлов.
+Пришлось бы передавать состояние через указатель, как сейчас у `pop_prandom`
+(это +20…40 тактов, не принципиально).
+
+## Вариант B — xorshift(7,9,8), ~86 тактов
+
+Самый быстрый, период 65535.
+
+```z80
+xrnd:
+    ld hl, 1       ; seed must not be 0
+    ld a, h
+    rra
+    ld a, l
+    rra
+    xor h
+    ld h, a
+    ld a, l
+    rra
+    ld a, h
+    rra
+    xor l
+    ld l, a
+    xor h
+    ld h, a
+    ld (xrnd+1), hl
+    ret
+```
+
+**Две оговорки.** Ноль — неподвижная точка, а сид раскладки кладки у нас
+считается как `номер комнаты + смещение ряда + колонка` и вполне может
+оказаться нулём: нужен либо guard, либо шаг Вейля поверх.  И тот же SMC-сид,
+что в варианте A.
+
+## Чего НЕ брать: RND из Apple II
+
+Оригинальный `Prince-of-Persia-Apple-II`:
+
+```
+RNDseed := (5 * RNDseed + 23) mod 256
+```
+
+```asm
+RND
+ lda RNDseed
+ asl
+ asl
+ clc
+ adc RNDseed
+ clc
+ adc #23
+ sta RNDseed
+ rts
+```
+
+Полный период 256 (`a ≡ 1 mod 4`, `c` нечётное), и для своего движка он
+работал.  Нам не годится: у LCG по модулю 256 младшие биты вырождены — бит 0
+просто чередуется.  Наши вызовы это увидят: раскладка кладки берёт
+`prandom(1)` (ОДИН бит) и `prandom(4)`, то есть вместо шума получилась бы
+аккуратная шахматка.
+
+## Сколько реально можно выиграть
+
+Меньше, чем кажется по числам 86/148 против 1 020.  Тело генератора — уже не
+весь расход: остаются обёртка `pop_prandom`, приведение к диапазону
+`pop_rnd_fit` и ABI вызова.  Верхняя граница выигрыша видна из замера выше:
+между нынешним asm-LCG и самым дешёвым из проверенных вариантов разница
+**2 814 тактов за кадр (0.65 %)** при двух вызовах за кадр, и это ПОТОЛОК —
+любой из вариантов A/B ниже него не опустится.
+
+Порядок действий, если понадобится:
+
+1. Сначала убрать обёртки: слить `pop_rnd_fit` в ту же asm-процедуру, чтобы
+   на вызов приходился один `call`, а не три.  Это ничего не ломает и не
+   трогает совместимость с эталоном.
+2. И только если этого мало — менять генератор, начиная с варианта A
+   (качество последовательности у него не хуже LCG, в отличие от B).
+
+Важно помнить: число вызовов вырастет с боёвкой.  Сейчас их два за кадр
+(факелы), а `guard_advance` / `guard_block` / `guard_strike` дёргают
+`prandom(255)` каждый по разу за кадр боя — то есть при драке станет 5–6, и
+цена вопроса вырастет во столько же раз.
@@ -1,5 +1,21 @@
 # PoP roomtest — модель `kid_room ≠ drawn_room` (баг #4)

+> **Статус: ЖИВОЙ ПЛАН, сделан частично (сверено 2026-08-01).**
+> - **S1 — сделан:** `kid_room` заведён отдельно от `cur_room`,
+>   `update_kid_render_dx()` (`roomtest.c`) даёт рендер-смещение ∓140, а
+>   `pop_kid_set_render_dx` применяет его в отрисовке.  Фактически это пока
+>   каркас: `enter_room` держит `kid_room == cur_room`, так что смещение
+>   всегда 0.
+> - **S2/S3/S4 — не сделаны и не срочны.**  Исходный повод (баг #4,
+>   пинг-понг у шва) закрыт иначе — поправкой odd-pixel в
+>   `char_x_forward_edge` + `pop_leave_timer` (разбор корня —
+>   `../roomtest/bug_closed.md`, BUG-SEAM-PINGPONG).
+>
+> **Зачем документ остаётся.**  Полная straddle-модель понадобится для:
+> (а) читов осмотра соседних комнат `H/J/U/N` (`levels_plan.md` §4),
+> (б) сцен, где Кид и страж в разных комнатах кадра, (в) остатков окклюзии у
+> шва (S4).  Брать из `../roomtest/TASKS_OPEN.md`, когда дойдёт очередь.
+
 Порт straddle-модели SDLPoP: персонаж может находиться в СОСЕДНЕЙ комнате,
 пока на экране ещё ТЕКУЩАЯ (drawn_room).  Источник истины — SDLPoP.

@@ -62,7 +78,9 @@ drawn_room с `curr_col=-1/10` + снапшоты соседей `g_lcol/g_rcol`
 ### S4. Полировка
 - Окклюзия/ceiling у шва при straddle, BUG-OCCL-1 (глубина), правый край.

-## Связанные баги (bug_list.md)
+## Связанные баги — все ЗАКРЫТЫ (`../roomtest/bug_closed.md`)
 BUG-CEIL-1 (руки при прыжке вверх), BUG-CEIL-2 (loose в потолке),
 BUG-CEIL-3 (потолок над анимируемыми воротами), BUG-OCCL-1 (тень дальней
-колонны).  Memory: `pop_seam_room_model`.
+колонны) — починены без полной straddle-модели.  То есть S4 «полировка
+окклюзии» осталась актуальной только для окклюзии У ШВА при straddle.
+Memory: `pop_seam_room_model`.
@@ -1,335 +0,0 @@
-# roomtest — план оптимизации по размеру + переход на huge/banking
-
-Статус: **план для отдельной сессии** (2026-07-21).  Документ самодостаточный
-(рассчитан на старт с пустого контекста).  Цель — освободить место: сейчас
-`applications/PoP/roomtest` в режиме `small` почти упёрся в потолок 32 КБ.
-
-Правило проекта (`applications/PoP/CLAUDE.md`): механику/раскладку памяти
-сверять с исходником и с memory (`sprinter_memory_modes`, `sdcc_banking`,
-`bank_local_data_pattern`, `pop_banking_architecture`).  Перед оптимизацией —
-`make size-check`-подобный замер до/после (здесь — руками по `.map`).
-
---
-
-## 0. Как мерить
-
- Сборка: `cd applications/PoP/roomtest && make roomtest.exe` (режим `small`,
-  `--gfx 256`).  Карта символов — `.sprinter-cc-roomtest/roomtest.map`
-  (адреса сдвигаются при каждой пересборке!).
- Размеры областей — из `.map` (`_CODE`, `_DATA`, `_BSS`).
- Вклад модулей в `_CODE` — атрибуция диапазонов между символами по модулю
-  (скрипт-однострочник на python в истории; группировать символы `.map` по
-  3-й колонке-модулю и суммировать `addr[i+1]-addr[i]`).
- MAME-проверка после изменений раскладки ОБЯЗАТЕЛЬНА (режимы памяти —
-  типовой источник «молча ломается», см. `sprinter_memory_modes`).
-
-## 1. ТЕКУЩЕЕ СОСТОЯНИЕ (замер 2026-07-21)
-
-Режим `small` = единое пространство **W1+W2 = 0x4000..0xBFFF (32 КБ)**; CODE с
-0x4100, DATA/BSS/heap цепляются ЗА CODE автоматически (`--data-loc 0` =
-linker chains), стек — вверху W2.
-
-| Область | Размер | Диапазон |
-|---------|--------|----------|
-| `_CODE` | ~27 250 Б (0x6A6F) | 0x4100–0xAB6F |
-| `_HOME` | 227 Б | 0xAB6F |
-| `_DATA` | 3 449 Б (0x0D79) | 0xAC78–0xB9F1 |
-| `_BSS`  | 290 Б | |
-
-**Образ ≈ 31.2 КБ; до верха W2 (0xBFFF) остаётся ≈ 1.3 КБ на кучу+стек.**
-Куча в roomtest почти не используется (атласы/уровень — в EMM-страницах),
-но запас критично мал.
-
-### Вклад модулей в _CODE (по .map, приблизительно)
-```
- 7003  pop_bg      (вся отрисовка тайлов/слоёв/wall_pattern)
- 6326  pop_kid     (из них ~3745 Б — СТАТ. ТАБЛИЦЫ kid_data.h, см. ниже)
- 3762  pop_map     (коллизия/физика/пики)
- 1455  pop_trob    (кнопки/ворота/пики-каркас)
- 1224  pop_level   (загрузка уровня, doorlink)
-  914  roomtest    (главный цикл)
- ~7000 libc/libbgi (gfx_blit*, atlas_load, kbd_raw, open/read, irq, div/mul…)
-```
-
-### Крупные СТАТИЧЕСКИЕ данные (сейчас в _CODE как `const`)
- **`kid_data.h` — самый большой кусок, ~3.7 КБ**, живёт в _CODE (атрибутируется
-  pop_kid):
-  - `kid_seqtbl[2310]` — байткод последовательностей (play_seq).
-  - `kid_frames[241]` × 5 Б = 1205 Б — таблица кадров (image,dx,dy,flags,sword).
-  - `kid_seq_off[115]` × 2 Б = 230 Б — смещения seq.
- `pop_bg`: `tile_table[31]`×12 = 372 Б + ~20 мелких const-таблиц (COL_XH,
-  WALL_FRAM_*, SPIKES_FRAM_{RIGHT,LEFT,FORE}, LOOSE_FRAM_*, DOOR_FRAM_SLICE,
-  BLUELINE_*, LPOS/RPOS, FLOOR_LEFT_OVERLAY) — суммарно ~0.5–0.7 КБ.
- `pop_map`: `x_bump[20]`, `y_land[5]`, `wall_dl/dr`, `dir_front/behind` — ~100 Б.
- В `_DATA` (W2, не CODE): `room_modif[24][30]`=720 Б + копии LINKLOC/LINKMAP=512 Б
-  (pop_trob/pop_level) + рабочие массивы roomtest.
-
---
-
-## 2. ПУТЬ A — оптимизация КОДА (без смены модели)
-
-1. **Компиляторные флаги** (`bin/sprinter-cc`): попробовать `--opt-code-size`
-   у SDCC и подобрать `--max-allocs` (сейчас дефолт 100000; меньше = мельче код,
-   но медленнее компиляция; см. `mdview2_size_budget` — там `--max-allocs`
-   давал −1.4 КБ).  Замерить каждый модуль отдельно.
-2. **Дедуп подстановки нажатой кнопки**: логика `opener→floor / closer→stuck`
-   по таймеру связи ПРОДУБЛИРОВАНА в `draw_tile` и `fore_tile` (pop_bg.c).
-   Вынести в `static inline`/helper `subst_pressed_button(code,mod)`.
-3. **wall_pattern / prandom** (pop_bg): 32-битный LCG (`unsigned long`) —
-   пользователь не любит 32-бит (см. `avoid_32bit_arith_z80`); но это PRNG
-   оригинала (нужен для совпадения раскладки стен) — трогать осторожно, только
-   если найдётся 16-битный эквивалент, дающий ТУ ЖЕ последовательность.
-4. **Ревизия дублей**: `y_to_row` определён в pop_bg И pop_map; мелкие
-   геометрические хелперы дублируются — свести в один internal-модуль.
-5. `/simplify`-проход по последним правкам Фазы B (pop_trob/pop_bg).
-
-Ожидаемый выигрыш пути A: единицы–первые сотни байт на пункт; в сумме,
-оптимистично, ~1–2 КБ.  Недостаточно как единственная мера.
-
---
-
-## 3. ПУТЬ B — вынос СТАТ. ДАННЫХ в EMM-страницы (с атласами / с level)
-
-**Идея (по замечанию пользователя):** EMM-страницы атласов и уровня
-использованы лишь частично (страница 16 КБ, данных меньше), в «хвосте» —
-свободное место.  Часть `const`-таблиц можно хранить ТАМ, а не в _CODE/_DATA,
-если таблица читается ИМЕННО ТОГДА, когда нужная страница уже в W0.
-
-**Механика W0:** атласы блитятся из W0 (`_gfx_w0_state`: `_gfx_w0_cur` —
-спрайт-страница в W0; ISR-стаб `_gfx_w0_isr` возвращает её после прерывания).
-Уровень (pop_level) маппит свою страницу в W0 на время извлечения
-(`gfx_w0_map`/`gfx_w0_unmap`).  → пока страница в W0, CPU может читать и
-данные из неё по адресам 0x0000..0x3FFF.
-
-**Категоризация таблиц по W0-контексту (задача сессии — уточнить по каждой):**
-
- **(a) Читается, когда в W0 АТЛАС** → хранить в свободном хвосте атлас-страницы.
-  Кандидаты — таблицы, которые нужны В МОМЕНТ блита конкретного атласа.
-  ГРАБЛИ: `draw_tile` читает `tile_table`/`COL_XH` ДО блита (чтобы решить, какой
-  спрайт/куда) — в этот момент в W0 может быть ДРУГАЯ страница (DSS/предыдущий
-  атлас).  Т.е. большинство draw-таблиц читаются ВНЕ W0-атлас-контекста →
-  «в лоб» не переносятся.  Нужен аудит КАЖДОГО чтения: гарантирована ли нужная
-  страница в W0 в этот тик.
- **(b) Читается, когда в W0 LEVEL** → хранить с уровнем (в его странице; там
-  ~13.7 КБ свободно из 16).  Кандидаты: константы декода doorlink, разбор
-  комнат — всё, что pop_level делает под `gfx_w0_map(lvl_page)`.
- **(c) Нужна и там, и там** → дублировать в обеих страницах ЛИБО оставить
-  резидентной (если дубли дороже экономии).
- **(d) Читается в чистой ЛОГИКЕ (W0 не важен)** → перенос требует ЯВНОГО
-  `gfx_w0_map` на каждое чтение (дорого, особенно в горячих циклах) → как
-  правило оставить резидентной.
-
-**Отдельно `kid_data.h` (3.7 КБ — самый жирный кандидат):**
- `kid_frames`/`kid_seqtbl` читаются в `play_seq` (ЧИСТАЯ логика, каждый тик) И
-  в `kid_draw` (блит из kid-атласа, kid-страница в W0).  Т.е. частично (a),
-  частично (d).  Перенос всей таблицы в kid-атлас-страницу заставит `play_seq`
-  делать `gfx_w0_map` на каждый шаг байткода → замерить стоимость (может убить
-  бюджет спрайтов, см. `sprite_engine_perf`).  Вариант: держать в EMM отдельной
-  страницей данных Kid и маппить один раз на кадр вокруг kid_tick+kid_draw.
- Это самый большой одиночный выигрыш (−3.7 КБ из _CODE), но и самый рискованный
-  по скорости — приоритетный к ПРОТОТИПИРОВАНИЮ и замеру.
-
-**Паттерн переноса writable/const данных в банк/страницу:** см. memory
-`bank_local_data_pattern` (--codeseg/--constseg/--dataseg BANKn + trampoline-fix
-+ mkexe -p 0) и `sdcc_static_storage_gotcha`.
-
-### 3.1 Свободное место в страницах (замер 2026-07-21, страница = 16384 Б)
-```
-BG-атласы:           размер   свободно
-  pop_env0.atl        10578     5806
-  pop_env1.atl        12449     3935   <- САМАЯ ТЕСНАЯ из bg
-  pop_env2.atl        10798     5586
-  pop_env3.atl         5032    11352   <- много места
-  pop_env4.atl         8498     7886
-  pop_wall.atl        11543     4841
-  pop_fore.atl         7763     8621
-Kid-атласы (28 стр): free min=6161  max=15452  avg=9722
-Level (res2001.bin):  данные 2305, свободно ~13823 (16384 − 0x100 стаб − 2305)
-```
-
-**Выводы по вместимости:**
- **Макс. данных в ОДНОМ атлас-банке = свободный хвост ЭТОЙ страницы** (см.
-  таблицу).  Связывающее ограничение — самая тесная нужная страница (env1 =
-  3935 Б; не перегружать её).
- Если страница будет маппиться в **W0** — минус ~0x100 Б на ISR-стаб (как
-  level).  Атлас-страницы стаб УЖЕ содержат (atlas_load патчит) → данные класть
-  в хвост ПОСЛЕ атласа.
- **`kid_data.h` (3.7 КБ) влезает в kid-страницу** (min free 6161) или в
-  отдельную выделенную страницу данных Kid — предпочтительно отдельную (маппить
-  раз на кадр, не конфликтуя с kid-атласами блита).
- **Level-таблицы** — вагон места в level-странице (~13.8 КБ).
- **BG draw-таблицы** (~0.7 КБ) влезут в env3/fore/env4 (много free), НО см.
-  граблю W0-контекста в §3(a) — читаются ли они, когда нужная страница в W0.
- **Выделенная страница ТОЛЬКО под данные** (не делить с атласом) = до ~16 КБ
-  (−0x100 стаб при W0-маппинге).  EMM-бюджет это позволяет (см.
-  `sprinter_emm_budget`: 215/3440 КБ free на старте).
- **Принудительно уменьшать макс. атлас (репак мельче) — КРАЙНИЙ случай:** это
-  резко поднимет число атлас-банков (сейчас 5 env-страниц адресуются как id>>5;
-  дробление ломает эту адресацию и множит страницы).  Сначала использовать
-  СУЩЕСТВУЮЩИЙ свободный хвост и отдельные data-страницы.
-
---
-
-## 4. ПУТЬ C — переход на huge (banked code)
-
-### 4.1 Что такое huge сейчас (`bin/sprinter-cc`, `runtime/crt0_banked`)
- `--memory huge`: `MODE_CODE_LOC=0x4100`, **`MODE_DATA_LOC=0x8000` (ФИКС.)**,
-  banked code в W3.  crt0_banked, как crt0_small, авто-детектит W2.
-  Помечено `[TODO]` — не обкатано.
- Отличие от small: small цепляет DATA сразу за CODE (`--data-loc 0`); huge
-  ФИКСИРУЕТ DATA на 0x8000.
-
-### 4.2 ТРЕБОВАНИЕ (по пользователю): huge должен переносить DATA динамически
-Сейчас huge жёстко кладёт DATA на 0x8000.  Если РЕЗИДЕНТНЫЙ CODE вылезет за
-0x8000 (W1 = только 0x4000..0x7FFF ≈ 16 КБ; резидент > 16 КБ лезет в W2) →
-коллизия с DATA.  **Надо научить huge класть DATA динамически ЗА резидентным
-CODE (как small: `--data-loc 0` + crt0 считает старт), а не на фикс 0x8000.**
-Тогда huge = «small-раскладка резидента (W1+W2, DATA за CODE) + ДОП. код в
-банках W3».  Это первый пункт работ по huge.
-
-### 4.3 КОНФЛИКТ: графика тоже хочет W3 (ключевой риск)
-`pop_banking_architecture` прямо говорит: **графику нельзя в W3** (блиты/атласы
-используют окна; см. §4.5).  Поэтому в банки W3 можно выносить ТОЛЬКО
-НЕ-графические блоки, и такой банк НЕ должен во время своего исполнения держать
-графику в W3.  Если W3-банкованная функция ЗОВЁТ графику (которой нужен W3),
-трамплин обязан сохранить/восстановить банк вокруг вызова (проверить, что
-banking-ABI это делает — `sdcc_banking`).  Альтернатива без этого риска —
-**big + BANK_W1** (банк кода в W1, не W3), рекомендованная в
-`pop_banking_architecture` именно из-за W3-графики.  Сессия должна выбрать:
-huge(W3) с аккуратным save/restore ИЛИ big(BANK_W1).
-
-### 4.4 Какие блоки МОЖНО вынести (не работают с графикой напрямую)
-Замер graphics-ref по модулям (grep `gfx_|blit|env_b|wall_b|fore_b|setfillstyle|
-bar(|GFX_BANK|initgraph`):
-```
-pop_bg.c    : 83  — РЕЗИДЕНТ (вся отрисовка)
-roomtest.c  : 23  — РЕЗИДЕНТ (главный цикл + флип страниц)
-pop_level.c : 17  — использует gfx_w0_map (W0, не W3-блиты) — ПОГРАНИЧНЫЙ
-pop_kid.c   : 12  — kid_draw = графика; НО play_seq — чистая логика (можно split)
-pop_ctrl.c  :  0  — КАНДИДАТ В БАНК (ввод/диспетчер control)
-pop_map.c   :  0  — КАНДИДАТ В БАНК (коллизия/физика, ~3.8 КБ) — лучший по объёму
-pop_trob.c  :  0  — КАНДИДАТ В БАНК (кнопки/ворота/пики-логика)
-```
- **Лучшие кандидаты в W3-банк(и): pop_map + pop_trob + pop_ctrl** (нет прямой
-  графики; вместе ~5.3 КБ CODE).  Освобождают резидент → он влезает в W1.
- **Осторожно с межбанковыми вызовами:** pop_map/pop_trob ЗОВУТ pop_bg
-  (перерисовка loose/пик/кнопок/шва) и pop_kid (play_seq/kid_set_seq).  Это
-  кросс-банк вызовы через трамплин (`sdcc_banking`: стек +3 байта, виртуальный
-  24-битный адрес).  Правило `pop_banking_architecture`: «один файл = один банк
-  = прямые вызовы», main резидентен.  Проверить, что трамплин сохраняет W3
-  вокруг вызова в графический pop_bg (см. §4.3).
- **pop_kid split** (по желанию): вынести play_seq/seqtbl-интерпретатор
-  (логика + таблицы kid_data.h) в банк, оставить kid_draw/kid_heal резидентными.
-  Даёт и −код, и −данные из резидента, но требует аккуратного разделения TU
-  (1 функция = 1 модуль, см. `libc_one_function_per_module`).
- **pop_level: пограничный** — не блитит, но маппит уровень в W0; банковать
-  можно, если W0-логика совместима с трамплином (проверить ISR-стаб взаимодействие).
-
-### 4.5 Почему графику нельзя в W3 (контекст)
-Блиттер держит спрайт-страницу атласа в **W0** (`_gfx_w0_state`,
-`_gfx_w0_isr`).  Ускоритель/адресация видео — отдельная тема (см.
-`sprinter_accelerator`, `sprinter_graphics`).  W3 в banked-раскладке — окно
-кода-банка; смешивать с окном, которое графика перемапливает, нельзя без
-save/restore.  Детально — `pop_banking_architecture`, `graphics_constraints`.
-
---
-
-## 5. РЕКОМЕНДУЕМЫЙ ПОРЯДОК РАБОТ (для след. сессии)
-
-1. **Замер-базлайн** (CODE/DATA/BSS + per-module) — зафиксировать до.
-2. **Путь A** дешёвые пункты (флаги, дедуп кнопки, дедуп y_to_row) — быстрый −1..2 КБ.
-3. **huge §4.2**: научить huge класть DATA динамически (как small) — инфраструктурный
-   пререквизит, без него банкинг не даст гибкости.  Обкатать в MAME на текущем
-   резиденте (пока без выноса — просто huge-раскладка = small + пустой W3).
-4. **huge §4.4**: вынести pop_map (+pop_trob, +pop_ctrl) в W3-банк(и); проверить
-   кросс-банк вызовы в pop_bg (§4.3) в MAME.  ЛИБО выбрать big+BANK_W1.
-5. **Путь B** (по остатку нужды): прототип выноса `kid_data.h` в EMM-страницу
-   Kid с маппингом раз на кадр; замерить скорость (`sprite_engine_perf`).
-   Затем аудит draw-таблиц по W0-контексту (§3 a/b/c/d).
-
-## 6. Ссылки
- `bin/sprinter-cc` (§162+ — резолв memory-mode → CODE_LOC/DATA_LOC).
- `runtime/crt0_small.*`, `runtime/crt0_banked.*`, `runtime/bank.s`.
- memory: `sprinter_memory_modes`, `memory_modes_implemented`,
-  `setwin2_for_w2_alloc`, `sdcc_banking`, `bank_local_data_pattern`,
-  `pop_banking_architecture`, `avoid_32bit_arith_z80`,
-  `libc_one_function_per_module`, `sprite_engine_perf`, `mdview2_size_budget`.
- `applications/PoP/roomtest/bug_list.md` — открытые баги Фазы B (не блокируют
-  оптимизацию, но держать в уме при рефакторе pop_map/pop_bg).
-
---
-
-## 7. Лишние блиты в горячем пути (добавлено 2026-07-27)
-
-Найдено при разборе окклюзии по эталону SDLPoP: **наш «передний слой» рисовал
-спрайты, которых в оригинале там нет** — это и артефакты, и лишняя работа
-каждый кадр.  Исправлено: `fore_tile` (вызывается для КАЖДОГО тайла футпринта
-Kid, обычно 2–4 за кадр) рисовал ещё и `bottom_id` — переднюю кромку пола; в
-оригинале `draw_tile_fore` (seg008:690) добавляет только `add_foretable`-часть,
-а `bottom` идёт через `draw_tile_bottom` в backtable (ПОД персонажем).
-Итог: −2..4 блита за кадр, `_CODE` −388 Б, ушла «тень» у основания колонны.
-
-**Что проверить тем же методом (по одному вопросу к каждому месту: а есть ли
-этот спрайт в оригинале в ЭТОЙ таблице?):**
-
-1. `pop_room_draw`/`draw_tile` — вызовы на входе в комнату не критичны по
-   скорости, но по ним стоит сверить состав слоёв (backtable vs foretable).
-2. `overlay_mid_tile` — сейчас точный порт midtable-части `draw_tile2`;
-   проверить, не рисуем ли `base_id` там, где оригинал его не рисует
-   (loose: base=0, потому что кадр плиты идёт через `draw_loose` в backtable).
-3. `pop_loose_mob_tick` — перерисовка соседнего тайла (`draw_tile(mob_row,
-   mob_col+1)`) КАЖДЫЙ кадр падения: в оригинале это `set_redraw_full` на
-   один кадр; можно ограничить только тайлом, который реально пересекается
-   с куском.
-4. `pop_ceil_shake_draw` — heal 64×8 + два `draw_tile(-1,·)` на кадр тряски;
-   проверить, нужен ли второй тайл (правую грань loose в полосе потолка
-   оригинал не рисует вовсе — `draw_tile_aboveroom` без `draw_tile_anim_right`).
-5. `fore_only_tile` для полосы потолка: вызывается для всех колонок габарита,
-   а оригинал (`redraw_needed_above`) — только для колонок с флагом
-   `redraw_frames_above`; сузить до колонок, реально задетых спрайтом.
-6. `wall_pattern` внутри fore/overlay — тяжёлая (PRNG + до 4 блитов); проверить,
-   не зовём ли её там, где оригинал ограничивается `wall_fram_main`.
-
---
-
-## 8. Скорость отрисовки: замеры и запас (2026-07-27)
-
-Профилирование в MAME (маркеры в порт 0xFE + `wpiset … totalcycles`, приём из
-memory `mame_mcp_bridge`).  Кадр Sprinter = **430 080 тактов**.
-
-**Стоимость блита почти НЕ зависит от размера** — платим за проход по цепочке
-`gfx_blit → gfx_blit_part → _gfx_blit_full` (16-битная арифметика, клип,
-пересчёт src, нарезка полос >256), а не за пиксели:
-
-| путь (спрайт 32×3) | тактов |
-|---|---|
-| `gfx_blit` (общее ядро, с клипом) | 13 288 |
-| линейное спрайтовое ядро без клипа (`putsprite` при `gfx_sprite_clip(0)`) | 4 617 |
-
-Отсюда `draw_tile(0,0)` тайла шва (9 блитов) стоил **183 690 тактов = 43 %
-кадра**; сам `bar` — только 13 308.
-
-**СДЕЛАНО (шаг 1):** в libbgi добавлен `gfx_blit_noclip()`
-(`common/gfx_blit_noclip.c`, прототип в `include/gfx.h`) — блит без клипа в
-ТЕКУЩЕМ банке через линейное ядро; `pop_bg.blit_b` уходит на него, когда
-спрайт целиком на экране и не нужен `g_clip_top`.  Выигрыш ~2.9× на каждом
-фоновом блите (подтверждено в MAME).
-**ВАЖНО:** W3-скобку (`_bgi_begin/_bgi_end`) ставит САМА libbgi — вызывать её
-из модуля, собранного с `--w3`, нельзя: после `_bgi_begin` окно W3 занято
-видеобанком и код вызывающего исчезает из адресного пространства (проверено:
-белый экран).
-
-**ЗАПАС (шаг 2), когда перестанет хватать бюджета кадра:**
-
-1. **Батчинг W3-скобки** — одна `_bgi_begin/_bgi_end` на весь `draw_tile`
-   вместо скобки на блит; нужен публичный batch-API в libbgi (как у
-   спрайтового движка).  Осторожно: между begin/end стоит `DI` — длинная
-   серия задержит кадровое прерывание.
-2. **Решётка ворот одним спрайтом** — `draw_gate_back` рисует бары по одному
-   (`env 52`, до 7 блитов).  Сгенерировать в атласе «столб решётки» (повтор
-   бара на высоту тайла) и выводить одним `gfx_blit_part` с обрезкой по фазе
-   `gate_bot_y & 7`: 7 блитов → 1.
-3. **Не перерисовывать статичные части шва** — грань ворот (env 47, 26×62),
-   пол (41) и кромка (43) при анимации решётки не меняются; если стирать
-   только полосу баров, уйдут ещё 3 блита из 9.
-4. См. также §7 (лишние блиты, которых нет в оригинале).
@@ -36,4 +36,6 @@ static const char *const kid_atl[KID_PAGES] = {
    "kid27.atl",
 };
 #define KID_PAL_FILE "kid.pal"
+#define KID_SWORD_ATL "sword.atl"   /* chtab_0: меч в руке */
+#define KID_SWORD_ID0 0  /* индекс в атласе = sword_tbl.id - ID0 */
 #endif
@@ -11,13 +11,29 @@
 по памяти и не угадывай константы/порядок слоёв.  Расхождение с SDLPoP =
 по умолчанию баг у нас.

+**Что в работе сейчас — `TASKS_OPEN.md`** (доска задач: приоритеты, критерии
+готовности); сделанное с протоколами замеров — `TASKS_CLOSED.md`.  Баги —
+`bug_list.md` (только ОТКРЫТЫЕ) и `bug_closed.md` (закрытые + разбор корней:
+перед заведением нового бага грепни там по симптому); сырые формулировки
+пользователя с прогонов — `bugs_level1.md` / `bugs_level2.md`.  План
+следующих уровней — `../docs/levels_plan.md`.
+
+Правило разнесения: как только задача/баг закрыт — запись целиком переезжает
+в `TASKS_CLOSED.md` / `bug_closed.md`, а в открытом файле остаётся ссылка.
+Открытые файлы обязаны читаться целиком за раз.
+
 ## Сборка и запуск

 ```
 make            # собрать roomtest.exe (упаковав ассеты через toolchain/)
 make run        # exe + EXTRA_DATA на дискету + запуск MAME (см. корневой док)
+make -C tests-host   # модульные тесты движка под ucsim_z80 (секунды, без MAME)
 ```

+Логику, которую можно проверить без железа, покрывать в `tests-host/`
+(обвязка — `testkit/`, там же почему прогон именно под z80).  MAME остаётся
+для отрисовки, банков, таймингов и клавиатуры.
+
 `MEMORY=small`, `--gfx 256`.  Ассеты (`pop_env0..4.atl`, `pop_wall.atl`,
 `pop_fore.atl`, `kid0..27.atl`, `kid.pal`) генерируются python-скриптами
 `../toolchain/` — Makefile дёргает их сам при изменении.  Данные комнаты —
@@ -34,7 +50,10 @@ Kid — `kid_data.h` (генерится `pop_extract_kid_data.py`).
 Отладочные тумблеры в живой сессии (`roomtest.c`): **SPACE** — вкл/выкл
 дабл-буфер (в однобуфере видно баги рисования без мерцания-через-кадр);
 **1** — заморозить кадр, **2** — продолжить (разбор позы/окклюзии);
-**ESC** — выход.
+**ESC** — выход.  Читы (`pop_cheat.h`): **K** — убить стража, **I** —
+бессмертие, **S** — выдать меч, **Shift+L** — следующий уровень,
+**+/−** — обход комнат (`ROOMNAV`).  Уровень грузится по номеру
+(`pop_level_load_num`), на диске лежат все 15.

 ## Модули

@@ -5,14 +5,53 @@ PROJ_ROOT   := $(abspath $(CURDIR)/../../..)
 EXAMPLE     := roomtest
 # small: W1+W2 как единое 32КБ-пространство, DATA сразу за CODE (иначе
 # CODE ~23КБ переполняет W1 и лезет в фиксированный DATA@0x8000 в huge).
-MEMORY      ?= small
-EXTRA_FLAGS ?= --gfx 256 --w3 pop_trob.c pop_map.c --w3 pop_bg.c
-EXTRA_SRCS  := pop_kid.c pop_ctrl.c pop_level.c 
+MEMORY      ?= huge        # small-раскладка + банки кода в W3 (стражи)
+# Резидента --w3 БОЛЬШЕ НЕТ: отрисовка уехала в БАНК 2 (pop_bg + pop_gdraw
+# в одной странице — вызовы между ними прямые, если функция не помечена
+# __banked).  Так снято главное ограничение резидента: из банка его было
+# не достать ни прямо, ни транзитивно, а банк→банк работает (трамплин
+# сохраняет страницу окна на СТЕКЕ, проверено вложенной цепочкой
+# банк1→банк2→банк1 в MAME 2026-07-30).  Теперь в банки можно уводить и
+# логику, которая рисует.  См. docs/layout_plan_v2.md §2, memory
+# sdcc_banked_call_rules.
+# Банк 5 = pop_ctrl.c (MEM-BANK5).  CODE и DATA делят одно 32-КБ
+# пространство W1+W2, поэтому килобайт кода, уехавший в банк, — это
+# килобайт, доступный данным.  Кандидат выбран не по размеру, а по частоте
+# вызова: диспетчер управления дёргается один раз за кадр на персонажа и
+# горячих банк→банк переходов не создаёт (в отличие от pop_level, чей
+# pop_level_tile зовётся из банка 2 на КАЖДЫЙ тайл).  Шина control_*
+# переехала в pop_state.c — см. там.
+# --max-allocs-per-node: во сколько вариантов размещения регистров SDCC
+# упирается на узел.  У sprinter-cc дефолт 100000 (агрессивно, как fast-сборки
+# библиотек) — на roomtest это МИНУТЫ на банк, потому что модули крупные.
+# Дефолт SDCC — 3000, и для разработки его достаточно: разница в размере
+# единицы процента, а сборка кратно быстрее.  Замер (2026-08-05) — в шапке
+# TASKS_CLOSED.md, запись BUILD-FAST.
+#
+#   make                 — быстрая сборка (ALLOCS=3000)
+#   make ALLOCS=100000   — как раньше: минимальный код, для замеров размера
+#                          и для «релизного» образа
+#
+# ВАЖНО: любое сравнение занятости банков имеет смысл только при ОДНОМ и том
+# же ALLOCS — иначе сравниваются не правки, а уровни оптимизации.
+ALLOCS      ?= 3000
+EXTRA_FLAGS ?= --gfx 256 --max-allocs $(ALLOCS) --bank 2=pop_bg.c --bank 4=pop_gdraw.c --bank 3=pop_map.c --bank 1=guards.c --bank 5=pop_ctrl.c --bank 6=pop_trob.c $(PROF_FLAGS)
+# Профилирование полосами бордюра (см. PROF() в roomtest.c) — ВКЛЮЧЕНО по
+# умолчанию, пока идёт работа с производительностью; make PROF=0 выключает.
+# Каждая фаза кадра красит бордюр в свой цвет, высота полосы на скриншоте
+# MAME = время фазы в растровых строках.
+PROF        ?= 1
+PROF_FLAGS  := -DPROF_BORDER=$(PROF)
+EXTRA_SRCS  := pop_state.c pop_draw.c pop_kid.c pop_level.c pop_redraw.c pop_geom.c pop_guard.c

 BG_DIR      := $(CURDIR)/../poc/res/bg
 KID_DIR     := $(CURDIR)/../poc/res/kid
 LVL_DIR     := $(CURDIR)/../SDLPoP/data/LEVELS
-LVL_DATA    := $(LVL_DIR)/res2001.bin
+# ВСЕ уровни игры (res2001..res2015, по 2305 Б = 34 КБ на всех): переход
+# уровень→уровень и чит Shift+L требуют, чтобы файл следующего лежал на
+# диске.  res2000 — демо-уровень, в скоуп не входит.
+LVL_NUMS    := 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15
+LVL_DATA    := $(foreach n,$(LVL_NUMS),$(LVL_DIR)/res20$(n).bin)
 BG_DATA     := $(BG_DIR)/pop_env0.atl $(BG_DIR)/pop_env1.atl $(BG_DIR)/pop_env2.atl \
               $(BG_DIR)/pop_env3.atl $(BG_DIR)/pop_env4.atl \
               $(BG_DIR)/pop_wall.atl $(BG_DIR)/pop_fore.atl \
@@ -21,17 +60,49 @@ BG_DATA     := $(BG_DIR)/pop_env0.atl $(BG_DIR)/pop_env1.atl $(BG_DIR)/pop_env2.
 # не рисуются (kid_draw пропускает незагруженную страницу).  Палитра —
 # ЕДИНАЯ игровая (env+wall+kid).
 KID_PAGES   := $(foreach n,0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27,$(KID_DIR)/kid$(n).atl)
-KID_DATA    := $(KID_PAGES) $(KID_DIR)/kid.pal
+KID_DATA    := $(KID_PAGES) $(KID_DIR)/kid.pal $(KID_DIR)/sword.atl
+# Таблицы анимации (кадры+seqtbl) — отдельный бинарь в EMM-странице, его
+# делает pop_extract_kid_data.py (не упаковщик спрайтов) — своё правило ниже.
+KID_BIN     := $(KID_DIR)/kid_data.bin
+GUARD_DIR   := $(CURDIR)/../poc/res/guard
+GUARD_DATA  := $(GUARD_DIR)/g0.atl $(GUARD_DIR)/g1.atl $(GUARD_DIR)/g2.atl \
+               $(GUARD_DIR)/g3.atl $(GUARD_DIR)/g4.atl
+# Скелет — ОТДЕЛЬНЫЙ набор спрайтов (SKEL.DAT в оригинале): его грузит
+# уровень 3 (tbl_guard_type == 2), кадров меньше (28 против 34).
+SKEL_DIR    := $(CURDIR)/../poc/res/skel
+SKEL_DATA   := $(SKEL_DIR)/g0.atl $(SKEL_DIR)/g1.atl $(SKEL_DIR)/g2.atl \
+               $(SKEL_DIR)/g3.atl

-EXTRA_DATA  := $(BG_DATA) $(KID_DATA) $(LVL_DATA)
+EXTRA_DATA  := $(BG_DATA) $(KID_DATA) $(KID_BIN) $(GUARD_DATA) $(SKEL_DATA) $(LVL_DATA)
 include $(PROJ_ROOT)/app.mk

+# Образ HDD для MAME: ресурсы раскладываются ПО КАТАЛОГАМ (8.3, как в DSS),
+# чтобы корень диска не зарастал десятками .atl.
+#   BG\     — фон (env/wall/fore/pot)
+#   KID\    — персонаж (kid0..27, палитра, меч, таблицы анимации)
+#   GUARD\  — стражи (появятся здесь же)
+#   LEVELS\ — уровни
+hdd: $(EXAMPLE).exe
+	$(PROJ_ROOT)/toolchain/make_hdd.sh $(PROJ_ROOT)/mame/v306/IMG/test_hdd.chd \
+	  $(EXAMPLE).exe \
+	  $(foreach f,$(BG_DATA),BG:$(f)) \
+	  $(foreach f,$(KID_DATA) $(KID_BIN),KID:$(f)) \
+	  $(foreach f,$(GUARD_DATA),GUARD:$(f)) \
+	  $(foreach f,$(SKEL_DATA),SKEL:$(f)) \
+	  $(foreach f,$(LVL_DATA),LEVELS:$(f))
+
 TC := $(PROJ_ROOT)/applications/PoP/toolchain
 $(BG_DATA): $(TC)/pop_pack_bg.py $(TC)/render_room.py
 	cd $(TC) && python3 pop_pack_bg.py
+$(GUARD_DATA): $(TC)/pop_pack_guard.py
+	cd $(TC) && python3 pop_pack_guard.py
+
+$(SKEL_DATA): $(TC)/pop_pack_guard.py
+	cd $(TC) && python3 pop_pack_guard.py SKEL
+
 $(KID_DATA): $(TC)/pop_pack_kid.py $(TC)/pop_pack_bg.py
 	cd $(TC) && python3 pop_pack_kid.py
-kid_data.h: $(TC)/pop_extract_kid_data.py
+kid_data.h $(KID_BIN): $(TC)/pop_extract_kid_data.py
 	cd $(TC) && python3 pop_extract_kid_data.py

-$(EXAMPLE).exe: pop_bg.c pop_bg.h pop_kid.c pop_kid.h pop_ctrl.c pop_ctrl.h pop_map.c pop_map.h pop_level.c pop_level.h pop_trob.c pop_trob.h kid_data.h $(BG_DATA) $(KID_DATA) $(LVL_DATA)
+$(EXAMPLE).exe: guards.c pop_guard.c pop_guard.h pop_gdraw.c pop_draw.c _pop_draw.h pop_state.c pop_state.h pop_cheat.h pop_bg.c pop_bg.h pop_geom.c pop_geom.h pop_redraw.c pop_redraw.h pop_kid.c pop_kid.h pop_ctrl.c pop_ctrl.h pop_map.c pop_map.h pop_level.c pop_level.h pop_trob.c pop_trob.h kid_data.h $(BG_DATA) $(KID_DATA) $(KID_BIN) $(LVL_DATA)
@@ -39,9 +39,19 @@ ESC выход.
 - `room1_data.h` — карта комнаты 1; `kid_data.h` — данные анимации Kid
  (оба генерируются скриптами `../toolchain/`).

-## Статус
+## Статус (2026-08-07)

-Готово и проверено в MAME: статический фон комнаты 1; Kid — анимация,
-управление, коллизия/падение, зацеп/подтягивание/спуск, fore-окклюзия
-пола/стены над Kid.  В работе: проваливающиеся полы (loose floors) — см.
-`../docs/loose_floors_plan.md`.
+**Уровни 1 и 2 приняты** (пользователь прошёл все комнаты обоих, крупных
+багов нет): комнаты и переходы, Kid (анимация, управление, коллизия/падение,
+зацеп/подтягивание/спуск, окклюзия), кнопки и ворота, пики, проваливающиеся
+полы, дверь уровня и переход на следующий уровень, меч и бой, стражи с ИИ,
+HP и зелья, чекпойнт уровня 3.
+
+Уровень 3 играется, но не принят: нет **чомперов** и **скелета**.  Не сделано
+вовсе: звук, таймер/HUD времени, меню и сохранения.
+
+**Что берём в работу сейчас — [`TASKS_OPEN.md`](TASKS_OPEN.md)** (сделанное с
+протоколами замеров — [`TASKS_CLOSED.md`](TASKS_CLOSED.md)); открытые баги —
+[`bug_list.md`](bug_list.md), закрытые с разбором корней —
+[`bug_closed.md`](bug_closed.md); план следующих уровней —
+[`../docs/levels_plan.md`](../docs/levels_plan.md).
@@ -0,0 +1,621 @@
+# roomtest — ЗАКРЫТЫЕ задачи (архив досок, обновлено 2026-08-07)
+
+Сделанное — с протоколами замеров, граблями и причинами решений.  Файл
+существует не ради истории: половина записей ниже — это ЧИСЛА (сколько тактов
+стоил heal, сколько байт теряет клавиатура, почему `static inline` дорог) и
+перечень того, что делать НЕЛЬЗЯ, потому что уже пробовали.
+
+Открытые задачи — [`TASKS_OPEN.md`](TASKS_OPEN.md); открытые баги —
+[`bug_list.md`](bug_list.md), закрытые с разбором корней —
+[`bug_closed.md`](bug_closed.md).
+
+---
+
+## Приёмка уровней
+
+<a id="l1-pass"></a>
+### L1-PASS. Сквозное прохождение уровня 1 — **ЗАКРЫТ 2026-08-07**
+
+> **Smoke 2026-08-05 (пользователь): успешный.**  От старта до выхода с
+> уровня одним заходом — меч подобран, **оба стража побеждены в честном бою**
+> (без читов), выход отработал корректно.  Ценность прогона в том, что он снял
+> главные риски этапа 1 разом — боёвка, предметы, переход с уровня — и стал
+> регресс-базой для уровня 2.
+>
+> **Полный обход комнат 2026-08-07 (пользователь): крупных багов нет.**  Этим
+> же прогоном закрыта [таблица обхода 24 комнат](bug_closed.md#обход-всех-24-комнат-уровня-1)
+> и [чек-листы ручной перепроверки фиксов](bug_closed.md#ручная-перепроверка-2026-08-03)
+> — обе уехали в `bug_closed.md`.
+
+Приёмка этапа 1 и одновременно регресс-база для уровня 2: от старта до двери
+уровня одним заходом — подбор меча, страж, кнопки/ворота, пики, loose-полы,
+зелье, падения.  Точки, где смотрели внимательно, — закрытая косметика
+окклюзии (потолок при прыжке вверх, шов при анимации решётки, грани дальней
+колонны) и подъём на тайл-кнопку (оговорка к BUG-3 в `bug_closed.md`).
+
+<a id="l2-pass"></a>
+### L2-PASS. Приёмка уровня 2 — **ЗАКРЫТ 2026-08-07**
+
+> **Smoke 2026-08-05 (пользователь): уровень 2 пройден.**  Из smoke пришли
+> BUG-LOOSE-3 и BUG-GUARD-DEAF-1 — оба закрыты (`bug_closed.md`).  Следом
+> прогнан smoke уровня 3.
+>
+> **Полный обход комнат 2026-08-07 (пользователь): крупных багов нет.**
+> Открытыми с этого прогона остались три записи в
+> [`bug_list.md`](bug_list.md): [BUG-GUARD-COLOR-1](bug_list.md#bug-guard-color-1)
+> (страж всегда одного цвета), BUG-GUARD-SPLASH-1 (нет брызг при попадании по
+> стражу — **закрыт 2026-08-07**, разбор в
+> [`bug_closed.md`](bug_closed.md#bug-guard-splash-1)) и
+> [BUG-CHEAT-FIGHT-1](bug_list.md#bug-cheat-fight-1) (наш чит `+`/`−` в бою
+> отнимает управление).  Ни одна играть не мешает.
+
+Ниже — **карта содержимого уровня, снятая прямо с `res2002.bin`**.  Она
+осталась в архиве не как отчёт, а как справочник для повторных прогонов и
+для сравнения с SDLPoP: если механика в таблице есть, а в игре не сработала —
+это баг, а не «так задумано».
+
+**Стражи — 5, в комнатах 4, 7, 11, 15, 24** (skill 1/2/1/1/3, цвета
+1/3/1/1/6 — цвет мы пока игнорируем, атлас один, см.
+[BUG-GUARD-COLOR-1](bug_list.md#bug-guard-color-1)).  Заметить: страж
+комнаты 24 со skill 3 — первый по-настоящему опасный.
+
+**Кнопки и что они открывают** (декодировано из LINKLOC/LINKMAP):
+
+| Кнопка | Тип | Цель |
+|--------|-----|------|
+| к.9 @ряд1,кол1 | RAISE | **дверь уровня** к.23 @1,3 — то есть выход |
+| к.11 @1,1 | RAISE | ворота к.18 @0,9 |
+| к.18 @0,7 | RAISE | ворота к.7 @0,9 **и** к.18 @0,9 (две сразу) |
+| к.18 @0,2 | DROP | закрывает ворота к.7 @0,9 |
+| к.13 @1,4 | DROP | закрывает ворота к.13 @1,5 |
+
+**Ловушки и предметы по комнатам:**
+
+```
+к. 3  loose@2,2   зелье@2,5 (здоровье)
+к. 4  loose@1,7   loose@1,8            + СТРАЖ
+к. 5  дверь уровня @1,2-3 — ВХОД (захлопывается за спиной)
+к. 6  пики@1,3    loose@1,5   зелье@2,7 (здоровье)
+к. 7  ворота@0,9  пики@2,7               + СТРАЖ
+к. 8  зелье@2,2 (здоровье)
+к. 9  кнопка RAISE@1,1   loose@2,6
+к.10  пики@2,2
+к.11  кнопка RAISE@1,1                    + СТРАЖ
+к.12  зелье@2,6 (здоровье)   loose@2,8
+к.13  зелье@1,3 (ВРЕДНОЕ, −1 HP)  кнопка DROP@1,4  ворота@1,5  зелье@1,8
+к.15                                      + СТРАЖ
+к.18  кнопка DROP@0,2  loose@0,4  кнопка RAISE@0,7  ворота@0,9  зелье@2,6
+к.19  пики@1,4
+к.20  ЗЕЛЬЕ@1,2 — БОЛЬШАЯ СКЛЯНКА (+1 к потолку HP)   пики@2,6   пики@2,7
+к.23  дверь уровня @1,3-4 — ВЫХОД
+к.24                                      + СТРАЖ (skill 3)
+```
+
+Отдельно проверялось то, что появилось именно на этом уровне:
+- **большая склянка** (к.20) — потолок HP становится 4, индикатор рисует
+  четыре деления, и это HP **переносится на уровень 3**;
+- **меч уже в руках** с самого старта (`have_sword = level >= 2`);
+- **выход через дверь к.23** вживую (кнопка в к.9);
+- **смерть/респавн** возвращают на уровень 2, а не на 1.
+
+---
+
+## Уровни и механика
+
+<a id="l3-chkp"></a>
+### L3-CHKP. Чекпойнт уровня 3 — **СДЕЛАНО 2026-08-06** (коммит 0cd6b2d)
+
+`level3_set_chkp` (seg002:0665): флаг взводится, когда Кид уходит **ВЛЕВО ИЗ
+комнаты 7**; `do_startpos` (seg003:141) по нему подменяет старт на комнату 2,
+тайлпос 6, направление влево и снимает loose-плиту (комната 7, колонка 4,
+ряд 0).  Константы — в `pop_tune.h` (`POP_CHKP_*`), механика `hitp_beg_lev`
+была сделана раньше в L2.
+
+**Тонкость, на которой сначала ошиблись:** `level3_set_chkp` вызван из
+`leave_room` ДО `goto_other_room`, поэтому `Char.room == 7` — это комната, ИЗ
+которой уходят, а не в которую входят.  Поймал пользователь прогоном в
+SDLPoP: смерть В комнате 7 вернула его в стартовую 9, а плита осталась цела.
+
+**Проверено в MAME:** вход в 7 флаг не ставит, уход влево — ставит; респавн в
+комнате 2; после обычной смерти (без чекпойнта) плиты восстанавливаются как
+раньше.  Вживую в игре (не читом) — потрогать на приёмке уровня 3
+([L3-PASS](TASKS_OPEN.md#l3-pass)).
+
+### L2. Переход на уровень 2 и его игра — **МАШИНЕРИЯ СДЕЛАНА 2026-08-04**
+
+Порт `levels_plan.md` §2 (шаг 1).  Что появилось:
+
+- **Номер уровня стал состоянием.**  `pop_current_level` (порт
+  `current_level`) в `pop_level.c`; `pop_next_level` больше не флаг, а
+  НОМЕР — `END_LEVEL` его инкрементит (как `++next_level`, seg006:662), а
+  главный цикл срабатывает по расхождению `pop_next_level !=
+  pop_current_level` (порт `play_level_2`, seg003:0386).
+- **Загрузка по номеру** — `pop_level_load_num(n)`: `LEVELS\res20NN.bin`
+  (fallback `a:\`), старая EMM-страница отпускается ТОЛЬКО после успешной
+  загрузки новой (нет файла — играем дальше на текущем).  На диск кладутся
+  все 15 уровней (34 КБ).
+- **Потабличные различия** (`data.h:840..848`) — таблицы по 16 в
+  `pop_level.c`: `tbl_entry_pose` (поза входа), `tbl_guard_hp` (HP стража,
+  ушло из хардкода `3`), `tbl_guard_type` (**−1 = стражей нет**, иначе на
+  14/15 они полезли бы из данных комнат), `tbl_level_type` (тайлсет —
+  пока только читается).
+- **`find_start_level_door`** (seg003:02E6) — на уровне 2 это НЕ косметика:
+  стартовый тайл (комната 5, ряд 1, колонка 3) — правая половина двери
+  уровня, и без `modif = 43` + `add_trob(...,3)` Кид материализуется внутри
+  глухой створки.  Тип 3 = «быстро закрыть»: дверь захлопывается за спиной
+  за три кадра, как в оригинале.
+- **HP через уровень** — `hitp_beg_lev` (seg003): рестарт уровня
+  откатывает HP к нему, пройденный уровень подтягивает его к `hitp_max`.
+  Заодно реализована **большая склянка** (`add_life`, тип зелья 2: +1 к
+  ПОТОЛКУ HP до 10) — на уровне 2 она есть, комната 20.
+- **Меч** — `have_sword = level >= 2` (play_level, seg003:106), а не
+  жёсткий ноль.
+- **Чит Shift+L** (seg000:698) — `pop_next_level = pop_current_level + 1`.
+  NB: `L` без Shift занят отладочным «осторожным шагом вправо»
+  (`pop_ctrl` `KBD_DBG_STEPR`); с Shift шаг тоже пройдёт, но уровень тут же
+  сменится — на практике не мешает.
+
+**Проверено в MAME (2026-08-04):** старт уровня 1 → Shift+L → уровень 2
+рисуется правильно (комната 5, большие колонны — новые для нас тайлы 8/9 —
+на месте, дверь захлопнута, HP 3) → влево в комнату 4, страж на месте →
+Shift+L → уровень 3 (комната 9).  То есть цепочка загрузок работает
+повторно, а не только один раз.
+
+Контент уровня 2 (сквозное прохождение, выход через дверь) закрыт отдельно —
+[L2-PASS](#l2-pass).  Цвет стража из данных остался открытым багом —
+[BUG-GUARD-COLOR-1](bug_list.md#bug-guard-color-1).
+
+### L1-START. Старт по данным уровня — **СДЕЛАНО 2026-08-01**
+
+Старт и оба рестарта (смерть, выпадение из уровня) сведены в один
+`pop_start_level()` — порт `start_level` + `do_startpos` + `set_start_pos`
+(seg003): комната/тайл/направление берутся из `pop_level_start_*`, направление
+инвертируется (`~start_dir`), поза входа — из `tbl_entry_pose`.  У уровня 1
+это «падение внутрь» плюс нажатие кнопки room5(0,2) — то самое, что
+захлопывает решётку за спиной.  Проверено: старт даёт room 1, col 0, падение
+на row 1 — как по данным уровня.
+
+`#define ROOMNAV` оставлен ВКЛЮЧЁННЫМ осознанно: это наш чит, которого в
+оригинале не было, — как и `S` (выдать меч), `K`, `I`.  Все они со временем
+съедутся в общий блок читов, разрешаемый в настройках (решение 2026-08-01).
+
+### L1-EXIT. Выход с уровня (дверь уровня) — **СДЕЛАНО 2026-08-01**
+
+Портированы: ветка двери уровня из `up_pressed` + `go_up_leveldoor`
+(seg005:0482/0574) — в `pop_leveldoor_enter()` (`pop_map.c`, тайлы и
+геометрия) и `up_pressed()` (`pop_ctrl.c`, только последовательность);
+опкод `0xF1 END_LEVEL` в `play_seq` теперь инкрементит `pop_next_level`
+(порт `next_level`), а главный цикл по нему перезапускает уровень — ровно
+та точка, куда `levels_plan.md` §2.2 подключила загрузку уровня 2.
+
+Открытость двери проверяем по `modifier >= 42` (ветка `fix_exit_door`), а не
+по ванильному `leveldoor_open`: с ванильным условием можно войти в ещё
+ползущую створку.
+
+**Грабли, которые стоили отдельного разбора:** `go_up_leveldoor` сначала
+писал `Char.x`/`Char.direction`, и оба присваивания молча терялись — окно
+`Char` вокруг диспетчера возвращает назад ТОЛЬКО `curr_seq` и `sword`
+(`pop_savekid_state`).  Направление оставалось «вправо», а все `DX`
+последовательности seq_70 отрицательные, поэтому Кид уходил ИЗ проёма влево.
+Вывод на будущее: геометрию персонажа в этом порте меняет `pop_map` (пишет в
+`Kid`), а не диспетчер.
+
+✅ Косметика тоже закрыта: BUG-DOOR-CLIP (обрезка силуэта правым косяком
+проёма) — недоставало второй половины `clip_char` (`obj_clip_right`) и
+обрезки СПРАВА у колоночного блита.  В libbgi добавлен
+`gfx_blit_cols_part_w(..., maxw)`; разбор — в [`bug_closed.md`](bug_closed.md).
+
+### L1-TRIAGE. Ревизия багов — **ЗАКРЫТА** (часть 1 — 2026-08-01, хвост — 2026-08-07)
+
+✅ **Три Critical'а прогнаны в MAME и закрыты** (протокол с числами — в
+[`bug_closed.md`](bug_closed.md), раздел «Проверено в MAME 2026-08-01»):
+BUG-1 (провал на row 1 при переходе через открытые ворота) и BUG-2
+(ping-pong при возврате) **не воспроизводятся**, BUG-3 (окклюзия climb-up на
+кнопке) закрыт фиксом `tile_code_drawn` от 2026-07-28.  Заодно снят неверный
+диагноз BUG-1: репроекция Y при БОКОВОМ переходе — не наш пробел, а точное
+поведение `goto_other_room` (`SDLPoP/src/seg002.c:390` меняет только `x`).
+Список разделён на [`bug_list.md`](bug_list.md) (открытое) и
+[`bug_closed.md`](bug_closed.md) (закрытое + разбор корней).
+
+✅ **Косметика окклюзии тоже закрыта** — BUG-CEIL-1/2/3 и BUG-OCCL-1 были
+починены кодом ещё в июле, а записи никто не снял: `ceil_over_kid_tile`
+(`pop_bg.c:1275`), `pop_ceil_modif` + `pop_ceil_shake_draw`/`_bake_empty`
+(`:547,815,827`), `bar` с `POP_YOFF+3` в `pop_room_redraw_seam_left` (`:793`),
+разделение слоёв по `add_backtable` vs `ptr_add_table` в `overlay_mid_tile`
+(`:1367`).  Разбор — в [`bug_closed.md`](bug_closed.md).
+
+✅ **Хвост закрыт 2026-08-07:** таблица обхода 24 комнат уровня 1 — прогоном
+всех комнат уровней 1 и 2 (крупных багов нет), см.
+[`bug_closed.md`](bug_closed.md#обход-всех-24-комнат-уровня-1).
+
+---
+
+## Отрисовка и память
+
+<a id="clip-1"></a>
+### CLIP-1. Аудит блитов: где клип не нужен — **СДЕЛАНО 2026-08-01**
+
+> **Итог.**  Heal Кида и стража переведены на выбор ядра по тому же тесту,
+> что давно стоит у блитов.  Замер в MAME (счётчики `totalcycles` на входах
+> `kid_heal` и `kid_tick`, то есть вся группа heal за кадр; комната 1, Кид
+> стоит, стража нет):
+>
+> | путь | тактов на кадр | кадров в выборке |
+> |------|----------------|------------------|
+> | клипающее ядро (как было) | **26 200** | 149 |
+> | noclip (стало) | **15 848** | 239 |
+>
+> **−10 352 такта на кадр, то есть −39.5 % с группы heal** (≈0.49 мс при
+> ~21 МГц).  A/B честный: оба замера сняты в ОДНОМ прогоне, вторая половина —
+> с пропатченным в памяти условием (`jr nz` → `jr` в `pop_heal_fast`), то
+> есть на той же геометрии и в той же сцене.
+>
+> **Размер: −362 Б суммарно** (не плюс!): `_CODE` 25 289 → 25 306 (+17),
+> BANK2 13 792 → **13 676** (−116, свободно стало 2708 Б — это тот самый
+> тесный банк из рисков `levels_plan.md` §5), BANK3 6512 → 6249 (−263),
+> BANK4 без изменений.
+>
+> **Грабли, стоившие двух пересборок** (вынесено в память
+> `sdcc-static-inline-double-cost`): первым заходом хелпер был `static
+> inline` в `pop_bg.h` — и SDCC 4.5 И встроил его тело (181 Б) в каждое
+> место вызова, И оставил отдельную копию в КАЖДОМ TU, который видит
+> заголовок.  `pop_guard_heal` раздулся с ~60 до 663 Б, итого +1091 Б в
+> `_CODE` и +636 Б в банке стража.  Лечится обычной функцией в одном
+> резидентном модуле (`pop_draw.c`, W1 — из банков это прямой `call` без
+> трамплина, как у `pop_sword_draw`).
+>
+> **Проверено визуально:** обычная ходьба, прыжок, спуск и позиция «за
+> решёткой шва» (straddle — там как раз работает клипающий фолбэк) —
+> артефактов и следов нет.
+
+**Ниже — исходная постановка задачи (что и почему смотрели).**
+
+**Зачем было сейчас.**  Кадр занят на ~86 %; подготовка клипающего варианта
+стоит ~5.6 К тактов на вызов, а общее ядро против линейного — 13 288 против
+4 617 тактов на спрайт 32×3 (`libbgi/include/gfx.h`).  Это самая дешёвая
+оставшаяся оптимизация: не переписывание логики, а выбор ядра.
+
+**Что чинили:**
+
+- ✅ `kid_heal()` и `pop_guard_heal()` звали `gfx_heal` — **всегда с
+  клипом**, хотя `gfx_heal_noclip` существует и `heal_off` в `pop_bg.c` им
+  уже пользовался.  Это heal 2–4 прямоугольников КАЖДЫЙ кадр; замер общего
+  ядра — 11 658 тактов на heal 22×22.  Теперь все три идут через общий
+  `pop_heal_fast` (`pop_draw.c` + `_pop_draw.h`).
+- ⛔ `pop_room_clip_borders()` (`pop_bg.c`) — `gfx_heal(0,0,320,…)`:
+  **оставлен клипающим осознанно**.  Полоса шириной 320 не лезет в 8-битный
+  параметр noclip-ядра, а бить её на два куска по 160 нет смысла: гейт
+  `border_dirty` пускает туда только в кадрах падения, и выигрыш подготовки
+  тонет в цене самих 320×28 пикселей.  Причина записана прямо в коде, чтобы
+  не «оптимизировать» повторно.
+
+**Что обязано остаться с клипом** (зафиксировано комментариями в коде):
+- кромочные тайлы фона (`blit_b` в `pop_bg.c`) — тайл у края экрана режется
+  по построению;
+- спрайты при straddle (`kid_render_dx = ∓140`, комната Кида ≠ отрисованной)
+  и при падении ниже поля — фолбэки в `kid_draw`/`pop_guard_draw`;
+- борта поля (`pop_room_clip_borders`) — см. выше.
+
+**Что уже было правильно** (шаблон, который и распространили): блиты Кида,
+стража, клинка и брызг спрашивают `pop_onscreen_cols()` и уходят в
+`gfx_blit_cols_part_noclip`.  Отдельный случай — `pop_kid_img_blit`: noclip
+БЕЗ проверки, потому что единственный вызывающий (полоса HP) рисует по
+фиксированным координатам; это тоже помечено в коде.
+
+<a id="mem-bank5"></a>
+### MEM-BANK5. Разгрузка W1/W2 новым банком кода — **СДЕЛАНО 2026-08-05**
+
+Итог: `pop_ctrl.c` уехал в банк 5, куча 180 Б → **2298 Б** (после снижения
+`--max-allocs`, см. [BUILD-FAST](#build-fast), — 2751 Б).
+
+Вопрос 2026-08-04: «надо делать новый банк?».  **Да, и он лечит именно то,
+что жмёт.**  В нашей раскладке (`MEMORY=huge`, small-вариант) CODE и DATA
+живут в ОДНОМ 32-КБ пространстве W1+W2 — карта сборки на тот момент:
+
+```
+_CODE  0x4100..0xAA00   26880 Б
+_DATA  0xAAD0..0xB9B0    3808 Б
+_BSS   0xB9B8..0xBADA     290 Б
+куча   0xBADA..0xBB00      38 Б      ← упёрлись сюда, добавляя отладку
+стек   0xBB00..0xC000    1280 Б
+```
+
+Поэтому **каждый килобайт кода, уехавший в банк, становится килобайтом,
+доступным данным**.  Отдельного «дефицита W2» у нас нет — дефицит один.
+(38 байт кучи не опасны сами по себе: malloc'ом мы не пользуемся, страницы
+берутся через `mem_alloc_block`.  Опасно то, что следующая структура
+данных упрётся в стек молча.)
+
+Резидентный код по модулям (из `.sprinter-cc-roomtest/*.rel`):
+
+| модуль | _CODE | как часто зовётся | в банк? |
+|--------|------:|-------------------|---------|
+| `pop_kid.c`  | 6287 | `load_frame`/`play_seq` — 2×/кадр (Кид + страж) | частично: холодная половина (загрузка страниц спрайтов, `pop_kid_load`) — да; движок кадров — нет |
+| `roomtest.c` | 3893 | main-loop | нет (точка входа, зовёт всех) |
+| `pop_trob.c` | 2526 | `do_trobs` 1×/кадр, но `pop_trob_modif` — горячий аксессор | кандидат, если вынести аксессор в резидент |
+| `pop_level.c`| 2292 | `pop_level_tile` — из `pop_bg` (банк 2) на каждый тайл | **нет**: банк→банк на каждый тайл убьёт отрисовку |
+| `pop_ctrl.c` | 2189 | `user_control` 1×/кадр | **взят** — дёшево и безопасно |
+| `pop_guard.c`|  923 | 1×/кадр | нет смысла |
+
+Критерий кандидата — **не размер, а частота вызова и отсутствие горячих
+банк→банк переходов**; `pop_level` показывает, что большой холодный на вид
+модуль может быть горячим аксессором.  Следующий шаг (расщепление
+`pop_kid.c`) — в [`TASKS_OPEN.md`](TASKS_OPEN.md#mem-next), брать по факту
+нехватки места.
+
+<a id="build-fast"></a>
+### BUILD-FAST. Сборка 10 минут → 1:48 — **СДЕЛАНО 2026-08-06** (коммит 0cd6b2d)
+
+`--max-allocs-per-node` — во сколько вариантов размещения регистров SDCC
+упирается на узел.  У `sprinter-cc` дефолт 100000 (агрессивно, как fast-сборки
+библиотек), и на крупных модулях roomtest это МИНУТЫ на банк.  Дефолт SDCC —
+3000, для разработки его достаточно: разница в размере — единицы процента.
+
+Итог: сборка с нуля **1:48 вместо >10 минут**, куча 2751 Б вместо 2298
+(на 3000 резидент иначе не влезает — замер: конец `_HOME` 0xBC69 при стеке с
+0xBB00).  В Makefile это `ALLOCS ?= 3000`:
+
+```
+make                 — быстрая сборка (ALLOCS=3000)
+make ALLOCS=100000   — как раньше: минимальный код, для замеров размера
+                       и для «релизного» образа
+```
+
+**ВАЖНО:** любое сравнение занятости банков имеет смысл только при ОДНОМ и
+том же `ALLOCS` — иначе сравниваются не правки, а уровни оптимизации.
+
+<a id="dbg-cheats"></a>
+### DBG-CHEATS. Отладочные читы SDLPoP — **`[`/`]` СДЕЛАНЫ 2026-08-05**, остальное — оценка
+
+Мотив прямой: мост MAME **теряет нажатия при быстрой отправке**, поэтому
+подогнать Кида в нужную позу для отладки автоматикой нельзя — именно на это
+упёрлись BUG-LOOSE-2 и BUG-GATE-PASS-1.
+
+**Сделано:**
+
+- **`[` / `]` — сдвинуть Кида на пиксель влево/вправо.**  Оригинал —
+  `../SDLPoP/src/seg000.c:1828`:
+  ```c
+  if (key_states[SDL_SCANCODE_RIGHTBRACKET] & key_state) ++Char.x;
+  else if (key_states[SDL_SCANCODE_LEFTBRACKET] & key_state) --Char.x;
+  ```
+  У нас: коды PS/2 set 2 `[` = **0x54**, `]` = **0x5B** в `pop_cheat.h`
+  рядом с `KBD_CHEAT_KILL/IMMO/SWORD`; обработка — в том же блоке читов
+  `roomtest.c`, **по фронту** (`*_prev`, как у остальных), иначе одно
+  нажатие уедет на десяток пикселей.  Работает по `Kid.x` напрямую:
+  геометрию персонажа в этом порте меняет не диспетчер (см. грабли L1-EXIT).
+- **Shift+L — следующий уровень** (вошло в L2-машинерию).
+
+**Остальные — оценка, а не обязательство** (актуальный статус —
+[`TASKS_OPEN.md`](TASKS_OPEN.md), «Отложено осознанно»):
+
+| Чит | Вердикт |
+|-----|---------|
+| **T — таймер** | **не сейчас**: таймера уровня у нас нет вообще (Фаза 6), чит пришлось бы делать вместе с механикой |
+| **F — остаток feather-fall** | **вместе с Shift+W**: ветка `JMP_IF_FEATHER` (опкод `0xF7`) в `play_seq` есть, но не проверена ничем; индикатор без самого зелья бесполезен, а пара «включить + видеть остаток» закрывает ветку целиком.  Перо — уровень 7, так что не срочно |
+| **Shift+F9 — quickload с тем же уровнем** | **самое ценное и самое дорогое**: это сериализация `Char` + `room_modif` всех комнат + trob'ов + стражей (`levels_plan.md` §4).  Даёт воспроизводимый регресс «вот кадр, где баг» вместо ручной подгонки |
+
+---
+
+<a id="kbd-1"></a>
+## KBD-1. Shift + стрелки: нажатия теряются — **ПРИЧИНА НАЙДЕНА, ФИКС ПРОВЕРЕН** (остаток отложен)
+
+> **ПОПРАВКА К ПОСЫЛКЕ (2026-08-05).**  Ниже «fake shift» подан как
+> установленный факт («при зажатом Shift PS/2 удваивает трафик»).  Прямой
+> замер потока байт это не подтвердил: клавиатура MAME-Sprinter
+> (`pc_kbd ms_naturl`) обёртку `E0 F0 12` / `E0 12` не шлёт вовсе — при
+> зажатом Shift поток на стрелку ровно `E0 75 E0 75 …`.  Значит удвоения
+> трафика в связке Shift+стрелка нет, и мотивировка «поэтому FIFO
+> переполняется» отпадает; сам ФИКС (плотный опрос `kbd_raw_poll`) остаётся
+> верным и нужным — переполнение вызывает не Shift, а короткая жизнь
+> импульса IRQ (пункт 3 гипотезы) плюс DI-окна графики.  Разбор и следствия
+> — [BUG-KBD-5](bug_closed.md).
+>
+> **Итог (2026-08-01).**  Причина — не наш код и не DI-окна графики: импульс
+> запроса прерывания здесь теряется примерно в 44 % случаев, и трёхбайтовый
+> FIFO SIO переполняется.  Лечится ПЛОТНЫМ опросом: `kbd_raw_poll` повешен
+> idle-хуком на ожидание кадра (`gfx_set_idle_hook`, новый API libbgi) —
+> процессор всё равно проводит там ~42 мс из 60, крутя опрос луча.
+>
+> **Проверка в roomtest тем же счётным методом: 35 нажатий Shift+Home →
+> 35 make, ноль потерь** (до фикса — 9 из 10).  Боевой сценарий тоже:
+> четыре Shift+→ подряд дали четыре осторожных шага, `Kid.x` 114 → 147.
+> Цена: `_CODE` +170 Б, кадровый бюджет не затронут (опрос стоит в
+> простое).
+>
+> **ОСТАТОК (ручная проверка пользователем, 2026-08-01): «стало значительно
+> лучше, но иногда при зажатом Shift стрелка всё-таки пропускается».**
+> Ощущение, не замер — счётчики на 35 нажатиях подряд потерь не показали,
+> значит остаточная частота заметно ниже прежних ~15 %.  **Задача осознанно
+> ОТЛОЖЕНА до финальной полировки всей программы** (решение пользователя);
+> сейчас клавиатура пригодна для работы.
+>
+> **Где именно осталась дыра — чтобы на полировке не начинать с нуля.**
+> Idle-хук покрывает простой, то есть ~2/3 кадра.  Оставшаяся треть — это
+> занятая фаза, и там DI-окно одного accel-прохода доходит до ~650 мкс при
+> допуске FIFO ~300 мкс.  Пачка байт, целиком попавшая в такое окно, всё
+> ещё может потерять байт — ровно «иногда».  Порядок действий, если
+> вернёмся:
+> 1. Вернуть вызовы `kbd_raw_poll()` между блитами занятой фазы (они
+>    бесплатны; сами по себе не помогали, но вместе с хуком закрывают
+>    именно этот зазор) и при необходимости внутрь тайловых циклов
+>    `pop_bg` — тогда слепым остаётся только тело одного блита.
+> 2. Мерить тем же счётным методом (см. ниже), а не на ощупь: скриптовые
+>    нажатия ровнее человеческих, поэтому набирать выборку от 50 нажатий.
+> 3. Если и это не добьёт — остаются два рычага вне нашего кода: Scan Code
+>    Set 3 через BIOS `$EA` (убирает «fake shift» в корне, но в MAME
+>    непроверяемо — обратный путь к клавиатуре не разведён) и общий
+>    `m_irq_off_timer` в драйвере MAME.
+
+**Симптом (пользователь, 2026-08-01).**  Залипаний почти нет, но при
+УДЕРЖИВАЕМОМ Shift первые один-два нажатия ← дают осторожные шаги, дальше
+нажатия ← не отрабатываются, пока Shift не отпустишь.
+
+**Рабочая гипотеза, с которой начинали.**  Три факта складывались в одну
+картину:
+
+1. **PS/2 Set 2, «fake shift».**  При зажатом Shift нажатие РАСШИРЕННОЙ
+   клавиши (стрелки — `E0`-коды) обрамляется фиктивным отпусканием/нажатием
+   шифта: нажатие ← шлёт `E0 F0 12` + `E0 6B` = **5 байт** (без шифта было
+   бы 2), отпускание — `E0 F0 6B` + `E0 12` = **5 байт** (было 3).
+   (**Опровергнуто замером 2026-08-05, см. поправку выше.**)
+2. **Приёмный FIFO SIO — 3 байта.**  Пачка в 5 байт переживает только то,
+   что мы успеваем вычерпывать её по ходу.  Потерянный make стрелки =
+   «нажатие не отработало»; потерянный break = залипание (его лечит
+   `kbd_raw_sync`, но ценой сброса всех немодификаторных клавиш).
+3. **Импульс IRQ клавиатуры в MAME живёт 32 такта CPU.**
+   `mame/sources/MAME/src/mame/sinclair/sprinter.cpp`: `on_kbd_data()`
+   выставляет `m_irqs->in_set<1>()` НА КАЖДЫЙ принятый байт (то есть старая
+   запись в `docs/TODO.md` «MAME не даёт per-byte INT» — неверна), но тут же
+   заводит `m_irq_off_timer` на 32 такта, а `irq_off()` снимает линию.
+   **Если в эти 32 такта мы под `DI` — прерывание пропало насовсем**, байт
+   остаётся в FIFO до следующего IRQ (следующий байт или кадровый 50 Гц).
+4. **Наши DI-окна длинные.**  Ядра акселератора держат `di` на ВЕСЬ блит
+   (`libbgi/bgi256/_bgi_blit_cols_raw.c:47` — «один DI на весь блит»);
+   порядок цены прохода — 13.6 К тактов (`libbgi/include/gfx.h`), это
+   сотни микросекунд, на порядки больше 32-тактового импульса.
+
+Логика ввода (`pop_ctrl.c`, порт `read_user_control`/`safe_step`) сверена с
+SDLPoP и корректна: `safe_step()` ставит `control_forward = CONTROL_IGNORE`,
+и это снимается в `read_user_control()` при ОТПУСКАНИИ стрелки — то есть
+повторные тапы ← при зажатом Shift обязаны работать.  Не работали они
+потому, что до нас не доезжал либо make, либо break стрелки.
+
+### ЧТО ИЗМЕРЕНО (сессия 2026-08-01) — гипотеза про DI НЕ подтвердилась
+
+**Методика.**  Симптом «нажатие не отработало» переведён в счётчики, чтобы не
+спорить с глазами.  Нажимается **Home** — тоже расширенная клавиша (тот же
+`E0`-префикс), но игрой игнорируется, поэтому Кид стоит на месте и рельеф
+комнаты на результат не влияет.  Брейкпоинты с действием
+`{ b@ADDR = b@ADDR + 1 ; g }` (счёт без остановки машины) в трёх точках: вход
+клавиатурной ветки трамплина, чтение порта 0x18 внутри drain-цикла, запись
+make-бита для кода `0x6C`.  Скратч-байты — хвост `ovr_tile[]`.
+
+**Симптом воспроизведён скриптом:** при зажатом Shift 10 нажатий → до
+декодера дошло 9 make-байт.  Без Shift потерь нет — ровно как сообщил
+пользователь.
+
+| Прогон | make дошло / нажато | overrun |
+|--------|---------------------|---------|
+| игра идёт, `kbd_raw_poll` ВКЛ | 9 / 10 | 3 |
+| игра идёт, `kbd_raw_poll` ВЫКЛ (патч `ret` в точке входа) | 9 / 10 | 4 |
+| игра ЗАМОРОЖЕНА клавишей «1» (блитов нет вообще, значит и длинных DI нет) | **8 / 10** | 6 |
+
+**Вывод 1: наши DI-окна ни при чём.**  В замороженном кадре, где блитов нет
+и прерывания разрешены практически всё время, потерь НЕ меньше, а больше.
+
+**Вывод 2: `kbd_raw_poll()` в той расстановке бесполезен** — 9/10 и с ним, и
+без.  Причина понятна задним числом: шесть вызовов стояли В ТЕХ ЖЕ точках,
+где прерывания и так разрешены.  Вызовы из `roomtest.c` убраны; сама функция
+в libc оставлена — она корректна и нужна как заготовка под «плотный опрос».
+
+**Вывод 3 (главный): байт теряется НИЖЕ нашего кода.**  Счётчик чтений порта
+0x18: 5 нажатий Shift+Home должны дать ровно 50 байт.  Насчитано **49** — и
+ровно один make потерян.  То есть до процессора байт не доехал вообще,
+декодер тут ни при чём.
+
+**Вывод 4: прерывание на байт теряется примерно в 44 % случаев.**  На тех же
+49 прочитанных байтах — только **28 входов** в клавиатурную ветку трамплина
+(1.75 байта за вход).  Байты копятся в трёхбайтовом FIFO вплотную к потолку;
+одна неудачная пауза — и байт потерян.
+
+### ПОТОЛОК ПЛОТНОГО ОПРОСА ИЗМЕРЕН — приём лечит полностью
+
+`tests/kbdpoll` — программа, которая не делает НИЧЕГО, кроме
+`kbd_raw_poll()` в бесконечном цикле (ни графики, ни vsync, ни вывода:
+любая работа разредила бы опрос и испортила замер).  Это физический
+максимум плотности.  Тот же счётный метод, те же брейкпоинты-счётчики.
+
+| Прогон | нажатий | make дошло | байт прочитано / ожидалось |
+|--------|---------|-----------|-----------------------------|
+| контроль: Shift зажат 4 с, нажатий нет | 0 | 0 | 0 (Shift сам ничего не шлёт — автоповтора у модификатора нет) |
+| Shift + Home | **25** | **25** | **250 / 250** |
+
+**Ни одного потерянного байта.**  Для сравнения: в игре при шести вызовах
+за кадр терялся 1 байт из 50.  При такой частоте потерь вероятность
+случайно получить ноль потерь на 250 байтах ≈ 0.6 %, так что результат не
+совпадение.
+
+**Вывод: опрос — рабочее решение, вопрос только в ПЛОТНОСТИ.**  Нужно
+опрашивать примерно раз в 0.5 мс (≈10 000 тактов), а шесть вызовов за
+60-мс кадр давали один раз в 10 мс — в двадцать раз реже необходимого.
+
+**Где взять частоту:** логический тик = 60 мс, из них ~18 мс занято
+работой и **~42 мс процессор простаивает внутри `gfx_wait_vsync`**, опрашивая
+луч.  Опрос там стоит ноль и покрывает две трети периода с запасом.
+Остаётся слепым только тело одного accel-блита под DI (до ~650 мкс) —
+разорвать его нельзя (см. «что НЕ делать»).
+
+**Почему нужна именно такая частота** (вопрос «PS/2 же не даёт больше 30
+нажатий в секунду»).  Частота опроса определяется НЕ темпом нажатий, а
+темпом байт ВНУТРИ одного нажатия и глубиной FIFO.  Клавиатура выдаёт байты
+со скоростью провода: 11 бит на байт при ~10–16 кГц = ~0.7–1.1 мс на байт.
+Воронка — 3 байта.  Значит между двумя вычерпываниями имеют право прийти
+максимум два байта, то есть вычерпывать надо не реже чем раз в ~1.5–2 мс
+(0.5 мс взято с запасом).  **Даже ОДНО нажатие в секунду переполнит FIFO**,
+если в эти несколько миллисекунд его никто не разгребает.  Замер это
+подтверждает: 1.75 байта за одно вычерпывание — уже 58 % ёмкости.  В норме
+разгребает прерывание; опрос понадобился только потому, что ~44 % импульсов
+здесь теряется.
+
+**Альтернатива, которая убирает опрос совсем — уменьшить трафик, а не
+ускорять разгребание.**  BIOS `$EA` (`FN_KBD_OUT`, `docs/new/09-input.md`
+§9.2) шлёт байт НА клавиатуру, то есть ей можно скомандовать:
+- **Scan Code Set 3** — нет ни «fake shift», ни `E0`-префиксов: make = 1 байт,
+  break = 2;
+- либо хотя бы отключить typematic (`0xF5`/`0xF7`).
+
+**Но проверить это в MAME НЕЛЬЗЯ:** в `sprinter.cpp` подключено только
+направление клавиатура→SIO (`m_kbd->out_data_cb() → rxa_w`); обратный путь
+(SIO→клавиатура) не разведён вовсе, так что команда просто уйдёт в никуда.
+Плюс пришлось бы переписать все наши константы кодов под Set 3.  Значит это
+кандидат на «когда дойдём до реального железа».
+
+**Что сделано по этому плану (2026-08-01):**
+1. ✅ Idle-хук в libbgi: `gfx_set_idle_hook(fn)`, вызывается в цикле ожидания
+   луча внутри `gfx_wait_vsync`.  Приложение ставит туда `kbd_raw_poll`.
+   Полезен не только нам — любой программе даёт «качать» что-то в ожидании
+   кадра.  Осторожно с регистрами: цикл ждёт на BC-таймауте, вокруг вызова
+   нужен push/pop, а сам таймаут в итерациях станет длиннее по времени.
+   **Важно про цену: это НЕ новая нагрузка.**  Опрос ставится ровно туда,
+   где процессор и так впустую крутит `in a,(#0xFE)` — 42 мс из 60.
+   **Ограничитель области, если «постоянный опрос» не нравится:** потери
+   случаются ТОЛЬКО при зажатом модификаторе (замерено), значит хук можно
+   взводить лишь пока нажат Shift/Ctrl/Alt.
+2. ✅ Перемерено в roomtest тем же счётным методом: **35/35**, потерь нет.
+3. ⏳ Вызовы в занятую треть кадра НЕ возвращены: одного idle-хука хватило.
+   Держать в уме, если на реальном железе или на более тяжёлых сценах
+   (несколько стражей) потери появятся снова — накрыть блиты дешевле, чем
+   изобретать что-то новое.
+4. ⏳ Ручная проверка пользователем — «стало значительно лучше, иногда всё
+   ещё пропускает»; остаток отложен (см. врезку в начале записи).
+
+**Куда смотреть дальше, если плотного опроса не хватит.**
+1. **Драйвер MAME — НЕ ТРОГАЕМ** (решение пользователя: пересборка MAME на
+   его машине занимает часы).  Для протокола, подозрение осталось:
+   `sinclair/sprinter.cpp` держит запрос от клавиатуры ровно **32 такта
+   CPU**, и `m_irq_off_timer` — **один на два источника** (`irq_on()` экрана
+   заводит его же, `irq_off()` гасит разом обе линии).  То есть кадровое
+   прерывание способно обрезать клавиатурный импульс — правдоподобное
+   объяснение «44 % пропущенных импульсов».
+2. **Реальное железо.**  Если п.1 — чисто эмуляционный артефакт, на железе
+   проблемы может не быть вовсе.  Проверять при первом прогоне на живом
+   Sprinter.
+
+**Про совпадение кадрового и клавиатурного прерываний** (вопрос
+пользователя, 2026-08-01).  Документация Sprinter: оба приходят с вектором
+`0FFh`, различать по биту приёма байта в порту клавиатуры — «не пришёл,
+значит экран»; совпадение возможно, но «исключительно редкий случай»
+(в новой версии обещают развести жёстче через ПЛМ).  То есть наш трамплин
+делает ровно предписанное.  Известный побочный эффект: при совпадении мы
+обслуживаем клавиатуру и `reti`, пропуская кадровую цепочку и DSS — на
+потерю байт это не влияет (линия кадрового остаётся взведённой и вызывает
+повторный вход), но кадровый тик может пропасть.  Отдельная мелкая правка.
+
+**Что НЕ делать (проверено, стоило времени):**
+- **Снимать `di` в accel-ядрах libbgi нельзя.**  Патч `di`→`nop` в
+  `_bgi_blit_cols_raw`/`_bgi_heal_rows_raw`/`_bgi_blit_rows_raw` прямо в
+  памяти **уронил машину в перезагрузку**.  То есть режим «акселератор
+  работает при EI» из `docs/new/06-accel.md §6.6` в этой прошивке/эмуляции
+  недоступен — вопрос закрыт артефактом, а не рассуждением.
+- Дробить DI-окна по колонкам смысла тоже нет: см. вывод 1.
@@ -0,0 +1,487 @@
+# roomtest — доска ОТКРЫТЫХ задач (обновлено 2026-08-07)
+
+Что берём в работу сейчас и в каком порядке.  Каждая запись: что сделать,
+почему именно сейчас, чем подтверждать результат.
+
+- закрытые задачи с протоколами и замерами — [`TASKS_CLOSED.md`](TASKS_CLOSED.md);
+- открытые баги — [`bug_list.md`](bug_list.md), закрытые с разбором корней —
+  [`bug_closed.md`](bug_closed.md);
+- планы фаз — `../docs/PORT_PLAN.md`, `../docs/layout_plan_v2.md`,
+  `../docs/levels_plan.md`.
+
+**Состояние на 2026-08-07:** пользователь прогнал ВСЕ комнаты уровней 1 и 2 —
+крупных багов нет.  Приёмки [L1-PASS](TASKS_CLOSED.md#l1-pass) и
+[L2-PASS](TASKS_CLOSED.md#l2-pass) закрыты; с прогона открыты три записи по
+уровню 2 (цвет стража, брызги по стражу, чит `+`/`−` в бою) — все в
+[`bug_list.md`](bug_list.md).  Уровень 3 играется, но приёмки не было: сначала
+чомперы и скелет.
+
+Правило проекта в силе: механику сверять с `../SDLPoP/src/` ДО кодинга;
+диагноз платформы подтверждать артефактом (брейкпоинт/дамп/.asm), а не
+гипотезой (memory `defer_unexplained_quirks`).
+
+---
+
+## ТЕКУЩАЯ ЦЕЛЬ: уровни 1–3 (подземелье) отлажены целиком
+
+Решение 2026-08-04: **palace (уровни 4+) откладываем**, доводим до
+играбельности три dungeon-уровня.  Основание — они не требуют ни одного
+нового ассета фона: инвентарь тайлов, снятый с `res200N.bin`, показывает,
+что новое появляется только так —
+
+```
+ур. 1  empty, floor, spike, pillar, gate, closer, potion, loose, debris,
+       opener, level_door L/R, torch, wall, skeleton, sword     ← всё есть
+ур. 2  bigpillar_bottom(8), bigpillar_top(9), doortop(12)       ← есть (2026-08-04)
+ур. 3  chomper(18)                                              ← НЕТ механики
+ур. 4  lattice_pillar(25)…lattice_right(29) + тайлсет palace    ← отложено
+```
+
+| # | Задача | Что | Блокирует |
+|---|--------|-----|-----------|
+| 1 | [GUARD-PHYS](#guard-phys) | физика стража = физика Кида (одна над `Char`) | **ядро сделано 2026-08-07**; открыт живой сценарий в MAME |
+| 2 | [L3-CHOMP](#l3-chomp) | чомперы (5 шт) | прохождение ур. 3 |
+| 3 | [L3-SKEL](#l3-skel)   | скелет (единственный противник ур. 3) | прохождение ур. 3 |
+| 4 | [L3-PASS](#l3-pass)   | приёмка уровня 3 (обход комнат) | закрытие цели |
+| — | [L1-SPEED](#l1-speed) | игра на ~39 % быстрее оригинала | ощущение от ВСЕХ уровней; берётся в любой момент |
+| — | [TUNE-1](#tune-1) | параметры движка → cfg-файл (сейчас `pop_tune.h`) | отладка таймингов и моды; берётся по мере надобности |
+
+Сделанное по этой цели — в [`TASKS_CLOSED.md`](TASKS_CLOSED.md): L2 (машинерия
+уровней), L2-PASS, L1-PASS, [L3-CHKP](TASKS_CLOSED.md#l3-chkp) (чекпойнт
+уровня 3), MEM-BANK5, CLIP-1, KBD-1, DBG-CHEATS.
+
+---
+
+## Ждёт ФИНАЛЬНОЙ приёмки уровней 1–3
+
+Сюда попадает то, что уже работает в проверочном прогоне, но должно быть
+подтверждено на сквозных прогонах уровней — потому что задевает механику
+шире, чем собственный сценарий.
+
+- **Зацеп ПРЯМО В ПРЫЖКЕ** (`POP_ENABLE_JUMP_GRAB`, `pop_tune.h`, сделан
+  2026-08-06, предварительно проверен пользователем).  Почему нужен именно
+  финальный прогон: точки вызова стоят не только в `check_action`, но и в
+  ОБЕИХ ветках `check_bumped` — то есть код вклинивается перед обычным
+  ударом о стену.  Регрессия проявится не в самом зацепе, а рядом: удар о
+  стену с зажатым Shift, осторожный шаг у стены, отскок в прыжке.  На
+  уровнях 1–3 это надо специально потрогать в паре мест каждого уровня.
+  Напоминание: в ВАНИЛИ этого зацепа нет (у SDLPoP — `enable_jump_grab`),
+  так что сверять его с оригиналом «как есть» нельзя — только с SDLPoP при
+  включённых enhancements.
+  Прогон 2026-08-07 (уровни 1 и 2) регрессий рядом не показал, но специально
+  на удар о стену с Shift не проверялся.
+
+## P0 — делаем сейчас
+
+### <a id="guard-phys"></a>GUARD-PHYS. Страж живёт по тем же правилам, что Кид — **ЯДРО СДЕЛАНО 2026-08-07**
+
+> **Что уже работает** (решение пользователя: переносим физику на `Char`,
+> без предварительных замеров — иначе третий-четвёртый экземпляр той же
+> логики неизбежен).
+>
+> - **физика переведена на `Char`**: `pop_map.c` целиком работает с активным
+>   персонажем, а кто в `Char` — решают окна `loadkid`/`savekid` и
+>   `loadshad`/`saveshad`, как в оригинале (seg006:809).  Два входа:
+>   `pop_phys_tick` (порт хвоста play_kid_frame) и `pop_guard_phys_tick`
+>   (порт play_guard_frame) — списки вызовов отличаются ровно тем, чем в
+>   оригинале;
+> - **`take_hp` стал общим** (`pop_take_hp` в резиденте `pop_guard.c`): урон
+>   идёт тому, кто в `Char`, по `charid`.  Раньше у боёвки и у физики были
+>   свои копии, причём у физики неверная — правила `hitp_curr` мимо дельты и
+>   про не-Кидов не знала;
+> - **порт веток по charid в `land()`** (seg005:173): страж гибнет с двух
+>   рядов, тень падает как с одного, у не-Кида приземление даёт боевую
+>   стойку; `check_guard_bumped` (seg004:0522), `droppedout` +
+>   `guard_follows_kid_down` (seg002:09F8), `check_guard_fallout`
+>   (seg002:0241);
+> - **`pop_savekid_state` снова полное `Kid = Char`**, а
+>   `pop_load_fram_det_col` пересчитывает колонку ЛЮБОМУ персонажу — обе
+>   заплатки существовали только потому, что физика знала один `Kid`.
+>
+> **Проверено:** `tests-host` — трассы Кида не изменились (`[phys] ok: 1723`,
+> тот же эталон), новый набор `t_char` (32 проверки) покрывает ветки по
+> персонажам; в MAME проверено, что игра жива (респавн, бег, падение,
+> приземление).  Цена: `_CODE` +80 Б, банк 3 (`pop_map`) 7973 → 8485
+> (51.8 %), банк 1 (`guards`) 2042 → 2156.
+>
+> **Проверено пользователем 2026-08-07:** страж СПРЫГИВАЕТ ЗА КИДОМ на ряд
+> ниже — связка «ИИ + физика» работает вживую, не только в тестах.
+>
+> **`follow_guard` портирован и проверен в MAME (2026-08-07):** уровень 1,
+> бой в комнате 3, Кид отступает влево — страж приходит следом (`Guard.room`
+> 3 → 2, X перенесён через шов), ровно как в SDLPoP.  Условия отбора
+> покрыты тестами `t_char` (7 сценариев: пороги 91/165, «не бой», мёртвый,
+> вверх/вниз, занятая соседняя комната).  **Сцена вскрыла отдельный баг —
+> [BUG-SWORD-GHOST-1](bug_list.md#bug-sword-ghost-1): при переходе в бою Кид
+> прячет меч и дальше дерётся пустой рукой.**
+>
+> **Осталось (потому и запись открыта):**
+> 1. `check_chomped_guard` — вместе с [L3-CHOMP](#l3-chomp);
+> 2. ветки `check_guard_fallout` для тени и скелета (скелет возрождается в
+>    комнате 3) — вместе с [L3-SKEL](#l3-skel);
+> 3. страж, нажимающий напольную кнопку, вживую не проверялся (код —
+>    общий `check_press`).
+
+**Почему это была ОДНА физика, а не «сделаем стражу свою».**  В оригинале
+слот `Guard` — не «стражи», а все НЕ-Киды: тем же `play_guard_frame` ходят
+**страж** (charid 2), **скелет** (4, ур. 3), **тень** (1, ур. 4/5/6/12),
+**визирь-Джаффар** (ур. 13), **толстяк** (FAT, ур. 12) и **мышь** (0x18,
+ур. 8) — `tbl_guard_type` = {0,0,0,2,0,0,1,0,0,0,0,0,4,3,−1,−1}, а
+`autocontrol_opponent` (seg002:628) разводит их ТОЛЬКО по ИИ.  То есть
+второй экземпляр логики пришлось бы делать не один раз, а пять.
+
+**Гард по X: страж не уходит САМ — но его МОГУТ ПЕРЕНЕСТИ.**  Поправка к
+формулировке, которая была здесь раньше («страж не покидает комнату ни в
+каком виде») — она неверна, контрпример дал пользователь: в SDLPoP страж из
+комнаты 3 оказывается в комнате 2 вслед за отступающим Кидом.
+
+Разделять надо два разных механизма:
+
+- **своим ходом — не может.**  Физика персонажа слота Guard обёрнута
+  `Char.room == drawn_room` и `Char.x >= 44 && Char.x < 211` (seg000:1252),
+  и никакого `check_leave` в его списке вызовов нет.  Провалившегося ниже
+  комнаты убирает `check_guard_fallout` (seg002:0241) — вниз он не уходит.
+- **следом за Кидом — переносит движок.**  `exit_room` (seg002:03C7)
+  вызывается ПОСЛЕ того, как комнату сменил Кид, и решает судьбу стража:
+
+  ```c
+  if (Guard.alive < 0 && Guard.sword == sword_2_drawn) {      // жив и В БОЮ
+      if (guards_tile[kid_room−1] >= 30 ||                    // в новой комнате
+          guards_seq_hi[kid_room−1] != 0) {                   // своего живого нет
+          if (ушёл ВЛЕВО)  { if (Guard.x >= 91)  leave = 1; } // страж далеко — остаётся
+          else if (ВПРАВО) { if (Guard.x < 165)  leave = 1; }
+          else if (ВВЕРХ)  { if (Guard.curr_row >= 0) leave = 1; }  // всегда → не идёт
+          else             { if (Guard.curr_row < 3)  leave = 1; }  // вниз → не идёт
+      } else leave = 1;
+  } else leave = 1;
+  leave ? leave_guard() : follow_guard();
+  ```
+
+  `follow_guard` (seg002:039E) стирает `guards_tile` в ОБЕИХ комнатах
+  (0xFF — «стража здесь нет», чтобы он не раздвоился) и гонит стража через
+  `goto_other_room` в окне `loadshad`/`saveshad`.
+
+**Что это значит для нас.**  У нас в `enter_room` (`roomtest.c:265`) стоит
+безусловный `pop_guard_leave()` — то есть всегда ветка `leave_guard`, и
+страж ВСЕГДА остаётся.  Портировать надо сам `exit_room`-выбор: условия
+«жив + меч вынут + в целевой комнате нет своего стража + он у нужного
+края» и `follow_guard`.  Пороги 91/165 — это «страж у того края, в который
+ушёл Кид»; вверх и вниз оригинал не пускает никогда.
+
+**Чем подтверждать:** уровень 1, комната 3 — начать бой, отступить влево в
+комнату 2: страж обязан прийти следом и продолжить бой (как в SDLPoP на
+скриншотах пользователя).  Обратная проверка: если в соседней комнате СВОЙ
+живой страж — переход не происходит.
+
+### <a id="l3-chomp"></a>L3-CHOMP. Чомперы — механика уровня 3
+
+**Где:** 5 штук, комнаты 5(тайл 4), 16(23,24,25), 22(26).  Дальше они почти
+на каждом уровне, так что это вложение не только в ур. 3.
+
+**Что портировать:** `animate_chomper` (seg007) — состояние в `room_modif`,
+как у пик/ворот, значит шаблон уже отработан (`gates_spikes_plan.md`);
+коллизия и смерть Кида в сомкнутых челюстях (`seg004`/`seg006`); отрисовка
+кадра по модификатору (`draw_tile_anim`, ветка `tiles_18_chomper`).
+
+**Риск:** банк 2 (`pop_bg`) занят на **90.8 %, свободно 1503 Б** (замер
+2026-08-07, было 2213 Б) — считать
+место ДО кодинга (`levels_plan.md` §5.1), иначе повторится «банк 2 упёрся
+в потолок» (коммит 2f3e854).  Свободные номера банков есть (5+).
+
+**Ассеты УЖЕ упакованы (2026-08-07):** `pop_pack_bg.py` кладёт в атлас весь
+набор кадров чомпера явно (`CHOMPER_BOT_IDS` 101-105, `CHOMPER_TOP_IDS`
+111-113, `CHOMPER_FORE_IDS` 106-110 + кровь 114-123 mono-силуэтом цветом 12).
+Раньше в атласе не было НИ ОДНОГО его кадра: `render_room.py` пропускает
+анимированные тайлы, а `tile_table[0x12].base_id = 0` — отсюда и «чомпера не
+видно вовсе».  Рост: `pop_env3.atl` 5200 -> 12937 Б, `pop_fore.atl` 7763 ->
+12359 Б, число EMM-страниц НЕ изменилось (7).
+
+**Чем подтверждать:** комната 22 уровня 3 — чомпер (2,6) анимируется и
+рисуется (сейчас его не видно вовсе, см. раздел «Уровень 3» в
+[`bug_list.md`](bug_list.md)); смерть Кида в сомкнутых челюстях.
+
+### <a id="l3-skel"></a>L3-SKEL. Скелет — единственный противник уровня 3
+
+**Важно:** в данных уровня 3 **стражей нет вообще** (`guards_tile` пуст во
+всех 24 комнатах).  Единственный враг — скелет, и он не «страж из данных»,
+а **спецсобытие** `check_skel` (seg002:1044):
+
+> в комнате 1, когда `Kid.curr_col` == 2 или 3 и дверь уровня открыта,
+> тайл `tiles_21_skeleton` (комната 1, тайлпос 15) стирается в пол, а на
+> его месте поднимается персонаж: `charid_4_skeleton`, меч сразу вынут,
+> `seq_88_skel_wake_up`, skill 2, HP 3.
+
+Ещё два тайла скелета (комнаты 17 и 19) — декорация, они не оживают.
+
+> **Сделано 2026-08-07 (ждёт живой проверки на уровне 3):**
+> - **атлас скелета** — `pop_pack_guard.py SKEL` собирает `poc/res/skel/g0..g3.atl`
+>   (28 кадров, 30 КБ, 4 EMM-страницы); упаковщик получил параметр набора
+>   (`GUARD`/`SKEL`).  Палитра у скелета СВОЯ (`SKEL/res750.pal`), а не из
+>   `res10.bin`: на уровне 3 `tbl_guard_type != 0`, значит
+>   `curr_guard_color = 0` и оригинал палитру не подменяет вовсе;
+> - `pop_guard_load` выбирает набор по типу уровня и заливает палитру
+>   скелета; Makefile кладёт атласы в `SKEL\` на диск;
+> - **`check_skel`** (seg002:1042) — порт в `guards.c`: уровень 3, комната 1,
+>   дверь уровня открыта, `Kid.curr_col` 2 или 3, тайл 21 на (5,1) → тайл
+>   стирается в пол (обе страницы), персонаж встаёт с `seq_88_skel_wake_up`,
+>   мечом наголо, skill 2, HP 3.  Зовётся из главного цикла ДО логики
+>   персонажей, как в `play_frame`;
+> - **`leveldoor_open`** — флаг появился (`pop_state.c`), взводит анимация
+>   двери при `modif >= 43` (seg007:456);
+> - **`enter_guard`** — ветка `charid_4_skeleton`: встаёт сразу активным
+>   (меч вынут), а не в стойке покоя;
+> - **возрождение** — `check_guard_fallout`: упавший скелет, под комнатой
+>   которого лежит комната 3, появляется там снова (x 133, ряд 1);
+> - **ИИ** — `autocontrol_skeleton` (seg002:685): меч у скелета вынут всегда.
+>
+> Регресс: `tests-host` зелёные, `t_char` вырос до 65 проверок (добавлены два
+> сценария возрождения).  Цена: `_CODE` +80 Б, банк 1 (`guards`) 2342 → 2519,
+> банк 4 (`gdraw`) 3875 → 4269.
+>
+> **Не проверено вживую:** сцена требует пройти уровень 3 до кнопки, которая
+> открывает выход — без открытой двери скелет по условию не встаёт.
+
+**Что нужно:**
+- `charid_4_skeleton` в `enter_guard`/`pop_guard_enter` (seg002:196): при
+  `tbl_guard_type[level] == 2` персонаж поднимается **с вынутым мечом** и
+  последовательностью `seq_63_guard_active_after_fall`, а не
+  `seq_77_guard_stand_inactive`;
+- скелет **бессмертен** — чит `K` его уже не берёт (`pop_guard_kill`
+  проверяет `CHARID_4_SKELETON`), но и боёвка должна возвращать его к
+  жизни (seg002:252);
+- **новый атлас**: `../SDLPoP/data/SKEL/` (29 файлов) — `pop_pack_guard.py`
+  сейчас прибит к `GUARD/`, нужен параметр набора (`tbl_guard_dat` =
+  GUARD/FAT/SKEL/VIZIER/SHADOW).  Здесь же удобно закрыть
+  [BUG-GUARD-COLOR-1](bug_list.md#bug-guard-color-1): палитра стража
+  подменяется по `guards_color`, и оба изменения живут в одном упаковщике.
+
+### <a id="l3-color"></a>L3-COLOR. Палитра КЛАДКИ уровня 3 (в оригинале он зелёный)
+
+**Наблюдение (пользователь, 2026-08-07, со сравнением карт VGA).**  В
+оригинальной VGA-версии кладка уровня 3 ЗЕЛЁНАЯ, а уровней 1-2 — серо-синяя.
+В SDLPoP все подземелья одинаковые, поэтому по нему разницу не увидеть.
+
+**Почему в SDLPoP её нет — проверено, не гипотеза.**  Механизм там ЕСТЬ
+(seg000:1140, «Level colors (1.3)»):
+
+```c
+int level_color = custom->tbl_level_color[current_level];
+if (level_color != 0) {
+    byte* env_pal  = level_var_palettes + 0x30*(level_color-1);
+    byte* wall_pal = env_pal + 0x30 * custom->tbl_level_type[current_level];
+    set_pal_arr(0x50, 0x10, (rgb_type*)env_pal);    /* chtab_6 environment */
+    set_pal_arr(0x60, 0x10, (rgb_type*)wall_pal);   /* chtab_7 wall        */
+}
+```
+
+`tbl_level_color` (data.h:842) = `{0,0,0,1,0,0,0,1,2,2,0,0,3,3,4,0}` — у
+уровня 3 цвет **1**, у 7 тоже 1, у 8/9 — 2, у 12/13 — 3, у 14 — 4.  Но
+`level_var_palettes` — это ресурс **20** из `PRINCE.DAT` (только версии
+1.3/1.4), а в `SDLPoP/data/PRINCE/` его НЕТ: там лежит лишь `res10.bin`
+(палитры стражей).  Значит `level_var_palettes == NULL` и вся ветка молча
+пропускается — отсюда одинаковые подземелья.
+
+**Данные у нас есть.**  В `../MSDOS/PRINCE.DAT` ресурс 20 присутствует:
+offset 22790, **240 байт** = 5 палитр × 16 цветов × 3 байта (6-битные
+каналы, как res10).
+
+**Что делать (когда дойдём до вида уровня 3).**
+1. Достать ресурс 20 из `MSDOS/PRINCE.DAT` (упаковщику придётся читать сам
+   `.DAT` — сейчас все скрипты берут распакованные PNG из SDLPoP);
+2. сгенерировать таблицу палитр рядом с `pop_guard_pal.h`;
+3. при загрузке уровня заливать слоты **0x50..0x5F** (env) и **0x60..0x6F**
+   (wall) — у нас ровно эти базы (`pop_pack_bg.load_indexed`: `pal_base =
+   0x60` для WALL, `0x50` для env), то есть совпадение со `set_pal_arr`
+   один в один;
+4. `wall_pal = env_pal + 0x30 * tbl_level_type[level]` — для подземелья
+   (`level_type == 0`) обе палитры одинаковые.
+
+**Грабли, уже пойманные на цвете стражей:** `gfx_pal_load` отдаёт указатель
+в BIOS (`$A4` через `rst #0x08`), а BIOS читает только `#4000-#BFFF` —
+таблицу нельзя передавать прямо из банка (0xC000+), надо копировать в
+W1/W2 (см. [BUG-GUARD-COLOR-1](bug_closed.md#bug-guard-color-1)).
+
+### <a id="draw-char"></a>DRAW-CHAR. Отрисовка — ОДНА на всех Char, как физика после GUARD-PHYS
+
+**Почему заведено (пользователь, 2026-08-07).**  После GUARD-PHYS физика стала
+общей над `Char`, а ОТРИСОВКА так и осталась продублированной: `kid_draw` и
+`pop_guard_draw` считают `load_frame_to_obj`, флип и heal-прямоугольники
+каждая по-своему, окклюзия — двумя проходами (`pop_fore_over_kid` /
+`pop_fore_over_char`).  Общее вынесено лишь частично (`char_footprint`,
+`other_overlay_tile`, `pop_sword_draw`), а СПИСКИ ВЫЗОВОВ разные.
+
+**В оригинале она общая — проверено.**  `seg008` держит два входа с
+ИДЕНТИЧНЫМ телом:
+
+```
+add_kid_to_objtable (seg008:22F0)      add_guard_to_objtable (seg008:2324)
+  loadkid()                              loadshad()
+  load_fram_det_col()                    load_fram_det_col()
+  load_frame_to_obj()                    load_frame_to_obj()
+  stuck_lower()                          stuck_lower()
+  set_char_collision()                   set_char_collision()
+  set_objtile_at_char()                  set_objtile_at_char()
+  redraw_at_char()                       redraw_at_char()
+  redraw_at_char2()                      redraw_at_char2()
+  clip_char()                            clip_char()
+  add_objtable(0)                        add_objtable(1 тень / 2 страж)
+```
+
+Различаются ТОЛЬКО окно (`Kid`/`Guard`), тип объекта и спецкейс тени у
+зеркала (уровень 4).  То есть та же схема, что `play_kid_frame` /
+`play_guard_frame` у физики.
+
+**Цена дублирования уже видна.**  Скелет, падающий в пропасть (ур. 3),
+рисовался ПОВЕРХ верхней грани пола соседней колонки: проход
+`other_overlay_tile` (порядок midtable — «тайлы позже персонажа ложатся
+поверх него») вызывался только у Кида.  Симптом закрыт 2026-08-07
+переносом прохода в `pop_fore_over_char`, но корень — именно дублирование.
+Раньше это не всплывало потому, что ОБЫЧНЫЙ страж в пропасть не падает: его
+физика гейтится `x ∈ [44,211)`, а провалившегося убирает
+`check_guard_fallout`.  Тем же путём пойдут тень (ур. 4/5/6/12), визирь
+(13), толстяк (12) — расхождение будет повторяться на каждом.
+
+**Что сделать:** свести к одному набору функций над `Char`, оставив
+параметрами ровно то, что различается в оригинале:
+- окно (`loadkid`/`loadshad` — уже есть);
+- набор атласов и таблица кадров (`kid*` / `GUARD` / `SKEL` — уже
+  выбирается в `pop_guard_load`);
+- слот heal-прямоугольников (у каждого персонажа свой, по страницам
+  дабл-буфера);
+- тип объекта для порядка (Kid / тень / страж).
+
+**Не портированы вовсе и относятся сюда же:** `stuck_lower`, `redraw_at_char2`,
+`clip_char` (см. memory `pop_clip_char_todo`).
+
+**Чем подтверждать:** падение скелета в пропасть с разных X (сегодняшний
+сценарий), бой стража на ур. 1-2 без регрессий, `tests-host` зелёные.
+
+### <a id="l3-pass"></a>L3-PASS. Приёмка уровня 3 — обход всех комнат
+
+Как L1-PASS/L2-PASS: сквозной проход руками плюс обход комнат читом ROOMNAV.
+Осмысленна ТОЛЬКО после L3-CHOMP и L3-SKEL — без них уровень заведомо
+неполон, и половина наблюдений будет «механики нет».
+
+Что уже снято и пригодится (справка ниже): комнаты **23 и 24 недостижимы** и
+полностью пусты — баги в них не в приоритете; **чекпойнт** уровня 3 сделан
+([L3-CHKP](TASKS_CLOSED.md#l3-chkp)), его тоже надо потрогать вживую: уйти
+влево из комнаты 7, умереть, проверить респавн в комнате 2 и снятую
+loose-плиту (7, кол 4, ряд 0).
+
+### <a id="rooms-graph"></a>Справка: связность комнат уровней 1–3 (снято 2026-08-05)
+
+Обход графа `roomlinks` (@1952, по 4 байта на комнату: L, R, U, D; 0 = нет
+соседа) от стартовой комнаты — тем же методом, которым на уровне 1 нашлись
+13/18/24 (см. «НЕ БАГИ» в [`bug_closed.md`](bug_closed.md)).  Скрипт разовый,
+в репозиторий не клался: чтение трёх массивов, BFS и проверка симметрии.
+
+| уровень | старт | недостижимы | признак |
+|---------|-------|-------------|---------|
+| 1 | к.1 (0,0) | **13, 18, 24** | ссылки наружу есть, обратных нет |
+| 2 | к.5 (1,3) | **нет** | граф полностью симметричен, все 24 достижимы |
+| 3 | к.9 (2,4) | **23, 24** | то же, что на 1: односторонние ссылки, обе комнаты **полностью пустые** |
+
+```
+ур.3:  23 L→4,  у 4  R=22   |  24 L→2,  у 2  R=7
+       23 R→22, у 22 L=4    |  24 R→7,  у 7  L=2
+                            |  24 U→16, у 16 D=0
+       на 23 ссылается только 24, на 24 — только 23; тайлы обеих = все empty
+```
+
+То есть на уровне 3 это даже более чистый случай, чем на уровне 1: там в
+брошенных комнатах была геометрия, здесь — пустота.  Практический вывод тот
+же: **в 23/24 возможен «мусор в шве»** (наш рендер кромки читает крайнюю
+колонку соседа ПО ССЫЛКЕ, а сосед соседом себя не считает), приоритет багов
+там низкий, в игре их не видно.
+
+**Уровень 2 — недостижимых нет, но есть три КОЛОДЦА без выхода** (единственная
+связь — вверх, откуда Кид падает):
+
+```
+к.10  U→4    пики(2,2) + пол — падение из комнаты 4
+к.14  U→21   шахта 2 тайла шириной, дно = обломки
+к.17  U→15   то же
+```
+
+Это не баги данных: в 14/17 попадают только падением насмерть, а из 10
+(если выжил) выхода нет вовсе — так в оригинале.  При приёмке не считать
+«застрял» багом.
+
+---
+
+## P1 — берётся в любой момент
+
+### <a id="l1-speed"></a>L1-SPEED. Игра идёт быстрее оригинала (найдено 2026-08-01)
+
+Сверка таймингов: оригинал — `BASE_FPS = 60` при `base_speed = 5` тиков на
+логический кадр (`SDLPoP/src/types.h:1373`, `data.h:869`) = **83.3 мс**, в бою
+`fight_speed = 6` = **100 мс**.  У нас `roomtest.c` ждёт **три** `gfx_wait_vsync()`
+= 60 мс, и отдельной скорости боя нет — то есть примерно **+39 % к скорости
+эталона**.  Соответствие: 4 ожидания (80 мс) обычно, 5 (100 мс) в бою.
+Условие «делать ПОСЛЕ CLIP-1» снято — CLIP-1 закрыт.  Проверка —
+секундомером по одинаковому отрезку рядом с живым SDLPoP, не «на глаз».
+
+### <a id="tune-1"></a>TUNE-1. Параметры движка — в конфиг, а не в код
+
+**Что уже есть.**  `pop_tune.h` — все настраиваемые числа собраны в одном
+заголовке: чекпойнт уровня 3 (`POP_CHKP_*`), отладочное окно решётки
+(`POP_DBG_GATE_HOLD`), включатель зацепа в прыжке (`POP_ENABLE_JUMP_GRAB`).
+Правило уже действует: новое «особое событие» или тайминг заводится ТАМ, а
+не константой по месту.
+
+**Что нужно сделать.**  Читать их из ФАЙЛА рядом с exe, чтобы менять без
+пересборки — под отладку («растянуть решётку, чтобы успеть пройти») и под
+моды.  Формат: простой ini/`ключ=значение`, парсер на ~50 строк (числа,
+комментарии `;`, неизвестные ключи игнорировать), файл необязателен —
+нет файла, значит зашитые дефолты.  Секции по смыслу: `[level]`,
+`[debug]`, `[enhancements]`.
+
+**Ориентир — SDLPoP.**  У него это `custom_options_type` (types.h) +
+`SDLPoP.ini` + меню Settings/Mods; наши имена намеренно совпадают с его
+(`custom->имя`), чтобы сверка оставалась механической.  Осмотр его меню и
+опций — часть задачи: у него уже разложены по группам стартовые
+HP/минуты, номера «особых» комнат и уровней (шадоу, скелет, зеркало,
+чекпойнт), тайминги ворот и пик, скорости, а отдельной группой —
+`fixes`/`enhancements` (включая `enable_jump_grab`, который мы уже
+портировали).  Брать всё подряд не надо: переносим по мере того, как
+константа реально понадобилась в игре.
+
+**Оговорка по памяти.**  Парсер и таблица параметров — холодный код,
+исполняется один раз при старте: кандидат в банк, а не в резидент W1.
+
+### <a id="mem-next"></a>MEM. Следующий шаг разгрузки W1/W2
+
+`pop_ctrl.c` уехал в банк 5 ([MEM-BANK5](TASKS_CLOSED.md#mem-bank5), куча
+180 Б → 2298 Б; после снижения `--max-allocs` — 2751 Б).  Следующий кандидат
+по тому же критерию (**не размер, а частота вызова и отсутствие горячих
+банк→банк переходов**) — **расщепление `pop_kid.c`**: холодная половина
+(загрузка страниц спрайтов, `pop_kid_load`) в банк, движок кадров
+(`load_frame`/`play_seq`, 2×/кадр) оставить в резиденте.
+
+Брать по факту нехватки места, не заранее.  Таблица резидентного кода по
+модулям и разбор, почему `pop_level.c` в банк НЕЛЬЗЯ, — в
+[`TASKS_CLOSED.md`](TASKS_CLOSED.md#mem-bank5).
+
+---
+
+## Отложено осознанно (не брать, пока не появится причина)
+
+- **KBD-1, остаток** — «иногда при зажатом Shift стрелка всё-таки
+  пропускается» (ощущение пользователя, не замер: счётчики на 35 нажатиях
+  подряд потерь не показывают).  Решение пользователя 2026-08-01: отложено до
+  финальной полировки.  Где именно осталась дыра и что делать, если вернёмся,
+  — в [`TASKS_CLOSED.md`](TASKS_CLOSED.md#kbd-1) (там же весь протокол
+  замеров и список того, что делать НЕЛЬЗЯ).
+- **Quickload (Shift+F9) и остальные читы SDLPoP** — оценка сделана
+  ([DBG-CHEATS](TASKS_CLOSED.md#dbg-cheats)), код не написан.  Самое ценное и
+  самое дорогое: сериализация `Char` + `room_modif` всех комнат + trob'ов +
+  стражей (`levels_plan.md` §4), зато даёт воспроизводимый регресс «вот кадр,
+  где баг» вместо ручной подгонки позы.
+- **Звук** (CBL-эффекты, Фаза 5 `PORT_PLAN.md`) — геймплей не блокирует.
+- **Таймер уровня / HUD времени / меню / сохранения** — Фаза 6.
+- **[T-1](bug_list.md#t-1)** (пики: перерисовка по причине) — отдаётся почти
+  бесплатно после [T-2](bug_list.md#t-2), отдельно не окупается.
+- **Отключение мыши на время игры** и **замена PRNG** —
+  `../docs/ideas_backlog.md` (оба дают доли процента кадра).
+- **OPT-1** (хирургический редрой шва) — решено НЕ делать, стоимость
+  транзиентная; разбор в [`bug_closed.md`](bug_closed.md).
@@ -0,0 +1,47 @@
+/*
+ * _pop_draw.h — внутренний заголовок слоя отрисовки: выбор ядра libbgi
+ * (клипающее / линейное «noclip») по одному и тому же тесту для блита и
+ * для heal.
+ *
+ * ПОЧЕМУ ОТДЕЛЬНЫЙ ФАЙЛ, А НЕ pop_bg.h.  Обе функции — `static inline`, а
+ * SDCC 4.5 оставляет тело такой функции в КАЖДОМ TU, который видит
+ * объявление, даже если тот её не зовёт (memory
+ * `sdcc_inline_codegen_findings`).  pop_bg.h включают почти все модули PoP,
+ * то есть из общего заголовка эти ~100 Б размножились бы десятком мёртвых
+ * копий (замер CLIP-1, 2026-08-01: +1091 Б в _CODE и +636 Б в банке
+ * стража — за код, который там никто не вызывает).  Здесь их видят ровно
+ * три файла, которые реально рисуют: pop_bg.c, pop_kid.c, pop_gdraw.c.
+ */
+#ifndef POP_DRAW_H
+#define POP_DRAW_H
+
+#include <stdint.h>
+#include <gfx.h>
+
+/* Спрайт целиком на экране И укладывается в 8-битные параметры noclip-
+ * примитивов libbgi?  Условие входа в gfx_blit_cols_part_noclip: клипающий
+ * вариант платит ~5.6 К тактов подготовки на КАЖДЫЙ вызов, независимо от
+ * того, вылезает край или нет. */
+static inline uint8_t pop_onscreen_cols(int x, int y, uint16_t w, uint16_t h)
+{
+    return (uint8_t)(x >= 0 && y >= 0 && w < 256 && h < 256 &&
+                     x + (int)w <= 320 && y + (int)h <= 256);
+}
+
+/* Стереть прямоугольник (heal из ОЗУ-копии) тем же приёмом, что и блит:
+ * целиком на экране → линейное ядро без клипа.  Условие входа у
+ * gfx_heal_noclip ровно то же, что у gfx_blit_cols_part_noclip, поэтому
+ * тест один — общее ядро gfx_heal платит за клип и 16-бит, а не за пиксели
+ * (замер: 11 658 тактов на heal 22×22).
+ *
+ * НЕ inline (тело — pop_draw.c, резидент W1): SDCC 4.5 встраивал бы его в
+ * каждое место вызова по 181 Б И оставлял мёртвую копию в каждом TU — см.
+ * шапку pop_draw.c с замером.  Зовётся 5 раз за кадр, цена вызова тонет в
+ * стоимости самого heal.
+ *
+ * w/h тут int, а не uint16_t: вызывающие считают их вычитанием (h − skip), и
+ * отрицательный результат обязан быть no-op, а не превратиться в огромный
+ * unsigned. */
+void pop_heal_fast(int x, int y, int w, int h);
+
+#endif
@@ -1,353 +1,250 @@
-# roomtest — список известных багов (Фаза B и смежное)
+# roomtest — ОТКРЫТЫЕ баги и незакрытые оптимизации

-Найдено при тестировании Фазы B (кнопки/ворота) в MAME.  **НЕ решаем сейчас**
-— задача следующего этапа.  Правило проекта: механику сверять с
-`applications/PoP/SDLPoP/src/` ДО кодинга.
+Только то, что **не закрыто**.  Всё закрытое (и, что важнее, разбор корней)
+переехало в [`bug_closed.md`](bug_closed.md): прежде чем заводить новый баг,
+грепни там по симптому.

-Статус на момент записи: 2026-07-21.  Тестовый старт — комната 6 (`START_ROOM`
-в `roomtest.c`).  Кнопка room6(0,2, opener) → ворота room8(0,9), видны в левом
-шве room6.
+Приоритеты работ — в [`TASKS_OPEN.md`](TASKS_OPEN.md) (закрытые задачи с
+протоколами — [`TASKS_CLOSED.md`](TASKS_CLOSED.md)), а не здесь.  Правило
+проекта: механику сверять с `../SDLPoP/src/` ДО кодинга.
+
+**Ревизия списка: 2026-08-07 — прогон ВСЕХ комнат уровней 1 и 2**
+(пользователь).  Крупных багов нет.  Поэтому в [`bug_closed.md`](bug_closed.md)
+уехали разом: чек-листы ручной перепроверки фиксов (2026-08-03, обе волны),
+таблица обхода 24 комнат уровня 1 и таблица сырых наблюдений того же прогона —
+все они закрыты этим проходом.  С прогона пришли **три новые записи**, все по
+уровню 2 (сырые формулировки — [`bugs_level2.md`](bugs_level2.md)).
+
+| ID | что | тип | статус |
+|----|-----|-----|--------|
+| [BUG-CHEAT-FIGHT-1](#bug-cheat-fight-1) | `+`/`−` в бою с вынутым мечом → Кид теряет управление | Major (чит) | открыт |
+| [BUG-GATE-PASS-1](#bug-gate-pass-1) | проход сквозь закрывшуюся решётку (0,9) комнаты 5 | Major | **ждёт сценария**: прогоном 2026-08-07 не воспроизведён |
+| [BUG-SPIKE-1](#bug-spike-1) | пики залипают выдвинутыми рядом с Кидом | **низкий** | маловоспроизводимый: ни сценарием, ни попиксельной подгонкой X не поднимается |
+| [T-1](#t-1) | пики перерисовываются безусловно | оптимизация | открыт |
+| [T-2](#t-2) | Кид перерисовывается в покое | оптимизация | открыт |

 ---

-## BUG-1. Боковой переход через ворота: Kid проваливается на row 1  — **Critical**
+<a id="уровень-2"></a>
+# Уровень 2 — баги с приёмки

-**Симптом:** при проходе через ОТКРЫТЫЕ ворота в соседнюю комнату (через шов)
-Kid оказывается на ряду **row 1** вместо row 0 — «проваливается» на этаж ниже
-(стоит в дверном проёме на неправильной высоте).
+Приёмка уровня 2 закрыта ([L2-PASS](TASKS_CLOSED.md#l2-pass)): smoke
+2026-08-05 + обход всех комнат 2026-08-07.  Карта содержимого уровня (что где
+стоит по `res2002.bin`, какие кнопки какие ворота открывают) — там же, по ней
+видно, «механика не сработала» это или «так и задумано».

-**Где:** `pop_map.c` `check_leave()` (порт seg002 leave_room) — боковой уход
-`pop_leave_dir`; репроекция координат `Kid.x ∓= 140` есть, но Y/`curr_row`
-при боковом переходе НЕ репроецируются (в отличие от `check_leave_below`,
-где `Kid.y -= 189; curr_row = y_to_row`).  При входе в соседнюю комнату у
-шва Kid, видимо, попадает в позицию, где `determine_col`/физика следующего
-кадра сбрасывают его на row 1 (нет пола на row 0 у входа, либо неверный y).
+**Закрыто с этой волны:** [BUG-LOOSE-3](bug_closed.md) — чёрный бар под
+упавшей плитой-потолком; [BUG-GUARD-DEAF-1](bug_closed.md) — страж не
+оборачивался на вернувшегося Кида;
+[BUG-GUARD-SPLASH-1](bug_closed.md#bug-guard-splash-1) — «брызги» при
+попадании по стражу; [BUG-SWORD-GHOST-1](bug_closed.md#bug-sword-ghost-1) —
+меч, спрятанный посреди боя после перехода комнаты (корень — мнимая стена за
+краем комнаты в `get_tile`; кэш соседей расширен до полных комнат);
+[BUG-GUARD-COLOR-1](bug_closed.md#bug-guard-color-1) — цвет стража и его
+полосы HP теперь берётся из `guards_color` уровня (2026-08-07).

-**Сверить с SDLPoP:** `goto_other_room` (seg002) — как именно
-пересчитываются `Char.curr_row`/`Char.y` при side-переходе (left/right).
-Для вертикального перехода мы это сделали, для бокового — нет.
+Ниже — то, что осталось открытым после прогона 2026-08-07.

-## BUG-2. Возврат из комнаты назад: Kid отбрасывается обратно (ping-pong)  — **Critical**
+<a id="bug-cheat-fight-1"></a>
+## BUG-CHEAT-FIGHT-1. Чит `+`/`−` в бою: Кид остаётся в режиме боя и теряет управление

-**Симптом:** после перехода в соседнюю комнату попытка сразу вернуться
-обратно приводит к тому, что Kid снова закидывается в ту же комнату —
-переход «пинг-понгует», выйти нельзя.
+**Наблюдение (пользователь, 2026-08-07).**  Если нажать `+`/`−` (ROOMNAV,
+переход по комнатам) в момент, когда Кид вытащил меч для битвы, — в новой
+комнате Кид не управляется: нажатия стрелок игнорируются.

-**Где:** `pop_map.c` `check_leave()`.  После перехода Kid репроецирован к
-ПРОТИВОПОЛОЖНОЙ кромке новой комнаты (`x ∓ 140`).  На СЛЕДУЮЩЕМ же кадре
-передний край снова за порогом ухода в обратную сторону → `pop_leave_dir`
-взводится опять → мгновенный обратный переход.  Нужен guard «только что
-перешёл» (подавить повторный leave на N кадров / пока Kid не отойдёт от
-кромки), как в оригинале (`next_room`/leave обрабатываются раз за кадр +
-Kid входит достаточно внутрь).
+**Корень (прочитан по коду, сверен с seg005).**  Чит ROOMNAV
+(`roomtest.c:576`) телепортирует и сбрасывает позу и HP —
+`enter_room()`, `kid_init(SEQ_STAND, …)`, `pop_kid_hp_reset()`, — но **не
+трогает состояние боя**: `Kid.sword` остаётся `SWORD_2_DRAWN`.  Диспетчер
+`pop_control` (`pop_ctrl.c:578`) при вынутом мече уходит в
+`control_with_sword`, а там единственный выход из режима боя —

-**Сверить с SDLPoP:** порядок `leave_room`/`goto_other_room` + на какой
-X ставится персонаж при входе (должен быть НЕ на самой кромке, иначе
-мгновенный обратный триггер).
+```c
+if (Char.frame == FRAME_171_STAND_WITH_SWORD) {   /* seg005:987 */
+    Char.sword = SWORD_0_SHEATHED;
+    seqtbl_offset_char(SEQ_92_PUT_SWORD_AWAY);
+}
+```

-## BUG-3. Climb-up на тайл-кнопку: неправильная окклюзия (Kid поверх кнопки)  — **Critical**
+Стража в новой комнате нет (`can_guard_see_kid` = 0), кадр после
+`kid_init(SEQ_STAND)` — обычная стойка, а не 171, поэтому не срабатывает ни
+`swordfight()`, ни ветка «убрать меч»: `control_with_sword` каждый кадр
+не делает НИЧЕГО, и ввод не доходит до движения.  Заклинивание вечное.

-**Симптом:** когда Kid подтягивается (climb-up) на тайл, верх которого —
-КНОПКА (opener/closer), а не обычный пол, отрисовка неверная: Kid рисуется
-ПОВЕРХ кнопки, хотя передняя грань пола/кнопки должна перекрывать нижнюю
-часть Kid во время подъёма.
+Это баг **нашего чита**, а не порта: в оригинале телепорта между комнатами
+нет, и в режим боя без соперника попасть нечем.

-**Где:** `pop_bg.c` `climb_overlay_tile()` — floor-overlay при подъёме
-рисуется только для floor-подобных тайлов `code ∈ {1,3,5,19}`.  Кнопка
-(opener 0x0F / closer 0x06) в этот набор НЕ входит → пол-оверлей кнопки не
-рисуется поверх Kid.  Нужно: для нажатой кнопки (draw как floor/stuck)
-трактовать её как floor-тайл в climb-overlay (учесть подстановку из
-`get_tile_to_draw`), и/или добавить opener/closer в набор.
+**Как чинить.**  В ветке ROOMNAV телепорт трактовать как выход из боя (то же
+самое, что делает `pop_start_level`): `Kid.sword = SWORD_0_SHEATHED`,
+`holding_sword = 0`, сбросить `offguard`/`guard_refrac` и состояние стража
+(`pop_guard_reset()` вызывается по входу в комнату — проверить, что он
+обнуляет `Opp`).  Меч в инвентаре (`pop_have_sword`) при этом НЕ терять.
+Второй кандидат на ту же болезнь — чит `K` (убить стража) в момент, когда
+Кид в стойке с мечом, но не в кадре 171: там оригинал сам доводит до 171
+через `swordfight`, так что проверить сценарием, а не менять вслепую.

-**Сверить с SDLPoP:** `draw_floor_overlay` (seg008) + `get_tile_to_draw`
-(нажатая кнопка → tiles_1_floor / tiles_5_stuck) — оверлей должен идти по
-ПОДСТАВЛЕННОМУ типу тайла.
+<a id="bug-spike-1"></a>
+## BUG-SPIKE-1. Пики залипают выдвинутыми — НИЗКИЙ ПРИОРИТЕТ, МАЛОВОСПРОИЗВОДИМ
+
+> **Статус 2026-08-05, вечер.**  Пользователь **повторить не смог**, а замер
+> (ниже) показал, что чистый пробег по убранным пикам убивает штатно.  То
+> есть в смертельности бага, похоже, нет вовсе: наблюдался частный случай —
+> пики, УЖЕ выдвинутые полностью (h = 1), для бегущего безвредны и в
+> оригинале.  Запись оставлена открытой ровно из-за визуального расхождения
+> со скриншотом SDLPoP (у нас острия торчат, у него убраны) — см. конец.
+>
+> **Как получить состояние нарочно:** подойти к пикам вплотную (выдвинутся),
+> отступить на полшага, НЕ выходя из зоны срабатывания, и пробежать по ним.
+> Пользователь пробовал и это, и попиксельную подгонку X читом `[`/`]` —
+> не поднялось.  Вывод для будущего разбора: состояние **не чисто
+> позиционное**, одной шириной габарита его не объяснить; следующий
+> подозреваемый — момент, в который `process_trobs` застаёт модификатор
+> относительно кадра Кида.
+
+**Наблюдение (пользователь, 2026-08-05).**  Уровень 2, комната 6, пики (1,3):
+
+| действие | что происходит |
+|----------|----------------|
+| длинный прыжок с ряда 0 на пики | **смерть — правильно** (путь `fell_on_spikes`) |
+| пробег по ряду 1 прямо по пикам | **урона нет** |
+| после уборки пик | **на экране остаются белые остатки остриёв** (в оригинале чисто) |
+| прыжок на месте, стоя на пиках | урона нет |
+| просто стоять на выдвинутых пиках | можно сколько угодно |
+
+**Замер (MAME, чтение `room_modif` комнаты 6).**  Пока Кид стоит на тайле,
+модификатор пики (индекс 13) = **0x8E**, то есть «пики ПОЛНОСТЬЮ вышли и
+идёт обратный отсчёт».  Дальше вся арифметика сходится с оригиналом:
+
+```
+is_spike_harmful (seg007:1178):  0/-1 → 0;  <0 → 1;  1..4 → 2;  >=5 → 0
+check_spiked     (seg006:0658):  убивает при h>=2 на кадрах бега 7..14
+                                 и при h!=0 на кадрах приземления 43/26
+```
+
+То есть **при h = 1 (пики уже вышли) бегущий не гибнет и в оригинале** —
+смертельно только окно ВЫДВИЖЕНИЯ (модификатор 1..4, h = 2).  Наши
+`animate_spike`, `start_anim_spike`, `is_spike_harmful`, `check_spiked`
+сверены с seg006/seg007 построчно и совпадают дословно.
+
+**ВТОРОЕ НАБЛЮДЕНИЕ (то же место, сравнение с оригиналом).**  Кид уронил
+плиту-потолок и спрыгнул вниз; пики выдвинулись и «спрятались не все — часть
+артефактов осталась».  Скриншоты рядом:
+[наш](bugscreens/l2-r6-spikes-ours.png) и
+[SDLPoP](bugscreens/l2-r6-spikes-sdlpop.png) в той же позе.  У нас из-под
+щебня торчат белые острия, у оригинала пик не видно ВООБЩЕ.
+
+**ГИПОТЕЗА «ТРИГГЕР СРАБАТЫВАЕТ РАНО» ПРОВЕРЕНА И ОПРОВЕРГНУТА (замер
+2026-08-05, MAME, watchpoint на `room_modif[13]` комнаты 6).**  Чистый
+пробег по УБРАННЫМ пикам убивает штатно:
+
+```
+запись modif=1 : кадр 11 (беговой), x=112, curr_col=2   ← пики пошли вверх
+запись modif=2 : кадр 12 (беговой), x=117, curr_col=3   ← Кид уже НА тайле, h=2
+запись modif=3 : кадр 177 (frame_177_spiked)            ← напоролся
+```
+
+То есть `check_spike_below`, `check_spiked`, `is_spike_harmful` и тайминг
+выдвижения работают правильно, и «раннего» триггера нет.
+
+**Настоящий корень — пики ЗАЛИПАЮТ выдвинутыми.**  Пока габарит Кида
+накрывает колонку пики, `check_spike_below` каждый кадр зовёт
+`start_anim_spike`, а тот при отрицательном модификаторе переставляет его
+обратно в 0x8F — отсчёт до уборки не доходит.  А выдвинутые пики (h = 1)
+для бегущего БЕЗВРЕДНЫ по правилам оригинала.  Отсюда обе жалобы: пробег
+по уже вышедшим пикам не убивает, и они же остаются торчать на экране.
+
+**Что осталось выяснить (и это единственный открытый вопрос).**  Код
+`start_anim_spike` у нас с оригиналом совпадает дословно, значит оригинал
+тоже удерживал бы пики, стой Кид там же.  На скриншоте SDLPoP в похожей
+позе пики УБРАНЫ — то есть его Кид стоит чуть левее и его габарит колонку
+пики уже не задевает.  Разница в 2–3 пикселя посадки, а у нас такие
+расхождения по X уже ловились (см. заметку в BUG-GRAB-1: после касания
+площадки SDLPoP уводит Кида на 134, мы — на 141).
+
+**Как закрывать:** инструментировать SDLPoP (печать `char_x_left/right`,
+`left/right_checked_col` и модификатора пики каждый кадр), проиграть ту же
+сцену — падение плиты-потолка в комнате 6 и остановку на щебне — и сверить
+с нашей трассой ПОЗИЦИЮ КИДА после приземления.  Если позиции совпадут, а
+диапазоны колонок разойдутся — виноват габарит (`kid_fp` против
+`set_char_collision` текущего кадра); если разойдутся позиции — это отдельный
+баг посадки, а пики — его следствие.

 ---

-## Оптимизации (отложено)
+<a id="уровень-3"></a>
+# Уровень 3 — не баги, а неначатые задачи

-### OPT-1. Хирургический редрой левого шва (ворота соседа)  — 2026-07-22
+Smoke-прогон уровня 3 (пользователь, 2026-08-05) дал четыре наблюдения.  Два
+были настоящими багами и **закрыты в тот же день** (разбор — в
+[`bug_closed.md`](bug_closed.md): **BUG-JUMPWALL-1** и **BUG-SEAM-WEDGE-1**).
+Оставшиеся два — не баги, а неначатые задачи:

-**Возможность:** `pop_room_redraw_seam_left()` (pop_bg.c) на каждое изменение
-openness рисует `bar(BLACK)` по всему col0 + **полный `draw_tile(0,0)`**
-(стены, `topright`, `wall_pattern` с `prandom()` — десятки блитов).  Реально
-анимируются только бары решётки — `draw_gate_back` (~9 `env_b`).
+| наблюдение | что это на самом деле |
+|------------|------------------------|
+| к.22: чомпер (2,6) не анимируется и **вообще не рисуется** | [L3-CHOMP](TASKS_OPEN.md#l3-chomp) — механики чомперов НЕТ.  В таблице тайлов `pop_bg.c:211` строка `12 chomper` рисует только основание, правую грань и низ; самих челюстей (спрайт из `chtab`, `draw_tile_anim` seg008) нет вовсе.  Так и должно выглядеть до порта |
+| к.10: скелет не оживает | [L3-SKEL](TASKS_OPEN.md#l3-skel) — `check_skel` (seg002:0E1F) не портирован.  **И комната другая:** тайл `skeleton(21)`, который оживает, лежит в **к.1 (1,5)** — это `skeleton_room=1, skeleton_column=5, skeleton_row=1`.  Ещё два скелета уровня (к.17 (2,7), к.19 (2,2)) — просто декорация, они не оживают никогда.  Плюс условие: скелет встаёт, только когда **дверь уровня уже открыта** и Кид стоит в колонке 2 или 3 |

-**Стоимость:** seam-блок (синий io_border) занимает ~30-50% кадрового периода,
-**но только пока openness меняется** — т.е. во время открытия и медленного
-авто-закрытия (~5 сек после схода с кнопки).  В покое (ворота открыты-держим
-кнопку / закрыты / FF) — 0%.  Замерено в MAME: брейк на
-`_pop_room_redraw_seam_left` (0x5A54) срабатывает ⟺ сегмент дорогой.
-
-**Приём** (как у пик, но сложнее — heal НЕ годится: печёные бары устаревшие,
-поэтому и стоит `bar(BLACK)`+redraw): `bar(BLACK)` только по полосе баров
-(x=0, gate_top..gate_bot) + `draw_gate_back(lmod,...)` + дорисовать статику
-тайла (0,0), задетую полосой.  Ожидаемо срезает бóльшую часть 30-50%.
-**Пиксель-чувствительно** — полоса баров пересекается со статикой col0,
-обязательна выверка в MAME по кромкам.
-
-**Решение (2026-07-22):** оставляем как есть — стоимость транзиентная, в бюджет
-помещаемся.  Делать, если упрёмся в кадровый бюджет на сценах с воротами.
+Приёмки уровня 3 (полного обхода комнат) ещё не было — она осмысленна только
+после L3-CHOMP/L3-SKEL.

 ---

-## Исправлено
+# Открытые баги уровня 1

- **Спуск с кнопки (room8, кромка (0,6)): Кид просвечивал в щель, ближняя рука
-  срезана до одного пикселя** — ИСПРАВЛЕНО 2026-07-28.  Две причины:
-  (а) не был портирован `clip_char()` (seg006:1749) — верхняя обрезка спрайта по
-  `y_clip[curr_row+1]`, когда тайл над головой стена/пол; сделано
-  (`pop_clip_char_top` в pop_map.c + `gfx_blit_cols_part` в libbgi, heal чистит
-  уже обрезанный прямоугольник);
-  (б) `climb_overlay_tile` выбирал ветку `draw_floor_overlay` (seg008:1E3A) по
-  СЫРОМУ коду тайла — а нажатая кнопка в `get_tile_to_draw` (seg008:240)
-  подменяется на floor/stuck.  Тайл-кнопка не проходил тест floor, уходил в
-  `draw_other_overlay` и закрашивал Kid ЦЕЛЫМ тайлом вместо узкой кромки
-  `floor_left_overlay[frame-137]`.  Фикс — `tile_code_drawn()` (одна подстановка
-  на все слои).  Проверено покадрово в MAME (кадры 148..138).
+<a id="bug-gate-pass-1"></a>
+## BUG-GATE-PASS-1. Проход сквозь закрывшуюся решётку — ЖДЁТ СЦЕНАРИЯ

- **Шов ворот жёг 50% кадра в покое (закрытая решётка)** — ИСПРАВЛЕНО
-  2026-07-22.  Причина — **баг кодогенератора SDCC z80** (memory
-  `sdcc_z80_cmp_store_a_bug`): `if (m[9] != seam_sig) seam_sig = m[9];`
-  компилировался в `sub (seam_sig)` (A ← разность) + `ld (seam_sig),a` —
-  сохранял РАЗНОСТЬ `m[9]-seam_sig`, не `m[9]`.  `seam_sig` осциллировала
-  (напр. 25↔231), `m[9]!=seam_sig` истинно каждый кадр → `draw_tile(0,0)`
-  каждый кадр даже у неподвижной решётки.  Фикс: store-до-сравнения
-  (`seam_sig = g;` из чистого `g` ДО `sub`), подтверждён в .asm.  Прочёс всех
-  модулей PoP: других случайных compare-then-store нет.
+**Статус: наблюдался один раз (2026-08-03), воспроизвести не удалось ни
+тогда, ни прогоном всех комнат уровня 1 (2026-08-07).**  Заведён, чтобы
+наблюдение не потерялось; закрывать нельзя — ни как исправленный, ни как
+«не баг», пока нет надёжного сценария.  Оговорка: BUG-GATEMOD-1, из-за
+которого решётка стартовала не в том состоянии, с тех пор закрыт, и
+наблюдение могло быть его следствием.

- **Пики: 2×полный `draw_tile` на кадр анимации** → хирургический редрой,
-  2026-07-22.  `pop_spike_redraw`: `heal_off` уже возвращает всю печёную
-  статику (база 127, пол, грани); поверх анимируются только два острия
-  (`SPIKES_FRAM_LEFT` в своей ячейке + `SPIKES_FRAM_RIGHT` в соседней).
-  Заменили 2×`draw_tile` на 2×`env_b` — пиксель-в-пиксель тот же результат,
-  в разы дешевле (шахта из нескольких пик больше не съедает полный кадр).
+**Что наблюдалось.**  Комната 5: Кид стоял НА тайле решётки (0,9)
+и ждал, пока она опустится.  После закрытия пошёл вправо — прошёл в комнату 1
+и упал на (1,1).

- **Отрисовка нажатой кнопки (0,2)/(0,3)** — ИСПРАВЛЕНО.  Причина: `fore_tile`
-  (pop_bg.c, fore-слой поверх Kid) рисовал переднюю грань КНОПКИ (bottom_id
-  149) поверх уже нарисованной грани пола (43) — «остаток нажатой кнопки».
-  Фикс: `fore_tile` применяет ту же подстановку нажатой кнопки, что и
-  `draw_tile` (opener→floor / closer→stuck при таймере связи >1).  Плюс
-  `pop_button_redraw` — wipe своей ячейки + правой грани (дальний угол в
-  0,3), низ строго yb+64 (не залезать в стену ряда 1).
+**Что уже измерено и в чём загвоздка.**  Сразу после наблюдения повторить не
+получилось: в том же месте Кид стоит на `x = 196`, `col = 9`, и решётка его
+ДЕРЖИТ — то есть штатно.

-## Заметки
+Арифметика оригинала объясняет разницу.  `is_obstacle` (seg004) ставит
+плоскость блокировки в `x_bump[col + FIRST_ONSCREEN_COLUMN] + TILE_MIDX`, для
+колонки 9 это **x = 205**.  При этом «колонка 9» по `get_tile_div_mod_m7` —
+это `x ∈ [191, 205)`.  Пока `curr_col == 9`, Кид гарантированно левее
+плоскости и обязан блокироваться; чтобы пройти, он должен оказаться **правее
+205**, то есть уже на дальней стороне решётки, — и тогда уход вправо законен:
+решётка закрылась у него за спиной, в оригинале она блокирует плоскость, а не
+весь тайл.

- Тестовые клавиши осторожного шага: **J** = шаг влево, **L** = шаг вправо
-  (эмуляция Shift+стрелка), см. `pop_ctrl.c` `KBD_DBG_STEP*`.  Первый шаг в
-  сторону = разворот (как в оригинале safe_step), движение со второго.
- Респавн после смерти — по **↑** (или авто через `RESPAWN_DELAY`).
- `START_ROOM=6` — временный тестовый старт; вернуть на
-  `pop_level_start_room()` после отладки объектов.
+Отсюда рабочая гипотеза: в момент наблюдения Кид стоял правее 205 (успел зайти
+по тайлу дальше, пока решётка была поднята), и поведение штатное.  Но повторить
+эту позу и снять `x` пока не удалось, поэтому гипотеза НЕ подтверждена.
+
+**Что снять в следующий раз** (без этих чисел вопрос не закрыть):
+
+1. `Kid.x` и `Kid.curr_col` в момент, когда решётка уже закрылась, а Кид ещё
+   стоит на её тайле — до шага вправо;
+2. модификатор решётки (openness) комнаты 5, тайл 9 — `can_bump_into_gate()`
+   считает её препятствием только пока `(modif >> 2) + 6 < char_height`, то
+   есть пока она опустилась достаточно низко относительно РОСТА кадра;
+3. `Kid.x` покадрово на самом шаге вправо — где именно перестал блокировать.
+
+Быстрый способ снять первое: отладочный стоп-кадр (**1** заморозить, **2**
+продолжить), затем чтение `_Kid` из отладчика MAME; подгонка позы по пикселю —
+читы `[`/`]`.
+
+**Возможный корень, если гипотеза не подтвердится.**  Проверка идёт по колонке,
+которая на шве уже принадлежит СОСЕДНЕЙ комнате (`curr_row_coll_room[]` в
+оригинале); у нас межкомнатная коллизия на шве — исторически проблемное место
+(ср. закрытый BUG-SEAM-PINGPONG).  Второй кандидат — `char_height` в
+`can_bump_into_gate()`: если он берётся не от того кадра, решётка может
+перестать считаться препятствием раньше времени.

 ---

-## BUG-CEIL-1. Прыжок вверх: руки Kid рисуются ПОВЕРХ потолка  — **Medium**
-
-**Симптом (2026-07-22):** при прыжке вверх (SEQ up, кадры 67..79) руки/голова
-Kid заходят в полосу кладки у потолка (row -1) и рисуются ПОВЕРХ неё — потолок
-должен окклюдить руки (как передняя грань).
-
-**Где:** `pop_bg.c` — полоса потолка (`draw_tile(-1)`) сейчас только фон
-(запечена в pop_room_draw), не окклюдер поверх Kid.  Нужен ceiling-overlay в
-`pop_fore_over_kid` (перерисовать срез полосы над Kid поверх спрайта), по
-аналогии с fore-тайлами.  Инфраструктура `g_clip_top`/`gfx_blit_part` уже есть.
-
-## BUG-CEIL-2. Тряска/разбитие loose-плиты в потолке (row -1) не работает  — **Medium**
-
-**Симптом (2026-07-22):** loose-плита в ряду 2 верхнего соседа (room5 (2,5) →
-потолок room6 над (0,5)) при прыжках Kid на (0,5) НЕ трясётся и не разбивается.
-
-**Где:** верхний сосед не «живой» — `above_fg` берётся из статики уровня,
-loose-состояние соседней комнаты не тянем (per-room loose/modif не персистятся,
-P0).  check_press/knock работают только по текущей комнате.  Нужно: (а) пробой
-loose сверху через границу комнаты, (б) персистентное loose-состояние соседа +
-его отрисовка в полосе.  Пока полоса рисует loose статически (кадр покоя).
-
-## BUG-OCCL-1. Тень дальней колонны перекрывает Kid в (0,4)-(0,5)  — **Medium**
-
-**Симптом (2026-07-22):** Kid, стоя/прыгая у (0,4)-(0,5), частично перекрыт
-тёмной штриховкой — это ТЕНЬ/боковая грань ДАЛЬНЕЙ колонны (сзади по глубине),
-которая НЕ должна окклюдить персонажа.  Over-occlusion fore-слоя.
-
-**Где:** `pop_bg.c` `pop_fore_over_kid`/`fore_tile` — рисует fore футпринт-тайлов
-без учёта глубины (какая грань РЕАЛЬНО перед Kid).  Порт seg003 redraw_at_char
-окклюдит только передние грани; дальняя колонна (за Kid) не должна.  Сверить с
-SDLPoP redraw_at_char (какие тайлы/грани идут в fore vs back по y-сортировке).
-
-## BUG-CEIL-3. Анимация ворот стирает потолок над ними  — **Medium**
-
-**Симптом (2026-07-22):** при опускании/поднятии решётки шва (анимация openness)
-полоса кладки у потолка НАД воротами пропадает (см. потолок над левым швом).
-
-**Где:** `pop_bg.c` `pop_room_redraw_seam_left` (и `pop_button_redraw`/
-`pop_spike_redraw` — общий класс): чёрный `bar` по col0 row0 стирает потолочную
-полосу (row-1), а redraw рисует только сам гейт, не восстанавливая полосу.
-Нужно: при перерисовке шва/тайла у потолка перерисовать и срез потолочной полосы
-(draw_tile(-1,col) с g_clip_top) над затронутыми колонками.
-
---
-
-# BUG-SEAM-PINGPONG (#4). Пинг-понг drawn_room у шва с закрытыми воротами — **РЕШЁН 2026-07-22**
-
-Статус: 2026-07-22, вечер.  НАСТОЯЩИЙ корень найден потиковой трассой ЖИВОГО
-SDLPoP 1.23 (lldb-брейкпоинты на leave_room/bumped/safe_step с логом Char +
-char_x_left/right; fixes выключены = vanilla).  Все прежние гипотезы ниже
-оставлены для истории — они НЕ были причиной.
-
-## КОРЕНЬ (подтверждён трассой + исходником)
-
-`set_char_collision` (seg006:0723): `char_x_right = obj_x/2 + 58`, где
-`load_frame_to_obj` (seg008:1728) считает `obj_x = 2*char_dx_forward(dx) - 116`
-и **добавляет +1** для кадров «чётного пикселя»:
-`if ((sbyte)(cur_frame.flags ^ obj_direction) >= 0) ++obj_x;`
-(бит 0x80 флагов кадра XOR направление; вправо: +1 если бит НЕ стоит).
-Деление `obj_x/2` — C-усечение К НУЛЮ, поэтому при `e = x+dx <= 57`
-(obj_x < 0, зона левого шва) поправка +1 даёт `char_x_right = e+1`, а при
-e >= 58 формула сокращается к чистому `e`.
-
-Итог: Kid, осевший после отскока от ворот шва на x=57 (frame15, флаги 0x43 —
-бит 0x80 не стоит), имеет **char_x_right = 58** и порога leave-left (<=57)
-НЕ достигает.  Наш движок считал передний край как `Kid.x + dx` без поправки
-→ 57 → ложный leave → пинг-понг.
-
-Эталонный цикл SDLPoP (сн normalized по трассе): стойка x=61 → тап вправо →
-safe_step(d=0) → step, на первом dx(1) x=62 → bump (edge-триггер) → align 61 →
-seq47 dx(-4) → **x=57** (скрыт за кромкой) → кадры 50/51/52 (cxr 61/60/58, у
-всех бит 0x80 снят, e>57 — без сдвига) → стойка cxr=58 → leave НЕ срабатывает;
-тап → safe_step d=3 → x=60 (1/3 видно); тап → step1 → x=61 (2/3 видно); тап →
-bump → 57 … по кругу.  Char.room и drawn_room НЕ меняются вообще.
-
-## Фикс (pop_map.c)
-
-`char_x_forward_edge()`: `e = char_dx_forward(dx); if (((flags ^ (dir<0 ?
-0x80 : 0)) & 0x80) == 0 && e <= 57) e++;` — используется в `char_front_coll`
-(коллизия/bump/edge_distance) и в `check_leave` (порог ухода).  Плюс порт
-doortop-гарда leave-right из leave_room (тайл (9,row) = doortop → правого
-выхода нет).  `pop_leave_timer` (exit_room_timer) оставлен — он реален в
-seg002/seg003.
-
-## Гипотезы, ОТПАВШИЕ после трассы (история диагноза)
-
-## Симптом (подтверждён пользователем + инструментально)
-
-Kid стоит за решёткой закрытых ворот шва (левый сосед room8 виден в кромке
-room6).  При удержании/нажатии ВПРАВО экран пинг-понгует между двумя
-состояниями:
- **A**: показывается room6, Kid у левой кромки за решёткой (спрайт виден на 2/3);
- **B**: показывается room8, Kid у его правой кромки.
-
-Эталон SDLPoP (описан пользователем): drawn_room **всегда остаётся room6**,
-Kid осциллирует у кромки (1/3→2/3→отступил→по кругу), в room8 экран НЕ
-переключается.  То есть у нас лишний свитч A→B.
-
-## Тестовый контекст
-
-START_ROOM=6.  Ворота room8(0,9) закрыты, видны в col0 room6.  Kid-структура
-kframe: см. pop_kid.h (frame,x,y,direction,curr_col,curr_row,action,...).
-Адрес _Kid и статиков — в .sprinter-cc-roomtest/roomtest.map (сдвигается от
-сборки к сборке).  MAME: memory `mame_mcp_bridge`/`mame_hdd_test_disk`.
-Отладочные: J/L — короткий шаг влево/вправо (эмуляция Shift+стрелка).
-
-## Инструментальный диагноз (watchpoint на pop_leave_dir)
-
-В момент лишнего свитча A→B: `pop_leave_dir=1 (LEFT)`, Kid **frame=15 (СТОЯ,
-не transient!), Kid.x=57** (до репроекции +140).  То есть:
- `char_x_right = char_dx_forward(kid_cur_dx()) = Kid.x + frame15.dx = 57+0 = 57`.
- Порог leave-left (взгляд вправо): `char_x_right <= 57` → срабатывает РОВНО на 57.
- Грань ворот (где их держит коллизия) = **61** (`wall_dist_from_left[1]=10 +
-  coll_tile_left_xpos=51`).  Между 57 и 61 — **зазор 4px**: Kid НЕ удержан
-  воротами (d=61−57=4≥0 → check_bumped не бампит), но уже на пороге ухода.
- Kid оседает на 57 из-за recoil отскока: seq_47 = `act(bumped), dx(-4),
-  frame_50, 51, 52`; SEQ_DX(−4) двигает Char.x на −4 суммарно; frame_50.dx=4
-  компенсирует ТОЛЬКО точку коллизии НА кадре 50, но при возврате в стойку
-  (frame15, dx=0) `char_x_right = Char.x = aligned−4 = 57`.
-
-## Что ИСКЛЮЧЕНО (сверено с исходниками SDLPoP, НЕ причина)
-
- Формула char_x: `char_x_right = obj_x/2+58 = Char.x+frame.dx` (seg006
-  set_char_collision) — совпадает с нашим char_dx_forward.
- Позиция грани ворот: `get_left_wall_xpos = wall_dist_from_left[1](10) +
-  xpos_in_drawn_room(x_bump[9+5])+7 = 10+(184−140)+7 = 61` — совпадает с нашим
-  (`x_bump[−1+5]=44`, +7, +10 = 61).
- Порог leave: SDLPoP leave_room looking-right `char_x_right<=57` — совпадает.
- Данные кадров: frame_50 (image=49,dx=4,flags=0x67) и frame_15
-  (image=14,dx=0,flags=0x43,sword=9) — БАЙТ-В-БАЙТ как в SDLPoP frame_table_kid.
- seq_47 (act bumped, dx(-4), frame 50/51/52) — совпадает.
-
-## Почему точечные фиксы НЕ работают
-
- Гард в check_leave (подавить leave на закрытых воротах) — это ОТСЕБЯТИНА,
-  не SDLPoP (в leave_room такого нет); откачено.
- `exit_room_timer=2` (порт seg002 exit_room — РЕАЛЬНЫЙ механизм, оставлен как
-  pop_leave_timer): блокирует leave 2 кадра после входа в комнату.  НЕ спасает:
-  положение Char.x=57 **устойчивое** (Kid стоит), а не transient — после
-  истечения таймера leave срабатывает.
- По коду SDLPoP raw-рассуждением раз за разом выходит, что leave-left ДОЛЖЕН
-  сработать и там (Char.x=57), но эталон показывает, что нет.  Значит различие
-  не в этих кусках, а в ДИНАМИКЕ: где именно оседает Char.x у шва И как
-  вычисляется drawn_room.
-
-## КОРЕНЬ (гипотеза)
-
-Наш движок держит `drawn_room == комната_Kid` ВСЕГДА, а шов подделан:
- коллизия — самодельные снапшоты кромок соседа (g_lcol/g_rcol, 1 колонка) +
-  `x_bump[tcol=-1]`, а НЕ порт `curr_row_coll_room[]`/`get_all_coll_row`/
-  `xpos_in_drawn_room` из seg004;
- уход — мгновенный `enter_room(сосед)` при пороге char_x, а НЕ отложенный
-  drawn_room через `next_room`/`check_the_end`.
-
-Из-за упрощённой коллизии Char.x у шва оседает иначе, чем в SDLPoP (у нас ровно
-57 = порог), и/или drawn_room переключается там, где в оригинале нет.
-
-## План S2/S3 (порт coll_room + отложенный drawn_room) — НЕ потребовался для
-## этого бага (трасса показала: в эталоне Char.room/drawn_room вообще не
-## меняются).  Остаётся как задел под стражей/двух персонажей в кадре.
-
-Правило проекта: SDLPoP — источник истины, переводить 1:1, НЕ рассуждать «как
-должно быть».  Нужно портировать связку целиком:
-
-1. **Раздельные комнаты.**  `Char.room` (реальная комната персонажа) ≠
-   `drawn_room` (отрисованная).  У нас уже есть `kid_room` (S1) + рендер-смещение
-   `pop_kid_set_render_dx(∓140)` (порт xpos_in_drawn_room для СПРАЙТА).
-
-2. **Коллизия по Char.room через coll_room (seg004, S2).**  Портировать
-   `check_collisions` → `get_row_collision_data` (строки curr/below/above) →
-   `get_left_wall_xpos`/`get_right_wall_xpos` (по `xpos_in_drawn_room(x_bump[
-   col+FIRST_ONSCREEN_COLUMN])`, ±140 когда колонка принадлежит соседу) →
-   массивы `curr_row_coll_room[]`/`_flags[]`, `bump_col_left_of_wall`/
-   `bump_col_right_of_wall` → `check_bumped_look_left/right` → `bumped()`.
-   Тайлы берутся из РЕАЛЬНОЙ комнаты колонки (get_tile(room,col,row) для любой
-   комнаты), НЕ из снапшота.  Именно это определяет, где Char.x оседает у шва.
-
-3. **Отрисовка по drawn_room, персонаж со сдвигом.**  Рисуем drawn_room; Kid
-   (и будущие стражи) — со смещением ±140, если их комната ≠ drawn_room.
-
-4. **Отложенная смена drawn_room (seg002/seg000, S3).**  Уход =
-   `leave_room` (seg002:0504, ПОРТ ЦЕЛИКОМ, включая up/down/side, guard'ы
-   climb/standup/turn, doortop-check для right) → `goto_other_room`
-   (seg002:0486: Char.room=сосед, x±140/y±189).  `exit_room` (seg002:03C7):
-   `exit_room_timer` + `next_room = Char.room`.  `check_the_end` (seg000:0FBD):
-   `if (next_room != 0 && next_room != drawn_room) drawn_room = next_room;
-   redraw`.  drawn_room меняется ТОЛЬКО так, а не по нашему прямому enter_room.
-
-Ключевой момент, который надо переводить БУКВАЛЬНО (а не выводить): порядок
-вызовов в play_frame (seg000:863 `play_frame`: … play_kid_frame → exit_room →
-check_the_end) + set_char_collision перед leave_room в exit_room.
-
-Карта сегментов: seg002 (leave/goto/exit_room), seg004 (коллизия/coll_room/
-bumped), seg006 (set_char_collision/play_seq/frame_table_kid), seg000
-(play_frame/check_the_end/draw).  Наши файлы: pop_map.c (коллизия/физика/leave),
-roomtest.c (enter_room/drawn_room/главный цикл), pop_kid.c (кадры/рендер-сдвиг).
-
-Реализовано на 2026-07-22: S1 (kid_room + render_dx) + pop_leave_timer.
-S2/S3 отложены — баг закрыт odd-pixel поправкой (см. КОРЕНЬ выше).
-Память: [[pop_seam_room_model]], [[sdlpop_odd_pixel_char_x]].
-
---
-
-# TODO: оптимизация отрисовки (записано 2026-07-29)
+# Оптимизация отрисовки (записано 2026-07-29)

 Не баги — план работ.  Оба пункта про одно: у оригинала пометка тайла к
 перерисовке стоит копейки (бит в таблице, которая всё равно чистится каждый
@@ -355,6 +252,7 @@ S2/S3 отложены — баг закрыт odd-pixel поправкой (с
 ОЗУ-копии акселератора) плюс блиты.  Поэтому буквальный порт «перерисовываем
 безусловно» корректен, но дорог.

+<a id="t-1"></a>
 ## T-1. Пики: перерисовывать по причине, а не безусловно

 **Сейчас:** `pop_process_trobs` зовёт `pop_spike_redraw` каждый кадр для
@@ -378,6 +276,9 @@ S2/S3 отложены — баг закрыт odd-pixel поправкой (с
 сравнивает `tilepos` с диапазоном целочисленно.  Никаких пересечений
 прямоугольников (см. память `manual_hints_over_auto_detect`).

+**Приоритет:** отдаётся почти бесплатно ПОСЛЕ T-2, отдельно не окупается.
+
+<a id="t-2"></a>
 ## T-2. Idle-skip: не перерисовывать Кида, когда ничего не происходит

 **Сейчас:** `kid_heal` → `kid_draw` → `pop_fore_over_kid` идут каждый кадр,
@@ -392,43 +293,29 @@ S2/S3 отложены — баг закрыт odd-pixel поправкой (с
 неизменного кадра — иначе одна из двух страниц останется со старым
 содержимым.  Условие «обе страницы уже получили это состояние».

-**Связь с T-1:** после T-1 idle-skip не требует ничего дополнительного для
-пик: раз Кида не перерисовываем — heal'а нет — стирать пики нечем — редрой
-не нужен, он отпадает сам.
+**Связь с T-1:** после T-2 пики отпадают сами — раз Кида не перерисовываем,
+heal'а нет, стирать пики нечем, редрой не нужен.
+
+**Связь с KBD-1:** это ещё и минус DI-окна в самых спокойных кадрах — ровно
+там, где тапают Shift+стрелку (остаток KBD-1 отложен, см.
+[`TASKS_CLOSED.md`](TASKS_CLOSED.md#kbd-1)).

 ---

-# Обход всех 24 комнат уровня 1 — поиск багов отрисовки
+## Заметки (отладка)

-Инструмент: `#define ROOMNAV` в `roomtest.c` — `+`/`-` (цифровой блок либо
-`=`/`-` основного ряда) переключают комнату по номеру (1..24, с обёрткой),
-Kid ставится на первый пол, `pop_trob_reset()` возвращает пики/ворота в
-исходное.  Номер комнаты — полосками в верхнем борте: слева десятки, справа
-единицы (`||` `||||` = 24).  Убирается закомментированием одной строки.
-
-| комната | статус | что не так |
-|---------|--------|------------|
-| 1 |  |  |
-| 2 |  |  |
-| 3 |  |  |
-| 4 |  |  |
-| 5 |  |  |
-| 6 |  |  |
-| 7 |  |  |
-| 8 |  |  |
-| 9 |  |  |
-| 10 |  |  |
-| 11 |  |  |
-| 12 |  |  |
-| 13 |  |  |
-| 14 |  |  |
-| 15 |  |  |
-| 16 |  |  |
-| 17 |  |  |
-| 18 |  |  |
-| 19 |  |  |
-| 20 |  |  |
-| 21 |  |  |
-| 22 |  |  |
-| 23 |  |  |
-| 24 |  |  |
+- Тестовые клавиши осторожного шага: **J** = шаг влево, **L** = шаг вправо
+  (эмуляция Shift+стрелка), см. `pop_ctrl.c` `KBD_DBG_STEP*`.  Первый шаг в
+  сторону = разворот (как в оригинале safe_step), движение со второго.
+- Читы (`pop_cheat.h`): **K** — убить стража, **I** — бессмертие (toggle),
+  **S** — выдать меч, **Shift+L** — следующий уровень, **`[`/`]`** — сдвиг
+  Кида на пиксель по X.
+- Респавн после смерти — по **↑** (или авто через `RESPAWN_DELAY`); ставит
+  Kid в стартовую позицию УРОВНЯ (`pop_start_level`, порт do_startpos).
+- **ROOMNAV (`=`/`-`) — тоже наш чит**, которого в оригинале не было, как и
+  `S`.  Все они со временем съедутся в общий блок читов, разрешаемый в
+  настройках; пока просто включены (`pop_cheats = 1` в `roomtest.c`).
+  Известный баг этого чита — [BUG-CHEAT-FIGHT-1](#bug-cheat-fight-1).
+- Комнаты **13, 18, 24 уровня 1 недостижимы** в обычной игре — это свойство
+  данных уровня (разбор — «НЕ БАГИ» в [`bug_closed.md`](bug_closed.md));
+  приоритет багов в них низкий.  Аналогично 23/24 на уровне 3.
@@ -0,0 +1,80 @@
+Активные баги на уровне 1 -
+
+- После того как кувшин со здоровьем выпит и Кид попадает в комнату во второй раз
+  то иногда кувшин мы не показываем (это правильно) но показываем анимацию пузырьков над
+  кувшином (чего показывать больше не должны - нет кувшина, нет пузырьков),
+  а в комнате 14 пузырек вообще восстанавливается полностью после того как Кид 
+  выйдет из комнаты и вернется в нее обратно (есть ощущение что даже в одной комнате 
+  поведение пузырька - будет ли он восстановлен или нет зависит от чего-то непонятного.
+  (есть еще ощущение что первый выпитый кувшин не восстанавливается а остальные 
+  восстанавливаются)
+- Меч - один раз подобранный он больше не должен появляться в своей (15-ой) комнате 
+  иногда он появляется снова, иногда он больше не появляется но на дальней стене начинают
+  моргать контуры кирпичной кладки (странно что она не впечатана в heal уровень потому
+  что она должна быть отрисована всегда). причем мерцает по странному - не как double-buff
+  а как буд-то вместо искры на мече - изредка на несколько (один логический?) кадров.
+- комната 12 - опять проблема с телепортацией через решетку - решетка в 0,9 - Кид стоит 
+  за шаг (пол-шага) от решетки - бежит и пробегает через закрытую решетку.
+- после respawn - остаются разбитыми плиты что были разбиты, выпитыми пузырьки и прочее -
+  это надо сравнить с оригиналом (SDLPoP) - но главное другое - если до respawn какая-то
+  плита не была разбита то теперь если ее разбить, выйти из комнаты и вернуться - то 
+  плита восстановится (еще интереснее вариант когда плита-потолок в комнате 12 разбивается,
+  Кид через проем поднимается в верхнюю комнату и поднявшись плита в новой комнате опять
+  закрывает проем. 
+- проблема с плитой из комнаты 12 в верхнюю и пузырек в комнате 22 - они возникают даже 
+  без respawn - когда Кид заходит в комнату 22 из комнаты 16, выпивает пузырек, выходит опять
+  в комнату 16 и опять возвращается в комнату 22 - пузырек возникает снова. Когда Кид разбивает
+  плиту из комнаты 12 в комнату 16 то после подъема в комнату 16 плита опять возникает.
+  аналогично комната 17 - если войти в нее из комнаты 23, разбить плиты 1,5 и 1,6, опуститься на 
+  2,3 и выпить пузырек. вернуться в комнату 23 и опять в 17 - то и плиты вернутся и пузырек.
+  но могут плита и пузырек не вернуться - такое ощущение что если это первая разбитая плита 
+  (Кида мы перенесли в комнату 12 через cheats) - то разбитая плита остается разбитой.
+- комната 6 - Кид бежит по уровню ноль справа налево (начало бега 0,9), делает длинный 
+  прыжок между 0,6 и 0,7 - он пролетает во внутрь стены и респавнится - скриншоты в bugscreens
+- иногда залипают все-таки клавиши (пока замечено на кнопке вверх - отлипает только после
+  следующего нажатия). надо проверить - есть ли возможность не только отслеживать события
+  нажатие/отжатие но и текущий статус нажатых кнопок. Может вообще отказаться от прямой работы
+  с клавиатурой а работать с нею через BIOS ?
+- иногда таки залипает и shift =((((
+- комната 5 - кнопка на 0,4 не открывает решетку/ворота на 0,5 - это двойная кнопка - она 
+  должна сразу открывать ворота на 0,5 и на 0,9 (возможно у нас она работает только на 0,9)
+  возможно что логически решетка на 0,5 открывается но анимации ее открытия нету =(
+- комната 5 - Кид падает с кнопки 0,6 на 2,7 - получает урон, присяд в 2,8 - когда встает 
+  он проваливается еще ниже в комнату 6 на между 2,7-2,8.
+- если стражник убивает Кида то Кид респавнится на месте смерти и стражник тут же его убивает
+  еще раз и так по циклу
+
+--------
+
+- проверить как отрисовывается Кид вместе с мертвым стражником - в оригинале стражник поверх
+  Кида (Кид проходит за телом стража), у нас Кид поверх (перед) стражем;
+- сейчас у нас шифт не залипает но теперь он теряет статус нажатости - то есть при нажатом шифте
+  второе-треть-четвертое нажатие стрелки отрабатывает не как осторожный шаг а переводит Кида на бег
+  по идее с новым алгоритмом должно было бы корректно отрабатывать нажатие шифта ? теперь же залипаний
+  нету но есть фантомный отжим ? такое поведение работы с клавиатурой хуже чем залипание шифта (потому
+  что игрок надеется что шифт нажат и будет короткий шаг а Кид начинает бежать и может провалиться в
+  ловушку/яму или набежать на пики и погибнуть). то есть надо как-то более точно проверять статус нажатости
+  шифта.
+  то есть - когда нажат шифт и нажимаются стрелки то вариант редких пропусков стрелок предпочтительнее чем 
+  вариант когда мы перестаем понимать что шифт нажат.
+- после respawn - должны ли оживать стражники ? сейчас они остаются мертвые.
+- небольшой баг отображения (такой баг у нас уже был и ты его фиксил) - комната 12 - две падающие плиты
+  рядом (0,1 и 0,2) - после падения осколки только от одной на 1,2 а от 0,1 на 1,1 осколков нету.
+  при том что в комнате 7 две плиты 0,5 и 0,6 падая на 2,5 и 2,6 дают двое осколков.
+  возможная причина - когда Кид пробегает в комнате 12 по падающим плитам то он убегает сразу в комнату 15
+  и плита 0,2 успевает упасть и поменять статус пола 1,2 на пол с осколками а плита 0,1 еще остается в падении
+  когда Кид уже уходит в комнату 15 и потому статус пола на 1,1 на 'пол с осколками' измениться не успевает
+
+--------
+
+Подумай вот над чем -
+  интересует возможность покрытия уже написаного кода автотестами (тесткейсами).
+  автотесты внутри MAME я думаю будут достаточно затруднительными, но поскольку это у нас plain-C
+  то можно наверное делать автотесты и на host OS.
+  возможно это нам поможет не создавать ситуации когда нам каждый раз приходится фиксить баги которые
+  мы уже фиксили (по крайней мере постараемся избегать регресса при реализации новых фич)
+  я понимаю что это скорее всего будет достаточно сложно совместить с тем что финальный продукт идет 
+  для Sprinter. но подумать над этим надо.
+
+Пока ничего не предпринимай, только подумай что и как можно сделать.
+
@@ -0,0 +1,10 @@
+Баги/недоработки на уровне 2 
+
+- комната 4 - бой со стражем - страж другого цвета/другого цвета у него HP (сравнение с SDLPoP)
+- комната 4 - бой со стражем - при нанесении урона стражу должен рисоваться сплеш (типа звезды) - что бы игрок 
+  видел что удар дошел до цели без перевода внимания на HP (
+
+- баг нашего cheats - если мы нажимаем +/- (переход по комнатам) в момент когда Кид вытащил меч для битвы - 
+  Кид теряет управление (он переключается в режим боя но в новой комнате нету стража - в результате нажатия
+  кнопок движения игнорятся)
+  
@@ -0,0 +1,576 @@
+/*
+ * guards.c — ЛОГИКА стража, собирается в БАНК (--bank 1=guards.c, окно W3).
+ *
+ * Правила банка (проверено пробником tests/w3bankgfx):
+ *   - состояние держим в W1/W2 (pop_guard.c): статики банка линкуются в
+ *     страницу банка и снаружи не читаются;
+ *   - звать можно W1/W2-код (pop_map, pop_kid, pop_geom, libc, примитивы
+ *     libbgi) — скобка _bgi_begin/_bgi_end возвращает страницу БАНКА;
+ *   - звать НЕЛЬЗЯ резидент W3 (pop_bg) — ни напрямую, ни транзитивно:
+ *     пока исполняется банк, резидентной страницы в адресном пространстве
+ *     нет.  Поэтому фон/окклюзию за стража рисует главный цикл.
+ *
+ * Порт: seg003 check_can_guard_see_kid, seg002 autocontrol_*, seg000
+ * play_guard_frame, seg006 char_opp_dist.  ДИСПЕТЧЕР у соперника не свой:
+ * ИИ выставляет те же глобалы control_* (pop_ctrl.h), что и ввод игрока, а
+ * дальше работает общий pop_control().
+ */
+#include "pop_guard.h"
+#include "pop_kid.h"
+#include "pop_ctrl.h"
+#include "pop_map.h"
+#include "pop_geom.h"
+#include "pop_trob.h"
+#include "pop_level.h"    /* pop_current_level — спецсобытие уровня 3 */
+#include "pop_state.h"      /* pop_immortal, pop_droppedout */
+
+#define TILE_MIDX      7        /* середина тайла в координатах персонажа  */
+#define SCREENSPACE_X 58        /* = pop_x_bump[FIRST_ONSCREEN_COLUMN]     */
+
+#define TILE_SPIKE          2
+#define TILE_GATE           4
+#define TILE_DOORTOP_FLOOR  7
+#define TILE_LOOSE         11
+#define TILE_DOORTOP       12
+#define TILE_CHOMPER       18
+#define TILE_WALL          20
+
+/* actions (types.h:334) — нужны ветке «идти ли за упавшим Кидом». */
+#define ACT_HANGCLIMB       2
+#define ACT_HANGSTRAIGHT    6
+
+/* tile_is_floor (seg004): не-пол — пустота, ковёр, верх двери, стена и
+ * «половинки» 26..29.  Дубликат крошечного switch'а из pop_map: тянуть его
+ * через границу банка дороже, чем повторить. */
+static uint8_t tile_is_floor(uint8_t t)
+{
+    switch (t) {
+    case 0: case 9: case 12: case 20:
+    case 26: case 27: case 28: case 29:
+        return 0;
+    default:
+        return 1;
+    }
+}
+
+/* Тайл в ряду Кида по X-координате персонажа (порт get_tile_at_kid,
+ * seg003:761): xpos − 7 делится на ширину тайла с округлением вниз. */
+static int8_t tile_col;                       /* колонка последнего tile_at_kid */
+
+static uint8_t tile_at_kid(int16_t xpos)
+{
+    /* get_tile_div_mod_m7 (seg006:697): колонка = floor((xpos − 7 − 58)/14),
+     * СРАЗУ в координатах комнаты (58 = x_bump[FIRST_ONSCREEN_COLUMN]).
+     * Оригинал берёт её из tile_div_tbl, у нас — делением с округлением
+     * вниз, как в pop_map. */
+    int16_t x = xpos - 7 - SCREENSPACE_X;
+    int16_t col = x / TILE_SIZEX;
+    if (x % TILE_SIZEX < 0) --col;
+    tile_col = (int8_t)col;
+    return pop_tile_at(tile_col, Kid.curr_row);
+}
+
+/* check_can_guard_see_kid (seg003:688) — луч видимости по ряду.
+ * Результат в can_guard_see_kid: 0 не видит / 1 видит, но не пойдёт /
+ * 2 видит и пойдёт. */
+void pop_check_can_guard_see_kid(void) __banked
+{
+    uint8_t kid_frame = Kid.frame;
+    int16_t left_pos, right_pos;
+    uint8_t tile;
+
+    if (!(Guard.charid != 0 &&
+          /* кадры 219..228 — подъём по лестнице: там страж Кида не видит */
+          kid_frame != 0 && (kid_frame < 219 || kid_frame >= 229) &&
+          Kid.alive < 0 && Guard.alive < 0 &&
+          Kid.room == Guard.room && Kid.curr_row == Guard.curr_row)) {
+        can_guard_see_kid = 0;
+        return;
+    }
+
+    can_guard_see_kid = 2;
+    left_pos  = pop_x_bump[Kid.curr_col   + FIRST_ONSCREEN_COLUMN] + TILE_MIDX;
+    right_pos = pop_x_bump[Guard.curr_col + FIRST_ONSCREEN_COLUMN] + TILE_MIDX;
+    if (left_pos > right_pos) {
+        int16_t t = left_pos; left_pos = right_pos; right_pos = t;
+    }
+    /* Чомпер стоит у ЛЕВОГО края тайла — свой тайл он не перекрывает. */
+    if (tile_at_kid(left_pos) == TILE_CHOMPER)
+        left_pos += TILE_SIZEX;
+    /* Ворота — у ПРАВОГО края, поэтому крайний правый тайл не считается. */
+    if (tile_at_kid(right_pos) == TILE_GATE)
+        right_pos -= TILE_SIZEX;
+
+    while (left_pos <= right_pos) {
+        tile = tile_at_kid(left_pos);
+        /* Сквозь это не видно вовсе. */
+        if (tile == TILE_WALL || tile == TILE_DOORTOP_FLOOR || tile == TILE_DOORTOP) {
+            can_guard_see_kid = 0;
+            return;
+        }
+        /* Видно, но страж не пойдёт: провалится / попадёт под чомпер /
+         * упрётся в неоткрытые ворота / шагнёт в дыру. */
+        if (tile == TILE_LOOSE || tile == TILE_CHOMPER || !tile_is_floor(tile)) {
+            can_guard_see_kid = 1;
+        } else if (tile == TILE_GATE &&
+                   pop_gate_modif(tile_col, Kid.curr_row) < 112) {
+            can_guard_see_kid = 1;    /* ворота подняты не до конца */
+        }
+        left_pos += TILE_SIZEX;
+    }
+}
+
+
+/* ---- Скелет: спецсобытие подъёма (check_skel, seg002:1042) ---------- *
+ * На уровне 3 стражей в данных НЕТ ВООБЩЕ (guards_tile пуст во всех 24
+ * комнатах) — единственный противник поднимается сам: когда Кид в комнате 1
+ * доходит до колонки 2 или 3 при открытой двери уровня, тайл 21 (скелет)
+ * стирается в пол, а на его месте встаёт персонаж слота Guard с уже вынутым
+ * мечом.  Отсюда и место здесь, рядом с ИИ, а не в enter_guard. */
+#define SKEL_LEVEL      3
+#define SKEL_ROOM       1
+#define SKEL_COL        5
+#define SKEL_ROW        1
+#define SKEL_TRIG_COL1  2
+#define SKEL_TRIG_COL2  3
+#define SKEL_SKILL      2
+#define SKEL_HP         3
+#define TILE_SKELETON  21
+
+void pop_check_skel(void) __banked
+{
+    if (pop_current_level != SKEL_LEVEL) return;
+    if (Guard.charid != 0) return;             /* слот занят (dir_56_none) */
+    if (Kid.room != SKEL_ROOM) return;
+    if (!pop_leveldoor_open) return;
+    if (Kid.curr_col != SKEL_TRIG_COL1 && Kid.curr_col != SKEL_TRIG_COL2) return;
+    if (pop_tile_at(SKEL_COL, SKEL_ROW) != TILE_SKELETON) return;
+
+    pop_skel_wake_tile((uint8_t)(SKEL_ROW * 10 + SKEL_COL));
+
+    /* Поднимаем В ОКНЕ Char — как оригинал (он же и saveshad'ит). */
+    pop_loadshad();
+    Char.room      = Kid.room;
+    Char.curr_row  = SKEL_ROW;
+    Char.y         = (uint8_t)pop_y_land[SKEL_ROW + 1];
+    Char.curr_col  = SKEL_COL;
+    Char.x         = (uint8_t)(pop_x_bump[SKEL_COL + FIRST_ONSCREEN_COLUMN] + TILE_SIZEX);
+    Char.direction = -1;                       /* dir_FF_left */
+    Char.alive     = -1;
+    Char.sword     = SWORD_2_DRAWN;
+    Char.charid    = CHARID_4_SKELETON;
+    Char.fall_x    = Char.fall_y = 0;
+    pop_char_set_seq(SEQ_88_SKEL_WAKE_UP);
+    play_seq();
+    pop_saveshad();
+
+    guard_skill = SKEL_SKILL;
+    guardhp_max = guardhp_curr = SKEL_HP;
+    guardhp_delta = 0;
+    is_guard_notice = guard_refrac = 0;
+}
+
+/* ---- Синтетический ввод (seg002:0706..) --------------------------- */
+static void move_0_nothing(void)
+{
+    control_shift = control_y = control_x = control_shift2 = 0;
+    control_down = control_up = control_backward = control_forward = 0;
+}
+static void move_1_forward(void)
+{
+    control_x = POP_CONTROL_HELD_FORWARD;
+    control_forward = POP_CONTROL_HELD;
+}
+static void move_2_backward(void)
+{
+    control_backward = POP_CONTROL_HELD;
+    control_x = POP_CONTROL_HELD_BACKWARD;
+}
+static void move_3_up(void)
+{
+    control_y = POP_CONTROL_HELD_UP;
+    control_up = POP_CONTROL_HELD;
+}
+static void move_4_down(void)
+{
+    control_down = POP_CONTROL_HELD;
+    control_y = POP_CONTROL_HELD_DOWN;
+}
+static void move_6_shift(void)
+{
+    control_shift = POP_CONTROL_HELD;
+    control_shift2 = POP_CONTROL_HELD;
+}
+static void move_down_back(void)
+{
+    control_down = POP_CONTROL_HELD;
+    move_2_backward();
+}
+static void move_down_forw(void)
+{
+    control_down = POP_CONTROL_HELD;
+    move_1_forward();
+}
+
+/* autocontrol_guard_inactive (seg002:710): страж с убранным мечом.
+ * Пока Кид за спиной — страж не реагирует; исключение — «шум» Кида
+ * (is_guard_notice), от которого страж оборачивается. */
+static void autocontrol_guard_inactive(void)
+{
+    int16_t distance;
+    if (Kid.alive >= 0) return;
+    distance = pop_char_opp_dist();
+    /* В оригинале условие записано как (word)distance < (word)-8 —
+     * беззнаковое сравнение, истинное для ВСЕГО, кроме диапазона −8..−1.
+     * То есть: Кид не «вплотную за спиной». */
+    if (Opp.curr_row != Char.curr_row || distance >= 0 || distance < -8) {
+        if (is_guard_notice) {
+            is_guard_notice = 0;
+            if (distance < 0) {
+                if (distance < -4) move_4_down();   /* обернуться на шум */
+                return;
+            }
+        } else if (distance < 0) {
+            return;
+        }
+    }
+    if (can_guard_see_kid) {
+        /* Увидел — переходит в боевую стойку (вниз+вперёд = достать меч). */
+        move_down_forw();
+    }
+}
+
+/* ---- Активный страж (меч обнажён), seg002:737.. -------------------- *
+ * Таблицы вероятностей по 12 градациям мастерства (seg002:26..38).  Бросок
+ * — prandom(255) с СОБСТВЕННЫМ сидом: у нас последовательности разведены
+ * по доменам (кладка / анимация тайлов / бой), см. pop_geom.h. */
+static const uint8_t STRIKEPROB[NUM_GUARD_SKILLS]   = { 61,100, 61, 61, 61, 40,100,220,  0, 48, 32, 48};
+static const uint8_t RESTRIKEPROB[NUM_GUARD_SKILLS] = {  0,  0,  0,  5,  5,175, 16,  8,  0,255,255,150};
+static const uint8_t BLOCKPROB[NUM_GUARD_SKILLS]    = {  0,150,150,200,200,255,200,250,  0,255,255,255};
+static const uint8_t IMPBLOCKPROB[NUM_GUARD_SKILLS] = {  0, 61, 61,100,100,145,100,250,  0,145,255,175};
+static const uint8_t ADVPROB[NUM_GUARD_SKILLS]      = {255,200,200,200,255,255,200,  0,  0,255,100,100};
+
+/* Бросок «сработало ли»: в оригинале prob > prandom(255). */
+static uint8_t roll(uint8_t prob)
+{
+    return (uint8_t)(prob > (uint8_t)pop_prandom(&pop_fight_seed, 255));
+}
+
+/* guard_advance (seg002:0AF5): наступать.  Мастерство 0 наступает всегда,
+ * остальные — только пока Кид не замахнулся. */
+static void guard_advance(void)
+{
+    if (guard_skill == 0 || kid_sword_strike == 0) {
+        if (roll(ADVPROB[guard_skill])) move_1_forward();
+    }
+}
+
+/* guard_block (seg002:0B1D): блокировать замах Кида.  Если Кид только что
+ * пробил блок (justblocked) — своя, «импровизационная» вероятность. */
+static void guard_block(void)
+{
+    uint8_t of = Opp.frame;
+    if (of == FRAME_152_STRIKE_2 || of == FRAME_153_STRIKE_3 ||
+        of == FRAME_162_BLOCK_TO_STRIKE) {
+        if (roll(justblocked ? IMPBLOCKPROB[guard_skill]
+                             : BLOCKPROB[guard_skill]))
+            move_3_up();
+    }
+}
+
+/* guard_strike (seg002:0B73): бить.  По замаху Кида не бьём (кадры 169/151);
+ * из своего парирования — по отдельной вероятности «добить». */
+static void guard_strike(void)
+{
+    uint8_t of = Opp.frame, cf = Char.frame;
+    if (of == FRAME_169_BEGIN_BLOCK || of == FRAME_151_STRIKE_1) return;
+    if (cf == FRAME_161_PARRY || cf == FRAME_150_PARRY) {
+        if (roll(RESTRIKEPROB[guard_skill])) move_6_shift();
+    } else {
+        if (roll(STRIKEPROB[guard_skill])) move_6_shift();
+    }
+}
+
+/* autocontrol_guard_kid_armed (seg002:0AC1): Кид с мечом.  Вплотную и
+ * далеко — наступаем; в «рабочей» дистанции 10..28 сначала пробуем блок, и
+ * только отдышавшись бьём. */
+static void autocontrol_guard_kid_armed(int16_t distance)
+{
+    if (distance < 10 || distance >= 29) {
+        guard_advance();
+    } else {
+        guard_block();
+        if (guard_refrac == 0) {
+            if (distance < 12 || distance >= 29) guard_advance();
+            else                                 guard_strike();
+        }
+    }
+}
+
+/* autocontrol_guard_kid_in_sight (seg002:0A93). */
+static void autocontrol_guard_kid_in_sight(int16_t distance)
+{
+    if (Opp.sword == SWORD_2_DRAWN) {
+        autocontrol_guard_kid_armed(distance);
+    } else if (guard_refrac == 0) {
+        /* Кид безоружен: подойти и рубить. */
+        if (distance < 29) move_6_shift();
+        else               move_1_forward();
+    }
+}
+
+/* Тайл перед стражем / через один (порт get_tile_infrontof_char и
+ * get_tile_infrontof2_char, seg004) — но для Char, а не для Kid. */
+static uint8_t tile_infront(int8_t step)
+{
+    int8_t d = (int8_t)(Char.direction < 0 ? -step : step);
+    return pop_tile_at((int8_t)(Char.curr_col + d), Char.curr_row);
+}
+
+/* autocontrol_guard_kid_far (seg002:09CB): идём, если впереди есть пол хотя
+ * бы через тайл; иначе пятимся (не шагать в пропасть). */
+static void autocontrol_guard_kid_far(void)
+{
+    if (tile_is_floor(tile_infront(1)) || tile_is_floor(tile_infront(2)))
+        move_1_forward();
+    else
+        move_2_backward();
+}
+
+/* guard_follows_kid_down (seg002:09F8): Кида спихнули с уступа (droppedout),
+ * страж его больше не видит — идти ли следом вниз?  Условия оригинала, все
+ * «не идти»: впереди стена; ИЛИ впереди не пол и при этом внизу пика,
+ * loose-плита, стена или пустота; ИЛИ Кид не ровно на ряд ниже.
+ *
+ * Тайлы читаются через pop_tile_at — это банк 1 → банк 3, то есть трамплин.
+ * Здесь это не жаль: ветка срабатывает только в кадре, когда Кид сорвался
+ * из боя, а не каждый кадр (её гейтят can_guard_see_kid == 0 и droppedout).
+ *
+ * Не идём — сбросить droppedout и попятиться; идём — шаг вперёд, дальше
+ * персонажа уводит вниз обычная физика (та же, что у Кида). */
+static void guard_follows_kid_down(void)
+{
+    uint8_t below, front;
+    if (Opp.action == ACT_HANGCLIMB || Opp.action == ACT_HANGSTRAIGHT) return;
+    front = tile_infront(1);
+    below = pop_tile_at((int8_t)(Char.curr_col + (Char.direction < 0 ? -1 : 1)),
+                        (int8_t)(Char.curr_row + 1));
+    if (front == TILE_WALL ||
+        (!tile_is_floor(front) &&
+         (below == TILE_SPIKE || below == TILE_LOOSE || below == TILE_WALL ||
+          !tile_is_floor(below) || Char.curr_row + 1 != Opp.curr_row))) {
+        pop_droppedout = 0;
+        move_2_backward();
+    } else {
+        move_1_forward();
+    }
+}
+
+/* autocontrol_guard_active (seg002:737). */
+static void autocontrol_guard_active(void)
+{
+    uint8_t cf = Char.frame;
+    uint8_t of;
+    int16_t distance;
+
+    /* Кадр 166 (неактивная стойка) и всё, что ниже 150, — не боевые позы. */
+    if (cf == FRAME_166_STAND_INACTIVE || cf < 150 || can_guard_see_kid == 1)
+        return;
+
+    if (can_guard_see_kid == 0) {
+        /* seg002:740: Кид пропал из виду.  Если его СПИХНУЛИ (droppedout) —
+         * решаем, идти ли за ним вниз; иначе просто отступаем.  Скелет не
+         * отступает никогда (у него нет этой ветки в оригинале). */
+        if (pop_droppedout) guard_follows_kid_down();
+        else if (Char.charid != CHARID_4_SKELETON) move_down_back();
+        return;
+    }
+
+    /* can_guard_see_kid == 2 */
+    of = Opp.frame;
+    distance = pop_char_opp_dist();
+    /* Кид падает/приземляется в отскоке — не мешаем ему, ждём. */
+    if (distance >= 12 && of >= 102 && of < 118 && Opp.action == 5)
+        return;
+
+    if (distance < 35) {
+        if ((Char.sword < SWORD_2_DRAWN && distance < 8) || distance < 12) {
+            /* Слишком близко: если смотрим в одну сторону — развернуться. */
+            if (Char.direction == Opp.direction) move_2_backward();
+            else                                 move_1_forward();
+        } else {
+            autocontrol_guard_kid_in_sight(distance);
+        }
+        return;
+    }
+
+    if (guard_refrac != 0) return;
+    if (Char.direction != Opp.direction) {
+        /* Кид разбежался — встречаем ударом, а не шагом. */
+        if (of >= 7 && of < 15) {                  /* бег          */
+            if (distance < 40) move_6_shift();
+            return;
+        } else if (of >= 34 && of < 44) {          /* разбег в прыжок */
+            if (distance < 50) move_6_shift();
+            return;
+        }
+    }
+    autocontrol_guard_kid_far();
+}
+
+/* autocontrol_guard (seg002:701) + autocontrol_opponent (seg002:628). */
+static void autocontrol_opponent(void)
+{
+    move_0_nothing();
+    /* Таймеры боя убывают раз в кадр — здесь, как в оригинале. */
+    if (justblocked)      --justblocked;
+    if (kid_sword_strike) --kid_sword_strike;
+    if (guard_refrac)     --guard_refrac;
+    /* autocontrol_skeleton (seg002:685): у скелета меч вынут ВСЕГДА — он не
+     * бывает «неактивным», поэтому ветка inactive ему недоступна. */
+    if (Char.charid == CHARID_4_SKELETON) Char.sword = SWORD_2_DRAWN;
+    if (Char.sword < SWORD_2_DRAWN) autocontrol_guard_inactive();
+    else                            autocontrol_guard_active();
+}
+
+/* ---- Урон мечом (seg002:0CD4..0E1F) -------------------------------- */
+#define ACTION_99_HURT   99
+#define ACTION_1_RUN     1
+#define FRAME_154_POKING 154
+#define SEQ_69_ATTACK_WAS_PARRIED 69
+#define SEQ_74_HIT_BY_SWORD       74
+#define SEQ_85_STABBED_TO_DEATH   85
+
+/* refractimer (seg002:36) — «отдышка» стража после того, как его ранили. */
+static const uint8_t REFRACTIMER[NUM_GUARD_SKILLS] =
+    { 16, 16, 16, 16,  8,  8,  8,  8,  0,  8,  0,  0};
+
+/* hurt_by_sword (seg002): применить попадание к АКТИВНОМУ персонажу.
+ * Без меча в руке любое попадание смертельно; с мечом — минус 1 HP и кадр
+ * «получил удар».
+ * УПРОЩЕНИЕ: ветку «сбит с уступа» (seq_81, когда сзади пусто и до кромки
+ * меньше 4) не портируем — ей нужны тайловые запросы ОТ Char, а pop_map
+ * пока умеет только от Kid.  На ровном полу (тайл сзади не пустой) оригинал
+ * идёт ровно нашей веткой. */
+static void hurt_by_sword(void)
+{
+    if (Char.alive >= 0) return;
+    /* Чит бессмертия перекрывает и «безоружного закалывают насмерть»:
+     * без этого Кид гибнет с одного удара мимо стойки, и чит бесполезен
+     * ровно там, где нужен.  Анимацию удара оставляем. */
+    if (Char.charid == CHARID_0_KID && pop_immortal) {
+        pop_char_set_seq(SEQ_74_HIT_BY_SWORD);
+        Char.y = (uint8_t)pop_y_land[Char.curr_row + 1];
+        Char.fall_y = 0;
+        play_seq();
+        return;
+    }
+    if (Char.sword != SWORD_2_DRAWN) {
+        pop_take_hp(100);
+        pop_char_set_seq(SEQ_85_STABBED_TO_DEATH);
+    } else if (Char.charid != CHARID_4_SKELETON && pop_take_hp(1)) {
+        pop_char_set_seq(SEQ_85_STABBED_TO_DEATH);   /* HP кончились */
+    } else {
+        pop_char_set_seq(SEQ_74_HIT_BY_SWORD);
+    }
+    Char.y = (uint8_t)pop_y_land[Char.curr_row + 1];
+    Char.fall_y = 0;
+    play_seq();                                      /* TODO: звук 12/13 */
+}
+
+/* check_hurting (seg002:0D56): достал ли АКТИВНЫЙ персонаж соперника.
+ * Бьют кадры 153/154; если соперник в этот момент парирует — удар отбит. */
+static void check_hurting(void)
+{
+    int16_t distance;
+    uint8_t cf, of, min_range;
+
+    if (Char.sword != SWORD_2_DRAWN) return;
+    if (Char.curr_row != Opp.curr_row) return;
+    cf = Char.frame;
+    if (cf != FRAME_153_STRIKE_3 && cf != FRAME_154_POKING) return;
+
+    distance = pop_char_opp_dist();
+    of = Opp.frame;
+    if (distance < 0 || distance >= 29 ||
+        (of != FRAME_161_PARRY && of != FRAME_150_PARRY)) {
+        /* Соперник НЕ парирует. */
+        if (cf == FRAME_154_POKING) {
+            min_range = (uint8_t)(Opp.sword < SWORD_2_DRAWN ? 8 : 12);
+            distance = pop_char_opp_dist();
+            if (distance >= (int16_t)min_range && distance < 29)
+                Opp.action = ACTION_99_HURT;
+        }
+    } else {
+        /* Парировано. */
+        Opp.frame = FRAME_161_PARRY;
+        if (Char.charid != CHARID_0_KID) justblocked = 4;
+        pop_char_set_seq(SEQ_69_ATTACK_WAS_PARRIED);
+        play_seq();
+    }
+}
+
+/* check_sword_hurting (seg002:0D1A): прогнать проверку с ОБЕИХ сторон. */
+void pop_check_sword_hurting(void) __banked
+{
+    uint8_t kf = Kid.frame;
+    if (kf == 0 || (kf >= 219 && kf < 229)) return;   /* подъём по лестнице */
+    pop_loadshad_and_opp();
+    check_hurting();
+    pop_saveshad_and_opp();
+    pop_loadkid_and_opp();
+    check_hurting();
+    pop_savekid_and_opp();
+}
+
+/* check_sword_hurt (seg002:0CD4): применить помеченные попадания.  Если
+ * ранен страж — Киду в этом кадре урон уже не проходит (в оригинале так же:
+ * его action сбрасывается ДО проверки). */
+void pop_check_sword_hurt(void) __banked
+{
+    if (Guard.action == ACTION_99_HURT) {
+        if (Kid.action == ACTION_99_HURT) Kid.action = ACTION_1_RUN;
+        pop_loadshad();
+        hurt_by_sword();
+        pop_saveshad();
+        guard_refrac = (int8_t)REFRACTIMER[guard_skill];
+    } else if (Kid.action == ACTION_99_HURT) {
+        pop_loadkid();
+        hurt_by_sword();
+        pop_savekid();
+    }
+}
+
+/* play_guard (seg006): ИИ + общий диспетчер.  Отдельная ветка «HP кончились»:
+ * пока страж жив (alive < 0) и HP есть — обычный ход; как только HP дошли до
+ * нуля, он переводится в «умирает» (alive = 0), и дальше тот же control()
+ * ставит ему seq_71_dying.  Уже умирающий сюда попадает с alive >= 0 и просто
+ * доигрывает последовательность. */
+static void play_guard(void)
+{
+    if (Char.alive < 0 && guardhp_curr == 0) {
+        Char.alive = 0;
+        /* on_guard_killed (seg006:1927) — у нас пока только звук победы,
+         * которого нет; для уровня 1 других эффектов там нет. */
+    }
+    autocontrol_opponent();
+    pop_control();
+}
+
+/* pop_guard_tick — порт play_guard_frame (seg000:1246) в объёме, который у
+ * нас уже есть: окно Char/Opp вокруг ИИ, диспетчера и интерпретатора
+ * последовательностей.  Физика стража (fall_accel/коллизия/бамп/пики) —
+ * отдельным шагом. */
+void pop_guard_tick(void) __banked
+{
+    if (Guard.charid == 0) return;      /* стража в комнате нет */
+    pop_loadshad_and_opp();             /* Char = Guard, Opp = Kid */
+    /* Симметрично Киду (play_guard_frame, seg000:1248): cur_frame один на
+     * всех, и до этой строки в нём лежит кадр КИДА — он тикал раньше. */
+    pop_load_fram_det_col();
+    play_guard();
+    /* Анимация: та же seqtbl, что у Кида, но своя таблица кадров —
+     * выбирается по Char.charid внутри load_frame (seg006:0293). */
+    play_seq();
+    pop_saveshad();
+}
@@ -8,449 +8,20 @@

 #define SEQTBL_BASE 0x196Eu

-/* {image, dx, dy, flags, sword}; chtab = sword>>6 (0=kid). */
+/* {image, dx, dy, flags, sword}; chtab = sword>>6 (0=kid).
+ * САМА таблица кадров и seqtbl лежат в kid_data.bin (EMM-
+ * страница); здесь только тип и размеры. */
 typedef struct { uint8_t image; int8_t dx, dy; uint8_t flags, sword; } kframe;
 #define KID_NFRAMES 241
-static const kframe kid_frames[KID_NFRAMES] = {
-    {255,   0,   0,0x00,0x00},
-    {  0,   1,   0,0xC4,0x00},
-    {  1,   1,   0,0x44,0x00},
-    {  2,   3,   0,0x47,0x00},
-    {  3,   4,   0,0x48,0x00},
-    {  4,   0,   0,0xE6,0x00},
-    {  5,   0,   0,0x49,0x00},
-    {  6,   0,   0,0x4A,0x00},
-    {  7,   0,   0,0xC5,0x00},
-    {  8,   0,   0,0x44,0x00},
-    {  9,   0,   0,0x47,0x00},
-    { 10,   0,   0,0x4B,0x00},
-    { 11,   0,   0,0x43,0x00},
-    { 12,   0,   0,0xC3,0x00},
-    { 13,   0,   0,0x47,0x00},
-    { 14,   0,   0,0x43,0x09},
-    { 15,   0,   0,0xC3,0x00},
-    { 16,   0,   0,0x44,0x00},
-    { 17,   0,   0,0x46,0x00},
-    { 18,   0,   0,0x48,0x00},
-    { 19,   0,   0,0x89,0x00},
-    { 20,   0,   0,0x0B,0x00},
-    { 21,   0,   0,0x8B,0x00},
-    { 22,   0,   0,0x11,0x00},
-    { 23,   0,   0,0x07,0x00},
-    { 24,   0,   0,0x05,0x00},
-    { 25,   0,   0,0xC1,0x00},
-    { 26,   0,   0,0xC6,0x00},
-    { 27,   0,   0,0x43,0x00},
-    { 28,   0,   0,0x48,0x00},
-    { 29,   0,   0,0x42,0x00},
-    { 30,   0,   0,0x42,0x00},
-    { 31,   0,   0,0xC2,0x00},
-    { 32,   0,   0,0xC2,0x00},
-    { 33,   0,   0,0x43,0x00},
-    { 34,   0,   0,0x48,0x00},
-    { 35,   0,   0,0xCE,0x00},
-    { 36,   0,   0,0xC1,0x00},
-    { 37,   0,   0,0x45,0x00},
-    { 38,   0,   0,0x8E,0x00},
-    { 39,   0,   0,0x0B,0x00},
-    { 40,   0,   0,0x8B,0x00},
-    { 41,   0,   0,0x8A,0x00},
-    { 42,   0,   0,0x01,0x00},
-    { 43,   0,   0,0xC4,0x00},
-    { 44,   0,   0,0xC3,0x00},
-    { 45,   0,   0,0xC3,0x00},
-    { 46,   0,   0,0xA5,0x00},
-    { 47,   0,   0,0xA4,0x00},
-    { 48,   0,   0,0x66,0x00},
-    { 49,   4,   0,0x67,0x00},
-    { 50,   3,   0,0x66,0x00},
-    { 51,   1,   0,0x44,0x00},
-    { 64,   0,   0,0xC2,0x00},
-    { 65,   0,   0,0x41,0x00},
-    { 66,   0,   0,0x42,0x00},
-    { 67,   0,   0,0x00,0x00},
-    { 68,   0,   0,0x00,0x00},
-    { 69,   0,   0,0x80,0x00},
-    { 70,   0,   0,0x00,0x00},
-    { 71,   0,   0,0x80,0x00},
-    { 72,   0,   0,0x00,0x00},
-    { 73,   0,   0,0x80,0x00},
-    { 74,   0,   0,0x00,0x00},
-    { 75,   0,   0,0x00,0x00},
-    { 76,   0,   0,0x80,0x00},
-    {255,   0,   0,0x00,0x00},
-    { 80,  -2,   0,0x41,0x00},
-    { 81,  -2,   0,0x41,0x00},
-    { 82,  -1,   0,0xC2,0x00},
-    { 83,  -2,   0,0x42,0x00},
-    { 84,  -2,   0,0x41,0x00},
-    { 85,  -2,   0,0x41,0x00},
-    { 86,  -2,   0,0x41,0x00},
-    { 87,  -1,   0,0x07,0x00},
-    { 88,  -1,   0,0x05,0x00},
-    { 89,   2,   0,0x07,0x00},
-    { 90,   2,   0,0x07,0x00},
-    { 91,   2,  -3,0x00,0x00},
-    { 92,   2, -10,0x00,0x00},
-    { 93,   2, -11,0x80,0x00},
-    { 94,   3,  -2,0x43,0x00},
-    { 95,   3,   0,0xC3,0x00},
-    { 96,   3,   0,0xC3,0x00},
-    { 97,   3,   0,0x63,0x00},
-    { 98,   4,   0,0xE3,0x00},
-    { 28,   0,   0,0x00,0x00},
-    { 99,   7, -14,0x80,0x00},
-    {100,   7, -12,0x80,0x00},
-    {101,   4, -12,0x00,0x00},
-    {102,   3, -10,0x80,0x00},
-    {103,   2, -10,0x80,0x00},
-    {104,   1, -10,0x80,0x00},
-    {105,   0, -11,0x00,0x00},
-    {106,  -1, -12,0x00,0x00},
-    {107,  -1, -14,0x00,0x00},
-    {108,  -1, -14,0x00,0x00},
-    {109,  -1, -15,0x80,0x00},
-    {110,  -1, -15,0x80,0x00},
-    {111,   0, -15,0x00,0x00},
-    {255,   0,   0,0x00,0x00},
-    {255,   0,   0,0x00,0x00},
-    {112,   0,   0,0xC6,0x00},
-    {113,   0,   0,0x46,0x00},
-    {114,   0,   0,0xC5,0x00},
-    {115,   0,   0,0x45,0x00},
-    {116,   0,   0,0xC2,0x00},
-    {117,   0,   0,0xC4,0x00},
-    {118,   0,   0,0xC5,0x00},
-    {119,   0,   0,0x46,0x00},
-    {120,   0,   0,0x47,0x00},
-    {121,   0,   0,0x47,0x00},
-    {122,   0,   0,0x49,0x00},
-    {123,   0,   0,0xC8,0x00},
-    {124,   0,   0,0xC9,0x00},
-    {125,   0,   0,0x49,0x00},
-    {126,   0,   0,0x45,0x00},
-    {127,   2,   0,0x45,0x00},
-    {128,   2,   0,0xC5,0x00},
-    {129,   0,   0,0xC3,0x00},
-    {255,   0,   0,0x00,0x00},
-    {133,   0,   0,0x43,0x00},
-    {134,   0,   0,0xC4,0x00},
-    {135,   0,   0,0xC5,0x00},
-    {136,   0,   0,0x48,0x00},
-    {137,   0,   0,0x6C,0x00},
-    {138,   0,   0,0xEF,0x00},
-    {139,   0,   0,0x63,0x00},
-    {140,   0,   0,0xC3,0x00},
-    {141,   0,   0,0x43,0x00},
-    {142,   0,   0,0x43,0x00},
-    {143,   0,   0,0x44,0x00},
-    {144,   0,   0,0x44,0x00},
-    {172,   0,   1,0xC1,0x00},
-    {173,   0,   1,0xC7,0x00},
-    {145,   0, -12,0x01,0x00},
-    {146,   0, -21,0x00,0x00},
-    {147,   1, -26,0x80,0x00},
-    {148,   4, -32,0x80,0x00},
-    {149,   6, -36,0x81,0x00},
-    {150,   7, -41,0x82,0x00},
-    {151,   2,  17,0x42,0x00},
-    {152,   4,   9,0xC4,0x00},
-    {153,   4,   5,0xC9,0x00},
-    {154,   4,   4,0xC8,0x00},
-    {155,   5,   0,0x69,0x00},
-    {156,   5,   0,0xE9,0x00},
-    {157,   5,   0,0xE8,0x00},
-    {158,   5,   0,0x69,0x00},
-    {159,   5,   0,0x69,0x00},
-    {184,   0,   2,0x80,0x10},
-    {174,   0,   2,0x80,0x1A},
-    {175,   3,   2,0x00,0x12},
-    {176,   7,   2,0xC4,0x16},
-    {177,  10,   2,0x00,0x15},
-    {178,   7,   2,0x80,0x17},
-    {179,   4,   2,0x80,0x19},
-    {180,   0,   2,0xCE,0x18},
-    {181,   0,   2,0xCD,0x0F},
-    {182,   3,   2,0x00,0x14},
-    {183,   3,   2,0x00,0x1F},
-    {184,   0,   2,0x80,0x10},
-    {185,   0,   2,0x80,0x11},
-    {186,   0,   2,0x00,0x20},
-    {187,   0,   2,0x80,0x21},
-    {188,   2,   2,0xC3,0x22},
-    { 14,   0,   0,0x43,0x00},
-    {189,   7,   2,0x80,0x13},
-    {190,   1,   2,0x80,0x0E},
-    {191,   0,   2,0x80,0x1B},
-    {181,   0,   2,0xCD,0x0F},
-    {181,   0,   2,0xCD,0x0F},
-    {112,   0,   0,0xC6,0x2B},
-    {113,   0,   0,0x46,0x2C},
-    {114,   0,   0,0xC5,0x2D},
-    {115,   0,   0,0x45,0x2E},
-    {114,   0,   0,0xC5,0x00},
-    { 78,   0,   3,0x8A,0x00},
-    { 77,   4,   3,0x87,0x00},
-    {211,   0,   1,0x44,0x00},
-    {212,   0,   1,0x44,0x00},
-    {213,   0,   1,0x44,0x00},
-    {214,   0,   1,0x47,0x00},
-    {215,   0,   7,0x4B,0x00},
-    {255,   0,   0,0x00,0x00},
-    { 79,   4,   7,0x49,0x00},
-    {130,   0,   0,0x44,0x00},
-    {131,   0,   0,0x44,0x00},
-    {132,   0,   2,0x44,0x00},
-    {255,   0,   0,0x00,0x00},
-    {255,   0,   0,0x00,0x00},
-    {192,   0,   0,0x00,0x00},
-    {193,   0,   1,0x00,0x00},
-    {194,   0,   0,0x80,0x00},
-    {195,   0,   0,0x00,0x00},
-    {196,  -1,   0,0x00,0x00},
-    {197,  -1,   0,0x00,0x00},
-    {198,  -1,   0,0x00,0x00},
-    {199,  -4,   0,0x00,0x00},
-    {200,  -4,   0,0x80,0x00},
-    {201,  -4,   0,0x00,0x00},
-    {202,  -4,   0,0x00,0x00},
-    {203,  -4,   0,0x00,0x00},
-    {204,  -4,   0,0x00,0x00},
-    {205,  -5,   0,0x00,0x00},
-    {206,  -5,   0,0x00,0x00},
-    {255,   0,   0,0x00,0x00},
-    {207,   0,   1,0x46,0x00},
-    {208,   0,   1,0xC6,0x00},
-    {209,   0,   1,0xC8,0x00},
-    {210,   0,   1,0x4A,0x00},
-    {255,   0,   0,0x00,0x00},
-    {255,   0,   0,0x00,0x00},
-    {255,   0,   0,0x00,0x00},
-    {255,   0,   0,0x00,0x00},
-    {255,   0,   0,0x00,0x00},
-    {255,   0,   0,0x00,0x00},
-    { 52,   0,   0,0x80,0x00},
-    { 53,   0,   0,0x00,0x00},
-    { 54,   0,   0,0x00,0x00},
-    { 55,   0,   0,0x00,0x00},
-    { 56,   0,   0,0x80,0x00},
-    { 57,   0,   0,0x00,0x00},
-    { 58,   0,   0,0x00,0x00},
-    { 59,   0,   0,0x00,0x00},
-    { 60,   0,   0,0x80,0x00},
-    { 61,   0,   0,0x00,0x00},
-    { 62,   0,   0,0x80,0x00},
-    { 63,   0,   0,0x00,0x00},
-    {160,   1,   1,0xC3,0x23},
-    {161,   0,   1,0x49,0x24},
-    {162,   0,   1,0xC3,0x25},
-    {163,   0,   1,0x49,0x26},
-    {164,   0,   1,0xC3,0x27},
-    {165,   1,   1,0x49,0x28},
-    {166,   1,   1,0x43,0x29},
-    {167,   1,   1,0xC9,0x2A},
-    {168,   4,   1,0xC6,0x00},
-    {169,   3,   1,0xCA,0x00},
-    {170,   1,   1,0x43,0x00},
-    {171,   1,   1,0xC8,0x00},
-};
-
 #define KID_SEQTBL_LEN 2310
-static const uint8_t kid_seqtbl[KID_SEQTBL_LEN] = {
-    0xF9,0x01,0xFF,0x81,0x19,0xF9,0x01,0x01,0x02,0x03,0x04,0xFB,
-    0x08,0x05,0xFB,0x03,0x06,0xFB,0x03,0x07,0xFB,0x05,0x08,0xFB,
-    0x01,0xF2,0x01,0x09,0xFB,0x02,0x0A,0xFB,0x04,0x0B,0xFB,0x05,
-    0x0C,0xFB,0x02,0xF2,0x01,0x0D,0xFB,0x03,0x0E,0xFB,0x04,0xFF,
-    0x81,0x19,0xF9,0x00,0x0F,0xFF,0xA0,0x19,0xF9,0x01,0xA6,0xFF,
-    0xA8,0x19,0xF9,0x05,0xFB,0x0A,0xB1,0xB1,0xFB,0xF9,0xFA,0xFE,
-    0xB2,0xFB,0x05,0xFA,0x02,0xA6,0xFB,0xFF,0xFF,0xD2,0x19,0xFF,
-    0xD2,0x19,0xF9,0x01,0xFB,0x02,0xCF,0xD0,0xFB,0x02,0xD1,0xFB,
-    0x02,0xD2,0xFB,0x03,0xF9,0x01,0xF2,0x00,0x9E,0xAA,0xAB,0xFF,
-    0xD8,0x19,0xF9,0x05,0xF8,0xFF,0x00,0xAC,0xFB,0xFF,0xFA,0x01,
-    0xAD,0xFB,0xFF,0xAE,0xFB,0xFF,0xFA,0x02,0xFB,0xFE,0xFA,0x01,
-    0xFB,0xFB,0xFA,0xFC,0xFF,0x4D,0x1A,0xF9,0x01,0xF8,0x01,0x00,
-    0x9B,0xFB,0x02,0xA5,0xFB,0xFE,0xFF,0xD2,0x19,0xF9,0x01,0xF8,
-    0xFF,0x00,0x9B,0x9C,0x9D,0x9E,0xFF,0x2E,0x1A,0xF9,0x01,0xF8,
-    0x01,0x00,0xFB,0x02,0xA3,0xFB,0x04,0xA4,0xA5,0xFF,0xD2,0x19,
-    0xF9,0x01,0xF8,0x01,0x00,0xFB,0x06,0xA4,0xA5,0xFF,0xD2,0x19,
-    0xF9,0x01,0xF8,0xFF,0x00,0xFB,0xFD,0xA0,0xFB,0xFE,0x9D,0xFF,
-    0xD2,0x19,0xF9,0x01,0xF8,0xFF,0x00,0xA8,0xF9,0x01,0x97,0xF9,
-    0x01,0x98,0x99,0x9A,0xF9,0x05,0x9B,0xF9,0x01,0x9C,0x9D,0xFF,
-    0xD2,0x19,0xF9,0x01,0xA7,0xFF,0x4A,0x1A,0xA2,0xFF,0x45,0x1A,
-    0xA9,0x96,0xFF,0xD2,0x19,0x9F,0xA0,0xFF,0x5F,0x1A,0xF9,0x01,
-    0xF4,0xFF,0xD2,0x19,0xF9,0x05,0xFB,0xF8,0xFF,0xD2,0x19,0xF9,
-    0x05,0xA0,0x9D,0xFF,0xD2,0x19,0xF9,0x07,0xFB,0xF8,0xFF,0x39,
-    0x1B,0xF9,0x05,0xFE,0xFB,0x05,0xFF,0x2E,0x1A,0xF9,0x05,0xFE,
-    0xFB,0x12,0xFF,0xA6,0x19,0xF9,0x01,0x10,0x11,0xFB,0x02,0x12,
-    0xFB,0x02,0x13,0xFB,0x02,0x14,0xFB,0x02,0x15,0xFB,0x02,0x16,
-    0xFB,0x07,0x17,0xFB,0x09,0x18,0xFB,0x05,0xFA,0xFA,0x19,0xFB,
-    0x01,0xFA,0x06,0x1A,0xFB,0x04,0xF4,0xF2,0x01,0x1B,0xFB,0xFD,
-    0x1C,0xFB,0x05,0x1D,0xF2,0x01,0x1E,0x1F,0x20,0x21,0xFB,0x01,
-    0xFF,0xA0,0x19,0xF9,0x01,0xF2,0x01,0x22,0xFB,0x05,0x23,0xFB,
-    0x06,0x24,0xFB,0x03,0x25,0xFB,0x05,0xF2,0x01,0x26,0xFB,0x07,
-    0x27,0xFB,0x0C,0xFA,0xFD,0x28,0xFB,0x08,0xFA,0xF7,0x29,0xFB,
-    0x08,0xFA,0xFE,0x2A,0xFB,0x04,0xFA,0x0B,0x2B,0xFB,0x04,0xFA,
-    0x03,0x2C,0xFB,0x05,0xF4,0xF2,0x01,0xFF,0x81,0x19,0xF9,0x01,
-    0xFB,0x01,0x6B,0xFB,0x02,0xFB,0x02,0x6C,0xFB,0x02,0x6D,0xFB,
-    0x02,0x6D,0xFB,0x02,0x6D,0xFF,0x16,0x1B,0x00,0xF9,0x01,0xFB,
-    0x01,0x6E,0x6F,0xFB,0x02,0x70,0xFB,0x02,0x6C,0xFB,0x02,0x6D,
-    0xFF,0x29,0x1B,0xF9,0x07,0xFE,0xFB,0x06,0x2D,0xFB,0x01,0x2E,
-    0xFF,0xC4,0x19,0xF9,0x07,0xFE,0xFB,0x06,0x2D,0xFB,0x01,0x2E,
-    0xFB,0x02,0x2F,0xFB,0xFF,0x30,0xFB,0x01,0x31,0xFB,0xFE,0x32,
-    0x33,0x34,0xFF,0xA0,0x19,0xF9,0x01,0xFB,0xFF,0xFF,0x75,0x19,
-    0xF9,0x01,0xFB,0x01,0x35,0xFB,0x01,0xF2,0x01,0x36,0xFB,0x08,
-    0x37,0xF2,0x01,0x38,0xFB,0x07,0x39,0xFB,0x03,0x3A,0xFB,0x01,
-    0x3B,0x3C,0xFB,0x02,0x3D,0xFB,0xFF,0x3E,0x3F,0x40,0xFB,0xFF,
-    0x41,0xFB,0xF2,0xFE,0xFF,0x95,0x19,0xF9,0x03,0xFA,0xFF,0x66,
-    0xFB,0xFE,0xFA,0x06,0x67,0xFB,0xFE,0xFA,0x09,0x68,0xFB,0xFF,
-    0xFA,0x0C,0x69,0xFB,0xFD,0xF8,0x00,0x0F,0xFF,0x49,0x1D,0xF9,
-    0x03,0xFA,0xFF,0xFB,0xFE,0x66,0xFB,0xFD,0xFA,0x06,0x67,0xFB,
-    0xFD,0xFA,0x09,0x68,0xFB,0xFE,0xFA,0x0C,0x69,0xFB,0xFD,0xF8,
-    0x00,0x0F,0xFF,0x49,0x1D,0xF9,0x03,0xFB,0x01,0xFA,0xFF,0x66,
-    0xFB,0x02,0xFA,0x06,0x67,0xFB,0xFF,0xFA,0x09,0x68,0xFA,0x0C,
-    0x69,0xFB,0xFE,0xF8,0x01,0x0F,0xFF,0x49,0x1D,0xF9,0x03,0xFB,
-    0x01,0xFA,0x03,0xF7,0x06,0x1C,0x66,0xFB,0x02,0xFA,0x06,0x67,
-    0xFB,0xFF,0xFA,0x09,0x68,0xFA,0x0C,0x69,0xFB,0xFE,0xF8,0x01,
-    0x0F,0xFF,0x49,0x1D,0xFB,0xFF,0xFA,0xFD,0xFF,0xE4,0x1B,0xFB,
-    0x01,0xFF,0xDB,0x1B,0x66,0xFB,0x02,0xFA,0x03,0x67,0xFB,0xFF,
-    0xFA,0x04,0x68,0xFA,0x05,0x69,0xFB,0xFE,0xF8,0x01,0x06,0xFF,
-    0x49,0x1D,0xF9,0x03,0xFB,0x01,0xFA,0x03,0x66,0xFB,0x02,0xFA,
-    0x06,0x67,0xFB,0x01,0xFA,0x09,0x68,0xFB,0x02,0xFA,0x0C,0x69,
-    0xF8,0x02,0x0F,0xFF,0x49,0x1D,0xF9,0x03,0xFB,0x01,0xFA,0x03,
-    0x66,0xFB,0x03,0xFA,0x06,0x67,0xFB,0x02,0xFA,0x09,0x68,0xFB,
-    0x03,0xFA,0x0C,0x69,0xF8,0x03,0x0F,0xFF,0x49,0x1D,0xF9,0x01,
-    0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0xF9,
-    0x02,0x4E,0x4F,0x50,0xFF,0xA1,0x1C,0xF9,0x01,0x43,0x44,0x45,
-    0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0xF9,0x02,0xFB,0x01,
-    0x4E,0xFB,0x02,0x4F,0xFB,0x01,0x50,0xFF,0xA1,0x1C,0xF9,0x01,
-    0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0xFB,0xFF,
-    0x4D,0xF9,0x02,0xFB,0xFE,0x4E,0xFB,0xFF,0x4F,0xFB,0xFF,0x50,
-    0xFF,0xA1,0x1C,0xF9,0x02,0x5B,0x5A,0x59,0x58,0x57,0x57,0x57,
-    0x58,0x59,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F,0x60,0x61,0x62,0x63,
-    0x61,0x60,0x5F,0x5E,0x5D,0x5C,0x5B,0x5A,0x59,0x58,0x57,0x58,
-    0x59,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F,0x60,0x5F,0x5E,0x5D,0x5C,
-    0xFF,0x25,0x1D,0xF9,0x06,0x5C,0x5D,0x5D,0x5C,0x5C,0x5B,0xFF,
-    0xD8,0x1C,0x87,0x88,0x89,0x89,0x8A,0x8A,0x8A,0x8A,0x89,0x88,
-    0x87,0xFB,0xF9,0xFF,0x25,0x1D,0xF9,0x01,0x94,0x91,0x90,0x8F,
-    0x8E,0x8D,0xFB,0xFB,0xFA,0x3F,0xFC,0xF9,0x03,0x8C,0x8A,0x88,
-    0x5B,0xF9,0x02,0xFF,0xA4,0x1C,0xF9,0x01,0x87,0x88,0x89,0x8A,
-    0x8B,0x8C,0xFB,0x05,0xFA,0xC1,0xFD,0x8D,0x8E,0x8F,0x90,0x91,
-    0x92,0x93,0x94,0xF9,0x05,0x95,0xF9,0x01,0x76,0x77,0xFB,0x01,
-    0xFF,0xA0,0x19,0x51,0x52,0xF9,0x05,0x53,0xF9,0x01,0xF4,0xF2,
-    0x00,0x54,0x55,0xFB,0x03,0xFF,0xA0,0x19,0xF9,0x03,0x51,0xFA,
-    0x06,0x51,0xFA,0x09,0x51,0xFA,0x0C,0xFB,0x02,0xF8,0x00,0x0C,
-    0xFF,0x49,0x1D,0xF9,0x04,0x6A,0xFF,0x4B,0x1D,0xF9,0x01,0x35,
-    0xFB,0x02,0xF2,0x01,0x36,0xFB,0x07,0x37,0xF2,0x01,0x38,0xFB,
-    0x02,0x31,0xFB,0xFE,0x32,0x33,0x34,0xFF,0xA0,0x19,0xF9,0x01,
-    0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,
-    0xF9,0x00,0xF5,0x4F,0xFF,0x25,0x1D,0xF9,0x01,0x43,0x44,0x45,
-    0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,0xFA,0xFC,
-    0x4F,0xFA,0xFE,0x4F,0x4F,0xFA,0x02,0x4F,0xFA,0x04,0xFF,0x25,
-    0x1D,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0xFA,
-    0xFF,0x4D,0xFA,0xFD,0x4E,0xFA,0xFC,0x4F,0xFA,0xF6,0x4F,0xFA,
-    0xF7,0x4F,0xFA,0xF8,0x4F,0xFA,0xF9,0x4F,0xFA,0xFA,0x4F,0xFA,
-    0xFB,0x4F,0xFA,0xFC,0x4F,0xFA,0xFD,0x4F,0xFA,0xFE,0x4F,0xFA,
-    0xFE,0x4F,0xFA,0xFF,0x4F,0xFA,0xFF,0x4F,0xFA,0xFF,0x4F,0x4F,
-    0x4F,0x4F,0xFA,0x01,0x4F,0xFA,0x01,0x4F,0xFA,0x02,0x4F,0xFA,
-    0x02,0x4F,0xFA,0x03,0x4F,0xFA,0x04,0x4F,0xFA,0x05,0x4F,0xFA,
-    0x06,0x4F,0xF8,0x00,0x06,0xFF,0x49,0x1D,0xF9,0x03,0x50,0xFF,
-    0xA1,0x1C,0xF9,0x05,0xFB,0xFC,0x32,0x33,0x34,0xFF,0xA0,0x19,
-    0xF9,0x05,0xFB,0x01,0xFA,0x03,0xF7,0x25,0x1E,0x66,0xFB,0x02,
-    0xFA,0x06,0x67,0xFB,0xFF,0xFA,0x09,0x68,0xFA,0x0C,0x69,0xFB,
-    0xFE,0xF8,0x00,0x0F,0xFF,0x49,0x1D,0x66,0xFB,0x02,0xFA,0x03,
-    0x67,0xFB,0xFF,0xFA,0x04,0x68,0xFA,0x05,0x69,0xFB,0xFE,0xF8,
-    0x00,0x06,0xFF,0x49,0x1D,0xF9,0x05,0xFB,0xFF,0xFA,0xFC,0x66,
-    0xFB,0xFF,0xFA,0x03,0xFB,0xFD,0xFA,0x01,0xF4,0xFB,0x01,0xF2,
-    0x01,0x6B,0xFB,0x02,0x6C,0xF2,0x01,0x6D,0xFF,0xB3,0x1F,0x79,
-    0xFB,0x01,0x7A,0x7B,0xFB,0x02,0x7C,0xFB,0x04,0x7D,0xFB,0x03,
-    0x7E,0xFB,0xFC,0x56,0xF2,0x01,0xF4,0xFB,0xFC,0x74,0xFB,0xFE,
-    0x75,0x76,0x77,0xFF,0xA0,0x19,0xFB,0xFB,0xFF,0xA0,0x19,0xF9,
-    0x01,0x79,0xFB,0x01,0x7A,0xFB,0x01,0x7B,0xFB,0x03,0x7C,0xFB,
-    0x04,0x7D,0xFB,0x03,0x7E,0xFB,0xFF,0xFB,0x03,0x7F,0x80,0x81,
-    0x82,0x83,0x84,0xFF,0xA0,0x19,0xF9,0x01,0x79,0xFB,0x01,0x7A,
-    0xFB,0x01,0x7B,0xFB,0x03,0x7C,0xFB,0x04,0x7D,0xFB,0x03,0x7E,
-    0xFB,0xFF,0xFB,0x02,0x7F,0x80,0x81,0x82,0x83,0x84,0xFF,0xA0,
-    0x19,0xF9,0x01,0x79,0xFB,0x01,0x7A,0xFB,0x01,0x7B,0xFB,0x03,
-    0x7C,0xFB,0x04,0x7D,0xFB,0x03,0x7E,0xFB,0xFF,0xFB,0x01,0x7F,
-    0x80,0x81,0x82,0x83,0x84,0xFF,0xA0,0x19,0xF9,0x01,0x79,0xFB,
-    0x01,0x7A,0xFB,0x01,0x7B,0xFB,0x03,0x7C,0xFB,0x04,0x7D,0xFB,
-    0x03,0x7E,0xFB,0xFF,0x7F,0x80,0x81,0x82,0x83,0x84,0xFF,0xA0,
-    0x19,0xF9,0x01,0x79,0xFB,0x01,0x7A,0xFB,0x01,0x7B,0xFB,0x03,
-    0x7C,0xFB,0x04,0x7D,0xFB,0x03,0x7E,0xFB,0xFE,0x80,0x81,0x82,
-    0x83,0x84,0xFF,0xA0,0x19,0xF9,0x01,0x79,0xFF,0xFC,0x1E,0xF9,
-    0x01,0x79,0xFB,0x01,0x7A,0xFB,0x01,0x7B,0xFB,0x03,0x7C,0xFB,
-    0x04,0x7D,0xFB,0xFF,0x7F,0x80,0x81,0x82,0x83,0x84,0xFF,0xA0,
-    0x19,0xF9,0x01,0x79,0xFB,0x01,0x7A,0xFB,0x01,0x7B,0xFB,0x03,
-    0x7C,0xFB,0x02,0x81,0x82,0x83,0x84,0xFF,0xA0,0x19,0xF9,0x01,
-    0x79,0xFB,0x01,0x7A,0xFB,0x01,0x7B,0xFB,0x02,0x7C,0xFB,0x02,
-    0x81,0x82,0x83,0x84,0xFF,0xA0,0x19,0xF9,0x01,0x79,0xFB,0x01,
-    0x7A,0xFB,0x01,0x7B,0xFB,0x02,0x7C,0xFB,0x01,0x81,0x82,0x83,
-    0x84,0xFF,0xA0,0x19,0xF9,0x01,0x79,0xFB,0x01,0x7A,0xFB,0x01,
-    0x7B,0xFB,0x02,0x83,0x84,0xFF,0xA0,0x19,0xF9,0x01,0x79,0xFB,
-    0x01,0x7A,0xFB,0x01,0x7B,0xFB,0x01,0x83,0x84,0xFF,0xA0,0x19,
-    0xF9,0x01,0x79,0xFB,0x01,0x7A,0xFB,0x01,0x84,0xFF,0xA0,0x19,
-    0xF9,0x01,0x79,0xFB,0x01,0x84,0xFF,0xA0,0x19,0xF9,0x01,0xFB,
-    0x01,0x6B,0xFB,0x02,0x6C,0x6D,0xFF,0xAF,0x1F,0xF9,0x05,0xFB,
-    0x01,0x6E,0x6F,0xFB,0x02,0x70,0x71,0xFB,0x01,0x72,0x73,0x74,
-    0xFB,0xFC,0x75,0x76,0x77,0xFF,0xA0,0x19,0xF9,0x01,0xF3,0x01,
-    0xE5,0xE5,0xE5,0xE5,0xE5,0xE5,0xE6,0xE7,0xE8,0xFF,0xDA,0x1F,
-    0xF9,0x01,0xFB,0xFB,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,0xF0,
-    0x85,0x85,0x86,0x86,0x86,0x30,0xFB,0x01,0x31,0xFB,0xFE,0xF9,
-    0x05,0x32,0xF9,0x01,0x33,0x34,0xFF,0xA0,0x19,0xF9,0x01,0xFB,
-    0xFB,0xEA,0xEC,0xEE,0xF0,0x86,0xFB,0xFF,0xFF,0xA0,0x19,0xF9,
-    0x01,0xFB,0x04,0xBF,0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xF2,0x03,
-    0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCD,0xCD,0xF3,0x01,
-    0xCD,0xCD,0xC9,0xC6,0xFB,0xFC,0xFF,0xA0,0x19,0xF9,0x05,0xF4,
-    0xFB,0x01,0x6B,0xFB,0x02,0x6C,0xF9,0x01,0x6D,0xFF,0x36,0x20,
-    0xF9,0x01,0xFA,0xFE,0xFB,0x01,0x6B,0xFB,0x02,0x6C,0x6D,0xFB,
-    0x01,0x6E,0x6F,0xFB,0x02,0x70,0x71,0xFB,0x01,0xFA,0x01,0x72,
-    0xFA,0x01,0x73,0xFB,0xFE,0xFF,0x78,0x19,0xF9,0x05,0xF4,0xFA,
-    0xFE,0xFB,0x01,0xFB,0x02,0x6C,0x6D,0x6D,0x6D,0x6D,0x6D,0x6D,
-    0x6D,0x6D,0x6D,0x6D,0x6D,0x6D,0x6D,0x6D,0x6D,0x6D,0x6D,0x6D,
-    0x6D,0x6D,0x6D,0x6D,0x6D,0x6D,0x6D,0x6D,0x6D,0x6D,0x6D,0xFB,
-    0x01,0x6E,0x6E,0x6E,0x6F,0xFB,0x02,0x70,0x71,0xFB,0x01,0xFA,
-    0x01,0x72,0xFA,0x01,0x73,0x74,0xFB,0xFC,0x75,0x76,0x77,0xFF,
-    0xA0,0x19,0xF9,0x05,0xF4,0xFA,0xFE,0xFB,0x03,0xB9,0xF6,0xB9,
-    0xFF,0xA5,0x20,0xF9,0x05,0xFF,0xAE,0x20,0xF9,0x01,0xF6,0xB3,
-    0xB4,0xB5,0xB6,0xFB,0x01,0xB7,0xFB,0xFC,0xB9,0xFF,0xBA,0x20,
-    0xF9,0x01,0xF4,0xFB,0x04,0xB1,0xF6,0xB1,0xFF,0xC5,0x20,0xF9,
-    0x01,0xB2,0xF6,0xB2,0xFF,0xCD,0x20,0xFF,0x5A,0x20,0xF8,0x00,
-    0x00,0xF9,0x04,0xB9,0xFF,0xD9,0x20,0xF9,0x05,0xFB,0xFB,0xFA,
-    0xFF,0xF2,0x01,0xD9,0xDA,0xDB,0xFB,0x01,0xDC,0xFB,0xFC,0xFA,
-    0xFD,0xF2,0x01,0xDD,0xFB,0xFC,0xFA,0xFE,0xDE,0xFB,0xFE,0xFA,
-    0xFD,0xDF,0xFB,0xFD,0xFA,0xF8,0xF2,0x04,0xF2,0x01,0xE0,0xFB,
-    0xFF,0xFA,0xFF,0xE1,0xFB,0xFD,0xFA,0xFC,0xE2,0xFB,0xFF,0xFA,
-    0xFB,0xF2,0x01,0xE3,0xFB,0xFE,0xFA,0xFF,0xE4,0x00,0xF2,0x01,
-    0x00,0x00,0x00,0xF2,0x01,0x00,0x00,0x00,0xF2,0x01,0x00,0x00,
-    0x00,0xF2,0x01,0xF1,0x00,0xFF,0x2E,0x21,0x36,0xFF,0x32,0x21,
-    0x55,0x43,0x43,0x43,0x43,0x43,0x43,0x43,0x43,0x43,0x43,0x44,
-    0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x53,0x54,0x4C,0xFF,0x4B,
-    0x21,0xFB,0x01,0x30,0xFB,0x02,0x31,0xFB,0x06,0x32,0xFB,0x01,
-    0x33,0xFB,0xFF,0x34,0xFB,0x01,0x35,0xFB,0x01,0xFF,0x51,0x21,
-    0xFB,0x01,0x37,0x38,0xFF,0x32,0x21,0x4D,0x4E,0x4F,0x50,0x51,
-    0x52,0xFB,0x01,0x36,0x36,0x36,0x36,0x36,0x36,0x39,0x3A,0x3B,
-    0x3C,0x3D,0xFB,0x02,0x3E,0xFB,0xFF,0x3F,0xFB,0xFD,0x40,0x41,
-    0xFB,0xFF,0x42,0xFE,0xFB,0x10,0xFB,0x03,0xFF,0x54,0x21,0x0B,
-    0xFF,0x95,0x21,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0xFE,
-    0xFB,0x08,0x0B,0xFF,0x95,0x21,0xFE,0xFB,0x0B,0x0C,0xFB,0x01,
-    0x0D,0xFB,0x01,0x0E,0xFB,0x03,0x0F,0xFB,0x01,0x10,0x11,0xFF,
-    0xB8,0x21,0x13,0xFF,0xBC,0x21,0x14,0xFF,0xC0,0x21,0x15,0xFB,
-    0x01,0x16,0x17,0x18,0xFB,0x01,0x19,0xFB,0xFD,0x1A,0xFB,0xFE,
-    0x1B,0xFB,0xFC,0x1C,0xFB,0xFD,0x1D,0xFB,0xFE,0x1E,0xFB,0xFD,
-    0x1F,0xFB,0xFF,0x20,0x21,0xFF,0xE2,0x21,0x25,0xFF,0xE6,0x21,
-    0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,0xFE,
-    0xFB,0x0C,0x0B,0xFF,0xF8,0x21,0x0B,0x0B,0xFE,0xFB,0x0D,0x2F,
-    0x2E,0x2D,0x2C,0x2B,0x2A,0x29,0x28,0x27,0x26,0x25,0x24,0x24,
-    0x24,0x23,0x23,0x23,0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x23,
-    0x23,0x24,0x24,0x24,0x23,0x23,0x23,0x22,0x22,0x22,0x22,0x22,
-    0x22,0x22,0x23,0x23,0x24,0x24,0x24,0x23,0x23,0x23,0x22,0x22,
-    0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x23,0x23,0x23,0x24,0xFF,
-    0x3C,0x22,0x01,0x12,0xFF,0x41,0x22,0xF9,0x01,0xBA,0xFB,0x05,
-    0xBA,0xFB,0x03,0xBB,0xFB,0x04,0xFF,0x47,0x22,0xBA,0xFF,0x53,
-    0x22,0xBC,0xFF,0x57,0x22,0xF9,0x00,0xBA,0xBA,0xBA,0xBC,0xBC,
-    0xBC,0xBC,0xBC,0xBC,0xBC,0xBC,0xFE,0xFB,0x08,0xFF,0x47,0x22,
-    0xBA,0xBA,0xBC,0xFF,0x70,0x22,
-};
+
+/* Раскладка kid_data.bin: кадры (KID_NFRAMES*5), затем seqtbl. */
+#define KID_BIN_FRAMES_OFF 0
+#define KID_BIN_SEQTBL_OFF 1205
+/* Таблица кадров СТРАЖА (frame_tbl_guard, seg006:372): индекс
+ * frame + add_frame - 149 (add_frame=70 для кадров 102..106). */
+#define KID_NGFRAMES 41
+#define KID_BIN_GFRAMES_OFF 3515

 #define KID_NSEQ 115
 static const uint16_t kid_seq_off[KID_NSEQ] = {
@@ -471,4 +42,31 @@ static const uint16_t kid_seq_off[KID_NSEQ] = {
    0x21FC,0x2240,0x2257,
 };

+/* sword_tbl (seg006:2047): клинок отдельным спрайтом chtab_0.
+ * Индекс — sword_frame (кадр.sword & 0x3F), id 255 = клинка нет.
+ * Смещения x/y — ЭКРАННЫЕ (применяются после calc_screen_x_coord),
+ * x — «вперёд» по направлению персонажа. */
+#define KID_NSWORD 51
+#define KID_SWORD_ID_INIT { \
+    0xFF,0x00,0x05,0x01,0x02,0x06,0x07,0x03,0x04,0x1E,0x08,0x09, \
+    0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,0x10,0x11,0x12,0x13,0x13,0x11, \
+    0x11,0x07,0x01,0x1C,0x08,0x04,0x04,0x0A,0x0D,0x0D,0x0D,0x14, \
+    0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0xFF,0xFF,0x1D,0x08,0x1F, \
+    0x20,0x21,0x08, \
+}
+#define KID_SWORD_DX_INIT { \
+    0,0,-9,7,17,7,0,17,16,12,13,7, \
+    10,10,22,28,13,0,0,21,14,21,22,7, \
+    15,0,7,14,7,6,9,11,24,19,21,7, \
+    14,14,14,28,28,21,14,14,21,0,8,14, \
+    14,7,8, \
+}
+#define KID_SWORD_DY_INIT { \
+    0,-9,-29,-25,-26,-14,-5,-16,-19,-9,-34,-25, \
+    -16,-11,-21,-23,-35,-38,-29,-19,-23,-22,-23,-13, \
+    -18,-8,-27,-28,-27,-23,-21,-18,-23,-23,-23,-32, \
+    -32,-31,-29,-28,-28,-25,-22,-25,-25,-16,-37,-24, \
+    -24,-14,-37, \
+}
+
 #endif
@@ -25,13 +25,18 @@
 /* Экранный y нижней границы поля (ниже — статус-полоса + борт → клип). */
 #define POP_CLIP_BOTTOM (POP_YOFF + POP_PLAYFIELD_H)

+/* Выбор ядра libbgi (pop_onscreen_cols / pop_heal_fast) переехал в
+ * `_pop_draw.h` — его включают только три рисующих модуля.  Из общего
+ * заголовка SDCC размножал мёртвые копии этих inline'ов по всем TU: см.
+ * шапку `_pop_draw.h`. */
+
 /* Загрузить 7 атласов фона.  Звать ДО initgraph (как poc.c — atlas_load
 * трогает W3; проверенный порядок).  Палитру pop_bg.pal грузит ПРИЛОЖЕНИЕ
 * после initgraph (gfx_pal_fload).  0 — OK, -1 — ошибка. */
-int  pop_bg_load(void);
+int  pop_bg_load(void) __banked;

 /* Освободить EMM-страницы атласов. */
-void pop_bg_free(void);
+void pop_bg_free(void) __banked;

 /* Нарисовать комнату: fg[30]/bg[30] — foretable-коды/backtable-модификаторы
 * (по строкам, row*10+col).  lcol_fg/lcol_bg — 3 тайла правого столбца
@@ -39,93 +44,132 @@ void pop_bg_free(void);
 * тогда левая кромка = стена.  room_num — номер комнаты (зерно стен). */
 void pop_room_draw(uint8_t room_num,
                   const uint8_t *fg, const uint8_t *bg,
-                   const uint8_t *lcol_fg, const uint8_t *lcol_bg);
+                   const uint8_t *lcol_fg, const uint8_t *lcol_bg) __banked;

-/* Задать ряд 0 комнаты СНИЗУ (fg-коды, 10 шт.) — для draw_tile_topright,
- * когда тайл нижнего ряда стал empty (после падения loose): «стена вниз»
- * рисуется по коду room_B(0, col-1).  0 — нет комнаты снизу. */
-void pop_room_set_below(const uint8_t *below_row0_fg);
+/* Задать ряд 0 комнаты СНИЗУ — для draw_tile_topright, когда тайл нижнего
+ * ряда стал empty (после падения loose): «стена вниз» рисуется по коду
+ * room_B(0, col-1).  ОДИННАДЦАТЬ байт: [0..9] — колонки комнаты снизу,
+ * [10] — тайл (0,9) комнаты СНИЗУ-СЛЕВА (сосед угла (2,0); см.
+ * load_rowbelow, seg008:368).  0 — нет комнаты снизу. */
+void pop_room_set_below(const uint8_t *below_row0_fg) __banked;

 /* Задать ряд 2 (fg-коды + модификаторы, 10 шт.) комнаты СВЕРХУ — для полосы
 * кладки у потолка (seg008 draw_room доп. верхний ряд из room_A).  0 — нет
 * комнаты сверху (кромка уровня → пол). */
-void pop_room_set_above(const uint8_t *above_row2_fg, const uint8_t *above_row2_mod);
+void pop_room_set_above(const uint8_t *above_row2_fg, const uint8_t *above_row2_mod) __banked;

 /* Перерисовать передний слой (fore) тайлов футпринта Kid ПОВЕРХ него —
 * звать ПОСЛЕ kid_draw.  obj_x — ЛОГИЧЕСКАЯ X кадра (до ×8/7), obj_y — низ
 * спрайта, w/h — размер кадра, dir — направление Kid (<0 влево).  Метрики
 * берутся из pop_kid (kid_fp_*).  См. redraw_at_char/set_char_collision. */
 void pop_fore_over_kid(int obj_x, int obj_y, uint16_t w, uint16_t h,
-                       int8_t dir, uint8_t frame, uint8_t action);
+                       int8_t dir, uint8_t frame, uint8_t action) __banked;
+
+/* Окно fore-слоя: прямоугольник СПРАЙТА (экранные координаты, y уже с
+ * POP_YOFF), поверх которого fore-проход возвращает куски тайлов.  Ставит
+ * тот, кто нарисовал спрайт (kid_draw / pop_guard_draw) — он один знает
+ * итоговый габарит (у Kid — с учётом клинка и обрезки clip_char).  Вне
+ * fore-проходов окно игнорируется: фон рисуется целиком.  Мотивация и
+ * замер — в pop_bg.c у fclip_on. */
+void pop_fore_set_clip(int x, int y, int w, int h) __banked;
+
+/* То же для НЕ-Kid персонажа (страж): только слой fore + полоса потолка,
+ * без оверлеев поз виса/полёта/подъёма.  obj_x — ЛОГИЧЕСКАЯ координата
+ * (до ×8/7), как у kid_fp_obj_x(). */
+/* __banked: отрисовка стража уехала в СВОЙ банк (pop_gdraw.c), поэтому
+ * вызов стал кроссбанковым и обязан идти через трамплин.  Зовётся раз в
+ * кадр, других вызывающих нет — цена одного трамплина здесь не видна. */
+/* ex/ey/ew/eh — ОБЪЕДИНЁННЫЙ экранный прямоугольник «персонаж + клинок +
+ * брызги» (тот же, что уходит в pop_fore_set_clip): перебор передних тайлов
+ * идёт по нему, иначе меч и звёздочка удара остаются поверх кладки.
+ * ew == 0 — расширения нет (только габарит кадра). */
+void pop_fore_over_char(int obj_x, int obj_y, uint16_t w, uint16_t h,
+                        int8_t dir, uint8_t sword,
+                        int ex, int ey, uint16_t ew, uint16_t eh,
+                        uint8_t action, int8_t ccol, int8_t crow) __banked;

 /* Восстановить фон там, где в прошлых кадрах рисовался ОВЕРЛЕЙ
 * (draw_other_overlay/floor_overlay/полоса потолка): он выходит за
 * прямоугольник Kid, поэтому kid_heal его не убирает — на второй странице
 * дабл-буфера остаётся след и мерцает.  Звать рядом с kid_heal. */
-void pop_fore_heal(void);
+void pop_fore_heal(void) __banked;

 /* Loose floors — динамическая отрисовка (состояние pop_loose_modif в
 * pop_map).  Звать на ТЕКУЩЕЙ (back) странице из pop_loose_tick.
 * shake_draw — дрожащий кадр (heal+SPRITE); bake_empty — запечь пустоту
 * после падения (NORMAL, в ОЗУ-копию). */
-void pop_loose_shake_draw(int row, int col);
-void pop_loose_bake_empty(int row, int col);
+void pop_loose_shake_draw(int row, int col) __banked;
+void pop_loose_bake_empty(int row, int col) __banked;

 /* Плита-ПОТОЛОК (loose ряда 2 комнаты СВЕРХУ, наш ряд −1): дрожащий кадр в
 * полосе у потолка / «запечь» пустоту (колодец наверх) после провала.
 * Состояние — pop_ceil_modif[10] в pop_map. */
-void pop_ceil_shake_draw(int col);
-void pop_ceil_bake_empty(int col);
+void pop_ceil_shake_draw(int col) __banked;
+void pop_ceil_bake_empty(int col) __banked;

-/* Кусок приземлился (loose_land): 0 = нет, иначе tilepos+1 тайла, на который
- * он лёг.  Ставит pop_loose_mob_tick, разбирает pop_loose_tick (debris+knock). */
-extern uint8_t pop_loose_landed;
+/* Кусок приземлился (loose_land) — переехал в pop_state.h: переменную
+ * читают по обе стороны банковой границы. */
+#include "pop_state.h"

 /* Пики (spike) — перерисовка тайла (row,col) на back-странице по живому
 * modif (pop_trob).  Звать из pop_process_trobs.  См. pop_bg.c. */
-void pop_spike_redraw(int row, int col);
+void pop_spike_redraw(int row, int col) __banked;

 /* Анимация факела/зелья (динамика каждый кадр; фон запечён без них):
 * modif — живой room_modif тайла.  Для факела col — колонка САМОГО факела
 * (пламя рисуется в ячейке правого соседа). */
-void pop_torch_draw(int row, int col, uint8_t modif);
-void pop_potion_draw(int row, int col, uint8_t modif);
+void pop_torch_draw(int row, int col, uint8_t modif) __banked;
+void pop_potion_draw(int row, int col, uint8_t modif) __banked;

 /* Ворота на ЛЕВОМ шве (col0) — перерисовать по живому modif соседа слева.
 * g_lbg (lcol_bg) должен быть обновлён вызывающим.  Звать из основного цикла
 * на back-странице, когда сосед слева анимируется.  См. pop_bg.c. */
-void pop_room_redraw_seam_left(void);
+void pop_room_redraw_seam_left(void) __banked;

 /* Перерисовать ПОЛ тайла (row,col) + правую грань в соседе на back-странице
 * (wipe по площади пола, БЕЗ стены ряда ниже).  Для смены тайла на месте:
 * кнопка нажата/отжата, floor → debris от упавшей плиты. */
-void pop_floor_bake(int row, int col);
-void pop_button_redraw(int row, int col);   /* = pop_floor_bake (кнопка) */
+void pop_floor_bake(int row, int col) __banked;
+void pop_button_redraw(int row, int col) __banked;   /* = pop_floor_bake (кнопка) */
+
+/* Дверь уровня: перерисовать её ПРАВУЮ половину (row, col = правая) с
+ * запечкой — створка анимируется (pop_trob animate_leveldoor). */
+void pop_leveldoor_redraw(int row, int col) __banked;
+
+/* Ворота ВНУТРИ отрисованной комнаты: перерисовать по живому modif.
+ * (row,col) — координаты САМИХ ворот; бары рисует ячейка правого соседа
+ * (draw_tile, ветка lcode==4), туда и идёт wipe+redraw.  Порт draw_trob
+ * (seg007:01E6), которым заканчивается animate_door. */
+void pop_gate_redraw(int row, int col) __banked;

 /* Падающий кусок loose (mob, seg007 move_loose): спавн при падении тайла
 * (row,col) и покадровое продвижение+отрисовка на back-странице.  tick
 * зовётся каждый кадр (внутри pop_loose_tick); клип низа делает clip. */
-void pop_loose_mob_spawn(int row, int col);
-void pop_loose_mob_tick(void);
-void pop_loose_mob_reset(void);   /* остановить кусок (смена комнаты) */
+void pop_loose_mob_spawn(int row, int col) __banked;
+void pop_loose_mob_tick(void) __banked;
+void pop_loose_mob_reset(void) __banked;   /* убрать все куски (СТАРТ УРОВНЯ, mobs_count=0) */
+
+/* Смена комнаты: куски продолжают падать в СВОИХ комнатах (do_mobs крутит
+ * mobs[] независимо от drawn_room), сбрасывается только heal-история. */
+void pop_loose_mob_room_changed(void) __banked;

 /* Кусок НИЖЕ Kid по obj_y → рисуется ПОВЕРХ него (порт sort_curr_objs,
 * seg008:1561).  Звать после kid_draw, перед fore-слоем. */
-void pop_loose_mob_draw_over(void);
+void pop_loose_mob_draw_over(void) __banked;

 /* Позиция куска (колонка, y низа) для check_loose_fall_on_kid.  0 — нет. */
-uint8_t pop_loose_mob_pos(int *col, int *y);
+uint8_t pop_loose_mob_pos(int *col, int *y) __banked;

 /* Детектор выхода спрайта за поле: если спрайт [x,w] с ЭКРАННЫМ верхом
 * sy_top и высотой h заходит ниже поля (статус-полоса/борт) или выше
 * верхнего борта — взводит внутренний флаг «борта грязные» на 2 кадра.
 * Звать СРАЗУ после блита падающего объекта (Kid/кусок). */
-void pop_clip_sprite(int x, int w, int sy_top, int h);
+void pop_clip_sprite(int x, int w, int sy_top, int h) __banked;

 /* Почистить борта (верхний + статус-полоса/нижний) — но ТОЛЬКО в кадрах,
 * где кто-то реально вышел за поле (гейт по флагу от pop_clip_sprite):
 * даром в покое, O(1) при падении (не зависит от числа спрайтов).  Звать
 * КАЖДЫЙ кадр ПОСЛЕ kid_draw+fore на back-странице. */
-void pop_room_clip_borders(void);
+void pop_room_clip_borders(void) __banked;

 #endif
@@ -0,0 +1,32 @@
+/*
+ * pop_char.h — состояние ПЕРСОНАЖА, общее для Кида, стража и активной
+ * копии Char.  Порт char_type (types.h:302).
+ *
+ * Зачем отдельным заголовком: интерпретатор последовательностей в
+ * оригинале один на всех (работает с Char, а вокруг стоят
+ * loadkid/savekid и loadshad/saveshad, seg006:809).  Пока у Кида был свой
+ * усечённый тип, а у стража свой, общий интерпретатор был невозможен.
+ * Поля и их порядок — как в char_type, чтобы порт seg005/seg006 ложился
+ * один в один.
+ */
+#ifndef POP_CHAR_H
+#define POP_CHAR_H
+
+#include <stdint.h>
+
+typedef struct {
+    uint8_t frame;
+    uint8_t x, y;
+    int8_t  direction;      /* -1 влево, 0 вправо */
+    int8_t  curr_col, curr_row;
+    uint8_t action;
+    int8_t  fall_x, fall_y;
+    uint8_t room;
+    uint8_t repeat;
+    uint8_t charid;         /* 0 = Kid, 2 = страж (см. CHARID_* в pop_guard.h) */
+    uint8_t sword;
+    int8_t  alive;          /* -1 = жив (как в оригинале), 0 = убит */
+    uint16_t curr_seq;      /* адрес в seqtbl (база SEQTBL_BASE) */
+} pop_char_t;
+
+#endif
@@ -0,0 +1,30 @@
+/*
+ * pop_cheat.h — режим читов (порт cheats_enabled, seg000:111).
+ *
+ * В оригинале включается ключом командной строки megahit/debug и меняет
+ * набор доступных клавиш.  У нас конфигурации/UI пока нет, поэтому это
+ * просто глобальный флаг: main ставит его при старте (на время разработки —
+ * ВКЛЮЧЁН).  Клавиши читов обрабатывает главный цикл.
+ *
+ * Реализовано: K — убить стража (seg000:786), I/S/Shift+L (наши отладочные),
+ * [ / ] — подгонка Кида по X (seg000:1828).  Остальные читы оригинала
+ * (время, перо, воскрешение, переход по комнатам) пока не портированы.
+ */
+#ifndef POP_CHEAT_H
+#define POP_CHEAT_H
+
+#include <stdint.h>
+
+extern uint8_t pop_cheats;      /* 0 = выключены, иначе включены */
+
+#define KBD_CHEAT_KILL 0x42     /* K (PS/2 set 2) — kill guard */
+#define KBD_CHEAT_IMMO 0x43     /* I (PS/2 set 2) — бессмертие Кида (toggle) */
+#define KBD_CHEAT_SWORD 0x1B    /* S (PS/2 set 2) — выдать Киду меч          */
+#define KBD_CHEAT_NEXTLVL 0x4B  /* Shift+L (PS/2 set 2) — следующий уровень  */
+#define KBD_CHEAT_XDEC 0x54     /* [ (PS/2 set 2) — сдвинуть Кида на 1 px влево  */
+#define KBD_CHEAT_XINC 0x5B     /* ] (PS/2 set 2) — сдвинуть Кида на 1 px вправо */
+
+/* Последний уровень игры (tbl_* в pop_level рассчитаны на 0..15). */
+#define POP_LAST_LEVEL 15
+
+#endif
@@ -17,8 +17,11 @@
 */
 #include <stdint.h>
 #include <kbd_raw.h>
+#include "pop_state.h"
+#include "pop_ctrl.h"         /* свой API (__banked) + объявления шины control_* */
 #include "pop_kid.h"
 #include "pop_map.h"
+#include "pop_guard.h"        /* charid, состояние меча, seq стража */

 /* Отладочные клавиши осторожного шага (эмуляция Shift+стрелка) для тестов в
 * MAME, где Shift трудно подать: J = шаг влево, L = шаг вправо.  PS/2 set2
@@ -51,12 +54,15 @@
 #define SEQ_49_STAND_UP_FROM_CROUCH 49
 #define SEQ_50_CROUCH              50
 #define SEQ_79_CROUCH_HOP          79
+#define SEQ_78_DRINK               78   /* выпить зелье               */
+#define SEQ_91_PICKUP_SWORD        91   /* поднять меч (pickupsword) */
 #define SEQ_STEP_BASE              28   /* +distance(1..14) = seq 29..42 шаг-N */
 #define SEQ_39_UNSAFE_STEP         39   /* шаг за кромку (distance 11)         */
 #define SEQ_44_STEP_ON_EDGE        44
 #define SEQ_14_JUMP_INTO_CEILING   14   /* прыжок вверх: сверху стена/пол      */
 #define SEQ_28_JUMP_NOTHING_ABOVE  28   /* прыжок вверх: сверху пусто          */
 #define SEQ_25_HANG_AGAINST_WALL   25   /* вис у стены (Shift в висе)          */
+#define SEQ_GO_UP_LEVELDOOR        70   /* seq_70_go_up_on_level_door          */

 #define FRAME_7_RUN         7
 #define FRAME_11_RUN       11
@@ -69,18 +75,25 @@
 #define FRAME_109_CROUCH  109

 /* ---- Состояние управления (seg006 globals) ------------------------ *
- * control_x/y/shift — «сырое» состояние осей ЭТОГО кадра (абсолютно:
- * X LEFT/-1..RIGHT/+1); *_forward/backward/up/down/shift2 — конечный
- * автомат held/released/ignore (авто-повтор); ctrl1_* — их память между
- * кадрами (rest/save). */
-static int8_t control_x, control_y, control_shift;
-static int8_t control_forward, control_backward, control_up, control_down, control_shift2;
+ * Сами control_* ЖИВУТ В pop_state.c, а не здесь.  Модуль уехал в БАНК 5,
+ * а шину пишут с трёх сторон (этот банк, guards.c из банка 1) и читают из
+ * банка 3 (pop_map) — это ровно тот случай, для которого pop_state и
+ * заведён.  Сегодня оно работало бы и отсюда: банки собираются БЕЗ
+ * --bank-data, поэтому их писучие данные остаются в общем _DATA.  Но это
+ * флаг сборки, а не свойство кода: включат --bank-data ради экономии
+ * W1/W2 — и шина молча уедет в страницу банка.
+ *
+ * ctrl1_* остаются здесь: их трогает только этот модуль. */
 static int8_t ctrl1_forward, ctrl1_backward, ctrl1_up, ctrl1_down, ctrl1_shift2;

 /* ---- seqtbl_offset_char: сменить последовательность Kid ------------ *
 * Обёртка над kid_set_seq (единая точка в pop_kid — kid_seq_off/kid_seqtbl
 * не дублируются в этот TU). */
-#define seqtbl_offset_char(seq)  kid_set_seq(seq)
+/* В оригинале seqtbl_offset_char работает с АКТИВНЫМ персонажем, и
+ * control() вызывается внутри окна Char.  Раньше макрос вёл на
+ * kid_set_seq (пишет прямо в Kid) — после введения окна это ломало ввод:
+ * savekid затирал Kid копией Char со старой curr_seq. */
+#define seqtbl_offset_char(seq)  pop_char_set_seq(seq)

 static int8_t release_arrows(void)
 {
@@ -104,17 +117,43 @@ static void standing_jump(void)
    seqtbl_offset_char(SEQ_3_STANDING_JUMP);
 }

+/* check_get_item (seg005:061F): решение по тайлам принимает pop_map, здесь
+ * только исполнение.  Триггер в оригинале — Shift (control_shift2) в стойке
+ * или в приседе: первый раз Kid приседает к предмету, второй — поднимает.
+ * Возврат 1 = управление обработано (caller делает return). */
+static uint8_t get_item_action(void)
+{
+    uint8_t a = pop_get_item_action();
+    if (a == 1) { crouch(); return 1; }
+    if (a == 2) {
+        control_shift2 = CONTROL_IGNORE;       /* do_pickup: без авто-повтора */
+        seqtbl_offset_char(SEQ_91_PICKUP_SWORD);
+        return 1;
+    }
+    if (a == 3) {                              /* зелье — выпить (get_item) */
+        control_shift2 = CONTROL_IGNORE;
+        seqtbl_offset_char(SEQ_78_DRINK);
+        return 1;
+    }
+    return 0;
+}
+
+/* run_jump (seg005:0AA8).  Выравнивание по кромке пола живёт в pop_map
+ * (там тайловые запросы) — pop_run_jump_align; здесь только диспетчерская
+ * часть.  Отказ выравнивателя = прыжка в этом кадре НЕТ, и control_up
+ * гасить нельзя: Кид бежит дальше с зажатой «вверх» и попробует снова на
+ * следующем кадре.  Ровно так игрок и «ловит» фазу перед провалом. */
 static void run_jump(void)
 {
-    /* Оригинал выравнивает Kid по краю пола (нужны tile-запросы) — это
-     * полировка K3; K2b просто запускает run-jump. */
-    if (Kid.frame >= FRAME_7_RUN) {
+    if (Char.frame >= FRAME_7_RUN) {
+        if (!pop_run_jump_align()) return;
        control_up = release_arrows();
        seqtbl_offset_char(SEQ_4_RUN_JUMP);
    }
 }

 static void safe_step(void);   /* fwd */
+static void draw_sword(void);  /* fwd: нужен в control_standing */

 static void forward_pressed(void)
 {
@@ -155,8 +194,15 @@ static void jump_up(void)

 static void up_pressed(void)
 {
-    /* (дверь уровня/телепорт — нет в тесте.)  ↑+forward = прыжок с места;
-     * иначе вертикальный прыжок вверх. */
+    /* Дверь уровня рядом и открыта → войти в неё: постановку в проём
+     * (go_up_leveldoor) делает pop_leveldoor_enter, здесь остаётся только
+     * последовательность подъёма по лестнице.  Телепортов у нас нет — это
+     * модификация SDLPoP, а не оригинал.
+     * Иначе: ↑+forward = прыжок с места, иначе вертикальный прыжок вверх. */
+    if (pop_leveldoor_enter()) {
+        seqtbl_offset_char(SEQ_GO_UP_LEVELDOOR);
+        return;
+    }
    if (control_x == CONTROL_HELD_FORWARD)
        standing_jump();
    else
@@ -173,15 +219,15 @@ static void safe_step(void)
    control_forward = CONTROL_IGNORE;
    distance = pop_edge_distance();
    if (distance) {
-        Kid.repeat = 1;
+        Char.repeat = 1;
        seqtbl_offset_char((uint8_t)(distance + SEQ_STEP_BASE));
    } else if (pop_edge_type() == EDGE_WALL) {
        /* вплотную к стене: маленький шаг-1 — check_bumped отскочит назад
         * (шаг назад со звуком, как оригинал), НЕ seq_39 (шаг за край=падение). */
-        Kid.repeat = 1;
+        Char.repeat = 1;
        seqtbl_offset_char((uint8_t)(1 + SEQ_STEP_BASE));
-    } else if (Kid.repeat != 0) {
-        Kid.repeat = 0;
+    } else if (Char.repeat != 0) {
+        Char.repeat = 0;
        seqtbl_offset_char(SEQ_44_STEP_ON_EDGE);
    } else {
        seqtbl_offset_char(SEQ_39_UNSAFE_STEP);   /* реальный обрыв (edge=CLOSER) */
@@ -191,6 +237,8 @@ static void safe_step(void)
 /* ---- control_* обработчики состояний ------------------------------ */
 static void control_crouched(void)
 {
+    /* Shift в приседе — поднять предмет (seg005 control_crouched). */
+    if (control_shift2 == CONTROL_HELD && get_item_action()) return;
    if (control_y != CONTROL_HELD_DOWN) {
        seqtbl_offset_char(SEQ_49_STAND_UP_FROM_CROUCH);
    } else if (control_forward == CONTROL_HELD) {
@@ -201,7 +249,37 @@ static void control_crouched(void)

 static void control_standing(void)
 {
-    /* Kid charid_0, без меча: остаётся нижняя часть control_standing. */
+    /* Shift в стойке над предметом — присесть к нему (seg005:0358, первая
+     * строка control_standing).  Идёт ДО остальных shift-веток. */
+    if (control_shift2 == CONTROL_HELD && control_shift == CONTROL_HELD &&
+        get_item_action())
+        return;
+    /* Ветку «charid != kid && вниз+вперёд -> draw_sword» не портируем: у нас
+     * соперник до control_standing не доходит, его перехватывает
+     * control_guard_inactive в самом диспетчере (порядок как в seg005). */
+
+    /* seg005:352 — Кид с мечом ВИДИТ активного стража: достаёт клинок сам.
+     * Без этого игрок стоит с мечом в ножнах, пока его рубят. */
+    if (pop_have_sword) {
+        if (offguard != 0 && control_shift >= CONTROL_RELEASED) {
+            /* Меч убран намеренно (down в бою) — не доставать, пока не
+             * отпустят Shift; в оригинале это переход на loc_6213. */
+        } else if (can_guard_see_kid >= 2) {
+            int16_t d = pop_char_opp_dist();
+            if (d >= -10 && d < 90) {
+                holding_sword = 1;
+                /* (word)d < (word)-6 — беззнаковое: истинно для ВСЕГО, кроме
+                 * −6..−1.  То есть «страж вплотную за спиной» -> отступить,
+                 * иначе достать меч. */
+                if (d >= -6 && d < 0) { back_pressed(); return; }
+                draw_sword();
+                return;
+            }
+        } else {
+            offguard = 0;
+        }
+    }
+
    if (control_shift == CONTROL_HELD) {
        if (control_backward == CONTROL_HELD)      back_pressed();
        else if (control_up == CONTROL_HELD)       up_pressed();
@@ -242,7 +320,7 @@ static void control_running(void)
    /* Стену НЕ обрабатываем тут — check_bumped (pop_phys_tick) даёт отскок
     * seq_47 при беге в стену (как оригинал), с корректной позицией. */
    if (control_x == CONTROL_RELEASED &&
-        (Kid.frame == FRAME_7_RUN || Kid.frame == FRAME_11_RUN)) {
+        (Char.frame == FRAME_7_RUN || Char.frame == FRAME_11_RUN)) {
        control_forward = release_arrows();
        seqtbl_offset_char(SEQ_13_STOP_RUN);
    } else if (control_x == CONTROL_HELD_BACKWARD) {
@@ -293,21 +371,218 @@ static void control_jumpup(void)
        standing_jump();
 }

-/* control() — диспетчер по кадру (seg005.c:252), Kid жив, без меча. */
-static void control(void)
+/* draw_sword (seg005:945): достать меч.  Кид переходит в seq_55 (подъём
+ * клинка со звуком), соперник — сразу в стойку en garde (seq_90).  Стрелки
+ * гасятся, чтобы «вперёд», которым меч достали, не сработало второй раз
+ * уже как выпад. */
+static void draw_sword(void)
 {
-    uint8_t f = Kid.frame;
+    uint8_t seq_id = SEQ_55_DRAW_SWORD;
+    control_forward = control_shift2 = release_arrows();
+    if (Char.charid == CHARID_0_KID) {
+        offguard = 0;              /* TODO: play_sound(19) — звука пока нет */
+    } else if (Char.charid != CHARID_1_SHADOW) {
+        seq_id = SEQ_90_EN_GARDE;  /* соперник встаёт сразу в стойку */
+    }
+    Char.sword = SWORD_2_DRAWN;
+    seqtbl_offset_char(seq_id);
+}
+
+/* control_guard_inactive (seg006:2123): неактивный страж реагирует ТОЛЬКО в
+ * кадре 166 (стойка) и только на «вниз»: вниз+вперёд — достать меч,
+ * вниз без «вперёд» — развернуться (stand flipped). */
+static void control_guard_inactive(void)
+{
+    if (Char.frame == FRAME_166_STAND_INACTIVE && control_down == CONTROL_HELD) {
+        if (control_forward == CONTROL_HELD) {
+            draw_sword();
+        } else {
+            control_down = CONTROL_IGNORE;
+            seqtbl_offset_char(SEQ_80_STAND_FLIPPED);
+        }
+    }
+}
+
+/* ---- Боёвка (seg005:964..) ---------------------------------------- *
+ * Всё это ветки ОБЩЕГО диспетчера: у стража тот же control(), просто
+ * control_* ему выставляет ИИ (autocontrol_*, guards.c), а не клавиатура. */
+
+/* back_with_sword (seg005): шаг назад — только из стоек. */
+static void back_with_sword(void)
+{
+    uint8_t f = Char.frame;
+    if (f == FRAME_158_STAND_WITH_SWORD || f == FRAME_170_STAND_WITH_SWORD ||
+        f == FRAME_171_STAND_WITH_SWORD) {
+        control_backward = CONTROL_IGNORE;      /* без авто-повтора */
+        seqtbl_offset_char(SEQ_57_BACK_WITH_SWORD);
+    }
+}
+
+/* forward_with_sword (seg005): шаг вперёд; у стража своя последовательность. */
+static void forward_with_sword(void)
+{
+    uint8_t f = Char.frame;
+    if (f == FRAME_158_STAND_WITH_SWORD || f == FRAME_170_STAND_WITH_SWORD ||
+        f == FRAME_171_STAND_WITH_SWORD) {
+        control_forward = CONTROL_IGNORE;
+        seqtbl_offset_char(Char.charid != CHARID_0_KID ? SEQ_56_GUARD_FORWARD
+                                                       : SEQ_86_FORWARD_WITH_SWORD);
+    }
+}
+
+/* sword_strike (seg005): выпад из стойки/шага либо добивание после парирования. */
+static void sword_strike(void)
+{
+    uint8_t f = Char.frame;
+    uint8_t seq_id;
+    if (f == FRAME_157_WALK_WITH_SWORD || f == FRAME_158_STAND_WITH_SWORD ||
+        f == FRAME_170_STAND_WITH_SWORD || f == FRAME_171_STAND_WITH_SWORD ||
+        f == FRAME_165_WALK_WITH_SWORD) {
+        seq_id = (Char.charid == CHARID_0_KID) ? SEQ_75_STRIKE : SEQ_58_GUARD_STRIKE;
+    } else if (f == FRAME_150_PARRY || f == FRAME_161_PARRY) {
+        seq_id = SEQ_66_STRIKE_AFTER_PARRY;
+    } else {
+        return;
+    }
+    control_shift2 = CONTROL_IGNORE;
+    seqtbl_offset_char(seq_id);
+}
+
+/* parry (seg005): блок.  Условие сильно разное у Кида и у соперника —
+ * соперник блокирует ТОЛЬКО на кадре 152 (второй кадр удара), а Кид ещё и
+ * по 153 (и тогда последовательность прокручивается сразу). */
+static void parry(void)
+{
+    uint8_t cf = Char.frame, of = Opp.frame;
+    uint8_t seq_id = SEQ_62_PARRY;
+    uint8_t do_play_seq = 0;
+
+    if (cf == FRAME_158_STAND_WITH_SWORD || cf == FRAME_170_STAND_WITH_SWORD ||
+        cf == FRAME_171_STAND_WITH_SWORD || cf == FRAME_168_BACK ||
+        cf == FRAME_165_WALK_WITH_SWORD) {
+        if (pop_char_opp_dist() >= 32 && Char.charid != CHARID_0_KID) {
+            back_with_sword();
+            return;
+        } else if (Char.charid == CHARID_0_KID) {
+            if (of == FRAME_168_BACK) return;
+            if (of != FRAME_151_STRIKE_1 && of != FRAME_152_STRIKE_2 &&
+                of != FRAME_162_BLOCK_TO_STRIKE) {
+                if (of == FRAME_153_STRIKE_3) do_play_seq = 1;
+            }
+        } else {
+            if (of != FRAME_152_STRIKE_2) return;
+        }
+    } else {
+        if (cf != FRAME_167_BLOCKED) return;
+        seq_id = SEQ_61_PARRY_AFTER_STRIKE;
+    }
+    control_up = CONTROL_IGNORE;
+    seqtbl_offset_char(seq_id);
+    if (do_play_seq) play_seq();
+}
+
+/* swordfight (seg005:0CDB) — разбор ввода в бою.  Порядок веток важен:
+ * удар старше «убрать меч», тот старше блока, блок старше шагов. */
+static void swordfight(void)
+{
+    uint8_t f = Char.frame;
+    uint8_t seq_id;
+
+    if (f == FRAME_161_PARRY && control_shift2 >= CONTROL_RELEASED) {
+        seqtbl_offset_char(SEQ_57_BACK_WITH_SWORD);   /* отскок после парирования */
+        return;
+    } else if (control_shift2 == CONTROL_HELD) {
+        if (Char.charid == CHARID_0_KID) kid_sword_strike = 15;
+        sword_strike();
+        if (control_shift2 == CONTROL_IGNORE) return;
+    }
+
+    if (control_down == CONTROL_HELD) {
+        if (f == FRAME_158_STAND_WITH_SWORD || f == FRAME_170_STAND_WITH_SWORD ||
+            f == FRAME_171_STAND_WITH_SWORD) {
+            control_down = CONTROL_IGNORE;
+            Char.sword = SWORD_0_SHEATHED;
+            if (Char.charid == CHARID_0_KID) {
+                offguard = 1;        /* убрал намеренно — сразу не доставать */
+                guard_refrac = 9;    /* и страж на это время придержан */
+                holding_sword = 0;
+                seq_id = SEQ_93_PUT_SWORD_AWAY_FAST;
+            } else if (Char.charid == CHARID_1_SHADOW) {
+                seq_id = SEQ_92_PUT_SWORD_AWAY;
+            } else {
+                seq_id = SEQ_87_GUARD_BECOME_INACT;   /* Кид ушёл из виду */
+            }
+            seqtbl_offset_char(seq_id);
+        }
+    } else if (control_up == CONTROL_HELD) {
+        parry();
+    } else if (control_forward == CONTROL_HELD) {
+        forward_with_sword();
+    } else if (control_backward == CONTROL_HELD) {
+        back_with_sword();
+    }
+}
+
+/* control_with_sword (seg005:964): пока соперник виден и близко — бой;
+ * иначе страж убирает меч, а Кид просто стоит. */
+static void control_with_sword(void)
+{
+    if (Char.action >= 2) return;              /* actions_2_hang_climb и выше */
+    if (pop_tile_at(Char.curr_col, Char.curr_row) == 11 /* loose */ ||
+        can_guard_see_kid >= 2) {
+        int16_t d = pop_char_opp_dist();
+        if (d < 90) {
+            if (d >= 0) { swordfight(); return; }
+            /* Соперник за спиной: далеко — развернуться, вплотную — драться. */
+            if (d < -4) { seqtbl_offset_char(SEQ_60_TURN_WITH_SWORD); return; }
+            swordfight();
+            return;
+        }
+    }
+    /* Не видит / далеко. */
+    if (Char.charid == CHARID_0_KID && Char.alive < 0)
+        holding_sword = 0;                 /* seg005:980 — индикатор HP стража */
+    if (Char.charid < CHARID_2_GUARD) {
+        if (Char.frame == FRAME_171_STAND_WITH_SWORD) {
+            Char.sword = SWORD_0_SHEATHED;
+            seqtbl_offset_char(SEQ_92_PUT_SWORD_AWAY);   /* страж убит */
+        }
+    } else {
+        swordfight();
+    }
+}
+
+/* control() — диспетчер по кадру (seg005.c:252) для АКТИВНОГО персонажа. */
+void pop_control(void) __banked
+{
+    uint8_t f = Char.frame;
+    /* seg005 control(), самая первая ветка: персонаж УМИРАЕТ (alive >= 0).
+     * Из любой стойки он валится в seq_71_dying; остальное управление в
+     * этом состоянии не обрабатывается.  Через это же место проходит чит K
+     * (pop_guard_kill ставит Guard.alive = 0). */
+    if (Char.alive >= 0) {
+        if (f == FRAME_15_STAND || f == FRAME_166_STAND_INACTIVE ||
+            f == FRAME_158_STAND_WITH_SWORD || f == FRAME_171_STAND_WITH_SWORD)
+            seqtbl_offset_char(SEQ_71_DYING);
+        return;
+    }
    /* seg005 control(): в отскоке (bumped) и в свободном падении управление
     * НЕ обрабатывается вовсе — только гасятся стрелки.  Без этого игрок
     * прерывает присед после удара (medland/плита по голове) нажатием ↑, и
     * последовательность не доигрывает свои dy(1)+dy(1), компенсирующие
     * стартовый dy(-2) → Kid навсегда остаётся на 2px выше пола (баг «Y на
     * пару пикселей меньше, чем должен»). */
-    if (Kid.action == 5 || Kid.action == 4) {   /* bumped / in_freefall */
+    if (Char.action == 5 || Char.action == 4) {   /* bumped / in_freefall */
        release_arrows();
        return;
    }
-    if (f == FRAME_15_STAND || (f >= FRAME_50_TURN && f < 53))
+    /* Порядок веток — как в seg005: меч старше charid, charid старше кадров.
+     * Пока Kid безоружен, обе ветки — про стража. */
+    if (Char.sword == SWORD_2_DRAWN)
+        control_with_sword();
+    else if (Char.charid >= CHARID_2_GUARD)
+        control_guard_inactive();
+    else if (f == FRAME_15_STAND || (f >= FRAME_50_TURN && f < 53))
        control_standing();
    else if (f == FRAME_48_TURN)
        control_turning();
@@ -382,12 +657,12 @@ static void flip_control_x(void)
 /* user_control (seg006:0DC0): «вперёд» относительно направления Kid. */
 static void user_control(void)
 {
-    if (Kid.direction >= DIR_RIGHT) {
+    if (Char.direction >= DIR_RIGHT) {
        flip_control_x();
-        control();
+        pop_control();
        flip_control_x();
    } else {
-        control();
+        pop_control();
    }
 }

@@ -403,7 +678,7 @@ static void save_ctrl_1(void)
 }

 /* ---- Публичный API ------------------------------------------------ */
-int pop_ctrl_init(void)
+int pop_ctrl_init(void) __banked
 {
    control_forward = control_backward = control_up = control_down = CONTROL_RELEASED;
    control_shift2 = CONTROL_RELEASED;
@@ -411,22 +686,46 @@ int pop_ctrl_init(void)
    return kbd_raw_open();
 }

-void pop_ctrl_close(void)
+void pop_ctrl_close(void) __banked
 {
    kbd_raw_close();
 }

-int8_t pop_ctrl_shift_held(void)
+int8_t pop_ctrl_shift_held(void) __banked
 {
    return (int8_t)(control_shift == CONTROL_HELD);
 }

-void pop_ctrl_tick(void)
+void pop_ctrl_tick(void) __banked
 {
    kbd_raw_sync();          /* снять залипшее после Rx-overrun SIO */
+    /* control_kid (seg006:0CD1), ПЕРВАЯ строка: HP кончились — персонаж
+     * мёртв.  Без этой ветки смерть от меча стража не доводилась до конца:
+     * hurt_by_sword играл seq_85, hitp_curr падал в 0, но Kid.alive
+     * оставался −1 и pop_kid_dead не взводился — Кид досматривал сиквенс,
+     * возвращался в стойку с нулём HP, и страж убивал его снова по кругу
+     * (BUG-DEATH-1).  pop_kid_dead — наш сигнал главному циклу на респавн
+     * (в оригинале это счётчик Char.alive в play_kid, seg006:0BEE). */
+    if (Kid.alive < 0 && hitp_curr == 0) {
+        Kid.alive = 0;
+        pop_kid_dead = 1;
+    }
    rest_ctrl_1();
    read_input();
    read_user_control();
-    user_control();      /* -> control(): может сменить Kid.curr_seq */
+    /* Окно Char вокруг диспетчера: control() работает с АКТИВНЫМ
+     * персонажем (как в оригинале), поэтому ввод игрока применяется к
+     * Киду только внутри loadkid/savekid.
+     *
+     * load_fram_det_col ОБЯЗАТЕЛЕН здесь — порт play_kid_frame
+     * (seg000:1209), где он стоит ровно между loadkid_and_opp() и
+     * play_kid().  cur_frame один на всех персонажей, и в кадре последним
+     * его перезаписывает страж; без перезагрузки диспетчер считает
+     * геометрию Кида (dx_weight -> determine_col -> distance_to_edge_weight
+     * -> get_edge_distance) по кадру СТРАЖА.  Замерено: BUG-CTRL-FRAME-1. */
+    pop_loadkid();
+    pop_load_fram_det_col();
+    user_control();      /* -> pop_control(): может сменить Char.curr_seq */
+    pop_savekid_state();
    save_ctrl_1();
 }
@@ -18,18 +18,51 @@

 #include <stdint.h>

+/* МОДУЛЬ ЖИВЁТ В БАНКЕ 5 (--bank 5=pop_ctrl.c), поэтому всё, что зовут
+ * снаружи, помечено __banked.  Зовут с трёх сторон: главный цикл
+ * (резидент), guards.c (банк 1) и pop_map.c (банк 3) — банк→банк
+ * работает, трамплин сохраняет страницу окна на стеке.  Диспетчер
+ * дёргается один раз за кадр на персонажа, так что цена перехода
+ * незаметна.  Сама шина control_* лежит в pop_state.c (см. ниже). */
+
 /* Открыть raw-канал клавиатуры и обнулить память авто-повтора.
 * 0 — OK, -1 — ошибка (EBUSY и пр., см. kbd_raw_open). */
-int  pop_ctrl_init(void);
-void pop_ctrl_close(void);
+int  pop_ctrl_init(void) __banked;
+void pop_ctrl_close(void) __banked;

 /* Один кадр ввода: прочитать клавиши -> обновить control_* -> прогнать
 * диспетчер control() (может сменить Kid.curr_seq).  Звать ПЕРЕД
 * kid_tick() (play_seq продолжит с новой последовательности). */
-void pop_ctrl_tick(void);
+void pop_ctrl_tick(void) __banked;

 /* control_shift зажат ПРЯМО СЕЙЧАС? — для check_grab в физике (pop_map):
 * зацеп за уступ в падении по Shift.  Валидно после pop_ctrl_tick. */
-int8_t pop_ctrl_shift_held(void);
+int8_t pop_ctrl_shift_held(void) __banked;
+
+/* ---- Шина синтетического ввода (порт глобалов control_* из seg005) ----
+ * В оригинале ИИ соперника (autocontrol_*, seg002) не имеет своего
+ * диспетчера: он ВЫСТАВЛЯЕТ эти переменные, а дальше исполняется тот же
+ * control(), что и для игрока.  Значения — CONTROL_RELEASED/IGNORE/HELD. */
+#define POP_CONTROL_RELEASED   0
+#define POP_CONTROL_IGNORE     1
+#define POP_CONTROL_HELD     (-1)
+/* Оси ЭТОГО кадра (абсолютные): X = -1 влево / +1 вправо, Y = -1 вверх /
+ * +1 вниз.  Для ИИ «вперёд/назад» уже в системе персонажа, поэтому оси он
+ * заполняет как есть, без flip_control_x. */
+/* Определены в pop_state.c (резидент W1/W2), а не в pop_ctrl.c: шину
+ * трогают три банка сразу, а данные банкового модуля живут в _DATA лишь
+ * пока сборка идёт без --bank-data. */
+extern int8_t control_x, control_y, control_shift;
+#define POP_CONTROL_HELD_FORWARD  (-1)
+#define POP_CONTROL_HELD_BACKWARD   1
+#define POP_CONTROL_HELD_UP       (-1)
+#define POP_CONTROL_HELD_DOWN       1
+extern int8_t control_forward, control_backward, control_up, control_down,
+              control_shift2;
+
+/* Диспетчер (seg005:252) для АКТИВНОГО персонажа Char.  Игрок идёт через
+ * pop_ctrl_tick (тот делает user_control с зеркалом «вперёд»), страж — из
+ * своего тика напрямую. */
+void pop_control(void) __banked;

 #endif
@@ -0,0 +1,29 @@
+/*
+ * pop_draw.c — выбор ядра libbgi для heal: линейное «noclip», если
+ * прямоугольник целиком на экране, иначе общее клипающее.  Объявление и
+ * мотивация — `_pop_draw.h`.
+ *
+ * ПОЧЕМУ ОТДЕЛЬНЫЙ РЕЗИДЕНТНЫЙ МОДУЛЬ, а не inline в заголовке.  Замер
+ * CLIP-1 (2026-08-01), SDCC 4.5: `static inline` тут обходится втридорога —
+ * компилятор И встраивает тело в каждый вызов (181 Б на место), И оставляет
+ * отдельную мёртвую копию в каждом TU.  У стража это раздуло
+ * `pop_guard_heal` с ~60 до 663 Б.  Пяти местам вызова это стоило бы ~1.4 КБ
+ * ради экономии ~50 тактов на вызов — при том что BANK2 занят на 86 %.
+ *
+ * Резидент W1 (_CODE), а не банк: сюда зовут из ДВУХ разных банков
+ * (pop_bg.c → BANK2, pop_gdraw.c → BANK4) и из резидента (pop_kid.c).  W1
+ * замаплено всегда, поэтому из банка это обычный `call` без трамплина —
+ * тот же приём, что у pop_sword_draw.
+ */
+#include <stdint.h>
+#include <gfx.h>
+#include "_pop_draw.h"
+
+void pop_heal_fast(int x, int y, int w, int h)
+{
+    if (w <= 0 || h <= 0) return;
+    if (pop_onscreen_cols(x, y, (uint16_t)w, (uint16_t)h))
+        gfx_heal_noclip(x, y, (uint8_t)w, (uint8_t)h);
+    else
+        gfx_heal(x, y, w, h);
+}
@@ -0,0 +1,371 @@
+/*
+ * pop_gdraw.c — ОТРИСОВКА стража.  Резидент окна W3 (--w3 pop_gdraw.c).
+ *
+ * Почему отдельным файлом, а не внутри pop_guard.c: --w3 забирает МОДУЛЬ
+ * целиком (код+rodata в 0xC000), а состояние стража и его логика обязаны
+ * остаться в W1/W2 — из банка (guards.c) резидент W3 недостижим ни прямо,
+ * ни транзитивно (docs/layout_plan_v2.md §2 R2).  Значит граница проходит
+ * ровно между «что рисует» (зовёт только главный цикл → резидент) и «что
+ * знает» (зовёт и банк → W1/W2).
+ *
+ * Писучие статики резидента (--dataseg не трогаем) остаются в обычном
+ * _DATA, то есть в W2 — сюда переезжает КОД, не данные.
+ */
+#include <graphics.h>
+#include <gfx.h>
+#include <sprite.h>
+#include "pop_guard.h"
+#include "pop_kid.h"          /* pop_sword_draw — клинок общий с Кидом */
+#include "pop_bg.h"           /* POP_YOFF, pop_fore_over_char */
+#include "_pop_draw.h"   /* pop_onscreen_cols / pop_heal_fast */
+#include "pop_map.h"          /* hitp_curr/hitp_max — HP Кида */
+#include "pop_level.h"        /* тип соперника уровня (набор спрайтов) */
+#include "kid_data.h"
+#include "pop_guard_pal.h"    /* таблица палитр стражей (сгенерена упаковщиком) */
+
+/* Цвет стража (set_chtab_palette, seg003:257).  Оригинал держит ОДИН набор
+ * спрайтов и подменяет 16 цветов палитры chtab_5 по level.guards_color —
+ * так на уровне 2 стражи комнат 4/7/11/15/24 разного цвета (1/3/1/1/6).
+ * Полоса HP стража рисуется тем же атласом, поэтому меняется заодно.
+ * color = 0 — палитру не трогаем (оригинал в этом случае set_chtab_palette
+ * не зовёт: тип уровня не «обычный страж»).
+ * Грузим В ОБЕ палитры: у страниц дабл-буфера они раздельные. */
+void pop_guard_set_palette(uint8_t color) __banked
+{
+    /* Таблица — rodata ЭТОГО модуля, то есть страница банка (0xC000+), а
+     * gfx_pal_load отдаёт указатель в BIOS ($A4 через rst #0x08).  BIOS
+     * читает только #4000-#BFFF (см. корневой CLAUDE.md), поэтому копируем
+     * запись в локальный буфер — стек гарантированно в W2.  Без копии BIOS
+     * забирал мусор с чужой страницы и страж становился невидимым. */
+    uint8_t buf[64];
+    const uint8_t *p;
+    uint8_t i;
+    if (color == 0 || color > POP_GUARD_NPAL) return;
+    p = pop_guard_pal[color - 1];
+    for (i = 0; i < 64; i++) buf[i] = p[i];
+    gfx_pal_load(0, POP_GUARD_PAL_BASE, 16, buf);
+    gfx_pal_load(1, POP_GUARD_PAL_BASE, 16, buf);
+}
+
+/* ---- Атласы стража (chtab_5, база 750): g[id>>3], idx id&7 ---------- */
+#define GUARD_PAGES 5
+static atlas_t gp[GUARD_PAGES];
+static uint8_t g_ok;
+
+/* Прямоугольник последней отрисовки ПО СТРАНИЦЕ дабл-буфера (как у Kid:
+ * heal обязан стирать спрайт именно той страницы, в которую рисуем). */
+static int gx_l[2], gy_l[2];
+static uint16_t gw_l[2], gh_l[2];
+static uint8_t gvalid[2];
+
+/* Клинок — ОТДЕЛЬНЫМ прямоугольником, не объединением со стражем: объединение
+ * почти вдвое больше суммы двух (клинок уходит вперёд-вверх), а heal стоит
+ * ровно по площади.  Объединение считаем только для окна fore-клипа. */
+static int sx_l[2], sy_l[2];
+static uint16_t sw_l[2], sh_l[2];
+static uint8_t svalid[2];
+
+/* Брызги удара — тоже свой прямоугольник, по той же причине: спрайт мелкий и
+ * уезжает вперёд-вверх от стража.  Живут они ОДИН кадр, но стереть их обязана
+ * та же страница, в которую рисовали (иначе остаток виден через кадр). */
+static int qx_l[2], qy_l[2];
+static uint16_t qw_l[2], qh_l[2];
+static uint8_t qvalid[2];
+
+/* Ширина спрайта последнего кадра стража — нужна set_char_collision
+ * (char_width_half) при вычислении его ТАЙЛА ОБЪЕКТА.  Не по страницам:
+ * это свойство кадра, а не буфера.  Отставание на кадр допустимо — так же
+ * работает kid_fp_width() у Кида. */
+static uint16_t g_last_w;
+
+uint16_t pop_guard_fp_width(void) __banked { return g_last_w; }
+
+/* Набор спрайтов соперника выбирает ТИП УРОВНЯ (load_lev_spr, seg000:1092):
+ * tbl_guard_type = {0 guard, 1 fat, 2 skeleton, 3 vizier, 4 shadow, −1 нет}.
+ * У нас пока два набора: обычный страж (уровни 1-2) и скелет (уровень 3);
+ * у скелета и кадров меньше (28 против 34), поэтому пятую страницу он не
+ * грузит.  Уровень БЕЗ соперников (type < 0) не грузит ничего. */
+int pop_guard_load(void) __banked
+{
+    static const char *const guard_names[GUARD_PAGES] = {
+        "GUARD\\g0.atl", "GUARD\\g1.atl", "GUARD\\g2.atl",
+        "GUARD\\g3.atl", "GUARD\\g4.atl"
+    };
+    static const char *const skel_names[GUARD_PAGES] = {
+        "SKEL\\g0.atl", "SKEL\\g1.atl", "SKEL\\g2.atl",
+        "SKEL\\g3.atl", 0
+    };
+    const char *const *names;
+    int8_t type = pop_level_guard_type(pop_current_level);
+    uint8_t i;
+    if (type < 0) return 0;                     /* соперников на уровне нет */
+    names = (type == 2) ? skel_names : guard_names;
+    for (i = 0; i < GUARD_PAGES; i++) {
+        if (names[i] == 0) break;
+        if (atlas_load(&gp[i], names[i]) != 0) return -1;
+    }
+    g_ok = 1;
+    /* Цвет: у скелета он СВОЙ (палитра из его набора), у стража подменяется
+     * из res10.bin по guards_color — это делает pop_guard_set_palette при
+     * входе в комнату (seg002:186: у не-guard curr_guard_color = 0). */
+    if (type == 2) {
+        uint8_t buf[64], k;
+        for (k = 0; k < 64; k++) buf[k] = pop_skel_pal[k];   /* BIOS: буфер в W2 */
+        gfx_pal_load(0, POP_GUARD_PAL_BASE, 16, buf);
+        gfx_pal_load(1, POP_GUARD_PAL_BASE, 16, buf);
+    }
+    return 0;
+}
+
+void pop_guard_free(void) __banked
+{
+    uint8_t i;
+    if (!g_ok) return;
+    for (i = 0; i < GUARD_PAGES; i++) atlas_free(&gp[i]);
+    g_ok = 0;
+}
+
+/* Стирание прошлого кадра стража и его клинка.  pop_heal_fast — по той же
+ * причине, что в kid_heal: стираем ровно то, что рисовали, а рисовали в
+ * большинстве кадров noclip-ядром.  Два прямоугольника, а не объединение
+ * (см. комментарий к sx_l выше). */
+void pop_guard_heal(void) __banked
+{
+    uint8_t p = gfx_get_draw_page() & 1;
+    if (gvalid[p]) pop_heal_fast(gx_l[p], gy_l[p] + POP_YOFF, gw_l[p], gh_l[p]);
+    if (svalid[p]) pop_heal_fast(sx_l[p], sy_l[p] + POP_YOFF, sw_l[p], sh_l[p]);
+    if (qvalid[p]) pop_heal_fast(qx_l[p], qy_l[p] + POP_YOFF, qw_l[p], qh_l[p]);
+    gvalid[p] = svalid[p] = qvalid[p] = 0;
+}
+
+void pop_guard_draw(void) __banked
+{
+    int obj_x, obj_y, top, fwd, fp_x;
+    uint8_t page, idx, p, flip;
+    const uint8_t *img;
+    uint16_t w, h;
+    /* Окно fore-клипа — по ОБЪЕДИНЁННОМУ габариту «страж + клинок»; сам
+     * футпринт (pop_fore_over_char) считается по спрайту стража, поэтому
+     * w/h ниже НЕ трогаем. */
+    int clip_x = 0, clip_y = 0; uint16_t clip_w = 0, clip_h = 0;
+
+    if (!g_ok || Guard.charid == 0 || pop_gframe.image == 255) return;
+    /* load_frame_to_obj (seg008:1728) — та же математика, что у Kid. */
+    fwd   = (int)Guard.x + ((Guard.direction < 0) ? -pop_gframe.dx : pop_gframe.dx);
+    obj_x = (fwd << 1) - 116;
+    obj_y = (int)Guard.y + pop_gframe.dy;
+    if ((int8_t)(pop_gframe.flags ^ Guard.direction) >= 0) obj_x++;
+    fp_x  = obj_x;                           /* ЛОГИЧЕСКАЯ X (до ×8/7) — футпринт */
+    obj_x = obj_x * 8 / 7;                   /* calc_screen_x_coord */
+
+    page = (uint8_t)(pop_gframe.image >> 3);
+    idx  = (uint8_t)(pop_gframe.image & 7);
+    if (page >= GUARD_PAGES) return;
+    img = (const uint8_t *)atlas_image(&gp[page], idx);
+    gfx_w0_map(gp[page].page);
+    w = (uint16_t)(img[0] | ((uint16_t)img[1] << 8));
+    h = (uint16_t)(img[2] | ((uint16_t)img[3] << 8));
+    if (w && h) {
+        int bx = obj_x;
+        /* Поле комнаты — 192 строки (reset_obj_clip, seg006:0507:
+         * obj_clip_top = 0, obj_clip_bottom = 192).  Персонаж, вышедший за
+         * него (скелет, падающий в пропасть), обязан обрезаться: ниже поля
+         * идёт полоса HP, и без клипа спрайт лез прямо на неё. */
+        int skip = 0, rows;
+        top = obj_y - (int)h + 1;
+        flip = (uint8_t)(Guard.direction >= 0);   /* спрайты нарисованы влево */
+        if (flip) bx -= (int)w;
+        rows = (int)h;
+        if (top < 0) { skip = -top; rows -= skip; top = 0; }
+        if (top + rows > 192) rows = 192 - top;
+        if (rows > 0) {
+            p = gfx_get_draw_page() & 1;
+            gfx_set_bank(GFX_BANK_SPRITE);
+            if (pop_onscreen_cols(bx, top + POP_YOFF, w, (uint16_t)rows))
+                gfx_blit_cols_part_noclip(bx, top + POP_YOFF, img, flip,
+                                          (uint8_t)skip, (uint8_t)rows);
+            else
+                gfx_blit_cols_part(bx, top + POP_YOFF, img, flip, skip, rows);
+            gfx_set_bank(GFX_BANK_NORMAL);
+            /* heal — ровно по НАРИСОВАННОМУ (обрезанному) прямоугольнику. */
+            gx_l[p] = bx; gy_l[p] = top; gw_l[p] = w; gh_l[p] = (uint16_t)rows;
+            gvalid[p] = 1;
+            clip_x = bx; clip_y = top; clip_w = w; clip_h = (uint16_t)rows;
+        }
+        g_last_w = w;                        /* для char_width_half, см. выше */
+    }
+    /* Брызги удара (draw_hurt_splash, seg006:16CE) — ровно здесь, между
+     * стражем и клинком: draw_guard кладёт их в objtable СРАЗУ после стража
+     * и ДО клинка (seg008:22C9), а порядок записей задаёт порядок рисования.
+     *
+     * Спрайт — chtab_5_guard `obj_id = 1`, то есть image 1 нашего атласа
+     * стража (страница 0, индекс 1): у add_midtable аргумент `obj_id + 1`, а
+     * get_image вычитает единицу обратно (тот же off-by-one, что расписан в
+     * шапке pop_pack_guard.py).  У Кида это image 218 своего chtab.
+     *
+     * Смещения от кадра персонажа — по трём веткам оригинала; у стража
+     * подъём на 11 (у Кида 15: `((charid == kid) << 2) + 11`). */
+    if (pop_guard_hurt && Guard.frame != 178 /* chomped: брызг нет */) {
+        int qx = fp_x, qy = obj_y;
+        const uint8_t *qimg = (const uint8_t *)atlas_image(&gp[0], 1);
+        uint16_t qw, qh;
+        int fw = (Guard.direction < 0) ? -5 : 5;      /* obj_dx_forward(5) */
+        if (Guard.frame == 185 ||                     /* мёртв              */
+            (Guard.frame >= 106 && Guard.frame < 111)) {  /* падение+посадка */
+            qy += 4;
+        } else if (Guard.frame == 177) {              /* напоролся на пики  */
+            fw = -fw;                                 /* obj_dx_forward(-5) */
+        } else {
+            qy -= 11;
+        }
+        qx = (qx + fw) * 8 / 7;                       /* calc_screen_x_coord */
+        gfx_w0_map(gp[0].page);
+        qw = (uint16_t)(qimg[0] | ((uint16_t)qimg[1] << 8));
+        qh = (uint16_t)(qimg[2] | ((uint16_t)qimg[3] << 8));
+        if (qw && qh) {
+            int qtop = qy - (int)qh + 1;
+            uint8_t qflip = (uint8_t)(Guard.direction >= 0);
+            int qskip = 0, qrows = (int)qh;   /* клип полем 192, как у спрайта */
+            if (qflip) qx -= (int)qw;
+            if (qtop < 0) { qskip = -qtop; qrows -= qskip; qtop = 0; }
+            if (qtop + qrows > 192) qrows = 192 - qtop;
+            if (qrows <= 0) goto splash_done;
+            qh = (uint16_t)qrows;
+            gfx_set_bank(GFX_BANK_SPRITE);
+            if (pop_onscreen_cols(qx, qtop + POP_YOFF, qw, qh))
+                gfx_blit_cols_part_noclip(qx, qtop + POP_YOFF, qimg, qflip,
+                                          (uint8_t)qskip, (uint8_t)qrows);
+            else
+                gfx_blit_cols_part(qx, qtop + POP_YOFF, qimg, qflip, qskip, qrows);
+            gfx_set_bank(GFX_BANK_NORMAL);
+            p = gfx_get_draw_page() & 1;
+            qx_l[p] = qx; qy_l[p] = qtop; qw_l[p] = qw; qh_l[p] = qh;
+            qvalid[p] = 1;
+            if (!clip_w) {
+                clip_x = qx; clip_y = qtop; clip_w = qw; clip_h = qh;
+            } else {
+                int x1 = clip_x + (int)clip_w, y1 = clip_y + (int)clip_h;
+                if (qx < clip_x) clip_x = qx;
+                if (qtop < clip_y) clip_y = qtop;
+                if (qx + (int)qw > x1) x1 = qx + (int)qw;
+                if (qtop + (int)qh > y1) y1 = qtop + (int)qh;
+                clip_w = (uint16_t)(x1 - clip_x);
+                clip_h = (uint16_t)(y1 - clip_y);
+            }
+        }
+splash_done: ;
+    }
+    /* Клинок стража — тот же chtab_0, что у Кида (add_sword_to_objtable,
+     * seg006:1798): у ЖИВОГО стража меч в руке всегда.  Свой прямоугольник
+     * heal; окно fore-клипа — объединение (без него клинок полез бы поверх
+     * переднего столба). */
+    {
+        int sx, sy; uint16_t sw, sh;
+        if (pop_sword_draw(&Guard, &pop_gframe, obj_x, obj_y,
+                           &sx, &sy, &sw, &sh)) {
+            p = gfx_get_draw_page() & 1;
+            sx_l[p] = sx; sy_l[p] = sy; sw_l[p] = sw; sh_l[p] = sh;
+            svalid[p] = 1;
+            if (!clip_w) {
+                clip_x = sx; clip_y = sy; clip_w = sw; clip_h = sh;
+            } else {
+                int x1 = clip_x + (int)clip_w, y1 = clip_y + (int)clip_h;
+                if (sx < clip_x) clip_x = sx;
+                if (sy < clip_y) clip_y = sy;
+                if (sx + (int)sw > x1) x1 = sx + (int)sw;
+                if (sy + (int)sh > y1) y1 = sy + (int)sh;
+                clip_w = (uint16_t)(x1 - clip_x);
+                clip_h = (uint16_t)(y1 - clip_y);
+            }
+        }
+    }
+    gfx_w0_unmap();
+    /* Окно fore-слоя = прямоугольник стража с клинком (см. pop_bg.c,
+     * fclip_on): без него проход возвращал ЦЕЛЫЕ тайлы — 432 К тактов. */
+    pop_fore_set_clip(clip_x, clip_y + POP_YOFF, (int)clip_w, (int)clip_h);
+    /* Передние грани тайлов ПОВЕРХ стража: в оригинале персонаж — запись
+     * midtable, а foretable рисуется после всех midtable-записей, поэтому
+     * колонна/кромка пола перекрывает ЛЮБОГО персонажа, не только Kid
+     * (seg008:690 draw_tile_fore).  Без этого страж виден сквозь передний
+     * столб. */
+    if (w && h)
+        pop_fore_over_char(fp_x, obj_y, w, h, Guard.direction, Guard.sword,
+                           clip_x, clip_y + POP_YOFF, clip_w, clip_h,
+                           Guard.action, Guard.curr_col, Guard.curr_row);
+}
+
+/* ---- Индикаторы HP (порт draw_kid_hp / draw_guard_hp, seg000:1416) --- *
+ * Оригинал рисует их в статус-полосе на y = 194 (ниже поля тайлов, внутри
+ * тех же 200 строк экрана PoP): HP Кида слева направо шагом 7, HP стража
+ * справа налево от x = 314.  Пустые деления у Кида — свой спрайт (chtab_2
+ * id 217); у стража оригинал печатает тот же спрайт ЧЁРНЫМ силуэтом, а мы
+ * просто не печатаем — полоса и так на чёрном фоне.
+ *
+ * Спрайты Кида (216/217) лежат в его же атласах, поэтому блитим через
+ * pop_kid_img_blit; спрайт стража — image 0 его chtab (наша страница 0). */
+#define HP_Y         194
+#define HP_STEP        7
+#define HP_KID_FULL  216
+#define HP_KID_EMPTY 217
+#define HP_MAXDRAW    10          /* больше в полосу всё равно не влезает */
+
+/* Полоса перерисовывается ТОЛЬКО когда числа изменились — и тогда на ОБЕИХ
+ * страницах дабл-буфера (иначе на второй останется старое значение и его
+ * будет видно как мерцание через кадр).  Отсюда счётчик страниц, а не флаг.
+ *
+ * Снимки прошлых значений пишем ДО сравнения: `if (n != s) s = n;` SDCC z80
+ * собирает неверно — SUB затирает A, и в s уезжает разность (memory
+ * sdcc_z80_cmp_store_a_bug). */
+static uint8_t hp_todo;                  /* сколько страниц ещё обновить  */
+static uint8_t hp_kid_prev, hp_kidmax_prev, hp_gd_prev, hp_gdmax_prev;
+
+/* Заставить перерисовать полосу на обеих страницах: звать при входе в
+ * комнату (фон перерисован целиком и стёр её) и при старте. */
+void pop_hp_invalidate(void) __banked { hp_todo = 2; }
+
+void pop_hp_draw(void) __banked
+{
+    uint8_t i, n;
+    uint8_t gd = (uint8_t)(Guard.charid ? guardhp_curr : 0);
+    uint8_t gm = (uint8_t)(Guard.charid ? guardhp_max  : 0);
+
+    {   /* Изменилось хоть одно число — обновить обе страницы. */
+        uint8_t k = hitp_curr, km = hitp_max;
+        uint8_t changed = (uint8_t)(k != hp_kid_prev || km != hp_kidmax_prev ||
+                                    gd != hp_gd_prev || gm != hp_gdmax_prev);
+        hp_kid_prev = k; hp_kidmax_prev = km;
+        hp_gd_prev = gd; hp_gdmax_prev = gm;
+        if (changed) hp_todo = 2;
+    }
+    if (hp_todo == 0) return;
+    hp_todo--;
+
+    /* Стереть прошлую полосу: фон под ней — чёрный борт. */
+    gfx_set_bank(GFX_BANK_NORMAL);
+    setfillstyle(SOLID_FILL, BLACK);
+    bar(0, HP_Y + POP_YOFF, 319, HP_Y + POP_YOFF + 6);
+
+    /* Кид: сначала пустые деления, поверх — полные (порядок оригинала). */
+    n = (uint8_t)(hitp_max > HP_MAXDRAW ? HP_MAXDRAW : hitp_max);
+    for (i = hitp_curr; i < n; i++)
+        pop_kid_img_blit(HP_KID_EMPTY, (int)i * HP_STEP, HP_Y + POP_YOFF);
+    for (i = 0; i < hitp_curr && i < HP_MAXDRAW; i++)
+        pop_kid_img_blit(HP_KID_FULL, (int)i * HP_STEP, HP_Y + POP_YOFF);
+
+    /* Страж: только полные деления, справа налево.  Скелет полосы не имеет. */
+    if (g_ok && Guard.charid != 0 && Guard.charid != CHARID_4_SKELETON && gd) {
+        const uint8_t *img = (const uint8_t *)atlas_image(&gp[0], 0);
+        uint16_t w, h;
+        gfx_w0_map(gp[0].page);
+        w = (uint16_t)(img[0] | ((uint16_t)img[1] << 8));
+        h = (uint16_t)(img[2] | ((uint16_t)img[3] << 8));
+        if (w && h) {
+            /* Атлас стража тоже column-major — блит колоночный. */
+            n = (uint8_t)(gd > HP_MAXDRAW ? HP_MAXDRAW : gd);
+            for (i = 0; i < n; i++)
+                gfx_blit_cols_part_noclip(314 - (int)i * HP_STEP,
+                                          HP_Y + POP_YOFF, img, 0, 0, 0);
+        }
+        gfx_w0_unmap();
+    }
+}
@@ -0,0 +1,236 @@
+/*
+ * pop_geom.c — общая геометрия + PRNG оригинала.  См. pop_geom.h.
+ */
+#include "pop_geom.h"
+
+/* data.h: шаг 14 (ширина тайла в координатах персонажа), [5] = col 0. */
+const int16_t pop_x_bump[20] = {
+    -12, 2, 16, 30, 44, 58, 72, 86, 100, 114,
+    128, 142, 156, 170, 184, 198, 212, 226, 240, 254
+};
+const int16_t pop_y_land[5] = {-8, 55, 118, 181, 244};
+
+int8_t pop_y_to_row(int16_t y)
+{
+    return (int8_t)((y + 60) / TILE_SIZEY % 4 - 1);
+}
+
+/* Уложить значение в диапазон 0..maxv.  Вызовы оригинала — prandom(1),
+ * prandom(255), prandom(0xFF): делитель степень двойки, то есть маска, а не
+ * деление.  __moduint на Z80 стоит заметно дороже проверки n & (n-1). */
+static uint16_t pop_rnd_fit(uint16_t v, uint16_t maxv)
+{
+    uint16_t n = (uint16_t)(maxv + 1);
+    if ((uint16_t)(n & (uint16_t)(n - 1)) == 0)
+        return (uint16_t)(v & (uint16_t)(n - 1));
+    return (uint16_t)(v % n);
+}
+
+#if POP_PRANDOM_EXACT
+/* ---- LCG оригинала: s = s*214013 + 2531011 (seg009:321) ------------ *
+ *
+ * ЕДИНСТВЕННОЕ место в порте на ассемблере, и вот почему.  На Z80 нет
+ * умножения, а SDCC для 32-битного `s * 214013` зовёт __mullong — 8 430
+ * тактов на вызов (замер в MAME).  Написанное на C через 16-битные
+ * половины это ~3 500.  Здесь ~1 000, при полностью той же
+ * последовательности, что в SDLPoP.  Альтернатива «взять генератор
+ * попроще» (8-битный RND Apple II, xorshift) экономит меньше и ломает
+ * совместимость с эталоном, по которому сверяем картинку.
+ *
+ * Приём: 214013 = ((((1<<1)+1)<<2 + 1)<<4 + 1)<<10 - 3 — схема Горнера по
+ * РАЗРЕЖЕННОЙ записи константы.  Вместо 12 сложений (по числу единиц в
+ * 0x343FD) — 17 удвоений, ТРИ сложения и одно вычитание.  Величина 3*s,
+ * нужная в конце, попадается по дороге на втором шаге — её и сохраняем.
+ *
+ * ABI __sdcccall(1): arg1 (указатель на сид) -> HL, возврат -> DE.  IX не
+ * используется, сохранять нечего.  Клоббер AF/BC/DE/HL.  Аккумулятор —
+ * DE:HL (DE старшее слово); s.lo живёт в BC, s.hi и 3*s — в статиках
+ * (регистров на всё не хватает).
+ */
+uint16_t pop_pr_ptr;                   /* адрес сида                    */
+uint16_t pop_pr_sh;                    /* старшее слово исходного сида  */
+uint16_t pop_pr_3s_lo, pop_pr_3s_hi;   /* 3*s, нужное в конце           */
+
+static uint16_t pop_lcg_step(pop_rnd_t *seed) __naked
+{
+    (void)seed;
+    __asm
+        ld      (_pop_pr_ptr), hl
+        ld      c, (hl)
+        inc     hl
+        ld      b, (hl)                ; BC = s.lo
+        inc     hl
+        ld      a, (hl)
+        ld      (_pop_pr_sh), a
+        inc     hl
+        ld      a, (hl)
+        ld      (_pop_pr_sh + 1), a    ; (pop_pr_sh) = s.hi
+
+        ld      h, b
+        ld      l, c
+        ld      de, (_pop_pr_sh)       ; акк = s
+
+        ;; акк = акк*2 + s  =>  3s
+        add     hl, hl
+        rl      e
+        rl      d
+        add     hl, bc
+        ex      de, hl
+        ld      a, (_pop_pr_sh)        ; LD A,(nn) флаги НЕ трогает
+        adc     a, l
+        ld      l, a
+        ld      a, (_pop_pr_sh + 1)
+        adc     a, h
+        ld      h, a
+        ex      de, hl
+        ld      (_pop_pr_3s_lo), hl
+        ld      (_pop_pr_3s_hi), de
+
+        ;; акк = акк*4 + s  =>  13s
+        add     hl, hl
+        rl      e
+        rl      d
+        add     hl, hl
+        rl      e
+        rl      d
+        add     hl, bc
+        ex      de, hl
+        ld      a, (_pop_pr_sh)
+        adc     a, l
+        ld      l, a
+        ld      a, (_pop_pr_sh + 1)
+        adc     a, h
+        ld      h, a
+        ex      de, hl
+
+        ;; акк = акк*16 + s  =>  209s
+        add     hl, hl
+        rl      e
+        rl      d
+        add     hl, hl
+        rl      e
+        rl      d
+        add     hl, hl
+        rl      e
+        rl      d
+        add     hl, hl
+        rl      e
+        rl      d
+        add     hl, bc
+        ex      de, hl
+        ld      a, (_pop_pr_sh)
+        adc     a, l
+        ld      l, a
+        ld      a, (_pop_pr_sh + 1)
+        adc     a, h
+        ld      h, a
+        ex      de, hl
+
+        ;; акк *= 1024  =>  214016s   (10 удвоений)
+        add     hl, hl
+        rl      e
+        rl      d
+        add     hl, hl
+        rl      e
+        rl      d
+        add     hl, hl
+        rl      e
+        rl      d
+        add     hl, hl
+        rl      e
+        rl      d
+        add     hl, hl
+        rl      e
+        rl      d
+        add     hl, hl
+        rl      e
+        rl      d
+        add     hl, hl
+        rl      e
+        rl      d
+        add     hl, hl
+        rl      e
+        rl      d
+        add     hl, hl
+        rl      e
+        rl      d
+        add     hl, hl
+        rl      e
+        rl      d
+
+        ;; акк -= 3s  =>  214013s
+        ld      bc, (_pop_pr_3s_lo)
+        or      a                      ; CY = 0
+        sbc     hl, bc
+        ld      bc, (_pop_pr_3s_hi)    ; LD BC,(nn) флаги НЕ трогает
+        ex      de, hl
+        sbc     hl, bc
+        ex      de, hl
+
+        ;; акк += 2531011 = 0x0026_9EC3
+        ld      bc, #0x9EC3
+        add     hl, bc
+        ld      bc, #0x0026
+        ex      de, hl
+        adc     hl, bc
+        ex      de, hl
+
+        ;; сохранить сид, вернуть СТАРШЕЕ слово в DE
+        push    de
+        ex      de, hl                 ; DE = младшее слово
+        ld      hl, (_pop_pr_ptr)
+        ld      (hl), e
+        inc     hl
+        ld      (hl), d
+        inc     hl
+        pop     de                     ; DE = старшее слово
+        ld      (hl), e
+        inc     hl
+        ld      (hl), d
+        ret
+    __endasm;
+}
+
+uint16_t pop_prandom(pop_rnd_t *seed, uint16_t maxv)
+{
+    return pop_rnd_fit(pop_lcg_step(seed), maxv);
+}
+
+#else  /* !POP_PRANDOM_EXACT — генератор попроще, НЕ совместимый с эталоном */
+
+/* xorshift16 + шаг Вейля.  Зачем не LCG оригинала: тот 32-битный, и даже
+ * без __mullong (см. ветку выше) стоит ~7 000 тактов на вызов — при двух
+ * вызовах за кадр это 3 % бюджета на генератор случайных чисел.  Здесь
+ * умножений нет вовсе, только сдвиги и xor.
+ *
+ * Почему НЕ 8-битный RND Apple II (RNDseed := 5*RNDseed + 23 mod 256,
+ * Prince-of-Persia-Apple-II): он ещё быстрее, но у LCG по модулю 256
+ * младшие биты вырождены — бит 0 просто чередуется.  Наши вызовы это
+ * видят: раскладка кладки берёт prandom(1) (один бит) и prandom(4), и
+ * вместо шума получилась бы правильная шахматка.  У xorshift такой
+ * структуры нет, а стоит он примерно столько же.
+ *
+ * Шаг Вейля (+0x9E37, нечётный) нужен ещё и потому, что у чистого
+ * xorshift ноль — неподвижная точка, а сид кладки (номер комнаты + ряд +
+ * колонка) вполне может оказаться нулём.
+ *
+ * ПОСЛЕДСТВИЕ: последовательность отличается от SDLPoP — другая (но
+ * статистически такая же) раскладка кладки и другие броски в боёвке.
+ * Поэтому по умолчанию собирается НЕ эта ветка: после переписывания LCG
+ * на ассемблер выигрыш от смены генератора почти исчез, а сверять
+ * картинку с эталоном стало важнее.  Ветка оставлена как запасной ход. */
+uint16_t pop_prandom(pop_rnd_t *seed, uint16_t maxv)
+{
+    uint16_t s = seed->lo;
+    s ^= (uint16_t)(s << 7);
+    s ^= (uint16_t)(s >> 9);
+    s ^= (uint16_t)(s << 8);
+    s = (uint16_t)(s + 0x9E37u);
+    seed->lo = s;
+    seed->hi = 0;                    /* старшая половина не используется */
+    /* Отдаём СТАРШИЙ байт: у него нет короткопериодической структуры
+     * младших бит, а вызывающие берут от результата именно младшие. */
+    return pop_rnd_fit((uint16_t)(s >> 8), maxv);
+}
+
+#endif
@@ -0,0 +1,61 @@
+/*
+ * pop_geom.h — общая геометрия PoP и PRNG оригинала.
+ *
+ * Сюда сведено то, что раньше дублировалось по модулям (x_bump/y_land в
+ * pop_kid и pop_map, y_to_row в pop_bg и pop_map, 32-битный LCG в pop_bg и
+ * pop_trob).  Кроме экономии это ФУНДАМЕНТ bank-safe API: модуль живёт в
+ * W1/W2 и не трогает графику, поэтому его может звать и главный цикл, и
+ * резидент W3, и будущий __banked-код стражей (docs/layout_plan_v2.md §4).
+ */
+#ifndef POP_GEOM_H
+#define POP_GEOM_H
+
+#include <stdint.h>
+
+#define FIRST_ONSCREEN_COLUMN 5    /* индекс col 0 комнаты в x_bump          */
+#define TILE_SIZEX           14    /* ширина тайла в координатах персонажа   */
+#define TILE_SIZEY           63    /* высота ряда                            */
+
+/* x_bump (data.h): левая граница колонки в координатах персонажа; колонка
+ * комнаты col = x_bump[col + FIRST_ONSCREEN_COLUMN].  y_land: пол ряда
+ * (индекс row+1; [0] — ряд «над комнатой»). */
+extern const int16_t pop_x_bump[20];
+extern const int16_t pop_y_land[5];
+
+/* y_to_row_mod4 (seg006): ряд по координате y с оборотом mod 4 (−1 = полоса
+ * над комнатой, 3 = под комнатой). */
+int8_t pop_y_to_row(int16_t y);
+
+/* prandom (порт seg009:321).  Сид ВНЕШНИЙ: у стен (раскладка кладки) и у
+ * анимаций тайлов (фаза факелов) свои последовательности, смешивать их
+ * нельзя.
+ *
+ * ДВА генератора, выбор через POP_PRANDOM_EXACT (см. pop_geom.c):
+ *   1 (по умолчанию) — LCG оригинала (s*214013+2531011) БИТ-В-БИТ: та же
+ *     раскладка кладки и те же броски, что в SDLPoP, поэтому по картинке
+ *     можно сверяться с эталоном;
+ *   0 — xorshift16 + шаг Вейля, без единого умножения.  Дешевле ровно на
+ *     5 646 тактов за кадр, 1.3 % бюджета (замер A/B в MAME, комната 3,
+ *     175 кадров: 403 632 против 397 986).  Последовательность другая —
+ *     статистически эквивалентная, но не та же.
+ *
+ * Обе версии считают 16-битными половинами, а не unsigned long: на 32-бит
+ * умножении SDCC зовёт __mullong, и это 8 430 тактов на вызов (замер в
+ * MAME, breakpoint на __mullong).
+ *
+ * ЗАДЕЛ: разрыв между версиями определяется не алгоритмом, а кодогенерацией
+ * SDCC — те же генераторы на Z80-ассемблере укладываются в 86..148 тактов.
+ * Если процент понадобится, сначала переписать в asm ОРИГИНАЛЬНЫЙ LCG (там
+ * умножение на константу), а менять генератор — только если и этого мало. */
+typedef struct { uint16_t lo, hi; } pop_rnd_t;
+
+#ifndef POP_PRANDOM_EXACT
+#define POP_PRANDOM_EXACT 1
+#endif
+
+uint16_t pop_prandom(pop_rnd_t *seed, uint16_t maxv);
+
+/* Сид из 16-битного числа (старшая половина = 0). */
+#define pop_prandom_set(s, v)  do { (s).lo = (uint16_t)(v); (s).hi = 0; } while (0)
+
+#endif
@@ -0,0 +1,314 @@
+/*
+ * pop_guard.c — СОСТОЯНИЕ и ЛОГИКА стража (W1/W2).  См. pop_guard.h.
+ *
+ * Здесь только то, что должно оставаться достижимым из банка (guards.c):
+ * поля Guard, HP, вход в комнату, чит-убийство, чтение кадра из таблицы.
+ * ОТРИСОВКА — в pop_gdraw.c, резиденте W3 (её зовёт лишь главный цикл).
+ */
+#include <stdint.h>
+#include "pop_guard.h"
+#include "pop_geom.h"
+#include "pop_level.h"
+#include "pop_kid.h"          /* Char/play_seq — интерпретатор общий */
+#include "pop_map.h"          /* hitp_* — HP Кида */
+#include "pop_state.h"        /* pop_immortal — чит бессмертия */
+#include "kid_data.h"
+
+pop_char_t Guard;
+uint8_t  guardhp_curr, guardhp_max;
+int8_t   guardhp_delta;
+uint8_t  pop_guard_hurt;
+int8_t   can_guard_see_kid;
+int8_t   is_guard_notice;
+uint8_t  guard_skill;
+int8_t   guard_refrac, justblocked, kid_sword_strike;
+int8_t   offguard, holding_sword;
+
+/* Сид бросков боёвки.  В оригинале генератор один на всё, у нас
+ * последовательности разведены по доменам (кладка / анимация тайлов / бой),
+ * см. pop_geom.h — иначе перерисовка стены сбивала бы броски стража. */
+pop_rnd_t pop_fight_seed;
+
+/* Кадр стража (порт cur_frame для Char).  Глобальный, а не статик: его
+ * заполняет логика (W1/W2), а читает отрисовка из резидента W3. */
+kframe pop_gframe;
+
+uint8_t pop_guard_present(void)
+{
+    return (uint8_t)(Guard.charid != 0 && Guard.alive < 0 && guardhp_curr != 0);
+}
+
+void pop_guard_reset(void)
+{
+    Guard.charid = 0;
+    Guard.alive = 0;
+    Guard.direction = 0;
+    guardhp_curr = 0;
+    guardhp_delta = 0;
+    can_guard_see_kid = 0;
+    is_guard_notice = 0;
+    guard_refrac = justblocked = kid_sword_strike = 0;
+    offguard = holding_sword = 0;
+}
+
+/* kill guard cheat (seg000:786):
+ *     if (Guard.charid != charid_4_skeleton) {
+ *         guardhp_delta = -guardhp_curr;
+ *         Guard.alive = 0;
+ *     }
+ * Скелета чит не убивает — он и в оригинале бессмертен. */
+void pop_guard_kill(void)
+{
+    if (Guard.charid == CHARID_4_SKELETON) return;
+    if (!pop_guard_present()) return;
+    /* Как в оригинале: HP НЕ обнуляем здесь — ставим дельту, её применит
+     * pop_do_delta_hp.  alive = 0 переводит стража в «умирает», а дальше
+     * общий control() ставит ему seq_71_dying. */
+    guardhp_delta = (int8_t)-guardhp_curr;
+    Guard.alive = 0;
+}
+
+/* take_hp (seg006:06BD) — общий для боёвки и физики; см. pop_guard.h. */
+uint8_t pop_take_hp(uint8_t count)
+{
+    if (Char.charid == CHARID_0_KID) {
+        if (pop_immortal) return 0;
+        if (count >= hitp_curr) { hitp_delta = (int8_t)-hitp_curr; return 1; }
+        hitp_delta = (int8_t)-(int8_t)count;
+    } else {
+        if (count >= guardhp_curr) { guardhp_delta = (int8_t)-guardhp_curr; return 1; }
+        guardhp_delta = (int8_t)-(int8_t)count;
+    }
+    return 0;
+}
+
+/* do_delta_hp (seg003): применить накопленную за кадр дельту HP и обнулить
+ * её.  Звать раз в кадр ПОСЛЕ тиков персонажей, как в play_frame. */
+void pop_do_delta_hp(void)
+{
+    int16_t hp;
+    if (hitp_delta) {
+        hp = (int16_t)hitp_curr + hitp_delta;
+        if (hp < 0) hp = 0;
+        if (hp > (int16_t)hitp_max) hp = (int16_t)hitp_max;
+        hitp_curr = (uint8_t)hp;
+        /* Брызги и красная вспышка — только на УРОН: и draw_kid (seg008:1643),
+         * и flash_if_hurt (seg003:785) смотрят именно `hitp_delta < 0`.  С
+         * условием «дельта не ноль» их получало и зелье здоровья (+1). */
+        if (hitp_delta < 0) pop_kid_hurt = 1;
+        hitp_delta = 0;
+    }
+    if (guardhp_delta) {
+        hp = (int16_t)guardhp_curr + guardhp_delta;
+        if (hp < 0) hp = 0;
+        if (hp > (int16_t)guardhp_max) hp = (int16_t)guardhp_max;
+        guardhp_curr = (uint8_t)hp;
+        if (guardhp_delta < 0) pop_guard_hurt = 1;   /* -> брызги поверх стража */
+        guardhp_delta = 0;
+    }
+}
+
+/* check_guard_fallout (seg002:0241): персонаж слота Guard провалился НИЖЕ
+ * комнаты.  Уйти в комнату снизу он не может (у стража нет перехода), и
+ * оригинал его просто убирает: guards_tile комнаты становится −1, то есть
+ * стража там больше нет и после возврата.  У нас тот же смысл — запомнить
+ * состояние с tile = 30 («стража в комнате больше нет»).
+ *
+ * Ветки тени (падает, только если она в свободном полёте) и скелета (тот
+ * возрождается в комнате 3) появятся вместе с L3-SKEL — сейчас в слоте
+ * бывает только обычный страж.
+ *
+ * Полосу HP перерисовывать отдельно не надо: pop_hp_draw сравнивает числа
+ * и сам увидит, что стража не стало. */
+/* Куда и как возрождается упавший СКЕЛЕТ (seg002:252): если под комнатой,
+ * из которой он выпал, лежит комната 3 — он появляется там снова.  Убить
+ * его нельзя вовсе, падение лишь переносит. */
+#define SKEL_REAPPEAR_ROOM  3
+#define SKEL_REAPPEAR_X   133
+#define SKEL_REAPPEAR_ROW   1
+
+void pop_guard_fallout(void)
+{
+    if (Guard.charid == 0 || Guard.y < 211) return;
+    if (Guard.charid == CHARID_4_SKELETON) {
+        uint8_t down = pop_room_link(Guard.room, 3 /* вниз */);
+        if (down == SKEL_REAPPEAR_ROOM) {
+            Guard.room      = down;
+            Guard.x         = SKEL_REAPPEAR_X;
+            Guard.curr_row  = SKEL_REAPPEAR_ROW;
+            Guard.direction = 0;             /* dir_0_right */
+            Guard.alive     = -1;
+            pop_guard_leave();               /* запомнить его в новой комнате */
+            return;
+        }
+    }
+    pop_guard_state_save(Guard.room, 30, 0, 0, 0, 0, 0);
+    Guard.charid = 0;
+    Guard.direction = 0;
+    Guard.alive = 0;
+    guardhp_curr = 0;
+}
+
+/* load_frame для стража (seg006:0293 ветка charid_2_guard): таблица у
+ * стражей СВОЯ (frame_tbl_guard), индекс = frame + add_frame − 149, где
+ * add_frame = 70 для кадров 102..106 (seg006:535). */
+void pop_guard_load_frame(void)
+{
+    int16_t idx = (int16_t)Guard.frame;
+    if (idx >= 102 && idx < 107) idx += 70;      /* add_frame */
+    idx -= 149;
+    if (idx < 0 || idx >= KID_NGFRAMES) { pop_gframe.image = 255; return; }
+    pop_kid_data_frame(KID_BIN_GFRAMES_OFF, (uint8_t)idx, (uint8_t *)&pop_gframe);
+}
+
+/* leave_guard (seg002:02F5): вызывать ПЕРЕД сменой комнаты, пока Guard ещё
+ * держит стража уходящей комнаты.  Мёртвого запоминаем вместе с
+ * последовательностью — тогда при возврате он лежит там же, а не встаёт
+ * живым. */
+void pop_guard_leave(void)
+{
+    if (Guard.charid == 0) return;              /* стража не было */
+    pop_guard_state_save(Guard.room,
+                         (uint8_t)(Guard.curr_row * 10),   /* get_tilepos(0,row) */
+                         Guard.direction, Guard.x, guard_skill,
+                         Guard.curr_seq,
+                         (uint8_t)(Guard.alive >= 0));
+}
+
+static int8_t guard_col_from_x(uint8_t xpos);   /* определена ниже */
+
+/* ---- Страж ИДЁТ ЗА КИДОМ в соседнюю комнату ------------------------- *
+ * Порт ветки стража из exit_room (seg002:0340..0382) + follow_guard
+ * (seg002:039E).  Своим ходом персонаж слота Guard из комнаты не уходит
+ * (его физика гейтится x ∈ [44,211), см. pop_guard_phys_tick), но когда
+ * комнату меняет КИД, движок может перенести стража следом — именно так в
+ * оригинале страж из комнаты 3 оказывается в комнате 2 за отступающим
+ * Кидом.
+ *
+ * Условия оригинала, все обязательные:
+ *   - страж есть, ЖИВ и с ВЫНУТЫМ МЕЧОМ (то есть идёт бой);
+ *   - переход ВБОК: вверх и вниз оригинал не пускает никогда (там условия
+ *     `curr_row >= 0` и `curr_row < 3` истинны всегда → leave_guard);
+ *   - в целевой комнате НЕТ своего ЖИВОГО стража (иначе их стало бы два:
+ *     проверка `guards_tile >= 30 || guards_seq_hi != 0` — «пусто или
+ *     труп»);
+ *   - страж прижат к тому краю, в который ушёл Кид: x < 91 при уходе
+ *     влево, x >= 165 при уходе вправо.
+ *
+ * side — куда ушёл КИД (0 = left, 1 = right, 2 = up, 3 = down), то есть
+ * roomleave_result оригинала.  Возврат: 1 — страж перенесён в new_room
+ * (вызывающий НЕ должен звать ни pop_guard_leave, ни pop_guard_enter),
+ * 0 — остаётся, всё как раньше. */
+uint8_t pop_guard_follow(uint8_t new_room, uint8_t side)
+{
+    uint8_t tile, color, skill;
+    int8_t dir;
+
+    if (Guard.charid == 0) return 0;                     /* dir_56_none */
+    if (Guard.alive >= 0 || Guard.sword != SWORD_2_DRAWN) return 0;
+    if (side > 1) return 0;                              /* только вбок */
+    /* «В целевой комнате уже есть живой страж» = страж по данным есть И это
+     * не запомненный труп (у трупа сохранена последовательность). */
+    if (pop_level_guard(new_room, &tile, &dir, &color, &skill) &&
+        pop_guard_state_seq(new_room) == 0) return 0;
+    if (side == 0) { if (Guard.x >= 91)  return 0; }     /* Кид ушёл влево  */
+    else           { if (Guard.x <  165) return 0; }     /* Кид ушёл вправо */
+
+    /* follow_guard: сначала «стража нет» в ОБЕИХ комнатах (в оригинале
+     * guards_tile = 0xFF).  Без этого он раздвоится: в старой комнате его
+     * поднимут из данных при возврате, а в новой — при следующем входе. */
+    pop_guard_state_save(Guard.room, 30, 0, 0, 0, 0, 0);
+    pop_guard_state_save(new_room,   30, 0, 0, 0, 0, 0);
+
+    /* goto_other_room (seg002:0486) для стража: комната + перенос X через
+     * шов (влево +140, вправо −140).  Ряд при боковом переходе не меняется;
+     * колонку пересчитываем из новой X, как enter_guard. */
+    Guard.room = new_room;
+    Guard.x = (uint8_t)(side == 0 ? Guard.x + 140 : Guard.x - 140);
+    Guard.curr_col = guard_col_from_x(Guard.x);
+    return 1;
+}
+
+/* get_tile_div_mod_m7 (seg006:697): колонка комнаты по X персонажа —
+ * floor((xpos − 7 − 58) / 14), где 58 = pop_x_bump[FIRST_ONSCREEN_COLUMN]. */
+static int8_t guard_col_from_x(uint8_t xpos)
+{
+    int16_t x = (int16_t)xpos - 7 - pop_x_bump[FIRST_ONSCREEN_COLUMN];
+    int16_t col = x / TILE_SIZEX;
+    if (x % TILE_SIZEX < 0) --col;
+    return (int8_t)col;
+}
+
+void pop_guard_enter(uint8_t room)
+{
+    uint8_t tile, color, skill;
+    int8_t dir;
+    pop_guard_reset();
+    /* load_lev_spr (seg000:1112): tbl_guard_type == −1 — стражей на уровне
+     * НЕТ вообще (14/15), их графика даже не грузится.  Без этой проверки
+     * на таком уровне полезли бы стражи из данных комнат. */
+    if (pop_level_guard_type(pop_current_level) < 0) return;
+    if (!pop_level_guard(room, &tile, &dir, &color, &skill)) return;
+    /* Цвет — ДО отрисовки комнаты (как redraw_screen, seg003:255): слоты
+     * палитры общие на экран, и смена посреди кадра дала бы стража в новой
+     * палитре с полосой HP в старой. */
+    pop_guard_set_palette(color);
+    /* enter_guard (seg002:0112) + pos_guards (seg003): X считается из
+     * колонки тайла, а не берётся из файла. */
+    Guard.room      = room;
+    Guard.curr_row  = (int8_t)(tile / 10);
+    Guard.y         = (uint8_t)pop_y_land[Guard.curr_row + 1];
+    Guard.x         = (uint8_t)(pop_x_bump[(tile % 10) + FIRST_ONSCREEN_COLUMN] + TILE_SIZEX);
+    Guard.curr_col  = (int8_t)(tile % 10);
+    Guard.direction = dir;
+    /* seg002:196: на уровне со скелетами слот поднимает СКЕЛЕТА, и он
+     * встаёт сразу активным — с вынутым мечом (seq_63), а не в стойке
+     * покоя (seq_77).  Стойку ставит ветка ниже, вместе с seq трупа. */
+    Guard.charid    = (pop_level_guard_type(pop_current_level) == 2)
+                      ? CHARID_4_SKELETON : CHARID_2_GUARD;
+    Guard.sword     = (Guard.charid == CHARID_4_SKELETON)
+                      ? SWORD_2_DRAWN : 0;   /* sword_0_sheathed */
+    Guard.alive     = -1;
+    Guard.action    = 1;                     /* actions_1_run_jump */
+    Guard.fall_x = Guard.fall_y = 0;
+    /* enter_guard (seg002:214): мастерство из данных уровня, 12 градаций;
+     * всё, что вне диапазона, оригинал сводит к 3. */
+    guard_skill = (uint8_t)(skill < NUM_GUARD_SKILLS ? skill : 3);
+    /* get_guard_hp (seg002:54): extrastrength[skill] + tbl_guard_hp[уровень].
+     * extrastrength (seg002:38) ненулевой только у skill 4 (=1). */
+    guardhp_max = guardhp_curr =
+        (uint8_t)(pop_level_guard_hp(pop_current_level) + (guard_skill == 4 ? 1 : 0));
+    guardhp_delta = 0;
+    /* enter_guard (seg002:0208).  Живого поднимаем стандартной стойкой; у
+     * ЗАПОМНЕННОГО МЁРТВОГО берём сохранённую последовательность — он лежит
+     * ровно там, где лёг (порт ветки guards_seq_hi != 0). */
+    {
+        uint16_t saved_seq = pop_guard_state_seq(room);
+        /* У ЗАПОМНЕННОГО трупа X берём сохранённую: pos_guards (seg003:620)
+         * пересчитывает её из колонки только при загрузке уровня, а дальше
+         * ею владеет leave_guard.  Иначе тело при возврате прыгает в центр
+         * тайла. */
+            if (saved_seq) Guard.x = pop_guard_state_x(room);
+            /* ...и КОЛОНКУ пересчитываем из X (enter_guard, seg002:180:
+             * `Char.curr_col = get_tile_div_mod_m7(Char.x)`).  Брать её из
+             * тайла нельзя: leave_guard сохраняет get_tilepos(0, row), то
+             * есть колонку 0 всегда.  У живого стража это незаметно (X там
+             * сам считается из колонки), а у ЗАПОМНЕННОГО ТРУПА X
+             * настоящая, и curr_col оставался нулём при теле, лежащем в
+             * колонке 2.  Тайл трупа шёл в обходе раньше тайла Кида, и Кид
+             * рисовался ПОВЕРХ тела вместо того, чтобы пройти за ним
+             * (BUG-DRAWORDER-1).  Колонка нужна не только отрисовке — на
+             * неё смотрят коллизия и check_can_guard_see_kid. */
+            Guard.curr_col = guard_col_from_x(Guard.x);
+        pop_loadshad();
+        if (saved_seq) Char.curr_seq = saved_seq;
+        else           pop_char_set_seq(SEQ_77_GUARD_STAND_INACTIVE);
+        pop_saveshad();
+        pop_guard_play();                    /* до первого кадра */
+        /* enter_guard (seg002:218): кадр смерти -> страж поднят ТРУПОМ. */
+        if (Guard.frame == 185 || Guard.frame == 177 || Guard.frame == 178) {
+            Guard.alive = 1;
+            guardhp_curr = 0;
+        }
+    }
+}
@@ -0,0 +1,212 @@
+/*
+ * pop_guard.h — СОСТОЯНИЕ стража и точки входа в его логику.
+ *
+ * Разделение по окнам (docs/layout_plan_v2.md §4, подтверждено пробником
+ * tests/w3bankgfx):
+ *   - СОСТОЯНИЕ живёт здесь, в W1/W2.  Писучие статики __banked-модуля
+ *     линкуются В СТРАНИЦУ БАНКА и снаружи не читаются, поэтому банк —
+ *     только код;
+ *   - ЛОГИКА (ИИ, боёвка) — в guards.c, собираемом как --bank 1=guards.c;
+ *   - ОТРИСОВКА стража — в pop_gdraw.c, РЕЗИДЕНТЕ W3 (--w3): её зовёт
+ *     только главный цикл, а из банка резидент недостижим.  Так код
+ *     отрисовки не занимает дефицитные W1/W2 (куча).
+ *
+ * Поля char_type — как в оригинале (types.h:302), чтобы порт seg005/seg006
+ * ложился один в один.
+ */
+#ifndef POP_GUARD_H
+#define POP_GUARD_H
+
+#include <stdint.h>
+#include "kid_data.h"          /* kframe */
+#include "pop_char.h"
+#include "pop_geom.h"    /* pop_rnd_t — сид бросков боёвки */
+
+/* seqids (types.h:1052+) — последовательности боя и стойки. */
+#define SEQ_55_DRAW_SWORD           55
+#define SEQ_56_GUARD_FORWARD        56   /* шаг вперёд с мечом (страж)   */
+#define SEQ_57_BACK_WITH_SWORD      57
+#define SEQ_58_GUARD_STRIKE         58
+#define SEQ_60_TURN_WITH_SWORD      60
+#define SEQ_61_PARRY_AFTER_STRIKE   61
+#define SEQ_62_PARRY                62
+#define SEQ_66_STRIKE_AFTER_PARRY   66
+#define SEQ_71_DYING                71
+#define SEQ_75_STRIKE               75   /* удар (Кид)                   */
+#define SEQ_63_GUARD_ACTIVE_AFTER_FALL 63  /* стойка АКТИВНОГО (скелет)   */
+#define SEQ_77_GUARD_STAND_INACTIVE 77
+#define SEQ_88_SKEL_WAKE_UP         88   /* скелет встаёт (спецсобытие)   */
+#define SEQ_80_STAND_FLIPPED        80
+#define SEQ_86_FORWARD_WITH_SWORD   86   /* шаг вперёд с мечом (Кид)     */
+#define SEQ_87_GUARD_BECOME_INACT   87
+#define SEQ_90_EN_GARDE             90
+#define SEQ_92_PUT_SWORD_AWAY       92
+#define SEQ_93_PUT_SWORD_AWAY_FAST  93
+
+/* frameids (types.h:911+) и состояния меча (types.h:332). */
+#define FRAME_150_PARRY            150
+#define FRAME_151_STRIKE_1         151
+#define FRAME_152_STRIKE_2         152
+#define FRAME_153_STRIKE_3         153
+#define FRAME_157_WALK_WITH_SWORD  157
+#define FRAME_158_STAND_WITH_SWORD 158
+#define FRAME_161_PARRY            161
+#define FRAME_162_BLOCK_TO_STRIKE  162
+#define FRAME_165_WALK_WITH_SWORD  165
+#define FRAME_166_STAND_INACTIVE   166
+#define FRAME_167_BLOCKED          167
+#define FRAME_168_BACK             168
+#define FRAME_169_BEGIN_BLOCK      169
+#define FRAME_170_STAND_WITH_SWORD 170
+#define FRAME_171_STAND_WITH_SWORD 171
+#define SWORD_0_SHEATHED             0
+#define SWORD_2_DRAWN                2
+
+/* charids (types.h:320) — нужны хотя бы для «скелет не убивается читом». */
+#define CHARID_0_KID       0
+#define CHARID_1_SHADOW    1
+#define CHARID_2_GUARD     2
+#define CHARID_4_SKELETON  4
+#define CHARID_5_PRINCESS  5
+
+/* Градаций мастерства стража (seg002: таблицы вероятностей по 12 записей). */
+#define NUM_GUARD_SKILLS  12
+
+/* Тип персонажа — в pop_char.h (общий с Кидом и Char). */
+
+extern pop_char_t Guard;            /* страж ТЕКУЩЕЙ комнаты (как в оригинале) */
+extern uint8_t  guardhp_curr, guardhp_max;
+extern int8_t   guardhp_delta;      /* <0 = в этом кадре отняли HP */
+
+/* take_hp (seg006:06BD): отнять count HP у АКТИВНОГО персонажа (Char) —
+ * Киду из `hitp_*`, любому другому из `guardhp_*`.  Возврат 1 = HP кончились
+ * (для вызывающего это «умер»); саму дельту применяет pop_do_delta_hp раз в
+ * кадр, как в оригинале.
+ *
+ * Живёт в резиденте W1/W2, потому что зовут ОБА банка: боёвка (guards.c,
+ * банк 1) и физика (pop_map.c, банк 3) — раньше у каждого была своя копия,
+ * причём у pop_map неверная (правила hitp_curr напрямую, мимо дельты, и не
+ * знала про не-Кидов).  Чит бессмертия ловится здесь же. */
+uint8_t pop_take_hp(uint8_t count);
+
+/* Взводится в кадре, когда СТРАЖУ убавили HP (guardhp_delta < 0 оригинала):
+ * по нему pop_guard_draw рисует «брызги» удара, как draw_guard в seg008:1654.
+ * Снимает главный цикл после отрисовки — стража могло не оказаться в
+ * отрисованной комнате, и тогда флаг обязан просто пропасть. */
+extern uint8_t pop_guard_hurt;
+
+/* Видит ли страж Кида (порт can_guard_see_kid, seg003:688):
+ *   0 — не видит, 1 — видит, но не пойдёт (между ними loose/чомпер/дыра),
+ *   2 — видит и пойдёт.  Считает pop_check_can_guard_see_kid (банк) раз в
+ * кадр ДО логики персонажей; читают ИИ (autocontrol_*) и боёвка. */
+extern int8_t can_guard_see_kid;
+
+/* Кид «нашумел» (порт is_guard_notice, seg000:364): заставляет неактивного
+ * стража обернуться, даже если Кид у него за спиной.  Ставит источник шума,
+ * снимает сам ИИ. */
+extern int8_t is_guard_notice;
+
+/* Боевые таймеры/уровень мастерства (seg000:295..311).  Все убывают раз в
+ * кадр в autocontrol_opponent — как в оригинале.
+ *   guard_skill      — 0..11, из данных уровня; индекс в таблицы вероятностей;
+ *   guard_refrac     — «отдышка» стража: пока >0, он не атакует и не наступает;
+ *   justblocked      — Кид только что парировал (влияет на вероятность блока);
+ *   kid_sword_strike — Кид только что бил (стража это придерживает). */
+extern uint8_t guard_skill;
+extern int8_t  guard_refrac, justblocked, kid_sword_strike;
+
+/* Состояние меча КИДА (seg005/seg006):
+ *   offguard      — меч убран НАМЕРЕННО (вниз в бою): пока стоит, Кид не
+ *                   достаёт клинок автоматически, даже видя стража;
+ *   holding_sword — клинок в руке (для индикатора HP стража). */
+extern int8_t  offguard, holding_sword;
+
+/* Сид бросков боёвки (свой домен последовательности, см. pop_geom.h). */
+extern pop_rnd_t pop_fight_seed;
+
+/* Луч видимости стража — раз в кадр, ДО тиков персонажей (в оригинале
+ * check_can_guard_see_kid стоит в play_frame перед play_kid_frame). */
+void pop_check_can_guard_see_kid(void) __banked;
+
+/* check_skel (seg002:1042) — СПЕЦСОБЫТИЕ уровня 3: скелета нет в данных
+ * уровня (guards_tile пуст во всех комнатах), он поднимается сам, когда Кид
+ * доходит до нужной колонки комнаты 1 при открытой двери уровня.  Звать раз
+ * в кадр, ДО логики персонажей (порядок play_frame, seg000:868). */
+void pop_check_skel(void) __banked;
+
+/* Боёвка: пометить попадания (обе стороны) и применить их.  Порядок в
+ * кадре как в play_frame: hurting -> hurt -> do_delta_hp. */
+void pop_check_sword_hurting(void) __banked;
+void pop_check_sword_hurt(void) __banked;
+
+/* Текущий кадр стража (порт cur_frame для Char): заполняет логика в W1/W2,
+ * читает отрисовка в резиденте W3.  image == 255 — рисовать нечего. */
+extern kframe pop_gframe;
+void pop_guard_load_frame(void);
+
+/* check_guard_fallout (seg002:0241): убрать персонажа слота Guard, если он
+ * провалился ниже комнаты.  Звать раз в кадр после физики и HP — как
+ * play_frame (seg000:884). */
+void pop_guard_fallout(void);
+
+/* Есть ли живой страж в отрисованной комнате (для главного цикла). */
+uint8_t pop_guard_present(void);
+
+/* Атласы стража (GUARD\\g0..g4.atl) — грузить ДО initgraph, как Kid.
+ * 0 — OK, -1 — ошибка (тогда страж просто не рисуется). */
+int  pop_guard_load(void) __banked;
+void pop_guard_free(void) __banked;
+
+/* Вход в комнату: поднять стража из данных уровня (порт enter_guard,
+ * seg002:0112) либо убрать его, если в комнате стража нет. */
+void pop_guard_enter(uint8_t room);
+
+/* Запомнить стража УХОДЯЩЕЙ комнаты (порт leave_guard).  Звать в начале
+ * enter_room, пока Guard ещё держит прежнего. */
+void pop_guard_leave(void);
+
+/* Страж идёт ЗА КИДОМ в соседнюю комнату — порт ветки стража из exit_room
+ * (seg002:0340) + follow_guard (seg002:039E).  Звать ВМЕСТО пары
+ * leave/enter при смене комнаты: 1 = страж уже перенесён в new_room (ни
+ * leave, ни enter звать нельзя), 0 = остаётся в старой (всё как раньше).
+ * side — куда ушёл КИД: 0 left, 1 right, 2 up, 3 down. */
+uint8_t pop_guard_follow(uint8_t new_room, uint8_t side);
+
+/* Нарисовать текущий кадр стража на back-странице (банк GFX_BANK_SPRITE,
+ * как kid_draw) и стереть прошлый (heal).  Реализация — pop_gdraw.c
+ * (резидент W3), поэтому звать ТОЛЬКО из главного цикла, не из банка. */
+/* Полоса HP (Кид слева, страж справа) в статус-полосе.  Рисует главный цикл
+ * ПОСЛЕ персонажей — она ничего не перекрывает. */
+void pop_hp_draw(void) __banked;
+/* Полоса стёрта перерисовкой фона (вход в комнату) — обновить обе страницы. */
+void pop_hp_invalidate(void) __banked;
+
+/* Цвет стража — подменой 16 слотов палитры (порт set_chtab_palette,
+ * seg003:257): спрайты лежат в индексах POP_GUARD_PAL_BASE + v, а цвет
+ * задаёт level.guards_color[room-1] (1..7; 0 = не менять).  Звать ДО
+ * отрисовки комнаты, как это делает redraw_screen. */
+void pop_guard_set_palette(uint8_t color) __banked;
+
+void pop_guard_heal(void) __banked;
+void pop_guard_draw(void) __banked;
+
+/* Ширина спрайта последнего нарисованного кадра стража (char_width_half
+ * в set_char_collision).  Нужна для его ТАЙЛА ОБЪЕКТА — от него зависит
+ * порядок отрисовки относительно Кида. */
+uint16_t pop_guard_fp_width(void) __banked;
+
+/* Убрать стража со сцены (смена комнаты / инициализация). */
+void pop_guard_reset(void);
+
+/* Чит «убить стража» (seg000:786, K): скелета не берёт.  Вызывать только
+ * при включённых читах — проверку делает вызывающий. */
+void pop_guard_kill(void);
+
+/* do_delta_hp (seg003): применить дельту HP, накопленную за кадр.  Звать
+ * раз в кадр ПОСЛЕ тиков персонажей (в оригинале — в play_frame). */
+void pop_do_delta_hp(void);
+
+/* Тик логики стража — В БАНКЕ (guards.c).  Состояние берёт отсюда. */
+void pop_guard_tick(void) __banked;
+
+#endif
@@ -0,0 +1,31 @@
+/* pop_guard_pal.h — палитры стражей (guard_palettes из res10.bin).
+ * СГЕНЕРЕНО toolchain/pop_pack_guard.py — НЕ править вручную.
+ *
+ * Индексация как в оригинале: цвет из level.guards_color[room-1]
+ * (младшие 4 бита), 1..7 -> строка [color-1]; 0 = палитру НЕ менять
+ * (seg003:255 при curr_guard_color == 0 set_chtab_palette не зовёт).
+ * Запись — 4 байта (B, G, R, 0), формат gfx_pal_load. */
+#ifndef POP_GUARD_PAL_H
+#define POP_GUARD_PAL_H
+
+#include <stdint.h>
+
+#define POP_GUARD_PAL_BASE 0x90   /* слоты Sprinter под chtab_5 */
+#define POP_GUARD_NPAL     7
+
+static const uint8_t pop_guard_pal[POP_GUARD_NPAL][64] = {
+    { 0x00,0x00,0x00,0x00,0xFF,0x91,0x48,0x00,0xB2,0x81,0x69,0x00,0xFF,0xFF,0xFF,0x00,0x38,0x5D,0x79,0x00,0x50,0x6D,0xAA,0x00,0x69,0x89,0xDA,0x00,0xD2,0xB6,0xD2,0x00,0x91,0x7D,0x91,0x00,0xFF,0xDA,0xFF,0x00,0x4C,0x81,0xA1,0x00,0x71,0xBA,0xEA,0x00,0x79,0x28,0x81,0x00,0xB2,0x81,0x69,0x00,0xC2,0xC2,0xC2,0x00,0x38,0x00,0xF6,0x00 },
+    { 0x00,0x00,0x00,0x00,0x00,0x30,0xAA,0x00,0x00,0x24,0x81,0x00,0x79,0x79,0xFF,0x00,0x38,0x5D,0x79,0x00,0x50,0x6D,0xAA,0x00,0x69,0x89,0xDA,0x00,0xC2,0x69,0x85,0x00,0xAA,0x5D,0x75,0x00,0xFF,0x89,0xB2,0x00,0x50,0x50,0x79,0x00,0x71,0x71,0xAA,0x00,0xBE,0x28,0xBA,0x00,0x00,0x24,0x81,0x00,0x61,0x61,0xCA,0x00,0x38,0x00,0xF6,0x00 },
+    { 0x00,0x00,0x00,0x00,0x00,0x50,0xFF,0x00,0x00,0x38,0xBE,0x00,0xFF,0xFF,0xFF,0x00,0x38,0x5D,0x79,0x00,0x50,0x6D,0xAA,0x00,0x69,0x89,0xDA,0x00,0x00,0x99,0xD2,0x00,0x00,0x7D,0xAA,0x00,0x00,0xBA,0xFF,0x00,0x4C,0x81,0xA1,0x00,0x71,0xBA,0xEA,0x00,0x99,0x28,0x6D,0x00,0x00,0x38,0xBE,0x00,0xD2,0xCA,0xCA,0x00,0x38,0x00,0xF6,0x00 },
+    { 0x00,0x00,0x00,0x00,0x00,0x91,0x0C,0x00,0x00,0x71,0x0C,0x00,0xFF,0xD2,0xFF,0x00,0x38,0x5D,0x79,0x00,0x50,0x6D,0xAA,0x00,0x69,0x89,0xDA,0x00,0x4C,0xAE,0xCA,0x00,0x38,0x7D,0x91,0x00,0x61,0xDA,0xFF,0x00,0x4C,0x81,0xA1,0x00,0x71,0xBA,0xEA,0x00,0x20,0x00,0x99,0x00,0x00,0x71,0x0C,0x00,0xB2,0x91,0xB2,0x00,0x38,0x00,0xF6,0x00 },
+    { 0x00,0x00,0x00,0x00,0xFF,0x00,0x61,0x00,0xAA,0x00,0x61,0x00,0xB2,0x3C,0xBE,0x00,0x38,0x5D,0x79,0x00,0x50,0x6D,0xAA,0x00,0x69,0x89,0xDA,0x00,0x8D,0xBA,0xCA,0x00,0x6D,0x8D,0x99,0x00,0xB2,0xEA,0xFF,0x00,0x34,0x6D,0x91,0x00,0x40,0x89,0xBA,0x00,0x79,0x28,0x81,0x00,0xAA,0x00,0x61,0x00,0x81,0x2C,0x89,0x00,0x38,0x00,0xF6,0x00 },
+    { 0x00,0x00,0x00,0x00,0xFF,0x59,0xCA,0x00,0xC2,0x44,0x99,0x00,0xFF,0xAA,0x91,0x00,0x38,0x5D,0x79,0x00,0x50,0x6D,0xAA,0x00,0x69,0x89,0xDA,0x00,0xD2,0xB6,0xD2,0x00,0x99,0xB2,0xB2,0x00,0xDA,0xFF,0xFF,0x00,0x4C,0x81,0xA1,0x00,0x71,0xBA,0xEA,0x00,0xA1,0x6D,0x5D,0x00,0xC2,0x44,0x99,0x00,0xD2,0x8D,0x79,0x00,0x38,0x00,0xF6,0x00 },
+    { 0x00,0x00,0x00,0x00,0x00,0xFF,0xFF,0x00,0x00,0xDA,0xDE,0x00,0xE2,0x30,0xB2,0x00,0x38,0x5D,0x79,0x00,0x50,0x6D,0xAA,0x00,0x69,0x89,0xDA,0x00,0x00,0x9D,0xD2,0x00,0x00,0x9D,0xF2,0x00,0x00,0xC2,0xFF,0x00,0xA1,0x4C,0x75,0x00,0xFF,0x79,0xBA,0x00,0xB2,0x00,0x61,0x00,0x00,0xDA,0xDE,0x00,0xAA,0x24,0x85,0x00,0x38,0x00,0xF6,0x00 },
+};
+
+/* Скелет (SKEL/res750.pal): свой набор — свой цвет. */
+static const uint8_t pop_skel_pal[64] = {
+    0x00,0x00,0x00,0x00,0xFF,0xFF,0x55,0x00,0x89,0x79,0xBA,0x00,0xF2,0xFF,0xFF,0x00,0x00,0x00,0xAA,0x00,0xAA,0x00,0xAA,0x00,0x00,0x55,0xAA,0x00,0xDA,0xE6,0xE6,0x00,0x55,0x55,0x55,0x00,0xFF,0x55,0x55,0x00,0x55,0xFF,0x55,0x00,0xFF,0xFF,0x55,0x00,0x55,0x55,0xFF,0x00,0x00,0x00,0x00,0x00,0x55,0xFF,0xFF,0x00,0xFF,0xFF,0xFF,0x00,
+};
+
+#endif
@@ -2,42 +2,146 @@
 * pop_kid.c — движок Kid (Фаза K1): порт seg006.c play_seq/load_frame +
 * seqtbl-интерпретатор.  Данные — kid_data.h.
 */
+#include <fcntl.h>
+#include <unistd.h>
+#include <sprinter.h>
+#include <sprinter_mem.h>
 #include <graphics.h>
 #include <gfx.h>
 #include <sprite.h>
 #include "pop_kid.h"
+#include "pop_guard.h"   /* Guard/pop_gframe/CHARID_* — интерпретатор общий */
 #include "pop_bg.h"           /* POP_YOFF — вертикальное центрирование */
+#include "_pop_draw.h"   /* pop_onscreen_cols / pop_heal_fast */
 #include "pop_map.h"          /* pop_clip_char_top (clip_char) */
+#include "pop_geom.h"
 #include "kid_data.h"

-kid_t Kid;
+pop_char_t Kid;

 /* Флаг сотрясения (seg006 knock): ставится seqtbl-командой KNOCK_UP/DOWN
 * в play_seq, потребляется pop_check_knock (pop_map) — трясёт loose-полы. */
 int8_t knock;

-/* Координатные таблицы (data.h). */
-static const uint8_t x_bump[20] = {
-    (uint8_t)-12, 2, 16, 30, 44, 58, 72, 86, 100, 114,
-    128, 142, 156, 170, 184, 198, 212, 226, 240, 254
-};
-static const int16_t y_land[5] = {-8, 55, 118, 181, 244};
-#define FIRST_ONSCREEN_COLUMN 5
-#define TILE_SIZEX 14
+/* Порт глобала next_level: seqtbl-команда END_LEVEL инкрементит его в конце
+ * seq_70 (подъём по лестнице за дверью уровня), а главный цикл сравнивает с
+ * текущим уровнем и грузит следующий.  Счётчик, а не флаг — ровно как в
+ * оригинале, чтобы читы «следующий/предыдущий уровень» (levels_plan.md §4)
+ * легли сюда же без переделки. */
+uint8_t pop_next_level;
+

 /* ---- Атласы Kid (прямая адресация image>>3) ------------------------ */
 #define KID_MAXPAGES 28
 static atlas_t kidp[KID_MAXPAGES];
 static uint8_t kid_npages;

+/* chtab_0 «меч в руке» (add_sword_to_objtable, seg006:1798): клинок —
+ * ОТДЕЛЬНЫЙ спрайт поверх персонажа, один и тот же атлас у Кида и у стража.
+ * Таблица sword_tbl (kid_data.h, генерится из seg006) индексируется
+ * sword_frame = кадр.sword & 0x3F; id 255 = клинка в этом кадре нет.
+ * Смещения — в ЭКРАННЫХ пикселях: оригинал применяет их ПОСЛЕ
+ * calc_screen_x_coord, x — «вперёд» по направлению персонажа. */
+static const uint8_t SWORD_ID[KID_NSWORD] = KID_SWORD_ID_INIT;
+static const int8_t  SWORD_DX[KID_NSWORD] = KID_SWORD_DX_INIT;
+static const int8_t  SWORD_DY[KID_NSWORD] = KID_SWORD_DY_INIT;
+static atlas_t swordp;
+static uint8_t  sword_ok;
+
+int pop_sword_load(void)
+{
+    if (atlas_load(&swordp, "KID\\sword.atl") != 0) return -1;
+    sword_ok = 1;
+    return 0;
+}
+
+/* add_sword_to_objtable (seg006:1798).  Клинок рисуется, если персонаж в
+ * кадрах подъёма/ножен, ИЛИ держит меч, ИЛИ это ЖИВОЙ страж (у стража меч
+ * в руке всегда, даже пока sword ещё sheathed).  Страницу W0 оставляем
+ * замапленной — вызывающий делает gfx_w0_unmap сам. */
+uint8_t pop_sword_draw(const pop_char_t *ch, const kframe *fr,
+                       int obj_x, int obj_y,
+                       int *rx, int *ry, uint16_t *rw, uint16_t *rh)
+{
+    uint8_t sf, id, flip;
+    const uint8_t *simg;
+    uint16_t w, h;
+    int bx, top;
+
+    if (!sword_ok) return 0;
+    if (!((ch->frame >= 229 && ch->frame < 238) ||
+          ch->sword != 0 ||
+          ((ch->charid == CHARID_2_GUARD || ch->charid == CHARID_4_SKELETON) &&
+           ch->alive < 0)))
+        return 0;
+    sf = (uint8_t)(fr->sword & 0x3F);
+    if (sf == 0 || sf >= KID_NSWORD) return 0;
+    id = SWORD_ID[sf];
+    if (id == 0xFF) return 0;
+
+    simg = (const uint8_t *)atlas_image(&swordp, id);
+    gfx_w0_map(swordp.page);
+    w = (uint16_t)(simg[0] | ((uint16_t)simg[1] << 8));
+    h = (uint16_t)(simg[2] | ((uint16_t)simg[3] << 8));
+    if (!w || !h) return 0;
+
+    flip = (uint8_t)(ch->direction >= 0);
+    bx  = obj_x + ((ch->direction < 0) ? -(int)SWORD_DX[sf] : (int)SWORD_DX[sf]);
+    top = obj_y + (int)SWORD_DY[sf] - (int)h + 1;
+    if (flip) bx -= (int)w;
+    /* Поле комнаты — 192 строки (reset_obj_clip, seg006:0507): клинок
+     * обрезается по нему так же, как сам персонаж.  Без этого у падающего
+     * в пропасть скелета меч оставался виден НИЖЕ поля, на полосе HP. */
+    {
+        int skip = 0, rows = (int)h;
+        if (top < 0) { skip = -top; rows -= skip; top = 0; }
+        if (top + rows > 192) rows = 192 - top;
+        if (rows <= 0) return 0;
+        gfx_set_bank(GFX_BANK_SPRITE);
+        /* Клинок почти всегда целиком на экране — noclip-путь (см. gfx.h:
+         * подготовка клипающего варианта стоит ~5.6 К тактов на вызов). */
+        if (pop_onscreen_cols(bx, top + POP_YOFF, w, (uint16_t)rows))
+            gfx_blit_cols_part_noclip(bx, top + POP_YOFF, simg, flip,
+                                      (uint8_t)skip, (uint8_t)rows);
+        else
+            gfx_blit_cols_part(bx, top + POP_YOFF, simg, flip, skip, rows);
+        gfx_set_bank(GFX_BANK_NORMAL);
+        *rx = bx; *ry = top; *rw = w; *rh = (uint16_t)rows;
+    }
+    return 1;
+}
+
+/* Блит спрайта chtab_2 (атласы Kid) по ЕГО id, левым верхним углом в (x,y).
+ * Нужен полосе HP: она рисует id 216/217 из тех же атласов, что и кадры
+ * Кида, а держать вторую копию раскладки в pop_gdraw ни к чему. */
+void pop_kid_img_blit(uint8_t image, int x, int y)
+{
+    uint8_t pg  = (uint8_t)(image >> 3);   /* раскладка атласов: 8 спрайтов/стр. */
+    uint8_t idx = (uint8_t)(image & 7);
+    const uint8_t *img;
+    uint16_t w, h;
+    if (pg >= kid_npages) return;
+    img = (const uint8_t *)atlas_image(&kidp[pg], idx);
+    gfx_w0_map(kidp[pg].page);
+    w = (uint16_t)(img[0] | ((uint16_t)img[1] << 8));
+    h = (uint16_t)(img[2] | ((uint16_t)img[3] << 8));
+    /* Атласы Кида хранятся COLUMN-MAJOR (transpose_cols в pop_pack_kid —
+     * ради бесплатного горизонтального флипа), поэтому блит обязан быть
+     * колоночным.  Row-major gfx_blit_noclip выдал бы марку транспонированной.
+     * noclip БЕЗ проверки (CLIP-1): единственный вызывающий — полоса HP
+     * (pop_gdraw.c), у неё координаты фиксированные и заведомо на экране. */
+    if (w && h) gfx_blit_cols_part_noclip(x, y, img, 0, 0, 0);
+    gfx_w0_unmap();
+}
+
 int pop_kid_load(uint8_t npages)
 {
    static const char *const names[KID_MAXPAGES] = {
-        "kid0.atl","kid1.atl","kid2.atl","kid3.atl","kid4.atl","kid5.atl",
-        "kid6.atl","kid7.atl","kid8.atl","kid9.atl","kid10.atl","kid11.atl",
-        "kid12.atl","kid13.atl","kid14.atl","kid15.atl","kid16.atl","kid17.atl",
-        "kid18.atl","kid19.atl","kid20.atl","kid21.atl","kid22.atl","kid23.atl",
-        "kid24.atl","kid25.atl","kid26.atl","kid27.atl"
+        "KID\\kid0.atl","KID\\kid1.atl","KID\\kid2.atl","KID\\kid3.atl","KID\\kid4.atl","KID\\kid5.atl",
+        "KID\\kid6.atl","KID\\kid7.atl","KID\\kid8.atl","KID\\kid9.atl","KID\\kid10.atl","KID\\kid11.atl",
+        "KID\\kid12.atl","KID\\kid13.atl","KID\\kid14.atl","KID\\kid15.atl","KID\\kid16.atl","KID\\kid17.atl",
+        "KID\\kid18.atl","KID\\kid19.atl","KID\\kid20.atl","KID\\kid21.atl","KID\\kid22.atl","KID\\kid23.atl",
+        "KID\\kid24.atl","KID\\kid25.atl","KID\\kid26.atl","KID\\kid27.atl"
    };
    uint8_t i;
    if (npages > KID_MAXPAGES) npages = KID_MAXPAGES;
@@ -56,63 +160,268 @@ void pop_kid_free(void)
    kid_npages = 0;
 }

-/* ---- seqtbl-доступ (база SEQTBL_BASE) ------------------------------ */
-#define SEQ(cs) kid_seqtbl[(uint16_t)((cs) - SEQTBL_BASE)]
+/* ---- Данные анимации в EMM-странице (kid_data.bin) ------------------ *
+ * Таблица кадров (241*5 Б) и seqtbl (2310 Б) занимали 3.5 КБ в _CODE окна
+ * W1/W2 — самый дефицитный ресурс.  Теперь они лежат в отдельной EMM-
+ * странице, которая маппится в W0 РОВНО на время play_seq (раз за тик), а
+ * весь остальной код читает cur_frame — 5-байтовую копию текущего кадра.
+ * Это ровно устройство оригинала: load_frame (seg006) заполняет cur_frame,
+ * и коллизия/отрисовка работают с ним, а не с таблицей.
+ * Страница адресуется как у pop_level: данные с 0x100, ниже — ISR-стаб. */
+extern void _gfx_w0_isr(void);
+
+#define KD_DATA_OFF   0x100u
+/* Адрес кадра i в замапленной странице.  Считаем В uint16_t и кастуем ОДИН
+ * раз: запись `(const uint8_t *)CONST + (uint16_t)i * 5u` SDCC 4.5 собирает
+ * НЕВЕРНО — умножение делает в 16 битах (add hl,hl / add hl,bc), а потом
+ * берёт только МЛАДШИЙ байт результата и подставляет старший байт константы
+ * (`ld c,l` / `inc b`).  Для кадров i >= 52 (i*5 >= 256) адрес уезжает на
+ * −256*k, и cur_frame наполняется чужой строкой таблицы: у бега/шага/подъёма
+ * пропадал бит FRAME_NEEDS_FLOOR, и Kid проваливался сквозь пол.
+ * Артефакт: .sprinter-cc-roomtest/pop_kid.asm, функция load_frame. */
+static const uint8_t *kd_frame_ptr(uint8_t i)
+{
+    uint16_t off = (uint16_t)i;
+    off += (uint16_t)(off << 2);        /* i*5 = i + i*4, без умножения */
+    off += (uint16_t)(KD_DATA_OFF + KID_BIN_FRAMES_OFF);
+    return (const uint8_t *)off;
+}
+
+/* То же для таблицы кадров СТРАЖА (frame_tbl_guard дописана в ту же
+ * страницу данных, см. pop_extract_kid_data.py). */
+static const uint8_t *kd_gframe_ptr(uint8_t i)
+{
+    uint16_t off = (uint16_t)i;
+    off += (uint16_t)(off << 2);
+    off += (uint16_t)(KD_DATA_OFF + KID_BIN_GFRAMES_OFF);
+    return (const uint8_t *)off;
+}
+#define KD_SEQ(cs)    (*((const uint8_t *)(KD_DATA_OFF + KID_BIN_SEQTBL_OFF) + \
+                        (uint16_t)((cs) - SEQTBL_BASE)))
+/* Байт seqtbl по адресу оригинала (база SEQTBL_BASE); ТОЛЬКО под замапленной
+ * страницей данных — то есть внутри play_seq. */
+#define SEQ(cs)       KD_SEQ(cs)
+
+static uint8_t kdat_blk, kdat_page, kdat_ok;
+
+/* Текущий кадр (порт глобала cur_frame, seg006): 5 байт вместо таблицы.
+ * Заполняется load_frame для АКТИВНОГО персонажа (Char), поэтому на
+ * выходе из play_seq его надо сохранить в кэш своего персонажа: страж
+ * тикает ПОСЛЕ Кида, и без разделения kid_draw взял бы кадр стража. */
+static kframe cur_frame;
+static kframe kid_frame;          /* кадр Kid для kid_draw */
+
+/* Char (seg006): АКТИВНЫЙ персонаж.  Интерпретатор последовательностей в
+ * оригинале работает не с Kid и не с Guard, а с этой копией, а вокруг
+ * стоят loadkid/savekid и loadshad/saveshad (seg006:809..825).  Копия, а
+ * не указатель, — и так же, как в оригинале, и быстрее на Z80: обращения
+ * в горячем цикле идут абсолютной адресацией глобала, а 16-байтовое
+ * копирование платится один раз на переключение персонажа. */
+pop_char_t Char;
+
+/* Opp (seg006): СОПЕРНИК активного персонажа — вторая копия, которую ставят
+ * рядом с Char (loadkid_and_opp / loadshad_and_opp, seg006:809).  Через неё
+ * ИИ и боёвка меряют дистанцию (char_opp_dist), не зная, кто именно перед
+ * ними: для стража Opp = Kid, для Кида Opp = Guard. */
+pop_char_t Opp;
+
+void pop_loadkid(void)  { Char = Kid; }
+void pop_savekid(void)  { Kid = Char; }
+/* Выгрузка после control() — теперь ПОЛНАЯ, как savekid оригинала.
+ *
+ * Была выборочной (только curr_seq и sword) ровно потому, что pop_map правил
+ * геометрию ПРЯМО в Kid, мимо окна Char: полное копирование затирало его
+ * правки — Kid терял выравнивание x и ряд, и спуск с уступа через вис не
+ * срабатывал (персонаж просто приседал).  Приходилось ещё и сравнивать
+ * последовательность со снимком на входе в окно, чтобы понять, чья правка
+ * свежее.  С переводом физики на Char (GUARD-PHYS) диспетчер и pop_map
+ * пишут в одно и то же место, и разбирать это больше не нужно. */
+void pop_savekid_state(void) { Kid = Char; }
+void pop_loadshad(void) { Char = Guard; }
+void pop_saveshad(void) { Guard = Char; }
+void pop_loadshad_and_opp(void) { Char = Guard; Opp = Kid; }
+void pop_saveshad_and_opp(void) { Guard = Char; Kid = Opp; }
+void pop_loadkid_and_opp(void)  { Char = Kid;   Opp = Guard; }
+void pop_savekid_and_opp(void)  { Kid = Char;   Guard = Opp; }
+
+/* char_opp_dist (seg006:2135): >0 — соперник ПЕРЕД Char, <0 — за спиной.
+ * +13 при встречных направлениях: у стоящих лицом друг к другу «ноль»
+ * приходится на ширину тайла между ними.  Живёт здесь, а не в guards.c,
+ * потому что нужен по обе стороны банковой границы — и ИИ, и диспетчеру
+ * боёвки (pop_ctrl). */
+int16_t pop_char_opp_dist(void)
+{
+    int16_t distance;
+    if (Char.room != Opp.room) return 999;
+    distance = (int16_t)Opp.x - (int16_t)Char.x;
+    if (Char.direction < 0) distance = -distance;
+    if (distance >= 0 && Char.direction != Opp.direction) distance += 13;
+    return distance;
+}
+
+int pop_kid_data_load(const char *path)
+{
+    uint8_t *pg = (uint8_t *)0xC000;      /* страница мапится в W3 на время чтения */
+    uint8_t saved_w3, blk;
+    uint16_t stub;
+    int fd, n;
+
+    fd = open(path, O_RDONLY);
+    if (fd < 0) return -1;
+    blk = mem_alloc_pages(1);
+    if (!blk) { close(fd); return -1; }
+    kdat_blk  = blk;
+    kdat_page = mem_get_page(blk, 0);
+
+    saved_w3 = _io_page_w3;
+    sprinter_page_w3(kdat_page);
+    n = read(fd, pg + KD_DATA_OFF, 16384 - KD_DATA_OFF);
+    if (n >= (int)(KID_BIN_SEQTBL_OFF + KID_SEQTBL_LEN)) {
+        stub = (uint16_t)&_gfx_w0_isr;    /* ISR-стаб W0-страницы (как pop_level) */
+        pg[0x38] = 0xC3;
+        pg[0x39] = (uint8_t)(stub & 0xFF);
+        pg[0x3A] = (uint8_t)(stub >> 8);
+        pg[0x66] = 0xED; pg[0x67] = 0x45; /* RETN */
+    }
+    sprinter_page_w3(saved_w3);
+    close(fd);
+    if (n < (int)(KID_BIN_SEQTBL_OFF + KID_SEQTBL_LEN)) { mem_free_block(blk); return -1; }
+    kdat_ok = 1;
+    return 0;
+}
+
+void pop_kid_data_free(void)
+{
+    if (kdat_ok) { mem_free_block(kdat_blk); kdat_ok = 0; }
+}
+
+/* Прочитать кадр из ЛЮБОЙ таблицы страницы данных (у Kid и у стража они
+ * разные: KID_BIN_FRAMES_OFF / KID_BIN_GFRAMES_OFF).  Сама маппит страницу,
+ * поэтому годится для вызова извне (pop_guard) — но НЕ в горячем цикле. */
+void pop_kid_data_frame(uint16_t tbl_off, uint8_t idx, uint8_t *out5)
+{
+    const uint8_t *f;
+    uint16_t off = (uint16_t)idx;
+    if (!kdat_ok) { out5[0] = 255; return; }
+    off += (uint16_t)(off << 2);            /* idx*5, без умножения */
+    off += (uint16_t)(KD_DATA_OFF + tbl_off);
+    gfx_w0_map(kdat_page);
+    f = (const uint8_t *)off;
+    out5[0] = f[0]; out5[1] = f[1]; out5[2] = f[2];
+    out5[3] = f[3]; out5[4] = f[4];
+    gfx_w0_unmap();
+}
+
+/* load_frame (seg006:0293): скопировать кадр Kid.frame из таблицы в
+ * cur_frame.  Звать ТОЛЬКО когда страница данных замаплена в W0. */
+static void load_frame(void)
+{
+    /* Таблица кадров зависит от персонажа (seg006:0293): у Kid своя, у
+     * стража frame_tbl_guard с индексом frame + add_frame − 149, где
+     * add_frame = 70 для кадров 102..106 (seg006:535).
+     *
+     * СКЕЛЕТ идёт по той же ветке, что страж (seg006:529 — общий case): у
+     * него свой атлас, но НУМЕРАЦИЯ кадров та же.  Пока здесь стоял только
+     * charid_2_guard, скелет попадал в таблицу Кида, получал несуществующий
+     * image (180 при 28 спрайтах в наборе) и не рисовался вовсе.
+     * ТЕНЬ (charid_1_shadow) — по таблице стража ТОЛЬКО в кадрах 150..189,
+     * в остальных она ходит кадрами Кида (seg006:532). */
+    const uint8_t *f;
+    uint8_t use_guard_tbl =
+        (Char.charid == CHARID_2_GUARD || Char.charid == CHARID_4_SKELETON ||
+         (Char.charid == CHARID_1_SHADOW &&
+          Char.frame >= 150 && Char.frame < 190));
+    if (use_guard_tbl) {
+        int16_t idx = (int16_t)Char.frame;
+        if (idx >= 102 && idx < 107) idx += 70;
+        idx -= 149;
+        if (idx < 0 || idx >= KID_NGFRAMES) { cur_frame.image = 255; return; }
+        f = kd_gframe_ptr((uint8_t)idx);
+    } else {
+        f = kd_frame_ptr(Char.frame);
+    }
+    cur_frame.image = f[0];
+    cur_frame.dx    = (int8_t)f[1];
+    cur_frame.dy    = (int8_t)f[2];
+    cur_frame.flags = f[3];
+    cur_frame.sword = f[4];
+    /* Кэш кадра для ОТРИСОВКИ раскладываем ЗДЕСЬ, по charid активного
+     * персонажа, а не в save*-функциях.  Раньше кэш писали pop_savekid/
+     * pop_saveshad, и любое окно Char БЕЗ play_seq (окна боёвки
+     * check_sword_hurting / check_sword_hurt) записывало Киду кадр, который
+     * на самом деле принадлежал СТРАЖУ: kid_draw брал его image из атласа
+     * Кида и рисовал произвольную позу.  Теперь владелец один — тот, для
+     * кого кадр реально загружен. */
+    if (Char.charid == CHARID_0_KID) kid_frame  = cur_frame;
+    else                             pop_gframe = cur_frame;
+}

 static uint8_t char_dx_forward(int8_t dx)
 {
-    if (Kid.direction < 0) dx = (int8_t)-dx;
-    return (uint8_t)(Kid.x + dx);
+    if (Char.direction < 0) dx = (int8_t)-dx;
+    return (uint8_t)(Char.x + dx);
 }

-/* Аксессоры к текущему кадру (для pop_map — без дублирования kid_frames). */
-int8_t  kid_cur_dx(void)    { return kid_frames[Kid.frame].dx; }
-uint8_t kid_cur_flags(void) { return kid_frames[Kid.frame].flags; }
+/* Аксессоры к текущему кадру (для pop_map): читают cur_frame, НЕ таблицу —
+ * их дёргают несколько раз за кадр, маппинг страницы тут недопустим. */
+int8_t  kid_cur_dx(void)    { return cur_frame.dx; }
+int8_t  kid_cur_dy(void)    { return cur_frame.dy; }
+uint8_t kid_cur_flags(void) { return cur_frame.flags; }

 /* seqtbl_offset_char: сменить последовательность Kid (единая точка —
 * pop_ctrl/pop_map зовут ЕЁ, а не дублируют kid_seq_off/kid_seqtbl). */
 void kid_set_seq(uint8_t seq_id) { Kid.curr_seq = kid_seq_off[seq_id]; }

-/* play_seq (seg006.c:570): крутит опкоды до КАДРА (байт < 0xF0). */
+/* То же для АКТИВНОГО персонажа — внутри окна Char (порт
+ * seqtbl_offset_char, seg006).  Нужен стражу: его последовательность
+ * ставится, когда Char уже загружен из Guard. */
+void pop_char_set_seq(uint8_t seq_id) { Char.curr_seq = kid_seq_off[seq_id]; }
+
+/* play_seq (seg006.c:570): крутит опкоды до КАДРА (байт < 0xF0).
+ * Страница данных маппится в W0 на ВЕСЬ разбор — один map/unmap за вызов
+ * (в тике, до отрисовки: конфликта с атласом в W0 нет).  В конце —
+ * load_frame: пока страница ещё замаплена, копируем кадр в cur_frame. */
 void play_seq(void)
 {
+    if (!kdat_ok) return;
+    gfx_w0_map(kdat_page);
    for (;;) {
-        uint8_t cmd = SEQ(Kid.curr_seq);
-        Kid.curr_seq++;
+        uint8_t cmd = SEQ(Char.curr_seq);
+        Char.curr_seq++;
        switch (cmd) {
        case 0xFB: /* DX */
-            Kid.x = char_dx_forward((int8_t)SEQ(Kid.curr_seq));
-            Kid.curr_seq++;
+            Char.x = char_dx_forward((int8_t)SEQ(Char.curr_seq));
+            Char.curr_seq++;
            break;
        case 0xFA: /* DY */
-            Kid.y = (uint8_t)(Kid.y + (int8_t)SEQ(Kid.curr_seq));
-            Kid.curr_seq++;
+            Char.y = (uint8_t)(Char.y + (int8_t)SEQ(Char.curr_seq));
+            Char.curr_seq++;
            break;
        case 0xFE: /* FLIP */
-            Kid.direction = (int8_t)~Kid.direction;
+            Char.direction = (int8_t)~Char.direction;
            break;
        case 0xF7: /* JMP_IF_FEATHER: нет пера -> пропустить адрес */
-            Kid.curr_seq += 2;
+            Char.curr_seq += 2;
            break;
        case 0xFF: { /* JMP */
-            uint16_t a = (uint16_t)(SEQ(Kid.curr_seq) |
-                         ((uint16_t)SEQ((uint16_t)(Kid.curr_seq + 1)) << 8));
-            Kid.curr_seq = a;
+            uint16_t a = (uint16_t)(SEQ(Char.curr_seq) |
+                         ((uint16_t)SEQ((uint16_t)(Char.curr_seq + 1)) << 8));
+            Char.curr_seq = a;
            break;
        }
        case 0xFD: /* UP */
-            Kid.curr_row--;
+            Char.curr_row--;
            break;
        case 0xFC: /* DOWN */
-            Kid.curr_row++;
+            Char.curr_row++;
            break;
        case 0xF9: /* ACTION */
-            Kid.action = SEQ(Kid.curr_seq);
-            Kid.curr_seq++;
+            Char.action = SEQ(Char.curr_seq);
+            Char.curr_seq++;
            break;
        case 0xF8: /* SET_FALL */
-            Kid.fall_x = (int8_t)SEQ(Kid.curr_seq); Kid.curr_seq++;
-            Kid.fall_y = (int8_t)SEQ(Kid.curr_seq); Kid.curr_seq++;
+            Char.fall_x = (int8_t)SEQ(Char.curr_seq); Char.curr_seq++;
+            Char.fall_y = (int8_t)SEQ(Char.curr_seq); Char.curr_seq++;
            break;
        case 0xF5: /* KNOCK_UP: сотрясение трясёт loose РЯДОМ ВЫШЕ (check_knock) */
            knock = 1;
@@ -120,39 +429,94 @@ void play_seq(void)
        case 0xF4: /* KNOCK_DOWN: приземление трясёт loose В СВОЁМ РЯДУ */
            knock = -1;
            break;
-        case 0xF2: /* SOUND — потребить 1 байт */
-            Kid.curr_seq++;
+        case 0xF2: /* SOUND (seg006:0611): звука у нас нет, но опкод несёт
+                    * ВТОРОЙ смысл — «Кид нашумел», и его терять нельзя.
+                    * Шумом считаются id 0..2 (SILENT/FOOTSTEP/BUMP); id 0
+                    * назван silent потому, что НЕ звучит, а стражи его всё
+                    * равно замечают (стоит, например, в seq доставания меча).
+                    * DRINK(3)/LEVEL(4) — не шум.  См. BUG-GUARD-DEAF-1. */
+            if (SEQ(Char.curr_seq) < 3) is_guard_notice = 1;
+            Char.curr_seq++;
            break;
-        case 0xF1: /* END_LEVEL */
+        case 0xF1: /* END_LEVEL: seq_70 доиграл — уровень пройден.
+                    * В оригинале это `++next_level`, а главный цикл
+                    * (play_level_2, seg003:0386) выходит, когда next_level
+                    * разошёлся с current_level.  У нас так же: счётчик, а
+                    * решение — снаружи (roomtest.c). */
+            pop_next_level++;
            break;
-        case 0xF3: /* GET_ITEM — потребить 1 байт */
-            Kid.curr_seq++;
+        case 0xF3: /* GET_ITEM: аргумент 1 — применить эффект предмета
+                    * (порт play_seq -> proc_get_object, seg006) */
+            if (SEQ(Char.curr_seq) == 1)
+                pop_proc_get_object();
+            Char.curr_seq++;
            break;
        case 0xF6: /* DIE nop */
            break;
        default: /* КАДР */
-            Kid.frame = cmd;
+            Char.frame = cmd;
+            load_frame();          /* cur_frame := таблица[frame] (страница ещё в W0) */
+            gfx_w0_unmap();
            return;
        }
    }
 }

+/* load_fram_det_col (seg006:0144) = load_frame() + determine_col().
+ *
+ * Зачем это отдельной публичной точкой.  cur_frame — ОДИН глобал на всех
+ * персонажей (так и в оригинале), и его владелец — тот, кто последним
+ * прошёл load_frame.  В кадре последним тикает страж, поэтому к моменту
+ * управления Кидом в cur_frame лежит кадр СТРАЖА.  А через cur_frame
+ * считается вся геометрия: dx_weight -> determine_col ->
+ * distance_to_edge_weight -> get_edge_distance, то есть буквально выбор
+ * ветки в check_jump_up.
+ *
+ * Оригинал от этого страхуется явно: play_kid_frame (seg000:1209) и
+ * play_guard_frame (seg000:1246) сразу после loadkid/loadshad зовут
+ * load_fram_det_col() — ДО control().  У нас этого не было, и Кид считал
+ * свой прыжок по кадру стража (BUG-CTRL-FRAME-1): при distance 2 вместо 10
+ * check_jump_up уходил в «пустой прыжок вверх» вместо «шаг назад и
+ * зацеп».  Результат менялся от кадра к кадру — вместе с анимацией стража.
+ *
+ * determine_col теперь общий: pop_map работает с Char, поэтому колонка
+ * пересчитывается ЛЮБОМУ активному персонажу — ровно как load_fram_det_col
+ * в оригинале.  Раньше вторая половина связки работала только на ветке Кида
+ * (стражу колонку вёл pop_guard_enter/leave) — прямое следствие того, что
+ * физика знала один Kid. */
+void pop_load_fram_det_col(void)
+{
+    if (!kdat_ok) return;
+    gfx_w0_map(kdat_page);
+    load_frame();
+    gfx_w0_unmap();
+    pop_determine_col();
+}
+
+/* Прокрутить последовательность КОНКРЕТНОГО персонажа (порт связки
+ * loadkid/play_seq/savekid, seg006).  Звать вместо голого play_seq: тот
+ * работает с Char и сам по себе не знает, чей это персонаж. */
+void pop_kid_play(void)   { pop_loadkid();  play_seq(); pop_savekid();  }
+void pop_guard_play(void) { pop_loadshad(); play_seq(); pop_saveshad(); }
+
 void kid_init(uint8_t seq_id, int8_t col, int8_t row, int8_t dir)
 {
    Kid.curr_col = col;
    Kid.curr_row = row;
    Kid.direction = dir;
-    Kid.x = (uint8_t)(x_bump[col + FIRST_ONSCREEN_COLUMN] + TILE_SIZEX);
-    Kid.y = (uint8_t)y_land[row + 1];
+    Kid.x = (uint8_t)(pop_x_bump[col + FIRST_ONSCREEN_COLUMN] + TILE_SIZEX);
+    Kid.y = (uint8_t)pop_y_land[row + 1];
    Kid.fall_x = Kid.fall_y = 0;
    Kid.repeat = 0;
+    Kid.charid = 0;                          /* charid_0_kid: своя таблица кадров */
+    Kid.alive = -1;                          /* в оригинале ЖИВОЙ = alive < 0 */
    Kid.curr_seq = kid_seq_off[seq_id];
-    play_seq();                 /* до первого кадра */
+    pop_kid_play();             /* до первого кадра */
 }

 void kid_tick(void)
 {
-    play_seq();
+    pop_kid_play();
 }

 /* Отрисовка текущего кадра: obj_x=(char_x+dx)*2-116, obj_y=char_y+dy
@@ -182,6 +546,64 @@ static int kid_lx[2], kid_ly[2];
 static uint16_t kid_lw[2], kid_lh[2];
 static uint8_t kid_lvalid[2];

+/* ОТДЕЛЬНЫЙ прямоугольник накладных спрайтов (клинок chtab_0, брызги урона).
+ * Раньше он объединялся с прямоугольником персонажа — но объединение сильно
+ * больше суммы двух: клинок уходит вперёд-вверх, и общий габарит выходил
+ * почти вдвое шире и выше самого Kid, а heal стоит ровно по площади.
+ * Поэтому heal делаем двумя вызовами по своим прямоугольникам, а объединение
+ * оставляем ТОЛЬКО для окна fore-клипа (там это 4 сравнения, без рисования —
+ * зато клинок/брызги честно уходят под передние грани тайлов). */
+static int kid_ox[2], kid_oy[2];
+static uint16_t kid_ow[2], kid_oh[2];
+static uint8_t kid_ovalid[2];
+
+/* Добавить накладной спрайт в overlay-прямоугольник страницы dp.  Клинок и
+ * брызги в одном кадре встречаются редко и оба маленькие — их объединение
+ * дешевле третьего слота. */
+static void kid_overlay_add(uint8_t dp, int x, int y, uint16_t w, uint16_t h)
+{
+    if (!kid_ovalid[dp]) {
+        kid_ox[dp] = x; kid_oy[dp] = y; kid_ow[dp] = w; kid_oh[dp] = h;
+        kid_ovalid[dp] = 1;
+        return;
+    }
+    {
+        int x0 = kid_ox[dp], y0 = kid_oy[dp];
+        int x1 = x0 + (int)kid_ow[dp], y1 = y0 + (int)kid_oh[dp];
+        if (x < x0) x0 = x;
+        if (y < y0) y0 = y;
+        if (x + (int)w > x1) x1 = x + (int)w;
+        if (y + (int)h > y1) y1 = y + (int)h;
+        kid_ox[dp] = x0; kid_oy[dp] = y0;
+        kid_ow[dp] = (uint16_t)(x1 - x0); kid_oh[dp] = (uint16_t)(y1 - y0);
+    }
+}
+
+/* Окно fore-клипа = объединение «персонаж + накладные».  Считается по
+ * прямоугольникам, ничего не рисует. */
+static void kid_fore_clip(uint8_t dp)
+{
+    int x0, y0, x1, y1;
+    if (!kid_lvalid[dp] && !kid_ovalid[dp]) { pop_fore_set_clip(0, 0, 0, 0); return; }
+    if (!kid_ovalid[dp]) {
+        pop_fore_set_clip(kid_lx[dp], kid_ly[dp] + POP_YOFF,
+                          (int)kid_lw[dp], (int)kid_lh[dp]);
+        return;
+    }
+    if (!kid_lvalid[dp]) {
+        pop_fore_set_clip(kid_ox[dp], kid_oy[dp] + POP_YOFF,
+                          (int)kid_ow[dp], (int)kid_oh[dp]);
+        return;
+    }
+    x0 = kid_lx[dp] < kid_ox[dp] ? kid_lx[dp] : kid_ox[dp];
+    y0 = kid_ly[dp] < kid_oy[dp] ? kid_ly[dp] : kid_oy[dp];
+    x1 = kid_lx[dp] + (int)kid_lw[dp];
+    y1 = kid_ly[dp] + (int)kid_lh[dp];
+    if (kid_ox[dp] + (int)kid_ow[dp] > x1) x1 = kid_ox[dp] + (int)kid_ow[dp];
+    if (kid_oy[dp] + (int)kid_oh[dp] > y1) y1 = kid_oy[dp] + (int)kid_oh[dp];
+    pop_fore_set_clip(x0, y0 + POP_YOFF, x1 - x0, y1 - y0);
+}
+
 /* Метрики последнего kid_draw для футпринта fore-over-Kid (pop_bg):
 * obj_x — ЛОГИЧЕСКАЯ X кадра (ДО ×8/7), obj_y — низ, w/h — размер. */
 static int kid_fp_x, kid_fp_y;
@@ -225,45 +647,52 @@ void kid_draw_splash(void)
        int top = obj_y - (int)h + 1;
        if (flip) bx -= (int)w;
        gfx_set_bank(GFX_BANK_SPRITE);
+        if (pop_onscreen_cols(bx, top + POP_YOFF, w, h))
+            gfx_blit_cols_part_noclip(bx, top + POP_YOFF, img, flip, 0, 0);
+        else
            gfx_blit_cols(bx, top + POP_YOFF, img, flip);
        gfx_set_bank(GFX_BANK_NORMAL);
        pop_clip_sprite(bx, w, top + POP_YOFF, (int)h);
-        /* Прямоугольник splash расширяет область heal ЭТОЙ страницы: иначе
-         * брызги останутся на экране после кадра. */
+        /* Брызги — накладной спрайт: свой прямоугольник heal (см.
+         * kid_overlay_add), окно fore пересчитываем объединением. */
        {
            uint8_t dp = gfx_get_draw_page();
-            if (kid_lvalid[dp]) {
-                int x0 = kid_lx[dp] < bx ? kid_lx[dp] : bx;
-                int y0 = kid_ly[dp] < top ? kid_ly[dp] : top;
-                int x1 = kid_lx[dp] + (int)kid_lw[dp];
-                int y1 = kid_ly[dp] + (int)kid_lh[dp];
-                if (bx + (int)w > x1) x1 = bx + (int)w;
-                if (top + (int)h > y1) y1 = top + (int)h;
-                kid_lx[dp] = x0; kid_ly[dp] = y0;
-                kid_lw[dp] = (uint16_t)(x1 - x0); kid_lh[dp] = (uint16_t)(y1 - y0);
-            }
+            kid_overlay_add(dp, bx, top, w, h);
+            kid_fore_clip(dp);
        }
    }
    gfx_w0_unmap();
 }

-/* Восстановить фон из теневой копии на месте ПРЕДЫДУЩЕГО кадра Kid. */
+/* Восстановить фон из теневой копии на месте ПРЕДЫДУЩЕГО кадра Kid.
+ *
+ * pop_heal_fast, а не голый gfx_heal: прямоугольник тут — это ровно тот
+ * прямоугольник, который kid_draw нарисовал noclip-ядром, то есть в
+ * подавляющем большинстве кадров он заведомо на экране.  Клипающий путь
+ * остаётся для straddle (kid_render_dx = ∓140) и падения ниже поля —
+ * там координата реально уходит за экран. */
 void kid_heal(void)
 {
    uint8_t p = gfx_get_draw_page();
-    if (kid_lvalid[p])
-        gfx_heal(kid_lx[p], kid_ly[p] + POP_YOFF, kid_lw[p], kid_lh[p]);  /* +YOFF: центрирование */
-    kid_lvalid[p] = 0;
+    if (kid_lvalid[p])   /* +YOFF: центрирование */
+        pop_heal_fast(kid_lx[p], kid_ly[p] + POP_YOFF, kid_lw[p], kid_lh[p]);
+    if (kid_ovalid[p])
+        pop_heal_fast(kid_ox[p], kid_oy[p] + POP_YOFF, kid_ow[p], kid_oh[p]);
+    kid_lvalid[p] = kid_ovalid[p] = 0;
 }

 void kid_draw(void)
 {
-    kframe fr = kid_frames[Kid.frame];
+    kframe fr = kid_frame;      /* кадр Kid, сохранённый savekid */
    int fwd, obj_x, obj_y, top;
    uint8_t page, idx;
    const uint8_t *img;
    uint16_t w, h;

+    /* Окно fore-слоя по умолчанию пустое: на любом раннем выходе (нет
+     * кадра / страница не загружена) перекрывать нечего, и fore-проход
+     * не должен трогать экран. */
+    pop_fore_set_clip(0, 0, 0, 0);
    if (fr.image == 255)
        return;                 /* пустой кадр */
    /* +kid_render_dx: straddle-смещение (∓140) когда комната Kid ≠
@@ -294,22 +723,49 @@ void kid_draw(void)
        uint8_t flip = (Kid.direction >= 0);   /* dir_0_right -> зеркало */
        int bx = obj_x + KID_XOFF;
        int skip = 0;                           /* строк спрайта срезано сверху */
-        int ct;
+        int ct, cr;
+        uint16_t vis_w = w;                     /* видимая ширина (клип справа) */
        if (flip)
            bx -= (int)w;                       /* seg008: xpos -= image->w */
        top = obj_y - (int)h + 1 + KID_YOFF;
        uint8_t dp = gfx_get_draw_page();       /* в какую страницу рисуем */
        /* clip_char (seg006:1749): тайл над головой = стена/пол → всё выше
         * линии полосы своего ряда НЕ рисуется.  Иначе Kid просвечивает
-         * сквозь щели кладки при спуске/висе. */
+         * сквозь щели кладки при спуске/висе.
+         *
+         * Окно Char обязательно: clip_char работает с АКТИВНЫМ персонажем
+         * (в оригинале он и зовётся внутри add_kid_to_objtable, то есть под
+         * loadkid), а к моменту отрисовки в Char лежит тот, кто тикал
+         * последним — страж.  Выгружать назад нечего: clip_char только
+         * читает. */
+        pop_loadkid();
        ct = pop_clip_char_top(kid_fp_x, obj_y, w, h);
        if (ct > top) {
            skip = ct - top;
            if (skip >= (int)h) skip = (int)h;  /* обрезан целиком */
        }
+        /* clip_char, вторая половина: правый косяк двери уровня.  Дверь
+         * рисуется ПОД персонажем (вся в backtable), поэтому спрятать его
+         * можно только срезав спрайт — см. pop_clip_char_right. */
+        cr = pop_clip_char_right();
+        if (cr) {
+            int avail = cr - bx;
+            if (avail <= 0) vis_w = 0;                 /* весь спрайт за косяком */
+            else if (avail < (int)w) vis_w = (uint16_t)avail;
+        }
        gfx_set_bank(GFX_BANK_SPRITE);   /* видео-ОЗУ, без теневой копии */
-        if (skip < (int)h)               /* +YOFF: центрирование */
-            gfx_blit_cols_part(bx, top + skip + POP_YOFF, img, flip, skip, 0);
+        if (skip < (int)h && vis_w) {    /* +YOFF: центрирование */
+            /* noclip-ядро ширину не ограничивает, поэтому при обрезке справа
+             * идём общим путём: это редкие кадры (подъём в двери уровня раз
+             * за уровень), цена подготовки тут не видна. */
+            if (vis_w == w && pop_onscreen_cols(bx, top + skip + POP_YOFF, w,
+                                                (uint16_t)((int)h - skip)))
+                gfx_blit_cols_part_noclip(bx, top + skip + POP_YOFF, img, flip,
+                                          (uint8_t)skip, 0);
+            else
+                gfx_blit_cols_part_w(bx, top + skip + POP_YOFF, img, flip,
+                                     skip, 0, (uint8_t)(vis_w == w ? 0 : vis_w));
+        }
        gfx_set_bank(GFX_BANK_NORMAL);
        /* клип СВОЕГО выхода за поле (падение ниже поля / верхний борт) —
         * узко, только по прямоугольнику Кида и только при выходе. */
@@ -317,9 +773,38 @@ void kid_draw(void)
        /* heal чистит ТОЛЬКО нарисованное: иначе стирается кромка пола над
         * срезом (мусор/дыра в кладке на второй странице дабл-буфера). */
        kid_lx[dp] = bx; kid_ly[dp] = top + skip;
-        kid_lw[dp] = w; kid_lh[dp] = (uint16_t)((int)h - skip);
-        kid_lvalid[dp] = (skip < (int)h);
+        kid_lw[dp] = vis_w; kid_lh[dp] = (uint16_t)((int)h - skip);
+        kid_lvalid[dp] = (skip < (int)h && vis_w != 0);
        kid_fp_w = w; kid_fp_h = h;      /* размер кадра для футпринта fore */
    }
-    gfx_w0_unmap();
+    /* add_sword_to_objtable (seg006:1798): клинок отдельным спрайтом поверх
+     * Kid — со СВОИМ прямоугольником heal (kid_overlay_add). */
+    {
+        int sx, sy; uint16_t sw, sh;
+        if (pop_sword_draw(&Kid, &fr, obj_x, obj_y, &sx, &sy, &sw, &sh))
+            kid_overlay_add(gfx_get_draw_page() & 1, sx, sy, sw, sh);
+    }
+    gfx_w0_unmap();
+    /* Окно fore-слоя = объединение «Kid + клинок» (с обрезкой clip_char):
+     * fore-проход вернёт куски тайлов ТОЛЬКО поверх него, а не целыми
+     * тайлами — см. pop_bg.c, fclip_on.  Ставим и когда рисовать нечего:
+     * нулевое окно = fore-проход не трогает экран, что и правильно. */
+    kid_fore_clip(gfx_get_draw_page() & 1);
+}
+
+/* Вернуть окно fore-клипа на прямоугольник ПОСЛЕДНЕГО кадра Kid.
+ *
+ * Окно (pop_fore_set_clip) — одно на всех, и его ставит КАЖДЫЙ, кто рисует
+ * персонажа: kid_draw в конце — своё, pop_guard_draw в конце — своё.  Пока
+ * страж рисовался строго ДО Кида, к моменту pop_fore_over_kid в окне
+ * оказывался Kid, и всё сходилось само.  Как только порядок стал
+ * переменным (guard_over_kid в roomtest.c — порядок задаёт обход тайлов),
+ * при «страж поверх» окно оставалось СТРАЖЬИМ и fore-проход Кида отсекался
+ * целиком: Кид рисовался поверх передних столбов.
+ *
+ * Поэтому окно восстанавливается явно перед pop_fore_over_kid, а не
+ * держится «по счастливому порядку вызовов». */
+void kid_fore_clip_restore(void)
+{
+    kid_fore_clip(gfx_get_draw_page() & 1);
 }
@@ -11,30 +11,53 @@
 #define POP_KID_H

 #include <stdint.h>
+#include "pop_char.h"
+#include "kid_data.h"    /* kframe — тип кадра для pop_sword_draw */

-/* Состояние персонажа (подмножество char_type, types.h). */
-typedef struct {
-    uint8_t frame;
-    uint8_t x, y;
-    int8_t  direction;      /* -1 влево, 0 вправо */
-    int8_t  curr_col, curr_row;
-    uint8_t action;
-    int8_t  fall_x, fall_y;
-    uint8_t repeat;
-    uint16_t curr_seq;      /* адрес в seqtbl (база SEQTBL_BASE) */
-} kid_t;
-
-extern kid_t Kid;
+/* Состояние персонажа — общий тип для Кида, стража и Char (pop_char.h). */
+extern pop_char_t Kid;

 /* Флаг сотрясения (seg006 knock): +1 = KNOCK_UP (ряд выше), -1 = KNOCK_DOWN
 * (свой ряд).  Ставит play_seq, читает/сбрасывает pop_check_knock. */
 extern int8_t knock;

+/* Порт next_level (seg000): END_LEVEL в play_seq инкрементит — «уровень
+ * пройден».  Читает и обнуляет главный цикл.  Пока уровень один, поэтому
+ * там рестарт того же уровня; загрузка следующего — levels_plan.md. */
+extern uint8_t pop_next_level;
+
 /* Загрузить npages атласов Kid (kid0..kid{npages-1}.atl).  ДО initgraph.
 * 0 — OK, -1 — ошибка. */
 int  pop_kid_load(uint8_t npages);
+
+/* Данные анимации (таблица кадров + seqtbl) — отдельная EMM-страница
+ * (kid_data.bin): в _CODE окна W1/W2 они занимали 3.5 КБ.  Грузить ДО
+ * первого kid_init/play_seq.  0 — OK, -1 — ошибка (без них Kid не оживёт).
+ * Страница маппится в W0 внутри play_seq, раз за тик. */
+int  pop_kid_data_load(const char *path);
+
+/* Прочитать кадр из таблицы страницы данных: tbl_off — KID_BIN_FRAMES_OFF
+ * (Kid) или KID_BIN_GFRAMES_OFF (страж, своя таблица frame_tbl_guard).
+ * Маппит страницу сама; для горячего цикла есть cur_frame. */
+void pop_kid_data_frame(uint16_t tbl_off, uint8_t idx, uint8_t *out5);
+void pop_kid_data_free(void);
+
+/* Атлас chtab_0 «меч в руке» (sword.atl) — спрайт клинка поверх Kid в кадрах
+ * подъёма меча/убирания в ножны (add_sword_to_objtable, seg006:1798).
+ * Грузить ДО initgraph, как и страницы Kid.  0 — OK, -1 — ошибка (тогда
+ * кадры рисуются без клинка). */
+int  pop_sword_load(void);
 void pop_kid_free(void);

+/* Нарисовать клинок chtab_0 поверх персонажа (порт add_sword_to_objtable,
+ * seg006:1798) — общая точка для Кида и стража: меч в оригинале ОДИН на
+ * всех.  obj_x/obj_y — та же опорная точка, что у спрайта персонажа.
+ * Возвращает 1 и прямоугольник клинка (для heal), 0 — клинка нет.
+ * Страницу W0 оставляет замапленной: вызывающий делает gfx_w0_unmap. */
+uint8_t pop_sword_draw(const pop_char_t *ch, const kframe *fr,
+                       int obj_x, int obj_y,
+                       int *rx, int *ry, uint16_t *rw, uint16_t *rh);
+
 /* Инициализировать Kid: последовательность seq_id, клетка col/row,
 * направление dir (-1/0).  Ставит x/y по x_bump/y_land. */
 void kid_init(uint8_t seq_id, int8_t col, int8_t row, int8_t dir);
@@ -45,11 +68,46 @@ void kid_tick(void);

 /* play_seq напрямую (для pop_map start_fall — переход в fall-seq в тот же
 * physics-шаг, как оригинал). */
-void play_seq(void);
+void play_seq(void);          /* работает с Char — см. pop_kid_play ниже */
+
+/* Активный персонаж (порт Char, seg006) и его загрузка/выгрузка.
+ * Интерпретатор последовательностей общий для Kid и стража: у них общая
+ * seqtbl, но РАЗНЫЕ таблицы кадров (load_frame выбирает по Char.charid). */
+extern pop_char_t Char;
+/* Соперник активного персонажа (порт Opp): ставится вместе с Char через
+ * pop_loadshad_and_opp.  Читают ИИ стража и боёвка (char_opp_dist). */
+extern pop_char_t Opp;
+void pop_loadkid(void);
+void pop_savekid(void);
+void pop_savekid_state(void);   /* Kid = Char, кадр не трогаем */
+void pop_loadshad(void);
+void pop_saveshad(void);
+void pop_loadshad_and_opp(void);   /* Char = Guard, Opp = Kid (seg006:841) */
+void pop_saveshad_and_opp(void);   /* Guard = Char, Kid = Opp              */
+void pop_loadkid_and_opp(void);    /* Char = Kid,   Opp = Guard            */
+void pop_savekid_and_opp(void);    /* Kid = Char,   Guard = Opp            */
+
+/* Дистанция до соперника в системе Char: >0 впереди, <0 за спиной,
+ * 999 — разные комнаты (порт char_opp_dist, seg006:2135). */
+int16_t pop_char_opp_dist(void);
+
+/* Прокрутить последовательность персонажа целиком (load + play_seq +
+ * save).  Звать вместо голого play_seq. */
+void pop_char_set_seq(uint8_t seq_id);   /* seq активного персонажа */
+void pop_kid_play(void);
+void pop_guard_play(void);
+
+/* load_fram_det_col (seg006:0144) — перезагрузить cur_frame под АКТИВНОГО
+ * персонажа (Char) и пересчитать его колонку.  Звать сразу после pop_loadkid/
+ * pop_loadshad и ДО диспетчера control(), как это делают play_kid_frame /
+ * play_guard_frame (seg000:1209/1246): cur_frame один на всех, и без этого
+ * геометрия одного персонажа считается по кадру другого. */
+void pop_load_fram_det_col(void);

 /* Поля текущего кадра kid_frames[Kid.frame] (pop_map, без дублирования
 * таблицы во втором TU). */
 int8_t  kid_cur_dx(void);
+int8_t  kid_cur_dy(void);
 uint8_t kid_cur_flags(void);

 /* Сменить последовательность (Kid.curr_seq = kid_seq_off[seq_id]) — единая
@@ -68,10 +126,19 @@ void pop_kid_set_render_dx(int dx);
 * теневой копии; запоминает прямоугольник для kid_heal). */
 void kid_draw(void);

+/* Вернуть окно fore-клипа на прямоугольник последнего кадра Kid.  Звать
+ * ПЕРЕД pop_fore_over_kid, если между ним и kid_draw кто-то ещё рисовал
+ * персонажа (pop_guard_draw ставит окно по стражу). */
+void kid_fore_clip_restore(void);
+
 /* draw_hurt_splash (seg006:2003): «брызги» урона (image 218) поверх Kid —
 * звать СРАЗУ после kid_draw в кадре, когда HP убавилось (pop_kid_hurt). */
 void kid_draw_splash(void);

+/* Блит спрайта chtab_2 по id, левым верхним углом в (x,y) — для полосы HP
+ * (id 216 полное деление / 217 пустое). */
+void pop_kid_img_blit(uint8_t image, int x, int y);
+
 /* Восстановить фон (из теневой копии) на месте ПРЕДЫДУЩЕГО кадра Kid —
 * вместо перерисовки всего экрана.  Звать ПЕРЕД kid_tick/kid_draw. */
 void kid_heal(void);
@@ -16,6 +16,12 @@
 extern void _gfx_w0_isr(void);

 #define LVL_DATA_OFF 0x100u  /* данные с 0x100; 0x00..0xFF — ISR-стаб */
+/* Эталонная копия foretable В ТОЙ ЖЕ странице: страница 16 КБ, данных
+ * уровня 2.3 КБ — место даром.  Нужна, потому что foretable теперь
+ * МУТАБЕЛЬНАЯ (pop_level_set_tile), а рестарт уровня в оригинале —
+ * это load_level() заново (play_level, seg003:57), то есть все плиты целы
+ * и зелья на месте.  pop_level_reset_tiles восстанавливает из неё. */
+#define LVL_PRISTINE_OFF 0x1000u

 /* Смещения блоков blueprnt относительно начала данных (Table 6). */
 #define BP_FG      0u
@@ -23,10 +29,22 @@ extern void _gfx_w0_isr(void);
 #define BP_LINKLOC 1440u   /* doorlink1 (LINKLOC), 256 Б */
 #define BP_LINKMAP 1696u   /* doorlink2 (LINKMAP), 256 Б */
 #define BP_LINKS   1952u
+/* Стражи (level_type, types.h:228): по байту на комнату в каждом массиве. */
+#define BP_GTILE   2119u
+#define BP_GDIR    2143u
+#define BP_GX      2167u
+#define BP_GSEQLO  2191u
+#define BP_GSKILL  2215u
+#define BP_GSEQHI  2239u
+#define BP_GCOLOR  2263u
 #define BP_START   2112u
 #define ROOM_TILES 30u
 #define MIN_SIZE   (BP_START + 3u)   /* минимум, чтобы прочитать старт */

+/* fwd: инициализация живой копии стражей (тело ниже). */
+static void gstate_init(void);
+
+
 static uint8_t lvl_blk, lvl_page, lvl_ok;
 /* Копии таблиц дверных связей в W2 (LINKMAP мутабельна — таймеры кнопок). */
 static uint8_t dl1[256], dl2[256];
@@ -62,12 +80,16 @@ int pop_level_load(const char *path)
            dl1[i] = pg[LVL_DATA_OFF + BP_LINKLOC + i];
            dl2[i] = pg[LVL_DATA_OFF + BP_LINKMAP + i];
        }
+        /* Эталон foretable — для рестарта уровня (см. LVL_PRISTINE_OFF). */
+        for (i = 0; i < 24u * ROOM_TILES; i++)
+            pg[LVL_PRISTINE_OFF + i] = pg[LVL_DATA_OFF + BP_FG + i];
    }
    sprinter_page_w3(saved_w3);
    close(fd);

    if (n < (int)MIN_SIZE) { mem_free_block(blk); return -1; }
    lvl_ok = 1;
+    gstate_init();          /* живая копия состояния стражей — из уровня */
    return 0;
 }

@@ -76,6 +98,52 @@ void pop_level_free(void)
    if (lvl_ok) { mem_free_block(lvl_blk); lvl_ok = 0; }
 }

+/* ---- Номер уровня и потабличные различия ---------------------------- */
+
+uint8_t pop_current_level;
+
+/* Таблицы из SDLPoP data.h:840..848, индекс = номер уровня (0 = демо).
+ * Держим целиком по 16 байт: короче и дешевле любых «оптимизаций», а
+ * расхождение с оригиналом сразу видно глазами. */
+static const uint8_t tbl_entry_pose[16] =
+    { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0 };
+static const uint8_t tbl_guard_hp[16] =
+    { 4, 3, 3, 3, 3, 4, 5, 4, 4, 5, 5, 5, 4, 6, 0, 0 };
+static const int8_t  tbl_guard_type[16] =
+    { 0, 0, 0, 2, 0, 0, 1, 0, 0, 0, 0, 0, 4, 3, -1, -1 };
+static const uint8_t tbl_level_type[16] =
+    { 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0 };
+
+uint8_t pop_level_entry_pose(uint8_t n) { return n < 16 ? tbl_entry_pose[n] : 0; }
+uint8_t pop_level_guard_hp(uint8_t n)   { return n < 16 ? tbl_guard_hp[n] : 3; }
+int8_t  pop_level_guard_type(uint8_t n) { return n < 16 ? tbl_guard_type[n] : -1; }
+uint8_t pop_level_tileset(uint8_t n)    { return n < 16 ? tbl_level_type[n] : 0; }
+
+int pop_level_load_num(uint8_t n)
+{
+    /* Имена патчим на месте, а не через sprintf: printf-семейство тянет в
+     * резидент W1 форматтер, которого здесь больше негде применить. */
+    static char pri[] = "LEVELS\\res2000.bin";   /* цифры — [12],[13] */
+    static char alt[] = "a:\\res2000.bin";       /* цифры — [8],[9]   */
+    uint8_t saved_blk = lvl_blk, saved_page = lvl_page, saved_ok = lvl_ok;
+
+    if (n > 15) return -1;
+    pri[12] = alt[8] = (char)('0' + n / 10);
+    pri[13] = alt[9] = (char)('0' + n % 10);
+
+    /* Старую страницу отпускаем ТОЛЬКО после успешной загрузки новой:
+     * pop_level_load сам аллоцирует страницу, и если файла нет — остаёмся
+     * на текущем уровне вместо падения в пустой уровень. */
+    lvl_ok = 0;                          /* чтобы pop_level_load не мешался */
+    if (pop_level_load(pri) != 0 && pop_level_load(alt) != 0) {
+        lvl_blk = saved_blk; lvl_page = saved_page; lvl_ok = saved_ok;
+        return -1;
+    }
+    if (saved_ok) mem_free_block(saved_blk);
+    pop_current_level = n;
+    return 0;
+}
+
 /* Указатель на fg-тайлы комнаты r (1..24) в W0-пространстве (страница уже
 * замаплена вызывающим). */
 static const uint8_t *room_fg_ptr(uint8_t r)
@@ -142,12 +210,23 @@ int pop_room_load(uint8_t room, uint8_t *fg, uint8_t *bg,
        for (i = 0; i < 3; i++) { rcol_fg[i] = 20; rcol_fg[3 + i] = 20; rcol_bg[i] = 0; }
    }

-    /* belowrow: верхний ряд (row0) комнаты снизу */
+    /* belowrow: верхний ряд (row0) комнаты снизу — ОДИННАДЦАТЬ байт.
+     * [0..9] — колонки 0..9 комнаты снизу; [10] — тайл (0,9) комнаты
+     * ПО ДИАГОНАЛИ СНИЗУ-СЛЕВА (room_BL у оригинала).  Одиннадцатый нужен
+     * тайлу (2,0): его «сосед снизу-слева» — это колонка −1 ряда 3, то есть
+     * чужая комната, и load_rowbelow (seg008:368) резолвит её именно так,
+     * с дефолтом «стена» только когда такой комнаты НЕТ.  Раньше мы клали
+     * туда стену БЕЗУСЛОВНО, и в пустом углу рисовался клин кладки
+     * (BUG-SEAM-WEDGE-1, ур. 3 комн. 18). */
    if (down >= 1 && down <= 24) {
        const uint8_t *df = room_fg_ptr(down);
+        uint8_t dl = ((const uint8_t *)(LVL_DATA_OFF + BP_LINKS))[(down - 1) * 4];
        for (i = 0; i < 10; i++) below_fg[i] = (uint8_t)(df[i] & 0x1F);
+        below_fg[10] = (dl >= 1 && dl <= 24)
+                     ? (uint8_t)(room_fg_ptr(dl)[9] & 0x1F)
+                     : 20;                                            /* кромка уровня */
    } else {
-        for (i = 0; i < 10; i++) below_fg[i] = 20;                    /* нет комнаты снизу = стена */
+        for (i = 0; i < 11; i++) below_fg[i] = 20;                    /* нет комнаты снизу = стена */
    }

    gfx_w0_unmap();
@@ -171,6 +250,48 @@ int8_t pop_room_col_landing(uint8_t room, uint8_t col)
    return res;
 }

+/* set_tile-запись в ЖИВУЮ foretable уровня (порт curr_room_tiles[…] = …).
+ * В оригинале уровень — обычная структура в ОЗУ, и do_pickup (seg006:1671),
+ * remove_loose (seg007:0EB8), loose_land (seg007:11E8) правят её насовсем.
+ * У нас уровень в EMM-странице — пишем прямо туда, поэтому изменение
+ * переживает выход из комнаты (BUG-LVLSTATE-1).  Пишем БАЙТ ЦЕЛИКОМ:
+ * старшие биты старого тайла (напр. 0x20 «solid loose») к новому типу
+ * отношения не имеют. */
+void pop_level_set_tile(uint8_t room, uint8_t tilepos, uint8_t tile)
+{
+    if (!lvl_ok || room < 1 || room > 24 || tilepos >= ROOM_TILES) return;
+    gfx_w0_map(lvl_page);
+    ((uint8_t *)(LVL_DATA_OFF + BP_FG))[(uint16_t)(room - 1) * ROOM_TILES + tilepos]
+        = tile;
+    gfx_w0_unmap();
+}
+
+/* Рестарт уровня (порт load_level из цикла play_level, seg003:57): вернуть
+ * foretable в исходное состояние из эталонной копии. */
+void pop_level_reset_tiles(void)
+{
+    uint16_t i;
+    uint8_t *dst;
+    const uint8_t *src;
+    if (!lvl_ok) return;
+    gfx_w0_map(lvl_page);
+    dst = (uint8_t *)(LVL_DATA_OFF + BP_FG);
+    src = (const uint8_t *)LVL_PRISTINE_OFF;
+    for (i = 0; i < 24u * ROOM_TILES; i++) dst[i] = src[i];
+    gfx_w0_unmap();
+}
+
+/* Рестарт уровня, часть вторая (тот же load_level + pos_guards, seg003:83):
+ * стражи — такая же часть данных уровня, как тайлы, и перезагрузка файла
+ * возвращает их всех.  Убитый до смерти Кида страж после respawn снова жив
+ * и стоит на исходном тайле; забывается и запомненная поза трупа
+ * (guards_seq_hi = 0 -> «поднять стандартной стойкой»). */
+void pop_level_reset_guards(void)
+{
+    if (!lvl_ok) return;
+    gstate_init();
+}
+
 uint8_t pop_doorlink1(uint8_t i)          { return dl1[i]; }
 uint8_t pop_doorlink2(uint8_t i)          { return dl2[i]; }
 void    pop_doorlink2_set(uint8_t i, uint8_t v) { dl2[i] = v; }
@@ -234,6 +355,101 @@ static uint8_t start_byte(uint16_t off)
    return v;
 }

+/* Страж комнаты (enter_guard, seg002:0112 + pos_guards, seg003).  Возврат
+ * 0 = стража в комнате нет (tile >= 30).  X оригинал пересчитывает из
+ * колонки (pos_guards), поэтому guards_x из файла не читаем. */
+/* ---- ЖИВОЕ состояние стражей (порт level.guards_*) ------------------ *
+ * В оригинале массивы стражей — часть структуры уровня в ОЗУ, и движок их
+ * ПЕРЕПИСЫВАЕТ: leave_guard при выходе из комнаты кладёт туда текущие
+ * позицию/направление/мастерство, а у МЁРТВОГО ещё и curr_seq.  Благодаря
+ * этому, вернувшись, находишь труп там же, а не воскресшего стража.
+ * У нас уровень лежит в EMM-странице только на чтение, поэтому держим
+ * мутабельную копию в W2: 6 байт на комнату. */
+#define GS_TILE 0
+#define GS_DIR  1
+#define GS_X    2
+#define GS_SKILL 3
+#define GS_SEQL 4
+#define GS_SEQH 5
+static uint8_t gstate[24 * 6];
+
+static void gstate_init(void)
+{
+    const uint8_t *p = (const uint8_t *)LVL_DATA_OFF;
+    uint8_t r;
+    gfx_w0_map(lvl_page);
+    for (r = 0; r < 24; r++) {
+        uint8_t *g = gstate + (uint16_t)r * 6;
+        g[GS_TILE]  = p[BP_GTILE + r];
+        g[GS_DIR]   = p[BP_GDIR + r];
+        g[GS_X]     = p[BP_GX + r];
+        g[GS_SKILL] = p[BP_GSKILL + r];
+        /* guards_seq_lo/hi в ФАЙЛЕ не используются — там 0xFF во всех
+         * комнатах (оригинал чистит их в reset_level_unused_fields).
+         * Осмысленное значение туда кладёт только leave_guard, поэтому
+         * стартуем нулями: 0 = «поднимать стандартной стойкой».
+         * Без этого в интерпретатор уходил curr_seq = 0xFFFF и он вис. */
+        g[GS_SEQL]  = 0;
+        g[GS_SEQH]  = 0;
+    }
+    gfx_w0_unmap();
+}
+
+/* leave_guard (seg002:02F5): запомнить состояние стража комнаты.  seq
+ * сохраняем ТОЛЬКО у мёртвого — у живого seq_hi = 0 означает «поднять
+ * стандартной стойкой», как в оригинале. */
+void pop_guard_state_save(uint8_t room, uint8_t tile, int8_t dir, uint8_t x,
+                          uint8_t skill, uint16_t seq, uint8_t dead)
+{
+    uint8_t *g;
+    if (room < 1 || room > 24) return;
+    g = gstate + (uint16_t)(room - 1) * 6;
+    g[GS_TILE]  = tile;
+    g[GS_DIR]   = (uint8_t)dir;
+    g[GS_X]     = x;
+    g[GS_SKILL] = skill;
+    if (dead) { g[GS_SEQL] = (uint8_t)seq; g[GS_SEQH] = (uint8_t)(seq >> 8); }
+    else      { g[GS_SEQH] = 0; }
+}
+
+uint16_t pop_guard_state_seq(uint8_t room)
+{
+    const uint8_t *g;
+    if (room < 1 || room > 24) return 0;
+    g = gstate + (uint16_t)(room - 1) * 6;
+    if (g[GS_SEQH] == 0) return 0;          /* живой — стандартная стойка */
+    return (uint16_t)(g[GS_SEQL] | ((uint16_t)g[GS_SEQH] << 8));
+}
+
+/* Запомненная X стража комнаты (для трупа: он лежит там, где лёг, а не в
+ * центре тайла). */
+uint8_t pop_guard_state_x(uint8_t room)
+{
+    if (room < 1 || room > 24) return 0;
+    return gstate[(uint16_t)(room - 1) * 6 + GS_X];
+}
+
+uint8_t pop_level_guard(uint8_t room, uint8_t *tile, int8_t *dir,
+                        uint8_t *color, uint8_t *skill)
+{
+    const uint8_t *g;
+    uint8_t t;
+    if (!lvl_ok || room < 1 || room > 24) return 0;
+    /* Тайл/направление/мастерство — из ЖИВОЙ копии (её правит
+     * pop_guard_state_save); цвет статичен, его читаем со страницы. */
+    g = gstate + (uint16_t)(room - 1) * 6;
+    t = g[GS_TILE];
+    if (t < 30) {
+        *tile  = t;
+        *dir   = (int8_t)g[GS_DIR];
+        *skill = g[GS_SKILL];
+        gfx_w0_map(lvl_page);
+        *color = (uint8_t)(((const uint8_t *)LVL_DATA_OFF)[BP_GCOLOR + room - 1] & 0x0F);
+        gfx_w0_unmap();
+    }
+    return (uint8_t)(t < 30);
+}
+
 uint8_t pop_level_start_room(void) { return start_byte(BP_START + 0); }
 uint8_t pop_level_start_pos(void)  { return start_byte(BP_START + 1); }
 int8_t  pop_level_start_dir(void)  { return (int8_t)start_byte(BP_START + 2); }
@@ -26,6 +26,36 @@
 int  pop_level_load(const char *path);
 void pop_level_free(void);

+/* ---- Номер уровня и потабличные различия (levels_plan.md §1) -------- */
+
+/* Порт current_level (seg000 load_lev_spr: current_level = next_level =
+ * level).  Уровень 1..15; 0 — демо-уровень, в скоуп не входит.  Читают
+ * потабличные функции ниже, стражи (HP/тип) и стартовая логика. */
+extern uint8_t pop_current_level;
+
+/* Загрузить уровень НОМЕРОМ: освободить страницу прошлого, взять
+ * `LEVELS\res20NN.bin` (fallback `a:\res20NN.bin`) и выставить
+ * pop_current_level.  0 — OK, -1 — файла нет / не влез (тогда
+ * pop_current_level и страница НЕ тронуты — играем дальше на старом).
+ * Порт связки load_lev_spr + load_level (seg000:1098/1169). */
+int  pop_level_load_num(uint8_t n);
+
+/* tbl_entry_pose (data.h:848): 1 — падение внутрь (ур. 1), 2 — вбегание
+ * (ур. 13), 0 — разворот на месте.  Индекс — номер уровня. */
+uint8_t pop_level_entry_pose(uint8_t n);
+
+/* tbl_guard_hp (data.h:846) — база HP стража на уровне (get_guard_hp,
+ * seg002:0044: extrastrength[skill] + tbl_guard_hp[level]). */
+uint8_t pop_level_guard_hp(uint8_t n);
+
+/* tbl_guard_type (data.h:844): 0 обычный, 1 толстый, 2 скелет, 3 визирь,
+ * 4 тень, −1 — стражей на уровне НЕТ (уровни 14/15). */
+int8_t  pop_level_guard_type(uint8_t n);
+
+/* tbl_level_type (data.h:840): 0 = dungeon, 1 = palace.  Пока читается
+ * только для контроля — второй тайлсет это levels_plan.md §3. */
+uint8_t pop_level_tileset(uint8_t n);
+
 /* Извлечь комнату room (1..24) в массивы приложения (W2):
 *   fg[30], bg[30]           — тайлы комнаты (fg маскирован &0x1F, bg raw);
 *   lcol_fg[6], lcol_bg[3]   — [0..2] правый столбец (col9) комнаты СЛЕВА
@@ -33,7 +63,8 @@ void pop_level_free(void);
 *                              для коллизии на колонке −2 (Kid стоит В шве);
 *                              rcol_fg[6] симметрично (col0 / col1);
 *                              нет комнаты → стена/0;
- *   below_fg[10]             — верхний ряд (row0) комнаты СНИЗУ («стена
+ *   below_fg[11]             — [0..9] верхний ряд (row0) комнаты СНИЗУ,
+ *                              [10] тайл (0,9) комнаты СНИЗУ-СЛЕВА («стена
 *                              вниз»); нет комнаты → стена.
 * 0 — OK, -1 — уровень не загружен / room вне диапазона. */
 int  pop_room_load(uint8_t room, uint8_t *fg, uint8_t *bg,
@@ -49,6 +80,20 @@ uint8_t pop_room_link(uint8_t room, uint8_t side);
 * тип анимируемого тайла в ЛЮБОЙ комнате, не только текущей. */
 uint8_t pop_level_tile(uint8_t room, uint8_t tilepos);

+/* Записать тайл в ЖИВУЮ foretable уровня (порт curr_room_tiles[tp] = tile:
+ * do_pickup / remove_loose / loose_land).  Изменение персистентно — уровень
+ * лежит в ОЗУ-странице, а не в ПЗУ, — то есть переживает выход из комнаты,
+ * как в оригинале.  Отменяется только pop_level_reset_tiles. */
+void pop_level_set_tile(uint8_t room, uint8_t tilepos, uint8_t tile);
+
+/* Рестарт уровня: вернуть ВСЕ тайлы в исходное (порт load_level, который
+ * play_level зовёт на каждой итерации — в т.ч. после смерти Кида). */
+void pop_level_reset_tiles(void);
+
+/* Рестарт уровня: вернуть ВСЕХ стражей (тот же load_level + pos_guards).
+ * Убитый страж после respawn снова жив — как в оригинале. */
+void pop_level_reset_guards(void);
+
 /* Батч-доступ к странице уровня (один map/unmap окна 0 на много чтений).
 * Между begin/end — только pop_level_tile_raw, без рисования. */
 void    pop_level_access_begin(void);
@@ -73,6 +118,23 @@ void    pop_doorlink2_set(uint8_t i, uint8_t v);
 int8_t pop_room_col_landing(uint8_t room, uint8_t col);

 /* Стартовая позиция уровня (блок @2112): комната / поза / направление. */
+/* Страж комнаты: 1 = есть (заполнит tile/dir/color/skill), 0 = нет.
+ * Порт enter_guard (seg002:0112). */
+/* leave_guard (seg002:02F5): запомнить состояние стража комнаты в ЖИВОЙ
+ * копии массивов уровня.  dead != 0 — сохранить и последовательность, тогда
+ * при возврате в комнату страж поднимется трупом там же, где лёг.
+ * tile == 30 (или больше) — «стража в комнате больше нет». */
+void pop_guard_state_save(uint8_t room, uint8_t tile, int8_t dir, uint8_t x,
+                          uint8_t skill, uint16_t seq, uint8_t dead);
+
+/* Последовательность запомненного стража (0 — поднимать стандартной
+ * стойкой, как у живого). */
+uint16_t pop_guard_state_seq(uint8_t room);
+uint8_t  pop_guard_state_x(uint8_t room);
+
+uint8_t pop_level_guard(uint8_t room, uint8_t *tile, int8_t *dir,
+                        uint8_t *color, uint8_t *skill);
+
 uint8_t pop_level_start_room(void);
 uint8_t pop_level_start_pos(void);
 int8_t  pop_level_start_dir(void);
@@ -17,25 +17,68 @@
 * col<0/>9 или row<0/>2 трактуются как стена (край уровня).  Массив
 * МУТАБЕЛЬНЫЙ (loose-пол при падении → empty) — передавать ту же копию,
 * что и в pop_room_draw, чтобы отрисовка видела изменения. */
-void pop_map_set(uint8_t *fg);
+void pop_map_set(uint8_t *fg) __banked;

-/* Связи комнаты (0=нет соседа; иначе номер) + кромки швов для коллизии:
- * lcol_fg[6] = col9 левого соседа (за col0) в [0..2] и его col8 (колонка −2)
- * в [3..5]; rcol_fg[6] симметрично (col0 / col1 = колонки 10 и 11).  Вторая
- * колонка нужна, когда Kid стоит В шве и смотрит наружу.  Звать в enter_room. */
-void pop_map_set_edges(uint8_t left, uint8_t right, uint8_t up, uint8_t down,
-                       const uint8_t *lcol_fg, const uint8_t *rcol_fg);
+/* Связи комнаты (0=нет соседа; иначе номер).  Заодно кэширует fg соседей
+ * слева и справа ЦЕЛИКОМ (читает уровень сам).  Оригинал добирается до любой
+ * колонки через find_room_of_tile, у нас уровень в EMM-странице и маппить её
+ * на каждый get_tile (горячий путь физики) дорого — поэтому копия соседей.
+ * Колонка персонажа считается из x и на диапазоне x 0..255 лежит в −5..13,
+ * то есть заведомо выходит за комнату; кромочных колонок не хватало, и
+ * get_tile отдавал мнимую стену (BUG-SWORD-GHOST-1).  Звать в enter_room. */
+void pop_map_set_edges(uint8_t left, uint8_t right, uint8_t up, uint8_t down) __banked;
+
+/* check_skel: тайл скелета -> пол + пометка перерисовки (обе страницы). */
+void pop_skel_wake_tile(uint8_t tilepos) __banked;
+
+/* Openness ворот в (col,row) с резолвом за край комнаты (соседи слева/справа).
+ * 0xFF — тайла нет.  Нужен лучу видимости стража (guards.c). */
+uint8_t pop_gate_modif(int8_t col, int8_t row) __banked;

 /* Номер ТЕКУЩЕЙ комнаты (для доступа к room_modif пик/ворот в pop_trob).
 * Звать в enter_room. */
-void pop_map_set_room(uint8_t room);
+void pop_map_set_room(uint8_t room) __banked;
+
+/* Тайл-код текущей комнаты по клетке (col 0..9, row 0..2) — порт
+ * get_tile(room,col,row) для текущей комнаты.  Нужен лучу видимости стража
+ * (guards.c): он идёт по ряду между Кидом и стражем. */
+uint8_t pop_tile_at(int8_t col, int8_t row) __banked;
+
+/* determine_col (seg006:014D): Kid.curr_col = m7(dx_weight()).  Наружу — для
+ * pop_load_fram_det_col (pop_kid.c), порт load_fram_det_col. */
+void pop_determine_col(void) __banked;

 /* HP/смерть.  pop_kid_dead=1 когда Kid убит (пики); hitp_curr — текущее HP.
 * pop_kid_hp_reset() ставит старт HP и снимает смерть (звать в kid_init/
 * респавн). */
 extern uint8_t pop_kid_dead;
 extern uint8_t hitp_curr;
-void pop_kid_hp_reset(void);
+extern uint8_t hitp_max;   /* стартовое HP (для индикатора) */
+extern int8_t  hitp_delta; /* урон за кадр от меча; применяет pop_do_delta_hp */
+void pop_kid_hp_reset(void) __banked;
+
+/* hitp_beg_lev (seg003): HP, с которым НАЧАТ текущий уровень.  Рестарт
+ * уровня (смерть/выпадение) откатывает HP ровно к нему; пройденный уровень
+ * подтягивает его к hitp_max (play_level_2, seg003:410) — так «жизнь» из
+ * большой склянки переезжает на следующий уровень.  Правит главный цикл. */
+extern uint8_t hitp_beg_lev;
+#define POP_START_HITP 3   /* custom->start_hitp      */
+#define POP_MAX_HITP  10   /* custom->max_hitp_allowed */
+void pop_kid_hp_newgame(void) __banked;  /* начало ИГРЫ: hitp_beg_lev = 3 */
+
+/* Предметы (seg005 check_get_item/get_item, seg006 do_pickup/proc_get_object).
+ * pop_have_sword — «меч у Кида» (порт have_sword).  pop_item_taken — 0 или
+ * tilepos+1 только что поднятого предмета: вызывающий обязан запечь тайл
+ * (он стал полом) на ОБЕИХ страницах и записать override комнаты. */
+extern uint8_t pop_have_sword;
+extern uint8_t pop_item_taken;
+/* Вспышка фона (do_flash/set_bg_attr, seg001:0908): счётчик кадров, пока
+ * НУЛЕВАЯ запись палитры подменена ярко-жёлтым.  Тикает вызывающий. */
+extern uint8_t pop_flash_time;
+/* Цвет вспышки: 0 = ярко-жёлтая (подобран меч), 1 = красная (зелье). */
+extern uint8_t pop_flash_red;
+uint8_t pop_get_item_action(void) __banked;   /* 0 нет / 1 присесть / 2 поднять меч / 3 пить */
+void    pop_proc_get_object(void) __banked;   /* эффект — из play_seq (опкод GET_ITEM) */

 /* Уход из комнаты ВБОК/ВВЕРХ: 0=нет; 1=left,2=right,3=up (= side+1 для
 * pop_room_link).  Координаты Kid уже репроецированы (x∓140 / y+189).
@@ -54,8 +97,8 @@ extern uint8_t pop_leave_timer;
 * на ТЕКУЩЕЙ странице; звать в основном цикле ПОСЛЕ set_draw_page(back),
 * рядом с kid-отрисовкой. */
 extern uint8_t pop_loose_modif[30];
-void pop_loose_tick(void);
-void pop_loose_reset(void);   /* сброс loose-состояния при смене комнаты */
+void pop_loose_tick(void) __banked;
+void pop_loose_reset(void) __banked;   /* сброс loose-состояния при смене комнаты */

 /* Установлен в tilepos+1 в кадре, когда loose-пол упал (кусок улетел ВНИЗ).
 * Приложение: определить debris-приземление в комнате снизу.  Снять (=0). */
@@ -69,7 +112,7 @@ extern uint8_t pop_loose_fell;
 * pop_loose_modif), читает pop_bg.  Сигналы приложению (для персистентности
 * между входами в комнату): pop_ceil_fell = col+1 провалившейся плиты,
 * pop_debris_at = tilepos+1 щебня, оставшегося в ЭТОЙ комнате.  Снимать (=0). */
-void pop_map_set_above(uint8_t *above_row2_fg);
+void pop_map_set_above(uint8_t *above_row2_fg) __banked;
 extern uint8_t pop_ceil_modif[10];
 extern uint8_t pop_ceil_fell;
 extern uint8_t pop_debris_at;
@@ -80,7 +123,7 @@ extern uint8_t pop_kid_hurt;

 /* check_knock (seg003): по флагу knock (play_seq) тряхнуть loose-полы ряда
 * приземления/удара.  Зовётся из pop_phys_tick. */
-void pop_check_knock(void);
+void pop_check_knock(void) __banked;

 /* Установлен в 1, когда Kid пересёк НИЖНЮЮ границу комнаты (провал в дыру
 * или спуск-зацеп с кромки).  Координаты Kid УЖЕ репроецированы в кадр
@@ -91,15 +134,36 @@ extern uint8_t pop_fell_out;

 /* Пер-кадровая физика ПОСЛЕ kid_tick(play_seq): fall_accel + fall_speed +
 * determine_col + check_action (триггер падения / do_fall / приземление).
- * Порядок как в оригинале (seg000 play_kid_frame). */
-void pop_phys_tick(void);
+ * Порядок как в оригинале (seg000 play_kid_frame).
+ *
+ * Физика внутри работает с АКТИВНЫМ персонажем (Char), как в оригинале, и
+ * сама открывает окно loadkid/savekid — звать вне окон Char. */
+void pop_phys_tick(void) __banked;
+
+/* То же для стража — порт хвоста play_guard_frame (seg000:1246).  Звать из
+ * главного цикла СРАЗУ после pop_guard_tick() (тот прокручивает ИИ и
+ * последовательность), тоже вне окон Char: функция открывает своё.
+ *
+ * Физика у стража та же самая (одни функции над Char), отличается только
+ * список вызовов: нет ухода из комнаты, нет check_knock, вместо check_bumped
+ * — check_guard_bumped.  Тот же вход обслужит скелета/тень/визиря, когда
+ * они появятся: в оригинале все они живут в слоте Guard.
+ *
+ * «Нет ухода из комнаты» — про СВОЙ ход.  Следом за Кидом стража переносит
+ * exit_room/follow_guard (seg002:03C7/039E) — отдельная механика, у нас не
+ * портирована (GUARD-PHYS). */
+void pop_guard_phys_tick(void) __banked;

 /* clip_char (seg006:1749), верхняя граница клипа спрайта персонажа: если тайл
 * над головой — стена/пол, всё выше линии своей полосы не рисуется (Kid,
 * ушедший головой под пол при спуске/висе, не просвечивает сквозь щели).
 * obj_x — ЛОГИЧЕСКАЯ X кадра (до ×8/7), obj_y — низ спрайта, w/h — размер.
 * Возврат: КОМНАТНЫЙ y границы, 0 = клипа нет.  Зовёт kid_draw. */
-int pop_clip_char_top(int obj_x, int obj_y, uint16_t w, uint16_t h);
+int pop_clip_char_top(int obj_x, int obj_y, uint16_t w, uint16_t h) __banked;
+
+/* Парная половина clip_char: ЭКРАННЫЙ X, правее которого спрайт не рисуется
+ * (правый косяк двери уровня в кадрах подъёма 224..228).  0 = обрезки нет. */
+int pop_clip_char_right(void) __banked;

 /* Тип препятствия/края ВПЕРЕДИ по направлению (pop_edge_type после
 * pop_edge_distance): для control (бежать / осторожный шаг / стоп у стены). */
@@ -108,26 +172,39 @@ int pop_clip_char_top(int obj_x, int obj_y, uint16_t w, uint16_t h);
 #define EDGE_FLOOR   2   /* пол (нет препятствия рядом, дистанция = 11)     */

 /* Расстояние до края/стены впереди + побочно g_edge_type (pop_edge_type). */
-int     pop_edge_distance(void);
-uint8_t pop_edge_type(void);
+int     pop_edge_distance(void) __banked;
+uint8_t pop_edge_type(void) __banked;

 /* Стена впереди в пределах стопа? Если да — прижимает Kid.x к корректной
 * позиции (передний край у стены, симметрично) и возвращает 1.  Для
 * control_running (чистый стоп у стены). */
-int     pop_wall_ahead(void);
+int     pop_wall_ahead(void) __banked;
+
+/* Разбег-прыжок: выравнивание по кромке пола (run_jump, seg005:0AA8).
+ * Смотрит на 1–2 тайла вперёд; если там провал/пика — подгоняет Kid.x под
+ * толчок ровно с кромки.  1 = прыгать, 0 = ОТМЕНИТЬ прыжок (Кид не в той
+ * фазе относительно кромки; control_up гасить НЕЛЬЗЯ — попытка повторится
+ * на следующем кадре).  Без этого провал в три тайла непроходим. */
+uint8_t pop_run_jump_align(void) __banked;

 /* Прыжок вверх в стойке (↑): seq чистого прыжка (seq_28/seq_14) ЛИБО
 * прыжка-с-зацепом за уступ выше (seq_8/24/16) + выравнивание Kid.x.
 * check_jump_up/grab_up (K4.4).  control_up гасит caller. */
-uint8_t pop_jump_up_seq(void);
+uint8_t pop_jump_up_seq(void) __banked;

 /* ---- Вис/зацеп/спуск (K4.2/K4.3) — тайловые решения для pop_ctrl --- *
 * Управление (control_hanging/can_climb_up/hang_fall/down_pressed) в
 * pop_ctrl; здесь — предикаты + выбор seq (+ выравнивание Kid.x). */
-uint8_t pop_hang_grab_ready(void);   /* grab_timer истёк — можно climb-up   */
-uint8_t pop_hang_climb_up_seq(void); /* seq_10 / seq_73 (подтягивание)       */
-int8_t  pop_hang_wall(void);         /* Shift в висе: 1=у стены,-1=fall,0=держ.*/
-uint8_t pop_hang_fall_seq(void);     /* seq_23 / seq_11 (сорваться), +Kid.x  */
-uint8_t pop_down_action(void);       /* 1=обработано(спуск/отступ), 0=присед */
+uint8_t pop_hang_grab_ready(void) __banked;   /* grab_timer истёк — можно climb-up   */
+uint8_t pop_hang_climb_up_seq(void) __banked; /* seq_10 / seq_73 (подтягивание)       */
+int8_t  pop_hang_wall(void) __banked;         /* Shift в висе: 1=у стены,-1=fall,0=держ.*/
+uint8_t pop_hang_fall_seq(void) __banked;     /* seq_23 / seq_11 (сорваться), +Kid.x  */
+uint8_t pop_down_action(void) __banked;       /* 1=обработано(спуск/отступ), 0=присед */
+
+/* Дверь уровня рядом и ОТКРЫТА ПОЛНОСТЬЮ? → поставить Кида в проём (x +
+ * разворот влево, go_up_leveldoor) и вернуть 1; иначе 0, Кид не тронут.
+ * Ветка двери уровня из up_pressed (seg005:0482).  Последовательность
+ * seq_70 ставит вызывающий (pop_ctrl) — тайлы наши, управление его. */
+uint8_t pop_leveldoor_enter(void) __banked;

 #endif
@@ -0,0 +1,79 @@
+/*
+ * pop_redraw.c — пометки перерисовки тайлов и их разбор.  См. pop_redraw.h.
+ *
+ * Живёт в W1/W2 (НЕ в резиденте W3): пометки ставит логика, которая должна
+ * оставаться достижимой из будущих __banked-модулей.  Сам разбор зовёт
+ * pop_bg (резидент W3) — это законно, потому что разбор дёргает только
+ * главный цикл.
+ */
+#include <stdint.h>
+#include "pop_redraw.h"
+#include "pop_bg.h"
+
+#define NTILES 30
+#define NCOLS  10
+
+static uint8_t rd_kind[NTILES], rd_cnt[NTILES];
+static uint8_t rda_kind[NCOLS], rda_cnt[NCOLS];
+/* Сколько всего непустых пометок: без него проход по 40 ячейкам крутился бы
+ * КАЖДЫЙ кадр впустую (замер 2026-07-27 на прежнем rest-цикле: ~12 % кадра). */
+static uint8_t rd_pending;
+
+void pop_redraw_reset(void)
+{
+    uint8_t i;
+    for (i = 0; i < NTILES; i++) { rd_kind[i] = 0; rd_cnt[i] = 0; }
+    for (i = 0; i < NCOLS;  i++) { rda_kind[i] = 0; rda_cnt[i] = 0; }
+    rd_pending = 0;
+}
+
+void pop_set_redraw(uint8_t tilepos, uint8_t kind, uint8_t pages)
+{
+    if (tilepos >= NTILES) return;
+    if (!rd_cnt[tilepos]) rd_pending++;
+    rd_kind[tilepos] = kind;
+    if (pages > rd_cnt[tilepos]) rd_cnt[tilepos] = pages;
+}
+
+void pop_set_redraw_above(uint8_t col, uint8_t kind, uint8_t pages)
+{
+    if (col >= NCOLS) return;
+    if (!rda_cnt[col]) rd_pending++;
+    rda_kind[col] = kind;
+    if (pages > rda_cnt[col]) rda_cnt[col] = pages;
+}
+
+/* redraw_needed (seg008:0178): пройти пометки и нарисовать.  row/col ведём
+ * бегущими счётчиками, а не через i/10 и i%10 — у Z80 нет деления, и SDCC
+ * выносит __divuchar/__moduchar в вершину цикла как общее подвыражение
+ * аргументов (30*2 делений за кадр даже когда рисовать нечего). */
+void pop_redraw_needed(void)
+{
+    uint8_t i, row = 0, col = 0, left = 0;
+    if (!rd_pending) return;
+    for (i = 0; i < NTILES; i++) {
+        if (rd_cnt[i]) {
+            switch (rd_kind[i]) {
+            case POP_RD_SPIKE:      pop_spike_redraw(row, col);      break;
+            case POP_RD_LOOSE:      pop_loose_shake_draw(row, col);  break;
+            case POP_RD_LOOSE_GONE: pop_loose_bake_empty(row, col);  break;
+            case POP_RD_FLOOR:      pop_floor_bake(row, col);        break;
+            case POP_RD_LEVELDOOR:  pop_leveldoor_redraw(row, col);  break;
+            case POP_RD_GATE:       pop_gate_redraw(row, col);       break;
+            default: break;
+            }
+            if (--rd_cnt[i]) left++;
+            else             rd_kind[i] = 0;
+        }
+        if (++col == 10) { col = 0; row++; }
+    }
+    for (i = 0; i < NCOLS; i++) {
+        if (rda_cnt[i]) {
+            if (rda_kind[i] == POP_RDA_CEIL) pop_ceil_shake_draw(i);
+            else                             pop_ceil_bake_empty(i);
+            if (--rda_cnt[i]) left++;
+            else              rda_kind[i] = 0;
+        }
+    }
+    rd_pending = left;
+}
@@ -0,0 +1,51 @@
+/*
+ * pop_redraw.h — пометки «перерисовать тайл» и их разбор.
+ *
+ * Порт архитектуры оригинала: логика анимации НИЧЕГО не рисует, она ставит
+ * флаг (`set_redraw_full`/`set_wipe`/`redraw_20h`/`redraw_21h`, seg007), а
+ * отрисовка идёт отдельным проходом (`redraw_needed`, seg008:0178).  У нас
+ * так же: pop_map/pop_trob зовут pop_set_redraw*, а pop_redraw_needed()
+ * (главный цикл) разбирает пометки и дёргает pop_bg.
+ *
+ * ЗАЧЕМ (кроме сходства с SDLPoP): из __banked-кода резидентная страница W3
+ * недостижима — ни напрямую, ни транзитивно (docs/layout_plan_v2.md §2 R2).
+ * Пока pop_map звал pop_bg, его нельзя было использовать из банка стражей.
+ * Пометки живут в W1/W2 и зовутся откуда угодно.
+ *
+ * ОТЛИЧИЕ ОТ ОРИГИНАЛА: у нас не один экран с dirty-rect, а две страницы
+ * дабл-буфера со своей ОЗУ-копией фона, поэтому счётчик пометки — это ЧИСЛО
+ * СТРАНИЦ (обычно 2), а вид перерисовки хранится явно: heal+рисовать поверх
+ * (транзиент) или запечь новый фон.  В оригинале вид кодируется тем, в какой
+ * из таблиц redraw_frames_* стоит флаг.
+ */
+#ifndef POP_REDRAW_H
+#define POP_REDRAW_H
+
+#include <stdint.h>
+
+/* Виды перерисовки тайла (row*10+col). */
+#define POP_RD_SPIKE      1   /* пики: heal + оба тайла (redraw_21h)        */
+#define POP_RD_LOOSE      2   /* loose: дрожащий кадр / кадр покоя          */
+#define POP_RD_LOOSE_GONE 3   /* loose провалился: запечь пусто             */
+#define POP_RD_FLOOR      4   /* пол изменился: кнопка/щебень/поднятый меч  */
+#define POP_RD_LEVELDOOR  5   /* створка двери уровня (ПРАВАЯ половина)     */
+#define POP_RD_GATE       6   /* решётка ворот (tilepos = САМИ ворота)      */
+
+/* Виды перерисовки полосы у потолка (по колонке). */
+#define POP_RDA_CEIL      1   /* плита-потолок: дрожащий кадр / покой       */
+#define POP_RDA_CEIL_GONE 2   /* плита-потолок провалилась: колодец         */
+
+/* Пометить тайл/колонку: kind — вид, pages — на скольких страницах
+ * дабл-буфера перерисовать (1 = только текущая, 2 = обе).  Повторная
+ * пометка перекрывает вид и берёт максимум счётчика. */
+void pop_set_redraw(uint8_t tilepos, uint8_t kind, uint8_t pages);
+void pop_set_redraw_above(uint8_t col, uint8_t kind, uint8_t pages);
+
+/* Разобрать пометки: нарисовать всё помеченное на ТЕКУЩЕЙ (back) странице и
+ * уменьшить счётчики.  Звать из главного цикла в слое ФОНА — до kid_draw. */
+void pop_redraw_needed(void);
+
+/* Сбросить все пометки (смена комнаты/уровня). */
+void pop_redraw_reset(void);
+
+#endif
@@ -0,0 +1,66 @@
+/*
+ * pop_state.c — данные, которые читают ОБЕ стороны банковой границы.
+ *
+ * Зачем отдельный модуль: sprinter-cc собирает банковый модуль с
+ * --dataseg BANKn, поэтому ВСЯ его писучая память (глобалы, file-static,
+ * статики внутри функций) линкуется В СТРАНИЦУ БАНКА и снаружи не читается
+ * — проверено на .map (2026-07-30: глобал банкового модуля лёг по
+ * 0x0001C000, а не в _DATA).  Значит любую переменную, к которой нужен
+ * доступ и из банка, и снаружи, надо держать в НЕбанковом модуле — здесь.
+ *
+ * Модуль обязан оставаться в W1/W2: его читают и главный цикл, и банки.
+ */
+#include "pop_state.h"
+#include "pop_ctrl.h"          /* объявления шины control_* (живёт здесь) */
+
+uint8_t pop_loose_landed;
+uint8_t pop_droppedout;
+/* leveldoor_open (seg007:456): дверь уровня доехала до верха.  Ставит
+ * анимация двери (pop_trob, банк 6), читает спецсобытие подъёма скелета
+ * (guards.c, банк 1) — снова случай «данные через границу банков».
+ * Сбрасывается стартом уровня (seg003:97). */
+uint8_t pop_leveldoor_open;
+
+/* ---- Шина управления (seg006 globals) ------------------------------ *
+ * Объявлены в pop_ctrl.h, а ЛЕЖАТ здесь: к ним обращаются ТРИ банка —
+ * pop_ctrl (банк 5) пишет с клавиатуры, guards.c (банк 1) подаёт
+ * синтетический ввод ИИ (autocontrol_*, seg002), pop_map (банк 3) читает
+ * через pop_ctrl_shift_held.  Сегодня оно уцелело бы и в pop_ctrl.c
+ * (собираем без --bank-data, данные банков остаются в _DATA), но это
+ * флаг сборки: включат его — и шина уедет в страницу банка 5.
+ *
+ * control_x/y/shift — «сырое» состояние осей ЭТОГО кадра (абсолютно:
+ * X LEFT/-1..RIGHT/+1); *_forward/backward/up/down/shift2 — конечный
+ * автомат held/released/ignore (авто-повтор). */
+int8_t control_x, control_y, control_shift;
+int8_t control_forward, control_backward, control_up, control_down, control_shift2;
+
+/* Чит «бессмертие» (клавиша I).  Отладочный: Кид получает анимацию удара,
+ * но HP не теряет — иначе проверять боёвку приходится с трёх попаданий. */
+uint8_t pop_immortal;
+
+/* Габариты последней нарисованной двери уровня (порт leveldoor_right /
+ * leveldoor_ybottom): пишет draw_leveldoor из банка pop_bg, читает
+ * clip_char из pop_map.  См. pop_state.h. */
+int pop_leveldoor_right;
+int pop_leveldoor_ybottom;
+
+/* ---- Отладочная «пустышка» для брейкпоинтов из БАНКОВ ---------------- *
+ * Зачем.  PC-брейкпоинт видит только логический адрес, а 0xC000+ — это
+ * окно, куда мапятся ВСЕ банки: точка на адресе банковой функции ловит
+ * заодно чужой код, случайно легший по тому же смещению (проверено:
+ * точка на start_fall из банка 3 срабатывала на каждом кадре — попадала
+ * в pop_bg из банка 2).  Условные брейкпоинты этот отладчик MAME не
+ * поддерживает («error in assignment expression» на `==`).
+ *
+ * Приём (идея пользователя, 2026-08-04): позвать ЭТУ функцию ровно из
+ * того места банкового кода, которое отлаживаем, и поставить брейкпоинт
+ * на неё — она резидентна в W1, её адрес однозначен.  По возврату из неё
+ * читаем что нужно.  Условие «когда именно ловить» пишется обычным `if`
+ * в C — это гибче любых выражений отладчика.
+ *
+ * Счётчик нужен, чтобы вызов не выкинул оптимизатор; заодно видно, сколько
+ * раз точка прошла, если ловим не останавливаясь. */
+uint8_t pop_dbg_hits;
+
+void pop_dbg_trap(void) { pop_dbg_hits++; }
@@ -0,0 +1,49 @@
+/*
+ * pop_state.h — состояние, общее для банков и W1/W2.  См. pop_state.c.
+ *
+ * Правило: если переменную читают/пишут по обе стороны банковой границы —
+ * её место здесь, а НЕ в банковом модуле (там она уедет в страницу банка).
+ */
+#ifndef POP_STATE_H
+#define POP_STATE_H
+
+#include <stdint.h>
+
+/* Кусок loose приземлился (loose_land, seg007:11E8): 0 = нет, иначе
+ * tilepos+1 тайла, на который он лёг.  Ставит отрисовка mob (банк),
+ * разбирает логика loose-полов (pop_map, W1/W2). */
+extern uint8_t pop_loose_landed;
+
+/* Чит «бессмертие» (I): Кида бьют, но HP не убавляется.  Читают пути урона
+ * (боёвка в банке, пики в pop_map), переключает главный цикл. */
+extern uint8_t pop_immortal;
+
+/* Габариты ПОСЛЕДНЕЙ нарисованной двери уровня — порт глобалов
+ * leveldoor_right / leveldoor_ybottom (seg008 draw_leveldoor).  Их ставит
+ * отрисовка (банк pop_bg), а читает clip_char (pop_map, W1/W2): кадры
+ * подъёма по лестнице (224..228) обрезаются по правому косяку проёма и по
+ * низу поднятой створки.  Дверь рисуется ПОД персонажем, поэтому перекрыть
+ * его не может — оригинал именно режет спрайт.
+ * right — экранный X правой кромки; ybottom — room-space Y (без POP_YOFF).
+ * 0 = двери в отрисованной комнате нет. */
+extern int pop_leveldoor_right;
+extern int pop_leveldoor_ybottom;
+
+/* droppedout (seg006:1140): Кида СПИХНУЛИ с уступа в бою — он падает из
+ * боевой стойки.  Ставит start_fall (pop_map, банк 3), читает ИИ стража
+ * (guards.c, банк 1): по этому флагу страж решает, идти ли за упавшим вниз
+ * (guard_follows_kid_down, seg002:09F8).  Отсюда и место в общем модуле —
+ * банки друг другу данные не отдают. */
+extern uint8_t pop_droppedout;
+
+/* leveldoor_open (seg007:456): 1 — дверь уровня открыта полностью.  Пишет
+ * анимация двери (банк 6), читает подъём скелета (банк 1). */
+extern uint8_t pop_leveldoor_open;
+
+/* Отладочная «пустышка» для брейкпоинтов из банков — см. pop_state.c.
+ * Звать из отлаживаемого места под нужным `if`, брейкпоинт ставить на
+ * _pop_dbg_trap (резидент W1, адрес однозначен). */
+extern uint8_t pop_dbg_hits;
+void pop_dbg_trap(void);
+
+#endif
@@ -4,8 +4,18 @@
 * См. pop_trob.h.
 */
 #include "pop_trob.h"
+#include "pop_state.h"   /* pop_leveldoor_open */
 #include "pop_level.h"
-#include "pop_bg.h"        /* pop_spike_redraw */
+#include "pop_geom.h"
+#include "pop_redraw.h"    /* пометки перерисовки тайлов (вместо прямых вызовов) */
+/* pop_bg нужен ТОЛЬКО для пламени факела и пузырька зелья: это не тайловая
+ * перерисовка, а покадровый оверлей поверх фона (в оригинале — свои
+ * add_backtable/add_foretable внутри draw_tile).  Всё остальное идёт через
+ * пометки, поэтому pop_process_trobs — единственная функция модуля, которую
+ * нельзя звать из __banked-кода. */
+#include "pop_bg.h"
+#include "pop_guard.h"     /* is_guard_notice — нажатая кнопка слышна стражу */
+#include "pop_tune.h"      /* POP_DBG_GATE_HOLD — отладочное растягивание окна */

 /* Коды тайлов (fg & 0x1F), которые анимируются. */
 #define TILE_SPIKE   0x02
@@ -14,6 +24,9 @@
 #define TILE_DEBRIS  0x0E   /* button_type для «насовсем открыть» (died_on_button) */
 #define TILE_OPENER  0x0F
 #define TILE_POTION  0x0A
+#define TILE_LOOSE   0x0B   /* проваливающийся пол (фаза тряски в modif) */
+#define TILE_SWORD   0x16   /* меч-предмет на полу */
+#define TILE_LEVELDOOR 0x10 /* левая половина двери уровня (на ней modif) */
 #define TILE_TORCH   0x13
 #define TILE_TORCH_DEBRIS 0x1E

@@ -23,16 +36,11 @@ static uint8_t room_seen[POP_NROOMS];   /* modif проинициализиро

 /* ---- Список анимируемых тайлов ------------------------------------ */
 typedef struct { uint8_t room, tilepos; int8_t type; } trob_t;
-#define TROBS_MAX 24
+#define TROBS_MAX 30   /* как в оригинале (types.h) */
 static trob_t  trobs[TROBS_MAX];
 static uint8_t trobs_count;
 static uint8_t trob_code[TROBS_MAX];   /* префетч кодов тайлов на кадр (1 map W0) */

-/* Отложенная перерисовка «покоя» законченных пик/кнопок текущей комнаты
- * (2 кадра = обе страницы дабл-буфера, как loose_rest). */
-static uint8_t spike_rest[POP_ROOMTILES];
-static uint8_t button_rest[POP_ROOMTILES];
-
 /* Последняя НАРИСОВАННАЯ draw-сигнатура тайла (spike: modifier; button:
 * признак «нажата» = таймер связи >1).  Редрой пики/кнопки — ТОЛЬКО при её
 * изменении (порт redraw_11h-on-change из SDLPoP).  Без этого кнопка под
@@ -41,44 +49,53 @@ static uint8_t button_rest[POP_ROOMTILES];
 * расхождение было именно в безусловном редрое). */
 static uint8_t trob_drawn[POP_ROOMTILES];

-/* Сколько тайлов ждут отложенного редроя (spike_rest/button_rest).  Без
- * него цикл по 30 тайлам крутился КАЖДЫЙ кадр впустую: замер в MAME
- * (2026-07-27) — служебная часть pop_process_trobs ~50 000 тактов при
- * кадре 430 080, то есть ~12 % кадра на пустой проход. */
-static uint8_t rest_pending;
-
 /* prandom (seg009.c:321, 32-бит LCG) — нужен для стартовой фазы факела и
 * выбора следующего кадра пламени. */
-static unsigned long trob_seed;
+static pop_rnd_t trob_seed;

-static uint16_t trob_prandom(uint16_t maxv)
-{
-    trob_seed = trob_seed * 214013UL + 2531011UL;
-    return (uint16_t)((uint16_t)(trob_seed >> 16) % (uint16_t)(maxv + 1));
-}
+#define trob_prandom(maxv) pop_prandom(&trob_seed, (maxv))


-void pop_trob_reset(void)
+void pop_trob_reset(void) __banked
 {
    uint8_t i;
    for (i = 0; i < POP_NROOMS; i++) room_seen[i] = 0;
-    for (i = 0; i < POP_ROOMTILES; i++) { spike_rest[i] = 0; button_rest[i] = 0; trob_drawn[i] = 0; }
-    rest_pending = 0;
+    for (i = 0; i < POP_ROOMTILES; i++) trob_drawn[i] = 0;
+    pop_redraw_reset();
    trobs_count = 0;
 }

-uint8_t *pop_trob_modif(uint8_t room)
+uint8_t *pop_trob_modif(uint8_t room) __banked
 {
    if (room < 1 || room > POP_NROOMS) return 0;
    if (!room_seen[room - 1]) {
        uint8_t i;
        pop_level_room_bg(room, room_modif[room - 1]);
-        /* seg009 load_level: у ЗЕЛЬЯ модификатор сдвигается влево на 3 —
-         * старшие биты = тип зелья, младшие 3 = фаза пузырька. */
+        /* load_alter_mod (seg008:198E): модификатор В ФАЙЛЕ уровня и
+         * модификатор В РАНТАЙМЕ — разные величины, оригинал переводит их
+         * при загрузке.  Порт того, что нас касается:
+         *
+         *   ворота  1 = «открыты» (Table 8 спецификации DAT) -> 188, то есть
+         *               рабочая высота подъёма; ЛЮБОЕ другое значение -> 0
+         *               (закрыты).  Без этого перевода ворота, которые в
+         *               уровне открыты, стартуют закрытыми, и кнопка-closer
+         *               рядом с ними теряет смысл (ур. 2, комн. 13).
+         *   loose   -> 0: фаза тряски всегда начинается с нуля.
+         *   зелье   -> <<3: старшие биты = тип, младшие 3 = фаза пузырька.
+         *
+         * Ветка стен (blue-line/связи кладки) НЕ портируется намеренно: у
+         * нас pop_bg считает связи по типам СОСЕДЕЙ прямо при отрисовке
+         * (wall_modifier), сохранённый модификатор стены не читается вовсе. */
        pop_level_access_begin();
-        for (i = 0; i < POP_ROOMTILES; i++)
-            if ((pop_level_tile_raw(room, i) & 0x1F) == TILE_POTION)
-                room_modif[room - 1][i] = (uint8_t)(room_modif[room - 1][i] << 3);
+        for (i = 0; i < POP_ROOMTILES; i++) {
+            uint8_t *m = &room_modif[room - 1][i];
+            switch (pop_level_tile_raw(room, i) & 0x1F) {
+            case TILE_GATE:   *m = (uint8_t)((*m == 1) ? 188 : 0); break;
+            case TILE_LOOSE:  *m = 0;                              break;
+            case TILE_POTION: *m = (uint8_t)(*m << 3);             break;
+            default: break;
+            }
+        }
        pop_level_access_end();
        room_seen[room - 1] = 1;
    }
@@ -93,7 +110,7 @@ static int find_trob(uint8_t room, uint8_t tilepos)
    return -1;
 }

-void pop_add_trob(uint8_t room, uint8_t tilepos, int8_t type)
+void pop_add_trob(uint8_t room, uint8_t tilepos, int8_t type) __banked
 {
    int f = find_trob(room, tilepos);
    if (f >= 0) { trobs[f].type = type; return; }
@@ -104,23 +121,42 @@ void pop_add_trob(uint8_t room, uint8_t tilepos, int8_t type)
    trobs_count++;
 }

-void pop_trob_room_changed(void)
+void pop_trob_room_changed(void) __banked
 {
    uint8_t i;
-    for (i = 0; i < POP_ROOMTILES; i++) { spike_rest[i] = 0; button_rest[i] = 0; trob_drawn[i] = 0; }
-    rest_pending = 0;
+    for (i = 0; i < POP_ROOMTILES; i++) trob_drawn[i] = 0;
+    pop_redraw_reset();
 }

 /* anim_tile_modif (seg000:0B12) — при входе в комнату завести анимации её
 * тайлов: факелам — случайная стартовая фаза пламени (start_anim_torch,
 * seg007:0847: modif = prandom(8)), зельям — случайная фаза пузырька
 * (start_anim_potion: младшие 3 бита = prandom(6)+1, старшие = тип). */
-void pop_trob_anim_room(uint8_t room)
+void pop_trob_anim_room(uint8_t room) __banked
 {
    uint8_t *mod = pop_trob_modif(room);
    uint8_t i, code;
    if (!mod) return;
    pop_level_access_begin();
+    /* Освободить список от «декоративных» trob ДРУГИХ комнат: факел, зелье и
+     * блеск меча анимируются только в ОТРИСОВАННОЙ комнате, а место в списке
+     * занимают.  Оригинал их копит и на 30-й выдаёт «Trobs Overflow»; у нас
+     * отладочный обход всех 24 комнат упирается в лимит за пару минут, после
+     * чего новые анимации молча не заводятся.  Механику (ворота/пики/кнопки,
+     * в т.ч. кросс-комнатные) чистка не трогает. */
+    {
+        uint8_t k, wr = 0;
+        for (k = 0; k < trobs_count; k++) {
+            uint8_t c = (uint8_t)(pop_level_tile_raw(trobs[k].room,
+                                                     trobs[k].tilepos) & 0x1F);
+            if (trobs[k].room != room &&
+                (c == TILE_TORCH || c == TILE_TORCH_DEBRIS ||
+                 c == TILE_POTION || c == TILE_SWORD))
+                continue;
+            trobs[wr++] = trobs[k];
+        }
+        trobs_count = wr;
+    }
    for (i = 0; i < POP_ROOMTILES; i++) {
        code = (uint8_t)(pop_level_tile_raw(room, i) & 0x1F);
        if (code == TILE_TORCH || code == TILE_TORCH_DEBRIS) {
@@ -129,6 +165,10 @@ void pop_trob_anim_room(uint8_t room)
        } else if (code == TILE_POTION) {
            mod[i] = (uint8_t)((mod[i] & 0xF8) | (trob_prandom(6) + 1));
            pop_add_trob(room, i, 1);
+        } else if (code == TILE_SWORD) {
+            /* start_anim_sword (seg007:087C): случайная фаза счётчика блеска. */
+            mod[i] = (uint8_t)(trob_prandom(0xFF) & 0x1F);
+            pop_add_trob(room, i, 1);
        }
    }
    pop_level_access_end();
@@ -216,6 +256,13 @@ static int8_t trigger_1(uint8_t target_type, uint8_t room, uint8_t tilepos, uint
 {
    if (target_type == TILE_GATE)
        return trigger_gate(room, tilepos, button_type);
+    if (target_type == TILE_LEVELDOOR) {
+        /* trigger_1 (seg007:0999): дверь уровня открывается ОДИН раз — если
+         * створка уже тронулась (modif != 0), кнопка ничего не делает. */
+        uint8_t *m = pop_trob_modif(room);
+        if (m && m[tilepos] == 0) return 1;
+        return -1;
+    }
    return -1;
 }

@@ -235,13 +282,20 @@ static void do_trigger_list(uint8_t index, uint8_t button_type)
 }

 void pop_trigger_button(uint8_t room, uint8_t tilepos,
-                        uint8_t button_type, uint8_t modifier)
+                        uint8_t button_type, uint8_t modifier) __banked
 {
    uint8_t link_timer = get_doorlink_timer(modifier);
    if (link_timer != 0x1F) {                          /* не заклинено */
-        set_doorlink_timer(modifier, 5);
-        if (link_timer < 2)
-            pop_add_trob(room, tilepos, 1);            /* кнопка нажимается (+ TODO sound) */
+        /* Оригинал ставит 5; вынесено в pop_tune.h, потому что проверять
+         * руками проход в закрывающуюся решётку при таком окне почти
+         * невозможно (см. BUG-GATE-PASS-1). */
+        set_doorlink_timer(modifier, POP_DBG_GATE_HOLD);
+        if (link_timer < 2) {
+            pop_add_trob(room, tilepos, 1);            /* кнопка нажимается */
+            /* seg007:766: щелчок кнопки — шум, страж оборачивается.  Звука у
+             * нас нет, флаг обязан быть (BUG-GUARD-DEAF-1). */
+            is_guard_notice = 1;
+        }
        do_trigger_list(modifier, button_type);
    }
 }
@@ -258,6 +312,27 @@ static void animate_button(uint8_t idx, int8_t *type)
    }
 }

+/* animate_leveldoor (seg007:05F1): створка двери уровня.  type 0..2 —
+ * открытие (modif 0 -> 43, по пикселю за кадр), type >= 3 — быстрое
+ * закрытие со скоростями {0,5,17,99} (после выхода из уровня).  Готово ->
+ * type = -1. */
+static const uint8_t leveldoor_close_speeds[5] = {0, 5, 17, 99, 0};
+
+static void animate_leveldoor(uint8_t *m, int8_t *type)
+{
+    if (*type < 0) return;
+    if (*type >= 3) {
+        uint8_t sp;
+        if (*type < 7) (*type)++;
+        sp = leveldoor_close_speeds[*type - 3];
+        if (sp >= *m) { *m = 0; *type = -1; }
+        else           *m = (uint8_t)(*m - sp);
+    } else {
+        if (*m < 43) (*m)++;
+        if (*m >= 43) { *m = 43; *type = -1; pop_leveldoor_open = 1; }
+    }
+}
+
 /* animate_door (seg007:0522): openness по типу анимации.  *m — modif ворот,
 * *type — 0 закрытие / 1 открытие / 2 насовсем / 3..8 быстрое закрытие. */
 static const uint8_t gate_close_speeds[9] = {0, 0, 0, 20, 40, 60, 80, 100, 120};
@@ -292,7 +367,7 @@ static void animate_door(uint8_t *m, int8_t *type)
    *m = mod;
 }

-uint8_t pop_trob_room_active(uint8_t room)
+uint8_t pop_trob_room_active(uint8_t room) __banked
 {
    uint8_t i;
    for (i = 0; i < trobs_count; i++)
@@ -300,34 +375,35 @@ uint8_t pop_trob_room_active(uint8_t room)
    return 0;
 }

-static uint8_t torch_tick;      /* делитель скорости анимации пламени */

-void pop_process_trobs(uint8_t cur_room)
+/* Темп анимации пламени в ЛОГИЧЕСКИХ кадрах (один логический кадр = 3
+ * vsync и соответствует игровому тику оригинала):
+ *   1 — кадр пламени каждый тик, как в оригинале; кадры при этом ровные по
+ *       тактам, что нужно для счёта бюджета;
+ *   2 — вдвое реже (так было до 2026-07-30; пламя шло на половинной
+ *       скорости, а бюджет кадра «прыгал» на 6.2 % от того, попал кадр на
+ *       анимацию или нет). */
+#define TORCH_ANIM_DIV 1
+
+#if TORCH_ANIM_DIV > 1
+static uint8_t torch_tick;
+#define TORCH_ANIM_NOW ((uint8_t)(torch_tick % TORCH_ANIM_DIV) == 0)
+#else
+#define TORCH_ANIM_NOW 1
+#endif
+
+void pop_process_trobs(uint8_t cur_room) __banked
 {
    uint8_t i, w = 0;
+#if TORCH_ANIM_DIV > 1
    torch_tick++;
+#endif

    /* Перерисовка «покоя» законченных пик/кнопок (обе страницы).
     * row/col ведём бегущими счётчиками, а НЕ через i/10, i%10: иначе SDCC
     * выносит оба деления (__divuchar/__moduchar) в вершину цикла как общее
     * подвыражение аргументов redraw — 30*2=60 делений/кадр даже когда нет
     * активных пик/кнопок (тот же случай, что был в pop_loose_tick). */
-    if (rest_pending) {
-        uint8_t row = 0, col = 0, left = 0;
-        for (i = 0; i < POP_ROOMTILES; i++) {
-            if (spike_rest[i]) {
-                pop_spike_redraw(row, col);
-                if (--spike_rest[i]) left++;
-            }
-            if (button_rest[i]) {
-                pop_button_redraw(row, col);
-                if (--button_rest[i]) left++;
-            }
-            if (++col == 10) { col = 0; row++; }
-        }
-        rest_pending = left;
-    }
-
    if (trobs_count == 0) return;

    /* Префетч кодов тайлов всех trob'ов за ОДИН map/unmap окна 0, а не
@@ -360,13 +436,14 @@ void pop_process_trobs(uint8_t cur_room)
        case TILE_GATE:
            animate_door(&mod[tp], &type);
            break;
+        case TILE_LEVELDOOR:
+            animate_leveldoor(&mod[tp], &type);
+            break;
        case TILE_TORCH:
        case TILE_TORCH_DEBRIS:
-            /* animate_torch (seg007:03C1): кадр пламени; анимация вечная —
-             * type остаётся 1, пока комната отрисована.  Смена кадра — через
-             * ЛОГИЧЕСКИЙ кадр (torch_tick): у нас кадр короче игрового тика
-             * оригинала, и пламя «кипело» вдвое быстрее нужного. */
-            if (room == cur_room && (torch_tick & 1) == 0)
+            /* animate_torch (seg007:03C1): анимация вечная — type остаётся
+             * 1, пока комната отрисована.  Темп — TORCH_ANIM_DIV. */
+            if (room == cur_room && TORCH_ANIM_NOW)
                mod[tp] = get_torch_frame(mod[tp]);
            break;
        case TILE_POTION:
@@ -375,6 +452,15 @@ void pop_process_trobs(uint8_t cur_room)
            if (room == cur_room)
                mod[tp] = (uint8_t)((mod[tp] & 0xF8) | bubble_next_frame(mod[tp] & 7));
            break;
+        case TILE_SWORD:
+            /* animate_sword (seg007:0425): счётчик вниз; на 0 — новый период
+             * 0x28..0x67.  Блеск рисуется РОВНО на modif==1 (draw_tile берёт
+             * кадр (modif==1)+10), т.е. одиночная вспышка раз в 40..103 тика. */
+            if (room == cur_room) {
+                if (--mod[tp] == 0)
+                    mod[tp] = (uint8_t)((trob_prandom(255) & 0x3F) + 0x28);
+            }
+            break;
        default:
            type = -1;
            break;
@@ -400,11 +486,40 @@ void pop_process_trobs(uint8_t cur_room)
             * неизменной сигнатурой, и стёртое уже не возвращается: рядом с
             * Кидом остриё пропадало, а нижний кусок мерцал (стёрт на одной
             * странице дабл-буфера из двух). */
-            uint8_t trow = tp / 10, tcol = tp % 10;
-            pop_spike_redraw(trow, tcol);
-            /* Последний кадр (пика убралась, trob умирает) — на ВТОРУЮ страницу
-             * его уже никто не положит: ставим отложенный редрой. */
-            if (type < 0) { spike_rest[tp] = 1; rest_pending++; }
+            /* Последний кадр (пика убралась, trob умирает) — пометить ОБЕ
+             * страницы: живой trob метит каждый кадр по одной. */
+            pop_set_redraw(tp, POP_RD_SPIKE, (uint8_t)(type < 0 ? 2 : 1));
+        }
+        if (room == cur_room && code == TILE_GATE) {
+            /* draw_trob (seg007:01E6), которым заканчивается animate_door:
+             * пока trob жив — решётка едет каждый кадр, помечаем ТЕКУЩУЮ
+             * страницу; последний кадр (type<0, ворота встали) — ОБЕ, иначе
+             * на второй странице дабл-буфера застынет предыдущее положение
+             * и решётка дрожит через кадр.  Тайлпос — САМИ ворота, соседа
+             * справа выбирает pop_gate_redraw. */
+            pop_set_redraw(tp, POP_RD_GATE, (uint8_t)(type < 0 ? 2 : 1));
+        }
+        if (room == cur_room && code == TILE_LEVELDOOR) {
+            /* Створка едет каждый кадр — перерисовываем ПРАВУЮ половину (там
+             * её рисует draw_tile_anim_right) С ЗАПЕЧКОЙ в ОЗУ-копию: иначе
+             * kid_heal вернул бы из фона закрытую створку.  Куски двери
+             * непрозрачны, поэтому wipe не нужен. */
+            /* Створку рисует ПРАВАЯ половина двери; последний кадр анимации
+             * помечаем на обе страницы, иначе дверь дрожит через кадр. */
+            if (tp % 10 + 1 < 10)
+                pop_set_redraw((uint8_t)(tp + 1), POP_RD_LEVELDOOR,
+                               (uint8_t)(type < 0 ? 2 : 1));
+        }
+        if (room == cur_room && code == TILE_SWORD) {
+            /* МЕЧ — редрой только на смене видимого кадра (блеск = modif==1):
+             * спрайт запечён в фон (draw_tile), поэтому перерисовываем тайл
+             * той же схемой, что и кнопку — текущая страница сразу, вторая
+             * следующим кадром через rest-цикл. */
+            uint8_t sig = (uint8_t)(mod[tp] == 1);
+            if (sig != trob_drawn[tp]) {
+                pop_set_redraw(tp, POP_RD_FLOOR, 2);   /* обе страницы */
+                trob_drawn[tp] = sig;
+            }
        }
        if (room == cur_room && (code == TILE_OPENER || code == TILE_CLOSER)) {
            /* КНОПКА — редрой только при смене видимого состояния (нажата =
@@ -414,9 +529,7 @@ void pop_process_trobs(uint8_t cur_room)
             * считаем только в момент редроя (редко), а не каждый кадр. */
            uint8_t sig = (uint8_t)(get_doorlink_timer(mod[tp]) > 1);
            if (sig != trob_drawn[tp]) {
-                uint8_t trow = tp / 10, tcol = tp % 10;
-                pop_button_redraw(trow, tcol);
-                button_rest[tp] = 1; rest_pending++;
+                pop_set_redraw(tp, POP_RD_FLOOR, 2);   /* обе страницы */
                trob_drawn[tp] = sig;
            }
        }
@@ -25,41 +25,41 @@

 /* Сброс всего состояния (новый уровень / рестарт): забыть все комнаты и
 * очистить список trob. */
-void pop_trob_reset(void);
+void pop_trob_reset(void) __banked;

 /* Указатель на persistent modifier-массив комнаты room (1..24), 30 байт.
 * При ПЕРВОМ обращении лениво инициализируется из backtable уровня
 * (pop_level_room_bg).  Далее ЖИВЁТ (не перезагружается).  room вне
 * диапазона → 0. */
-uint8_t *pop_trob_modif(uint8_t room);
+uint8_t *pop_trob_modif(uint8_t room) __banked;

 /* Добавить/обновить trob (room, tilepos, type).  Если уже есть — сменить
 * type (как SDLPoP add_trob/find_trob).  type<0 = будет удалён. */
-void pop_add_trob(uint8_t room, uint8_t tilepos, int8_t type);
+void pop_add_trob(uint8_t room, uint8_t tilepos, int8_t type) __banked;

 /* Продвинуть все trob на кадр (animate_* по коду тайла из уровня), записать
 * modif, перерисовать тайлы ТЕКУЩЕЙ (cur_room) комнаты на back-странице.
 * Звать в основном цикле ПОСЛЕ set_draw_page(back), рядом с loose. */
-void pop_process_trobs(uint8_t cur_room);
+void pop_process_trobs(uint8_t cur_room) __banked;

 /* Кид встал на кнопку (opener/closer): взвести таймер связи + обойти цепочку
 * LINKLOC, добавив trob целям (ворота).  Порт seg007 trigger_button.
 * room/tilepos — кнопка; button_type — её тайл-код; modifier — её modif
 * (= индекс в LINKLOC).  Звать из check_press (pop_map). */
 void pop_trigger_button(uint8_t room, uint8_t tilepos,
-                        uint8_t button_type, uint8_t modifier);
+                        uint8_t button_type, uint8_t modifier) __banked;

 /* Есть ли активные trob в комнате room?  Для перерисовки ворот соседа через
 * шов (roomtest не дёргает шов, пока сосед не анимируется). */
-uint8_t pop_trob_room_active(uint8_t room);
+uint8_t pop_trob_room_active(uint8_t room) __banked;

 /* Смена комнаты: сбросить отложенные перерисовки «покоя» текущей комнаты
 * (trob-состояние в room_modif персистентно и НЕ трогается).  Звать в
 * enter_room. */
-void pop_trob_room_changed(void);
+void pop_trob_room_changed(void) __banked;

 /* anim_tile_modif (seg000:0B12): завести анимации тайлов комнаты (факелы,
 * зелья) со случайной стартовой фазой.  Звать в enter_room. */
-void pop_trob_anim_room(uint8_t room);
+void pop_trob_anim_room(uint8_t room) __banked;

 #endif
@@ -0,0 +1,66 @@
+/*
+ * pop_tune.h — НАСТРАИВАЕМЫЕ КОНСТАНТЫ движка (аналог custom_options
+ * SDLPoP) в одном месте.
+ *
+ * Зачем отдельный заголовок.  У оригинала «особые события» уровней зашиты
+ * магическими числами прямо в код (`current_level == 3 && Char.room == 7`),
+ * и SDLPoP вынес их в структуру `custom_options_type` (types.h) с
+ * загрузкой из SDLPoP.ini и правкой через меню Settings/Mods.  Нам нужно
+ * то же самое по двум причинам:
+ *
+ *   1. ОТЛАДКА.  Некоторые сцены руками почти не проверить (успеть в
+ *      закрывающуюся решётку), и единственный вменяемый способ — временно
+ *      растянуть тайминг.  Такие крутилки обязаны жить в одном месте, а не
+ *      прятаться числами по трём модулям.
+ *   2. МОДЫ.  Тот, кто захочет свой набор уровней, меняет ровно эти числа.
+ *
+ * Пока это только `#define` — ни INI, ни меню нет (см. TASKS_OPEN.md, запись
+ * TUNE-1).  Но правило уже действует: НОВОЕ «особое событие» или тайминг
+ * заводится ЗДЕСЬ, а не константой по месту.  Имена — как у SDLPoP
+ * (custom->имя), чтобы сверка с оригиналом оставалась механической.
+ */
+#ifndef POP_TUNE_H
+#define POP_TUNE_H
+
+/* ---- Чекпойнт уровня 3 (SDLPoP: checkpoint_*) ----------------------- *
+ * Оригинал: level3_set_chkp (seg002:0665) взводит флаг, когда Кид уходит
+ * ВЛЕВО ИЗ комнаты 7 (вызов стоит до goto_other_room, поэтому Char.room там
+ * ещё старая); do_startpos (seg003:0141) подменяет по
+ * нему стартовую позицию и убирает loose-плиту, через которую туда
+ * попадают (иначе после респавна дорога назад была бы уже провалена). */
+#define POP_CHKP_LEVEL            3   /* checkpoint_level                */
+#define POP_CHKP_ROOM             7   /* комната, ИЗ КОТОРОЙ уходят влево (у
+                                       * SDLPoP хардкод; это НЕ комната
+                                       * назначения — см. roomtest.c) */
+#define POP_CHKP_RESPAWN_ROOM     2   /* checkpoint_respawn_room         */
+#define POP_CHKP_RESPAWN_TILEPOS  6   /* checkpoint_respawn_tilepos      */
+#define POP_CHKP_RESPAWN_DIR   (-1)   /* checkpoint_respawn_dir: влево   */
+#define POP_CHKP_CLEAR_ROOM       7   /* checkpoint_clear_tile_room      */
+#define POP_CHKP_CLEAR_COL        4   /* checkpoint_clear_tile_col       */
+#define POP_CHKP_CLEAR_ROW        0   /* checkpoint_clear_tile_row       */
+
+/* ---- Отладочные крутилки (в оригинале и в SDLPoP их НЕТ) ------------ *
+ * POP_DBG_GATE_HOLD — сколько кадров решётка держится поднятой после
+ * нажатия кнопки, ПРЕЖДЕ чем пойдёт вниз.  В оригинале это таймер связи
+ * дверей: trigger_button ставит 5, animate_button вычитает по единице, и
+ * решётка стоит, пока таймер > 1 (то есть ~4 кадра после того, как Кид
+ * сошёл с кнопки).  Проверять руками проход в закрывающуюся решётку при
+ * таком окне почти невозможно, поэтому значение вынесено сюда: поставь
+ * 30 — и успеешь дойти спокойно.  ОБЯЗАН быть 5 в игровой сборке.
+ *
+ * ПОТОЛОК 30.  Таймер связи — пять бит модификатора кнопки (маска 0x1F), а
+ * значение 31 у оригинала означает «событие заклинено» (`link_timer != 0x1F`
+ * в trigger_button).  Больше 30 ставить нельзя — кнопка перестанет
+ * срабатывать вовсе. */
+#define POP_DBG_GATE_HOLD         5
+
+/* ---- Улучшения SDLPoP (в ОРИГИНАЛЕ их нет) -------------------------- *
+ * POP_ENABLE_JUMP_GRAB — зацепиться за кромку можно ПРЯМО В ПРЫЖКЕ, если
+ * Shift зажат заранее (SDLPoP `enable_jump_grab`, seg006:1228).  Ваниль
+ * разрешает зацеп только в начале падения (`check_grab`, кадры 102..105),
+ * то есть Shift приходится нажимать уже в полёте — это и раздражало на
+ * приёмке.  0 — как в оригинале, 1 — как в SDLPoP с включёнными
+ * enhancements. */
+#define POP_ENABLE_JUMP_GRAB      1
+
+#endif /* POP_TUNE_H */
@@ -15,20 +15,93 @@
 #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_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, loose), 3 = pop_map
+ * (коллизия/физика), 4 = pop_gdraw (отрисовка стража + полоса HP),
+ * 5 = pop_ctrl (диспетчер управления).
+ * Отрисовка стража вынесена из банка 2 отдельно: тот подошёл к 16 КБ
+ * вплотную (16 021 из 16 384), а расти ему ещё есть куда — тайлы поздних
+ * уровней, чомперы, зеркало.
+ *
+ * ДЕРЖАТЬ В СОГЛАСИИ с числом --bank в Makefile.  Забыть — это не ошибка
+ * сборки, а зависание: crt0 выделит меньше страниц, _bank_pages[N] так и
+ * останется нулём, и трамплин прыгнет по 0xC000 в мусор (см. шапку
+ * runtime/bank.s).  Проверено 2026-08-05: с n_banks=4 и пятым банком игра
+ * доходила до конца загрузки ресурсов и вставала намертво в DSS. */
+const uint8_t n_banks = 6;
+
+/* Режим читов (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 */

-/* Тест-старт для отладки пик (Фаза 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
+#ifndef FIRST_LEVEL
+#define FIRST_LEVEL 1      /* с какого уровня начинается игра (-DFIRST_LEVEL=N) */
+#endif
+
 #define RESPAWN_DELAY 400  /* авто-респавн (фолбэк), если не нажали ↑ */
 #define RESPAWN_SETTLE 20  /* тиков до приёма ↑ (труп успел лечь) */

@@ -39,6 +112,7 @@ __sfr __at (0xFE) io_border;
 * Убирается закомментированием ОДНОЙ строки ниже. */
 #define ROOMNAV 1

+
 /* Рабочая копия ТЕКУЩЕЙ комнаты (W2, мутабельная: loose→empty) + срезы
 * соседей для кромок.  Заполняются pop_room_load из уровня.  File-scope,
 * чтобы enter_room переключал комнату без длинного списка параметров. */
@@ -46,7 +120,7 @@ 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 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) */
@@ -64,6 +138,89 @@ static void update_kid_render_dx(void)
    pop_kid_set_render_dx(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(), kid_fp_width());
+    objtile_at_char(&gr, &gc, &Guard, pop_gframe.dx, pop_gframe.dy,
+                    pop_gframe.flags, pop_guard_fp_width());
+    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 > kid_fp_obj_y());
+}
+
 /* Change-driven редрой ЛЕВОГО шва (ворота соседа room8 видны в col0): тяжёлый
 * draw_tile(0,0) в pop_room_redraw_seam_left зовём ТОЛЬКО когда openness гейта
 * реально изменился.  Пока Кид держит кнопку и гейт открыт — modifier стабилен
@@ -77,51 +234,52 @@ static uint8_t seam_redraw;   /* оставшиеся кадры редроя (
 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.) */
+/* Изменения тайлов (упавшая плита → пусто, щебень на месте приземления
+ * куска, поднятый предмет → пол) пишутся ПРЯМО В УРОВЕНЬ —
+ * pop_level_set_tile, как в оригинале (curr_room_tiles[…] = …).  Раньше тут
+ * жила таблица переопределений на 8 записей, и девятая правка молча
+ * терялась: разбитые плиты и выпитые зелья «возвращались» при возврате в
+ * комнату (BUG-LVLSTATE-1). */
 #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;
+#define TILE_FLOOR      0x01

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

-/* Применить переопределения комнаты room к массиву тайлов: base = tilepos
- * первого элемента (0 для полной комнаты, 20 для ряда 2 верхнего соседа). */
-static void apply_overrides(uint8_t room, uint8_t *tiles, uint8_t base, uint8_t n)
+/* Подмена НУЛЕВОЙ записи палитры на обеих страницах (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)
 {
-    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];
+    gfx_pal_set(0, 0, r, g, b);
+    gfx_pal_set(1, 0, r, g, b);
 }

 /* Загрузить комнату room в рабочие массивы и отрисовать её фон в ОБЕ
 * страницы дабл-буфера (у каждой своя видео-ОЗУ/теневая копия).  Оставляет
 * активной страницу 1 — вызывающий восстанавливает нужную draw-страницу. */
-static void enter_room(uint8_t room)
+/* 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);
-    apply_overrides(room, room_fg, 0, 30);   /* щебень/пустота от упавших плит */
    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),
-                      lcol_fg, rcol_fg);
+                      pop_room_link(room, 2), pop_room_link(room, 3));
    pop_room_set_below(below_fg);
    /* Ряд 2 верхнего соседа → полоса кладки у потолка (row0).  fg — статика
     * уровня, mod — живой room_modif (ленивая инициализация). */
@@ -132,7 +290,6 @@ static void enter_room(uint8_t room)
            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);     /* плита-потолок: пробой снизу + провал */
@@ -142,9 +299,17 @@ static void enter_room(uint8_t room)
        }
    }
    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 */
+    if (!follow)
+        pop_guard_enter(room);         /* страж комнаты (порт enter_guard) */
+    pop_hp_invalidate();               /* фон перерисован — полоса HP тоже */
    /* Модификаторы тайлов (openness ворот, состояние пик) — ПЕРСИСТЕНТНЫЕ
     * per-room (room_modif живёт между входами); рисуем и коллидируем по ним,
     * а не по свежему backtable.  Фаза P0. */
@@ -172,34 +337,165 @@ static void enter_room(uint8_t room)
    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 — дверь прошлого уровня не в счёт */
+    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);
+    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 autofrz = 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;

    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("res2001.bin") != 0 &&   /* сырой уровень 1 в EMM-страницу */
-        pop_level_load("a:\\res2001.bin") != 0) {
+    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.pal") < 0)   /* единая игровая палитра */
+    if (gfx_pal_fload(0, "KID\\kid.pal") < 0)   /* единая игровая палитра */
        gfx_pal_fload(0, "a:\\kid.pal");
    gfx_pal_sync();                        /* палитра 0 -> плоскость 1 */

@@ -209,15 +505,11 @@ int main(void)
     * ТОЛЬКО прямоугольник Кида (kid_heal), а не весь экран. */
    /* Извлечь и отрисовать стартовую комнату (в обе страницы).  P0: сбросить
     * trob/room_modif (ленивая инициализация из уровня при первом входе). */
-    pop_trob_reset();
-    enter_room(START_ROOM);
+    /* Старт — ПО ДАННЫМ УРОВНЯ (комната/тайл/направление/поза входа), см.
+     * pop_start_level.  Управление: ←/→ бег, ↓ присед, ↑+→ прыжок с места,
+     * Shift шаг, ESC — выход.  Карта коллизии задана внутри enter_room. */
+    pop_start_level();
    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(),
@@ -228,12 +520,13 @@ int main(void)
        puts("kbd_raw open failed");
        return 1;
    }
+    gfx_set_idle_hook(kbd_idle);       /* вычерпывать FIFO, пока ждём кадр */

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

-        io_border = 2; /* синий - начало */
+        PROF(2);                       /* ввод + heal */

        uint8_t sp = kbd_raw_down(KBD_SPACE);
        if (sp && !sp_prev) {
@@ -250,8 +543,66 @@ int main(void)
         * стоит, можно спокойно разбирать позу Kid и окклюзию. */
        if (kbd_raw_down(0x16)) frozen = 1;
        if (kbd_raw_down(0x1E)) frozen = 0;
+        /* ВРЕМЕННО: автостоп на падении соперника в провал — сцену «скелет
+         * просвечивает сквозь кладку» руками не поймать (падение длится
+         * несколько кадров).  Замирает сам, дальше снимок и чтение памяти.
+         *
+         * Срабатывает ОДИН раз на падение: пока стоит фриз, состояние
+         * персонажа не меняется, поэтому условие остаётся истинным — без
+         * этого флага снятие фриза клавишей '2' тут же гасилось повторным
+         * автостопом в той же итерации.  Взводится заново, когда падение
+         * кончилось (страж убран или вышел из freefall).
+         * Снять вместе с разбором. */
+        if (Guard.charid != 0 && Guard.action == 4 /* in_freefall */ &&
+            Guard.y > 150) {
+            if (!autofrz) { frozen = 1; autofrz = 1; }
+        } else {
+            autofrz = 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) {
-	    io_border = 0;                        /* черный: ждём vsync    */
+	    PROF(0);                              /* чёрный: ждём vsync    */
            gfx_wait_vsync();
            continue;
        }
@@ -259,16 +610,32 @@ int main(void)
 #ifdef ROOMNAV
        /* Обход комнат по номеру: '+' (0x79 numpad / 0x55 '=') — вперёд,
         * '-' (0x7B / 0x4E) — назад.  Edge по nav_prev: одно нажатие = одна
-         * комната.  pop_trob_reset ДО enter_room — каждая комната смотрится в
-         * исходном состоянии (пики убраны, ворота закрыты). */
+         * комната.
+         *
+         * Здесь БЫЛ 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);
-                pop_trob_reset();
                enter_room(r);
                /* Предпочитаем обычный пол; иначе — любой tile_is_floor
                 * (seg001): всё, кроме пустоты/стены/верхов колонны и двери. */
@@ -291,41 +658,71 @@ int main(void)
        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 */
        kid_heal();                    /* стереть прошлый кадр ЭТОЙ страницы */
+        pop_guard_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;
            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);
+            } else {                   /* выпал из уровня (нет комнаты снизу) — рестарт */
+                pop_start_level();
                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));
+            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) {
-                enter_room(nb);
+                /* side для pop_guard_follow — то же направление, по которому
+                 * ищем соседа (roomleave_result оригинала). */
+                enter_room_side(nb, (uint8_t)(pop_leave_dir_prev - 1));
                gfx_set_draw_page(back);
            }
        }

-        io_border = 4;                 /* зеленый */
+        PROF(4);                       /* слой фона */

        pop_loose_tick();              /* loose-полы: анимация + перерисовка (СЛОЙ ФОНА */
                                       /* — ДО Kid, чтобы Kid всегда был поверх плиты) */
-        io_border = 6;                 /* голубой */
-        pop_process_trobs(cur_room);   /* пики/ворота: продвинуть + перерисовать (тоже */
-                                       /* слой фона — ДО Kid) */
-        io_border = 4;                 /* синий   */
+        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) {
@@ -342,51 +739,125 @@ int main(void)
                }
            }
        }
-        io_border = 2;                 /* зеленый */
+        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();
+                /* Всё состояние прошлого уровня сносит сам 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_trob_reset();      /* рестарт уровня: пики/ворота в исходное */
-                enter_room(START_ROOM);
+                pop_start_level();
                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);   /* сама плита исчезла */
+            pop_level_set_tile(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 (lrow >= 0) pop_level_set_tile(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 (up) pop_level_set_tile(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_level_set_tile(cur_room, (uint8_t)(pop_debris_at - 1), TILE_DEBRIS);
            pop_debris_at = 0;
        }
-        io_border = 4;                 /* зеленый */
+        if (pop_item_taken) {          /* предмет поднят → тайл стал полом */
+            item_pos  = (uint8_t)(pop_item_taken - 1);
+            item_bake = 2;             /* запечь на ОБЕИХ страницах */
+            pop_level_set_tile(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_color
+             * оригинала; нам хватает этих двух). */
+            if (pop_flash_red) flash_bg(255, 0, 0);      /* color_4_red        */
+            else               flash_bg(255, 255, 85);   /* color_14_brightyellow */
+            pop_flash_time--;
+            if (!pop_flash_time) pop_flash_red = 0;
+            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(6);                       /* спрайты: страж, Kid, fore поверх */
+        {   /* Кто позже — тот поверх; порядок задаёт обход тайлов, а не роль
+             * персонажа (см. guard_over_kid). */
+            uint8_t g_after = guard_over_kid();
+            if (!g_after) pop_guard_draw();
+            PROF(6);                   /* kid_draw (тот же циан) */
            kid_draw();                /* нарисовать новый кадр (детект выхода за поле) */
+            if (g_after) pop_guard_draw();
+            /* Брызги стража рисует сам pop_guard_draw (порядок objtable), а
+             * флаг снимаем здесь: стража могло не оказаться в отрисованной
+             * комнате — тогда брызги просто пропадают, как в оригинале.
+             * Снимаем ПО ФАКТУ, а не безусловно: запись в кадре удара —
+             * готовая точка останова для отладки в MAME (watchpoint), и
+             * лишней записи каждый кадр нет. */
+            if (pop_guard_hurt) pop_guard_hurt = 0;
+        }
        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_hp_draw();                 /* полоса HP — только при изменении */
+        PROF(6);                       /* fore поверх Kid + борта */
+        /* Окно fore-клипа общее, и pop_guard_draw ставит своё.  При «страж
+         * поверх» он отрабатывает ПОСЛЕ kid_draw, поэтому окно Кида
+         * восстанавливаем явно — иначе передние грани у Кида отсекаются и
+         * он рисуется поверх столбов. */
+        kid_fore_clip_restore();
        pop_fore_over_kid(kid_fp_obj_x(), kid_fp_obj_y(),
                          kid_fp_width(), kid_fp_height(),
                          Kid.direction, Kid.frame, Kid.action);
@@ -396,7 +867,7 @@ int main(void)
         * сделан (скрытая страница), wait_vsync ловит начало кадра,
         * set_visible_page переключает во время бланка (gfx.h паттерн). */

-        io_border = 0;                        /* черный: ждём vsync    */
+        PROF(0);                              /* чёрный: ждём vsync    */

        /* Отладка: номер отрисованной комнаты в верхнем борте — рисуем ТОЛЬКО
         * при её смене (change-driven, счётчик 2 = обе страницы дабл-буфера),
@@ -425,6 +896,10 @@ int main(void)
 #endif

        gfx_wait_vsync();
+        if (flash_on) {                /* строб: цвет держался один кадр растра */
+            flash_bg(0, 0, 0);
+            flash_on = 0;
+        }
        gfx_wait_vsync();
        gfx_wait_vsync();
        if (dbuf) {
@@ -433,10 +908,13 @@ int main(void)
        }
    }

+    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;
 }
@@ -0,0 +1 @@
+build/
@@ -0,0 +1,63 @@
+# Модульные тесты движка roomtest под ucsim_z80.  Обвязка общая (testkit/),
+# здесь — только сами наборы и список модулей, которые в них линкуются.
+TESTKIT    := $(abspath $(CURDIR)/../../../../testkit)
+ENGINE_DIR := $(abspath $(CURDIR)/..)
+
+# t_phys гоняет НАСТОЯЩУЮ физику, а она ходит по таблицам анимации
+# абсолютными адресами от KD_DATA_OFF (0x100) — там, куда на устройстве
+# мапится страница W0.  Значит блоб kid_data.bin лежит по 0x100, и код
+# набора обязан начинаться выше его конца (0x100 + 3720 = 0x0F88).
+CODE_LOC   := 0x1000
+# Данные — выше 0x8000: набор t_phys линкует уже полдвижка (геометрия, Kid,
+# карта/физика, управление, страж) и его код перевалил за 0x8000.  Раньше
+# это проявлялось как «тест зациклился»: хвост кода ложился поверх _DATA.
+# 0x9000 оставляет ~24 КБ под код и ~28 КБ до стека (0xFEF0).
+DATA_LOC   := 0xA000
+
+# Заголовки libc/libbgi нужны потому, что pop_kid.c включает gfx/sprite/
+# sprinter: под тестом эти функции заглушены (stubs.c), но объявления
+# берутся настоящие — иначе разъедутся сигнатуры.
+PROJ_ROOT  := $(abspath $(TESTKIT)/..)
+EXTRA_INC  := -I$(PROJ_ROOT)/libc/include -I$(PROJ_ROOT)/libbgi/include -I$(CURDIR)
+
+OBJS_geom := build/eng_pop_geom.rel
+
+# pop_guard.c линкуется НАСТОЯЩИЙ, а не заглушкой: после перевода физики на
+# Char урон идёт через pop_take_hp, и кому именно он достанется (hitp_* или
+# guardhp_*) решает charid — то есть ровно та логика, которую тесты обязаны
+# проверять, а не имитировать.
+OBJS_phys := build/eng_pop_geom.rel  build/eng_pop_kid.rel \
+             build/eng_pop_map.rel   build/eng_pop_ctrl.rel \
+             build/eng_pop_state.rel build/eng_pop_guard.rel \
+             build/stubs.rel build/scene.rel build/kid_blob.rel \
+             build/bank_stub.rel
+
+# Пробный набор (разведка, без эталонов) линкуется тем же составом.
+OBJS_grab := $(OBJS_phys)
+# t_wall — удар о стену в воздухе (BUG-JUMPWALL-1), состав тот же.
+OBJS_wall := $(OBJS_phys)
+# t_char — физика над Char для РАЗНЫХ персонажей (Кид / страж / тень).
+OBJS_char := $(OBJS_phys)
+
+include $(TESTKIT)/host-tests.mk
+
+# --- t_phys: блоб таблиц анимации ------------------------------------
+KID_BIN := $(abspath $(CURDIR)/../../poc/res/kid/kid_data.bin)
+
+build/kid_blob.c: gen_kid_blob.py $(KID_BIN) | $(BUILD)
+	@python3 gen_kid_blob.py $(KID_BIN) $@
+
+build/kid_blob.rel: build/kid_blob.c kidblob.h | $(BUILD)
+	@$(SDCC) $(CFLAGS) -c -o $@ $<
+
+build/stubs.rel: stubs.c stubs.h kidblob.h | $(BUILD)
+	@$(SDCC) $(CFLAGS) -c -o $@ $<
+
+build/scene.rel: scene.c scene.h stubs.h kidblob.h | $(BUILD)
+	@$(SDCC) $(CFLAGS) -c -o $@ $<
+
+build/bank_stub.rel: bank_stub.s | $(BUILD)
+	@$(SDASZ80) -plosgff $@ $<
+
+# Эталоны трасс: пересобрать набор, если их правили (см. шапку t_phys.c).
+build/phys.rel: $(wildcard golden/*.h)
@@ -0,0 +1,121 @@
+# tests-host — модульные тесты движка roomtest
+
+Прогоняются под `ucsim_z80`, обвязка общая — `testkit/` (там же объяснение,
+почему под z80, а не хостовым gcc, и грабли).
+
+```
+make host-tests                                  # из корня, вместе с остальными
+make -C applications/PoP/roomtest/tests-host     # только эти
+make -C applications/PoP/roomtest/tests-host t_geom
+```
+
+## Что покрыто
+
+| набор | модуль | что проверяет |
+|-------|--------|---------------|
+| `t_geom` | `pop_geom.c` | геометрия комнаты (`x_bump`, `y_land`, `y_to_row`) и PRNG оригинала |
+| `t_phys` | `pop_map.c` + `pop_kid.c` + `pop_ctrl.c` | покадровые трассы физики Кида: стойка, бег, шаг с Shift, разворот, присед, прыжок вверх, падение с кромки, loose-плита, разбег-прыжок через провал |
+| `t_char` | те же + `pop_guard.c` | физика над `Char` для РАЗНЫХ персонажей: кому достаётся урон (`take_hp` по charid), ветки `land()` (Кид −1 HP с двух рядов, страж гибнет, тень цела), падение и гард по X у слота Guard, `check_guard_fallout`, «окна Char не путают персонажей» |
+
+Главный тест в `t_geom` — `geom_lcg_matches_reference`. LCG оригинала
+(`s = s*214013 + 2531011`) написан в `pop_geom.c` на ассемблере по схеме
+Горнера ради обхода `__mullong`, и заявка «бит-в-бит как в SDLPoP» до
+появления теста держалась только на комментарии. Тест сверяет рукописный
+asm с наивной 32-битной формулой на 128 шагах — и по возвращаемому
+значению, и по обеим половинам сида.
+
+## t_phys: характеризация, а не проверка правильности
+
+Набор существует ради **страховки под рефакторинг**. Эталоны сняты с
+текущего билда, то есть консервируют и текущие баги — правильность
+по-прежнему проверяется сверкой с `SDLPoP/src/`. Ценность в другом:
+ближайший крупный шаг (перенос физики с `Kid.` на `Char.`, чтобы её мог
+переиспользовать страж) обязан быть **поведение-сохраняющим**, и «трасса до
+== трасса после» ловит ровно тот класс ошибок, который там возможен.
+
+Поэтому эталон **переснимается только осознанно**, и в коммите должно быть
+написано, что и почему поменялось. Молча обновлённый эталон обесценивает
+весь набор.
+
+Своё дело набор сделал: перенос физики на `Char` (GUARD-PHYS, 2026-08-07)
+прошёл при **неизменных трассах** — 1723 проверки без единого расхождения.
+
+## Грабли раскладки: `DATA_LOC`
+
+Набор линкует уже полдвижка, и его код перевалил за `--data-loc 0x8000`.
+Линкер `sdld` это НЕ ошибка: хвост кода (`_HOME`, деления из libsdcc) он
+молча кладёт ПОВЕРХ `_DATA`, после чего тест ведёт себя как «зациклился»
+— хотя логика ни при чём. Час на поиск стоило именно это.
+
+Поэтому: `DATA_LOC` в Makefile набора (сейчас `0x9000`), а `host-tests.mk`
+перед каждым прогоном проверяет `CODE_LOC + l__CODE <= DATA_LOC` и падает
+с внятным сообщением. Упёрлись снова — поднять `DATA_LOC` (стек в
+`crt0_ucsim` начинается с 0xFEF0).
+
+```
+python3 record_golden.py          # переснять все трассы
+python3 record_golden.py 7 9      # только сценарии 7 и 9
+```
+
+Трасса — по одной записи на кадр: `frame, x, y, dir, col, row, action` и
+смещение `curr_seq` от `SEQTBL_BASE`. Кадр гоняется ровно в том порядке,
+что и в главном цикле `roomtest.c`:
+
+```
+pop_ctrl_tick();   // ввод -> control(): смена последовательности
+kid_tick();        // play_seq: следующий кадр
+pop_phys_tick();   // падение/приземление/стена
+pop_loose_tick();  // досчёт тряски и снятие провалившейся плиты
+```
+
+Покадровость здесь принципиальна: порт seg005/seg006 — конечный автомат, и
+ошибка почти всегда проявляется не в одной функции, а в расхождении
+траектории через несколько кадров. Плюс главный риск переноса на `Char` —
+не арифметика, а то, **кто владеет окном `Char` внутри кадра**; поймать это
+можно только прогоном полного кадра.
+
+Проверка, что харнесс воспроизводит устройство: сценарий `stand` даёт
+`frame=15, x=114, y=118, curr_seq=0x19A3` — те же значения, что читаются из
+`_Kid` в живом MAME.
+
+### Как это заработало под ucsim
+
+Три шва, каждый закрыт без правок продуктового кода:
+
+1. **Таблицы анимации.** `pop_kid.c` ходит по ним абсолютными адресами от
+   `KD_DATA_OFF` (0x100) — там, куда на устройстве их приводит маппинг W0.
+   В тесте `kid_data.bin` просто кладётся по 0x100 (`gen_kid_blob.py`), а
+   `gfx_w0_map` заглушен. Следствие: код набора линкуется с
+   `--code-loc 0x1000` (`CODE_LOC` в Makefile), чтобы не налезть на блоб.
+2. **Окружение.** `stubs.c` — libc/libbgi (графика, память, файлы), соседние
+   модули (`pop_bg`/`pop_trob`/`pop_level`/`pop_redraw`) и состояние стража.
+   Заглушки не пустые там, где это меняет смысл: файловое чтение реально
+   отдаёт `kid_data.bin` (иначе `pop_kid_data_load` тихо сдаётся, `kdat_ok`
+   остаётся нулём и `play_seq` не делает ничего — трасса выходит из одного
+   застывшего кадра), клавиатура отвечает по набору «нажатых» скан-кодов
+   (так под тест попадают `read_input` и `read_user_control`, а не только
+   диспетчер), а обращения к соседям **журналируются** (`tk_log`) — можно
+   проверять «плита отвалилась и попросила перерисовку», а не только
+   координаты.
+3. **`__banked`.** Модули физики помечены как банковые, SDCC генерирует на
+   них трамплин `___sdcc_bcall_ehl`, которому нужны `set_bank`/`get_bank`.
+   В тесте память плоская — `bank_stub.s` отдаёт нулевой банк и пустое
+   переключение, соблюдая контракт по регистрам.
+
+Что харнесс НЕ покрывает и остаётся за MAME: отрисовка и окклюзия, реальные
+переключения банков, тайминги кадра, настоящая клавиатура.
+
+## Что нужно, чтобы двинуться дальше
+
+- **Доступ к странице уровня.** `pop_level.c` ходит по абсолютным адресам
+  (`(uint8_t *)(LVL_DATA_OFF + …)` после `gfx_w0_map`). Для `pop_map` это не
+  потребовалось — карту комнаты в него ИНЪЕКТИРУЮТ через `pop_map_set`, —
+  но набор на сам `pop_level`/`pop_trob` в это упрётся. Решение то же, что
+  для `kid_data`: положить страницу по нужному адресу и поднять `CODE_LOC`.
+- **Сценарии из `bug_closed.md`.** У каждой закрытой записи есть симптом и
+  ожидаемое поведение — готовый список регрессионных кейсов, который стоит
+  переносить в `t_phys` по мере надобности.
+- **BUG-LOOSE-2** (гонка «уйти из комнаты раньше, чем долетит плита») —
+  через мост MAME воспроизвести не удалось, а на уровне логики это
+  несколько строк: заспавнить кусок, сменить комнату, тикать до
+  приземления, проверить щебень.
@@ -0,0 +1,25 @@
+;--------------------------------------------------------------------------
+; bank_stub.s — set_bank/get_bank для прогона под ucsim.
+;
+; Модули движка помечены __banked (в продукте они лежат в страницах W3), и
+; SDCC генерирует на такие вызовы трамплин ___sdcc_bcall_ehl из своей
+; библиотеки.  Трамплин обязан найти две пользовательские подпрограммы:
+;
+;   get_bank — вернуть в A номер текущего банка, прочие регистры не трогать
+;   set_bank — переключить банк на A,        прочие регистры не трогать
+;
+; В тесте банков нет: вся память плоская, все модули слинкованы вместе.
+; Поэтому «банк» всегда нулевой, а переключение — пустое.  Важно только
+; соблюсти контракт по регистрам, иначе трамплин испортит аргументы вызова.
+;--------------------------------------------------------------------------
+	.area	_CODE
+
+	.globl	set_bank
+	.globl	get_bank
+
+get_bank::
+	ld	a, #0x00
+	ret
+
+set_bank::
+	ret
@@ -0,0 +1,46 @@
+#!/usr/bin/env python3
+"""
+gen_kid_blob.py — kid_data.bin как C-массив для тестов под ucsim.
+
+Зачем.  Таблицы кадров и seqtbl живут в EMM-странице, замапленной в W0, и
+pop_kid ходит по ним АБСОЛЮТНЫМИ адресами от KD_DATA_OFF (0x100).  В ucsim
+никакого W0 нет, зато есть ровная 64-КБ память, поэтому тест просто кладёт
+файл по 0x100 и глушит gfx_w0_map.  Единственное следствие для сборки —
+код набора линкуется с --code-loc выше конца блоба (см. Makefile).
+
+Файл берётся ровно тот, что уходит на устройство, — pop_extract_kid_data.py
+делает его из оригинального PRINCE.EXE, так что тест проверяет порт против
+НАСТОЯЩИХ данных игры, а не против переписанной от руки таблицы.
+"""
+import sys
+from pathlib import Path
+
+src, dst = Path(sys.argv[1]), Path(sys.argv[2])
+data = src.read_bytes()
+
+out = [
+    "/* Сгенерировано gen_kid_blob.py — не править руками. */",
+    '#include "kidblob.h"',
+    "",
+    f"const unsigned char kid_blob[{len(data)}] = {{",
+]
+for i in range(0, len(data), 16):
+    out.append("    " + ",".join(str(b) for b in data[i:i + 16]) + ",")
+out += [
+    "};",
+    "",
+    f"const unsigned int kid_blob_size = {len(data)};",
+    "",
+    "/* Разложить блоб по KD_DATA_OFF.  Без memcpy: тестовый бинарь не",
+    " * линкуется с libc, а тянуть ради этого z80-рантайм незачем. */",
+    "void kid_blob_install(void)",
+    "{",
+    "    unsigned char *d = (unsigned char *)KID_BLOB_ADDR;",
+    "    const unsigned char *s = kid_blob;",
+    f"    unsigned int n = {len(data)};",
+    "    while (n--) *d++ = *s++;",
+    "}",
+    "",
+]
+dst.write_text("\n".join(out))
+print(f"gen_kid_blob: {src.name} -> {dst.name} ({len(data)} Б)")
@@ -0,0 +1,22 @@
+/* Эталон трассы: crouch.  Снят record_golden.py — не править руками.
+ * Поля кадра: frame, x, y, dir, col, row, action, seq_lo, seq_hi. */
+    0x6B, 0x81, 0x76, 0x00, 0x04, 0x01, 0x01, 0x3E, 0x06,
+    0x6C, 0x83, 0x76, 0x00, 0x04, 0x01, 0x01, 0x41, 0x06,
+    0x6D, 0x83, 0x76, 0x00, 0x04, 0x01, 0x01, 0x42, 0x06,
+    0x6D, 0x83, 0x76, 0x00, 0x04, 0x01, 0x01, 0x42, 0x06,
+    0x6D, 0x83, 0x76, 0x00, 0x04, 0x01, 0x01, 0x42, 0x06,
+    0x6D, 0x83, 0x76, 0x00, 0x04, 0x01, 0x01, 0x42, 0x06,
+    0x6D, 0x83, 0x76, 0x00, 0x04, 0x01, 0x01, 0x42, 0x06,
+    0x6D, 0x83, 0x76, 0x00, 0x04, 0x01, 0x01, 0x42, 0x06,
+    0x6E, 0x84, 0x76, 0x00, 0x04, 0x01, 0x05, 0x4A, 0x06,
+    0x6F, 0x84, 0x76, 0x00, 0x04, 0x01, 0x05, 0x4B, 0x06,
+    0x70, 0x86, 0x76, 0x00, 0x04, 0x01, 0x05, 0x4E, 0x06,
+    0x71, 0x86, 0x76, 0x00, 0x04, 0x01, 0x05, 0x4F, 0x06,
+    0x72, 0x87, 0x76, 0x00, 0x04, 0x01, 0x05, 0x52, 0x06,
+    0x73, 0x87, 0x76, 0x00, 0x04, 0x01, 0x05, 0x53, 0x06,
+    0x74, 0x87, 0x76, 0x00, 0x04, 0x01, 0x05, 0x54, 0x06,
+    0x75, 0x83, 0x76, 0x00, 0x04, 0x01, 0x05, 0x57, 0x06,
+    0x76, 0x83, 0x76, 0x00, 0x04, 0x01, 0x05, 0x58, 0x06,
+    0x77, 0x83, 0x76, 0x00, 0x04, 0x01, 0x05, 0x59, 0x06,
+    0x0F, 0x83, 0x76, 0x00, 0x04, 0x01, 0x00, 0x35, 0x00,
+    0x0F, 0x83, 0x76, 0x00, 0x04, 0x01, 0x00, 0x35, 0x00,
@@ -0,0 +1,36 @@
+/* Эталон трассы: fall_ledge.  Снят record_golden.py — не править руками.
+ * Поля кадра: frame, x, y, dir, col, row, action, seq_lo, seq_hi. */
+    0x01, 0x56, 0x76, 0x00, 0x01, 0x01, 0x01, 0x08, 0x00,
+    0x02, 0x56, 0x76, 0x00, 0x01, 0x01, 0x01, 0x09, 0x00,
+    0x03, 0x56, 0x76, 0x00, 0x01, 0x01, 0x01, 0x0A, 0x00,
+    0x04, 0x56, 0x76, 0x00, 0x01, 0x01, 0x01, 0x0B, 0x00,
+    0x05, 0x5E, 0x76, 0x00, 0x01, 0x01, 0x01, 0x0E, 0x00,
+    0x06, 0x61, 0x76, 0x00, 0x01, 0x01, 0x01, 0x11, 0x00,
+    0x07, 0x64, 0x76, 0x00, 0x01, 0x01, 0x01, 0x14, 0x00,
+    0x08, 0x69, 0x76, 0x00, 0x02, 0x01, 0x01, 0x17, 0x00,
+    0x09, 0x6A, 0x76, 0x00, 0x02, 0x01, 0x01, 0x1C, 0x00,
+    0x0A, 0x6C, 0x76, 0x00, 0x02, 0x01, 0x01, 0x1F, 0x00,
+    0x0B, 0x70, 0x76, 0x00, 0x02, 0x01, 0x01, 0x22, 0x00,
+    0x0C, 0x75, 0x76, 0x00, 0x03, 0x01, 0x01, 0x25, 0x00,
+    0x0D, 0x77, 0x76, 0x00, 0x03, 0x01, 0x01, 0x2A, 0x00,
+    0x0E, 0x7A, 0x76, 0x00, 0x03, 0x01, 0x01, 0x2D, 0x00,
+    0x07, 0x7E, 0x76, 0x00, 0x03, 0x01, 0x01, 0x14, 0x00,
+    0x08, 0x83, 0x76, 0x00, 0x04, 0x01, 0x01, 0x17, 0x00,
+    0x09, 0x84, 0x76, 0x00, 0x04, 0x01, 0x01, 0x1C, 0x00,
+    0x0A, 0x86, 0x76, 0x00, 0x04, 0x01, 0x01, 0x1F, 0x00,
+    0x0B, 0x8A, 0x76, 0x00, 0x04, 0x01, 0x01, 0x22, 0x00,
+    0x0C, 0x8F, 0x76, 0x00, 0x05, 0x01, 0x01, 0x25, 0x00,
+    0x0D, 0x91, 0x76, 0x00, 0x05, 0x01, 0x01, 0x2A, 0x00,
+    0x0E, 0x94, 0x76, 0x00, 0x05, 0x01, 0x01, 0x2D, 0x00,
+    0x07, 0x98, 0x76, 0x00, 0x05, 0x01, 0x01, 0x14, 0x00,
+    0x66, 0x9E, 0x79, 0x00, 0x06, 0x02, 0x03, 0x77, 0x02,
+    0x67, 0xA0, 0x7F, 0x00, 0x06, 0x02, 0x03, 0x7C, 0x02,
+    0x68, 0x9F, 0x88, 0x00, 0x06, 0x02, 0x03, 0x81, 0x02,
+    0x69, 0x9F, 0x94, 0x00, 0x06, 0x02, 0x03, 0x84, 0x02,
+    0x6A, 0x9E, 0xA6, 0x00, 0x06, 0x02, 0x04, 0xDE, 0x03,
+    0x6B, 0xA0, 0xB5, 0x00, 0x06, 0x02, 0x05, 0xC3, 0x06,
+    0x6C, 0xA2, 0xB5, 0x00, 0x06, 0x02, 0x05, 0xC6, 0x06,
+    0x6D, 0xA2, 0xB5, 0x00, 0x06, 0x02, 0x01, 0xC9, 0x06,
+    0x6E, 0xA3, 0xB5, 0x00, 0x06, 0x02, 0x05, 0x4A, 0x06,
+    0x6F, 0xA3, 0xB5, 0x00, 0x06, 0x02, 0x05, 0x4B, 0x06,
+    0x70, 0xA5, 0xB5, 0x00, 0x06, 0x02, 0x05, 0x4E, 0x06,
@@ -0,0 +1,22 @@
+/* Эталон трассы: jump_up.  Снят record_golden.py — не править руками.
+ * Поля кадра: frame, x, y, dir, col, row, action, seq_lo, seq_hi. */
+    0x43, 0x80, 0x76, 0xFF, 0x04, 0x01, 0x01, 0x12, 0x04,
+    0x44, 0x80, 0x76, 0xFF, 0x04, 0x01, 0x01, 0x13, 0x04,
+    0x45, 0x80, 0x76, 0xFF, 0x04, 0x01, 0x01, 0x14, 0x04,
+    0x46, 0x80, 0x76, 0xFF, 0x04, 0x01, 0x01, 0x15, 0x04,
+    0x47, 0x80, 0x76, 0xFF, 0x04, 0x01, 0x01, 0x16, 0x04,
+    0x48, 0x80, 0x76, 0xFF, 0x04, 0x01, 0x01, 0x17, 0x04,
+    0x49, 0x80, 0x76, 0xFF, 0x04, 0x01, 0x01, 0x18, 0x04,
+    0x4A, 0x80, 0x76, 0xFF, 0x05, 0x01, 0x01, 0x19, 0x04,
+    0x4B, 0x80, 0x76, 0xFF, 0x04, 0x01, 0x01, 0x1A, 0x04,
+    0x4C, 0x80, 0x76, 0xFF, 0x04, 0x01, 0x01, 0x1B, 0x04,
+    0x4D, 0x80, 0x76, 0xFF, 0x04, 0x01, 0x01, 0x1C, 0x04,
+    0x4E, 0x80, 0x76, 0xFF, 0x04, 0x01, 0x01, 0x1D, 0x04,
+    0x4F, 0x80, 0x76, 0xFF, 0x04, 0x01, 0x01, 0x1E, 0x04,
+    0x4F, 0x80, 0x72, 0xFF, 0x04, 0x01, 0x01, 0x21, 0x04,
+    0x4F, 0x80, 0x70, 0xFF, 0x04, 0x01, 0x01, 0x24, 0x04,
+    0x4F, 0x80, 0x70, 0xFF, 0x04, 0x01, 0x01, 0x25, 0x04,
+    0x4F, 0x80, 0x72, 0xFF, 0x04, 0x01, 0x01, 0x28, 0x04,
+    0x51, 0x80, 0x76, 0xFF, 0x04, 0x01, 0x01, 0xB8, 0x03,
+    0x52, 0x80, 0x76, 0xFF, 0x04, 0x01, 0x01, 0xB9, 0x03,
+    0x53, 0x80, 0x76, 0xFF, 0x04, 0x01, 0x05, 0xBC, 0x03,
@@ -0,0 +1,36 @@
+/* Эталон трассы: loose.  Снят record_golden.py — не править руками.
+ * Поля кадра: frame, x, y, dir, col, row, action, seq_lo, seq_hi. */
+    0x01, 0x56, 0x76, 0x00, 0x01, 0x01, 0x01, 0x08, 0x00,
+    0x02, 0x56, 0x76, 0x00, 0x01, 0x01, 0x01, 0x09, 0x00,
+    0x03, 0x56, 0x76, 0x00, 0x01, 0x01, 0x01, 0x0A, 0x00,
+    0x04, 0x56, 0x76, 0x00, 0x01, 0x01, 0x01, 0x0B, 0x00,
+    0x05, 0x5E, 0x76, 0x00, 0x01, 0x01, 0x01, 0x0E, 0x00,
+    0x06, 0x61, 0x76, 0x00, 0x01, 0x01, 0x01, 0x11, 0x00,
+    0x07, 0x64, 0x76, 0x00, 0x01, 0x01, 0x01, 0x14, 0x00,
+    0x08, 0x69, 0x76, 0x00, 0x02, 0x01, 0x01, 0x17, 0x00,
+    0x09, 0x6A, 0x76, 0x00, 0x02, 0x01, 0x01, 0x1C, 0x00,
+    0x0A, 0x6C, 0x76, 0x00, 0x02, 0x01, 0x01, 0x1F, 0x00,
+    0x0B, 0x70, 0x76, 0x00, 0x02, 0x01, 0x01, 0x22, 0x00,
+    0x0C, 0x75, 0x76, 0x00, 0x03, 0x01, 0x01, 0x25, 0x00,
+    0x0D, 0x77, 0x76, 0x00, 0x03, 0x01, 0x01, 0x2A, 0x00,
+    0x0E, 0x7A, 0x76, 0x00, 0x03, 0x01, 0x01, 0x2D, 0x00,
+    0x07, 0x7E, 0x76, 0x00, 0x03, 0x01, 0x01, 0x14, 0x00,
+    0x08, 0x83, 0x76, 0x00, 0x04, 0x01, 0x01, 0x17, 0x00,
+    0x09, 0x84, 0x76, 0x00, 0x04, 0x01, 0x01, 0x1C, 0x00,
+    0x0A, 0x86, 0x76, 0x00, 0x04, 0x01, 0x01, 0x1F, 0x00,
+    0x0B, 0x8A, 0x76, 0x00, 0x04, 0x01, 0x01, 0x22, 0x00,
+    0x0C, 0x8F, 0x76, 0x00, 0x05, 0x01, 0x01, 0x25, 0x00,
+    0x0D, 0x91, 0x76, 0x00, 0x05, 0x01, 0x01, 0x2A, 0x00,
+    0x0E, 0x94, 0x76, 0x00, 0x05, 0x01, 0x01, 0x2D, 0x00,
+    0x07, 0x98, 0x76, 0x00, 0x05, 0x01, 0x01, 0x14, 0x00,
+    0x08, 0x9D, 0x76, 0x00, 0x06, 0x01, 0x01, 0x17, 0x00,
+    0x09, 0x9E, 0x76, 0x00, 0x06, 0x01, 0x01, 0x1C, 0x00,
+    0x0A, 0xA0, 0x76, 0x00, 0x06, 0x01, 0x01, 0x1F, 0x00,
+    0x0B, 0xA4, 0x76, 0x00, 0x06, 0x01, 0x01, 0x22, 0x00,
+    0x0C, 0xA9, 0x76, 0x00, 0x07, 0x01, 0x01, 0x25, 0x00,
+    0x0D, 0xAB, 0x76, 0x00, 0x07, 0x01, 0x01, 0x2A, 0x00,
+    0x0E, 0xAE, 0x76, 0x00, 0x07, 0x01, 0x01, 0x2D, 0x00,
+    0x07, 0xB2, 0x76, 0x00, 0x07, 0x01, 0x01, 0x14, 0x00,
+    0x08, 0xB7, 0x76, 0x00, 0x08, 0x01, 0x01, 0x17, 0x00,
+    0x09, 0xB8, 0x76, 0x00, 0x08, 0x01, 0x01, 0x1C, 0x00,
+    0x0A, 0xBA, 0x76, 0x00, 0x08, 0x01, 0x01, 0x1F, 0x00,
@@ -0,0 +1,36 @@
+/* Эталон трассы: rjump_gap3.  Снят record_golden.py — не править руками.
+ * Поля кадра: frame, x, y, dir, col, row, action, seq_lo, seq_hi. */
+    0x01, 0xB8, 0x76, 0xFF, 0x08, 0x01, 0x01, 0x08, 0x00,
+    0x02, 0xB8, 0x76, 0xFF, 0x08, 0x01, 0x01, 0x09, 0x00,
+    0x03, 0xB8, 0x76, 0xFF, 0x08, 0x01, 0x01, 0x0A, 0x00,
+    0x04, 0xB8, 0x76, 0xFF, 0x08, 0x01, 0x01, 0x0B, 0x00,
+    0x05, 0xB0, 0x76, 0xFF, 0x08, 0x01, 0x01, 0x0E, 0x00,
+    0x06, 0xAD, 0x76, 0xFF, 0x08, 0x01, 0x01, 0x11, 0x00,
+    0x07, 0xAA, 0x76, 0xFF, 0x08, 0x01, 0x01, 0x14, 0x00,
+    0x08, 0xA5, 0x76, 0xFF, 0x07, 0x01, 0x01, 0x17, 0x00,
+    0x09, 0xA4, 0x76, 0xFF, 0x07, 0x01, 0x01, 0x1C, 0x00,
+    0x0A, 0xA2, 0x76, 0xFF, 0x07, 0x01, 0x01, 0x1F, 0x00,
+    0x0B, 0x9E, 0x76, 0xFF, 0x07, 0x01, 0x01, 0x22, 0x00,
+    0x0C, 0x99, 0x76, 0xFF, 0x06, 0x01, 0x01, 0x25, 0x00,
+    0x0D, 0x97, 0x76, 0xFF, 0x06, 0x01, 0x01, 0x2A, 0x00,
+    0x22, 0x95, 0x76, 0xFF, 0x06, 0x01, 0x01, 0x64, 0x01,
+    0x23, 0x90, 0x76, 0xFF, 0x06, 0x01, 0x01, 0x67, 0x01,
+    0x24, 0x8A, 0x76, 0xFF, 0x06, 0x01, 0x01, 0x6A, 0x01,
+    0x25, 0x87, 0x76, 0xFF, 0x05, 0x01, 0x01, 0x6D, 0x01,
+    0x26, 0x82, 0x76, 0xFF, 0x05, 0x01, 0x01, 0x72, 0x01,
+    0x27, 0x7B, 0x76, 0xFF, 0x05, 0x01, 0x01, 0x75, 0x01,
+    0x28, 0x6F, 0x73, 0xFF, 0x04, 0x01, 0x01, 0x7A, 0x01,
+    0x29, 0x67, 0x6A, 0xFF, 0x03, 0x01, 0x01, 0x7F, 0x01,
+    0x2A, 0x5F, 0x68, 0xFF, 0x02, 0x01, 0x01, 0x84, 0x01,
+    0x2B, 0x5B, 0x73, 0xFF, 0x01, 0x01, 0x01, 0x89, 0x01,
+    0x2C, 0x57, 0x76, 0xFF, 0x01, 0x01, 0x01, 0x8E, 0x01,
+    0x07, 0x52, 0x76, 0xFF, 0x01, 0x01, 0x01, 0x14, 0x00,
+    0x32, 0x52, 0x76, 0xFF, 0x01, 0x01, 0x05, 0x93, 0x04,
+    0x33, 0x52, 0x76, 0xFF, 0x01, 0x01, 0x05, 0x94, 0x04,
+    0x34, 0x52, 0x76, 0xFF, 0x01, 0x01, 0x05, 0x95, 0x04,
+    0x0F, 0x52, 0x76, 0xFF, 0x01, 0x01, 0x00, 0x35, 0x00,
+    0x10, 0x52, 0x76, 0xFF, 0x01, 0x01, 0x01, 0x28, 0x01,
+    0x11, 0x52, 0x76, 0xFF, 0x01, 0x01, 0x01, 0x29, 0x01,
+    0x12, 0x50, 0x76, 0xFF, 0x01, 0x01, 0x01, 0x2C, 0x01,
+    0x13, 0x4E, 0x76, 0xFF, 0x01, 0x01, 0x01, 0x2F, 0x01,
+    0x32, 0x52, 0x76, 0xFF, 0x01, 0x01, 0x05, 0x93, 0x04,
@@ -0,0 +1,26 @@
+/* Эталон трассы: run_right.  Снят record_golden.py — не править руками.
+ * Поля кадра: frame, x, y, dir, col, row, action, seq_lo, seq_hi. */
+    0x01, 0x56, 0x76, 0x00, 0x01, 0x01, 0x01, 0x08, 0x00,
+    0x02, 0x56, 0x76, 0x00, 0x01, 0x01, 0x01, 0x09, 0x00,
+    0x03, 0x56, 0x76, 0x00, 0x01, 0x01, 0x01, 0x0A, 0x00,
+    0x04, 0x56, 0x76, 0x00, 0x01, 0x01, 0x01, 0x0B, 0x00,
+    0x05, 0x5E, 0x76, 0x00, 0x01, 0x01, 0x01, 0x0E, 0x00,
+    0x06, 0x61, 0x76, 0x00, 0x01, 0x01, 0x01, 0x11, 0x00,
+    0x07, 0x64, 0x76, 0x00, 0x01, 0x01, 0x01, 0x14, 0x00,
+    0x08, 0x69, 0x76, 0x00, 0x02, 0x01, 0x01, 0x17, 0x00,
+    0x09, 0x6A, 0x76, 0x00, 0x02, 0x01, 0x01, 0x1C, 0x00,
+    0x0A, 0x6C, 0x76, 0x00, 0x02, 0x01, 0x01, 0x1F, 0x00,
+    0x0B, 0x70, 0x76, 0x00, 0x02, 0x01, 0x01, 0x22, 0x00,
+    0x0C, 0x75, 0x76, 0x00, 0x03, 0x01, 0x01, 0x25, 0x00,
+    0x0D, 0x77, 0x76, 0x00, 0x03, 0x01, 0x01, 0x2A, 0x00,
+    0x0E, 0x7A, 0x76, 0x00, 0x03, 0x01, 0x01, 0x2D, 0x00,
+    0x07, 0x7E, 0x76, 0x00, 0x03, 0x01, 0x01, 0x14, 0x00,
+    0x08, 0x83, 0x76, 0x00, 0x04, 0x01, 0x01, 0x17, 0x00,
+    0x09, 0x84, 0x76, 0x00, 0x04, 0x01, 0x01, 0x1C, 0x00,
+    0x0A, 0x86, 0x76, 0x00, 0x04, 0x01, 0x01, 0x1F, 0x00,
+    0x0B, 0x8A, 0x76, 0x00, 0x04, 0x01, 0x01, 0x22, 0x00,
+    0x0C, 0x8F, 0x76, 0x00, 0x05, 0x01, 0x01, 0x25, 0x00,
+    0x0D, 0x91, 0x76, 0x00, 0x05, 0x01, 0x01, 0x2A, 0x00,
+    0x0E, 0x94, 0x76, 0x00, 0x05, 0x01, 0x01, 0x2D, 0x00,
+    0x07, 0x98, 0x76, 0x00, 0x05, 0x01, 0x01, 0x14, 0x00,
+    0x08, 0x9D, 0x76, 0x00, 0x06, 0x01, 0x01, 0x17, 0x00,
@@ -0,0 +1,14 @@
+/* Эталон трассы: stand.  Снят record_golden.py — не править руками.
+ * Поля кадра: frame, x, y, dir, col, row, action, seq_lo, seq_hi. */
+    0x0F, 0x72, 0x76, 0xFF, 0x03, 0x01, 0x00, 0x35, 0x00,
+    0x0F, 0x72, 0x76, 0xFF, 0x03, 0x01, 0x00, 0x35, 0x00,
+    0x0F, 0x72, 0x76, 0xFF, 0x03, 0x01, 0x00, 0x35, 0x00,
+    0x0F, 0x72, 0x76, 0xFF, 0x03, 0x01, 0x00, 0x35, 0x00,
+    0x0F, 0x72, 0x76, 0xFF, 0x03, 0x01, 0x00, 0x35, 0x00,
+    0x0F, 0x72, 0x76, 0xFF, 0x03, 0x01, 0x00, 0x35, 0x00,
+    0x0F, 0x72, 0x76, 0xFF, 0x03, 0x01, 0x00, 0x35, 0x00,
+    0x0F, 0x72, 0x76, 0xFF, 0x03, 0x01, 0x00, 0x35, 0x00,
+    0x0F, 0x72, 0x76, 0xFF, 0x03, 0x01, 0x00, 0x35, 0x00,
+    0x0F, 0x72, 0x76, 0xFF, 0x03, 0x01, 0x00, 0x35, 0x00,
+    0x0F, 0x72, 0x76, 0xFF, 0x03, 0x01, 0x00, 0x35, 0x00,
+    0x0F, 0x72, 0x76, 0xFF, 0x03, 0x01, 0x00, 0x35, 0x00,
@@ -0,0 +1,22 @@
+/* Эталон трассы: step_shift.  Снят record_golden.py — не править руками.
+ * Поля кадра: frame, x, y, dir, col, row, action, seq_lo, seq_hi. */
+    0x79, 0x72, 0x76, 0x00, 0x03, 0x01, 0x01, 0x6F, 0x05,
+    0x7A, 0x73, 0x76, 0x00, 0x03, 0x01, 0x01, 0x72, 0x05,
+    0x7B, 0x74, 0x76, 0x00, 0x03, 0x01, 0x01, 0x75, 0x05,
+    0x7C, 0x77, 0x76, 0x00, 0x03, 0x01, 0x01, 0x78, 0x05,
+    0x7D, 0x7B, 0x76, 0x00, 0x03, 0x01, 0x01, 0x7B, 0x05,
+    0x7E, 0x7E, 0x76, 0x00, 0x03, 0x01, 0x01, 0x7E, 0x05,
+    0x7F, 0x7D, 0x76, 0x00, 0x04, 0x01, 0x01, 0x81, 0x05,
+    0x80, 0x7D, 0x76, 0x00, 0x04, 0x01, 0x01, 0x82, 0x05,
+    0x81, 0x7D, 0x76, 0x00, 0x04, 0x01, 0x01, 0x83, 0x05,
+    0x82, 0x7D, 0x76, 0x00, 0x04, 0x01, 0x01, 0x84, 0x05,
+    0x83, 0x7D, 0x76, 0x00, 0x04, 0x01, 0x01, 0x85, 0x05,
+    0x84, 0x7D, 0x76, 0x00, 0x04, 0x01, 0x01, 0x86, 0x05,
+    0x0F, 0x7D, 0x76, 0x00, 0x04, 0x01, 0x00, 0x35, 0x00,
+    0x0F, 0x7D, 0x76, 0x00, 0x04, 0x01, 0x00, 0x35, 0x00,
+    0x0F, 0x7D, 0x76, 0x00, 0x04, 0x01, 0x00, 0x35, 0x00,
+    0x0F, 0x7D, 0x76, 0x00, 0x04, 0x01, 0x00, 0x35, 0x00,
+    0x0F, 0x7D, 0x76, 0x00, 0x04, 0x01, 0x00, 0x35, 0x00,
+    0x0F, 0x7D, 0x76, 0x00, 0x04, 0x01, 0x00, 0x35, 0x00,
+    0x0F, 0x7D, 0x76, 0x00, 0x04, 0x01, 0x00, 0x35, 0x00,
+    0x0F, 0x7D, 0x76, 0x00, 0x04, 0x01, 0x00, 0x35, 0x00,
@@ -0,0 +1,18 @@
+/* Эталон трассы: turn.  Снят record_golden.py — не править руками.
+ * Поля кадра: frame, x, y, dir, col, row, action, seq_lo, seq_hi. */
+    0x2D, 0x7A, 0x76, 0xFF, 0x04, 0x01, 0x07, 0xD1, 0x01,
+    0x2E, 0x79, 0x76, 0xFF, 0x04, 0x01, 0x07, 0xD4, 0x01,
+    0x2F, 0x77, 0x76, 0xFF, 0x04, 0x01, 0x07, 0xD7, 0x01,
+    0x30, 0x78, 0x76, 0xFF, 0x04, 0x01, 0x07, 0xDA, 0x01,
+    0x01, 0x79, 0x76, 0xFF, 0x04, 0x01, 0x01, 0x08, 0x00,
+    0x02, 0x79, 0x76, 0xFF, 0x04, 0x01, 0x01, 0x09, 0x00,
+    0x03, 0x79, 0x76, 0xFF, 0x04, 0x01, 0x01, 0x0A, 0x00,
+    0x04, 0x79, 0x76, 0xFF, 0x04, 0x01, 0x01, 0x0B, 0x00,
+    0x05, 0x71, 0x76, 0xFF, 0x03, 0x01, 0x01, 0x0E, 0x00,
+    0x06, 0x6E, 0x76, 0xFF, 0x03, 0x01, 0x01, 0x11, 0x00,
+    0x07, 0x6B, 0x76, 0xFF, 0x03, 0x01, 0x01, 0x14, 0x00,
+    0x08, 0x66, 0x76, 0xFF, 0x03, 0x01, 0x01, 0x17, 0x00,
+    0x09, 0x65, 0x76, 0xFF, 0x02, 0x01, 0x01, 0x1C, 0x00,
+    0x0A, 0x63, 0x76, 0xFF, 0x02, 0x01, 0x01, 0x1F, 0x00,
+    0x0B, 0x5F, 0x76, 0xFF, 0x02, 0x01, 0x01, 0x22, 0x00,
+    0x0C, 0x5A, 0x76, 0xFF, 0x02, 0x01, 0x01, 0x25, 0x00,
@@ -0,0 +1,18 @@
+/*
+ * kidblob.h — таблицы анимации Кида в памяти теста.
+ *
+ * KID_BLOB_ADDR обязан совпадать с KD_DATA_OFF из pop_kid.c: продукт
+ * адресует таблицы именно так, и в этом весь смысл — под тестом работает
+ * тот же код доступа, что на устройстве, просто без маппинга W0.
+ */
+#ifndef POP_TESTS_KIDBLOB_H
+#define POP_TESTS_KIDBLOB_H
+
+#define KID_BLOB_ADDR 0x0100
+
+extern const unsigned char kid_blob[];
+extern const unsigned int  kid_blob_size;
+
+void kid_blob_install(void);
+
+#endif
@@ -0,0 +1,72 @@
+#!/usr/bin/env python3
+"""
+record_golden.py — снять эталонные трассы для t_phys.
+
+Зачем скрипт, а не один прогон.  Отчёт tcheck ограничен 768 байтами лога, а
+трасс на все сценарии сильно больше.  Поэтому набор умеет снимать РОВНО
+ОДИН сценарий за прогон (-DSC_RECORD=<n>), а перебор делает этот скрипт:
+собирает набор N раз, каждый раз забирает из отчёта имя сценария и его
+трассу и пишет golden/<имя>.h.
+
+Эталон фиксирует ТЕКУЩЕЕ поведение.  Это осознанно: набор страхует
+поведение-сохраняющие правки (перенос физики Kid -> Char), а не доказывает
+правильность.  Правильность — сверка с SDLPoP.  Поэтому переснимать эталоны
+можно только вместе с внятным объяснением, что и почему поменялось.
+
+Использование:
+    python3 record_golden.py            # снять все сценарии
+    python3 record_golden.py 7 9        # только эти номера
+"""
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+GOLDEN = HERE / "golden"
+# Число сценариев = число TC_RUN в t_phys.c: список ведётся там, здесь его
+# дублировать незачем.
+NSCEN = len(re.findall(r"^\s*TC_RUN\(", (HERE / "t_phys.c").read_text(), re.M))
+
+
+def record(n: int) -> str:
+    # make не видит смены -DSC_RECORD (в зависимостях только файлы), поэтому
+    # объектник набора сносим руками — иначе следующий прогон молча снимет
+    # трассу предыдущего сценария под новым именем.
+    for f in ("phys.rel", "phys.ihx"):
+        (HERE / "build" / f).unlink(missing_ok=True)
+    subprocess.run(["make", "-s", "build/phys.ihx", f"EXTRA_CFLAGS=-DSC_RECORD={n}"],
+                   cwd=HERE, check=True)
+    p = subprocess.run(["make", "-s", "run-phys", f"EXTRA_CFLAGS=-DSC_RECORD={n}"],
+                       cwd=HERE, capture_output=True, text=True)
+    out = p.stdout
+    m = re.search(r"^\s*### (\S+)\s*$", out, re.M)
+    if not m:
+        raise SystemExit(f"сценарий {n}: в отчёте нет строки '### имя'\n{out}")
+    name = m.group(1)
+    rows = re.findall(r"^\s*([0-9A-F]{18})\s*$", out, re.M)
+    if not rows:
+        raise SystemExit(f"сценарий {n} ({name}): трасса пустая\n{out}")
+
+    lines = [f"/* Эталон трассы: {name}.  Снят record_golden.py — не править руками.",
+             " * Поля кадра: frame, x, y, dir, col, row, action, seq_lo, seq_hi. */"]
+    for r in rows:
+        lines.append("    " + ", ".join(f"0x{r[i:i+2]}" for i in range(0, 18, 2)) + ",")
+    GOLDEN.mkdir(exist_ok=True)
+    (GOLDEN / f"{name}.h").write_text("\n".join(lines) + "\n")
+    return f"{name}: {len(rows)} кадров"
+
+
+def main() -> int:
+    nums = [int(a) for a in sys.argv[1:]] or list(range(1, NSCEN + 1))
+    for n in nums:
+        print(f"[{n}/{NSCEN}] " + record(n))
+    # Итоговая пересборка в обычном режиме, чтобы каталог не остался с
+    # объектниками, собранными под SC_RECORD.
+    subprocess.run(["make", "-s", "clean"], cwd=HERE, check=True)
+    print("эталоны сняты; проверить: make -C", HERE.name, "t_phys")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
@@ -0,0 +1,207 @@
+/*
+ * scene.c — реализация покадрового раннера (см. scene.h).
+ */
+#include <stdint.h>
+#include <kbd_raw.h>
+
+#include "tcheck.h"
+#include "pop_kid.h"
+#include "pop_map.h"
+#include "pop_ctrl.h"
+#include "pop_geom.h"
+#include "pop_guard.h"
+#include "kid_data.h"
+#include "scene.h"
+#include "stubs.h"
+#include "kidblob.h"
+
+sc_rec  sc_trace[SC_TRACE_MAX];
+uint8_t sc_len;
+
+static uint8_t sc_fg[30];
+/* Соседей у сцены нет (links = 0) — по краям комнаты стена: карта сама
+ * решает так, когда соседняя комната не задана. */
+
+void sc_init(void)
+{
+    kid_blob_install();                 /* таблицы туда, куда смотрит pop_kid */
+    pop_kid_data_load("KID\\KID_DATA.BIN");
+    pop_kid_hp_newgame();
+}
+
+void sc_room(const uint8_t *fg, uint8_t room)
+{
+    uint8_t i;
+    for (i = 0; i < 30; i++) { sc_fg[i] = fg[i]; tk_modif[i] = 0; }
+    pop_map_set(sc_fg);
+    pop_map_set_room(room);
+    /* Изолированная сцена: соседей нет.  Тип TILE_WALL (20) с обеих сторон
+     * и сверху/снизу — тогда решения физики зависят только от sc_fg, и
+     * трасса не поедет, если когда-нибудь поменяется загрузка кромок. */
+    pop_map_set_edges(0, 0, 0, 0);
+    tk_start_room = room;
+    tk_log_clear();
+}
+
+void sc_kid_at(uint8_t col, uint8_t row, int8_t dir)
+{
+    kid_init(2 /* seq_2_stand */, (int8_t)col, (int8_t)row, dir);
+    pop_kid_hp_reset();
+}
+
+void sc_kid_at_x(uint8_t col, uint8_t row, uint8_t x, int8_t dir)
+{
+    kid_init(2 /* seq_2_stand */, (int8_t)col, (int8_t)row, dir);
+    Kid.x = x;                  /* тайл задаёт ряд, X — фазу внутри тайла */
+    /* Колонку пересчитываем В ОКНЕ Char: determine_col — часть физики, а та
+     * работает с активным персонажем (порт load_fram_det_col). */
+    pop_loadkid();
+    pop_determine_col();
+    pop_savekid();
+    pop_kid_hp_reset();
+}
+
+/* ---- слот Guard ------------------------------------------------------ */
+
+void sc_guard_at(uint8_t charid, uint8_t col, uint8_t row, int8_t dir, uint8_t hp)
+{
+    /* Поля — как в enter_guard (seg002:0112): X из колонки, Y с пола ряда. */
+    Guard.charid    = charid;
+    Guard.curr_col  = (int8_t)col;
+    Guard.curr_row  = (int8_t)row;
+    Guard.x         = (uint8_t)(pop_x_bump[col + FIRST_ONSCREEN_COLUMN] + TILE_SIZEX);
+    Guard.y         = (uint8_t)pop_y_land[row + 1];
+    Guard.direction = dir;
+    Guard.alive     = -1;
+    Guard.action    = 1;                    /* actions_1_run_jump */
+    Guard.sword     = 2;                    /* у живого стража меч в руке */
+    Guard.fall_x    = Guard.fall_y = 0;
+    Guard.repeat    = 0;
+    Guard.room      = 1;
+    guardhp_max = guardhp_curr = hp;
+    guardhp_delta = 0;
+    /* Стойка с мечом (seq_77 у неактивного стража — но нам нужна поза, из
+     * которой персонаж просто стоит и может упасть). */
+    pop_loadshad();
+    pop_char_set_seq(77 /* seq_77_guard_stand_inactive */);
+    play_seq();
+    pop_saveshad();
+}
+
+void sc_guard_run(uint8_t n)
+{
+    uint8_t i;
+    for (i = 0; i < n; i++) {
+        /* play_guard_frame (seg000:1246) без ИИ: окно, кадр, seq, физика. */
+        pop_loadshad_and_opp();
+        pop_load_fram_det_col();
+        play_seq();
+        pop_saveshad_and_opp();
+        pop_guard_phys_tick();
+    }
+}
+
+void sc_trace_clear(void) { sc_len = 0; }
+
+static void sc_record(void)
+{
+    sc_rec *r;
+    if (sc_len >= SC_TRACE_MAX) return;
+    r = &sc_trace[sc_len++];
+    r->frame  = Kid.frame;
+    r->x      = Kid.x;
+    r->y      = Kid.y;
+    r->dir    = Kid.direction;
+    r->col    = Kid.curr_col;
+    r->row    = Kid.curr_row;
+    r->action = Kid.action;
+    r->seq    = (uint16_t)(Kid.curr_seq - SEQTBL_BASE);
+}
+
+uint8_t sc_run(uint8_t keys, uint8_t n)
+{
+    uint8_t i, done = 0;
+    for (i = 0; i < n; i++) {
+        tk_keys_clear();
+        if (keys & SC_L)     tk_key_down(KBD_LEFT);
+        if (keys & SC_R)     tk_key_down(KBD_RIGHT);
+        if (keys & SC_U)     tk_key_down(KBD_UP);
+        if (keys & SC_D)     tk_key_down(KBD_DOWN);
+        if (keys & SC_SHIFT) tk_key_down(KBD_LSHIFT);
+
+        /* Порядок ровно как в главном цикле roomtest.c (kid_heal и
+         * отрисовка выпадают — они ничего не решают).  pop_loose_tick
+         * оставлен: он не рисование, а МЕХАНИКА — досчитывает тряску и
+         * убирает провалившуюся плиту из карты, то есть меняет то, по чему
+         * физика в следующем кадре принимает решения. */
+        pop_ctrl_tick();
+        kid_tick();
+        pop_phys_tick();
+        pop_loose_tick();
+
+        sc_record();
+        done++;
+        if (sc_len >= SC_TRACE_MAX) break;
+    }
+    return done;
+}
+
+/* ---- сверка с эталоном ---------------------------------------------- */
+
+void sc_expect(const uint8_t *golden, uint8_t nrec)
+{
+    uint8_t i;
+    const uint8_t *g = golden;
+    tc_check((int16_t)sc_len, (int16_t)nrec, "sc_len", __LINE__);
+    for (i = 0; i < nrec && i < sc_len; i++, g += SC_REC_BYTES) {
+        const sc_rec *r = &sc_trace[i];
+        /* Номер кадра идёт первым полем каждой проверки: в отчёте видно,
+         * на каком именно кадре трасса разошлась. */
+        tc_check((int16_t)r->frame,  (int16_t)g[0], "frame",  i);
+        tc_check((int16_t)r->x,      (int16_t)g[1], "x",      i);
+        tc_check((int16_t)r->y,      (int16_t)g[2], "y",      i);
+        tc_check((int16_t)r->dir,    (int16_t)(int8_t)g[3], "dir", i);
+        tc_check((int16_t)r->col,    (int16_t)(int8_t)g[4], "col", i);
+        tc_check((int16_t)r->row,    (int16_t)(int8_t)g[5], "row", i);
+        tc_check((int16_t)r->action, (int16_t)g[6], "action", i);
+        tc_check((int16_t)r->seq,
+                 (int16_t)((uint16_t)g[7] | ((uint16_t)g[8] << 8)), "seq", i);
+    }
+}
+
+/* ---- снятие эталона -------------------------------------------------- */
+
+static void put(char c)
+{
+    if (tc_result.logn < TC_LOGSZ) tc_result.log[tc_result.logn++] = (uint8_t)c;
+}
+
+static void put_byte(uint8_t v)
+{
+    static const char hex[] = "0123456789ABCDEF";
+    put(hex[v >> 4]); put(hex[v & 15]);
+}
+
+void sc_dump(const char *name)
+{
+    uint8_t i;
+    tc_result.magic = TC_MAGIC;
+    tc_result.total = 1;
+    tc_result.failed = 1;          /* иначе раннер лог не напечатает */
+    put('#'); put('#'); put('#'); put(' ');
+    while (*name) put(*name++);
+    put('\n');
+    for (i = 0; i < sc_len; i++) {
+        const sc_rec *r = &sc_trace[i];
+        put_byte(r->frame);
+        put_byte(r->x);
+        put_byte(r->y);
+        put_byte((uint8_t)r->dir);
+        put_byte((uint8_t)r->col);
+        put_byte((uint8_t)r->row);
+        put_byte(r->action);
+        put_byte((uint8_t)r->seq);
+        put_byte((uint8_t)(r->seq >> 8));
+        put('\n');
+    }
+}
@@ -0,0 +1,102 @@
+/*
+ * scene.h — покадровый сценарный раннер для тестов физики Кида.
+ *
+ * Почему покадровый, а не «вызвать функцию и сверить возврат».  Порт
+ * seg005/seg006 — это конечный автомат: диспетчер выбирает
+ * последовательность, интерпретатор проигрывает её кадр за кадром, физика
+ * между кадрами двигает персонажа и решает, не пора ли падать.  Ошибка
+ * почти всегда проявляется не в одной функции, а в РАСХОЖДЕНИИ ТРАЕКТОРИИ
+ * через несколько кадров.  Плюс главный риск ближайшего рефакторинга
+ * (Kid -> Char) — не арифметика, а то, КТО владеет окном Char внутри кадра;
+ * поймать это можно только прогоном полного кадра, как в главном цикле:
+ *
+ *     pop_ctrl_tick();   // ввод -> control(): смена последовательности
+ *     kid_tick();        // play_seq: следующий кадр
+ *     pop_phys_tick();   // падение/приземление/стена
+ *
+ * Отсюда формат: сцена (комната + стартовая поза) + скрипт ввода, на
+ * выходе — трасса состояния Кида по кадрам.  Сравнение трассы с эталоном
+ * и есть тест.
+ */
+#ifndef POP_TESTS_SCENE_H
+#define POP_TESTS_SCENE_H
+
+#include <stdint.h>
+
+/* Одна запись трассы: то, чем оперируют решения движка.  curr_seq —
+ * СМЕЩЕНИЕ от SEQTBL_BASE (адрес зависит от базы, смещение — нет). */
+typedef struct {
+    uint8_t frame;
+    uint8_t x, y;
+    int8_t  dir;
+    int8_t  col, row;
+    uint8_t action;
+    uint16_t seq;
+} sc_rec;
+
+#define SC_TRACE_MAX 48
+extern sc_rec  sc_trace[SC_TRACE_MAX];
+extern uint8_t sc_len;
+
+/* Кнопки скрипта ввода — битовая маска на кадр. */
+#define SC_L     0x01
+#define SC_R     0x02
+#define SC_U     0x04
+#define SC_D     0x08
+#define SC_SHIFT 0x10
+
+/* Инициализация окружения набора: таблицы анимации, обнуление состояния.
+ * Звать один раз в начале прогона. */
+void sc_init(void);
+
+/* Задать комнату: fg[30] — коды тайлов по рядам (row*10+col), room —
+ * номер (нужен trob'ам).  Модификаторы обнуляются; ставить их тест может
+ * сам через tk_modif.  Соседи комнаты — стены (изолированная сцена). */
+void sc_room(const uint8_t *fg, uint8_t room);
+
+/* Поставить Кида: колонка/ряд задают позицию по центру тайла, как это
+ * делает do_startpos (seg003) — так сцена описывается в терминах карты, а
+ * не в пикселях. */
+void sc_kid_at(uint8_t col, uint8_t row, int8_t dir);
+
+/* То же, но с точным X: тайл задаёт ряд и пол под ногами, X — фазу внутри
+ * тайла (нужно, когда исход зависит от того, где именно Кид стоит). */
+void sc_kid_at_x(uint8_t col, uint8_t row, uint8_t x, int8_t dir);
+
+/* ---- Персонажи слота Guard (страж/скелет/тень/визирь) ---------------- *
+ * Физика у них ОБЩАЯ с Кидом (одни функции над Char, разные окна), поэтому
+ * тестировать её надо на обоих слотах.  Поднимаем персонажа руками, как
+ * enter_guard (seg002:0112): данных уровня под тестом нет.
+ *   charid — CHARID_2_GUARD / CHARID_1_SHADOW / CHARID_4_SKELETON;
+ *   hp     — сколько HP выдать (guardhp_max = guardhp_curr = hp). */
+void sc_guard_at(uint8_t charid, uint8_t col, uint8_t row, int8_t dir, uint8_t hp);
+
+/* Прогнать n кадров ПЕРСОНАЖА СЛОТА GUARD — порт play_guard_frame без ИИ:
+ * окно loadshad → load_fram_det_col → play_seq → saveshad, затем
+ * pop_guard_phys_tick().  ИИ (guards.c, банк 1) в набор не линкуется: он
+ * решает «куда идти», а тут проверяется «что с ним делает физика». */
+void sc_guard_run(uint8_t n);
+
+/* Прогнать n кадров с ЗАЖАТОЙ маской keys, записывая трассу.
+ * Возвращает число записанных кадров (обрезается по SC_TRACE_MAX). */
+uint8_t sc_run(uint8_t keys, uint8_t n);
+
+/* Сбросить трассу (перед новым сценарием). */
+void sc_trace_clear(void);
+
+/* Сверить трассу с эталоном: golden — плоский массив по 8 байт на кадр
+ * (frame,x,y,dir,col,row,action,seq_lo,seq_hi — 9), nrec записей.
+ * Расхождения уходят в отчёт tcheck с номером кадра и поля. */
+void sc_expect(const uint8_t *golden, uint8_t nrec);
+
+#define SC_REC_BYTES 9
+
+/* Снятие эталона.  Лог tcheck всего 768 байт — на все сценарии сразу трасс
+ * не хватит, поэтому за прогон снимается РОВНО ОДИН сценарий (его номер
+ * задаёт -DSC_RECORD=<n>), а перебором занимается record_golden.py.
+ * Формат: строка «### имя», дальше по строке на кадр, по два хекс-символа
+ * на байт.  Раннер печатает лог только при провале — sc_dump ставит
+ * failed=1 намеренно. */
+void sc_dump(const char *name);
+
+#endif
--- a/Show More
+++ b/Show More