Тень закрыта: прогон на уровнях 4/5/6/12, расхождение по кайме в impl_diff

Звук: подтверждён формат (8 бит моно) и замерен бюджет EMM
Формат оригинала проверен по convert_digi_sound: один байт на кадр (моно), байт беззнаковый с центром 0x80 — ровно формат нашего CBL. Стерео в данных нет, каналы размножаются на выходе. Живой замер памяти из работающей программы: занято 124 страницы из 256 (система с exe 43, наши ассеты 81), свободно 132 = 2,06 МБ. Самый крупный ассет теперь набор Тени — 32 страницы. Эффекты WAV займут 8.
2026-08-20 12:33:46 +03:00 · 2026-08-20 12:25:31 +03:00 · 2026-08-20 12:10:04 +03:00 · 2026-08-20 11:57:19 +03:00 · 2026-08-20 11:53:02 +03:00 · 2026-08-20 11:35:09 +03:00
60 changed files with 2377 additions and 48 deletions
@@ -0,0 +1,603 @@
+# Фиксированный логический кадр — разбор перед реализацией
+
+Дата разбора: 2026-08-19.  Отправная точка — тег `0.0.1-prealpha`.
+Статус: **АНАЛИЗ, кода не трогали.**
+
+Задача пользователя: перевести логический кадр на фиксированный размер,
+не зависящий от длительности синей/зелёной/циан фаз.  Инструмент —
+`gfx_set_fps_div`, режимы FASTEST / FAST / NORMAL.
+
+
+## 1. Что на самом деле меняется
+
+Сейчас главный цикл (`roomtest.c`) после отрисовки ждёт **три**
+`gfx_wait_vsync()` подряд.  Каждый ждёт ближайший фронт луча, поэтому
+период логического кадра равен
+
+    период = ceil(W) + 2 растровых кадра,   W = работа в растрах
+
+Первое ожидание доедает хвост текущего растра, два следующих — целые
+растры.  Отсюда наблюдаемое: `W <= 1` → период 3; `W = 1.1` → период
+уже 4.  То есть **реальный бюджет логического кадра сегодня — один
+растр (430 080 тактов)**, всё сверх него стоит целого лишнего растра.
+
+Нужное поведение:
+
+    период = max(n, ceil(W))
+
+При `n = 3` бюджет становится **1 290 240 тактов** — втрое больше.
+Замеренный максимум работы на 13/23 (911 862) укладывается туда с
+запасом, а 11/15 (437 484 лёгкая / ~603 000 тяжёлая позиция) — вдвойне.
+
+Это главный выигрыш, и он не про скорость игры, а про **исчезновение
+скачков**: сегодня превышение растра на один такт стоит +33 % к периоду.
+
+
+## 2. Три режима и их привязка к оригиналу
+
+Растровый кадр Sprinter: 320 строк × 896 пикселей при 14 МГц =
+**20,48 мс** (48,83 Гц).  В тактах CPU (21 МГц) — **430 080**;
+замерено на холостом DSS: 430 131 на прерывание.
+
+Оригинал (`SDLPoP/src/seg003.c:363`): `BASE_FPS = 60`,
+`base_speed = 5` тика = **83,3 мс**, `fight_speed = 6` = **100 мс**.
+
+| режим | обычно | в бою | мс обычно | мс в бою | к оригиналу |
+|---|---:|---:|---:|---:|---|
+| FASTEST | 3 | 3 | 61,4 | 61,4 | +36 % скорости |
+| FAST | 3 | 4 | 61,4 | 81,9 | +36 % / точно |
+| NORMAL | 4 | 5 | 81,9 | 102,4 | точно (83,3 / 100) |
+
+NORMAL воспроизводит оригинал с точностью 1,7 % и 2,4 % — расхождение
+только из-за 48,83 Гц против 60 Гц, целыми делителями точнее не выйдет.
+
+**Условие «бой» берём у оригинала буквально** — оно проще, чем кажется:
+
+```c
+if (Kid.sword == sword_2_drawn)  set_timer_length(timer_1, fight_speed);
+else                             set_timer_length(timer_1, base_speed);
+```
+
+Это не «идёт бой» и не «есть страж рядом», а **только «у Кида вынут
+меч»**, и проверяется в самом верху главного цикла, до `play_frame()`.
+У нас поле есть (`Kid.sword`, `SWORD_2_DRAWN` — `guards.c`), так что
+переключение — одна строка в том же месте цикла.
+
+Это закрывает и давнюю задачу **L1-SPEED** (`TASKS_OPEN.md`): сейчас мы
+идём на 60 мс вместо 83,3 — примерно на 39 % быстрее эталона.
+
+
+## 3. Как устроен темп сейчас и что мешает
+
+`gfx_wait_vsync()` имеет две ветки (`libbgi/common/gfx_wait_vsync.c`):
+
+- **`_gfx_fps_div <= 1`** — лучевой поллинг бита 5 порта `0xFE` в тесном
+  цикле, и в этом цикле зовётся **idle-хук** (`gfx_set_idle_hook`).
+  roomtest вешает туда `kbd_raw_poll` — это единственное, что делает
+  клавиатуру работоспособной (задача KBD-1: приёмный FIFO SIO 3 байта,
+  импульс запроса прерывания живёт 32 такта и теряется в DI-окнах
+  акселератора; лечится только плотным опросом раз в ~0,5 мс).
+- **`_gfx_fps_div >= 2`** — счётчиковый путь: ждёт, пока фоновый ISR
+  (`_gfx_frame_isr`, слот кадровой цепочки) насчитает `n` фронтов, а
+  ожидание реализовано через **`ei; halt`**.
+
+**И вот здесь блокер.** На счётчиковом пути idle-хук не зовётся вообще.
+Включив `gfx_set_fps_div(3)` как есть, мы немедленно возвращаем KBD-1:
+теряются нажатия при зажатом Shift, залипают клавиши. Это не мелочь и
+не «потом поправим» — это единственная причина, по которой клавиатура
+сейчас вообще работает.
+
+
+## 4. Что измерено (MAME, 2026-08-19)
+
+### Метод и его границы
+
+Прерывания считались брейкпоинтами на резидентных адресах трамплина
+(`_irq_tramp` = 0x88B4, ветка кадрового пути `tr_frame` = 0x8995).
+
+**Счёт попаданий брейкпоинтом на этом драйвере недостоверен**: sprinter
+дёргает `Z80_INPUT_LINE_WAIT` (`do_mem_wait`), инструкция пересчитывается,
+и один и тот же PC срабатывает по нескольку раз.  Наблюдалось
+«попаданий больше, чем растровых кадров» и «попаданий в `tr_frame`
+больше, чем входов в трамплин» — логически невозможные результаты.
+
+Достоверен только **детектор разрыва**: брейкпоинт на следующей
+инструкции пишет `temp3 = totalcycles`, брейкпоинт с условием
+`(totalcycles - temp3) > 0x9D800` (1,5 растра) останавливает машину.
+Дубли попаданий его не портят.  Все числа ниже — этим методом.
+
+Отдельная грабля: **литералы в отладчике MAME шестнадцатеричные**.
+Первый прогон с порогом «700000» на деле проверял 0x700000 = 17 растров
+и не срабатывал никогда.
+
+### Факты
+
+1. **Холостой DSS** — 799 прерываний на 343 674 880 тактов = 430 131 на
+   прерывание.  Подтверждает константу растра и что потерь нет, когда
+   нечего рисовать.
+
+2. **11/15, покой (чомпер + два факела + страж)** — потери ЕСТЬ:
+   разрыв ровно 860 129 тактов = два растра = одно потерянное
+   прерывание.  Частота в «плохой» фазе: 12 потерь на 427 растровых
+   кадров = **2,8 %**; повтор — 12 на 495 (2,4 %) при бегущем Киде.
+
+3. **Та же сцена после сдвига Кида** (`]`/`[`, попиксельно) —
+   **0 потерь на 3919 кадров**, и после возврата обратно **0 на 4010**.
+
+4. **Полная перерисовка комнаты** (переход/`+`) — разрыв 1 720 289 =
+   ровно четыре растра = **три потерянных прерывания подряд**.
+
+5. **13/23** — ни в покое, ни при беге потерь не поймано; на смене
+   комнаты — поймано.
+
+6. **Клавиатура ни при чём**: с удержанной клавишей 3,1 %, без неё
+   2,8 % — в пределах разброса.
+
+### Как это читать
+
+Пункты 2 и 3 вместе — самое важное. Одна и та же сцена даёт то 2,8 %,
+то ноль. Значит потеря определяется **не нагрузкой, а фазой**: попадает
+ли момент кадрового прерывания внутрь DI-окна блита.
+
+Механизм подтверждён исходником MAME (`sprinter.cpp`):
+
+- `irq_on` поднимает линию и заводит `irq_off_timer` на **32 такта
+  неразогнанного клока (3,5 МГц) = 9,14 мкс**; `irq_off` гасит.  Ядро
+  z80 в MAME уровневое (`m_irq_state` без защёлки) — импульс, пришедший
+  под `di`, теряется НАСОВСЕМ.  Это же поведение у настоящего Spectrum
+  (INT 32 такта), так что это не эмуляторный артефакт.
+- DI-окно у нас — один вызов `_bgi_blit_rows_raw`, а он по контракту
+  режется вызывающим на **чанки ≤16 строк** (≈6 200 тактов ≈ 0,29 мс).
+  То есть DI-окна короткие и с промежутками, отсюда и «то теряем, то
+  нет»: всё решает, куда попал 9-микросекундный импульс.
+- `irqack_cb` гасит **все три** входа мержера (экран/клавиатура/CBL)
+  одним подтверждением.  Плюс трамплин обслуживает за вход ровно один
+  источник и делает приватный RETI. Значит кадровое прерывание может
+  быть съедено клавиатурной веткой или (в будущем) CBL-веткой.
+
+**Вывод по фазе.** Наш период сейчас 3 растра, но иногда 4 — и каждый
+такой случай сдвигает фазу рендера относительно луча. Отсюда «полосы»:
+десятки секунд без потерь, потом полоса с потерями. При жёстком
+пейсинге период станет РОВНО n, фаза перестанет плавать — и сцена может
+**залипнуть в плохой фазе надолго**. Это хуже случайных 3 %: систематическая
+потеря по прерыванию на кадр превратит логический кадр из 3 растров в 4,
+то есть даст ровные −25 % скорости, которые никак не проявятся в
+профиле тактов.
+
+
+## 5. Проблемы по убыванию риска
+
+| # | проблема | риск |
+|---|---|---|
+| P1 | счётчиковый путь ждёт через `halt` → idle-хук не зовётся → возврат KBD-1 (потеря нажатий, залипание клавиш) | блокер |
+| P2 | счётчик кадров теряет тики (фазозависимо, 0…3 %), при жёстком пейсинге может залипнуть в плохой фазе → ровный минус скорости | высокий |
+| P3 | полноэкранная перерисовка (вход в комнату, старт уровня) теряет 3+ тика подряд → счётчик недосчитает, ожидание растянется сильнее самой работы | средний |
+| P4 | звук через CBL (`_irq_cbl_hook`, реальный ISR в трамплине): (а) ещё один источник, крадущий кадровые тики приватным RETI; (б) обратно — любое подтверждение гасит ожидающий запрос CBL → underrun (счётчик `cbl_underruns()` уже есть); (в) ISR длинный (полный сейв обоих наборов + вызов в приложение) | средний, растёт |
+| P5 | второй call-site `gfx_wait_vsync()` — ветка `frozen` (`roomtest.c:320`) ждёт один фронт; под делителем её смысл меняется | низкий |
+| P6 | `IRQ_CHAIN_MAX = 4`; делитель занимает слот, звук — свой; запас есть, но конечный | низкий |
+| P7 | бит 5 порта `0xFE` доступен только при включённом `cbl_mode`; сейчас его лениво занимает сам `gfx_wait_vsync` через `_cbl_port_ref`, при открытии реального звука владение переходит к CBL — переход уже спроектирован, но его надо проверить в связке | низкий |
+
+Отдельно, не проблема а рычаг: по сообщению разработчиков
+(IvanMak.txt:846–848) **новая прошивка позволяет акселератору работать с
+EI** — по приходу прерывания он отключается, по `RETI` включается.
+Если это подтвердится на железе и моделируется в MAME, P2 исчезает
+полностью. Проверять отдельно; строить на этом нельзя (неизвестно, какая
+прошивка у пользователя).
+
+
+## 6. Варианты реализации
+
+### A. Включить `gfx_set_fps_div(3)` как есть
+Отвергается: P1 (убивает клавиатуру) — сразу, без вариантов.
+
+### B. Свой `wait` в приложении: счётчик только на рендер, ожидание — лучом
+Счётчик кадровых прерываний отвечает на один вопрос — «сколько фронтов
+съел рендер», а само ожидание идёт **существующим лучевым поллингом с
+idle-хуком**, то есть клавиатура работает ровно как сегодня.
+
+```
+k = tick - tick_at_frame_start;      /* фронтов съел рендер */
+if (k >= n) k = n - 1;               /* опоздали — ждём хотя бы один */
+повторить (n - k) раз: ждать фронт луча (поллинг + idle-хук)
+tick_at_frame_start = tick;          /* якорь на фактическом фронте */
+```
+
+Плюсы: минимальная правка, клавиатура нетронута, фаза переякоривается
+каждый кадр (ошибка не копится).  Минус: остаётся P2 — при залипании в
+плохой фазе `k` систематически занижен на 1, и кадр ровно на растр
+длиннее. Профилем это не видно.
+
+### C. Программный счётчик кадров по лучу (без прерываний вообще)
+Считать фронты **выборкой бита 5 в точках, которые мы и так проходим**.
+Окно бланка (строки 272…319) длится **3,07 мс**, максимальное DI-окно —
+0,29 мс, значит достаточно опрашивать чаще, чем раз в 3 мс.
+
+Точки выборки: `pop_blit_b` (наша обёртка, зовётся на каждый блит —
+в фазах рисования это плотнее 0,3 мс) плюс несколько точек в синей фазе
+(она 149 106 тактов ≈ 6,9 мс без единого блита, нужно 3-4 точки).
+
+Цена: `in a,(0xFE)` + проверка бита + дедуп фронта ≈ 40-50 тактов; при
+~50 выборках это 2 500 тактов = 0,6 % растра.
+
+Плюсы: **точно, и точность не зависит ни от DI, ни от звука, ни от
+клавиатуры** — снимает P2, P3, P4(а) разом.  Минус: заводит инвариант
+«между выборками не больше 3 мс», который легко нарушить будущей правкой.
+Инвариант проверяем в MAME тем же детектором разрыва.
+
+### D. CTC как источник кадра
+`irq_ctc_install` уже есть (каналы 2+3, вектор 0x06, отдельный от 0xFF).
+Запрос CTC **защёлкивается** (daisy chain — в `_irq.h` прямо записано,
+что без `RETI` следующего прерывания не будет), поэтому под `di` он не
+теряется, а откладывается.  Пресет 112 × 160 даёт ровно период кадра
+без дрейфа (обе частоты — от одного X_SP).
+
+Блокер: `irq_ctc_install` вектрится напрямую и требует кода в W2 →
+сейчас только tiny/big, а roomtest — **huge**.  Нужна W2-копия
+CTC-трамплина (в дизайн-доке помечена как follow-up).  Плюс защёлка
+хранит только ОДИН отложенный запрос — на полноэкранной перерисовке
+(P3) всё равно недосчитает.
+
+### Рекомендация
+
+**B как первый шаг, C — как способ закрыть P2**, и оба под одним
+интерфейсом: приложение зовёт свой `pop_wait_logical_frame(n)`, а чем
+внутри считаются кадры — деталь реализации.  Тогда B→C не трогает ни
+главный цикл, ни режимы.
+
+D не нужен, пока C справляется, и требует работы в libc (W2-копия
+CTC-трамплина) ради того же результата.
+
+
+## 7. Порядок работ с критериями приёмки
+
+**Ш0. Инструмент.** Скрипт замера потерь кадровых прерываний (детектор
+разрыва) — зафиксировать как повторяемую процедуру, он понадобится на
+каждом шаге.  Критерий: воспроизводит числа §4 на 11/15 и на смене комнаты.
+
+**Ш1. Свой `wait` (вариант B), делитель ещё не включён.**  Вынести
+хвост главного цикла в `pop_wait_logical_frame(n)`, поведение при n=3
+должно быть **бит-в-бит прежним** (три фронта после работы).  Критерий:
+такты по фазам и распределение периода не изменились, клавиатура
+работает.
+
+**Ш2. Счётчик кадров.**  Слот кадровой цепочки + `k = tick - anchor`.
+Критерий: в 11/15 период стал ровно 3 растра ВСЕГДА (сейчас 3/4/5), а
+на 13/23 — 3 вместо нынешних 3/4/5; клавиатура не деградировала
+(проверка Shift+стрелки по методике KBD-1, не «на глаз»).
+
+**Ш3. Режимы.**  `POP_SPEED_FASTEST/FAST/NORMAL` + условие боя
+`Kid.sword == SWORD_2_DRAWN` в верху цикла, как у оригинала.  Критерий:
+NORMAL секундомером совпадает с живым SDLPoP на одинаковом отрезке
+(методика из L1-SPEED — секундомер, не глазомер).
+
+**Ш4. Закрыть P2 (вариант C).**  Выборка луча в `pop_blit_b` и в синей
+фазе.  Критерий: детектор разрыва не ловит ни одного расхождения между
+программным счётчиком и лучом за 10 000 кадров, включая смену комнаты.
+
+**Ш5. Звук.**  Только после Ш4: открыть CBL и перемерить P4 —
+`cbl_underruns()` и потери кадровых тиков.
+
+## 8. Что проверить артефактом до начала
+
+1. Сколько именно фронтов съедает вход в комнату — от этого зависит,
+   нужен ли отдельный «resync» на тяжёлых переходах или хватит того,
+   что якорь переставляется каждый кадр.
+2. Ветка `frozen` (`roomtest.c:320`) — какой темп ей нужен под делителем.
+3. Проверить, что при n=4/5 бит 5 всё ещё единственный источник фронта
+   (то есть `_cbl_port_ref` держится всё это время).
+
+
+---
+
+# 9. Предлагаемый вариант подробно: программный счётчик кадров по лучу
+
+Дополнение от 2026-08-19 по запросу: как именно получается **точное**
+число пройденных кадровых интервалов.  Акселератор рассматриваем только
+в нынешнем виде — с DI/EI (режим «акселератор с EI» из новой прошивки
+из рассмотрения снят).
+
+## 9.1. Сигнал и его геометрия
+
+Единственный источник — **бит 5 порта `0xFE`**.  Точная семантика по
+исходнику MAME (`sprinter.cpp`, `kbd_fe_r`):
+
+```c
+data |= 0xe0;
+data ^= 0x40;
+if (cbl_mode()) {
+    data &= ~0xa0;                                   /* гасит биты 5 и 7 */
+    data |= (vpos >= BORDER_TOP + SCREEN_YSIZE) << 5;
+    data |= ... & 0x80;                              /* бит 7 — CBL */
+}
+```
+
+То есть **бит 5 = 1 ровно тогда, когда луч ниже картинки**
+(`vpos >= 16 + 256 = 272`), и это ЧТЕНИЕ ПОЛОЖЕНИЯ ЛУЧА, а не событие:
+ни прерывания, ни защёлки, ни очереди — его невозможно «потерять»,
+можно только не посмотреть.
+
+Важное следствие из той же строки: вне `cbl_mode` бит читается как 1
+всегда (его выставляет `data |= 0xe0` и уже ничто не гасит).  Поэтому
+счётчик обязан работать только при взведённом `_cbl_port_ref()` — том
+самом, который сейчас лениво взводит `gfx_wait_vsync`.
+
+Геометрия кадра (320 строк × 896 пикселей при 14 МГц):
+
+| | строк | мс | тактов CPU (21 МГц) |
+|---|---:|---:|---:|
+| бит 5 = 1 (нижний бланк) | 48 | 3,07 | **64 512** |
+| бит 5 = 0 (картинка + верхний бордер) | 272 | 17,41 | 365 568 |
+| кадр целиком | 320 | 20,48 | 430 080 |
+
+Границей кадра берём **фронт 1→0** — это `vpos = 0`, ровно то же
+событие, которого ждёт сегодняшний `gfx_wait_vsync`.  Значит момент
+свопа страниц не меняется: до начала картинки остаётся верхний бордер,
+16 строк ≈ 1 мс запаса, как и сейчас.
+
+## 9.2. Счётчик
+
+```c
+static uint8_t beam_prev;    /* бит 5 на прошлой выборке */
+static uint8_t frame_tick;   /* счётчик кадров, разностная арифметика */
+
+/* ~20 T-состояний тела + вызов; в тактах MAME ≈ 120 на выборку */
+void pop_beam_sample(void)
+{
+    uint8_t b = in_fe() & 0x20;
+    if (beam_prev && !b) frame_tick++;   /* фронт 1→0 = начало кадра */
+    beam_prev = b;
+}
+```
+
+Вся арифметика ожидания — разностная по модулю 256, wrap безопасен
+(тот же приём, что в существующем `_gfx_fps_state`).
+
+## 9.3. Почему счёт ТОЧНЫЙ (условие и запас)
+
+Утверждение: **если между соседними выборками проходит меньше 64 512
+тактов, то каждый фронт 1→0 будет засчитан ровно один раз.**
+
+Доказательство прямое.  Пусть максимальный зазор между выборками
+Δ < 64 512.  Окно «бит 5 = 1» длится 64 512 тактов, то есть длиннее Δ,
+значит в него попадает хотя бы одна выборка → `beam_prev` обязательно
+станет 1 внутри каждого бланка.  Окно «бит 5 = 0» длится 365 568 — тем
+более содержит выборку → сразу после бланка `beam_prev` перейдёт в 0 и
+даст ровно один инкремент.  Двойной счёт невозможен: инкремент
+происходит только на переходе 1→0, а `beam_prev` тут же обновляется.
+
+Условие ОДНО и оно про зазор, а не про нагрузку, не про DI, не про
+прерывания.  Отсюда все свойства варианта.
+
+**Какой запас по факту.**  Самый длинный неделимый кусок кода без
+возможности выборки — одно DI-окно акселератора, то есть один вызов
+`_bgi_blit_rows_raw`.  Он по контракту режется вызывающим на чанки
+**≤16 строк**; при ширине 32 это ≈ 6 200 тактов, при полной высоте
+спрайта 63 строки самый дорогой замеренный блит целиком — 32 073.
+Даже если мерить самым грубым образом (одна выборка на целый блит,
+а не на чанк), зазор вдвое меньше окна бланка.
+
+## 9.4. Где ставить выборки
+
+Правило простое: **выборка обязана стоять так, чтобы ни один путь
+исполнения не давал зазора длиннее 64 512 тактов.**  По фазам:
+
+- **Зелёная и циан** (436 494 и 382 770 тактов на 13/23) состоят из
+  блитов и хилов.  Достаточно одной выборки на вызов наших обёрток
+  `pop_blit_b`, `pop_heal_off`, `pop_heal_fast` — но НЕ только их:
+  прямые вызовы `gfx_blit_*` / `gfx_heal*` разбросаны по шести файлам
+  (`pop_cdraw.c`, `pop_draw.c`, `pop_kdraw.c`, `pop_room.c`,
+  `pop_state.c`, `pop_tile.c`).  Точный набор точек определяем НЕ
+  рассуждением, а замером (см. 9.7): ставим в обёртки, меряем худший
+  зазор, добавляем точки только там, где замер их требует.
+- **Синяя** (149 106 тактов) — блитов нет вообще, это 2,3 окна бланка.
+  Нужны явные точки: после ввода, после физики, после `pop_process_trobs`,
+  после mob-тика.  Ставятся на границах, которые и так размечены
+  зондами `pop_dbg_m*`.
+
+Чего заведомо НЕ хватит: выборок только в главном цикле.  Один
+`pop_floor_bake` — 179 914 тактов, почти три окна бланка.
+
+## 9.5. Ожидание — тот же примитив
+
+Ожидание фронта и есть плотная выборка, поэтому оно сливается со
+счётчиком, а опрос клавиатуры остаётся ровно таким же плотным, как
+сегодня:
+
+```c
+static void wait_edge(void)
+{
+    uint8_t t = frame_tick;
+    do {
+        pop_beam_sample();
+        kbd_raw_poll();          /* то, что сейчас висит idle-хуком */
+    } while (frame_tick == t);
+}
+```
+
+`gfx_set_idle_hook` при этом больше не нужен — опрос зовётся прямо.
+Обязателен аварийный выход по счётчику попыток (как в нынешнем
+`gfx_wait_vsync`): на железе, где бит ведёт себя иначе, цикл не должен
+виснуть насмерть.
+
+## 9.6. Пейсинг целиком
+
+```c
+uint8_t k = (uint8_t)(frame_tick - anchor);   /* фронтов съел рендер */
+if (k >= n) {
+    wait_edge();                  /* опоздали — выравниваемся на ближайший */
+} else {
+    do { wait_edge(); } while ((uint8_t)(frame_tick - anchor) < n);
+}
+anchor = frame_tick;              /* якорь по ФАКТУ, фаза не копится */
+flip_page();
+```
+
+`anchor = frame_tick`, а не `anchor += n` — сознательно: догонять
+пропущенное время нельзя, иначе после тяжёлого кадра игра рванёт
+вперёд.  Это же правило заложено в исходном дизайне делителя
+(«выравнивание на ближайший фронт, без накопления фазовой ошибки»).
+
+Поведение по случаям:
+
+| работа W (растров) | период | комментарий |
+|---|---|---|
+| W ≤ n | ровно n | цель задачи |
+| n < W ≤ n+1 | ceil(W) | подтормаживает ровно настолько, насколько не успели |
+| вход в комнату, W ≫ n | ceil(W) + 1 | ветка «опоздали»: один фронт, без растягивания |
+| загрузка уровня, файловые операции | ceil(W) + 1…n | выборок нет вовсе → k занижен; худшее — n лишних растров ОДИН раз |
+
+Последняя строка — единственный случай, где счёт неточен, и он
+безобиден: во время `ESTEX`-вызова выбирать нечего, а ошибка живёт один
+кадр, потому что якорь переставляется по факту.
+
+## 9.7. Как это доказывается, а не декларируется
+
+Инструмент уже построен и проверен на нынешнем коде (§4): брейкпоинт на
+следующей инструкции пишет `temp3 = totalcycles`, второй с условием
+`(totalcycles - temp3) > 0x9D800` останавливает машину.
+
+Для приёмки он ставится **на инструкцию инкремента `frame_tick`**.
+Если хоть один фронт пропущен, зазор между инкрементами станет два
+растра и детектор остановит машину.  Критерий: **10 000 кадров без
+единого срабатывания**, включая смену комнаты и смерть Кида.
+
+Дополнительно, в отладочной сборке — перекрёстная проверка со счётчиком
+кадровых прерываний (слот цепочки, один INC): прерывания теряются, луч
+не должен, значит `frame_tick` обязан идти НЕ МЕДЛЕННЕЕ `irq_tick`.
+Расхождение в другую сторону = пропущенная выборка.
+
+Напоминание о методике: **счёт попаданий брейкпоинтом на этом драйвере
+недостоверен** (WAIT-линия, инструкция пересчитывается) — только
+детектор разрыва.  И литералы в отладчике MAME шестнадцатеричные.
+
+## 9.8. Цена
+
+| статья | тактов |
+|---|---:|
+| одна выборка (с вызовом) | ≈ 120 |
+| ~60 выборок за логический кадр | ≈ 7 200 |
+| доля от бюджета при n=3 (1 290 240) | **0,6 %** |
+
+В горячих местах (`pop_blit_b`) выборку можно заинлайнить и снять цену
+вызова.
+
+## 9.9. Чем это лучше счётчика прерываний
+
+| | счётчик кадровых IRQ | счётчик по лучу |
+|---|---|---|
+| теряет тик под `di` акселератора | да, фазозависимо 0…3 % | нет — читается положение луча |
+| теряет тик, если IRQ съела клавиатурная/CBL-ветка трамплина | да (приватный RETI) | нет |
+| ломается от добавления звука | да (ещё один источник, `irqack` гасит все входы мержера) | нет |
+| поведение на полной перерисовке | 3 тика подряд мимо | считает все |
+| условие корректности | никакого — не в нашей власти | зазор выборок < 64 512 тактов, проверяется артефактом |
+| риск залипнуть в плохой фазе и ровно потерять 25 % скорости | есть | нет |
+
+## 9.10. Что осталось проверить зондами до кодирования
+
+1. **Худший зазор между выборками** при размещении «только в обёртках»
+   — сколько точек реально нужно добавить.  Это же число решает, нужна
+   ли выборка в синей фазе в четырёх местах или в двух.
+2. **Владение `cbl_mode`**: сейчас бит 5 доступен потому, что
+   `gfx_wait_vsync` взвёл `_cbl_port_ref()` при первом вызове.  Свой
+   ожидатель обязан взвести его сам — значит примитив логичнее держать
+   в libbgi (там доступен `_cbl_port_ref`), а не в приложении.
+3. **Ветка `frozen`** (`roomtest.c:320`) — какой темп ей нужен.
+4. Совпадает ли момент возврата `wait_edge()` с нынешним возвратом
+   `gfx_wait_vsync()` с точностью до микросекунд (иначе поедет момент
+   свопа и появятся разрывы картинки).
+
+
+---
+
+# 10. РЕЗУЛЬТАТ (2026-08-19, реализовано и проверено в MAME)
+
+Реализовано в приложении (`roomtest/pop_pace.c/.h`), в libbgi пока НИЧЕГО не
+переносили — по решению пользователя: сначала обкатать у себя.
+
+## 10.1. Что сделано
+
+- `pop_beam_sample()` — выборка бита 5 порта `0xFE`, 10 инструкций,
+  быстрый путь 46 T + вызов.  Модуль НЕ банковый, поэтому из банков
+  зовётся прямым `call` (проверено: банки так зовут `_pop_cd_hit_slot`).
+- `pop_wait_edge()` — ожидание одного фронта; внутри тот же
+  `kbd_raw_poll()`, что раньше висел idle-хуком.
+- `pop_pace_end(n)` — добрать до n фронтов от якоря; якорь ставится ПО
+  ФАКТУ.  Главный цикл: `pop_wait_edge()` → строб вспышки →
+  `pop_pace_end(n)` → своп страниц.
+- `pop_pace_arm()` — взводит `cbl_mode` через `gfx_wait_vsync()` и
+  ПРОВЕРЯЕТ, что фронты идут; если нет — `pace_ok = 0` и всё молча
+  откатывается на прежние `gfx_wait_vsync`.
+- Режимы FASTEST/FAST/NORMAL, клавиша **P** по кругу, дефолт FASTEST.
+  Условие боя — `Kid.sword == SWORD_2_DRAWN`, буквально как у оригинала.
+
+## 10.2. Где стоят выборки и как они выбраны
+
+Точки ставились **не на глаз, а по замеру**: детектор зазора между
+выборками (порог 64 512) останавливает машину, адрес возврата со стека
+называет виновника.  Пять итераций «замерил → закрыл дыру → перемерил»:
+
+| итерация | найденная дыра | тактов |
+|---|---|---:|
+| 1 | `kid_tick` + `pop_phys_tick` без выборок | 68 340 |
+| 1 | весь циан, когда оба персонажа «тихие» | 100 044 |
+| 2 | отрисовка персонажей идёт мимо `pop_blit_b` | 82 242 |
+| 2 | полоса HP: `pop_kid_img_blit` в цикле | 86 586 |
+| 3 | между двумя `pop_blit_b` — работа `pop_bg` | 75 000 |
+| 4 | сам блит и сам heal (выборка была только НА ВХОДЕ) | 71 900 |
+| 5 | `pop_loose_tick` | 73 990 |
+
+Итог: выборки в `pop_blit_b` (вход и перед каждым `gfx_w0_unmap`),
+`pop_heal_fast` (вход и выход), после каждого `gfx_set_bank(SPRITE)` в
+`pop_cdraw/pop_kdraw/pop_room`, в 16 потайловых функциях `pop_bg`, после
+зондов `pop_dbg_p1..p8` в физике и в 21 точке главного цикла.
+
+## 10.3. Замеры
+
+Метод точности счётчика — **атомарный снимок одной командой отладчика**:
+`printf "%d %d", totalcycles, b@<адрес pop_frame_tick>`.  Раздельные
+`lmem` и `print totalcycles` НЕ ГОДЯТСЯ: между двумя обращениями к мосту
+проходят десятки кадров, и «недосчёт» получается на ровном месте (на этом
+я сначала и обжёгся).
+
+| проверка | результат |
+|---|---|
+| счётчик, 11/15 покой, 5 окон | недосчёт **0** (270 растровых кадров) |
+| счётчик, 11/15 тяжёлая позиция Кида | недосчёт **0** |
+| счётчик, 13/23 | недосчёт **0** |
+| период кадра, 11/15 | **ровно 3 растра**: ни длиннее 3,1, ни короче 2,9 на 302 логических кадрах |
+| период кадра, 13/23 | **ровно 3 растра** на 308 логических (эталон был 3/4/5) |
+| режим NORMAL | ровно 4 растра |
+| NORMAL + `Kid.sword = 2` | ровно 5 растров |
+| клавиша P | 0 → 1 → 2 → 0 |
+| клавиатура | Кид отвечает на удержание и отпускание |
+
+**Цена выборок** — A/B прямо в памяти (заглушить `pop_beam_sample`
+байтом `C9` и снять `pace_ok`, чтобы игра не зависла в ожидании фронта):
+работа за кадр 543 860 с выборками против 539 832 без — **≈4 000 тактов,
+0,9 %**.  На фоне бюджета, который вырос втрое, это ничто.
+
+## 10.4. Грабли, стоившие времени
+
+1. **Литералы в отладчике MAME шестнадцатеричные.**  Порог «700000» на
+   деле проверял 0x700000 = 17 растров и не срабатывал никогда.
+2. **Счёт попаданий брейкпоинтом на этом драйвере недостоверен** (WAIT-
+   линия, инструкция пересчитывается): наблюдались «попаданий больше, чем
+   растровых кадров».  Достоверны только сравнения ВРЕМЁН.
+3. **Раздельные чтения через мост не атомарны** (см. 10.3).
+4. **Мёртвый Кид перезапускает уровень** раз в `RESPAWN_DELAY` тиков, а
+   рестарт уровня — это 3-5 растров без единой выборки.  Полдня я гонялся
+   за «дырой в статике», которой не было: Кид успел убежать в соседнюю
+   комнату и погибнуть, пока я мерил.  **Проверяй, что на экране, прежде
+   чем объяснять числа.**
+5. **`make LEVEL=13` без `make clean` не пересобирает** — флаги в
+   зависимостях не участвуют, на диск уезжает старый уровень.
+
+## 10.5. Что осталось
+
+- Перенос примитива в libbgi — по решению пользователя ПОСЛЕ обкатки.
+  Там же уместнее взводить `_cbl_port_ref` напрямую, без обходного
+  `gfx_wait_vsync()` в `pop_pace_arm`.
+- Загрузка уровня/комнаты остаётся без выборок (ESTEX-вызовы) — счётчик
+  там недосчитывает.  Это безобидно: якорь переставляется по факту, и
+  ошибка живёт один кадр.  Отдельного «resync» не потребовалось.
+- Проверить на реальном железе, что `pace_ok` взводится (в MAME — да).
@@ -480,3 +480,53 @@ BUG-CHEAT-FIGHT-1 (выход из боя), и лечится там же.
 вывод сделан чтением трёх мест кода.  Если понадобится подтверждение,
 сценарий короткий: любой бой у правого края комнаты, вытеснить стража за
 край и добить.
