life-game/AGENTS.md

AGENTS.md

Игра — один самодостаточный файл index.html (HTML+CSS+один <script>): без сборки, бандлера, фреймворка, TypeScript, зависимостей и бэкенда. Весь код в одном <script>, секции помечены рамками-комментариями. UI-тексты, комментарии и доки — на русском; при правках сохраняйте этот стиль. Этот файл — роль «конфига проекта» (линтеров/CI нет): здесь правила разработки, тестирования и список стабильных глобалов, на которые завязаны автотесты.

О проекте

Web-ремейк старого прототипа old/life (C++/Qt4): Conway's Game of Life с территориальной борьбой двух игроков. Каждый игрок своим цветом расставляет живые клетки, затем поле живёт по правилам Конвея — клетки выживают/рождаются и наследуют цвет большинства живых соседей. Цель — оставить на доске больше своих живых клеток, чем у соперника.

Формат партии — пошаговый hot-seat за одним экраном: игроки ходят по очереди на одном устройстве, передавая его друг другу. Настраиваемый размер поля (40/60/80/100/120/150/200/250/300, плюс прямоугольные 60×100/100×60), дефолт — 60×60. Клетки всегда квадратные, поле может быть прямоугольным. Каждый игрок может ставить клетки только в своей зоне рисования (P1 — левая половина, P2 — правая) и ограничен бюджетом клеток (дефолт 100). Опция «Замкнутая карта» (torus) включает заворот границ; по умолчанию границы жёсткие. Партия заканчивается при вымирании (когда у игрока не осталось ни одной клетки его цвета — бюджет его уже не спасает), ручным завершением (кнопка «Завершить партию», с подтверждением) либо тупиком по бюджету (поле стабильно, а отстающему нечем ходить — см. «Геймплей и FSM»); победитель определяется по числу живых клеток своего цвета.

old/ — референс старого C++/Qt4 прототипа, не часть продукта; его не трогать и не собирать (он даже в .gitignore).

Архитектура и стек

