Головоломка с рычагами и дверями: связи объектов в данных уровня

Коротко

Рычаги, плиты, кнопки и двери связывают в данных уровня, а не в коде: у каждого объекта есть id, у источника сигнала — список целей, а дверь сама считает своё состояние из входов по правилу «все» или «хотя бы один». Такие ссылки между объектами есть в Tiled (свойство типа object, с версии 1.4 от 20 июня 2020) и в LDtk (поле EntityRef с entityIid). Перед запуском уровень проверяют на висячие ссылки, двери без входов и циклы, а поиск в ширину по состояниям доказывает, что комнату можно пройти: в нашем примере кнопке нужно держать дверь открытой не меньше 3 ходов.

Содержание

  1. Почему связи живут в данных, а не в коде
  2. Схема данных: id, тип и цели
  3. Источники и приёмники: что умеет каждый объект
  4. Тянущая модель: дверь сама спрашивает входы
  5. Проверка уровня при загрузке
  6. Проверка решаемости поиском в ширину
  7. Код на JavaScript и проверка в Node.js
  8. Практический сценарий: комната с двумя дверями
  9. Когда вам это не подойдёт

Почему связи живут в данных, а не в коде

Связи хранят в данных, потому что тогда один и тот же код обслуживает любое число комнат, а левел-дизайнер меняет головоломку без программиста. Вариант «в лоб» выглядит так: if (lever1.on) door3.open = true. Он работает ровно для одной комнаты. На второй комнате появляется lever2 и door5, на десятой — файл из условий, где переименование одной двери ломает три уровня, а проверить, что все рычаги к чему-то подключены, можно только глазами.

В платформере из статьи про ключ и дверь связь была неявной: любой ключ открывал любую дверь, потому что оба — просто символы K и D в сетке. Это честно для одного экрана с одним ключом. Как только в комнате два рычага и три двери, нужна явная проводка: кто кому посылает сигнал.

Редакторы уровней решают это одинаково. В Tiled с версии 1.4 есть тип свойства object — «ссылка на объект», которая хранится как уникальный id целевого объекта; редактор рисует связь стрелкой цвета цели. В LDtk поле типа EntityRef экспортируется объектом EntityReferenceInfos, где главное — entityIid, строковый id сущности (поля layerIid, levelIid, worldIid уточняют, где она лежит). В обоих случаях в файле уровня лежит не «код двери», а пара «источник → id цели». Игре остаётся прочитать её одним общим загрузчиком.

Схема данных: id, тип и цели

Минимальная схема — это три поля у каждого объекта: id, type и, у источников, targets. Остальное — координаты и параметры типа. Сетку стен держим строками текста, как в прошлых уроках, а объекты — отдельным списком:

#############      S — старт, E — выход
#S....#.....#      L — рычаг l1, B — кнопка b1 (таймер)
#.###.D.###.#      P — плита p1
#L..B.#..PDE#      D — двери d1 (x=6,y=2) и d2 (x=10,y=3)
#############      буквы в сетке — подсказка для глаз, поведение задаёт список объектов

Шаблон объекта, который можно копировать в свой формат уровня:

ПолеКто используетЗначенияПример
idвсеуникальная строка"l1"
typeвсеlever, plate, button, gate, door"button"
x, yвсё, что стоит на клеткеномер клетки4, 3
targetsисточники и вентилисписок id приёмников["g1"]
modeвентиль и дверьall (И) или any (ИЛИ)"all"
invertвентиль и дверьtrue — сигнал наоборотfalse
durationкнопкаходов активности после нажатия4
startOnрычагположение при загрузкеfalse

Связи направлены только в одну сторону: источник знает свои цели, а дверь своих входов не хранит. Обратный индекс «дверь → входы» строит загрузчик. Так у дизайнера одно место правды: чтобы отключить рычаг от двери, достаточно убрать один id из одного списка.

Почему не хранить у двери список входов, а у рычага ничего? Можно и так — это зеркальная схема. Важно выбрать одну сторону и не дублировать: если связь записана и у рычага, и у двери, рано или поздно одну из двух записей забудут обновить.

Источники и приёмники: что умеет каждый объект

Источник даёт «да» или «нет», приёмник собирает входы и решает сам; в примере три источника и два приёмника. Разница между источниками — в том, как долго держится «да», и именно она задаёт характер головоломки.