+
+## ГСЧ разведён по доменам (у оригинала он ОДИН)
+
+**Оригинал.**  `random_seed` один на всё: кладка стены, анимация тайлов,
+броски боя, модификаторы падающих плит — всё тянет из одной
+последовательности (`seg009` PRNG, 32-битный LCG).  Поэтому в оригинале
+бой воспроизводим вместе со всем остальным: тот же сид — тот же бой.
+
+**У нас.**  Сидов несколько: `pop_t_seed` (кладка, `pop_tile.h`),
+`pop_fight_seed` (броски боя, `pop_guard.h`), отдельные у trob и loose.
+Сам генератор тот же (`pop_prandom`), таблицы вероятностей —
+побайтно те же, что в `data.h`.
+
+**Чем платим.**  Конкретный бой у нас и в SDLPoP разойдётся: порядок
+бросков другой, значит блоки/удары лягут иначе.  Статистически поведение
+то же (те же вероятности, тот же генератор), но «сверить бой кадр в кадр
+с SDLPoP» нельзя, и QuickSave обязан сохранять ВСЕ сиды, а не один.
+
+**Что проверять при регрессе.**  Если страж кажется сильнее/слабее
+оригинала — сначала проверить не таблицы (они сверены), а **режим
+скорости**: `fight_speed` у оригинала 100 мс, а в нашем FASTEST бой идёт
+61,4 мс, то есть в реальном времени на 63 % быстрее, и на глаз это ровно
+«страж давит сильнее».  Режим NORMAL (дефолт) даёт 102,4 мс — см.
+`frame_pacing_plan.md`.
+
+## Тень: кайма силуэта не подкрашивается фоном
+
+**Оригинал.**  Спрайт Тени не хранится — он кладётся ДВАЖДЫ: обычным
+прозрачным блитом в x и «блиттером XOR» в x+1 (`draw_objtable_item`,
+seg008.c:1600).  XOR идёт по 24-битному RGB того, что УЖЕ на экране
+(`blit_xor`, seg009.c:3190), поэтому там, где спрайт прозрачен в x, но
+непрозрачен в x−1, цвет получается как `фон XOR цвет спрайта`.
+
+**У нас.**  Пакетный блит наложения на себя не умеет, поэтому результат
+запечён в отдельный атлас (`toolchain/pop_pack_shadow.py`,
+`docs/shadow_atlas_plan.md`).  Запекать пришлось для КОНКРЕТНОГО фона, и
+выбран чёрный: на нём `фон XOR цвет == цвет`, то есть запечка точна.
+
+**Чем платим.**  Ровно одним: **кайма в один пиксель по ЛЕВЫМ кромкам
+силуэта** на НЕчёрном фоне.  У оригинала она принимает оттенок фона, у нас
+всегда «свой» цвет.  Внутренность силуэта и правые кромки совпадают точно —
+там первый проход уже закрасил пиксель, и от фона результат не зависит.
+
+**Почему это приемлемо.**  Тень бывает на четырёх уровнях, и почти всегда
+на чёрном: у зеркала (ур. 4), в проёме (5), над пропастью (6), в бою (12).
+
+**Что проверять при регрессе.**  Если Тень окажется на светлом фоне и
+кайма станет резать глаз — вариантов два: запечь второй набор под светлый
+фон (ещё 32 страницы EMM) или считать эту кайму прозрачной (силуэт станет
+на пиксель уже). Оба хуже нынешнего; трогать только по факту жалобы.
@@ -851,3 +851,21 @@ Apple II и по комментариям вида «DOS PoP does this» в са

 **Что проверять в первую очередь при новом «дорогом» месте:** не сколько
 там арифметики, а сколько раз за кадр пересекается граница банка.