• Один файл index.html: HTML + CSS + один <script>. Никаких отдельных .js/.css/ассетов — всё инлайн.
• Vanilla JS (ES6+), без сборки/бандлера/транспиляции/TS/фреймворков; работает напрямую с file:// (без http-сервера) и в любом современном браузере.
• Canvas 2D для отрисовки доски + DOM-оверлеи/HUD для меню, диалогов и тулбара.
• Адаптивная раскладка управления: в ландшафте доска занимает всю высоту и прижата влево, а управление (HUD/тулбар/действия) собирается в боковую панель справа (body.side, ширина --side-w); в портрете/узком ландшафте — прежняя центрированная раскладка (HUD сверху, панели снизу). См. «Рендер, зоны и HUD».
• Производительный рендер больших полей (до 300×300): клетки — через offscreen-канву fieldW×fieldH + ImageData, масштабируемую одним drawImage; пересборка только по dirty-флагу (см. «Рендер, зоны и HUD»).
• Внешних ассетов нет (без картинок/шрифтов/сети); всё рисуется кодом/эмодзи.
• Персистентность — localStorage, единственный ключ life-save-v1 (настройки + резюм текущей партии, включая reason финала — 'extinct'/'manual'/'stalemate'). Смена формата — только с миграцией в loadSave().
• Секции внутри <script> помечены рамками-комментариями (// ==== ДАННЫЕ ====, // ==== МОДЕЛЬ ПОЛЯ ====, // ==== FSM ====, // ==== ОТРИСОВКА ====, // ==== СОБЫТИЯ ====, // ==== ЦИКЛ ==== и т.п.) — навигация по одному длинному скрипту.
• Никакого Math.random в игровой логике — симуляция детерминирована (см. «Подводные камни»).

Структура проекта

life/
├── index.html            # вся игра: HTML + CSS + <script>
├── tests/
│   ├── package.json      # зависимость puppeteer-core
│   ├── package-lock.json # лок-файл (коммитим для воспроизводимости)
│   ├── parity-fixture.json # компактная фикстура паритета (clean/proto) для суиты
│   └── test.js           # полная headless-суита (Conway/FSM/скрытие/резюм/паритет/…)
├── tools/
│   ├── check.mjs         # проверка синтаксиса JS из index.html
│   ├── gen-campaign-levels.mjs # генератор 96 уровней кампании (seeded PRNG, без Math.random)
│   └── old-ref/          # harness паритета с прототипом (C++ + генераторы; см. README там)
├── AGENTS.md             # этот файл: правила разработки/тестирования + глобалы
├── README.md             # краткая документация для игрока
├── .gitignore            # old/, node_modules/, .slim/, dist/ и пр.
├── .opencode/            # агентский конфиг (в .gitignore, не часть продукта)
└── .slim/deepwork/       # локальное состояние процесса (git-ignored), в т.ч. план

• old/ — референс прототипа, не часть продукта, не собирается и не трогается (в .gitignore).
• tools/old-ref/ — независимый harness паритета: old_ref.cpp (порт Life::nextStep() + «чистое» правило + torus-эталон), reference.json/reference-clean.json/reference-torus.json, генераторы gen-clean.js/gen-torus.js/gen-fixture.js, дифтест diff-our.js и свой README.md. Бинарник old_ref не коммитится (собирается g++, см. .gitignore).
• .opencode/ — агентский конфиг (в .gitignore, не часть продукта).
• .slim/deepwork/ — локальное состояние процесса (git-ignored), в т.ч. план; ре-включено для поиска через .ignore (!.slim/deepwork/).
• .slim/deepwork/life-web-remake.md — зафиксированные решения и план фаз; читать перед началом работы.

Правила игры

• Автомат — классический Conway B3/S23: живая клетка выживает при 2–3 живых соседях, мёртвая рождается ровно при 3.
• Окрестность — Мура (8 соседей).
• Границы: по умолчанию жёсткие (клетки за краем поля не существуют и не считаются соседями — как в прототипе old); опция «Замкнутая карта» (wrap/torus) включает заворот, и соседи берутся с противоположной стороны. Дефолт wrap=false.
• Цвет (владение) клетки: цвет новорождённой = цвет большинства из 3 живых соседей, породивших её. При двух игроках расклад 2-1 всегда однозначен.
• Tie-break для ≥3 игроков: если большинство неоднозначно — выигрывает наименьший id цвета (при двух игроках не наблюдаем; пересмотреть при расширении).
• Не воспроизводить баг старого прототипа: в old/life/life.cpp:19-50 массив parent[] не обнулялся на каждую клетку, из-за чего цвета «протекали» между итерациями. Мы реализуем чистое правило «большинство из 3 живых соседей»; поведение старого кода в этом месте — баг, а не спецификация.

Геймплей и FSM

Поток партии (hot-seat):

1. P1 расставляет свои клетки (PLACE_P1).
2. Передача устройства сопернику со скрытым его вводом (HANDOFF_P1_P2).
3. P2 расставляет вслепую, не видя расстановку P1 (PLACE_P2).
4. Симуляция (RUNNING) → авто-пауза при стабилизации поля (см. ниже) → каждый игрок по отдельности дорисовывает свои клетки (EDIT_P1/EDIT_P2, в любом порядке, оба видят поле) → «Старт симуляции» → … → вымирание (когда цвет исчез — у игрока 0 клеток), тупик по бюджету (поле стабильно, отстающему нечем ходить) или ручное завершение (GAME_OVER).

Полный список состояний (state) и переходы:

Состояние	Смысл	Переходы
MENU	стартовый сплэш: краткое описание игры, тема оформления, возврат к отложенной партии; вход в «Кампанию» или на экран «Игра на двоих»	showTwoSetup()/#btnPlay → TWO_SETUP; resumeFromMenu() → отложенная партия; showLevelSelect()/#btnCampaign → LEVEL_SELECT
TWO_SETUP	экран «Игра на двоих» (не резюмируется; modeForState→menu): своя справка + настройки поля (размер/torus/бюджет)	#btnStartTwo/requestNewGame() → PLACE_P1 (подтверждение 'new' при suspended); toMenu()/#btnTwoBack → MENU
LEVEL_SELECT	экран выбора уровня кампании (не резюмируется; modeForState→menu)	requestCampaignLevel(i) (подтверждение 'campaign') → PLACE_P1 (кампания); toMenu()/#btnLevelsBack → MENU
PLACE_P1	P1 расставляет свои клетки (в кампании — игрок, commitTurn() сразу → RUNNING)	commitTurn() → HANDOFF_P1_P2; в кампании → RUNNING
HANDOFF_P1_P2	передача устройства P1→P2 (или назад к P1)	handoffNext() → PLACE_P2; handoffBack() → PLACE_P1
PLACE_P2	P2 расставляет вслепую	commitTurn() → HANDOFF_P2_START
HANDOFF_P2_START	расстановка P2 завершена: «Начать симуляцию» или вернуться к P1 (состояние реально существует в коде и раньше не попадало в таблицу)	handoffNext() → RUNNING; handoffBack() → PLACE_P1
RUNNING	симуляция идёт	pauseGame() → PAUSED; checkEnd() после каждого шага (вымирание) → GAME_OVER; авто-PAUSED+fieldStable при стабилизации поля (tick) и checkStalemate() (тупик по бюджету) → GAME_OVER/stalemate; requestEndGame() (подтверждение) → GAME_OVER/manual; toMenu() → MENU (партия откладывается)
PAUSED	пауза симуляции (без модального диалога); дорисовка доступна только при fieldStable	resumeGame() → RUNNING; startEdit(1)/startEdit(2) → EDIT_P1/EDIT_P2 (только если fieldStable); requestEndGame() → GAME_OVER; toMenu() → MENU
EDIT_P1	P1 дорисовывает на паузе (видит всё)	commitTurn() → PAUSED
EDIT_P2	P2 дорисовывает (видит всё)	commitTurn() → PAUSED
GAME_OVER	итог партии, победитель	newGame() → PLACE_P1; toMenu() → MENU

Стабильность поля — гейт дорисовки: дорисовка (EDIT_*) разрешается только когда поле перестало меняться. Во время RUNNING tick() после каждого шага считает hashField() и ищет его среди последних STABLE_WINDOW (1024) поколений (recentHashes): совпадение = поле вошло в фиксированную точку (период 1) или короткий цикл (например, блинкер, период 2). Тогда симуляция сама встаёт в PAUSED и выставляет fieldStable = true — кнопки дорисовки #btnEditP1/#btnEditP2 становятся видны. В кампании (игрок один) после авто-паузы сразу вызывается startEdit(1) — фаза EDIT_P1 открывается автоматически, без клика «Дорисовать» (если авто-пауза завершила партию поражением, состояние уже GAME_OVER и дорисовка не зовётся). Если поле не застывает (глайдеры/рост/хаос — хеш не повторяется в окне), fieldStable остаётся false: ручная пауза дорисовку не открывает, партию завершают вручную (либо она сама завершается вымиранием одной из сторон, см. ниже). fieldStable сбрасывается при любом изменении поля/запуске симуляции (startRunning засевает окно текущим хешем; resumeGame/newGame/setFieldDim/setFieldASCII/setWrap/forceState), а при выходе из EDIT_* (startPaused) сохраняется — второй игрок может дорисовать. Коллизия 32-битного хеша даёт ложное срабатывание с вероятностью ~2⁻³² (пренебрежимо).

Причина финала (reason): 'extinct' — вымирание (вход в GAME_OVER из checkEnd()), 'manual' — ручное завершение (requestEndGame() → подтверждение → finish('manual')), 'stalemate' — тупик: симуляция сама встала на паузу (поле стабильно), а отстающему игроку нечем ходить (см. ниже), 'win'/'defeat' — исход уровня кампании (см. «Кампания»). reason выставляется при входе в GAME_OVER, входит в форму сейва и сохраняется через save/persist().

Кампания. Отдельный режим (кнопка «Кампания» в меню → состояние LEVEL_SELECT) с заранее расставленными стабильными фигурами врага (цвет 2, CAMPAIGN_ENEMY); игрок играет цветом 1 (CAMPAIGN_PLAYER), одна сторона. Враг статичен — поле живёт обычной детерминированной симуляцией. Уровень описывает CAMPAIGN_LEVELS ({id,name,w,h,wrap,budget,zone:{x,y,w,h},cells:[[x,y],…]}): cells — компактные координаты клеток врага (не ASCII-сетка), buildCampaignField строит поле прямо из них с проверкой границ. Набор — 103 уровня: 7 заданы вручную («Разминка», «Каравай», «Рой» — много фигур, «Издалека» — враг вне зоны игрока, включая ружьё Госпера, и showcase «Флотилия»/«Погоня»/«Кролики» с новыми фигурами), остальные 96 сгенерированы детерминированным скриптом tools/gen-campaign-levels.mjs (seeded PRNG, без Math.random) и вшиты в файл статически (в рантайме ничего не генерируется; id 5..100). Размер поля у сгенерированных растёт от 60 до 300; зоны разнообразны, а часть уровней — с врагом вне зоны. У сгенерированных уровней зоны «всё поле» НЕТ: используются 7 типов (половина / центр / левый-верхний угол / правый-нижний угол / вертикальная полоса / горизонтальная полоса / произвольный прямоугольник), а полная зона оставлена только ручным «Разминке» и «Рою». Порядок массива = порядок в игре; id — метаданные (уникальны, 1..103). Ручной «Издалека» (id4) вставлен на 10-е место (индекс 9), сгенерированные id5..id10 сдвинуты вверх (индексы 3..8), а сразу за «Издалека» — ручные showcase id 101..103 (индексы 10..12). Размеры монотонны только у сгенерированных уровней (id 5..100, от 60 до 300); у ручных вставок размер свой. Решаемость уровней намеренно не гарантируется: среди них есть заведомо почти непроходимые (например с ружьём Госпера) — это задумка, а не дефект. Глобалы режима: campaign (bool), levelIndex (int≥0 | -1), zoneRect (прямоугольник зоны игрока | null), campaignProgress = {unlocked} (прогресс), pendingLevel (уровень в диалоге подтверждения). Особенности:

• Зона рисования — прямоугольник zoneRect (может покрывать всё поле), а не половина; предикат inZoneAt(x,y,player) в кампании смотрит zoneRect, иначе делегирует в inZone(x,player). Игровые места (paintTool, applyIntent, ввод, ghost-превью, clearZone) ходят через inZoneAt; сами inZone/zoneSplit не меняются (контракт тестов).
• Врага нельзя трогать: в paintTool клетки field[i] === CAMPAIGN_ENEMY пропускаются во всех ветках (краска/штамп/ластик) без траты и без возврата бюджета. applyBrush не знает о кампании (геометрический примитив).
• Скрытия нет: visibleMask() при campaign возвращает [1,2] (враг виден всегда).
• Своё поле/бюджет: startLevel(idx) (campaign=true, levelIndex=idx, zoneRect=campaignZoneFor(idx), wrap уровня, buildCampaignField, budget.total=lv.budget, used=0, speedMult=1, транзиентное сброшено, beginDraw('PLACE_P1',1)). clearZone/enterPlace не зовутся — иначе враг сотрётся из снимка начала хода.
• Победа — 0 клеток цвета 2: checkEnd() в кампании при countByPlayer(field).p2===0 → finish('win') (приоритет над поражением); иначе вымирание не финал (0 клеток игрока — не проигрыш, пока есть бюджет).
• Поражение — бюджет исчерпан, а враг жив: checkStalemate() при campaign && state==='PAUSED' && fieldStable && remaining(1)<=0 && p2>0 → finish('defeat'). Фиксируется только в ветке авто-паузы tick() (как stalemate), без собственных счётчиков шагов.
• Победитель в кампании — по reason (computeWinner: win→'1', defeat→'2'). При finish('win') campaignProgress.unlocked = max(unlocked, levelIndex+2) (с клампом по длине).
• Переходы: commitTurn() в кампании: и PLACE_P1, и EDIT_P1 → startRunning() («Готов» всегда сразу запускает симуляцию, отдельной кнопки «Старт» в цикле дорисовки нет); startEdit(2) — no-op; newGame()/showLevelSelect() сбрасывают campaign/levelIndex/zoneRect; requestNewGame() при campaign && levelIndex>=0 → startLevel(levelIndex) («Заново» на экране финала, без подтверждения); requestRestartLevel() («Заново» в панели действий, доступна в любой фазе уровня) открывает подтверждение (confirmAction='restart', на время диалога симуляция ставится на паузу, «Отмена» её возвращает); confirmProceed() ветки 'restart' → startLevel(levelIndex), 'campaign' → suspended=null; startLevel(pendingLevel); cancelConfirm() → pendingLevel=null.
• Настройки пользователя vs активная игра (D1): startLevel() применяет размер/wrap/бюджет УРОВНЯ к «активной игре» (fieldW/fieldH/wrap/budget.total), НЕ трогая menuFieldW/menuFieldH/menuWrap/menuBudget. Выход из кампании (toMenu/showLevelSelect) зовёт applyMenuSettings() — возвращает активные значения к пользовательским. Поэтому обычная партия после кампании стартует с прежних настроек (60×60 / 100 по умолчанию), а #optSize/#optWrap/#optBudget в syncDom всегда отражают menu*. setFieldDim/setFieldSize в кампании — no-op (иначе потерялся бы враг, D4); setWrap/setBudgetTotal обновляют и menu*.
• Ручное завершение (D3): endGame()/finish('manual') в кампании даёт reason='manual' и текст «Уровень прерван» (не «Поражение»); computeWinner для manual → 'draw'. Кнопки #btnEnd/#btnEndPause в кампании скрыты.
• applyIntent (D5): возвращает paintTool(...) > 0 — клик по клетке врага или по своей клетке (нет изменений) даёт false.
• UI: #btnCampaign (меню), #levels + #levelList (103 кнопки уровней, замок 🔒 для i>=unlocked; список — max-height~460px с overflow-y:auto, прокручивается, заголовок и «В меню» остаются видимы), #aboutCampaign (сворачиваемая справка «Как играть» на экране уровней), #btnLevelsBack, #btnNextLevel (только победа + есть следующий), #btnGameoverLevels; #turnLabel = «Уровень N/T» (+ «· поле стабильно»), #scores скрыт, #budgetLabel виден и в RUNNING/PAUSED (бюджет игрока 1), #btnEditP2/#btnEnd/#btnEndPause скрыты; кнопка #btnRestart («Заново») видна в любой фазе уровня (пока campaign && levelIndex>=0) и перезапускает уровень через подтверждение (requestRestartLevel → confirmAction='restart', тогда как #btnRevenge на экране финала перезапускает сразу); диалог #confirm обслуживает confirmAction 'campaign'/'restart'/'new'/'end'. syncLevelList() обновляет подписи/доступность только при state==='LEVEL_SELECT' (иначе 103 кнопки синхронятся вхолостую из syncDom).
• Сейв: аддитивные поля campaign, levelIndex, progress:{unlocked} (в suspended — тоже campaign/levelIndex), SAVE_VERSION остаётся 2; вайтлист reason расширен win/defeat. LEVEL_SELECT не резюмируется: при reload → MENU.

Вымирание — после каждого такта: checkEnd() вызывается из tick() после каждого шага симуляции и объявляет extinct, как только isExtinct(field) — т.е. у одного из игроков 0 клеток его цвета (у обоих 0 → ничья в computeWinner). Бюджет финал не отодвигает: пока у игрока есть хоть одна клетка, он жив; как только цвет исчез — партия окончена, дорисовать (EDIT_*) его уже нельзя. Устойчивость поля (fieldStable) на финал не влияет — вымирание может завершить партию и на «живом» поле. Если оба цвета живы, партия сама не завершится вымиранием — её заканчивают вручную либо она завершается тупиком по бюджету (см. ниже).

Тупик по бюджету — авто-финал на стабильной паузе: сразу после того, как симуляция сама встала на паузу (обнаружена устойчивость), tick() вызывает checkStalemate(). Если поле стабильно и отстающий игрок (у кого меньше живых клеток) исчерпал бюджет (remaining <= 0), он не может ни поставить, ни стереть ничего (ластик снимает только правку текущего хода, а на паузе правок нет) — исход зафиксирован, партия завершается finish('stalemate'). При равенстве клеток тупик фиксируется только если бюджет исчерпан у обоих (иначе один из них ещё может разорвать ничью) → winner='draw'. Если у отстающего есть бюджет — игра продолжается (он может дорисовать). Проверка живёт только в ветке авто-паузы tick() (ручная пауза/forceState('PAUSED') её не запускают); расход остатка уже в фазе EDIT_* финал не триггерит — для срабатывания нужно снова запустить симуляцию, поле стабильно, пауза вернётся за пару тиков.

Меню не теряет партию: toMenu() (кнопки «В меню»/⚙️) вызывает suspendGame() — снимок текущей резюмируемой партии (размер/wrap/поле/бюджет) кладётся в глобал suspended, после чего состояние становится MENU. В меню при наличии suspended видна кнопка «Продолжить партию» (resumeFromMenu() восстанавливает партию целиком). «Игра на двоих»/«Реванш» при наличии suspended сначала открывают диалог подтверждения (confirmAction='new'; requestNewGame()), чтобы случайно не потерять партию; newGame() очищает suspended.

Никакое действие не теряет партию одним кликом: диалог подтверждения #confirm (confirmAction = 'new' | 'end' | 'campaign' | 'restart') показывается при новой партии поверх незавершённой, при «Завершить партию» (requestEndGame(); confirmAction='end'), при выборе уровня кампании ('campaign') и при перезапуске уровня «Заново» (requestRestartLevel(); 'restart'). На время диалога завершения/перезапуска симуляция ставится на паузу (pauseGame()), а «Отмена» возвращает RUNNING (cancelConfirm()/confirmResume). Прямой endGame() (без диалога) оставлен только для тестов/checkEnd-пути.

Скрытие (важнейшее правило):

• чужое скрыто ТОЛЬКО в PLACE_* (первичная расстановка вслепую);
• в EDIT_* показываем всё (дорисовка идёт открыто, оба видят поле);
• в HANDOFF_P1_P2 (первичная передача) маска пуста + оверлей «Передайте устройство», счёт скрыт; в дорисовке (EDIT_*) передачи нет — оба видят поле.

Скрытие — ТОЛЬКО визуальное: field всегда хранит целое поле целиком; step всегда считается по полному полю; рендер не мутирует field. Маска/видимость — это лишь параметр отрисовки, модель данных от неё не зависит.

Инструменты и настройки

• Инструменты: карандаш 1×1, кисть 3×3, ластик 1×1, ластик 4×4 (таблица TOOLS).
• Правая кнопка мыши = ластик: ПКМ (PointerEvent button === 2) на время удержания подменяет активный инструмент ластиком через глобал paintOverride (в paintTool и ghost-превью вместо tool берётся paintOverride || tool); tool/тулбар/сейв при этом не меняются. Если активен ластик, ПКМ сохраняет его размер (1×1/4×4), иначе берётся базовый 1×1 (toolForButton). Сбрасывается в null на pointerup/pointercancel. Контекстное меню подавлено глобальным contextmenu → preventDefault().
• Готовые паттерны (штампы): таблица PATTERNS ({ id, name, group, cells }, cells — ASCII-строки, '1' = живая, '.' = пусто; group — категория для группировки дропдауна): Стойкие — блок, улей, ванна, лодка, кораблик, каравай, пожиратель, пруд, авианосец, длинная лодка, каноэ; Осцилляторы — мигалка, жаба, маяк, часы, пульсар, пентадекатлон; Корабли — глайдер, корабль LWSS, корабль MWSS, корабль HWSS, Loafer; Долгожители (метуселахи) — R-пентамино, жёлудь, Diehard (полностью гибнет на 130-м поколении), громовая птица, кролики; Ружья — ружьё Госпера, ружьё Симкина (36-клеточный вариант; LifeWiki даёт 29-клеточный). НЕ входят в TOOLS: выбираются дропдауном #optPattern в тулбаре (опции строит buildPatternOptions() из PATTERNS по порядку PATTERN_GROUPS — <optgroup> на категорию, пустая опция «нет паттерна» — прямым ребёнком select), активный живёт в глобале stamp (транзиентно, как speedMult — в сейв не пишется, между сессиями не переживает). Нативный popup <select> подавлен (mousedown → preventDefault), вместо него показывается свой список #patternMenu (buildPatternMenu(), .patitem/.patgroup, позиция в positionPatternMenu() рядом с селектом, но никогда не поверх него): на длинном списке (30 фигур) Chromium ставит нативный popup поверх курсора, и обычный клик выбирает случайную фигуру — дропдаун «открывается на нажатии и закрывается на отпускании». Свой список открывается/закрывается по клику на #optPattern (тумблер), выбор фигуры пишет value в #optPattern и шлёт change (единый путь установки stamp), закрывается по выбору/Escape/клику вне/resize/scroll; вне фаз рисования syncDom его закрывает. Сам <select> остаётся контрактом (value/change/disabled/active/optgroup/page.select). Разбор ASCII → offsets делает patternCells(p) (лениво кэширует p._cells/_w/_h), поиск по id — findPattern(id). Ставится веткой stamp в paintTool: якорь — левый верхний угол bbox в кликнутой клетке; зона/бюджет/перезапись чужого — как у краски (вне inZone не ставится, своя не тратит, при нехватке min(new, remaining) в порядке клеток), плюс кламп по доске. Одно нажатие = одна постановка (в onPointerDown штамп не включает painting, drag-повтор не заливает бюджет); ПКМ штамп не ставит, а стирает. Ghost-превью в draw(): клетки в своей зоне — цветом игрока, вылет за зону — COLORS.stampOut (клетки за краем доски не рисуются). selectTool() сбрасывает stamp («последнее действие побеждает»); пока штамп активен, ни одна кнопка инструмента не подсвечена, а #optPattern — подсвечен (.active). На дефолтном 60×60 зона = 30 столбцов, поэтому ружьё (36×9) обрезается — целиком оно влезает при поле ≥ 80. Порядок групп/записей в дропдауне задаёт PATTERN_GROUPS (внутренняя константа, не на window).
• Поворот штампа (колесо мыши и кнопка «↻»): глобал stampRot (0..3, транзиентный, как stamp) — поворот активного паттерна на 90° по часовой за шаг. Источники: (1) обработчик wheel на canvas ({ passive:false }, preventDefault) — действует только в фазах рисования и при выбранном stamp, иначе инертен; deltaY накапливается в wheelAccum до порога WHEEL_ROT_STEP (~100px; deltaMode нормализуется к пикселям) — один поворот на «щелчок» колеса, а тачпад с мелкими частыми дельтами поворачивает контролируемо; (2) кнопка #btnRotate в тулбаре (для сенсорных экранов без колеса) — stampRot = (stampRot+1)%4 за click, видна по syncDom только в фазах рисования при stamp, подпись #rotDeg показывает угол. stampCells() отдаёт offsets с учётом stampRot (базовый разбор кэширует patternCells; повёрнутый — на объекте, p._rot1..3) через rotate90(cells) (клетка (x,y) в bbox w×h → (h-1-y,x), якорь остаётся левым верхним углом). paintTool и ghost-превью используют stampCells(), поэтому поворот влияет и на постановку, и на превью. stampRot/wheelAccum сбрасываются при смене паттерна (#optPattern) и выборе инструмента (selectTool). В сейв не пишется.
• Режим «постановка по отпусканию» (тап, сенсорные экраны): тумблер #btnTapPlace в тулбаре + глобал tapPlace (транзиентный, как stamp/speedMult — в сейв не пишется, но newGame его не сбрасывает: это предпочтение устройства в рамках сессии; между сессиями не переживает). При tapPlace=true ввод работает иначе: onPointerDown только фиксирует удержание (pressing=true, paintOverride под ПКМ) и показывает ghost-превью, onPointerMove ведёт превью (линия не рисуется, painting не включается), а постановка/стирание происходит в onPointerUp одним paintTool (в клетке под пальцем; pointercancel отменяет — постановки нет). Так палец не закрывает точку постановки, а drag не заливает бюджет. Кнопка подсвечена .active при tapPlace. См. tests/test.js 36e–36j.
• Размер поля: 40 / 60 / 80 / 100 / 120 / 150 / 200 / 250 / 300 (FIELD_SIZES, квадраты) плюс прямоугольные FIELD_RECTS = [[60,100],[100,60]]; полный список для меню — FIELD_DIMS = квадраты + прямоугольники. Дефолт 60×60 (fieldW/fieldH). Клетки квадратные (board.cell — сторона), сама доска может быть прямоугольной (board.w×board.h). Квадратный размер меняет setFieldSize(n) (валидация по FIELD_SIZES), произвольный W×H — setFieldDim(w,h).
• Зоны рисования: inZone(x, player) — P1 ставит только в левой половине (2*x < fieldW), P2 — только в правой (2*x >= fieldW); формула целочисленна (корректна и для нечётной ширины). Зона производна от fieldW, в сейв не пишется. zoneSplit() возвращает границу (Math.ceil(fieldW/2)) и предикат. inZoneAt(x,y,player) — игровой предикат зоны: вне кампании делегирует inZone, в кампании проверяет прямоугольник zoneRect (см. «Кампания»).
• Пользовательские настройки (D1): setFieldDim/setFieldSize пишут и menuFieldW/menuFieldH, setWrap — menuWrap, setBudgetTotal — menuBudget; в кампании setFieldDim — no-op. applyMenuSettings() возвращает активную игру (fieldW/fieldH/wrap/budget.total) к menu* (вызывается toMenu/showLevelSelect).
• Бюджет клеток: накопительный на всю партию, дефолт 100 (DEFAULT_BUDGET), задаётся setBudgetTotal(n) (применяется в newGame). Глобал budget = { total, used1, used2 }, remaining(player) — остаток. Тратится только на ручную постановку клетки (перезапись чужого в своей зоне — тоже трата); своя клетка не тратит; при нехватке ставится min(new, remaining) в детерминированном порядке («жадно»). Ластик возвращает бюджет. Симуляция бюджет не меняет (used — инкрементальный счётчик, не выводится из field).
• Правило «новой клетки» (краска): ставится, если field[i] !== player (пусто или чужой) и remaining > 0; used++.
• Правило ластика: стирает только правку текущего хода (field[i] === player и turnStartField[i] !== player), восстанавливая turnStartField[i] и возвращая бюджет; клетки, существовавшие до хода, не трогаются.
• applyBrush — чисто геометрический примитив (кламп по полю, без зоны/бюджета). Игровое действие (фаза + зона + бюджет) — в paintTool(x,y) (единственная точка мутации budget.used*); его используют applyIntent, onPointerDown/Move, paintLine.
• «Сброс»: в фазах рисования — возвращает и поле, и бюджет к снимкам начала хода (turnStartField, turnStartBudget) (не трогает расстановку прошлых фаз, не перезапускает партию).
• Скорость: STEPS_PER_SEC настраивается, стартово ~8 (подбирается плейтестом). Во время симуляции (RUNNING) в панели действий есть ряд из четырёх маленьких кнопок 1×/2×/4×/8× (#speedRow, кнопки .speedbtn с data-speed): клик выбирает множитель speedMult (активная кнопка подсвечена). Эффективная скорость — STEPS_PER_SEC * speedMult; множитель транзиентный (не в сейв, сбрасывается в 1 при newGame); выбор — setSpeed(m).
• Клавиатура: пробел (keydown, event.code==='Space') дублирует паузу — в RUNNING ставит на паузу (pauseGame), в PAUSED запускает (resumeGame). В прочих фазах и при открытом confirmAction инертен; не перехватывается при фокусе в input/select/textarea/button/a (там пробел делает своё дело) и при repeat/Ctrl/Cmd/Alt.
• Персистентность (перф): в RUNNING turnStartField обнуляется, а turnStartBudget — в ноль (startRunning); запись сейва в RUNNING троттлится по времени (PERSIST_INTERVAL_MS, ~3 с).

Рендер, зоны и HUD

• Производительный рендер клеток: offscreen-канва fieldCanvas в координатах fieldW×fieldH (1 px = 1 клетка) + fieldImage (ImageData). rebuildFieldImage() делает один проход по полю и пишет RGBA цвета игрока (alpha 255) для видимых маской клеток, alpha 0 — для скрытых/мёртвых; draw() масштабирует слой одним ctx.drawImage(fieldCanvas, board.x, board.y, board.w, board.h) при imageSmoothingEnabled=false (nearest-neighbor — цвет клеток точный). Рендер не мутирует field.
• Dirty-флаг renderDirty: пересборка offscreen — только при изменении поля/маски/размера. Ставится в paintTool, tick (после step), beginDraw/переходах FSM (смена маски), resetGame, setFieldSize, setFieldASCII, setWrap, applySave, forceState; сбрасывается в draw() после rebuildFieldImage(). В статичных фазах draw() — практически только drawImage. resize() offscreen не пересобирает (он в координатах поля) — пересчитывает лишь геометрию доски. Сетка рисуется только при board.cell >= 5 (на крупных полях не рисуется).
• Подсветка зон рисования: в PLACE_*/EDIT_* своя половина мягко тонируется цветом текущего игрока (10%, rgba(P*_RGB,.10)), а неактивная (чужая) — затемняется оверлеем (COLORS.zoneDim); оба оверлея под слоем клеток (точный цвет клеток не искажается) + тонкая вертикальная линия границы (COLORS.zoneLine, zoneSplit().boundary). В RUNNING/PAUSED рисуется мягкая (5%, globalAlpha) подсветка территорий под клетками: левая — цветом P1, правая — P2 (затемнения нет, половины равноправны); в MENU/финале не рисуется. Цвета затемнения/линии/ghost — из COLORS, зависят от темы (см. «Тема оформления»).
• Акцент текущего игрока (UI-цвет): в фазах рисования syncDom() вешает на body класс turn-p1/turn-p2; через CSS-переменную --accent им подсвечиваются: рамка боковой панели (body.side … #ui, inset box-shadow — не меняет габариты), метка фазы #turnLabel (border-color). Кнопки дорисовки #btnEditP1/#btnEditP2 постоянно подкрашены цветом игрока (.editp1/.editp2). Вне фаз рисования --accent не задан — подсветки нет. Оверлей передачи (#handoff.to-p2) — цветом P2; панель финала (#gameover.win-p1/win-p2) — цветом победителя (ничья без класса).
• HUD бюджета (#budgetLabel): компактный текст «N / total» цветом текущего игрока (без префикса — чтобы плашка не переполняла HUD на узких экранах, M1); при нуле — класс .zero (красный). Виден только в фазах рисования, кроме кампании: там он виден ещё и в RUNNING/PAUSED (HUD уровня показывает остаток на протяжении всего уровня, всегда бюджет игрока 1). В HANDOFF_* (как счёт), MENU/GAME_OVER и в обычных RUNNING/PAUSED — скрыт (в симуляции/паузе обычной партии бюджет не расходуется). Синхронизация — в syncDom().
• UI меню: стартовый сплэш #menu — короткое описание (одно предложение), селект темы #optTheme («Тёмная»/«Светлая») → setTheme(value), #btnContinue («Продолжить партию», выделена акцентным .big, видна только в MENU при наличии suspended), #btnCampaign («Кампания» → LEVEL_SELECT) и #btnPlay («Игра на двоих» → TWO_SETUP) — оба режима в одинаковом нейтральном стиле .act wide; на сплэше нет свёрнутой справки-описания — оно краткое прямо в тексте. Настройки поля (размер/torus/бюджет) перенесены на экран «Игра на двоих» #setup: дропдаун размера #optSize — опции строит buildSizeOptions() из FIELD_DIMS (9 квадратов + 60×100/100×60), value = "WxH", подпись «W×H» → setFieldDim(w,h) по change; чекбокс #optWrap («Замкнутая карта (torus)») → setWrap(checked); бюджет #optBudget — комбобокс (<input type=number list=budgetOptions> + <datalist id="budgetOptions"> с пресетами 100/250/500): можно выбрать пресет или ввести любое число, change/blur → setBudgetTotal(n) (не-число/<1 игнорируется, значение нормализуется); #btnStartTwo («Начать» → requestNewGame()), #btnTwoBack («В меню» → toMenu()). У партии на двоих (#aboutTwo) и у кампании (#aboutCampaign) — свои сворачиваемые справки «Как играть» (<details class="help">). syncDom() отражает fieldW×fieldH (в #optSize), wrap, theme и budget.total в контролах, не перебивая ввод/фокус.
• Тема оформления (theme): 'dark' (дефолт) | 'light'. applyTheme(name) — только визуал: выставляет data-theme на <html> (CSS-переменные :root[data-theme="light"] переопределяют фон/панели/текст), копирует canvas-палитру из CANVAS_THEME[theme] в COLORS (bg/grid/border/zoneDim/zoneLine/eraseGhost) и правит <meta name="theme-color">. setTheme(name) = applyTheme + syncDom() + persist() (пользовательское действие). DOM-цвета — в CSS-переменных (--bg/--fg/--line/--chip-bg/--panel-bg/--muted/...), canvas-цвета — в COLORS/CANVAS_THEME; цвета игроков --p1/--p2 одинаковы в обеих темах. Тема сохраняется в сейве (theme) и применяется в applySave() (нет поля → 'dark'). Кнопки «В меню» (.act.menu) и «Завершить партию» (.act.danger) подкрашены статически (не тематические).
• Адаптивная раскладка (layoutSide): в ландшафте (viewW > viewH) и если сбоку реально влезает панель (≥ SIDE_MIN = 210px с учётом ширины доски, зависящей от пропорций поля), computeBoard() включает боковую раскладку: доска прижата влево и занимает всю высоту (board.h = viewH - 2*pad, board.w = board.h/fieldH*fieldW, board.x = pad, board.y по центру), а body.side собирает управление (#ui/#uiInner) в фиксированную зону справа шириной --side-w (выставляется в computeBoard), так что доска и панель не пересекаются. Иначе (портрет/узкий ландшафт) — прежняя центрированная раскладка: #ui/#uiInner — display:contents, HUD сверху, тулбар/действия снизу. Обёртки #ui/#uiInner — только для раскладки; syncDom() по-прежнему ходит к #hud/#toolbar/#actions по id.
• Пауза — без модального оверлея: модальный #pause удалён; управление паузой живёт инлайн в #actions (нижняя панель или боковая зона). Кнопки переключаются по state в syncDom(): в RUNNING видны «Пауза» (#btnPause) и «Завершить партию» (#btnEnd); в PAUSED — «Старт симуляции» (#btnResume), «Дорисовать красным» (#btnEditP1), «Дорисовать зелёным» (#btnEditP2), «Завершить партию» (#btnEndPause) и «В меню» (#btnPauseMenu). Кнопки дорисовки видны только при PAUSED && fieldStable (метка фазы получает суффикс «· поле стабильно»); на «живом» поле (ручная пауза, до стабилизации) они скрыты. Отдельные кнопки дорисовки дают независимый выбор игрока (startEdit(1)/startEdit(2)) без форс-цепочки P1→P2: commitTurn() из EDIT_* возвращает в PAUSED, а симуляцию запускает отдельная кнопка. Кнопки в нижней панели переносятся (flex-wrap), а в боковой зоне идут колонкой на всю ширину. Кнопки «Завершить партию» (#btnEnd/#btnEndPause) вызывают requestEndGame() — партия не завершается без подтверждения. Диалог подтверждения #confirm (#btnConfirmOk/#btnConfirmCancel) обслуживает оба случая: новую партию (confirmAction='new') и завершение ('end').

Сохранение и резюм (localStorage life-save-v1)

Единственный ключ — SAVE_KEY = 'life-save-v1' (имя историческое, не менять), значение — JSON-объект save (шаблон freshSave()). Форма сейва v2 (v — версия формата, текущая SAVE_VERSION = 2):

Поле	Смысл
v	версия формата (текущая SAVE_VERSION = 2; для миграций)
fieldW / fieldH	размер активной игры (для резюма; в кампании — размер уровня)
wrap	«Замкнутая карта» активной игры
menuFieldW / menuFieldH	пользовательский размер поля из меню (настройка)
menuWrap	пользовательская «Замкнутая карта» (настройка)
menuBudget	пользовательский лимит бюджета (настройка)
theme	тема оформления 'dark' | 'light' (настройка; дефолт 'dark')
tool	id активного инструмента (настройка; pencil/brush/erase1/erase4)
stepsPerSec	скорость симуляции (настройка)
budget	{ total, used1, used2, start1, start2 } — лимит и израсходовано по игрокам; startN — снимок начала хода
state / turn	состояние FSM и чей ход (резюм партии)
reason	причина финала: 'extinct' | 'manual' | 'stalemate' | 'win' | 'defeat' | null
winner	'1' | '2' | 'draw' | null
field	поле целиком в base64 (1 байт/клетка) — только при резюме, иначе null
turnStartField	снимок поля на начало хода для «Сброса» (base64 | null)
stable	признак устойчивости поля на паузе (fieldStable; для гейта дорисовки после reload) — true | false
campaign	идёт ли уровень кампании (аддитивно; нет поля → false)
levelIndex	индекс уровня кампании 0..N-1 или null (аддитивно; валидный int или null)
progress	прогресс кампании { unlocked } — число открытых уровней; normalizeProgress() клампит в [1, N] (нет поля → {unlocked:1})
suspended	отложенная в меню партия { state, turn, fieldW, fieldH, wrap, field, turnStartField, stable, budget:{total,used1,used2,start1,start2}, campaign, levelIndex } (base64-поля) или null — для кнопки «Продолжить партию»

Разделение «настройки меню» / «активная игра» (D1): fieldW/fieldH/wrap/budget.total описывают активную игру (её резюмит field), а menuFieldW/menuFieldH/menuWrap/menuBudget — пользовательские настройки. В обычном потоке они совпадают; кампания применяет к активной игре размер/wrap/бюджет уровня, не трогая menu* (startLevel). Выход из кампании (toMenu/showLevelSelect) и #optSize/#optWrap/#optBudget в syncDom работают с menu*, поэтому обычная партия после кампании стартует с прежними настройками пользователя. Старые сейвы без menu* читаются как «menu = активным».

Зона рисования в сейв не пишется (производна от fieldW; в кампании восстанавливается из levelIndex + конфига уровня). Поля suspended, theme, stable, campaign, levelIndex, progress, menuFieldW/menuFieldH/menuWrap/menuBudget — аддитивные расширения формата v2 (не ломают старые сейвы: нет поля → null/'dark'/false/false/null/{unlocked:1}; старый код просто игнорирует лишний ключ). Отложенная партия хранит свой размер/wrap/budget.total (D2) — в меню настройки могли измениться, но resumeFromMenu() восстанавливает снимок целиком (включая режим кампании и zoneRect).

• Резюмируемые состояния (isResumable): PLACE_P1/PLACE_P2/EDIT_P1/EDIT_P2/RUNNING/PAUSED/HANDOFF_P1_P2. Для них field пишется целиком (скрытие — только визуальное); в кампании дополнительно пишутся campaign/levelIndex, и при восстановлении zoneRect берётся из конфига уровня. GAME_OVER/MENU/LEVEL_SELECT — это настройки + чистый старт в MENU (выбор уровня не резюмируется); при этом в MENU отложенная партия/уровень живёт в suspended.
• Когда пишем (persist()): переходы FSM (newGame/commitTurn/handoffNext/pauseGame/resumeGame/startEdit/finish/resetGame), смена инструмента (selectTool), размера (setFieldSize), опции wrap (setWrap), темы (setTheme), бюджета (setBudgetTotal), выход в меню (toMenu); а во время RUNNING — троттлинг по времени (PERSIST_INTERVAL_MS, ~раз в 3 с в tick()), не каждый шаг. В RUNNING turnStartField обнуляется (startRunning), а turnStartBudget — в {used1:0,used2:0} (симметрично, чтобы в сейве не было иллюзии снимка хода).
• Авто-пауза при уходе со вкладки (visibilitychange) меняет state в памяти, но не вызывает persist() — чтобы скрытие вкладки на миг не перезаписывало RUNNING на PAUSED и партия корректно резюмилась.
• Чтение (loadSave()): нет данных / битый JSON / не объект / v > SAVE_VERSION → null (старт в MENU, без падений). Сейв без v трактуется как v1; поля нормализуются (в т.ч. suspended через normalizeSuspended() — битый/невалидный снимок даёт null, stable → false). applySave(s) при старте применяет настройки (wrap, budget, rebuildNeighborTables()), восстанавливает отложенную партию (suspended) и, если s.state резюмируемое и поле валидной длины, восстанавливает партию целиком (в RUNNING окно устойчивости засевается заново, в PAUSED/EDIT_* берётся stable из сейва).
• Миграции: при смене формата добавить шаг в loadSave() рядом с образцом-комментарием (// M1: …), подняв SAVE_VERSION; старые сейвы обязаны оставаться читаемыми. M1 (v1→v2): wrap = false, свежий budget = { total: DEFAULT_BUDGET, used1: 0, used2: 0, start1: 0, start2: 0 }.
• Валидация размера из меню — квадраты по FIELD_SIZES (setFieldSize игнорирует чужие значения), прямоугольники — через setFieldDim(w,h) (принимает любой корректный isValidSize); при загрузке сейва принимается любой корректный размер (тестовые поля могут быть не из списка). mode — производный описатель фазы из state (modeForState()), используется в игровом цикле (frame).

Соглашения о коммитах

• Сообщение коммита — краткое и по делу: тема одной строкой, при необходимости 2–4 пункта тела.
• Без лишних трейлеров и служебных подписей (Co-authored-by и т.п.) — только смысл изменения.
• Язык — русский, в стиле существующей истории коммитов (git log --oneline).

Проверка

Линтеров/typecheck/CI нет — два рубежа:

1. Синтаксис: node tools/check.mjs — вынимает JS-код <script> из index.html и прогоняет node --check (при ошибке показывает номер строки index.html). Плюс tools/check.mjs печатает check: OK — ….
2. Главный рубеж — headless-суита (запускать после правок index.html или tests/test.js):

   cd tests
   npm install   # puppeteer-core
   npm test      # = node test.js
   

   Ждать все PASS и exit 0 (финальный вывод ===== ИТОГ: N/N =====).
3. Паритет с прототипом (harness — tools/old-ref/, не обязателен для каждой правки, но после изменений ядра полезен):

   g++ -std=c++17 -O2 -o tools/old-ref/old_ref tools/old-ref/old_ref.cpp
   node tools/old-ref/diff-our.js          # exit 0 ⇔ наш step == clean (273/273)
   

   Подробности и пересборка фикстуры — в tools/old-ref/README.md.

Тестирование

Инфраструктура. tests/test.js — headless-суита на puppeteer-core со своим мини-фреймворком:

• ok(name, cond, extra) — записывает/печатает PASS|FAIL;
• waitState(page, st, timeout) — ждёт state === st (поллинг 40 мс);
• waitCond(page, expr, timeout) — ждёт произвольное выражение в странице;
• sleep(ms) — пауза.

Параметры запуска:

• Chromium из process.env.CHROMIUM || '/usr/bin/chromium-browser' (при падении на старте — поправьте путь под свой чекаут);
• viewport 390×844 @2 (defaultViewport), запуск с --no-sandbox --disable-gpu --hide-scrollbars --mute-audio;
• URL игры резолвится от каталога репо (file://…/index.html);
• в конце — console.log('===== ИТОГ: N/N =====') и process.exit(failed ? 1 : 0);
• суита подписывается на page.on('pageerror') и page.on('console') и проверяет отсутствие pageerror/console.error (молчаливые ошибки — это провал).

Тест-форсы (часть архитектуры, НЕ тестовый код): forceState(name), setFieldASCII(str,w), stepN(n), getScores(), hashField() — выставляются на window, чтобы page.evaluate мог их дёргать. Тесты ходят к внутренним глобалам напрямую, поэтому имена глобалов — стабильный публичный контракт (см. раздел «Стабильные глобалы»).

Что обязательно покрыть:

• Правила Conway:
  • блок 2×2 неподвижен;
  • блинкер — период 2;
  • глайдер за 4 шага сдвигается на (1,1);
  • рождение при 3 соседях; смерть при <2 и >3; выживание при 2 и 3.
• Наследование цвета: 1,1,2 → 1; 1,2,2 → 2; tie-break 1,2,3 → 1 (наименьший id). При двух игроках 2-1 однозначно.
• Границы: wrap=false — соседи за краем не считаются (как раньше); wrap=true — заворот (сосед с противоположной стороны), рождение через шов. Паритет step с эталоном закреплён при wrap=false (273/273) и для torus (reference-torus.json, 273/273). Переключение глобала setWrap(b) влияет на step/stepN без явного параметра и не мутирует field.
• Чистота step: step не мутирует src (hash до/после совпадает) — в т.ч. при wrap; stepN(n) детерминирован (два прогона → одинаковый hash).
• Инструменты: карандаш = 1 клетка, кисть = 9, ластики 1×1 и 4×4, кламп у границ (инструмент не выходит за поле); ПКМ (page.mouse.down/up({button:'right'})) стирает клетку, не меняя активный инструмент (paintOverride).
• Паттерны (штампы): patternCells (число клеток/размер bbox для всех PATTERNS, включая новые фигуры); постановка через paintTool (все клетки, якорь левый-верхний, бюджет −N), свои клетки не тратят; обрезка по зоне и кламп по доске, «Сброс» возвращает поле+бюджет; корректность фигур на симуляции (глайдер (1,1) за 4 шага, блок неподвижен, мигалка период 2, пульсар период 3, ружьё растит население; новые: стойкие ванна/лодка/кораблик/каравай/пожиратель/пруд/авианосец/длинная лодка/каноэ неподвижны, маяк/часы период 2, пентадекатлон период 15, жёлудь/громовая птица/кролики растят население, Diehard полностью гибнет за 130 шагов, MWSS/HWSS период 4 со смещением 2, Loafer период 7 со смещением 1, ружьё Симкина растит население); дропдаун #optPattern (выбор → stamp, подсветка .active, selectTool сбрасывает, disabled вне рисования; группировка — 5 optgroup по PATTERN_GROUPS, пустая опция прямым ребёнком select, все id на месте); свой список #patternMenu (клик по #optPattern открывает/закрывает, 30 фигур + 5 заголовков групп, выбор фигуры задаёт stamp/.active и закрывает список, Escape/клик вне закрывают, stamp при этом не сбрасывается); одно нажатие = одна постановка (drag не повторяет), ПКМ стирает; транзиентность (stamp не переживает reload).
• Поворот штампа: stampCells при stampRot 0..3 (у симметричного bbox размер сохраняется, у несимметричного w/h меняются местами: мигалка 3×1→1×3), 4 поворота = исходная форма; wheel на canvas (вниз +1, вверх −1) действует только в фазах рисования при активном stamp, иначе инертен; кнопка #btnRotate (клик +90°, 4 клика → 0, подпись угла в #rotDeg, скрыта без штампа/вне рисования); постановка paintTool использует stampCells (вертикальная мигалка); stampRot сбрасывается при смене паттерна/инструмента.
• Режим «постановка по отпусканию»: тумблер #btnTapPlace (клик → tapPlace, подсветка .active); при tapPlace=true mouse.down/mouse.move (в т.ч. drag) не меняют поле и бюджет, mouse.up ставит ровно одну клетку под пальцем; со штампом фигура ставится целиком по отпусканию; pointercancel отменяет постановку; ПКМ стирает по отпусканию, не меняя инструмент; tapPlace транзиентен (не переживает reload).
• Зоны: inZone (P1 лево / P2 право), корректность для чётной и нечётной ширины (полное покрытие без пересечений); applyIntent/paintTool вне своей зоны/доски не действуют (поле не меняется); кисть обрезается по границе зоны; drag из своей половины в чужую не закрашивает чужую.
• Бюджет: трата на новую/чужую клетку (карандаш +1, кисть 3×3 на пустом +9), своя не тратит; перезапись чужого — трата +1; частичная нехватка — min(new, remaining); исчерпание — новые не ставятся, ластик работает; ластик возвращает только правку текущего хода (и восстанавливает перезаписанный чужой цвет); «Сброс» восстанавливает бюджет к turnStartBudget; setBudgetTotal применяется в newGame; бюджет переживает reload.
• Размеры: FIELD_SIZES = 40…300 (9 значений) плюс прямоугольные FIELD_RECTS (60×100/100×60); дефолт 60; setFieldSize применяет значения из FIELD_SIZES и игнорирует чужие, setFieldDim(w,h) — произвольный W×H; 300×300 (90000 клеток) рендерится/резюмится без ошибок; прямоугольное поле (60×100) рендерится/резюмится, зона делится по ширине, клетки квадратные.
• Кампания: схема CAMPAIGN_LEVELS (103 уровня: 7 ручных + 96 сгенерированных, cells — непустой массив координат в границах без дублей, id уникальны и покрывают 1..103, зона внутри поля, свой бюджет; присутствуют все фигуры улей/мигалка/жаба/каравай/пульсар/ружьё, есть уровни с врагом вне зоны; «Издалека» на 10-м месте 60×60/зона {0,0,14,20}/бюджет 60; showcase id 101..103 на индексах 10..12; порядок вставки (id5..id10 на индексах 3..8, id4 на индексе 9); размеры сгенерированных (id 5..100) не убывают, последний == 300; у сгенерированных (id 5..100) нет зоны «всё поле», полная зона только у ручных «Разминка»/«Рой», среди сгенерированных присутствуют все 7 типов зон; детерминизм и --check генератора tools/gen-campaign-levels.mjs, сверка вывода с вшитым блоком id 5..100); startLevel (state/turn/режим/уровень/зона/бюджет/враг); видимость врага (visibleMask=[1,2] и пиксельно); inZoneAt (делегирование inZone вне кампании + прямоугольник zoneRect, регресс zoneRect=null); запрет трогать врага краской/штампом/ластиком (поле и бюджет неизменны); своя клетка ставится и тратит бюджет; победа (0 врага → win/winner='1'/unlocked++); вымирание игрока — не финал; поражение (remaining(1)<=0 + враг жив на PAUSED/fieldStable → defeat/winner='2' через checkStalemate и через авто-паузу tick; негативные случаи); прогресс/разблокировка (закрытый уровень не выбирается); сейв/резюм уровня после reload; suspended кампании (+ reload); HUD («Уровень N/103», остаток бюджета, скрытый счёт); проводка UI (#btnCampaign/#btnLevelsBack/#btnNextLevel/#btnRevenge/#btnGameoverLevels/#btnRestart; список #levelList из CAMPAIGN_LEVELS.length кнопок прокручивается, #btnLevelsBack виден; #btnRestart видна в любой фазе уровня и перезапускает его через подтверждение confirmAction='restart'); авто-пауза кампании сразу открывает EDIT_P1 (без клика «Дорисовать»); нормализация reason win/defeat и progress, reload в LEVEL_SELECT→MENU.
• Скрытие: в PLACE_P1 рендер не рисует клетки цвета 2, но field/hash неизменны; смена маски не мутирует field.
• Рендер (offscreen): pixel-тесты скрытия проходят после перехода на drawImage (точный цвет клеток: 0 «зелёных» пикселей в PLACE_P1, >0 в PLACE_P2); draw() не мутирует field; dirty-флаг ставится на мутациях и сбрасывается в draw() (в т.ч. stepN); крупное поле (300×300) рисуется без pageerror; подсветка зон не искажает точный цвет живых клеток (пиксель центра клетки = цвет игрока, и в активной, и в затемнённой половине); 10%-тинт своей половины окрашивает пустую клетку в оттенок игрока (доминирует его канал); классы акцента body.turn-p1/turn-p2 есть только в фазах рисования, #handoff.to-p2 — в HANDOFF_P1_P2, #gameover.win-p1/win-p2 — по победителю.
• UI меню: стартовый сплэш #menu (краткое описание + #optTheme + #btnContinue/#btnCampaign/#btnPlay) и экран #setup («Игра на двоих»): дропдаун размеров #optSize (квадраты 40…300 + прямоугольные 60×100/100×60, value="WxH"), чекбокс #optWrap → wrap, селект темы #optTheme (Тёмная/Светлая) → theme, комбобокс #optBudget (ввод + пресеты #budgetOptions) → budget.total; #btnStartTwo/#btnTwoBack; сворачиваемые справки #aboutTwo/#aboutCampaign; syncDom() отражает настройки.
• FSM: все переходы из таблицы (включая HANDOFF_P1_P2 и независимый цикл EDIT_* → PAUSED: дорисовка любого игрока и отдельный «Старт симуляции»).
• Стартовые экраны: в MENU виден сплэш #menu (тема и режимы), #setup скрыт, настройки поля лежат в #setup; #btnPlay → TWO_SETUP (#setup виден, #menu скрыт), #btnTwoBack → MENU; сворачиваемые справки #aboutTwo/#aboutCampaign присутствуют; TWO_SETUP не резюмируется (reload → MENU); «Игра на двоих» при suspended открывает #confirm ('new').
• Стабильность/дорисовка: блок 2×2 (фиксированная точка) и блинкер (период 2) в RUNNING → авто-PAUSED + fieldStable=true, кнопки дорисовки видны; в кампании авто-пауза сразу открывает EDIT_P1 (без клика «Дорисовать»), а «Готов» из неё сразу запускает симуляцию (цикл «нарисовал → побежало»); глайдер (поле не застывает) держит RUNNING, fieldStable=false, ручная пауза дорисовку не открывает (startEdit — no-op); resumeGame сбрасывает fieldStable; fieldStable переживает reload в PAUSED и откладывается в suspended.
• «Сброс»: восстанавливает поле и бюджет к началу текущего хода.
• Финал: вымирание (reason='extinct') → победа; ничья; ручное завершение (reason='manual'); вымирание объявляется после такта, как только у стороны 0 клеток (бюджет его не отодвигает); реванш/сброс.
• Тупик по бюджету (reason='stalemate'): стабильное поле (авто-пауза) + отстающий без бюджета → авто-GAME_OVER/stalemate с победой лидера; ничья при равном счёте завершается, только если бюджет исчерпан у обоих (иначе игра продолжается); при бюджете у отстающего авто-финала нет; текст финала объясняет кончившийся бюджет; reason='stalemate' переживает нормализацию сейва.
• Меню не теряет партию: toMenu() откладывает партию в suspended, кнопка #btnContinue видна только при наличии suspended; resumeFromMenu() возвращает ту же партию (state/turn/поле/бюджет/размер); «Игра на двоих»/«Реванш» при suspended открывают #confirm (отмена сохраняет партию, подтверждение запускает новую); suspended переживает reload.
• Подтверждение «Завершить партию»: клик #btnEnd/#btnEndPause не завершает партию, а открывает #confirm (confirmAction='end') и ставит симуляцию на паузу (поле за оверлеем не меняется); «Отмена» возвращает RUNNING (если шла), подтверждение → GAME_OVER/manual.
• Резюм: продолжение партии после reload (localStorage): state/turn/field/счёт восстанавливаются; сценарии в PLACE_P2 и в RUNNING; партия остаётся играбельной; «Сброс» использует сохранённый снимок начала хода.
• Сейв v2: freshSave() даёт v===2 и новые поля (wrap/бюджет); v1-сейв мигрируется (wrap=false, дефолтный бюджет) и резюмится; v > SAVE_VERSION → null.
• Миграция/битый сейв: мусор/массив/старый формат без v → loadSave() не падает, игра стартует в MENU; v > SAVE_VERSION → null; миграция v1→v2 даёт wrap=false и свежий бюджет.
• Настройки: размер из меню применяется к новой партии; tool, STEPS_PER_SEC, wrap, theme и budget.total переживают reload.
• Тема: дефолт dark; setTheme('light')/#optTheme меняет data-theme, COLORS.bg, <meta name="theme-color"> и save.theme, переживает reload; смена темы в меню не теряет отложенную партию (suspended).
• Проводка DOM / пауза инлайн: реальные page.click по #btnPlay/#btnStartTwo/#btnTwoBack/#btnReady/#btnHandoff/#btnHandoffBack/#btnPause/#speed1/#speed2/#speed4/#speed8/#btnResume/#btnEditP1/#btnEditP2/#btnEnd/#btnEndPause/#btnRevenge/#btnRestart/#btnSettings/#btnPauseMenu/#btnGameoverMenu/#btnContinue/#btnConfirmOk/#btnConfirmCancel и кнопкам инструментов (размер — page.select('#optSize', …)); Pointer Events через page.mouse. Модальный #pause отсутствует в разметке, кнопки показываются по state (RUNNING — «Пауза»+«Завершить»+ряд скорости; PAUSED — «Старт симуляции»/«Дорисовать красным»/«Дорисовать зелёным»/«Завершить»/«В меню»); кнопки дорисовки видны только в PAUSED (и только при fieldStable). Обычная партия: #btnPlay → TWO_SETUP, #btnStartTwo → старт, #btnTwoBack → MENU. Кампания: #btnCampaign → LEVEL_SELECT, #levelList (заблокированные button:disabled), #btnLevelsBack, #btnNextLevel, #btnGameoverLevels, #btnRevenge («Заново», без подтверждения), #btnRestart («Заново» в панели действий, перезапуск через подтверждение), диалог #confirm (confirmAction 'campaign'/'restart').
• Скорость (#speedRow): ряд из 4 кнопок 1×/2×/4×/8× виден только в RUNNING, скрыт в PAUSED; клик по кнопке задаёт speedMult (1/2/4/8), активная кнопка — класс .active (по умолчанию 1×).
• Клавиатура (пробел): keydown пробела (event.code==='Space') в RUNNING ставит паузу, в PAUSED — старт симуляции (то же, что #btnPause/#btnResume); вне этих состояний, при repeat/модификаторах, при открытом confirmAction и при фокусе в input/select/textarea/button/a — инертен. Проверяется реальным page.keyboard.press('Space') с предварительным blur().
• Раскладка: в ландшафте включена боковая панель (доска во всю высоту слева, управление справа, без пересечения); в портрете и узком ландшафте — центрированная раскладка.
• applyIntent: красит/стирает в фазе рисования; вне фаз и вне доски — не действует; возвращает true только при фактическом изменении (клик по врагу/своей клетке → false, D5).
• Дефекты ревью (D1–D5): настройки пользователя (menu*) переживают кампанию и стартуют обычную партию с прежними значениями (D1); suspended хранит budget.total и возвращает его (D2); ручное завершение уровня → «Уровень прерван» (D3); setFieldSize/setFieldDim в кампании — no-op (D4); победа кампании проверяется и честным tick-прогоном (враг гибнет под симуляцией).
• Resize: canvas пересчитывается под 2–3 viewport и DPR (кап 2), без pageerror.

Подводные камни

• Глобалы — контракт. Переименование любого имени из раздела «Стабильные глобалы» (или имени состояния) ломает тесты молча. Держать имена, либо синхронно править tests/test.js в том же коммите.
• Ввод — только Pointer Events (pointerdown/pointermove/pointerup), НЕ touch/mouse-обработчики: так тест управляет игрой мышью через page.mouse. Не заменять на тач.
• CSS: touch-action: none на игровых поверхностях и contextmenu → preventDefault() (не всплывает меню на тач-устройствах / правом клике).
• Рендер не мутирует field. Отрисовка и логика разделены; скрытие реализуется параметром рендера, а не правкой модели.
• Симуляция детерминирована: никакого Math.random в игровой логике; фиксированный шаг через аккумулятор (STEPS_PER_SEC), клампить dt как в ../fishing-game (чтобы переживать просадки fps).
• Границы по умолчанию жёсткие (как в прототипе); torus — только явная опция wrap. При wrap=false семантика соседей не должна меняться — иначе ломается паритет step с эталоном (273/273).
• Правило рождения — большинство из 3, а не баг прототипа (old/life/life.cpp:19-50, необнуляемый parent[]). Не восстанавливать.
• applyBrush — геометрический (без зоны и бюджета); зона и бюджет живут ТОЛЬКО в paintTool. Не тащить игровые правила в applyBrush (на нём держатся тесты инструментов).
• budget.used — инкрементальный счётчик: симуляция меняет field, но бюджет не трогает; used нельзя выводить из field. Мутируется только в paintTool (и сбрасывается/восстанавливается в newGame/resetGame/applySave).
• Имена состояний — строго из списка FSM (MENU, TWO_SETUP, LEVEL_SELECT, PLACE_P1, HANDOFF_P1_P2, PLACE_P2, HANDOFF_P2_START, RUNNING, PAUSED, EDIT_P1, EDIT_P2, GAME_OVER): тесты сравнивают state строками.
• Сейв — ключ localStorage life-save-v1 (имя историческое); текущая версия формата SAVE_VERSION = 2; форма включает wrap, budget, reason финала, stable и отложенную партию suspended; при смене формата добавлять миграцию в loadSave() (старые сейвы обязаны оставаться читаемыми).
• Резюм: после reload партия должна продолжаться с сохранённого состояния (не терять field/счётчики хода).
• Дорисовка — только на стабильном поле. startEdit() — no-op, если !fieldStable (на «живом» поле/ручной паузе кнопки скрыты). Признак fieldStable ставится ТОЛЬКО в tick() (обнаружение повтора хеша), сбрасывается при любом изменении поля/семантики (startRunning/seedStability, newGame, setFieldDim, setFieldASCII, setWrap, resumeFromMenu, applySave) и сохраняется при выходе из EDIT_*. Тест-форс forceState('PAUSED') выставляет fieldStable = true (тесты переходов не гоняют реальную симуляцию) — не полагаться на это в игровой логике.
• fieldStable — производное, не в логике step. Устойчивость определяется по hashField() (FNV-1a) в окне STABLE_WINDOW; коллизия 32-битного хеша даёт ложное срабатывание ~2⁻³². Не тащить детекцию в step (чистота/паритет ядра) и не делать Math.random.

Где крутить

• COLORS — палитра игроков/фона/сетки (canvas); структурные цвета UI — CSS-переменные, палитры тем — CANVAS_THEME.
• TOOLS — состав и размеры инструментов (карандаш/кисть/ластики); PATTERNS — набор готовых паттернов-штампов ({ id, name, group, cells }, ASCII-формы cells, якорь — левый верхний угол; выбираются #optPattern, активный — транзиентный stamp); PATTERN_GROUPS — порядок групп дропдауна (Стойкие/Осцилляторы/Корабли/Долгожители/Ружья). stampRot — поворот штампа 0..3 (колесо мыши или кнопка «↻» #btnRotate), rotate90/stampCells — его реализация; tapPlace — режим «постановка по отпусканию» (кнопка «👆 тап» #btnTapPlace).
• STEPS_PER_SEC — скорость симуляции (стартово ~8); speedMult — её транзиентный множитель 1/2/4/8 (ряд кнопок 1×/2×/4×/8× в #speedRow, не в сейв).
• STABLE_WINDOW — окно распознавания устойчивости поля (1024 поколения; гейт дорисовки, см. «Геймплей и FSM»).
• DEFAULT_BUDGET — лимит клеток на игрока за партию (стартово 100).
• CAMPAIGN_LEVELS — уровни кампании ({id,name,w,h,wrap,budget,zone,cells}, cells — массив координат клеток врага [x,y]): 7 ручных (id 1..4 и 101..103) + 96 сгенерированных (id 5..100); CAMPAIGN_PLAYER/CAMPAIGN_ENEMY — цвета сторон (1/2).
• tools/gen-campaign-levels.mjs — детерминированный генератор 96 уровней кампании (seeded PRNG, без Math.random): размер монотонно растёт 60→300, бюджет — с размером, зоны разнообразны (7 типов, без «всё поле»: половина/центр/углы/полосы/прямоугольник), часть уровней с врагом вне зоны. Печатает готовый блок cells для вставки в CAMPAIGN_LEVELS (node tools/gen-campaign-levels.mjs); --check — самопроверка (96 уровней, валидность, нет полной зоны, все 7 типов зон, монотонность). После правок генератора перенесите его вывод в index.html.
• Дефолтный размер поля — 60×60 (варианты 40…300, FIELD_SIZES; прямоугольные FIELD_RECTS, полный список — FIELD_DIMS).
• menuFieldW/menuFieldH/menuWrap/menuBudget — пользовательские настройки меню (D1), отдельно от активной игры (fieldW/fieldH/wrap/budget.total).
• SAVE_KEY — ключ localStorage (life-save-v1); текущий формат — SAVE_VERSION = 2.

Стабильные глобалы

Полный список имён, на которые завязаны тесты (контракт):

state, turn, mode, tool, TOOLS, winner, field, next, fieldW, fieldH,
step, applyBrush, countByPlayer, isExtinct, liveNeighbors, majorityColor,
hashField, newGame, commitTurn, handoffNext, handoffBack, pauseGame, resumeGame, startEdit,
endGame, resetGame, checkEnd, save, SAVE_KEY, freshSave, loadSave, persist,
forceState, setFieldASCII, stepN, getScores,
ctx, canvas, viewW, viewH, dpr, visibleMask, applyIntent, reason, STEPS_PER_SEC, speedMult,
wrap, budget, inZone, zoneSplit, setWrap, setBudgetTotal, remaining, paintTool,
DEFAULT_BUDGET, renderDirty, fieldCanvas,
FIELD_SIZES, FIELD_DIMS, setFieldSize, setFieldDim, selectTool, syncDom, board, draw, fieldImage,
turnStartField, turnStartBudget, bytesToB64, layoutSide,
suspended, confirmAction, theme, applyTheme, setTheme, fieldStable,
PATTERNS, stamp, patternCells, findPattern, stampRot, stampCells, rotate90, wheelAccum,
tapPlace,
campaign, levelIndex, zoneRect, campaignProgress, pendingLevel,
CAMPAIGN_LEVELS, CAMPAIGN_PLAYER, CAMPAIGN_ENEMY,
startLevel, showLevelSelect, showTwoSetup, inZoneAt, campaignZoneFor, requestCampaignLevel, normalizeProgress,
menuFieldW, menuFieldH, menuWrap, menuBudget

Дополнительные имена в последних двух строках найдены прямым поиском по tests/test.js (реально читаются тестами из контекста страницы): FIELD_SIZES/setFieldSize (размеры поля), selectTool (инструменты), syncDom (проводка DOM), board (геометрия доски), draw/fieldImage (offscreen-рендер), turnStartField/turnStartBudget (снимок хода), bytesToB64 (сейв), layoutSide (адаптивная боковая раскладка), suspended/confirmAction (отложенная в меню партия и диалог подтверждения), theme/applyTheme/setTheme (тема оформления), fieldStable (устойчивость поля — гейт дорисовки), campaign/levelIndex/zoneRect/campaignProgress/ pendingLevel/CAMPAIGN_LEVELS/CAMPAIGN_PLAYER/CAMPAIGN_ENEMY/startLevel/showLevelSelect/ inZoneAt/campaignZoneFor/requestCampaignLevel/normalizeProgress (кампания), menuFieldW/menuFieldH/menuWrap/menuBudget (пользовательские настройки меню, D1). COLORS и SAVE_VERSION в тестах встречаются только в комментариях и именах кейсов — как глобалы из страницы они не читаются, но входят в контракт настроек/сейва.

useWrap — опциональный параметр liveNeighbors(f,x,y,useWrap), step(src,dst,useWrap), stepN(n,useWrap); по умолчанию берётся глобал wrap (существующие вызовы без параметра сохраняют прежнее поведение). Параметр выбирает ветку обхода, но таблицы индексов соседей (colL/colR/rowU/rowD) строятся по глобалу wrap и используются только в ветке wrap=true (torus); при useWrap=false обход идёт brute-force циклом с проверкой границ. Пересобираются таблицы только через setWrap(b), поэтому смена режима — через setWrap (явный useWrap держать согласованным с глобалом, иначе таблицы и ветка обхода разойдутся).

имена состояний:

MENU, TWO_SETUP, LEVEL_SELECT, PLACE_P1, HANDOFF_P1_P2, PLACE_P2, RUNNING, PAUSED,
EDIT_P1, EDIT_P2, GAME_OVER

Ожидаемая роль ключевых из них:

• state — текущее состояние FSM; turn — чей ход; mode — производный описатель фазы (modeForState(): menu/place/edit/handoff/run/pause/over; используется игровым циклом frame); tool — выбранный инструмент; winner — победитель/ничья;
• field — плоский Uint8Array(fieldW*fieldH) цветов (0 = мёртвая, 1 = P1, 2 = P2); next — буфер следующего поколения того же размера; fieldW/fieldH — размеры;
• step — один тик симуляции (читает src — текущее поле, пишет dst — буфер next, не мутирует src); stepN(n) — n тиков; hashField() — детерминированный хеш поля; setFieldASCII(str,w) — построить поле из ASCII-строк (согласует снимки turnStartField/turnStartBudget); forceState(name) — форс состояния;
• applyBrush(...) — ГЕОМЕТРИЧЕСКИЙ примитив штампа инструмента (кламп по полю, без зоны/бюджета); paintTool(x,y) — ИГРОВОЕ действие (фаза + зона + бюджет, единственная точка мутации budget.used*); countByPlayer(...) — счётчики живых по цветам; isExtinct() — вымирание; liveNeighbors(...) — число живых соседей; majorityColor(...) — цвет большинства живых с tie-break (наименьший id);
• wrap — глобал-опция «Замкнутая карта»; setWrap(b) — установить + пересобрать таблицы; budget = { total, used1, used2 } — лимит/расход; remaining(player) — остаток; setBudgetTotal(n) — задать лимит; inZone(x,player) — предикат зоны; zoneSplit() — граница зон + предикат; DEFAULT_BUDGET — дефолт лимита;
• newGame(), commitTurn(), handoffNext(), handoffBack(), pauseGame(), resumeGame(), startEdit(player), endGame(), resetGame(), checkEnd() — переходы FSM; requestEndGame()/confirmProceed()/cancelConfirm() — подтверждение завершения партии (и общей опасной операции); toMenu()/suspendGame()/resumeFromMenu() и requestNewGame() — меню и отложенная партия (suspended);
• suspended — снимок прерванной партии ({state,turn,fieldW,fieldH,wrap,field,turnStartField,stable,budget}) или null; confirmAction — открытый диалог подтверждения (null | 'new' | 'end' | 'campaign' | 'restart'), confirmResume — вернуть ли симуляцию при «Отмене»;
• visibleMask() — массив видимых цветов по состоянию ([1]/[2]/[]/[1,2]; скрытие только визуальное); applyIntent(px,py) — применить активный инструмент в экранной точке (CSS-пиксели холста) для тестов/ввода (учитывает зону);
• ctx, canvas, viewW, viewH, dpr — холст и его геометрия (DPR-кап 2); reason — причина финала; STEPS_PER_SEC — скорость симуляции; speedMult — транзиентный множитель 1/2/4/8 (ряд кнопок 1×/2×/4×/8×, в сейв не пишется);
• renderDirty — dirty-флаг offscreen-слоя клеток; fieldCanvas (var, доступна как глобал) — offscreen-канва fieldW×fieldH в координатах поля (см. «Рендер, зоны и HUD»);
• fieldStable — устойчивость поля на паузе (гейт дорисовки): true, только когда симуляция сама остановилась на фиксированной точке/коротком цикле (recentHashes/STABLE_WINDOW, см. «Геймплей и FSM»); resetStability()/seedStability() — сброс/засев окна хешей (внутренние, в контракт не входят); checkStalemate() — авто-финал тупика по бюджету на стабильной паузе (вызывается из tick(), внутренняя);
• theme ('dark'/'light') — активная тема; applyTheme(name) — применить только визуал (data-theme/CSS-переменные/COLORS/meta); setTheme(name) — applyTheme + syncDom + persist (сохраняет тему в сейв);
• PATTERNS — таблица готовых паттернов-штампов ({ id, name, group, cells }); PATTERN_GROUPS — категории дропдауна (Стойкие/Осцилляторы/Корабли/Долгожители/Ружья), buildPatternOptions() строит <optgroup> по ним (внутренние, в контракт не входят); patternCells(p) — разбор ASCII → offsets (ленивый кэш p._cells/_w/_h); findPattern(id) — паттерн по id или null; stamp — активный паттерн (PATTERNS[i] | null), транзиентно (не в сейв, сбрасывается selectTool); stampRot — поворот активного штампа 0..3 (колесо мыши/кнопка «↻»), stampCells() — offsets с учётом поворота, rotate90(cells) — поворот offsets на 90° CW; ставится веткой stamp в paintTool (см. «Инструменты и настройки»); tapPlace — режим «постановка по отпусканию» (транзиентный), pressing — удержание в этом режиме (внутренний);
• campaign/levelIndex/zoneRect/campaignProgress/pendingLevel — режим «Кампания» (см. «Геймплей и FSM»); CAMPAIGN_LEVELS — конфиг уровней (CAMPAIGN_PLAYER=1/CAMPAIGN_ENEMY=2); startLevel(idx) — запуск уровня (враг/зона/бюджет/PLACE_P1), showLevelSelect() — экран выбора (LEVEL_SELECT), requestCampaignLevel(idx) — выбор уровня с подтверждением; campaignZoneFor(idx) — копия zoneRect уровня; inZoneAt(x,y,player) — предикат зоны с учётом кампании; normalizeProgress(p) — нормализация progress;
• TWO_SETUP / showTwoSetup() — экран «Игра на двоих» (#setup): своя справка и настройки поля перед обычной партией; вход — #btnPlay со сплэша MENU, старт — #btnStartTwo (requestNewGame()), возврат — #btnTwoBack (toMenu()); не резюмируется (reload → MENU);
• save, SAVE_KEY, freshSave(), loadSave(), persist() — персистентность (ключ life-save-v1; loadSave() с миграцией/нормализацией, persist() пишет настройки + резюм; форма сейва — см. раздел «Сохранение и резюм»); getScores() — счёт для HUD/финала.