ОбъектТипКогда «да»Сколько значений в состоянии
Рычагисточникпосле чётного числа заходов — нет, после нечётного — да (если startOn: false)2
Нажимная плитаисточниктолько пока герой на клетке0: выводится из позиции героя
Кнопка с таймеромисточникduration ходов после нажатияduration + 1
Вентиль (gate)приёмник и источникпо правилу all / any, с инверсией0: вычисляется
Дверьприёмникпо правилу all / any, с инверсией; занятый проём не закрывается0: вычисляется

Рычаг — память: игрок может уйти и вернуться. Плита — «держи, пока стоишь»: она требует, чтобы дверь была рядом или чтобы плиту прижал ящик. Кнопка с таймером — это гонка: она проверяет не логику, а маршрут. Вентиль нужен, когда одно условие кормит несколько дверей: вместо того чтобы повторять mode: "all" у каждой из них, ставят один вентиль «рычаг И кнопка» и направляют его выход на все нужные двери.

Последний столбец важен для проверки решаемости ниже: число состояний комнаты растёт как произведение значений всех источников с памятью. Три рычага и одна кнопка на 4 хода — это до 2 × 2 × 2 × 5 = 40 комбинаций на каждую клетку пола (наш расчёт). Плиты и двери состояния не добавляют: они выводятся из остального.

Тянущая модель: дверь сама спрашивает входы

Дверь не ждёт сообщений «открыться» и «закрыться», а при каждой проверке заново вычисляет, открыта ли она, из текущих значений своих входов. Это тянущая модель (pull). Альтернатива — толкающая (push): рычаг рассылает событие, дверь его ловит и меняет флаг. Для одной двери с одним рычагом разницы нет. Проблемы начинаются с правила «все входы»: двери приходится считать, сколько входов уже сказали «да», и этот счётчик рассинхронизируется при первой же пропущенной отписке или двойном событии. Про порядок доставки и утечки подписчиков подробно — в статье об издателе и подписчике.

У тянущей модели нет сохранённого флага «открыта», который может устареть: открытость всегда выводится из состояния. Отсюда три бесплатных следствия:

  • сохранение и откат хранят только рычаги и таймеры, двери восстанавливаются сами;
  • отмена хода — это возврат к прошлому снимку состояния, без обратных событий;
  • поиск решения может копировать состояние сколько угодно раз: в нём нет ссылок на живые объекты.

Цена — повторные вычисления. В комнате на десятки объектов это незаметно, а в цепочке «вентиль → вентиль → дверь» помогает кэш на один вызов: каждое значение считается один раз за проверку. В коде ниже это memo.

Отдельное правило двери: занятый проём не закрывается. Без него сценарий «встал на плиту, шагнул в дверь» кончается тем, что плита отпущена, дверь по логике закрыта, а герой стоит внутри стены. В пошаговой игре это визуальная ошибка, в платформере с физикой — застревание.

Проверка уровня при загрузке

Загрузчик должен находить ошибки проводки до того, как игрок войдёт в комнату, и показывать их дизайнеру списком. Пять проверок закрывают почти всё, что ломается при ручном редактировании:

  1. Повтор id — две двери d1, и сигнал уходит непонятно куда.
  2. Висячая ссылка — рычаг смотрит на d9, которого нет: дверь удалили или переименовали.
  3. Цель не принимает сигнал — рычаг подключён к плите или к другому рычагу.
  4. Приёмник без входов — дверь, которую ничто не открывает; с mode: "all" она по правилу пустого списка будет открыта всегда, что почти наверняка ошибка.
  5. Цикл — вентиль g1 кормит g2, а g2 кормит g1. В тянущей модели вычисление такой пары не заканчивается никогда.

Пятая проверка не косметическая. В нашем прогоне вызов вычисления сигнала на уровне с циклом без предварительной проверки упал с RangeError: Maximum call stack size exceeded — переполнением стека. Ловить это в игре поздно: цикл находят обходом в глубину по ссылкам при загрузке и не пускают такой уровень дальше.

Есть и мягкая проверка — предупреждение «источник ни к чему не подключён». Это не всегда ошибка: декоративный рычаг бывает намеренным. Но дизайнеру полезно видеть его в списке.

Проверка решаемости поиском в ширину

Решаемость комнаты доказывают полным перебором её состояний поиском в ширину: если очередь опустела, а выход не достигнут, пройти нельзя. Состояние — это не только клетка героя, а «клетка + положения рычагов + остатки таймеров». Одна и та же клетка с рычагом в разных положениях — разные состояния, иначе поиск отбросит путь «вернуться и переключить рычаг» как уже пройденный.