+
+## Фиксированный логический кадр (2026-08-19) — МЕНЯЕТ ВСЕ ЦЕЛЕВЫЕ ЧИСЛА
+
+Период логического кадра больше не `ceil(W) + 2`, а `max(n, ceil(W))`
+(`roomtest/pop_pace.c`, разбор — `frame_pacing_plan.md`).  Поэтому:
+
+- **Бюджет кадра вырос с 430 080 до 1 290 240 тактов** (n = 3, режим
+  FASTEST по умолчанию).  Все записи этого реестра, где «работа сверх
+  430 000 стоит сразу целого растра», СЧИТАТЬ УСТАРЕВШИМИ.
+- 13/23 (максимум работы 911 862) теперь укладывается в период 3 растра —
+  проверено, ни одного кадра длиннее.  Прежний профиль был 3/4/5.
+- Оптимизация из спешной стала плановой: смысл резать такты остался
+  (режим NORMAL при n=4 и бой при n=5 дают ещё больше запаса, а FASTEST —
+  верхнюю планку скорости), но «свалиться за растр» больше не обрыв.
+- Цена самого пейсинга — ≈4 000 тактов на кадр (0,9 %), замерено A/B.
+
+Приоритет P9 (G8) и остальных позиций от этого не меняется, но их
+СРОЧНОСТЬ падает: они больше не спасают от скачка периода.
@@ -0,0 +1,266 @@
+# Атлас Тени — разбор и план
+
+Дата: 2026-08-20.  Статус: **ЗАКРЫТО.**  Ш0-Ш4 сделаны, прогон
+пользователем на уровнях **4, 5, 6 и 12** — всё корректно.
+
+Задача: сейчас Тень рисуется спрайтами Кида (вне боя) и спрайтами стража
+(в бою) как есть, поэтому от Кида она не отличается.  В оригинале её вид
+даёт наложение спрайта на себя со сдвигом; наш пакетный блит такого не
+умеет, поэтому запекаем результат в отдельный атлас заранее.
+
+## 1. Что делает оригинал (проверено по SDLPoP, не по памяти)
+
+`draw_objtable_item`, `seg008.c:1600`:
+
+```c
+case 1: // shadow
+    add_midtable(obj_chtab, obj_id + 1, obj_xh, obj_xl,     obj_y, blitters_2_or,  1);
+    add_midtable(obj_chtab, obj_id + 1, obj_xh, obj_xl + 1, obj_y, blitters_3_xor, 1);
+```
+
+Тот же самый спрайт кладётся ДВАЖДЫ: первый проход в x, второй в x+1.
+Два уточнения, которые меняют алгоритм запекания:
+
+1. **`blitters_2_or` — это НЕ побитовое ИЛИ.**  В SDLPoP он реализован
+   обычным блитом с colour key = индекс 0 (`method_6_blit_img_to_scr`,
+   `seg009.c:3306`: `SDL_SetColorKey(image, SDL_TRUE, 0)`).  То есть
+   первый проход — наш обычный прозрачный блит, один в один.
+2. **`blitters_3_xor` работает по 24-битному RGB, а не по индексам
+   палитры** (`blit_xor`, `seg009.c:3190`: конвертация в 24 бита, затем
+   `*p_dest ^= *p_src` побайтно).  Прозрачности у него нет вообще —
+   XOR'ится весь прямоугольник, но прозрачные пиксели спрайта это
+   чёрный 0x000000, а XOR с нулём ничего не меняет.
+
+Отсюда и берётся необходимость СВОЕЙ палитры: XOR двух цветов игровой
+палитры даёт цвет, которого в ней нет.
+
+### Каким набором спрайтов рисуется Тень (проверено 2026-08-20)
+
+Сначала я решил, что в боевых кадрах Тень рисуется спрайтами СТРАЖА, и
+записал это в план.  **Это было неверно, поправка ниже.**
+
+Набор выбирает НЕ charid.  `load_frame_to_obj` (`seg008.c:1752`):
+
+```c
+word chtab_base = id_chtab_2_kid;              // жёстко Кид
+obj_chtab = chtab_base + (cur_frame.sword >> 6);   // старшие 2 бита кадра
+```
+
+то есть набор берётся из САМИХ ДАННЫХ КАДРА, поле `sword`: младшие 6 бит —
+картинка меча, старшие два — смещение chtab относительно Кида
+(`types.h:361`).  Проверил обе таблицы:
+
+- `frame_table_kid` — **все 241 кадра** имеют `sword & 0xC0 == 0` → chtab_2.
+  Значит **Кид всегда рисуется своими спрайтами**, боевые кадры 150..189 не
+  исключение;
+- `frame_tbl_guard` — все кадры имеют `0xC0` → chtab_5.
+
+Тень берёт `frame_tbl_guard` для кадров 150..189 (`seg006.c:533`), значит в
+бою она идёт через chtab_5.  **Но chtab_5 — это не «страж», это «соперник
+уровня»**: он грузится из `tbl_guard_dat[tbl_guard_type[уровень]]`
+(`seg000.c:1117`), а `tbl_guard_type[12] == 4` → **SHADOW.DAT**.
+
+Открыл SHADOW.DAT: его палитра **побайтно равна палитре Кида** (у GUARD.DAT
+там серая рампа под перекраску), а спрайты — Кид в боевых позах, не страж.
+Отрендерил тройками «Кид / SHADOW.DAT / GUARD.DAT» для кадров
+151/153/158/161/167: первые две колонки — один и тот же персонаж, третья —
+серый страж в тюрбане.
+
+**Вывод: Тень ВСЕГДА выглядит Кидом, и ощущение пользователя верно.**
+Спрайты при этом лежат в двух файлах: не-боевые кадры в chtab_2 (KID),
+боевые — в chtab_5, заполненном SHADOW.DAT.
+
+### Можно ли взять для боя собственные кадры Кида
+
+Механически да: `frame_table_kid` покрывает 150..189 со своей геометрией,
+и хватило бы снять спецветку для `charid_1_shadow` в `load_frame`.  Но
+кадры НЕ совпадают: из 34 боевых у 31 отличается габарит (на 1-6 px), у 3
+отличаются пиксели.  Это разная графика, а не одна и та же в двух файлах.
+Поэтому берём SHADOW.DAT — он и есть «кадры Кида для Тени», подготовленные
+авторами.
+
+## 2. Единственное место, где запечка отличается от оригинала
+
+XOR идёт по тому, что УЖЕ на экране, то есть результат зависит от фона.
+Разбор по пикселям показывает, что зависимость узкая:
+
+| пиксель | первый проход | второй проход | зависит от фона? |
+|---|---|---|---|
+| спрайт непрозрачен в x | закрашен цветом спрайта | XOR с цветом из x−1 | **нет** |
+| прозрачен в x, непрозрачен в x−1 | фон | фон XOR цвет | **да** |
+| прозрачен в обоих | фон | фон | нет (не рисуем) |
+
+То есть от фона зависит только **кайма в один пиксель по левым кромкам
+силуэта**.  На чёрном фоне (а Тень почти всегда на нём — уровень 4 у
+зеркала, уровень 6, бой на 12-м) `фон XOR цвет == цвет`, и запечка точна.
+На светлом фоне оригинал подкрасит эту кайму, мы — нет.
+
+**Это осознанное расхождение, в `impl_diff.md` при реализации.**
+
+## 3. Замеры на реальных ассетах
+
+Прогон алгоритма по правильным наборам (`SDLPoP/data/KID` +
+`SDLPoP/data/SHADOW`):
+
+| набор | кадров | макс. габарит | разных цветов |
+|---|---:|---|---:|
+| Кид (chtab_2) | 219 | 56×57 | 44 |
+| SHADOW.DAT (chtab_5 на ур. 12) | 32 | 49×38 | 22 |
+| **вместе** | **251** | 57×57 (с учётом +1 px сдвига) | **45** |
+
+Цветов вместе почти столько же, сколько у одного Кида: SHADOW.DAT сидит на
+той же палитре, новых сочетаний XOR почти не даёт.  Всего пикселей во всех
+кадрах Тени — 91 045.
+
+### Насколько заметна подмена
+
+«Затронуто» само по себе ничего не говорит — важно, НА СКОЛЬКО сместился
+цвет.  Порог различимости на плоской заливке ~30-40 единиц евклида в RGB
+(максимум возможного — 441).  Пробовал три стратегии подбора:
+
+- **A** — оставить N самых частых цветов ТОЧНО, остальные в ближайший;
+- **B** — взвешенный k-means по всем цветам (двигает вообще все);
+- **C** — гибрид: часть слотов под точные частые, остаток — кластеры хвоста.
+
+| палитра | стратегия | изменено px | заметно (40..90) | сильно (>90) | худшая |
+|---|---|---:|---:|---:|---:|
+| 16 | A самые частые | 959 (1,05 %) | 569 | 381 | 128 |
+| **16** | **C гибрид 5+11** | 6 984 (7,67 %) | 1 078 | **76** | 114 |
+| 32 | A самые частые | 50 (0,05 %) | 40 | 4 | 113 |
+| 32 | C гибрид 28+4 | 73 (0,08 %) | 58 | **0** | 90 |
+
+Читается так.  При 32 цветах всё практически идеально: 73 пикселя на 251
+кадр, грубых промахов нет вовсе.  При 16 цветах выбор стратегии виден:
+«самые частые» трогает меньше пикселей (959), но 381 из них уезжает СИЛЬНО;
+гибрид размазывает ошибку — грубых остаётся 76, то есть примерно **0,3
+пикселя на кадр**.
+
+### Решение: **16 цветов, стратегия C (гибрид 5 + 11)**
+
+Числа выше — про пиксели, а решает глаз.  Отрендерил одни и те же кадры в
+трёх видах (точный цвет / 32 / 16) и сравнил в увеличении ×3: **отличий
+не видно**.  Объяснение в самих числах: перцептивно значимых пикселей при
+16 цветах гибридом — 1 154 на 251 кадр, это ~4,6 пикселя на кадр при
+~1 000 видимых, и они РАССЫПАНЫ по контуру, а не собраны в пятно.
+
+Поэтому берём 16, а не 32: экономим блок палитры (пригодится под будущие
+наборы — принцесса, визирь, мышь), а разница неразличима.
+
+**Но стратегия обязана быть гибридной.**  При 16 цветах «взять самые
+частые» впятеро хуже по грубым промахам (381 пиксель против 76), и это
+единственное место, где выбор стратегии виден.  Гибрид: 5 самых частых
+берём ТОЧНО, оставшиеся 11 слотов отдаём под взвешенные кластеры хвоста.
+
+Если в реальной игре кайма всё же будет резать глаз — переход на 32 цвета
+это одна константа в упаковщике и один блок палитры, данные не меняются.
+
+## 4. Палитра: что занято и куда класть
+
+| блок | кто | примечание |
+|---|---|---|
+| 0x30..0x3F | VGA-16 | общая; из неё цвет вспышки, пузырьки зелий, отладочная метка |
+| 0x40..0x4F | chtab_1 | зелья, пламя |
+| 0x50..0x5F | env тайлсета | **меняется** подземелье/дворец |
+| 0x60..0x6F | wall тайлсета | **меняется** подземелье/дворец |
+| 0x70..0x7F | chtab_2 | Кид |
+| 0x80..0x8F | chtab_0 | меч в руке |
+| 0x90..0x9F | chtab_5 | страж, перезаливается цветом стража |
+
+Занято 112 слотов из 256, **свободно 144** — девять выровненных блоков по
+16.  Оговорки: 0xFF в наших атласах это маркер прозрачности, а запись 0
+правит `flash_bg`, так что блоки 0x00 и 0xF0 лучше не трогать.
+
+**Берём 0xA0..0xAF** (16 слотов) — сразу за стражем, персонажи остаются
+сгруппированы, а блок 0xB0 остаётся свободным (под 32 цвета Тени, если
+понадобится, или под будущие наборы).
+
+Важно: в наших атласах прозрачность кодируется байтом 0xFF, а исходный
+индекс 0 в них означает «прозрачно».  У Тени **чёрный — настоящий цвет**
+(это XOR-погашенная середина силуэта, 51 % всех её пикселей), поэтому у
+неё маппинг свой: «нет пикселя» → 0xFF, цвет k → 0xA0 + k, и слот 0xA0 =
+чёрный НЕПРОЗРАЧНЫЙ.
+
+## 5. Объём
+
+251 кадр против 219 у Кида — по страницам EMM примерно как нынешний
+набор Кида (28 страниц), плюс пара на кадры из SHADOW.DAT.  При 215 свободных
+страницах на старте (memory `sprinter_emm_budget`) это не проблема.
+
+Кадры смерти («убитый Кид») пока НЕ вырезаем — экономия несколько
+страниц, а риск промахнуться мимо нужного кадра реальный: Тень на 12-м
+уровне умирает.
+
+## 6. План работ
+
+**Ш0. Довезти SHADOW.DAT.**  Его у нас нет вовсе (см. BUG-SHADOW-SET) —
+добавить каталог ассетов и правило в Makefile рядом с GUARD/SKEL/VIZIER.
+
+**Ш1. Упаковщик** `toolchain/pop_pack_shadow.py`: прогнать оба набора
+через алгоритм §1, собрать 16-цветную палитру гибридом (10 точных + 6
+кластеров хвоста), выдать
+`poc/res/shadow/shadow0..N.atl` + `shadow.pal` + `pop_shadow_atlas.h`.
+Критерий: предпросмотр PNG совпадает с видом Тени в SDLPoP.
+
+**Ш2. Загрузка**: `pop_shadow_load()` рядом с `pop_kid_load`, палитра в
+0xA0..0xAF, и обе страницы дабл-буфера (как `bg_load_tile_pal`).
+Грузить ЛЕНИВО — только когда на уровне есть Тень (4, 5, 6, 12), иначе
+28 страниц EMM висят зря.
+
+**Ш3. Отрисовка**: одно место — `pop_cdraw.c:551..568`, где выбирается
+`pages`.  Сейчас там для соперника берётся `gp`, а для не-боевых кадров
+Тени подменяется на `kidp`; станет «charid == CHARID_1_SHADOW → shadowp»
+БЕЗ подмены: обе половины (кадры Кида и кадры SHADOW.DAT) лежат в ОДНОМ
+атласе Тени, так что ветка становится проще нынешней.
+
+**Ш4. Проверка в MAME**: уровень 4 (Тень у зеркала), уровень 6 (Тень
+крадёт зелье), уровень 12 (бой с Тенью — там она в боевых кадрах, то
+есть проверяется вторая половина набора).
+
+## 7. Что проверить артефактом до Ш3
+
+1. Индекс кадра для Тени в боевых кадрах: `frame_tbl_guard` адресуется
+   как `frame + add_frame - 149` (`seg006.c:535`), то есть у нашего
+   атласа Тени нумерация двух половин должна совпадать с тем, что уже
+   делает `pop_frame_tbl_is_guard`.
+2. Перекраска Тени НЕ нужна: SHADOW.DAT приходит уже в палитре Кида, а
+   `curr_guard_color` у не-стражей равен 0 (`seg002:183`).  Ветку
+   `pop_guard_set_palette` для типа 4 звать нельзя — она затрёт палитру
+   Тени палитрой стража.
+
+---
+
+# 8. Как сделали (2026-08-20)
+
+- `toolchain/pop_pack_shadow.py` — запекает обе половины, собирает
+  16-цветную палитру гибридом (получилось 5 частых точно + 11 кластеров
+  хвоста), пишет `poc/res/shadow/sk0..27.atl`, `sf0..3.atl` и
+  `roomtest/pop_shadow_atlas.h`.  Итог: **251 спрайт, 32 EMM-страницы,
+  225 178 Б**.
+- `roomtest/pop_shadow.c/.h` (банк 8) — загрузка.  **Грузим один раз при
+  старте**, а не по уровням: страниц EMM с запасом, а забыть перезагрузку
+  на границе легко — ровно так и появился BUG-SHADOW-SET.
+- `pop_cdraw.c` — одна ветка выбора атласа; заодно брызги урона теперь
+  берут атлас отдельным указателем (`spl`), потому что у оригинала они
+  всегда из «своего» chtab, а у Тени кадр может прийти из другой
+  половины набора.
+
+## Грабля, стоившая одного прогона
+
+Набор загрузился, силуэт нарисовался правильной формы — и **целиком
+чёрный**.  Причина: `gfx_pal_fload("KID\\kid.pal")` заливает ВСЕ 256
+записей палитры и затирает любые слоты, выставленные до него.  Ровно та
+же беда уже была с тайлсетом — сразу за этим вызовом стоит
+`pop_bg_pal_apply`.  Поэтому палитра Тени вынесена в отдельный
+`pop_shadow_pal_apply()` и зовётся там же, а не внутри загрузки атласов.
+
+**Правило на будущее: любой новый набор палитровых слотов красится ПОСЛЕ
+kid.pal, рядом с pop_bg_pal_apply.**
+
+## Проверено
+
+Уровни 4 (рождение из зеркала), 5 (кража зелья), 6 (прыжок через
+пропасть) и 12 (бой — там работает вторая половина набора, `sf*`) —
+прогон пользователя 2026-08-20, расхождений не найдено.
+
+Расхождение из §2 (кайма в один пиксель по левым кромкам на НЕчёрном
+фоне) записано в `impl_diff.md`.
@@ -0,0 +1,296 @@
+# Звук в порте PoP — разбор и план
+
+Дата: 2026-08-20.  Статус: **разбор, кода нет.**
+
+Задача пользователя: добавить звук.  Приоритет — эффекты; музыку, если
+найдётся способ.  Эффекты — **обязательно WAV, а не PC-спикер**
+(уточнение 2026-08-20; см. §1а — оказалось, что они и так все в WAV).  Ниже — что реально лежит в ассетах, что умеет железо, и
+почему получившийся план вышел проще, чем ожидалось.
+
+## 1. Главный вывод
+
+**Ни MIDI разбирать, ни ноты сочинять не придётся, и ресэмплировать тоже.**
+
+- Эффекты уже лежат **8-битным беззнаковым PCM на 11 000 Гц**, а у CBL есть
+  режим **10 937,5 Гц** — расхождение 0,6 %, на слух неразличимо.  Формат
+  сэмпла совпадает с нашим CBL байт в байт (`cbl.h`: 8 бит, беззнаковый,
+  центр 0x80).  То есть данные играются **как есть**, без конверсии.
+- Музыка есть в виде **списков нот PC-спикера — 7 КБ на всю игру**, а нота
+  там задана прямо в ГЕРЦАХ.  Пересчёт в делитель AY — одно деление.
+- AY и COVOX на Sp2000 сведены в **один ЦАП TDA1543** (док Ивана Мака,
+  §5), значит музыка на AY и эффекты через CBL звучат ОДНОВРЕМЕННО, и
+  смешивать их программно не надо.
+
+## 1а. Уточнение после разбора ВСЕХ наборов MS-DOS версии (2026-08-20)
+
+Пользователь попросил, чтобы эффекты были не PC-спикером, а WAV, и заодно
+посмотреть `mt32snd[1-2].dat`.  Разобрал все восемь `.dat` из `MSDOS/`.
+Ответ короткий: **эффекты И ТАК все до одного есть в WAV, а вот у музыки
+WAV нет ни в одном наборе.**
+
+| набор | формат | какие звуки | сколько |
+|---|---|---|---|
+| `digisnd1..3` | **WAV**, 8 бит PCM | эффекты 0..23, 44..49, 51 | **31** |
+| `mt32snd1..2` | MIDI для Roland MT-32 | ТЕ ЖЕ эффекты 0..23, 44..51 | 31 |
+| `midisnd1..2` | MIDI (AdLib/GM) | **музыка** 24..43, 50, 52..56 | 22 |
+| `ibm_snd1..2` | ноты PC-спикера | **всё подряд, 0..56** | 57 |
+
+Здесь пряталась ловушка: `mt32snd` по имени похож на «музыку получше», а
+на деле это набор ЭФФЕКТОВ для владельцев MT-32 — те же id, что у
+`digisnd`.  Музыки в нём нет вовсе.
+
+Частоты WAV: 28 звуков на 11 000 Гц, по одному на 8 200, 14 000 и 2 750.
+Итого 112 922 сэмпла = **11,4 с, ~110 КБ ≈ 6,7 EMM-страниц**.
+
+Только PC-спикером, без альтернатив, остаются четыре id: 31, 34, 42
+(пустые) и **38 `blink`** — четыре ноты.  То есть на весь звук игры
+спикер нужен ровно для одного писка.
+
+### Музыка: WAV нет, есть три пути
+
+| путь | данные | что получится | цена |
+|---|---|---|---|
+| **A. Ноты PC-спикера на AY** | 7 КБ | один квадратный голос — ровно то, что слышали на IBM PC 1989 | секвенсор на полсотни строк |
+| **B. MIDI -> AY, три голоса** | 27 КБ исходника | богаче: бас + мелодия + арпеджио | разбор MIDI + раскладка по каналам |
+| **C. MIDI -> WAV на хосте, стрим через CBL** | см. ниже | настоящее звучание, любое | нужен синтезатор на хосте + место |
+
+Про объём для пути C (замерено по длительностям треков):
+
+| группа | треков | длительность | WAV 11 кГц |
+|---|---:|---:|---|
+| звучат ПО ХОДУ игры (гимн уровня, смерть, зелья, перо, победа) | 12 | 74,7 с | **803 КБ = 50 EMM-страниц** |
+| заставки и титры | 10 | 248,1 с | 2 665 КБ = 167 страниц |
+
+Игровая половина в EMM **влезает** (при ~215 свободных страницах), а
+заставочная — нет, её пришлось бы стримить с диска.  Но заставки идут
+тогда, когда игра ничего не рисует, так что стрим там как раз уместен.
+
+**Предложение:** начинать с A (7 КБ, работает сразу, ноль рисков), а C
+держать как отдельную фазу — она ортогональна: проигрыватель WAV для
+музыки это тот же `cbl_push`, что и для эффектов, только длиннее буфер.
+B имеет смысл только если C окажется неподъёмным по месту.
+
+## 1б. РЕШЕНИЯ (пользователь, 2026-08-20)
+
+1. **Эффекты — WAV через CBL, 8 бит, МОНО, единая частота.**  Проверено по
+   `convert_digi_sound` (`seg009.c:2358`): один байт на кадр, то есть
+   моно, и байт беззнаковый (`(b | b<<8) - 32768`), центр 0x80 — ровно
+   формат нашего CBL.  Стерео в данных нет вовсе: каналы у оригинала
+   размножаются уже на выходе (`digi_audiospec->channels`).
+2. **Музыка, первый заход — путь A** (ноты спикера на AY).
+3. **Заставки и титры — потом WAV.**  Конфликта с эффектами там нет:
+   одновременно они не звучат.
+4. **Музыка ПО ХОДУ игры** (она может совпасть с эффектом) — открыто, два
+   варианта: либо тоже WAV с ГАШЕНИЕМ эффектов на время музыки (музыка
+   важнее — **проверить на слух**), либо путь B (MIDI -> три голоса AY).
+5. **Все эффекты привести к одной частоте.**
+6. Синтезатор для MIDI -> WAV — решать ближе к делу; годятся и онлайн-
+   конвертеры, хоть вручную, если fluidsynth/timidity не поставится.
+
+### Про единую частоту (замер)
+
+Приводим не к 11 000, а ровно к **10 937,5 Гц — частоте CBL**
+(`CBL_FREQ_10K9`).  Тогда тон точен, а не «на 0,6 % ниже»: проигрывание
+11 000 Гц данных на 10 937,5 даёт сдвиг **−9,9 цента**, что на коротком
+эффекте не слышно, но бесплатно избавиться от него всё равно приятно —
+пересчитывать три файла всё равно придётся.
+
+| id | звук | было | станет | дельта |
+|---|---|---|---|---:|
+| 15 | `leveldoor_sliding` | 2 750 Гц, 4 436 сэмплов | 17 643 | **+13 207 Б** |
+| 23 | `footstep` | 8 200 Гц, 996 | 1 329 | +333 Б |
+| 51 | `princess_door_opening` | 14 000 Гц, 6 188 | 4 834 | −1 354 Б |
+| — | остальные 28 (11 000 Гц) | — | ×0,9943 | −588 Б |
+
+Итог: **112 922 -> 124 531 Б, 6,9 -> 7,6 EMM-страниц.**  Рост целиком от
+`leveldoor_sliding`: источник у него 2 750 Гц, вчетверо реже целевой, и
+апсэмплинг не улучшит звучание — только уравняет формат.  Платим 0,8
+страницы за то, что **CBL открывается ОДИН раз и частоту менять не надо
+никогда** — ни между эффектами, ни при переходе на музыку-WAV.
+
+(Альтернатива для него — хранить как есть и повторять каждый сэмпл
+четырежды в рантайме: 2 750 × 4 = 11 000 ровно.  Это код в `fill()` ради
+13 КБ; не стоит того, но если место когда-нибудь прижмёт — вариант есть.)
+
+## 1в. Бюджет памяти EMM (живой замер 2026-08-20)
+
+Замерено `mem_info` из работающей программы (уровень 1), а не посчитано на
+бумаге: инструментовка ставилась временно и откатана.
+
+| | страниц | КБ |
+|---|---:|---:|
+| всего в машине | 256 | 4 096 |
+| система (DSS) + сам exe: база + 8 банков кода | **43** | 688 |
+| наши ассеты | **81** | 1 296 |
+| **занято** | **124** | 1 984 |
+| **свободно** | **132** | **2 112 (2,06 МБ)** |
+
+Разбивка 81 страницы ассетов (сходится точно):
+
+| набор | страниц |
+|---|---:|
+| **Тень** (`sk*` 28 + `sf*` 4) | **32** |
+| Кид (`kid0..27`) | 28 |
+| фон тайлсета (env 10 + wall 1 + fore 1) | 12 |
+| страж | 5 |
+| зелья (chtab_1), меч, `kid_data.bin`, страница уровня | по 1 |
+
+Самый крупный потребитель теперь — **набор Тени, 32 страницы**, больше
+самого Кида.  Если место когда-нибудь прижмёт, там есть очевидный резерв
+(кадры смерти и позы, в которых Тень не бывает), но при 132 свободных
+страницах трогать незачем.
+
+### Что из этого следует для звука
+
+| статья | страниц | останется свободно |
+|---|---:|---:|
+| эффекты WAV, все 31, 10 937,5 Гц | **8** | 124 |
+| музыка ПО ХОДУ игры в WAV (путь C, 12 треков) | 50 | 74 |
+| заставки и титры в WAV (10 треков, 248 с) | 167 | **не влезает** |
+
+То есть эффекты — капля, игровая музыка в WAV тоже поместится, а
+заставочную придётся стримить с диска в любом случае (что и планировалось:
+во время заставок игра ничего не рисует).
+
+Оговорка: 132 свободных страницы — это на уровне 1.  На уровне 9 добавятся
+зеркальные наборы (`pop_vflip_load_all`: 28 Кид + 5 страж + меч = 34
+страницы), останется ~98.  Проверять запас надо ИМЕННО ТАМ.
+
+## 2. Что лежит в ассетах (замерено, а не по памяти)
+
+Звук в PoP адресуется как ресурс `10000 + N`, N = 0..56 — 57 звуков
+(`load_sound`, `seg009.c:2289`).  Наборов три, и они ПАРАЛЛЕЛЬНЫЕ: один и
+тот же звук есть в нескольких видах.
+
+| набор | что это | объём | покрытие |
+|---|---|---:|---|
+| `DIGISND1..3.DAT` | оцифровка, 8 бит PCM | 103 941 Б | **31 звук** (эффекты) |
+| `MIDISND1..2.DAT` | MIDI-музыка | 27 776 Б | музыка |
+| `IBM_SND1..2` (распакованы) | ноты PC-спикера | **7 КБ** | **все 57** |
+
+### 2.1 Оцифровка (эффекты)
+
+Разбор контейнера: индекс по 8 байт на запись (id, offset, size), **первый
+байт ресурса — контрольная сумма**, тело за ней (спецификация
+`POP-DAT-FormatSpecifications`, §3.1.2 — на этом я сначала споткнулся и
+читал мусор).  Тело — `digi_type`: `word rate, word count, word unk,
+byte size`, дальше сэмплы.
+
+- 31 звук, все 8-битные;
+- частоты: **28 звуков на 11 000 Гц**, по одному на 8 200 и 14 000;
+- 103 701 сэмпл = **9,4 секунды**, **103 941 Б ≈ 6,3 EMM-страницы**.
+
+### 2.2 Ноты PC-спикера (и эффекты, и музыка)
+
+Формат: `byte type(=0), word tempo`, дальше тройки `word frequency,
+byte length`; `frequency <= 1` — пауза, `0x12` — конец.  Ключевое, что
+пришлось смотреть в `play_speaker_sound`/`speaker_callback` (`seg009.c`):
+
+- **`frequency` — это ГЕРЦЫ напрямую** (`generate_square_wave(stream,
+  (float)note->frequency, ...)`), а не делитель PIT, как кажется по
+  маленьким числам;
+- длительность ноты = `length / tempo` СЕКУНД.
+
+Замеры по всем 57 звукам: **2212 нот**, частоты 16..65507 Гц,
+длительности 1,74..2571 мс.
+
+Из них 23 звука — те, у которых оцифровки НЕТ, то есть вся музыка:
+заставки, гимны уровней, смерть, победа, титры (id 24..43, 50..56).
+**1469 нот**, и вот их длительности:
+
+| длительность ноты | нот | доля |
+|---|---:|---:|
+| < 3 мс | 0 | 0 % |
+| 3..12 мс | 2 | 0,1 % |
+| 12..25 мс | 140 | 9,5 % |
+| > 25 мс | 1327 | 90,3 % |
+
+Это число решает вопрос про таймер — см. §4.
+
+## 3. Что умеет железо (док Ивана Мака §5 + MAME)
+
+- **AY-3-8910/8912** в ПЛМ, «программируется по стандартным описаниям» —
+  то есть ZX-порты; в MAME он заведён как `AY8910(config, "ay8912",
+  X_SP/24)`, то есть **тактовая 1,75 МГц**.  Период канала = 109375 /
+  частота(Гц), 12 бит (макс 4095) → снизу берутся частоты от ~27 Гц.
+  Точные Z80-адреса портов идут через таблицу DCP, а не напрямую —
+  **проверить артефактом до кодинга** (ожидаем ZX-стандарт 0xFFFD/0xBFFD).
+- **CBL** — COVOX с буфером 256 Б, две половины по 128; бит 7 порта 0xFE
+  показывает играющую половину, порт управления 0x4E.  Прерывание —
+  когда половина сменилась.
+- **Бипер** (бит 5 порта 0xFE) — туда же в ЦАП.  Нам не нужен.
+- Всё это **сведено в один ЦАП**, поэтому AY и CBL звучат вместе.
+
+У нас уже есть готовая обвязка CBL (`libc/include/cbl.h`): callback
+`fill(n)`, выдача блока через `cbl_push_otir()` (порт 0x4F) или через
+акселератор, коды частот, счётчик недоливов.  Своего кольца библиотека не
+держит — данные пропихиваются прямо из наших EMM-страниц.
+
+## 4. Предлагаемая архитектура
+
+```
+           эффекты (31 шт, 8 бит 11 кГц)          музыка (23 шт, ноты)
+                     │                                    │
+              EMM-страницы (6,3)                    7 КБ нот в банке
+                     │                                    │
+        cbl_push_otir из fill()                  запись 3 регистров AY
+                     │                                    │
+                 CBL (10,9 кГц) ──────┐      ┌────────── AY (1,75 МГц)
+                                      ▼      ▼
+                                   TDA1543 (аппаратное смешивание)
+```
+
+**Один источник прерываний — CBL.**  Его callback приходит каждые 128
+сэмплов = **11,7 мс** при 10,9 кГц, и он же двигает секвенсор музыки.
+Отдельный таймер (CTC) НЕ нужен: по таблице из §2.2 короче 12 мс всего
+2 ноты из 1469 — они растянутся на один тик, чего не слышно.
+
+Почему это важно: `irq_ctc_install` сейчас требует кода в W2 (tiny/big),
+а roomtest — huge, и попадёт ли туда CTC-трамплин, зависит от раскладки.
+Обойтись без него — значит не открывать этот фронт вовсе.
+
+**Пейсинг кадра при этом не страдает.**  Наш темп считается ПО ЛУЧУ
+(`pop_pace.h`), а не по кадровым прерываниям, поэтому то, что CBL-ветка
+трамплина делает приватный RETI и съедает кадровые прерывания, нам
+безразлично.  Если бы пейсинг остался на прерываниях — звук бы его сломал.
+
+## 5. Объём работ
+
+| фаза | что | оценка |
+|---|---|---|
+| **З1** | распаковщик `pop_pack_sound.py`: DAT → `.snd`-страницы EMM (эффекты) + `.not` (ноты музыки) | формат уже разобран |
+| **З2** | `pop_sfx.c`: `cbl_open` + `fill()`, таблица «звук → страница/смещение/длина», `pop_sfx_play(id)` | ядро |
+| **З3** | развесить вызовы: 66 мест `play_sound` в оригинале; у нас часть уже помечена TODO (`pop_ctrl.c:408`, `guards.c:992`, `pop_map.c:3035/3107`, …).  **Плюс бесплатный кусок**: опкод `SEQ_SOUND` в seqtbl уже разбирается нашим `play_seq` (`pop_kid.c:326`) — шаги, приземления и прочее поедут сами | механическая |
+| **З4** | `pop_music.c`: секвенсор нот на AY (путь A), тик из CBL-callback | небольшая |
+| **З6** | заставки и титры — WAV-музыка потоком (эффекты в это время не звучат) | после З1-З4 |
+| **З7** | музыка по ходу игры: WAV с гашением эффектов ЛИБО путь B — решать по итогам З6 | открыто |
+| **З5** | приоритеты и вытеснение: у оригинала `play_sound` глушит предыдущий (`stop_sounds`), музыка и эффект — разные каналы | правила из seg009 |
+
+## 6. Что проверить артефактом ДО кодинга
+
+1. **Порты AY на Sprinter** — записать в 0xFFFD/0xBFFD и убедиться, что
+   MAME отдаёт звук (порты идут через DCP-таблицу, «стандартные ZX» —
+   это ожидание, а не факт).
+2. **CBL в режиме huge.**  Шапка `cbl.h` говорит «код/данные в W2
+   (tiny/big)», но это скорее всего устаревшая оговорка: IM2-трамплин
+   давно переделан на all-modes, и наш кадровый путь в huge работает.
+   Проверить `cbl_open` из roomtest.
+3. **Совместное владение портом 0xFE.**  Бит 5 (луч) у нас держится через
+   `_cbl_port_ref` «немым» кодом частоты; когда откроется НАСТОЯЩИЙ CBL,
+   владение переходит к нему.  Убедиться, что пейсинг переживает
+   `cbl_open`/`cbl_close`.
+4. **Цена fill() в кадре.**  128 байт через `cbl_push_otir` раз в 11,7 мс
+   — замерить тем же способом, что и остальное (брейкпоинт + totalcycles).
+
+## 7. Про MIDI — почему не он
+
+Музыка в MIDISND — настоящие MThd/MTrk чанки, 27 КБ.  Чтобы играть их на
+AY, нужен разбор MIDI, раскладка каналов на три голоса и таблица
+инструментов — это отдельный проект, и звучать он будет НЕ так, как
+оригинал на PC.  А набор PC-спикера — это ровно то, что слышал игрок на
+IBM PC 1989 года: один квадратный голос.  Он у нас есть целиком, весит
+7 КБ и ложится на AY напрямую.
+
+Если позже захочется богаче — материал уже будет разобран, и можно
+разложить те же мелодии на три канала AY (бас/мелодия/арпеджио), не трогая
+ни данные, ни секвенсор.
@@ -3380,3 +3380,28 @@ draw_tile_anim();  draw_tile_bottom(0);    draw_loose(0);
 Основной кандидат на возврат этих тактов — задача
 [HEAL-WIDTH](TASKS_OPEN.md#heal-width): heal'ы кусков и плит берут ширину по
 клеткам, а фактический след — 58/57.
+
+### BUG-DBGSTART-LEVEL. Отладочный старт ломал переход между уровнями (закрыт 2026-08-20)
+
+**Симптом** (найден пользователем на сборке `make LEVEL=6 ROOM=1 POS=18`):
+Кид проваливается в комнате 1 шестого уровня, уровень меняется на 7-й — и
+Кид появляется не там: приземляется в комнате 1 на 2,8 вместо того, чтобы
+продолжать падение по своей колонке.
+
+**Корень.**  Отладочный старт (`DBG_START_ROOM`/`DBG_START_POS`,
+`roomtest_cold.c`) подменял комнату и позицию БЕЗУСЛОВНО, а
+`pop_start_level` зовётся не только на первом запуске, но и **на каждой
+смене уровня**.  В результате на 7-м уровне стартовой становилась
+отладочная комната 1 вместо комнаты 17 из данных — и спецсобытие «вход
+падением» (`set_start_pos`, seg003:0196: уровень 7, комната 17 ->
+`goto_other_room(3)`) не срабатывало вовсе, потому что его условие
+сравнивает именно `start_room`.
+
+Само спецсобытие было портировано и работало; сломан был вход в него.
+
+**Починка:** подмена применяется только пока `pop_current_level ==
+FIRST_LEVEL`.  Рестарт ТОГО ЖЕ уровня (смерть, чекпойнт) отладочную
+позицию сохраняет — ради этого она и перебивает чекпойнт.
+
+**Проверено в MAME:** после провала на 6-м `pop_current_level` = 7, Kid.room
+= 16, то есть спецсобытие отработало (старт в 17, переход вниз).
@@ -23,6 +23,8 @@
 | [BUG-CHOMP-JUMP-1](#bug-chomp-jump-1) | прыжок с места вплотную к чомперу: кадр с отступом назад | **низкий** | маловоспроизводим: на повторе не поднялся; на пререлиз |
 | [GRAB-KBD-TIMING](#grab-kbd-timing) | зацеп в падении срабатывает менее стабильно, чем в оригинале | **после всех уровней** | открыт: подозрение на клавиатурный модуль, не на физику |
 | [GUARD-ENTRY-DEATH](#guard-entry-death) | вход в комнату вплотную к стражу = мгновенная смерть (не портирован `bump_into_opponent`) | порт | **фикс есть, ждёт проверки в MAME** |
+| [BUG-SHADOW-SET](#bug-shadow-set) | Тень на 12-м уровне дерётся спрайтами СТРАЖА: SHADOW.DAT у нас нет вовсе | порт | открыт, разбор готов |
+| [BUG-CORPSE-AIR](#bug-corpse-air) | труп Кида висит в воздухе, когда убившая его плита улетела вниз | физика | открыт |
 | [LOOSE-ROOM-CHANGE](#loose-room-change) | расшатанная плита не доваливается, если Кид ушёл в соседнюю комнату | порт | закрыт 2026-08-13, кроме [LOOSE-SEAM-ANIM](#loose-seam-anim) |
 | [JUMP-FLOOR-LEGS](#jump-floor-legs) | в прыжке с пола ноги Кида рисуются ПОВЕРХ кромки пола, а должны за ней | окклюзия | **корень найден и починен, ждёт проверки в MAME** |
 | [MOB-CLIP-RIGHT](#mob-clip-right) | окна и узор кладки рисуются ПОВЕРХ падающих плит | окклюзия | открыт: корень найден 2026-08-13 |
@@ -836,3 +838,58 @@ if (modif)
 `draw_leveldoor`, либо запечка. Проверять на уровне 1 (подземелье, ширина
 39, сдвиг 2) И на уровне 4 (дворец, 48, сдвиг 0) — иначе поймаем только
 половину.
+
+### <a id="bug-shadow-set"></a>BUG-SHADOW-SET. Тень в бою рисуется спрайтами стража
+
+**Симптом** (найдено пользователем 2026-08-20): в бою Тень выглядит не
+Кидом.  В SDLPoP она Кид всегда.
+
+**Корень.**  Набор спрайтов выбирает не charid, а поле `sword` САМОГО
+КАДРА: `load_frame_to_obj` (`seg008.c:1752`) держит `chtab_base` жёстко
+равным `id_chtab_2_kid` и прибавляет `cur_frame.sword >> 6`.  У всех 241
+кадра `frame_table_kid` эти биты нулевые, у всех кадров `frame_tbl_guard`
+— `0xC0`.  Тень берёт таблицу стража для кадров 150..189 (`seg006.c:533`),
+значит идёт через chtab_5.
+
+Дальше и кроется наша ошибка: **chtab_5 — это не «страж», а «соперник
+уровня»**.  Он грузится из `tbl_guard_dat[tbl_guard_type[уровень]]`
+(`seg000.c:1117`), а `tbl_guard_type[12] == 4` → **SHADOW.DAT**, и это
+графика КИДА в боевых позах (палитра SHADOW.DAT побайтно равна палитре
+Кида; у GUARD.DAT там серая рампа под перекраску).
+
+**У нас** `pop_guard_load` (`pop_cdraw.c:98`) разбирает только типы 2
+(скелет) и 3 (визирь), а всё остальное — включая тип 4 — уводит в
+`guard_names`.  SHADOW.DAT в ассетах отсутствует, каталога нет, в
+Makefile правила нет.
+
+**Починка** — часть работы по атласу Тени, см.
+[`../docs/shadow_atlas_plan.md`](../docs/shadow_atlas_plan.md) Ш0/Ш1:
+довезти SHADOW.DAT и запечь его во вторую половину атласа Тени.  Отдельно
+чинить смысла нет: как только Тень поедет своим атласом, ветка выбора
+набора для типа 4 исчезнет вместе с проблемой.
+
+**Оговорка.**  `pop_guard_set_palette` для типа 4 звать НЕЛЬЗЯ — она
+затрёт палитру Тени палитрой стража (`curr_guard_color` у не-стражей = 0,
+`seg002:183`).
+
+### <a id="bug-corpse-air"></a>BUG-CORPSE-AIR. Труп висит в воздухе после падения плиты
+
+**Симптом** (найдено пользователем 2026-08-20, ур. 12 к. 15, старт с
+`POS=15`): Кид встал на проваливающийся пол (0,6), плита обрушилась и
+убила его, но ТЕЛО осталось лежать на уровне исчезнувшего пола, а плита
+улетела дальше вниз.  Труп висит в пустоте.
+
+**Где смотреть.**  Кадр смерти — `actions_5_bumped` (см. seq в
+`kid_data`), а гравитация в `check_action` (seg006:05CD) для действия 5
+включается только на кадрах приседа: у оригинала есть отдельные фиксы
+`FIX_DEAD_FLOATING_IN_AIR` (кадры 177..185) именно про этот случай —
+значит **в оригинале 1989 года труп в воздухе тоже висит**, и SDLPoP
+чинит это опциональным фиксом, по умолчанию выключенным.
+
+**Отсюда вопрос к решению**, а не сразу правка: чинить ли вообще.  Если
+чинить — портировать `fix_dead_floating_in_air` и записать как
+осознанное расхождение в `../docs/impl_diff.md` (мы уже отказались от
+двух других опциональных фиксов SDLPoP в `bump_into_opponent`).
+
+**Приоритет низкий:** ситуация возникает только когда труп остаётся на
+проваливающемся полу, играбельности не мешает.
@@ -35,7 +35,7 @@ MEMORY      ?= huge        # small-раскладка + банки кода в W
 # ВАЖНО: любое сравнение занятости банков имеет смысл только при ОДНОМ и том
 # же ALLOCS — иначе сравниваются не правки, а уровни оптимизации.
 ALLOCS      ?= 3000
-EXTRA_FLAGS ?= --gfx 256 -I $(CURDIR)/../poc/res/bg --max-allocs $(ALLOCS) --bank 2=pop_bg.c --bank 7=pop_room.c --bank 4=pop_cdraw.c --bank 4=pop_kdraw.c --bank 3=pop_map.c --bank 1=guards.c --bank 5=pop_ctrl.c --bank 6=pop_trob.c --bank 7=pop_redraw.c --bank 8=roomtest_cold.c --bank 8=pop_level_cold.c --bank 8=pop_kboot.c --bank 8=pop_guard_cold.c $(PROF_FLAGS)
+EXTRA_FLAGS ?= --gfx 256 -I $(CURDIR)/../poc/res/bg --max-allocs $(ALLOCS) --bank 2=pop_bg.c --bank 7=pop_room.c --bank 4=pop_cdraw.c --bank 4=pop_kdraw.c --bank 3=pop_map.c --bank 1=guards.c --bank 5=pop_ctrl.c --bank 6=pop_trob.c --bank 7=pop_redraw.c --bank 8=roomtest_cold.c --bank 8=pop_level_cold.c --bank 8=pop_kboot.c --bank 8=pop_guard_cold.c --bank 8=pop_shadow.c $(PROF_FLAGS)
 # Профилирование полосами бордюра (см. PROF() в roomtest.c) — ВКЛЮЧЕНО по
 # умолчанию, пока идёт работа с производительностью; make PROF=0 выключает.
 # Каждая фаза кадра красит бордюр в свой цвет, высота полосы на скриншоте
@@ -57,7 +57,7 @@ POS         ?= 2
 ifneq ($(strip $(ROOM)),)
 PROF_FLAGS  += -DDBG_START_ROOM=$(ROOM) -DDBG_START_POS=$(POS)
 endif
-EXTRA_SRCS  := pop_vflip.c pop_state.c pop_draw.c pop_tile.c pop_kid.c pop_level.c pop_geom.c pop_guard.c
+EXTRA_SRCS  := pop_vflip.c pop_pace.c pop_state.c pop_draw.c pop_tile.c pop_kid.c pop_level.c pop_geom.c pop_guard.c

 BG_DIR      := $(CURDIR)/../poc/res/bg
 KID_DIR     := $(CURDIR)/../poc/res/kid
@@ -112,8 +112,16 @@ VIZIER_DIR  := $(CURDIR)/../poc/res/vizier
 VIZIER_DATA := $(VIZIER_DIR)/g0.atl $(VIZIER_DIR)/g1.atl $(VIZIER_DIR)/g2.atl \
               $(VIZIER_DIR)/g3.atl $(VIZIER_DIR)/g4.atl

+# ТЕНЬ — свой набор, запечённый упаковщиком (наложение спрайта на себя со
+# сдвигом; наш блит так не умеет, см. ../docs/shadow_atlas_plan.md).  Две
+# половины в одном наборе: sk* — кадры вне боя (спрайты Кида), sf* — кадры
+# 150..189 (SHADOW.DAT, это тоже графика Кида, а не стража).
+SHADOW_DIR  := $(CURDIR)/../poc/res/shadow
+SHADOW_DATA := $(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,$(SHADOW_DIR)/sk$(n).atl) \
+               $(foreach n,0 1 2 3,$(SHADOW_DIR)/sf$(n).atl)
+
 EXTRA_DATA  := $(BG_DATA) $(KID_DATA) $(KID_BIN) $(GUARD_DATA) $(SKEL_DATA) \
-               $(VIZIER_DATA) $(LVL_DATA)
+               $(VIZIER_DATA) $(SHADOW_DATA) $(LVL_DATA)
 include $(PROJ_ROOT)/app.mk

 # Образ HDD для MAME: ресурсы раскладываются ПО КАТАЛОГАМ (8.3, как в DSS),
@@ -130,6 +138,7 @@ hdd: $(EXAMPLE).exe
 	  $(foreach f,$(GUARD_DATA),GUARD:$(f)) \
 	  $(foreach f,$(SKEL_DATA),SKEL:$(f)) \
 	  $(foreach f,$(VIZIER_DATA),VIZIER:$(f)) \
+	  $(foreach f,$(SHADOW_DATA),SHADOW:$(f)) \
 	  $(foreach f,$(LVL_DATA),LEVELS:$(f))

 TC := $(PROJ_ROOT)/applications/PoP/toolchain
@@ -144,6 +153,9 @@ $(SKEL_DATA): $(TC)/pop_pack_guard.py
 $(VIZIER_DATA): $(TC)/pop_pack_guard.py
 	cd $(TC) && python3 pop_pack_guard.py VIZIER

+$(SHADOW_DATA) pop_shadow_atlas.h: $(TC)/pop_pack_shadow.py $(TC)/pop_pack_bg.py $(TC)/pop_pack_kid.py
+	cd $(TC) && python3 pop_pack_shadow.py
+
 $(KID_DATA): $(TC)/pop_pack_kid.py $(TC)/pop_pack_bg.py
 	cd $(TC) && python3 pop_pack_kid.py
 kid_data.h $(KID_BIN): $(TC)/pop_extract_kid_data.py
@@ -230,8 +230,10 @@ fore-слоя, и клип (`clip_char`), и брызги; полоса HP и л
 | # | Задача | Что | Блокирует |
 |---|--------|-----|-----------|
 | — | [DRAW-COST](#draw-cost) | **кадр уложился в бюджет 2026-08-09**: 470 964 -> 425 600 тактов, период цикла 4 растровых кадра -> **3**.  Дальнейшее — запас, не срочность | плавность на ВСЕХ уровнях |
-| — | [L1-SPEED](#l1-speed) | игра на ~39 % быстрее оригинала | ощущение от ВСЕХ уровней; берётся в любой момент |
+| ✔ | [L1-SPEED](#l1-speed) | **закрыта 2026-08-19** режимами скорости (NORMAL = 4/5 растров, как оригинал) | — |
 | — | [TUNE-1](#tune-1) | параметры движка → cfg-файл (сейчас `pop_tune.h`) | отладка таймингов и моды; берётся по мере надобности |
+| — | [TUNE-2](#tune-2) | параметры СТРАЖЕЙ (6 таблиц по 12 градаций мастерства + HP) → cfg-файл | подбор сложности боя без пересборки |
+| — | [SND](#snd) | звук: эффекты через CBL, музыка на AY | разбор готов — `../docs/sound_plan.md` |
 | — | [MEM](#mem-next) | следующий шаг разгрузки W1/W2 | берётся по факту нехватки места |

 Сделанное — в [`TASKS_CLOSED.md`](TASKS_CLOSED.md): L4-MIRROR, L3-CHOMP,
@@ -1120,7 +1122,17 @@ F6/F9).  Значит повторяем не букву, а устройств
 **Критерий приёмки:** сохранить, выйти по `ESC`, запустить roomtest заново,
 загрузить — и оказаться там же.

-### <a id="l1-speed"></a>L1-SPEED. Игра идёт быстрее оригинала (найдено 2026-08-01)
+### <a id="l1-speed"></a>L1-SPEED. Игра идёт быстрее оригинала (найдено 2026-08-01) — ЗАКРЫТА 2026-08-19
+
+**Закрыта** режимами скорости (`pop_pace.h`, клавиша **P**): FASTEST 3/3,
+FAST 3/4, **NORMAL 4/5 = 81,9 / 102,4 мс** против 83,3 / 100 мс у
+оригинала.  Условие боя взято буквально из SDLPoP (`seg003.c:363`):
+`Kid.sword == SWORD_2_DRAWN`.  Дефолт — FASTEST (решение пользователя).
+Проверено в MAME: период ровно 4 и ровно 5 растров.  Разбор и замеры —
+`../docs/frame_pacing_plan.md`.  Осталось из исходной формулировки только
+сверить NORMAL секундомером рядом с живым SDLPoP.
+
+Исходная запись:

 Сверка таймингов: оригинал — `BASE_FPS = 60` при `base_speed = 5` тиков на
 логический кадр (`SDLPoP/src/types.h:1373`, `data.h:869`) = **83.3 мс**, в бою
@@ -1158,6 +1170,67 @@ HP/минуты, номера «особых» комнат и уровней (
 **Оговорка по памяти.**  Парсер и таблица параметров — холодный код,
 исполняется один раз при старте: кандидат в банк, а не в резидент W1.

+### <a id="tune-2"></a>TUNE-2. Параметры СТРАЖЕЙ — в CFG-файл
+
+Частный, но самый востребованный срез [TUNE-1](#tune-1): сейчас весь ИИ
+стража зашит константами, и чтобы попробовать «а если он будет блокировать
+пореже» — надо пересобирать.
+
+**Что настраивать.**  Всё, что индексируется мастерством (12 градаций,
+`NUM_GUARD_SKILLS`), — таблицы в `guards.c`:
+
+| таблица | что решает | дефолт для навыка 4 |
+|---|---|---:|
+| `STRIKEPROB` | вероятность удара | 61 |
+| `RESTRIKEPROB` | добить из своего парирования | 5 |
+| `BLOCKPROB` | заблокировать замах | 200 |
+| `IMPBLOCKPROB` | то же, когда Кид только что пробил блок | 100 |
+| `ADVPROB` | наступать | 255 |
+| `REFRACTIMER` | «отдышка» после ранения, кадров | 8 |
+| `extrastrength` | надбавка HP (сейчас зашита как `skill == 4 ? 1 : 0`, `pop_guard_cold.c`) | 1 |
+
+Плюс не зависящее от навыка: `tbl_guard_hp[16]` (`pop_level_cold.c`) — база
+HP по уровню, и навык скелета (`SKEL_SKILL`) / тени (`SHADOW_SKILL`).
+
+**Формат — как у SDLPoP**, чтобы правки переносились в обе стороны без
+перевода: секции `[Skill 0]`..`[Skill 11]`, внутри `strikeprob=`,
+`blockprob=` и т.д. (`options.c:439`, пример — `SDLPoP/SDLPoP.ini:562`).
+Имена ключей брать ЕГО, регистр игнорировать.
+
+**Чего НЕ делать.**  Навык конкретного стража живёт в данных уровня
+(`level.guards_skill[комната-1]`, читаем в `pop_level_guard`) — его в CFG
+не тащим, иначе разъедется с файлами уровней.  Переопределение «в комнате
+N навык M» — отдельная надобность, если понадобится, то как явная секция
+`[Level N]`, а не подмена данных.
+
+**Зачем это стоит сделать.**  Прогон 2026-08-20 (11/22, навык 4) дал
+ощущение «страж тяжелее, чем в SDLPoP».  Сверка кода расхождений не нашла
+(протокол — в `../docs/impl_diff.md` и в ответе сессии: дистанция,
+диспетчер, три ветки ИИ, шесть таблиц, `justblocked`, `check_hurting`,
+`parry`, `swordfight`, порядок тиков, откат seq_74 = −10 — всё совпало
+побайтно).  Проверить такую гипотезу можно только подбором чисел на живом
+прогоне, а для этого их надо крутить без пересборки.
+
+**Оговорка по памяти** — та же, что в TUNE-1: парсер холодный, в банк.
+
+### <a id="snd"></a>SND. Звук — эффекты через CBL, музыка на AY
+
+Полный разбор с замерами — [`../docs/sound_plan.md`](../docs/sound_plan.md).
+Коротко, почему это оказалось дешевле, чем выглядело:
+
+- эффекты уже лежат **8-битным PCM на 11 000 Гц**, а у CBL есть режим
+  10 937,5 Гц (расхождение 0,6 %) и ровно тот же формат сэмпла —
+  **играются как есть, без конверсии**; 31 звук, 103 941 Б ≈ 6,3
+  EMM-страницы;
+- музыка есть **нотами PC-спикера, 7 КБ на всю игру**, причём нота задана
+  прямо в ГЕРЦАХ — пересчёт в период AY это одно деление; MIDI разбирать
+  не нужно;
+- AY и COVOX сведены в один ЦАП, поэтому играют одновременно;
+- отдельный таймер не нужен: секвенсор музыки двигает CBL-callback
+  (11,7 мс), а короче 12 мс во всей музыке всего 2 ноты из 1469.
+
+Фазы З1..З5 и список «проверить артефактом до кодинга» — в доке.
+
 ### <a id="mem-next"></a>MEM. Следующий шаг разгрузки W1/W2

 `pop_ctrl.c` уехал в банк 5 ([MEM-BANK5](TASKS_CLOSED.md#mem-bank5), куча
@@ -973,14 +973,15 @@ static void hurt_by_sword(void)
         * нет ни одной — управление зависало намертво: Кид стоял в боевой
         * стойке без меча и не разворачивался к сопернику (BUG-CHEAT-IMM-1).
         *
-         * Ветку глушим на время вызова, а не правим pop_take_hp: тот общий
-         * с физикой (падения/пики/чомперы), и там бессмертие обязано
-         * работать при любом положении меча. */
-        uint8_t imm = pop_immortal;
-        pop_immortal = 0;
+         * Костыля «снять бессмертие на время вызова» здесь БОЛЬШЕ НЕТ:
+         * pop_take_hp гасит только урон меньше 100, а тут ровно 100. */
        pop_take_hp(100);
-        pop_immortal = imm;
        pop_char_set_seq(SEQ_85_STABBED_TO_DEATH);
+    } else if (Char.charid == CHARID_0_KID && pop_immortal) {
+        /* ЧИТ, уровень 1 и выше: в боевой стойке удары не отнимают HP.
+         * Кадр «получил удар» оставляем — иначе бой перестаёт читаться,
+         * да и оригинал на выживший удар ставит ровно его. */
+        pop_char_set_seq(SEQ_74_HIT_BY_SWORD);
    } else if (Char.charid != CHARID_4_SKELETON && pop_take_hp(1)) {
        pop_char_set_seq(SEQ_85_STABBED_TO_DEATH);   /* HP кончились */
    } else {
@@ -14,6 +14,7 @@
 #include <fcntl.h>
 #include <unistd.h>
 #include "pop_bg.h"
+#include "pop_pace.h"    /* pop_beam_sample — счёт кадров по лучу */
 #include "_pop_bg.h"   /* контракт с холодной половиной (pop_room.c, банк 7) */
 #include "pop_tile.h"
 #include "pop_map.h"       /* pop_upside — переворот (зелье инверсии) */   /* общие листья слоя фона (резидент): блит, тайлы, таблица */
@@ -57,6 +58,7 @@ static void ov_mark(int x, int y, int w, int h)

 void pop_fore_heal(void) __banked
 {
+    pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
    uint8_t pg = gfx_get_draw_page() & 1;
    if (!(ov_pending & (1 << pg))) return;
    pop_heal_off(ov_x0, ov_y0, ov_x1 - ov_x0, ov_y1 - ov_y0);
@@ -197,6 +199,7 @@ static const uint8_t WR_RULE[4][6] = {

 static void wall_rnd(int row, int col)
 {
+    pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
    /* Кэшируем только штатную сетку: колонка вне 0..9 дала бы индекс
     * соседнего РЯДА и чужую раскладку (тихий баг вместо промаха). */
    int idx = (col >= 0 && col < 10) ? (row + 1) * 10 + col : -1;
@@ -282,6 +285,7 @@ static uint8_t wpp_d[5];               /* пять prandom(2), 0..2 */

 static void wall_rnd_palace(int row, int col)
 {
+    pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
    int idx = (col >= 0 && col < 10) ? (row + 1) * 10 + col : -1;
    pop_rnd_t saved;
    uint8_t i;
@@ -366,6 +370,7 @@ static void wpp_fill(int x, int ytop, int w, int h, uint8_t colour)

 static void wall_pattern_palace(int row, int col, int which_part)
 {
+    pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
    int xh = POP_COL_XH[col];
    int dbys = 63 * row + 65;                  /* база БЕЗ POP_YOFF — для блитов */
    int dmys = dbys - 3;
@@ -411,6 +416,7 @@ static void wall_pattern_palace(int row, int col, int which_part)

 static void wall_pattern(int row, int col, int which_part)
 {
+    pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
    int xh = POP_COL_XH[col];
    int dby = 63 * row + 65;
    uint8_t parts;
@@ -450,6 +456,7 @@ static void wall_pattern(int row, int col, int which_part)
 /* Решётка ворот (portcullis) из ЛЕВОЙ комнаты (seg008.c:1110). */
 static void draw_gate_back(uint8_t modl, int xh, int dby, int dmy)
 {
+    pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
    int x = xh * 8;
    int gate_top_y = dby - 62;
    int openness = (((modl > 188) ? 188 : modl) >> 2) + 1;
@@ -480,6 +487,7 @@ static void draw_gate_back(uint8_t modl, int xh, int dby, int dmy)
 * Клип по прямоугольнику персонажа делает pop_t_fclip (см. pop_tile.h). */
 static void draw_gate_fore(uint8_t modl, int xh, int dby, int dmy)
 {
+    pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
    int x = xh * 8;
    int gate_top_y = dby - 62;
    int openness = (((modl > 188) ? 188 : modl) >> 2) + 1;
@@ -576,6 +584,7 @@ static const uint8_t FORE_ANY[32] = {
 /* Контекст ft_* обязан быть проставлен вызывающим. */
 static void fore_only_tile(int row, int col)
 {
+    pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
    /* Нажатая кнопка → пол/stuck (get_tile_to_draw) — это уже учтено в ft_code
     * (его ставит pop_tile_code_drawn), иначе поверх Kid лезет передняя грань
     * КНОПКИ. */
@@ -622,6 +631,7 @@ static void fore_only_tile(int row, int col)
 * backtable — под персонажем. */
 static void ceil_over_kid_tile(int col)
 {
+    pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
    uint8_t code = pop_tile_code(-1, col);
    const piece *t = &pop_tile_table[code];
    int x = POP_COL_XH[col] * 8;
@@ -711,6 +721,7 @@ static void other_overlay_tile(int row, int col);   /* fwd (draw_floor_overlay -

 static void climb_overlay_tile(int row, int col, uint8_t fidx)
 {
+    pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
    /* тип — ПОДСТАВЛЕННЫЙ (нажатая кнопка = пол): иначе кромка, за которую
     * Kid спускается/подтягивается, закрашивается целым тайлом */
    uint8_t code;
@@ -747,6 +758,7 @@ static void climb_overlay_tile(int row, int col, uint8_t fidx)
 * draw_tile_base, draw_tile_anim (свои пики) и draw_tile_bottom. */
 static void overlay_mid_tile(int row, int col)
 {
+    pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
    uint8_t code = pop_tile_code_drawn(row, col);
    uint8_t lcode = pop_tile_code_drawn(row, col - 1);
    const piece *t;
@@ -809,6 +821,7 @@ static void overlay_mid_tile(int row, int col)
 * сразу), поэтому порядок эмулируется явной проверкой. */
 static void other_overlay_tile(int row, int col)
 {
+    pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
    uint8_t code, left;
    if (!tile_in_fclip(row, col)) return;
    code = pop_tile_code(row, col);
@@ -853,6 +866,7 @@ static void other_overlay_tile(int row, int col)
 void pop_mob_overlay_tile(int row, int col, int8_t oref_row, int8_t oref_col,
                         int mx, int my, uint8_t mh) __banked
 {
+    pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
    int8_t saved_row = pop_bg_obj_row, saved_col = pop_bg_obj_col;
    pop_bg_obj_row = oref_row;
    pop_bg_obj_col = oref_col;
@@ -952,6 +966,7 @@ static void char_footprint(int obj_x, int obj_y, uint16_t w, uint16_t h,
 * ничем не режется. */
 void pop_fore_tile_b(int row, int col) __banked
 {
+    pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
    uint8_t saved = pop_t_fclip_on;
    pop_t_fclip_on = 0;
    fore_tile(row, col);
@@ -974,6 +989,7 @@ void pop_fore_tile_b(int row, int col) __banked
 * странице её надо будет восстановить (pop_fore_heal). */
 void pop_ceil_fore_tile_b(int col) __banked
 {
+    pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
    int x = POP_COL_XH[col] * 8;
    /* ov_mark ЗДЕСЬ НЕ НУЖЕН, и это важно для бюджета.  Передние куски потолка
     * рисуются от dby = 2, то есть занимают строки 0..2 поля, а пометку ставит
@@ -999,6 +1015,7 @@ void pop_fore_pass_end(void)   __banked { gfx_set_bank(GFX_BANK_NORMAL); }
 void pop_fore_over_char(const pop_char_t *ch, int obj_x, int obj_y,
                        uint16_t w, uint16_t h) __banked
 {
+    pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
    int8_t cL, cR, cLraw, rT, rB, rTraw, r, c;
    uint8_t frame = ch->frame, action = ch->action;
    pop_t_fclip_on = 1;                          /* окно = прямоугольник спрайта */
@@ -23,6 +23,8 @@
 #include "_pop_kdraw.h"
 #include "pop_vflip.h"   /* зеркальные страницы атласов (зелье инверсии) */   /* меч + блит по id — сосед по банку 4 */          /* атласы/кадр Кида, pop_sword_draw, окна Char */
 #include "pop_cdraw.h"
+#include "pop_shadow.h"   /* запечённый набор Тени */
+#include "pop_pace.h"    /* pop_beam_sample — счёт кадров по лучу */
 #include "pop_state.h"   /* ВРЕМЕННО: зонды pop_dbg_b* */
 #include "pop_bg.h"           /* POP_YOFF, pop_fore_over_char, pop_fore_set_clip */
 #include "_pop_draw.h"   /* pop_onscreen_cols / pop_heal_fast */
@@ -507,6 +509,7 @@ static void cd_splash(pop_cdraw_t *s, uint8_t who, const atlas_t *pages,
        if (top + rows > 192) rows = 192 - top;
        if (rows <= 0) return;
        gfx_set_bank(GFX_BANK_SPRITE);
+        pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
        if (pop_onscreen_cols(qx, top + POP_YOFF, w, (uint8_t)rows))
            gfx_blit_cols_part_noclip(qx, top + POP_YOFF, img, flip,
                                      (uint8_t)skip, (uint8_t)rows);
@@ -525,6 +528,10 @@ void pop_char_draw(uint8_t who) __banked
    const pop_char_t *ch;
    const kframe *fr;
    const atlas_t *pages;
+    /* Атлас БРЫЗГ отдельно от кадра: у оригинала они всегда из «своего»
+     * chtab (Кид — chtab_2 image 218, прочие — chtab_5 image 1,
+     * seg006:2019), а у Тени кадр может прийти из другой половины набора. */
+    const atlas_t *spl;
    const uint8_t *img;
    uint8_t npages, page, idx, dp, flip, hurt, lskip;
    uint8_t  w, h, vis_w;
@@ -547,19 +554,31 @@ void pop_char_draw(uint8_t who) __banked
    if (who == POP_CH_KID) {
        pop_loadkid();
        ch = &Kid;  fr = &kid_frame;  pages = kidp;  npages = kid_npages;
+        spl = kidp;
        hurt = pop_kid_hurt;
    } else {
        pop_loadshad();
        ch = &Guard; fr = &pop_gframe; pages = gp;
        npages = g_ok ? GUARD_PAGES : 0;
+        spl = gp;
        hurt = pop_guard_hurt;
        if (Guard.charid == 0) return;      /* соперника на сцене нет */
-        /* ТЕНЬ (ур. 4) — это зеркальный Кид: вне боевых кадров 150..189 она
-         * ходит по таблице КИДА (seg006:0532), а `image` из неё индексирует
-         * спрайты Кида, а не стража.  Набор атласов обязан идти за таблицей —
-         * условие берём из того же места, что load_frame, чтобы они не
-         * разъехались. */
-        if (!pop_frame_tbl_is_guard(Guard.charid, Guard.frame)) {
+        /* Набор атласов обязан идти за ТАБЛИЦЕЙ КАДРОВ — условие берём из
+         * того же места, что load_frame (seg006:0532), чтобы они не
+         * разъехались: вне боевых кадров 150..189 Тень ходит по таблице
+         * КИДА, и `image` из неё индексирует спрайты Кида. */
+        if (Guard.charid == CHARID_1_SHADOW && pop_shadow_kid_n) {
+            /* У Тени СВОЙ запечённый набор (pop_shadow.h): её вид даёт
+             * наложение спрайта на себя со сдвигом, а пакетный блит так не
+             * умеет.  Обе половины лежат в нём же, поэтому подмены на kidp
+             * здесь уже не нужно. */
+            if (pop_frame_tbl_is_guard(Guard.charid, Guard.frame)) {
+                pages = pop_shadow_fgt; npages = pop_shadow_fgt_n;
+            } else {
+                pages = pop_shadow_kid; npages = pop_shadow_kid_n;
+            }
+            spl = pop_shadow_fgt;      /* брызги — из половины chtab_5 */
+        } else if (!pop_frame_tbl_is_guard(Guard.charid, Guard.frame)) {
            pages = kidp; npages = kid_npages;
        }
    }
@@ -713,6 +732,7 @@ void pop_char_draw(uint8_t who) __banked
        if (top < 0) { skip += -top; rows += top; top = 0; }
        if (top + rows > 192) rows = 192 - top;
        gfx_set_bank(GFX_BANK_SPRITE);   /* видео-ОЗУ, без теневой копии */
+        pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
        if (rows > 0 && vis_w) {         /* +YOFF: центрирование */
            /* noclip-ядро ширину не ограничивает, поэтому при обрезке справа
             * идём общим путём: это редкие кадры (подъём в двери уровня раз
@@ -738,7 +758,7 @@ void pop_char_draw(uint8_t who) __banked
                                         /* по нему считается футпринт      */
    }
    pop_dbg_m15();              /* ЗАМЕР: снимок прямоугольника сделан */
-    if (hurt) cd_splash(s, who, pages, fp_x, obj_y);
+    if (hurt) cd_splash(s, who, spl, fp_x, obj_y);
    /* add_sword_to_objtable (seg006:1798): клинок отдельным спрайтом поверх
     * персонажа — со своим прямоугольником heal. */
    {
@@ -865,6 +885,7 @@ void pop_mirror_draw(int clip_top) __banked
    }

    gfx_set_bank(GFX_BANK_SPRITE);
+    pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
    if (lskip)
        gfx_blit_cols_part_wx(bx, top + POP_YOFF, img, flip, skip, rows,
                              lskip, (uint8_t)(vis_w - lskip));
@@ -965,9 +986,11 @@ void pop_hp_draw(void) __banked
        if (w && h) {
            /* Атлас стража тоже column-major — блит колоночный. */
            n = (uint8_t)(gd > HP_MAXDRAW ? HP_MAXDRAW : gd);
-            for (i = 0; i < n; i++)
+            for (i = 0; i < n; i++) {
+                pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
                gfx_blit_cols_part_noclip(314 - (int)i * HP_STEP,
                                          HP_Y + POP_YOFF, img, 0, 0, 0);
+            }
        }
        gfx_w0_unmap();
    }
@@ -19,7 +19,9 @@
 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_IMMO 0x43     /* I (PS/2 set 2) — бессмертие Кида по кругу
+                                 * 0 -> 1 (только бой) -> 2 (и мелкий урон) -> 0;
+                                 * уровни расписаны в pop_state.h */
 #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 влево  */
@@ -18,12 +18,15 @@
 #include <stdint.h>
 #include <gfx.h>
 #include "_pop_draw.h"
+#include "pop_pace.h"    /* pop_beam_sample — счёт кадров по лучу */

 void pop_heal_fast(int x, int y, int w, int h)
 {
+    pop_beam_sample();      /* ТЕМП КАДРА: выборка луча, см. pop_pace.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);
+    pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */   /* и ПОСЛЕ: широкий heal сам по себе ~70 000 тактов */
 }
@@ -85,7 +85,14 @@ void pop_guard_kill(void)
 uint8_t pop_take_hp(uint8_t count)
 {
    if (Char.charid == CHARID_0_KID) {
-        if (pop_immortal) return 0;
+        /* ЧИТ БЕССМЕРТИЯ, уровень 2 (pop_state.h): гасим ТОЛЬКО мелкий урон
+         * — падение с двух этажей, придавливание плитой.  Мгновенная смерть
+         * (пики, чомпер, падение с трёх этажей, удар вне боевой стойки)
+         * приходит с count = 100 и проходит всегда: у читa нет задачи
+         * отменять смерть, у него задача отменить «минус одно деление».
+         * Уровень 1 сюда не вмешивается вовсе — он живёт в hurt_by_sword и
+         * гасит только удары мечом. */
+        if (pop_immortal >= 2 && count < 100) return 0;
        if (count >= hitp_curr) { hitp_delta = (int8_t)-hitp_curr; return 1; }
        hitp_delta = (int8_t)-(int8_t)count;
    } else {
@@ -17,6 +17,7 @@
 #include <sprite.h>
 #include "pop_kid.h"
 #include "_pop_kdraw.h"
+#include "pop_pace.h"    /* pop_beam_sample — счёт кадров по лучу */
 #include "pop_guard.h"        /* CHARID_* — клинок есть и у стража  */
 #include "pop_bg.h"           /* POP_YOFF — вертикальное центрирование */
 #include "_pop_draw.h"        /* pop_onscreen_cols */
@@ -103,6 +104,7 @@ uint8_t pop_sword_draw(const pop_char_t *ch, const kframe *fr,
        if (top + rows > 192) rows = 192 - top;
        if (rows <= 0) return 0;
        gfx_set_bank(GFX_BANK_SPRITE);
+        pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
        /* Клинок почти всегда целиком на экране — noclip-путь (см. gfx.h:
         * подготовка клипающего варианта стоит ~5.6 К тактов на вызов). */
        if (pop_onscreen_cols(bx, top + POP_YOFF, w, (uint16_t)rows))
@@ -121,6 +123,7 @@ uint8_t pop_sword_draw(const pop_char_t *ch, const kframe *fr,
 * Кида, а держать вторую копию раскладки в pop_cdraw ни к чему. */
 void pop_kid_img_blit(uint8_t image, int x, int y)
 {
+    pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
    uint8_t pg  = (uint8_t)(image >> 3);   /* раскладка атласов: 8 спрайтов/стр. */
    uint8_t idx = (uint8_t)(image & 7);
    const uint8_t *img;
@@ -19,6 +19,7 @@
 #include <string.h>          /* memcpy = LDIR: цикл на C тут стоил ~390 тактов на байт */
 #include "pop_kid.h"
 #include "pop_map.h"
+#include "pop_pace.h"    /* pop_beam_sample — счёт кадров по лучу */
 #include "pop_ctrl.h"          /* pop_ctrl_shift_held() — для check_grab */
 #include "pop_geom.h"          /* общая геометрия (x_bump/y_land/y_to_row) */
 #include "pop_tile.h"          /* POP_TILE_DIV/MOD — деление на ширину тайла таблицей */
@@ -1994,14 +1995,17 @@ static void check_collisions(void)
    }

    pop_dbg_p2();                          /* ЗАМЕР: вход в тело */
+    pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
    set_char_collision();
    pop_dbg_p3();                          /* ЗАМЕР: set_char_collision */
+    pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
    move_coll_to_prev(Char.curr_row);      /* заодно снимет окно prev */
    coll_prev_row = Char.curr_row;
    calc_coll_window();
    coll_lo = win_lo; coll_hi = win_hi;
    coll_scan_prepare();
    pop_dbg_p4();                          /* ЗАМЕР: окно посчитано */
+    pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
    /* Порядок важен: prev уже забран, теперь три ряда пересчитываются
     * НА ЭТОТ кадр (в оригинале ровно так же, seg004:0004).  Ряд здесь
     * гарантированно 0..2, поэтому соседние ряды — это те же базы ±10, без
@@ -2036,6 +2040,7 @@ static void check_collisions(void)
        coll_row(coll_above);
    }
    pop_dbg_p5();                          /* ЗАМЕР: три ряда просканированы */
+    pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
    /* Обход СВЕРХУ ВНИЗ, как в оригинале (9→0): побеждает МЛАДШАЯ колонка,
     * в которой флаг перешёл 0→1.  Только по ПЕРЕСЕЧЕНИЮ окон: вне его
     * сравнивать нечего (у оригинала там prev_coll_room != curr_row_coll_room
@@ -2685,6 +2690,7 @@ void pop_loose_tick(void) __banked
     * Инкремент+сравнение считают row/col без деления. */
    uint8_t row = 0, col = 0;
    pop_dbg_m9();                       /* ЗАМЕР: вход pop_loose_tick */
+    pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
    /* Гейт холостого хода: если ни одна фаза не взведена, оба цикла (30 + 10
     * позиций) пропускаем целиком — замер 11/15 дал 9 852 такта на комнату,
     * где loose-плит нет вовсе.  Флаг ставят места записи фазы, снимаем его
@@ -3164,11 +3170,14 @@ static void kid_phys(void)
    bump_into_opponent(); /* seg003: безоружный Кид отскакивает от стража */
    check_collisions();   /* seg004: флаги перекрытия по колонкам ряда */
    pop_dbg_p6();         /* ЗАМЕР: check_collisions целиком */
+    pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
    check_bumped();       /* удержать у стены до check_action (порядок PoP) */
    check_action();
    pop_dbg_p7();         /* ЗАМЕР */
+    pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
    check_press();        /* seg006: стойка/пробой loose → make_loose_fall */
    pop_dbg_p8();         /* ЗАМЕР */
+    pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
    check_spike_below();  /* seg006: над колонкой с пиками → выдвинуть пики */
    check_spiked();       /* seg006: напоролся на вредные пики → смерть */
    check_chomped_kid();  /* seg004: перемололо в сомкнутых челюстях → смерть */
@@ -3229,6 +3238,7 @@ void pop_phys_tick(void) __banked
     * кончился), а уход из комнаты и сотрясение отсечены внутри kid_phys. */
    pop_loadkid_and_opp();
    pop_dbg_p1();         /* ЗАМЕР: окно Char загружено */
+    pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
    kid_phys();
    pop_savekid_and_opp();
 }
@@ -0,0 +1,100 @@
+/*
+ * pop_pace.c — фиксированный логический кадр по лучу.  Зачем именно так,
+ * а не по счётчику кадровых прерываний — в шапке pop_pace.h (там же
+ * условие точности и замеры).
+ *
+ * Модуль НЕ банковый (EXTRA_SRCS): pop_beam_sample зовётся из банков
+ * рисования, а базовый код в W1 доступен им прямым call — трамплин на
+ * каждую выборку съел бы весь смысл.
+ */
+
+#include <stdint.h>
+#include <gfx.h>
+#include <kbd_raw.h>
+#include "pop_pace.h"
+
+uint8_t          pop_speed_mode;    /* crt0 зануляет _DATA → NORMAL */
+volatile uint8_t pop_frame_tick;
+
+/* Бит 5 порта 0xFE на прошлой выборке: 0 или 0x20.  На виду у asm-тела. */
+uint8_t pop_beam_prev;
+
+static uint8_t pace_anchor;         /* тик на начало текущего логического кадра */
+static uint8_t pace_ok;             /* 0 — луч не работает, откат на gfx_wait_vsync */
+
+/* ---- выборка луча --------------------------------------------------- *
+ * in a,(0xFE) кладёт A на старший байт адреса (выбор ряда клавиатуры) —
+ * биты 5/7 от него не зависят, так же читает и gfx_wait_vsync.
+ * Быстрый путь (состояние не изменилось) — 40 T + вызов. */
+void pop_beam_sample(void) __preserves_regs(b, c, d, e) __naked
+{
+    __asm
+        in    a, (#0xFE)
+        and   a, #0x20
+        ld    hl, #_pop_beam_prev
+        cp    a, (hl)
+        ret   Z                      ; состояние то же — выходим сразу
+        ld    (hl), a
+        or    a, a
+        ret   NZ                     ; 0→1: вошли в бланк, это не граница
+        ld    hl, #_pop_frame_tick
+        inc   (hl)                   ; 1→0: vpos = 0, начало кадра
+        ret
+    __endasm;
+}
+
+uint8_t pop_pace_arm(void)
+{
+    uint16_t tries;
+    uint8_t  t0;
+
+    /* Взводит cbl_mode (_cbl_port_ref) и заодно ставит нас на фронт. */
+    gfx_wait_vsync();
+
+    /* Затравка beam_prev без ложного фронта: что бы луч ни показал сейчас,
+     * первая выборка либо совпадёт (ранний выход), либо запишет 0x20 и
+     * уйдёт по ветке «вошли в бланк». */
+    pop_beam_prev = 0;
+    pop_beam_sample();
+
+    t0 = pop_frame_tick;
+    for (tries = 0; tries < 20000; tries++) {
+        pop_beam_sample();
+        if ((uint8_t)(pop_frame_tick - t0) >= 2) {
+            pace_anchor = pop_frame_tick;
+            pace_ok = 1;
+            return 1;
+        }
+    }
+    pace_ok = 0;                     /* бит не шевелится — прежнее поведение */
+    return 0;
+}
+
+void pop_wait_edge(void)
+{
+    uint8_t t;
+    if (!pace_ok) { gfx_wait_vsync(); return; }
+    t = pop_frame_tick;
+    do {
+        pop_beam_sample();
+        kbd_raw_poll();              /* KBD-1: опрос обязан быть плотным */
+    } while (pop_frame_tick == t);
+}
+
+void pop_pace_end(uint8_t n)
+{
+    if (!pace_ok) {                  /* откат: как было — добрать ожиданиями */
+        while (--n) gfx_wait_vsync();
+        return;
+    }
+    while ((uint8_t)(pop_frame_tick - pace_anchor) < n)
+        pop_wait_edge();
+    pace_anchor = pop_frame_tick;    /* якорь ПО ФАКТУ — фаза не копится */
+}
+
+uint8_t pop_pace_n(uint8_t fight)
+{
+    if (pop_speed_mode == POP_SPEED_NORMAL) return fight ? 5 : 4;
+    if (pop_speed_mode == POP_SPEED_FAST)   return fight ? 4 : 3;
+    return 3;                        /* FASTEST: и вне боя, и в бою */
+}
@@ -0,0 +1,102 @@
+/*
+ * pop_pace.h — фиксированный логический кадр (frame pacing) по ЛУЧУ.
+ *
+ * Задача: период логического кадра = max(n, ceil(W)) вместо нынешнего
+ * ceil(W) + 2, где W — работа в растровых кадрах.  Сегодня главный цикл
+ * ждёт три gfx_wait_vsync ПОСЛЕ отрисовки, поэтому реальный бюджет кадра
+ * — один растр (430 080 тактов), и превышение его на такт стоит целого
+ * лишнего растра.  При n=3 бюджет становится 1 290 240.
+ *
+ * ПОЧЕМУ НЕ СЧЁТЧИК КАДРОВЫХ ПРЕРЫВАНИЙ (замеры 2026-08-19, MAME, полный
+ * разбор в docs/frame_pacing_plan.md).  Импульс запроса кадрового
+ * прерывания живёт 32 такта неразогнанного клока = 9,14 мкс, а ядра
+ * акселератора держат di на весь чанк блита (~0,29 мс).  Импульс,
+ * попавший в такое окно, теряется насовсем — ядро z80 уровневое, защёлки
+ * нет (то же и на настоящем Spectrum).  Замерено: в сцене 11/15 теряется
+ * от 0 до 2,8 % прерываний в зависимости от ФАЗЫ рендера относительно
+ * луча, а на полной перерисовке комнаты — три подряд.  Сейчас фаза
+ * плавает (период то 3 растра, то 4) и потери размазаны; при жёстком
+ * пейсинге фаза застынет, и сцена может залипнуть в плохой — это ровные
+ * −25 % скорости, невидимые в профиле тактов.
+ *
+ * ЧТО ВМЕСТО.  Бит 5 порта 0xFE — это ЧТЕНИЕ ПОЛОЖЕНИЯ ЛУЧА (1, когда
+ * vpos >= 272; MAME sprinter.cpp kbd_fe_r), а не событие: ни импульса,
+ * ни очереди, ни защёлки.  Такой сигнал невозможно потерять — можно
+ * только не посмотреть.  Считаем фронты 1→0 (это vpos = 0, ровно тот же
+ * момент, которого ждёт gfx_wait_vsync) программно, выборкой из точек,
+ * которые код и так проходит.
+ *
+ * УСЛОВИЕ ТОЧНОСТИ — ОДНО: между соседними выборками должно проходить
+ * меньше 64 512 тактов (длина окна «бит 5 = 1»: 48 строк из 320).  Тогда
+ * в каждый бланк попадает хотя бы одна выборка, а в промежуток между
+ * бланками (365 568 тактов) — тем более; значит каждый фронт засчитан
+ * ровно один раз.  Двойной счёт невозможен: инкремент только на переходе,
+ * и beam_prev тут же обновляется.  Условие не про нагрузку, не про di,
+ * не про прерывания и не про звук — только про зазор.
+ *
+ * Запас: самый длинный неделимый кусок без выборки — одно di-окно, то
+ * есть один вызов _bgi_blit_rows_raw, а он по контракту режется на чанки
+ * ≤16 строк.  Даже если считать грубо — одна выборка на целый блит, а
+ * самый дорогой замеренный блит 32 073 такта — зазор вдвое меньше окна.
+ *
+ * ВАЖНО: бит 5 читается осмысленно ТОЛЬКО при включённом cbl_mode (в
+ * MAME `data &= ~0xa0` стоит внутри `if (cbl_mode())`, иначе бит выставлен
+ * в 1 намертво).  Его лениво взводит сам gfx_wait_vsync через
+ * _cbl_port_ref, поэтому pop_pace_arm обязан один раз позвать
+ * gfx_wait_vsync и ПРОВЕРИТЬ, что фронты реально идут.
+ */
+#ifndef POP_PACE_H
+#define POP_PACE_H
+
+#include <stdint.h>
+
+/* Режимы скорости.  Растровый кадр Sprinter — 20,48 мс (48,83 Гц).
+ * Оригинал (SDLPoP/src/seg003.c:363): base_speed 5 тиков при 60 Гц =
+ * 83,3 мс, fight_speed 6 = 100 мс.  Условие боя у оригинала одно и
+ * буквальное — «у Кида ВЫНУТ МЕЧ» (Kid.sword == sword_2_drawn), не
+ * «идёт бой» и не «рядом страж»; проверяется в верху главного цикла. */
+/* Нумерация НЕ произвольная: 0 обязан быть дефолтом (crt0 зануляет _DATA),
+ * а обход по кругу инкрементом даёт ровно NORMAL -> FAST -> FASTEST.
+ * Заодно номер режима = число палочек в отладочной метке минус один. */
+#define POP_SPEED_NORMAL  0   /* 4/5 — 81,9 / 102,4 мс; повтор оригинала   */
+#define POP_SPEED_FAST    1   /* 3/4 — 61,4 / 81,9 мс; бой как в оригинале */
+#define POP_SPEED_FASTEST 2   /* 3/3 — 61,4 мс; не успели — подтормаживаем */
+#define POP_SPEED_MODES   3
+
+extern uint8_t pop_speed_mode;      /* POP_SPEED_*; дефолт — NORMAL */
+
+/* Клавиша смены режима по кругу (PS/2 set 2).  P — свободна: заняты
+ * K/I/S/L/U/[/] (читы, pop_cheat.h) и +/- (обход комнат). */
+#define KBD_SPEED_MODE 0x4D        /* P */
+
+/* Делитель для текущего режима.  fight = «у Кида вынут меч». */
+uint8_t pop_pace_n(uint8_t fight);
+
+/* Счётчик кадров.  volatile: его правит pop_beam_sample, а читают циклы
+ * ожидания — перечитывать обязаны каждый оборот. */
+extern volatile uint8_t pop_frame_tick;
+
+/* ВЫБОРКА ЛУЧА.  Дёшево (~57 T с вызовом), не трогает bc/de/ix.
+ * Звать отовсюду, где иначе получился бы зазор длиннее 64 512 тактов:
+ * из обёрток рисования и с границ фаз.  Модуль НЕ банковый, поэтому из
+ * банков зовётся прямым call, без трамплина. */
+void pop_beam_sample(void) __preserves_regs(b, c, d, e);
+
+/* Однократная подготовка: взвести cbl_mode, снять первое состояние бита
+ * и убедиться, что фронты идут.  0 — луч не работает (тогда пейсинг
+ * молча откатывается на прежнее поведение: n ожиданий gfx_wait_vsync). */
+uint8_t pop_pace_arm(void);
+
+/* Ждать ОДИН фронт луча.  Внутри — тот же плотный опрос клавиатуры, что
+ * сейчас висит idle-хуком на gfx_wait_vsync (KBD-1: без опроса раз в
+ * ~0,5 мс теряются нажатия и залипают клавиши). */
+void pop_wait_edge(void);
+
+/* Добрать до n фронтов ОТ ЯКОРЯ и переставить якорь ПО ФАКТУ.
+ * Вызывающий обязан перед этим сделать хотя бы один pop_wait_edge() —
+ * на нём же и происходит своп страниц (tear-free).  Якорь ставится
+ * по факту, а не anchor += n: догонять пропущенное время нельзя, иначе
+ * после тяжёлого кадра игра рванёт вперёд. */
+void pop_pace_end(uint8_t n);
+
+#endif
@@ -17,6 +17,7 @@
 #include <fcntl.h>
 #include <unistd.h>
 #include "pop_bg.h"
+#include "pop_pace.h"    /* pop_beam_sample — счёт кадров по лучу */
 #include "_pop_bg.h"    /* контракт с горячей половиной (pop_bg.c, банк 2) */
 #include "pop_tile.h"   /* общие листья слоя фона (резидент): блит, тайлы, таблица */
 #include "_pop_draw.h"   /* pop_onscreen_cols / pop_heal_fast */
@@ -625,6 +626,7 @@ void pop_loose_shake_draw(int row, int col) __banked
     * 42/71/72 = 26x15-16.  Задача HEAL-WIDTH. */
    pop_heal_off(x, 63 * row + 46, 58, 24);
    gfx_set_bank(GFX_BANK_SPRITE);
+    pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
    draw_tile(row, col);                           /* loose: лево+низ (анимир.) */
    if (col + 1 < 10)
        draw_tile(row, col + 1);                   /* сосед: правая грань loose (анимир.) + его пол */
@@ -662,6 +664,7 @@ void pop_chomp_anim_draw(int row, int col) __banked
    uint8_t pose = pop_chomp_pose(cm);

    gfx_set_bank(GFX_BANK_SPRITE);
+    pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
    pop_cd_batch_begin();                    /* одна пометка на все куски */
    pop_env_b(CHOMP_FRAM_BOT[pose], x, dmy);
    if (cm & 0x80)                           /* кого-то перемололо */
@@ -691,6 +694,7 @@ void pop_spike_redraw(int row, int col) __banked
     * (63*row+34 .. +74); ширина 64 = обе ячейки. */
    pop_heal_off(x, 63 * row + 34, 64, 40);
    gfx_set_bank(GFX_BANK_SPRITE);
+    pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
    draw_tile(row, col);
    if (col + 1 < 10)
        draw_tile(row, col + 1);
@@ -714,6 +718,7 @@ void pop_chomp_redraw(int row, int col) __banked
     * Было 64 «на всю высоту тайла» — четыре лишние строки. */
    pop_heal_off(x, 63 * row + 3, 32, 60);
    gfx_set_bank(GFX_BANK_SPRITE);
+    pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
    draw_tile(row, col);
    gfx_set_bank(GFX_BANK_NORMAL);
 }
@@ -866,6 +871,7 @@ void pop_ceil_shake_draw(int col) __banked
     * heal'а, — он её и стирает. */
    pop_cd_touch(x, POP_YOFF, 64, CEIL_BAND_H);
    gfx_set_bank(GFX_BANK_SPRITE);
+    pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
    pop_t_clip_top = POP_YOFF;
    pop_t_win_set(x, POP_YOFF, 64, CEIL_BAND_H);   /* восстанавливаем ровно полосу */
    draw_tile(-1, col);
@@ -975,6 +981,7 @@ void pop_potion_draw(int row, int col, uint8_t modif) __banked
    }
    pop_heal_off(x - 1, yb - 10, 8, 12);
    gfx_set_bank(GFX_BANK_SPRITE);
+    pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
    pop_pot_b(POT_MASK_ID, x, yb);                 /* маска (под пузырьком) */
    pop_pot_b(bubb, x, yb);                        /* кадр пузырька */
    gfx_set_bank(GFX_BANK_NORMAL);
@@ -1788,6 +1795,7 @@ static void mob_render(mob_t *m, uint8_t pg)
     * left(41) на obj_y-3, bottom(43) на obj_y, right(42) на obj_x+4 (=col+1,
     * заходит в тайл СПРАВА) на obj_y-1. */
    gfx_set_bank(GFX_BANK_SPRITE);
+    pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
    /* КЛИПА ОБЪЕКТА ЗДЕСЬ НЕТ.  У оригинала он есть — add_mob_to_objtable
     * (seg007:1161) ставит куску clip.right = 40, — но единицы этого поля я
     * НЕ выяснил: буквальные 40 экранных пикселей срезают правый задний угол
@@ -0,0 +1,88 @@
+/*
+ * pop_shadow.c — загрузка запечённого набора спрайтов Тени.  Зачем набор
+ * отдельный и почему половин две — в шапке pop_shadow.h.
+ *
+ * Код ХОЛОДНЫЙ (раз на уровень), поэтому живёт в банке 8 вместе с прочей
+ * загрузкой.  Сами atlas_t — в W2: их читает отрисовка из банка 4, а
+ * данные видны из любого банка.
+ */
+
+#include <stdint.h>
+#include <gfx.h>
+#include <sprite.h>
+#include "pop_shadow.h"
+#include "pop_shadow_atlas.h"
+
+atlas_t pop_shadow_kid[POP_SHADOW_KID_PAGES];
+atlas_t pop_shadow_fgt[POP_SHADOW_FGT_PAGES];
+uint8_t pop_shadow_kid_n, pop_shadow_fgt_n;
+
+/* ГРУЗИМ ОДИН РАЗ НА ЗАПУСК, а не по уровням.
+ *
+ * Тень бывает на ЧЕТЫРЁХ уровнях: 4 — рождается прыжком сквозь зеркало
+ * (jump_through_mirror, seg003:0811, ставит Char.charid = charid_1_shadow
+ * прямо из Кида), 5 — крадёт зелье, 6 — прыгает через пропасть, 12 —
+ * дерётся.  Читается как три, потому что таблиц init_shad_N всего три
+ * (5/6/12): четвёртой нет — на 4-м Тень копируется с Кида, а не поднимается
+ * из таблицы.  Так вот, напрашивается
+ * грузить набор только там, как это сделано с перевёрнутыми наборами
+ * (pop_vflip_load_all зовётся лишь на POP_UPSIDE_LEVEL).  Решение
+ * пользователя — грузить сразу, и оно правильное по двум причинам:
+ * страниц EMM с запасом (32 из ~215 свободных), а вот забыть перезагрузку
+ * на границе уровня легко — ровно так и появился BUG-SHADOW-SET.  Разовая
+ * загрузка убирает целый класс ошибок и заодно не тормозит переход между
+ * уровнями на 32 файла. */
+int pop_shadow_load(void) __banked
+{
+    uint8_t i;
+    if (pop_shadow_kid_n || pop_shadow_fgt_n) return 0;   /* уже загружен */
+
+    for (i = 0; i < POP_SHADOW_KID_PAGES; i++) {
+        if (atlas_load(&pop_shadow_kid[i], pop_shadow_kid_atl[i]) != 0) {
+            pop_shadow_free();
+            return -1;
+        }
+        pop_shadow_kid_n = (uint8_t)(i + 1);
+    }
+    for (i = 0; i < POP_SHADOW_FGT_PAGES; i++) {
+        if (atlas_load(&pop_shadow_fgt[i], pop_shadow_fgt_atl[i]) != 0) {
+            pop_shadow_free();
+            return -1;
+        }
+        pop_shadow_fgt_n = (uint8_t)(i + 1);
+    }
+
+    pop_shadow_pal_apply();
+    return 0;
+}
+
+/* ПАЛИТРА ОТДЕЛЬНО ОТ ЗАГРУЗКИ, и это не косметика.
+ *
+ * `gfx_pal_fload("KID\\kid.pal")` заливает ВСЕ 256 записей — это единая
+ * игровая палитра, — и затирает любые слоты, выставленные до него.  Ровно
+ * та же беда уже была с тайлсетом: сразу за ним стоит pop_bg_pal_apply,
+ * который возвращает цвета env/wall.  Наши 0xA0..0xAF из той же оперы, и
+ * в первом заходе я на это наступил: набор грузился, силуэт рисовался
+ * правильной формы, но ЦЕЛИКОМ ЧЁРНЫЙ (поймано пользователем на 6-м
+ * уровне).  Поэтому вызов живёт рядом с pop_bg_pal_apply, а не внутри
+ * загрузки атласов.
+ *
+ * Обе страницы дабл-буфера: у них свои палитры.  Через буфер в W2 —
+ * gfx_pal_load отдаёт указатель BIOS ($A4), а тот читает только
+ * #4000-#BFFF и банковую rodata не увидит. */
+void pop_shadow_pal_apply(void) __banked
+{
+    uint8_t buf[64], k;
+    if (!pop_shadow_kid_n) return;           /* набора нет — нечего красить */
+    for (k = 0; k < 64; k++) buf[k] = pop_shadow_pal[k];
+    gfx_pal_load(0, POP_SHADOW_PAL_BASE, 16, buf);
+    gfx_pal_load(1, POP_SHADOW_PAL_BASE, 16, buf);
+}
+
+void pop_shadow_free(void) __banked
+{
+    uint8_t i;
+    for (i = 0; i < pop_shadow_kid_n; i++) atlas_free(&pop_shadow_kid[i]);
+    for (i = 0; i < pop_shadow_fgt_n; i++) atlas_free(&pop_shadow_fgt[i]);
+    pop_shadow_kid_n = pop_shadow_fgt_n = 0;
+}
@@ -0,0 +1,55 @@
+/*
+ * pop_shadow.h — запечённый набор спрайтов ТЕНИ.
+ *
+ * Оригинал спрайтов Тени не хранит: он кладёт обычный спрайт дважды — в x
+ * прозрачным блитом и в x+1 «блиттером XOR» (draw_objtable_item,
+ * seg008.c:1600).  Пакетный блит так не умеет, поэтому результат запечён
+ * заранее (toolchain/pop_pack_shadow.py); разбор и замеры —
+ * ../docs/shadow_atlas_plan.md.
+ *
+ * ПОЛОВИН ДВЕ, и это не наша выдумка.  Набор спрайтов у оригинала выбирает
+ * не персонаж, а поле `sword` САМОГО КАДРА (load_frame_to_obj,
+ * seg008.c:1752: chtab_base жёстко = chtab_2, плюс `sword >> 6`).  У всех
+ * кадров таблицы Кида эти биты нулевые, у всех кадров таблицы стража —
+ * 0xC0.  Тень берёт таблицу стража для кадров 150..189 (seg006.c:533),
+ * значит идёт через chtab_5 — а chtab_5 на 12-м уровне грузится из
+ * SHADOW.DAT (tbl_guard_type[12] == 4), и это графика КИДА в боевых позах.
+ * Отсюда:
+ *
+ *   pop_shadow_kid[] — кадры вне боя (запечены из спрайтов Кида);
+ *   pop_shadow_fgt[] — кадры 150..189 (запечены из SHADOW.DAT).
+ *
+ * Какая половина нужна, отрисовка уже знает — тем же условием, что
+ * выбирает таблицу кадров (pop_frame_tbl_is_guard).
+ *
+ * СПРАЙТ ТЕНИ НА ПИКСЕЛЬ ШИРЕ исходного: второй проход оригинала кладётся
+ * в x+1, суммарный след занимает [x, x+w].  Рисовать по тем же
+ * координатам, что и Кида — сдвиг уже внутри спрайта.
+ */
+#ifndef POP_SHADOW_H
+#define POP_SHADOW_H
+
+#include <stdint.h>
+#include <sprite.h>
+
+extern atlas_t pop_shadow_kid[];    /* половина «вне боя»              */
+extern atlas_t pop_shadow_fgt[];    /* половина «в бою» (SHADOW.DAT)   */
+/* Сколько страниц реально загружено; 0 = набора нет (уровень без Тени
+ * или загрузка не удалась) — отрисовка тогда идёт прежним путём. */
+extern uint8_t pop_shadow_kid_n, pop_shadow_fgt_n;
+
+/* Загрузить набор.  Звать ОДИН РАЗ при старте: набор не зависит от
+ * уровня, а перезагрузка на границе — лишний повод её забыть (почему
+ * именно так — в шапке pop_shadow.c).  Повторный вызов — no-op.
+ * Возврат: 0 — OK, -1 — ошибка загрузки. */
+int  pop_shadow_load(void) __banked;
+
+/* Залить 16 слотов палитры Тени.  ЗВАТЬ ПОСЛЕ ЛЮБОЙ заливки общей
+ * палитры (gfx_pal_fload kid.pal): та кладёт все 256 записей и затирает
+ * наши — см. развёрнуто в pop_shadow.c.  Рядом с pop_bg_pal_apply. */
+void pop_shadow_pal_apply(void) __banked;
+
+/* Освободить страницы; звать на выходе из программы. */
+void pop_shadow_free(void) __banked;
+
+#endif
@@ -0,0 +1,71 @@
+/* pop_shadow_atlas.h — раскладка атласа ТЕНИ.
+ * СГЕНЕРЕНО toolchain/pop_pack_shadow.py — НЕ править вручную.
+ *
+ * Две половины, потому что и у оригинала их две (см. шапку
+ * упаковщика): кадры вне боя адресуют chtab_2 (спрайты Кида),
+ * кадры 150..189 — chtab_5, а он на 12-м уровне это SHADOW.DAT.
+ * Какая половина нужна, приложение уже знает — тем же условием,
+ * что выбирает таблицу кадров (pop_frame_tbl_is_guard).
+ *
+ * Спрайт Тени НА ОДИН ПИКСЕЛЬ ШИРЕ исходного: второй проход
+ * оригинала кладётся в x+1, и суммарный след занимает [x, x+w].
+ * Рисовать по тем же координатам, что и Кида — сдвиг уже внутри.
+ */
+#ifndef POP_SHADOW_ATLAS_H
+#define POP_SHADOW_ATLAS_H
+
+#include <stdint.h>
+
+#define POP_SHADOW_SHIFT    3
+#define POP_SHADOW_MASK     7
+#define POP_SHADOW_PAL_BASE 0xA0   /* слоты Sprinter под Тень */
+
+/* Половина «вне боя» — кадры Кида (chtab_2). */
+#define POP_SHADOW_KID_PAGES  28
+/* Половина «в бою» — SHADOW.DAT (chtab_5, кадры 150..189). */
+#define POP_SHADOW_FGT_PAGES  4
+
+static const char *const pop_shadow_kid_atl[POP_SHADOW_KID_PAGES] = {
+    "SHADOW\\sk0.atl",
+    "SHADOW\\sk1.atl",
+    "SHADOW\\sk2.atl",
+    "SHADOW\\sk3.atl",
+    "SHADOW\\sk4.atl",
+    "SHADOW\\sk5.atl",
+    "SHADOW\\sk6.atl",
+    "SHADOW\\sk7.atl",
+    "SHADOW\\sk8.atl",
+    "SHADOW\\sk9.atl",
+    "SHADOW\\sk10.atl",
+    "SHADOW\\sk11.atl",
+    "SHADOW\\sk12.atl",
+    "SHADOW\\sk13.atl",
+    "SHADOW\\sk14.atl",
+    "SHADOW\\sk15.atl",
+    "SHADOW\\sk16.atl",
+    "SHADOW\\sk17.atl",
+    "SHADOW\\sk18.atl",
+    "SHADOW\\sk19.atl",
+    "SHADOW\\sk20.atl",
+    "SHADOW\\sk21.atl",
+    "SHADOW\\sk22.atl",
+    "SHADOW\\sk23.atl",
+    "SHADOW\\sk24.atl",
+    "SHADOW\\sk25.atl",
+    "SHADOW\\sk26.atl",
+    "SHADOW\\sk27.atl",
+};
+
+static const char *const pop_shadow_fgt_atl[POP_SHADOW_FGT_PAGES] = {
+    "SHADOW\\sf0.atl",
+    "SHADOW\\sf1.atl",
+    "SHADOW\\sf2.atl",
+    "SHADOW\\sf3.atl",
+};
+
+/* 16 цветов, запись 4 байта (B, G, R, 0) — формат gfx_pal_load. */
+static const uint8_t pop_shadow_pal[64] = {
+    0x00,0x00,0x00,0x00,0xD8,0xFC,0xFC,0x00,0x6C,0x80,0xDC,0x00,0x78,0x44,0x24,0x00,0xA0,0xB8,0xD8,0x00,0xB5,0x7C,0x21,0x00,0x00,0x90,0xB8,0x00,0x5D,0x6D,0xAB,0x00,0x0C,0xF0,0x6C,0x00,0xCC,0x38,0x05,0x00,0x38,0xCC,0xC0,0x00,0x58,0xDB,0xA7,0x00,0xBB,0x9F,0x54,0x00,0x5D,0x18,0x60,0x00,0x37,0xD7,0x37,0x00,0x2F,0x17,0xD2,0x00,
+};
+
+#endif
@@ -45,6 +45,15 @@ extern uint8_t pop_nav_hold;

 /* Чит «бессмертие» (I): Кида бьют, но HP не убавляется.  Читают пути урона
 * (боёвка в банке, пики в pop_map), переключает главный цикл. */
+/* ЧИТ БЕССМЕРТИЯ, три состояния (клавиша I по кругу):
+ *   0 — выключено;
+ *   1 — только БОЙ: удары мечом не отнимают HP (pop_take_hp тут ни при
+ *       чём, ветка живёт в hurt_by_sword, guards.c);
+ *   2 — бой И мелкий урон: не проходят «минус одно деление» от падения с
+ *       двух этажей и от падающей плиты (pop_take_hp гасит count < 100).
+ * МГНОВЕННАЯ СМЕРТЬ остаётся на любом уровне: пики, чомпер, падение с
+ * трёх этажей, удар мечом вне боевой стойки — все они приходят с
+ * count = 100.  Чит отменяет потерю HP, а не смерть. */
 extern uint8_t pop_immortal;

 /* Габариты ПОСЛЕДНЕЙ нарисованной двери уровня — порт глобалов
@@ -14,6 +14,7 @@
 #include "pop_map.h"       /* pop_upside — переворот (зелье инверсии) */
 #include "pop_cdraw.h"     /* POP_CD_TOUCH — фон тронут, персонажей перерисовать */
 #include "pop_tile.h"
+#include "pop_pace.h"    /* pop_beam_sample — счёт кадров по лучу */
 #include "pop_level.h"     /* pop_doorlink2 — подстановка нажатой кнопки */
 #include "_pop_draw.h"     /* pop_heal_fast */

@@ -565,6 +566,7 @@ static const uint8_t *pb_img;

 void pop_blit_b(atlas_t *a, uint8_t idx, int x, int ybottom)
 {
+    pop_beam_sample();      /* ТЕМП КАДРА: выборка луча, см. pop_pace.h */
    /* Аргументы сразу в file-scope: третий и дальше SDCC передаёт СТЕКОМ, и
     * дальше каждое их чтение — `-N(ix)` (замер 2026-08-17: 76 таких
     * обращений в теле, ~3 500 такта из 14 500 цены блита).  То же лечение,
@@ -597,6 +599,7 @@ void pop_blit_b(atlas_t *a, uint8_t idx, int x, int ybottom)
     * общий путь выше. */
    if (pb_img[1] | pb_img[3]) {                 /* кадр больше 255 — редкий путь */
        blit_b_oversize(pb_img, pb_x, pb_yb);
+        pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
        gfx_w0_unmap();
        return;
    }
@@ -618,6 +621,7 @@ void pop_blit_b(atlas_t *a, uint8_t idx, int x, int ybottom)
             * целиком внутри поля: иначе он залезет в борт (см. blit_b_clip). */
            if (pop_upside && (pb_top < POP_YOFF || pb_top + (int)pb_h > POP_CLIP_BOTTOM)) {
                blit_b_clip(pb_img, pb_x, pb_top, pb_w, pb_h);
+                pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
                gfx_w0_unmap();
                return;
            }
@@ -645,6 +649,7 @@ void pop_blit_b(atlas_t *a, uint8_t idx, int x, int ybottom)
            blit_b_clip(pb_img, pb_x, pb_top, pb_w, pb_h);
        }
    }
+    pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
    gfx_w0_unmap();
 }

@@ -23,6 +23,7 @@
 #include "pop_cheat.h"
 #include "pop_tune.h"
 #include "pop_vflip.h"    /* зеркальный набор персонажей (зелье инверсии) */
+#include "pop_pace.h"        /* фиксированный логический кадр по лучу */
 #include "roomtest_cold.h"   /* холодная половина цикла — в банке */

 __sfr __at (0xFE) io_border;
@@ -225,6 +226,7 @@ int main(void)
     * по умолчанию (без мерцания); SPACE переключает в однобуфер для
     * отладки багов рисования (edge по sp_prev, чтоб не дёргать). */
    uint8_t front = 0, back, dbuf = 1, sp_prev = 0, frozen = 0;
+    uint8_t pace_prev = 0;         /* edge клавиши смены режима скорости */
    uint8_t skip = 0;                     /* маска «слот перерисовывать не надо» */
    uint16_t dead_frames = 0;
 #ifdef ROOMNAV
@@ -243,6 +245,9 @@ int main(void)
        return 1;
    }
    gfx_set_idle_hook(kbd_idle);       /* вычерпывать FIFO, пока ждём кадр */
+    /* Темп кадра по лучу.  Если бит 5 порта 0xFE не шевелится (иное
+     * железо), pop_pace_* молча откатываются на прежние gfx_wait_vsync. */
+    pop_pace_arm();

    while (!kbd_raw_down(KBD_ESC)) {
        /* SPACE — тумблер дабл-буфера (edge, чтоб одно нажатие = один
@@ -260,6 +265,18 @@ int main(void)
        }
        sp_prev = sp;

+        /* P — переключить режим скорости по кругу (FASTEST -> FAST ->
+         * NORMAL).  Edge, чтоб одно нажатие = один шаг.  Дефолт FASTEST
+         * (crt0 зануляет _DATA).  Что означают режимы — pop_pace.h. */
+        {
+            uint8_t pk = kbd_raw_down(KBD_SPEED_MODE);
+            if (pk && !pace_prev) {
+                uint8_t m = (uint8_t)(pop_speed_mode + 1);
+                pop_speed_mode = (uint8_t)(m >= POP_SPEED_MODES ? 0 : m);
+            }
+            pace_prev = pk;
+        }
+
        /* Отладочный стоп-кадр: '1' (PS/2 0x16) — заморозить, '2' (0x1E) —
         * продолжить.  В заморозке пропускаем весь tick/draw/flip: картинка
         * стоит, можно спокойно разбирать позу Kid и окклюзию. */
@@ -295,7 +312,10 @@ int main(void)
            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;
+            /* Бессмертие по кругу: 0 выкл -> 1 «только бой» -> 2 «бой и
+             * мелкий урон» -> 0.  Что означают уровни — pop_state.h. */
+            if (pop_cheats && i && !immo_prev)
+                pop_immortal = (uint8_t)(pop_immortal >= 2 ? 0 : pop_immortal + 1);
            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);
@@ -317,7 +337,10 @@ int main(void)
        }
        if (frozen) {
 	    PROF(0);                              /* чёрный: ждём vsync    */
-            gfx_wait_vsync();
+            /* Заморозка — тоже полноценный логический кадр: иначе якорь
+             * пейсинга уедет и первый кадр после разморозки будет рваным. */
+            pop_wait_edge();
+            pop_pace_end(pop_pace_n((uint8_t)(Kid.sword == SWORD_2_DRAWN)));
            continue;
        }

@@ -362,14 +385,18 @@ int main(void)
            gfx_set_draw_page(back);
        }
        pop_dbg_m13();                 /* ЗАМЕР: ввод и читы разобраны */
+        pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
        pop_check_skel();              /* спецсобытие ур.3: скелет встаёт */
        pop_check_mouse();             /* спецсобытие ур.8: мышь жмёт кнопку */
        pop_check_killed_shadow();     /* спецсобытие ур.12: смерть тени = смерть Кида */
        pop_frame_timers();            /* timers (seg003:0735): вспышка слияния */
        pop_dbg_m9();                  /* ЗАМЕР: pop_frame_timers сделан */
+        pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
        pop_check_can_guard_see_kid(); /* луч видимости — ДО логики персонажей */
        pop_dbg_m14();                 /* ЗАМЕР: спецсобытия + луч видимости */
+        pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
        pop_ctrl_tick();               /* ввод -> control(): смена seq */
+        pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
        /* Кто в этом кадре не изменился с прошлой отрисовки ЭТОЙ страницы —
         * тот на ней уже нарисован правильно: ни стирать, ни рисовать заново
         * не надо (DRAW-COST, контракт в pop_cdraw.h).  Решение
@@ -381,18 +408,25 @@ int main(void)
         * skip-маске он не участвует (рисуется/стирается безусловно, живёт
         * только пока Кид стоит на тайле зеркала). */
        pop_mirror_heal();
+        pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
        pop_fore_heal();               /* + следы оверлея (шире прямоугольника Kid) */
+        pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
        PROF(2);                       /* логика (тот же синий) */
        pop_dbg_m1();                  /* ЗАМЕР: начало логики */
+        pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
        kid_tick();                    /* play_seq: следующий кадр */
+        pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
        pop_phys_tick();               /* K3: падение/приземление/стена */
+        pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
        pop_guard_tick();              /* логика стража — В БАНКЕ (guards.c) */
+        pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
        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_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
        pop_guard_fallout();           /* страж провалился ниже комнаты — убрать (seg002:241) */
        if (pop_fell_out) {            /* Kid пересёк нижнюю границу комнаты */
            uint8_t down = pop_room_link(cur_room, LINK_DOWN);
@@ -460,10 +494,12 @@ int main(void)

        PROF(4);                       /* слой фона */
        pop_dbg_m2();                  /* ЗАМЕР: конец логики / начало фона */
+        pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */

        pop_loose_tick();              /* loose-полы: анимация + перерисовка (СЛОЙ ФОНА */
                                       /* — ДО Kid, чтобы Kid всегда был поверх плиты) */
        pop_dbg_m5();                  /* ЗАМЕР: pop_loose_tick сделан */
+        pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
        pop_process_trobs(cur_room);   /* пики/ворота/дверь: продвинуть СОСТОЯНИЕ (порт */
                                       /* process_trobs — рисования внутри нет) */
        if (pop_neigh_dirty) {
@@ -491,8 +527,10 @@ int main(void)
            }
        }
        pop_dbg_m6();                  /* ЗАМЕР: pop_process_trobs сделан */
+        pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
        pop_redraw_needed();
        pop_dbg_m7();                  /* ЗАМЕР: pop_redraw_needed сделан */           /* и разобрать пометки перерисовки тайлов (порт */
+        pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
                                       /* redraw_needed, seg008:0178) — СЛОЙ ФОНА, до Kid */
        {                              /* ворота соседа слева (room8) видны в col0 — */
            uint8_t lft = pop_room_link(cur_room, 0);   /* редрой шва ТОЛЬКО при изменении openness */
@@ -630,6 +668,7 @@ int main(void)
        update_kid_render_dx();        /* straddle: смещение спрайта, если kid_room≠cur_room */
        PROF(6);                       /* спрайты: страж, Kid, fore поверх */
        pop_dbg_m3();                  /* ЗАМЕР: конец фона / начало спрайтов */
+        pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
        /* check_mirror (seg003:0798) — ПЕРВАЯ строка draw_people
         * (seg008:228A), до отрисовки кого бы то ни было: если Кид только что
         * пролетел сквозь зеркало, тень должна родиться ДО того, как слот
@@ -640,8 +679,10 @@ int main(void)
         * спрайта, иначе перепечатка ложится поверх уже нарисованного куска —
         * так окно задней стены и передняя грань пола оказывались на плите. */
        pop_dbg_m10();                 /* ЗАМЕР: check_mirror сделан */
+        pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
        pop_loose_mob_draw();
        pop_dbg_m11();                 /* ЗАМЕР: pop_loose_mob_draw сделан */
+        pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
        {   /* Кто позже — тот поверх; порядок задаёт обход тайлов, а не роль
             * персонажа (см. guard_over_kid).  Отрисовка одна на всех Char
             * (pop_cdraw.c), различает их только слот. */
@@ -651,6 +692,7 @@ int main(void)
            uint8_t g_after;
            skip = pop_char_skip_mask();
            pop_dbg_m12();             /* ЗАМЕР: skip_mask сделан */
+            pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
            /* Порядок «кто поверх кого» нужен, только если кого-то РИСУЕМ.
             * При skip == 3 оба слота тихие, рисовать некого — а вызов стоит
             * трамплина в банк 8 и двух objtile_at_char, 14 424 такта
@@ -682,7 +724,9 @@ int main(void)
         * оригинала (draw_tables, seg008:1373).  Пометки ставят сами
         * объекты вокруг себя (pop_redraw.h). */
        pop_fore_needed();
+        pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
        pop_hp_draw();                 /* полоса HP — только при изменении */
+        pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
        PROF(6);                       /* fore поверх Kid + борта */
        /* Fore-слой Кида — В КОНЦЕ, после плиты и полосы HP: окно fore-клипа
         * одно на всех, и его ставит каждый, кто рисовал персонажа, поэтому
@@ -695,11 +739,18 @@ int main(void)
         * взводит бит и обязан быть учтён.  Всё, что рисуется ниже
         * (mob поверх Кида, борта), взводит его заново само. */
        pop_cd_clear(back);
+        pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
        pop_room_clip_borders();       /* почистить борта — только в кадрах падения (гейт) */

-        /* Пейсинг 3 кадра, затем tear-free флип на vblank: draw уже
-         * сделан (скрытая страница), wait_vsync ловит начало кадра,
-         * set_visible_page переключает во время бланка (gfx.h паттерн). */
+        /* ФИКСИРОВАННЫЙ ЛОГИЧЕСКИЙ КАДР (pop_pace.h): период = max(n,
+         * ceil(W)) вместо прежнего ceil(W) + 2.  Раньше здесь стояли три
+         * gfx_wait_vsync ПОДРЯД — они отсчитывались от КОНЦА работы, из-за
+         * чего бюджет кадра был один растр, а превышение его на такт стоило
+         * целого лишнего.  Теперь ждём от ЯКОРЯ начала кадра.
+         *
+         * Первый фронт — всегда: на нём и происходит tear-free своп (до
+         * начала картинки остаётся верхний бордер, 16 строк).  Строб вспышки
+         * снимается ровно между первым фронтом и остальными, как и было. */

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

@@ -711,13 +762,15 @@ int main(void)
 #endif

        pop_dbg_m4();                  /* ЗАМЕР: конец спрайтов */
-        gfx_wait_vsync();
+        pop_beam_sample();   /* ТЕМП КАДРА: выборка луча (pop_pace.h) */
+        pop_wait_edge();
        if (flash_on) {                /* строб: цвет держался один кадр растра */
            flash_bg(0, 0, 0);
            flash_on = 0;
        }
-        gfx_wait_vsync();
-        gfx_wait_vsync();
+        /* Условие боя — буквально как у оригинала (SDLPoP seg003.c:363):
+         * не «идёт бой» и не «рядом страж», а «у Кида ВЫНУТ МЕЧ». */
+        pop_pace_end(pop_pace_n((uint8_t)(Kid.sword == SWORD_2_DRAWN)));
        if (dbuf) {
            gfx_set_visible_page(back);
            front = back;
@@ -23,8 +23,10 @@
 #include <sprite.h>       /* gfx_copy_page */
 #include "pop_tune.h"
 #include "pop_ctrl.h"     /* pop_ctrl_init/close — ввод поднимает и закрывает boot */
+#include "pop_shadow.h"   /* запечённый набор Тени */
 #include "pop_vflip.h"    /* сброс зеркальных страниц на смене уровня */
 #include "pop_cheat.h"   /* pop_cheats — режим разработки включает pop_boot */
+#include "pop_pace.h"    /* pop_speed_mode — режим скорости в отладочной метке */
 #include <stdio.h>       /* puts/printf — сообщения об ошибках загрузки */
 #include <kbd_raw.h>

@@ -111,8 +113,21 @@ void pop_start_level(void) __banked
     * перебивать и его тоже, иначе рестарт уровня уводил бы Кида из
     * измеряемой комнаты.  Направление и позу входа не трогаем — они из
     * данных уровня, как у обычного старта. */
-    start_room = DBG_START_ROOM;
-    pos        = DBG_START_POS;
+    /* ...НО ТОЛЬКО НА СВОЁМ УРОВНЕ.  pop_start_level зовётся ещё и на
+     * СМЕНЕ уровня, и без этой проверки отладочная позиция перехватывала
+     * переход: на 6-м Кид проваливается в комнате 1, а на 7-м обязан
+     * появиться в комнате 17 и продолжить падение вниз (спецсобытие
+     * «вход падением», см. ниже).  Вместо этого он оказывался в
+     * DBG_START_ROOM/POS, спецсобытие не срабатывало вовсе, и переход 6->7
+     * выглядел сломанным (поймано пользователем 2026-08-20 на сборке
+     * make LEVEL=6 ROOM=1 POS=18).
+     *
+     * Рестарт ТОГО ЖЕ уровня (смерть, чекпойнт) отладочную позицию
+     * сохраняет — ради этого она и перебивает чекпойнт выше. */
+    if (pop_current_level == FIRST_LEVEL) {
+        start_room = DBG_START_ROOM;
+        pos        = DBG_START_POS;
+    }
 #endif

    /* Рестарт уровня = load_level() заново (play_level, seg003:57): в
@@ -174,9 +189,11 @@ void pop_start_level(void) __banked
     * weight-биты, с учётом направления), поэтому геометрически ровной
     * середины тут нет.  Число снято замером живой сцены: x = 98 при позе
     * стойки даёт curr_col = 2, x = 94 — уже 1. */
-    Kid.x = (uint8_t)(pop_x_bump[(pos % 10) + FIRST_ONSCREEN_COLUMN] +
-                      TILE_SIZEX - 2);
-    Kid.curr_col = (int8_t)(pos % 10);
+    if (pop_current_level == FIRST_LEVEL) {          /* см. условие выше */
+        Kid.x = (uint8_t)(pop_x_bump[(pos % 10) + FIRST_ONSCREEN_COLUMN] +
+                          TILE_SIZEX - 2);
+        Kid.curr_col = (int8_t)(pos % 10);
+    }
 #endif
    /* Спецсобытие «вход падением» (set_start_pos, seg003:0196): на 7-м
     * уровне Кид ставится в комнату 17, а экран тут же переводится на
@@ -291,27 +308,86 @@ uint8_t pop_dbg_roomnav(uint8_t dir) __banked
    return 1;
 }

-/* ---- ОТЛАДКА: номер отрисованной комнаты в верхнем борте ------------- */
+/* ---- ОТЛАДКА: состояние прогона в верхнем борте ---------------------- *
+ *
+ * Четыре блока ПАЛОЧКАМИ, каждый своим цветом (outtextxy не годится: текст
+ * тянет системный знакогенератор, _gfx_font_buf — 2 КБ статики в W2, и
+ * сажает кучу).  Двузначные числа — двумя группами: слева десятки, справа
+ * единицы, ||  |||| = 24.
+ *
+ *   жёлтый  x  10.. 85  уровень   (1..15)
+ *   белый   x 100..175  комната   (1..24)
+ *   голубой x 190..205  скорость  (1 палочка NORMAL, 2 FAST, 3 FASTEST)
+ *   красный x 220..230  бессмертие (1 палочка = только бой, 2 = и мелкий урон)
+ *
+ * ЦВЕТА — индексы ИГРОВОЙ палитры, и выбраны они не по вкусу, а по двум
+ * ограничениям.
+ *
+ * Первое: записи палитры лежат в ФОРМАТЕ BGR (BIOS $A4), а не RGB — в
+ * kid.pal 0x3E это `55 ff ff`, то есть жёлтый, а не голубой.  Читать файл
+ * «как привычно» нельзя, цвета выйдут переставленными (на этом я и
+ * попался в первом заходе).
+ *
+ * Второе, важнее: часть палитры ПЕРЕЗАПИСЫВАЕТСЯ на ходу — 0x40..0x4F
+ * зелья, 0x50..0x5F env, 0x60..0x6F стена (эти два меняются при смене
+ * ТАЙЛСЕТА, подземелье/дворец), 0x90..0x9F страж.  Прежняя метка комнаты
+ * рисовалась цветом 0x57, то есть из env-диапазона: белой она была только
+ * в подземелье, а во дворце брала случайный цвет тайлсета.  Здесь берём
+ * только 0x3A..0x3F — их не трогает никто:
+ *   0x3E жёлтый (255,255,85), 0x3F белый, 0x3B голубой (85,255,255),
+ *   0x3C красный (226,0,48) — тот же, которым игра даёт вспышку урона.
+ *
+ * Перерисовка change-driven: пока ничего из показанного не изменилось, в
+ * борт не пишем вовсе.  Счётчик 2 — обе страницы дабл-буфера. */

-static uint8_t room_label_sig = 0xFF;   /* последняя показанная комната */
+static uint8_t room_label_sig = 0xFF;   /* последняя показанная комната  */
+static uint8_t lvl_label_sig  = 0xFF;   /* ...уровень                     */
+static uint8_t spd_label_sig  = 0xFF;   /* ...режим скорости              */
+static uint8_t imm_label_sig  = 0xFF;   /* ...бессмертие                  */
 static uint8_t room_label_redraw;       /* остаток кадров (2 = обе страницы) */

+/* Группа палочек: n штук от x вправо, шаг 5, ширина 2. */
+static void label_bars(int x, uint8_t n)
+{
+    uint8_t i;
+    for (i = 0; i < n; i++) bar(x + i * 5, 0, x + 1 + i * 5, 5);
+}
+
 void pop_dbg_room_label(uint8_t room) __banked
 {
-    uint8_t prev = room_label_sig, i;
-    room_label_sig = room;               /* СНАЧАЛА сохранить (sdcc_z80_cmp_store_a_bug) */
-    if (room != prev) room_label_redraw = 2;
+    /* СНАЧАЛА сохранить, потом сравнивать — обход sdcc_z80_cmp_store_a_bug
+     * (`if (n != g) g = n;` пишет разность вместо значения). */
+    uint8_t prev_room = room_label_sig, prev_lvl = lvl_label_sig;
+    uint8_t prev_spd  = spd_label_sig,  prev_imm = imm_label_sig;
+    uint8_t lvl = pop_current_level, spd = pop_speed_mode, imm = pop_immortal;
+    room_label_sig = room;
+    lvl_label_sig  = lvl;
+    spd_label_sig  = spd;
+    imm_label_sig  = imm;
+    if (room != prev_room || lvl != prev_lvl || spd != prev_spd || imm != prev_imm)
+        room_label_redraw = 2;
    if (!room_label_redraw) return;
-    /* Номер ПАЛОЧКАМИ, а не outtextxy: текст тянет системный знакогенератор
-     * (_gfx_font_buf, 2 КБ статики в W2) и сажает кучу.  Слева десятки,
-     * справа единицы: ||  |||| = 24. */
+
    setfillstyle(SOLID_FILL, BLACK);
-    bar(100, 0, 175, 5);
-    /* 0x57, а НЕ WHITE: палитра игровая, запись 15 в ней чёрная
-     * (kid.pal: 0x0F = 0,0,0; чистый белый = 0x57). */
-    setfillstyle(SOLID_FILL, 0x57);
-    for (i = 0; i < (uint8_t)(room / 10); i++) bar(100 + i * 5, 0, 101 + i * 5, 5);
-    for (i = 0; i < (uint8_t)(room % 10); i++) bar(130 + i * 5, 0, 131 + i * 5, 5);
+    bar(10, 0, 230, 5);
+
+    setfillstyle(SOLID_FILL, 0x3E);            /* уровень — жёлтый */
+    label_bars(10, (uint8_t)(lvl / 10));
+    label_bars(40, (uint8_t)(lvl % 10));
+
+    setfillstyle(SOLID_FILL, 0x3F);            /* комната — белый */
+    label_bars(100, (uint8_t)(room / 10));
+    label_bars(130, (uint8_t)(room % 10));
+
+    /* Скорость: номер режима + 1, то есть NORMAL 1, FAST 2, FASTEST 3 —
+     * чем больше палочек, тем быстрее (см. нумерацию в pop_pace.h). */
+    setfillstyle(SOLID_FILL, 0x3B);            /* скорость — голубой */
+    label_bars(190, (uint8_t)(spd + 1));
+
+    if (imm) {                                 /* бессмертие — красный */
+        setfillstyle(SOLID_FILL, 0x3C);
+        label_bars(220, imm);                  /* палочек = уровень (1 или 2) */
+    }
    room_label_redraw--;
 }

@@ -689,6 +765,7 @@ int pop_boot(void) __banked
    }
    pop_sword_load();                  /* меч в руке (без него кадры 229+ без клинка) */
    pop_guard_load();                  /* атласы стража (GUARD\\g0..g4) */
+    pop_shadow_load();                 /* запечённый набор Тени — один раз на запуск */
    if (pop_kid_load(28) != 0) {       /* ВСЕ страницы: бег+стоп+разворот+присед+прыжок */
        puts("kid atlas load failed");
        return -1;
@@ -711,6 +788,8 @@ int pop_boot(void) __banked
     * дворцовых уровнях без этого рисуется дворцовая геометрия подземельными
     * красками (сине-серое вместо песочного). */
    pop_bg_pal_apply();
+    /* ...и палитру Тени: kid.pal затёр и её 16 слотов (pop_shadow.c). */
+    pop_shadow_pal_apply();

    /* Фон комнаты рисуется в ОБЕ графические страницы: у каждой своя
     * ОЗУ-копия/видео-ОЗУ, а heal берёт чистый фон из ОЗУ-копии ТОЙ
@@ -793,6 +872,7 @@ void pop_shutdown(void) __banked
    closegraph();
    pop_bg_free();
    pop_kid_free();
+    pop_shadow_free();
    pop_guard_free();
    pop_kid_data_free();
    pop_level_free();
@@ -0,0 +1,292 @@
+#!/usr/bin/env python3
+"""
+pop_pack_shadow.py — упаковщик спрайтов ТЕНИ.
+
+ЗАЧЕМ ОТДЕЛЬНЫЙ НАБОР.  Оригинал не хранит спрайтов Тени вовсе: он кладёт
+обычный спрайт ДВАЖДЫ — в x обычным прозрачным блитом, и в x+1 «блиттером
+XOR» (draw_objtable_item, seg008.c:1600).  Наш пакетный блит так не умеет,
+поэтому результат запекается заранее, здесь.
+
+ЧТО ИМЕННО ДЕЛАЕТ ОРИГИНАЛ (проверено по исходнику, не по памяти):
+
+  * `blitters_2_or` — НЕ побитовое ИЛИ.  В SDLPoP это обычный блит с
+    colour key = индекс 0 (method_6_blit_img_to_scr, seg009.c:3306), то
+    есть один в один наш прозрачный блит.
+  * `blitters_3_xor` работает по 24-битному RGB, а не по индексам палитры
+    (blit_xor, seg009.c:3190: конвертация в 24 бита, затем `*p_dest ^=
+    *p_src` побайтно).  Прозрачности у него нет — XOR'ится весь
+    прямоугольник, но прозрачный пиксель это чёрный 0x000000, а XOR с
+    нулём ничего не меняет.
+
+Отсюда своя палитра: XOR двух цветов игровой палитры даёт цвет, которого в
+ней нет.
+
+ЕДИНСТВЕННОЕ РАСХОЖДЕНИЕ.  XOR считается по тому, что УЖЕ на экране, то
+есть зависит от фона.  Разбор по пикселям: от фона зависит только кайма в
+один пиксель по ЛЕВЫМ кромкам силуэта (там, где спрайт прозрачен в x, но
+непрозрачен в x−1).  На чёрном фоне `фон XOR цвет == цвет`, и запечка
+точна; Тень почти всегда на чёрном.  Мы печём именно этот случай.
+
+ДВА НАБОРА В ОДНОМ АТЛАСЕ.  Набор спрайтов у оригинала выбирает НЕ
+персонаж, а поле `sword` самого кадра: load_frame_to_obj (seg008.c:1752)
+держит chtab_base жёстко равным chtab_2 и прибавляет `sword >> 6`.  У всех
+кадров frame_table_kid эти биты нулевые, у всех кадров frame_tbl_guard —
+0xC0.  Тень берёт таблицу стража для кадров 150..189 (seg006.c:533), то
+есть идёт через chtab_5, а chtab_5 на 12-м уровне грузится из SHADOW.DAT
+(tbl_guard_type[12] == 4, seg000.c:1117) — и это графика КИДА в боевых
+позах, а не стража.  Поэтому печём обе половины:
+
+    KID    — data/KID/res(401+id).png,    id 0..218  -> sk0..skN.atl
+    SHADOW — data/SHADOW/res(751+id).png, id 0..31   -> sf0..sfM.atl
+
+Выход: poc/res/shadow/sk*.atl + sf*.atl + pop_shadow_atlas.h (палитра
+внутри заголовка — 16 записей, её заливает приложение через gfx_pal_load).
+"""
+import os
+import sys
+from PIL import Image
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, HERE)
+import pop_pack_bg as B
+from pop_pack_kid import transpose_cols
+
+DATA     = os.path.join(HERE, "..", "SDLPoP", "data")
+OUT_DIR  = os.path.join(HERE, "..", "poc", "res", "shadow")
+PAL_BASE = 0xA0           # слоты Sprinter под Тень: 0xA0..0xAF
+NCOL     = 16             # столько цветов в палитре Тени
+SHIFT    = 3              # sk[id>>3], idx id&7 — как у Kid (кадры крупные)
+MASK     = (1 << SHIFT) - 1
+
+# Половины набора: (каталог, база ресурса, префикс выходных файлов).
+# Off-by-one тот же, что у Kid и стража: images[0] = res(база+1), значит
+# frame.image = N -> res(база+1+N) (см. pop_pack_kid.load_kid).
+HALVES = (("KID",    400, "sk"),
+          ("SHADOW", 750, "sf"))
+
+
+def frames(dirname, base):
+    """Все кадры половины: [(id, w, h, [[rgb|None]...])] — уже после
+    наложения XOR, в честном RGB."""
+    out = []
+    id = 0
+    while True:
+        path = os.path.join(DATA, dirname, f"res{base + 1 + id}.png")
+        if not os.path.exists(path):
+            break
+        im = Image.open(path)
+        if im.mode != "P":
+            B.die(f"{path}: mode {im.mode}, ожидался P")
+        pal = im.getpalette()[:NCOL * 3]
+        rgb = [tuple(pal[i * 3:i * 3 + 3]) for i in range(NCOL)]
+        w, h = im.size
+        px = im.load()
+        grid = []
+        for y in range(h):
+            # Ширина на один больше: второй проход кладётся в x+1, и
+            # суммарный след занимает [x, x+w].
+            row = [None] * (w + 1)
+            for x in range(w):                      # проход 1: обычный блит
+                i = px[x, y]
+                if i:
+                    row[x] = rgb[i]
+            for x in range(w):                      # проход 2: XOR в x+1
+                i = px[x, y]
+                if not i:
+                    continue                        # чёрный: XOR — не операция
+                s = rgb[i]
+                t = x + 1
+                row[t] = s if row[t] is None else tuple(a ^ b for a, b in zip(row[t], s))
+            grid.append(row)
+        out.append((id, w + 1, h, grid))
+        id += 1
+    return out
+
+
+def histogram(halves):
+    h = {}
+    for _, fr in halves:
+        for _, _, _, grid in fr:
+            for row in grid:
+                for c in row:
+                    if c is not None:
+                        h[c] = h.get(c, 0) + 1
+    return h
+
+
+def _d2(a, b):
+    return (a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2 + (a[2] - b[2]) ** 2
+
+
+def _kmeans(pts, k, init):
+    """Взвешенный Ллойд по СПИСКУ ЦВЕТОВ с весами (их полсотни, не пиксели)."""
+    cent = list(init)
+    for _ in range(80):
+        groups = [[] for _ in cent]
+        for c, n in pts:
+            groups[min(range(len(cent)), key=lambda j: _d2(c, cent[j]))].append((c, n))
+        new = []
+        for j, g in enumerate(groups):
+            if not g:
+                new.append(cent[j])
+                continue
+            w = sum(n for _, n in g)
+            new.append(tuple(int(round(sum(c[i] * n for c, n in g) / w)) for i in range(3)))
+        if new == cent:
+            break
+        cent = new
+    return cent
+
+
+def build_palette(hist):
+    """16 цветов ГИБРИДОМ: часть слотов — самые частые цвета ТОЧНО, остаток
+    — взвешенные кластеры хвоста.
+
+    Почему не «просто самые частые»: тогда редкие цвета уезжают в далёкий
+    ближайший, и грубых промахов (сдвиг >90 по евклиду в RGB при максимуме
+    441) получается впятеро больше — 381 пиксель против 76 на все 251
+    кадр (замер 2026-08-20).  Почему не чистый k-means: он двигает вообще
+    все цвета, включая массовые.
+
+    Разделение слотов подбираем перебором по критерию «сначала минимум
+    грубых промахов, потом заметных, потом худшая ошибка»."""
+    items = sorted(hist.items(), key=lambda kv: -kv[1])
+
+    def stats(pal):
+        bad = worst = mid = big = 0
+        for c, n in items:
+            e = min(_d2(c, p) for p in pal) ** 0.5
+            if e > 0:
+                bad += n
+                worst = max(worst, e)
+                if e >= 90:
+                    big += n
+                elif e >= 40:
+                    mid += n
+        return bad, mid, big, worst
+
+    best = None
+    for m in range(1, NCOL):                       # m слотов под хвост
+        keep = [c for c, _ in items[:NCOL - m]]
+        rest = [(c, n) for c, n in items[NCOL - m:]]
+        if not rest:
+            continue
+        pal = keep + _kmeans(rest, m, [c for c, _ in rest[:m]])
+        bad, mid, big, worst = stats(pal)
+        score = (big, mid, worst)
+        if best is None or score < best[0]:
+            best = (score, m, pal, (bad, mid, big, worst))
+    _, m, pal, st = best
+    # Чёрный обязан быть ТОЧНЫМ и лежать в слоте 0: это XOR-погашенная
+    # середина силуэта, больше половины всех пикселей Тени.
+    j = min(range(len(pal)), key=lambda i: _d2((0, 0, 0), pal[i]))
+    pal[j] = (0, 0, 0)
+    pal[0], pal[j] = pal[j], pal[0]
+    bad, mid, big, worst = st
+    tot = sum(hist.values())
+    print(f"  палитра: {NCOL - m} частых точно + {m} кластеров хвоста; "
+          f"из {len(items)} цветов изменено {bad} px из {tot} "
+          f"({100.0 * bad / tot:.2f} %), заметно {mid}, сильно {big}, худшая {worst:.0f}")
+    return pal
+
+
+def encode(grid, w, h, pal):
+    """RGB-сетка -> байты атласа: нет пикселя -> 0xFF, цвет -> PAL_BASE + k.
+    Чёрный — НАСТОЯЩИЙ цвет Тени (слот 0), а не прозрачность."""
+    row = bytearray()
+    for y in range(h):
+        for x in range(w):
+            c = grid[y][x]
+            if c is None:
+                row.append(0xFF)
+            else:
+                row.append(PAL_BASE + min(range(len(pal)), key=lambda k: _d2(c, pal[k])))
+    return transpose_cols(w, h, bytes(row))
+
+
+def write_header(path, counts, pal):
+    vals = []
+    for (r, g, b) in pal:
+        vals += [b, g, r, 0]          # формат gfx_pal_load: B, G, R, 0
+    lines = [
+        "/* pop_shadow_atlas.h — раскладка атласа ТЕНИ.",
+        " * СГЕНЕРЕНО toolchain/pop_pack_shadow.py — НЕ править вручную.",
+        " *",
+        " * Две половины, потому что и у оригинала их две (см. шапку",
+        " * упаковщика): кадры вне боя адресуют chtab_2 (спрайты Кида),",
+        " * кадры 150..189 — chtab_5, а он на 12-м уровне это SHADOW.DAT.",
+        " * Какая половина нужна, приложение уже знает — тем же условием,",
+        " * что выбирает таблицу кадров (pop_frame_tbl_is_guard).",
+        " *",
+        " * Спрайт Тени НА ОДИН ПИКСЕЛЬ ШИРЕ исходного: второй проход",
+        " * оригинала кладётся в x+1, и суммарный след занимает [x, x+w].",
+        " * Рисовать по тем же координатам, что и Кида — сдвиг уже внутри.",
+        " */",
+        "#ifndef POP_SHADOW_ATLAS_H",
+        "#define POP_SHADOW_ATLAS_H",
+        "",
+        "#include <stdint.h>",
+        "",
+        "#define POP_SHADOW_SHIFT    %d" % SHIFT,
+        "#define POP_SHADOW_MASK     %d" % MASK,
+        "#define POP_SHADOW_PAL_BASE 0x%02X   /* слоты Sprinter под Тень */" % PAL_BASE,
+        "",
+        "/* Половина «вне боя» — кадры Кида (chtab_2). */",
+        "#define POP_SHADOW_KID_PAGES  %d" % counts["sk"],
+        "/* Половина «в бою» — SHADOW.DAT (chtab_5, кадры 150..189). */",
+        "#define POP_SHADOW_FGT_PAGES  %d" % counts["sf"],
+        "",
+        "static const char *const pop_shadow_kid_atl[POP_SHADOW_KID_PAGES] = {",
+    ]
+    lines += ['    "SHADOW\\\\sk%d.atl",' % i for i in range(counts["sk"])]
+    lines += [
+        "};",
+        "",
+        "static const char *const pop_shadow_fgt_atl[POP_SHADOW_FGT_PAGES] = {",
+    ]
+    lines += ['    "SHADOW\\\\sf%d.atl",' % i for i in range(counts["sf"])]
+    lines += [
+        "};",
+        "",
+        "/* 16 цветов, запись 4 байта (B, G, R, 0) — формат gfx_pal_load. */",
+        "static const uint8_t pop_shadow_pal[64] = {",
+        "    " + ",".join("0x%02X" % v for v in vals) + ",",
+        "};",
+        "",
+        "#endif",
+        "",
+    ]
+    with open(path, "w") as f:
+        f.write("\n".join(lines))
+    print(f"  pop_shadow_atlas.h -> {path}")
+
+
+def main():
+    os.makedirs(OUT_DIR, exist_ok=True)
+    halves = [(prefix, frames(d, base)) for d, base, prefix in HALVES]
+    for (d, base, prefix), (_, fr) in zip(HALVES, halves):
+        if not fr:
+            B.die(f"нет спрайтов в data/{d} (SHADOW.DAT распакован?)")
+        print(f"  {d}: {len(fr)} кадров")
+    pal = build_palette(histogram(halves))
+
+    counts, total, nspr = {}, 0, 0
+    for prefix, fr in halves:
+        pages = {}
+        for id, w, h, grid in fr:
+            pages.setdefault(id >> SHIFT, {})[id & MASK] = (w, h, encode(grid, w, h, pal))
+            nspr += 1
+        npg = max(pages) + 1
+        counts[prefix] = npg
+        for pg in range(npg):
+            nm = f"{prefix}{pg}.atl"
+            cnt, sz = B.pack_atlas(os.path.join(OUT_DIR, nm), pages.get(pg, {}))
+            total += sz
+        print(f"  {prefix}*.atl: {len(fr)} спрайтов, {npg} EMM-страниц")
+    write_header(os.path.join(HERE, "..", "roomtest", "pop_shadow_atlas.h"), counts, pal)
+    print(f"ИТОГО: {nspr} спрайтов Тени, "
+          f"{counts['sk'] + counts['sf']} EMM-страниц, {total} Б -> {OUT_DIR}")
+
+
+if __name__ == "__main__":
+    main()
Author	SHA1	Message	Date
snark13	a3d37bcbfe	Тень закрыта: прогон на уровнях 4/5/6/12, расхождение по кайме в impl_diff	2026-08-20 12:33:46 +03:00
snark13	22cdc67c3a	Звук: подтверждён формат (8 бит моно) и замерен бюджет EMM Формат оригинала проверен по convert_digi_sound: один байт на кадр (моно), байт беззнаковый с центром 0x80 — ровно формат нашего CBL. Стерео в данных нет, каналы размножаются на выходе. Живой замер памяти из работающей программы: занято 124 страницы из 256 (система с exe 43, наши ассеты 81), свободно 132 = 2,06 МБ. Самый крупный ассет теперь набор Тени — 32 страницы. Эффекты WAV займут 8.	2026-08-20 12:25:31 +03:00
snark13	4688364091	Звук: решения пользователя и единая частота 10 937,5 Гц Эффекты — WAV через CBL; музыка первым заходом путь A (ноты на AY); заставки потом WAV; музыка по ходу игры — открыто (WAV с гашением эффектов либо путь B). Единую частоту берём не 11 000, а ровно частоту CBL 10 937,5: тогда тон точен (иначе −9,9 цента), а пересчитывать три файла всё равно надо. 112 922 -> 124 531 Б, 6,9 -> 7,6 EMM-страниц; рост целиком от leveldoor_sliding (источник 2 750 Гц). Взамен CBL открывается один раз и частота не меняется никогда.	2026-08-20 12:10:04 +03:00
snark13	9f9a8f26ae	Звук: разобраны все наборы MS-DOS версии, включая mt32snd Эффекты все 31 есть в WAV (digisnd, 8 бит PCM) — просьба «не спикер, а wav» для них уже выполнена исходным планом. mt32snd оказался НЕ музыкой, а теми же эффектами в MIDI для Roland MT-32. У музыки WAV нет ни в одном наборе: только ноты спикера (7 КБ) или MIDI (27 КБ). Посчитал третий путь — рендер MIDI в WAV на хосте: игровые треки 74,7 с = 803 КБ = 50 EMM-страниц (влезает), заставки 248 с = 167 страниц (только стрим с диска). Только спикером во всей игре остаётся один звук — blink (4 ноты).	2026-08-20 11:57:19 +03:00
snark13	7fcd93a35b	Разбор звука: эффекты через CBL как есть, музыка на AY из нот PC-спикера Замеры по ассетам: 31 эффект уже 8-битным PCM на 11 000 Гц (у CBL есть 10 937,5 — расхождение 0,6 %, формат сэмпла совпадает байт в байт, то есть конверсии нет вовсе), 103 941 Б = 6,3 EMM-страницы. Вся музыка есть нотами PC-спикера — 7 КБ на 57 звуков, и нота там задана в ГЕРЦАХ напрямую (проверено по speaker_callback), а не делителем PIT, как кажется по числам. MIDI разбирать не нужно. Отдельный таймер не нужен: секвенсор музыки двигает CBL-callback раз в 11,7 мс, а короче 12 мс во всей музыке 2 ноты из 1469.	2026-08-20 11:53:02 +03:00
snark13	d1183f7315	Отладочный старт перехватывал смену уровня DBG_START_ROOM/POS подменялись безусловно, а pop_start_level зовётся и на границе уровня. Из-за этого на 7-м стартовой становилась отладочная комната вместо комнаты 17 из данных, и спецсобытие «вход падением» (set_start_pos, seg003:0196) не срабатывало — переход 6->7 выглядел сломанным. Подмена теперь действует только на своём уровне (FIRST_LEVEL); рестарт того же уровня отладочную позицию сохраняет, как и задумано.	2026-08-20 11:35:09 +03:00
snark13	30bcc3459b	Атлас Тени: запечённый набор вместо спрайтов стража Оригинал кладёт спрайт дважды — прозрачным блитом в x и XOR-блиттером в x+1; пакетный блит так не умеет, поэтому результат запечён упаковщиком. Две половины, как и у оригинала: sk* — кадры вне боя (спрайты Кида), sf* — кадры 150..189 (SHADOW.DAT, тоже графика Кида). 251 спрайт, 32 EMM-страницы, палитра 16 цветов в 0xA0..0xAF. Закрывает BUG-SHADOW-SET: раньше тип 4 уходил в guard_names, и Тень в бою дралась серым стражем. Грабля: kid.pal заливает все 256 записей и затирает слоты Тени — палитра вынесена в pop_shadow_pal_apply рядом с pop_bg_pal_apply. Проверено в MAME на 6-м уровне: силуэт с контуром, как в оригинале.	2026-08-20 11:22:53 +03:00
snark13	e60a04e900	Тень: набор спрайтов выбирает поле кадра, а не charid; SHADOW.DAT у нас нет Поправка к вчерашнему выводу «в бою Тень рисуется спрайтами стража». Набор берётся из cur_frame.sword>>6 (seg008.c:1752), chtab_base жёстко равен Киду. Тень идёт через chtab_5, но chtab_5 — это «соперник уровня», и на 12-м это SHADOW.DAT: графика КИДА в боевых позах, палитра побайтно равна палитре Кида. Пользователь прав — Тень всегда выглядит Кидом. Наш pop_guard_load уводит тип 4 в guard_names, SHADOW.DAT в ассетах нет вообще — заведён BUG-SHADOW-SET. Пересчитал палитру на правильных наборах: 251 кадр, 45 цветов; 16 цветов гибридом дают 76 грубых промахов на все кадры (было 129 на ошибочном наборе).	2026-08-20 10:50:36 +03:00
snark13	b6660d7694	Атлас Тени: остановились на 16 цветах (гибридный подбор), блок 0xA0..0xAF	2026-08-20 10:39:40 +03:00
snark13	acb483897d	Разбор атласа Тени: алгоритм оригинала, замеры палитры, план XOR у оригинала идёт по 24-битному RGB, а blitters_2_or — обычный блит с colour key 0. От фона зависит только кайма в один пиксель по левым кромкам силуэта; на чёрном фоне запечка точна. Замеры: 253 кадра (Кид 219 + страж 34, Тень в боевых кадрах рисуется спрайтами СТРАЖА), 59 разных цветов. 32 цвета оставляют перцептивно значимыми 232 пикселя из 96 746. Палитра: занято 112 слотов, свободно 144; берём 0xA0..0xBF.	2026-08-20 10:38:27 +03:00
snark13	47c26d1899	TUNE-2: параметры стражей в CFG-файл (формат секций как у SDLPoP)	2026-08-20 10:23:20 +03:00
snark13	0ef8c4b60e	Бессмертие: два уровня вместо тумблера 1 — только бой: удары мечом не отнимают HP (ветка в hurt_by_sword). 2 — плюс мелкий урон: не проходят «минус деление» от падения с двух этажей и от падающей плиты (pop_take_hp гасит count < 100). Мгновенная смерть остаётся на обоих: пики, чомпер, падение с трёх этажей и удар вне боевой стойки приходят с count = 100. В коде ровно два значения урона, 1 и 100, поэтому граница точная, а не эвристическая. Заодно ушёл костыль «снять бессмертие на время вызова take_hp(100)» в hurt_by_sword — он был нужен только потому, что прежний чит глушил и смертельный урон. Клавиша I идёт по кругу 0 -> 1 -> 2 -> 0; в отладочной метке число красных палочек = уровень.	2026-08-20 10:08:52 +03:00
snark13	10b920f156	impl_diff: ГСЧ разведён по доменам (у оригинала один сид)	2026-08-20 09:43:07 +03:00
snark13	6bdac70508	Отладочная метка: уровень, комната, режим скорости, бессмертие; дефолт NORMAL Четыре блока палочками в верхнем борте, каждый своим цветом. Цвета взяты из 0x3A..0x3F — единственного диапазона, который не перезаписывают ни зелья (0x40), ни env/wall тайлсета (0x50/0x60), ни страж (0x90). Прежняя метка комнаты рисовалась цветом 0x57, то есть из env-диапазона: белой она была только в подземелье, во дворце брала цвет тайлсета. Записи палитры — BGR (BIOS $A4), не RGB; читать kid.pal «как привычно» нельзя, цвета выйдут переставленными. Режимы перенумерованы: NORMAL=0, FAST=1, FASTEST=2. Тогда дефолт (crt0 зануляет _DATA) — NORMAL, обход инкрементом даёт NORMAL->FAST->FASTEST, а номер режима + 1 = число палочек.	2026-08-20 09:40:57 +03:00
snark13	5d61224229	Реестр оптимизации: бюджет кадра вырос втрое, срочность позиций падает	2026-08-19 23:23:22 +03:00
snark13	35d7bd38d4	L1-SPEED закрыта режимами скорости	2026-08-19 23:21:52 +03:00
snark13	5e9c6a2e9e	Пейсинг: результаты замеров и грабли методики	2026-08-19 23:21:33 +03:00
snark13	a6e39070af	Фиксированный логический кадр по лучу + режимы FASTEST/FAST/NORMAL Период стал max(n, ceil(W)) вместо ceil(W)+2: три gfx_wait_vsync после работы отсчитывались от её КОНЦА, поэтому бюджет кадра был один растр. Теперь ждём от якоря начала кадра, и при n=3 бюджет 1 290 240 тактов. Счёт кадров — программный, по биту 5 порта 0xFE (положение луча), а не по кадровым прерываниям: те теряются в DI-окнах акселератора фазозависимо (замер: 0..2,8 %, на полной перерисовке три подряд). Условие точности одно — зазор между выборками меньше 64 512 тактов; точки выборки расставлены по замеру, а не на глаз. Режимы (pop_pace.h), клавиша P по кругу, дефолт FASTEST. Условие боя взято у оригинала буквально (SDLPoP seg003.c:363): Kid.sword == SWORD_2_DRAWN, а не «идёт бой». Проверено в MAME на 11/15: счётчик без недосчёта на 270 кадров, период ровно 3 растра на 302 логических кадрах (ни длиннее 3,1, ни короче 2,9), NORMAL даёт ровно 4, с вынутым мечом — ровно 5.	2026-08-19 23:06:27 +03:00
snark13	61b8d80275	Пейсинг: подробный разбор счётчика кадров по лучу (условие точности, точки выборки, приёмка)	2026-08-19 21:55:05 +03:00
snark13	7f778bba2f	Разбор перехода на фиксированный логический кадр (кода не трогали) Замеры в MAME: кадровые прерывания теряются фазозависимо (0..3%), на полной перерисовке комнаты — три подряд. Причина: импульс запроса 32 такта (9,14 мкс) против DI-окон блита ~0,29 мс. Счёт попаданий брейкпоинтом на этом драйвере недостоверен (WAIT-линия), достоверен только детектор разрыва. Блокер включения gfx_set_fps_div как есть: счётчиковый путь ждёт через halt и не зовёт idle-хук, то есть возвращает KBD-1.	2026-08-19 21:41:13 +03:00