Коротко
Рычаги, плиты, кнопки и двери связывают в данных уровня, а не в коде: у каждого объекта есть id, у источника сигнала — список целей, а дверь сама считает своё состояние из входов по правилу «все» или «хотя бы один». Такие ссылки между объектами есть в Tiled (свойство типа object, с версии 1.4 от 20 июня 2020) и в LDtk (поле EntityRef с entityIid). Перед запуском уровень проверяют на висячие ссылки, двери без входов и циклы, а поиск в ширину по состояниям доказывает, что комнату можно пройти: в нашем примере кнопке нужно держать дверь открытой не меньше 3 ходов.
Содержание
- Почему связи живут в данных, а не в коде
- Схема данных: id, тип и цели
- Источники и приёмники: что умеет каждый объект
- Тянущая модель: дверь сама спрашивает входы
- Проверка уровня при загрузке
- Проверка решаемости поиском в ширину
- Код на JavaScript и проверка в Node.js
- Практический сценарий: комната с двумя дверями
- Когда вам это не подойдёт
Почему связи живут в данных, а не в коде
Связи хранят в данных, потому что тогда один и тот же код обслуживает любое число комнат, а левел-дизайнер меняет головоломку без программиста. Вариант «в лоб» выглядит так: 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.
Отдельное правило двери: занятый проём не закрывается. Без него сценарий «встал на плиту, шагнул в дверь» кончается тем, что плита отпущена, дверь по логике закрыта, а герой стоит внутри стены. В пошаговой игре это визуальная ошибка, в платформере с физикой — застревание.
Проверка уровня при загрузке
Загрузчик должен находить ошибки проводки до того, как игрок войдёт в комнату, и показывать их дизайнеру списком. Пять проверок закрывают почти всё, что ломается при ручном редактировании:
- Повтор id — две двери
d1, и сигнал уходит непонятно куда. - Висячая ссылка — рычаг смотрит на
d9, которого нет: дверь удалили или переименовали. - Цель не принимает сигнал — рычаг подключён к плите или к другому рычагу.
- Приёмник без входов — дверь, которую ничто не открывает; с
mode: "all"она по правилу пустого списка будет открыта всегда, что почти наверняка ошибка. - Цикл — вентиль
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 перед выходом.
Порядок работы:
- Собрать данные — сетку и список объектов, ни строчки кода под комнату.
- Загрузить и прочитать ошибки. Пусто — идём дальше. Висячая ссылка или цикл — правим данные.
- Перебрать
durationот 1 до 6 и записать минимальное рабочее значение. У нас это 3. - Добавить запас. При 3 решение идёт без права на ошибку: любой лишний шаг — и дверь закрыта. Наше правило для пошаговых комнат — минимум плюс 1–2 хода, то есть 4–5. В примере ставим 4: путь тот же, 14 ходов, но один шаг в сторону прощается.
- Сверить длину решения с ролью комнаты. 14 ходов для второй комнаты с новой механикой — нормально. Если бы поиск дал 30, механику стоило бы показать на комнате поменьше.
- Проверить «нечестные» пути. Поиск находит самый короткий путь, в том числе тот, который вы не задумывали. Если он короче задуманного — в проводке дыра.
Проверочный вопрос на плейтесте из 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.
Читайте также:
- Платформер на одном экране на JavaScript: ключ, дверь и состояние уровня
- Sokoban на JavaScript: ящики, цели и отмена хода
- Издатель и подписчик в игре: порядок доставки событий, отписка и утечки памяти
- Поиск пути A* на тайловой сетке: от поиска в ширину до рабочего кода на JavaScript
- Структура 2D-уровня в 4 шага по принципу «кисётэнкэцу»
- Секреты и коллекционные предметы: почему игроки ищут каждый угол