Поиск в ширину выбран намеренно: он находит самый короткий путь в ходах, и это число полезно дизайнеру. Если в комнате-обучалке кратчайшее решение — 40 ходов, обучалки не получилось. Если в «сложной» комнате решение находится за 6 — сложность в ней только кажущаяся. A* здесь не нужен: комната маленькая, а хорошую эвристику для состояния с рычагами придумать трудно; сам A* разобран в статье о поиске пути на тайловой сетке.

Порядок действий внутри хода нужно зафиксировать один раз и не менять, иначе ответы поиска и поведение игры разойдутся:

1. Можно ли войти в клетку — по состоянию ДО хода (дверь открыта сейчас?).
2. Герой переходит.
3. Все запущенные таймеры уменьшаются на 1.
4. Срабатывает то, на что наступили: рычаг переключается, кнопка заводит таймер на duration.
5. Двери и вентили не хранятся — при следующей проверке считаются заново.

Из этого порядка следует простое правило для кнопки: если от кнопки до двери k ходов, то duration должен быть не меньше k. В примере k = 3: два шага до проёма и шаг в сам проём.

Код на JavaScript и проверка в Node.js

Модуль ниже ничего не рисует: он загружает уровень, проверяет проводку, вычисляет сигналы, делает ход и ищет решение. Запуск — Node.js 24.22.1, вывод прогона приведён в конце раздела и совпадает с числами в тексте.

/** wiring.mjs — связи рычагов, кнопок и дверей в данных уровня */
const SOURCES = new Set(["lever", "plate", "button"]);
const RECEIVERS = new Set(["door", "gate"]);

export function loadLevel(data) {
  const errors = [], warnings = [];
  const byId = new Map();
  for (const o of data.objects) {
    if (byId.has(o.id)) errors.push("повтор id: " + o.id);
    byId.set(o.id, o);
  }
  const inputs = new Map(); // id приёмника -> список id входов
  for (const o of data.objects) {
    for (const t of o.targets ?? []) {
      const target = byId.get(t);
      if (!target) { errors.push(o.id + " → " + t + ": цели нет"); continue; }
      if (!RECEIVERS.has(target.type)) {
        errors.push(o.id + " → " + t + ": " + target.type + " не принимает сигнал"); continue;
      }
      if (!inputs.has(t)) inputs.set(t, []);
      inputs.get(t).push(o.id);
    }
    if (SOURCES.has(o.type) && !(o.targets ?? []).length)
      warnings.push(o.id + ": ни к чему не подключён");
  }
  for (const o of data.objects)
    if (RECEIVERS.has(o.type) && !inputs.has(o.id))
      errors.push(o.id + ": нет ни одного входа");
  // цикл: обход в глубину с цветами
  const color = new Map();
  const visit = (id, path) => {
    if (color.get(id) === 1) { errors.push("цикл: " + [...path, id].join(" → ")); return; }
    if (color.get(id) === 2) return;
    color.set(id, 1);
    for (const t of byId.get(id)?.targets ?? []) if (byId.has(t)) visit(t, [...path, id]);
    color.set(id, 2);
  };
  for (const o of data.objects) visit(o.id, []);
  return { errors, warnings, byId, inputs, grid: data.map, objects: data.objects };
}

export function startState(level) {
  const s = { x: 0, y: 0, on: {}, timer: {} };
  level.grid.forEach((row, y) => {
    const x = row.indexOf("S");
    if (x >= 0) { s.x = x; s.y = y; }
  });
  for (const o of level.objects) {
    if (o.type === "lever") s.on[o.id] = !!o.startOn;
    if (o.type === "button") s.timer[o.id] = 0;
  }
  return s;
}

// Тянущая модель: значение приёмника каждый раз считается от входов.
export function signal(level, s, id, memo = new Map()) {
  if (memo.has(id)) return memo.get(id);
  const o = level.byId.get(id);
  let v;
  if (o.type === "lever") v = s.on[id];
  else if (o.type === "plate") v = s.x === o.x && s.y === o.y;
  else if (o.type === "button") v = s.timer[id] > 0;
  else {
    const ins = level.inputs.get(id).map((i) => signal(level, s, i, memo));
    v = o.mode === "any" ? ins.some(Boolean) : ins.every(Boolean);
    if (o.invert) v = !v;
    // дверь не захлопывается на герое
    if (o.type === "door" && s.x === o.x && s.y === o.y) v = true;
  }
  memo.set(id, v);
  return v;
}

export function objectAt(level, x, y) {
  return level.objects.find((o) => o.x === x && o.y === y);
}

export function passable(level, s, x, y) {
  if (level.grid[y][x] === "#") return false;
  const o = objectAt(level, x, y);
  if (o && o.type === "door") return signal(level, s, o.id);
  return true;
}

export function step(level, s, dx, dy) {
  const nx = s.x + dx, ny = s.y + dy;
  if (!passable(level, s, nx, ny)) return null; // упёрся
  const n = { x: nx, y: ny, on: { ...s.on }, timer: { ...s.timer } };
  for (const id in n.timer) if (n.timer[id] > 0) n.timer[id] -= 1;
  const o = objectAt(level, nx, ny);
  if (o?.type === "lever") n.on[o.id] = !n.on[o.id];
  if (o?.type === "button") n.timer[o.id] = o.duration;
  return n;
}

const key = (s) => [s.x, s.y, JSON.stringify(s.on), JSON.stringify(s.timer)].join("|");
const DIRS = [[1, 0, "R"], [-1, 0, "L"], [0, 1, "D"], [0, -1, "U"]];

// Поиск в ширину по состояниям: позиция + рычаги + таймеры.
export function solve(level, maxStates = 200000) {
  const start = startState(level);
  const seen = new Set([key(start)]);
  const queue = [[start, ""]];
  for (let i = 0; i < queue.length; i++) {
    const [s, path] = queue[i];
    if (level.grid[s.y][s.x] === "E") return { moves: path.length, path, states: seen.size };
    for (const [dx, dy, c] of DIRS) {
      const n = step(level, s, dx, dy);
      if (!n) continue;
      const k = key(n);
      if (seen.has(k)) continue;
      if (seen.size >= maxStates) return { moves: -1, path: "", states: seen.size, capped: true };
      seen.add(k);
      queue.push([n, path + c]);
    }
  }
  return { moves: -1, path: "", states: seen.size };
}

Проверочный файл строит комнату из схемы выше, перебирает длину кнопки, прогоняет найденный путь по шагам и загружает заведомо сломанный уровень:

import { loadLevel, startState, step, signal, solve } from "./wiring.mjs";

const room = (duration) => ({
  map: [
    "#############",
    "#S....#.....#",
    "#.###.D.###.#",
    "#L..B.#..PDE#",
    "#############",
  ],
  objects: [
    { id: "l1", type: "lever", x: 1, y: 3, targets: ["g1"] },
    { id: "b1", type: "button", x: 4, y: 3, duration, targets: ["g1"] },
    { id: "g1", type: "gate", mode: "all", targets: ["d1"] },
    { id: "d1", type: "door", x: 6, y: 2, mode: "any" },
    { id: "p1", type: "plate", x: 9, y: 3, targets: ["d2"] },
    { id: "d2", type: "door", x: 10, y: 3, mode: "any" },
  ],
});

// 1. Решаемость при разной длине кнопки
for (const d of [1, 2, 3, 4, 6]) {
  const r = solve(loadLevel(room(d)));
  console.log("duration=" + d + ":", r.moves < 0 ? "не решается" : r.moves + " ходов " + r.path, "| состояний", r.states);
}

// 2. Пошаговый прогон найденного пути при duration = 4
const lvl = loadLevel(room(4));
const D = { R: [1, 0], L: [-1, 0], D: [0, 1], U: [0, -1] };
let s = startState(lvl);
solve(lvl).path.split("").forEach((c, i) => {
  s = step(lvl, s, ...D[c]);
  console.log(i + 1, c, "(" + s.x + "," + s.y + ")", "l1=" + +s.on.l1, "b1=" + s.timer.b1,
    "d1=" + +signal(lvl, s, "d1"), "d2=" + +signal(lvl, s, "d2"),
    i === 12 ? "| плита p1=" + signal(lvl, s, "p1") : "");
});

// 3. Сломанный уровень: что ловит проверка при загрузке
const b = loadLevel({
  map: ["#####", "#S.E#", "#####"],
  objects: [
    { id: "l1", type: "lever", x: 1, y: 1, targets: ["d9"] },
    { id: "l2", type: "lever", x: 2, y: 1, targets: ["p1"] },
    { id: "p1", type: "plate", x: 2, y: 1 },
    { id: "g1", type: "gate", mode: "all", targets: ["g2"] },
    { id: "g2", type: "gate", mode: "any", targets: ["g1"] },
    { id: "d1", type: "door", x: 3, y: 1, mode: "all" },
  ],
});
console.log("ошибки:", b.errors);
console.log("предупреждения:", b.warnings);
try { signal(b, startState(b), "g1"); }
catch (e) { console.log("signal() без проверки:", e.constructor.name, "—", e.message); }

Вывод прогона (Node.js 24.22.1, node test.mjs):

duration=1: не решается | состояний 24
duration=2: не решается | состояний 28
duration=3: 14 ходов DDRRRRURRDRRRR | состояний 44
duration=4: 14 ходов DDRRRRURRDRRRR | состояний 52
duration=6: 14 ходов DDRRRRURRDRRRR | состояний 76
1 D (1,2) l1=0 b1=0 d1=0 d2=0 
2 D (1,3) l1=1 b1=0 d1=0 d2=0 
3 R (2,3) l1=1 b1=0 d1=0 d2=0 
4 R (3,3) l1=1 b1=0 d1=0 d2=0 
5 R (4,3) l1=1 b1=4 d1=1 d2=0 
6 R (5,3) l1=1 b1=3 d1=1 d2=0 
7 U (5,2) l1=1 b1=2 d1=1 d2=0 
8 R (6,2) l1=1 b1=1 d1=1 d2=0 
9 R (7,2) l1=1 b1=0 d1=0 d2=0 
10 D (7,3) l1=1 b1=0 d1=0 d2=0 
11 R (8,3) l1=1 b1=0 d1=0 d2=0 
12 R (9,3) l1=1 b1=0 d1=0 d2=1 
13 R (10,3) l1=1 b1=0 d1=0 d2=1 | плита p1=false
14 R (11,3) l1=1 b1=0 d1=0 d2=0 
ошибки: [
  'l1 → d9: цели нет',
  'l2 → p1: plate не принимает сигнал',
  'd1: нет ни одного входа',
  'цикл: g1 → g2 → g1'
]
предупреждения: [ 'p1: ни к чему не подключён' ]
signal() без проверки: RangeError — Maximum call stack size exceeded

Что видно из прогона:

  • Кнопка на 1–2 хода делает комнату нерешаемой, на 3 — решается впритык, на 4 и 6 путь тот же: 14 ходов DDRRRRURRDRRRR. Больше duration — больше состояний (44 → 52 → 76), но решение не короче.
  • На 8-м ходу герой входит в проём d1 с остатком таймера 1, на 9-м таймер обнулился и дверь закрылась уже за спиной.
  • На 13-м ходу плита p1 отпущена (false), а d2 открыта только потому, что герой стоит в проёме. Уберите эту строку из signal() — и дверь «закроется» на герое.
  • Сломанный уровень выдал все четыре ошибки и одно предупреждение, а вычисление сигнала на нём без проверки упало с переполнением стека.

Чтобы подключить модуль к браузеру, хватит обработчика клавиш, который вызывает step() и, если вернулся не null, перерисовывает сетку; движение по клеткам подробно разобрано в статье про движение по сетке.

Практический сценарий: комната с двумя дверями

Задача: собрать комнату, где игрок сначала понимает связь «рычаг + кнопка → дверь», а потом — «плита держит дверь, пока стоишь», и проверить её до плейтеста. Входные условия — схема из раздела про данные: рычаг l1 и кнопка b1 идут в вентиль g1 с правилом all, вентиль — в дверь d1, плита p1 — в дверь d2 перед выходом.

Порядок работы:

  1. Собрать данные — сетку и список объектов, ни строчки кода под комнату.
  2. Загрузить и прочитать ошибки. Пусто — идём дальше. Висячая ссылка или цикл — правим данные.
  3. Перебрать duration от 1 до 6 и записать минимальное рабочее значение. У нас это 3.
  4. Добавить запас. При 3 решение идёт без права на ошибку: любой лишний шаг — и дверь закрыта. Наше правило для пошаговых комнат — минимум плюс 1–2 хода, то есть 4–5. В примере ставим 4: путь тот же, 14 ходов, но один шаг в сторону прощается.
  5. Сверить длину решения с ролью комнаты. 14 ходов для второй комнаты с новой механикой — нормально. Если бы поиск дал 30, механику стоило бы показать на комнате поменьше.
  6. Проверить «нечестные» пути. Поиск находит самый короткий путь, в том числе тот, который вы не задумывали. Если он короче задуманного — в проводке дыра.

Проверочный вопрос на плейтесте из 5–10 человек: сколько попыток уходит на первую дверь и понимают ли игроки, что кнопка работает только вместе с рычагом. Если почти все сначала жмут кнопку и бегут к закрытой двери — это нормально, так связь и обнаруживается. Если после трёх попыток не понимают — нужна видимая подсказка: провод на полу, лампочка над дверью, которая загорается от рычага. Как строить комнату «показать — усложнить — повернуть — применить», разобрано в статье про кисётэнкэцу.

Когда вам это не подойдёт

Проводка в данных и поиск в ширину хороши для маленьких дискретных головоломок, но не для всех случаев:

  • Комната с ящиками и толкающимися объектами. Каждый ящик добавляет в состояние свою позицию, и число состояний растёт как произведение клеток; поиск в ширину на 4–5 ящиках становится медленным. Ящики и отмену хода разбирали в статье про Sokoban — там проверку решаемости делают другими средствами или вручную.
  • Платформер с непрерывной физикой. «Ход» там — кадр, а позиция — дробные пиксели. Поиск по состояниям в лоб не сработает; проверяют записанными прохождениями и плейтестом.
  • Сюжетная логика с десятками флагов. Если дверь открывается «после разговора с кузнецом, если квест не провален», это уже скрипт или система условий, а не провод между двумя объектами.
  • Одна комната на всю игру. Если головоломка ровно одна, if (lever.on) в коде — честное решение, и схема с id будет лишней.
  • Связи между разными уровнями. Рычаг в одном уровне открывает дверь в другом — это уже сохранение прогресса мира. Ссылки LDtk умеют указывать на сущность другого уровня, но загрузчик и сохранения для этого нужны другие.

Мы разрабатываем J2DRU — браузерный 2D игровой движок, где логика собирается из событий, условий и действий, а проект можно углублять на TypeScript. Движок в разработке и публично пока не открыт, заявку можно оставить на странице раннего доступа (подача заявки не гарантирует приглашение).

Источники (проверено: ноябрь 2026, 11.11.2026): Tiled Documentation — Custom Properties (тип свойства object — ссылка на объект, «Since Tiled 1.4»); Tiled — Tiled 1.4 released (20 июня 2020: «Connections Between Objects», ссылка хранится как уникальный id объекта, связь рисуется стрелкой цвета цели); LDtk — JSON documentation (поле EntityRef, объект «Reference to an Entity instance» / EntityReferenceInfos с entityIid, layerIid, levelIid, worldIid, добавлен в 1.0.0; флаг allowOutOfLevelRef — ссылка на сущность вне текущего уровня). Схема полей, порядок хода, правило «минимум плюс 1–2 хода», комната и все числа прогона — наш пример и наш расчёт в Node.js 24.22.1.

Читайте также:

Частые вопросы

Как связать рычаг с дверью, не прописывая это в коде?

Дайте каждому объекту уровня уникальный id, а источнику сигнала — список целей, например targets: ["d1"]. Код один на все уровни: при загрузке он строит обратный индекс «дверь → её входы», а дверь каждый кадр или ход сама считает, открыта ли она. Новый уровень — это новый JSON, а не новый if в коде.

Чем рычаг отличается от нажимной плиты и кнопки с таймером?

Рычаг переключается при каждом входе героя на клетку и помнит положение. Плита активна, только пока на ней стоят. Кнопка с таймером после нажатия активна N ходов или кадров и гаснет сама. От этого зависит, сколько состояний придётся перебрать проверке решаемости: у рычага два значения, у кнопки — N + 1.

Почему дверь не должна закрываться на герое?

Если плита отпущена в тот момент, когда герой стоит в проёме, дверь по правилам должна закрыться, и герой окажется внутри стены. В нашем прогоне на 13-м ходу плита p1 уже не нажата, а дверь d2 открыта только благодаря правилу «занятый проём не закрывается».

Как проверить, что головоломку вообще можно решить?

Перебрать состояния поиском в ширину: позиция героя плюс положения всех рычагов и остатки всех таймеров. Если очередь опустела, а выход не достигнут, комната не решается. Для маленькой комнаты это десятки состояний: в нашем примере от 24 до 76.