Коротко
Повтор прохождения — это лента, а не запись экрана: заголовок с версией правил, зерном генератора и исходным уровнем плюс список действий вида «шаг 113, jump, нажато», которые симуляция с фиксированным шагом проигрывает заново и обязана прийти к тому же снимку мира до последнего бита. Повтор ломается всем, что влияет на шаг, но не попало в ленту: временем кадра, Math.random, стенными часами, раскладкой клавиш, порядком загрузки объектов, живой клавиатурой. В нашем прогоне каждая такая утечка видна в выводе — по контрольным суммам через каждые 60 шагов или по итогу — и исправлена, а исправленный повтор совпал с игрой при отрисовке на 30, 60 и 144 кадрах в секунду.
Содержание
- Повтор — не видео и не сохранение
- Что записывать: заголовок и лента действий
- Фиксированный шаг: лента считает шаги, а не миллисекунды
- Случайность: зерно в заголовке, Math.random вне симуляции
- Действия, а не клавиши
- Порядок обхода и удаление объектов
- Часы внутри шага и возврат на вкладку
- Проверка: контрольные суммы и сверка снимков
- Код на JavaScript и проверка в Node.js
- Что показал прогон: ловушки и исправления
- Практический сценарий: лента к отчёту об ошибке
- Когда вам это не подойдёт
Повтор — не видео и не сохранение
Повтор прохождения хранит не картинку и не состояние, а причину: ввод игрока по шагам симуляции и всё, от чего зависит старт. Видео отвечает на вопрос «что было на экране», сохранение — «каким был мир в одной точке», а повтор — «что делал игрок на каждом шаге», и мир из этого игра пересчитывает сама.
| Видео | Сохранение | Повтор (лента ввода) | |
|---|---|---|---|
| Что хранит | кадры экрана | состояние мира в одной точке | заголовок и действия по номеру шага |
| Размер в нашем примере | — | один снимок мира | 454 байта на 376 шагов |
| Можно проиграть быстрее | только перемоткой картинки | нет, это одна точка | да, без отрисовки |
| Можно проверить кодом | нет | частично | да, сверкой снимков |
| Что нужно для просмотра | любой плеер | та же игра | та же игра той же версии правил |
Отсюда главное требование: симуляция должна быть детерминированной. Гленн Фидлер в статье «Deterministic Lockstep» (29.11.2014) формулирует его жёстко: при одинаковом начальном состоянии и одинаковом вводе результат должен совпадать не «примерно», а до бита — настолько, что контрольная сумма всего состояния после каждого шага одинакова. Его статья о сетевой игре, наша — нет, но определение то же: повтор, который совпал «почти», через минуту расходится полностью, потому что любая разница на одном шаге становится входом следующего.
Отмена хода, как в Sokoban на JavaScript, идёт назад по истории, а повтор — всегда вперёд от старта. Хранить ленту можно так же, как сохранение, — строкой JSON, см. статью о сохранениях в браузерной игре.
Что записывать: заголовок и лента действий
Записывать нужно заголовок один раз и короткую ленту изменений ввода, а позиции объектов — только как редкие контрольные суммы для проверки. В нашей схеме лента — объект JSON такого вида (наш пример, не стандарт):
{
"logic": "demo-65.1",
"seed": 20261118,
"level": { "hero": { "x": 0, "y": 0 }, "hp": 3, "items": ["…"] },
"steps": 376,
"input": [[11, "right", 1], [113, "jump", 1], [119, "jump", 0], [154, "right", 0]],
"checks": { "60": "…", "120": "…", "180": "…" }
}
| Поле | Что хранит | Что ломается без него |
|---|---|---|
logic | версия правил симуляции | после правки баланса старая лента тихо проигрывает другую игру |
seed | зерно генератора случайных чисел | кристаллы появляются в других местах |
level | исходное состояние: уровень, герой, здоровье | повтор стартует не с той точки |
steps | сколько шагов длилась запись | повтор обрывается раньше или идёт дальше |
input | [шаг, действие, 1 или 0] — только изменения | — это и есть повтор |
checks | контрольная сумма снимка мира каждые 60 шагов | расхождение видно только по итогу или не видно вовсе |
Лента хранит изменения, а не состояние кнопок на каждом шаге: «на шаге 11 нажато right», «на шаге 154 отпущено». Фидлер в той же статье снимает структуру ввода в начале каждого шага и помечает её номером шага; для повтора это равноценно, а изменения короче — за 376 шагов нашей сессии их 8.
Записывать позицию героя и всех объектов на каждом шаге как основной способ — плохая замена. В нашем прогоне снимок мира на каждом шаге занял 41 238 байт против 454 байт ленты, и такой «повтор» не проверяет логику: он показывает, где был герой, но не доказывает, что игра снова приведёт его туда. Снимок нужен в другой роли — как контрольная точка, которую повтор пересчитывает и сравнивает.
Фиксированный шаг: лента считает шаги, а не миллисекунды
Для повтора симуляция должна идти фиксированными шагами, а лента — ссылаться на номер шага, а не на время на часах. Как устроены фиксированный шаг и накопитель кадрового времени, разобрано в статье об игровом цикле и столкновениях AABB; здесь важны три следствия для повтора.
Первое: шаг должен быть строго одинаковым. Фидлер в «Fix Your Timestep!» (10.06.2004) отдельно оговаривает, что точная повторяемость прогона при одинаковом вводе требует полностью фиксированного dt: полуфиксированный шаг с коротким остатком «почти такой же», но не точно такой же из-за ограниченной точности чисел с плавающей точкой. В нашем прогоне тот же ввод с dt, равным времени кадра, дал прыжок высотой 70,0 px на 60 кадрах в секунду и 66,7 px на 30 — и на 30 кадрах герой не достал звезду на высоте 80 px.
Второе: кадр и шаг — разные вещи. Нажатие приходит между кадрами, а применяется на первом шаге следующего кадра; в ленту пишется номер именно этого шага. Если вместо него записать время нажатия в миллисекундах и при повторе делить его на длину шага, неровные кадры сдвигают нажатия: в нашем прогоне right с шага 11 уехал на 12, отпускание — с 154 на 156.
Третье: повтор не зависит от частоты отрисовки. Та же лента в нашем прогоне дала одинаковую контрольную сумму при отрисовке на 30, 60 и 144 кадрах в секунду, а без отрисовки проигрывается так быстро, как позволяет процессор. Для плавной картинки между шагами рисуют промежуточное положение — интерполяцию из той же статьи об игровом цикле, — но саму симуляцию временем кадра не кормят. Если в игре есть ползунок скорости, как в статье о доступности 2D-игры, и он работает через накопитель, лента его не замечает: замедление меняет число шагов в секунду, а не сами шаги.
Случайность: зерно в заголовке, Math.random вне симуляции
Каждое случайное решение, которое влияет на мир, должно брать число из генератора с зерном, а зерно — лежать в заголовке ленты. Math.random для этого не годится: по MDN начальное зерно выбирает реализация, и пользователь не может ни задать, ни сбросить его. В нашем прогоне сессия с Math.random и повтор той же ленты разошлись уже на контрольных точках, хотя ввод совпадал до шага.
Сам генератор, мешок без повторов и взвешенный выбор разобраны в статье о случайности без несправедливости; в коде ниже мы берём оттуда функцию mulberry32 без изменений. Для повтора к ней добавляются три правила:
- Зерно — в ленту. Повтор, который взял зерно по умолчанию (в нашем прогоне 1 вместо 20261118), разошёлся на первой же контрольной точке, шаге 60: кристаллы появились в других местах, и итог — 6 очков вместо 5.
- Один генератор на симуляцию. Если эффекты частиц или звук берут числа из того же генератора, что и мир, то включённые в настройках частицы меняют, где появится следующий кристалл. Картинке — свой генератор или
Math.random, миру — свой. - Порядок вызовов — часть детерминизма. Генератор выдаёт последовательность, поэтому лишний вызов
rand()в одной ветке кода сдвигает все следующие числа. Фидлер приводит пример из физического движка ODE: решатель использовал генератор случайных чисел, чтобы перемешивать порядок обработки ограничений, и это ломало детерминизм; исправление — задавать внутреннее зерно номером кадра перед каждым шагом.
Действия, а не клавиши
В ленту пишут действия игры — left, right, jump, — а не коды клавиш и не номера кнопок геймпада. Как отделить действия от клавиш, разобрано в статье о вводе: KeyboardEvent.code, Gamepad API и мёртвой зоне; здесь — что это даёт повтору.
Карта клавиш — настройка конкретного игрока, а не часть игры. В нашем прогоне игрок переназначил прыжок на KeyW. Лента из сырых кодов у него проигрывается правильно, а у зрителя с раскладкой по умолчанию, где прыжок — Space, все четыре события KeyW ничего не значат: герой ни разу не прыгнул, не взял звезду, набрал 2 очка вместо 5, дверь не открылась, и контрольная сумма разошлась на шаге 120. Лента из действий от раскладки не зависит. То же правило мы уже встречали в статье о ветвящихся диалогах: выборы игрока пишут по id, а не по номеру кнопки.
Второе следствие — повтор должен читать только ленту. Если код шага берёт ввод из глобального объекта нажатых клавиш, во время просмотра в симуляцию попадает живая клавиатура. В нашем прогоне стрелка вправо, зажатая первые 30 шагов просмотра, увела героя на 22 px правее и мимо звезды: 2 очка вместо 5 и закрытая дверь. Исправление — один источник ввода на шаг: либо клавиатура через карту действий, либо лента, но не их смесь.
Порядок обхода и удаление объектов
Порядок, в котором шаг обходит объекты, должен определяться данными мира — например, сортировкой по стабильному id, — а не тем, в каком порядке объекты загрузились или были созданы снаружи шага. Иначе любой эффект, который зависит от порядка, даёт разный итог в игре и в повторе.
В нашем уровне сердце (+1 к здоровью, максимум 3) и шипы (−1) лежат в одной точке, и герой с полным здоровьем задевает их на одном шаге. Если сначала сердце, оно упирается в максимум, а шипы снимают единицу — здоровье 2. Если сначала шипы — 2, а потом сердце возвращает 3. Ограничение сверху делает эти два действия некоммутативными, и порядок в массиве решает исход. В нашем прогоне массив собирался в порядке завершения асинхронной загрузки: в игре сердце загрузилось первым, при просмотре — шипы. Итог: в игре 2, в повторе 3, расхождение на шаге 120.
Удаление посреди цикла — соседняя ошибка, и прогон показал важную деталь: само по себе оно повтор не ломает. splice внутри forEach пропускает следующий объект, но пропускает одинаково при каждом прогоне, поэтому при порядке по id игра и повтор совпали — оба с одной и той же ошибкой. Повтор ловит недетерминированность, а не любую ошибку логики. Расходится он, когда пропуск зависит от порядка, который пришёл извне. Почему удалять лучше после обхода и как устроено отложенное удаление, разобрано в статье о спавне и удалении объектов; для повтора добавим одно: новые объекты получают id из счётчика внутри мира (nextId), а не из глобального счётчика, который успел накрутить экран меню.
Часы внутри шага и возврат на вкладку
Внутри шага симуляции не должно быть Date.now(), performance.now() и любых других часов: время мира — это номер шага, умноженный на длину шага. Часы отличаются в игре и в повторе по определению, потому что повтор идёт быстрее или медленнее реального времени.
Ловушка выглядит безобидно: «кристалл живёт 2 секунды» как Date.now() - born < 2000. В нашем прогоне игрок на 3 секунды ушёл в другую вкладку. Браузер в это время кадров не присылал (в фоновой вкладке большинство браузеров приостанавливает requestAnimationFrame — об этом и об огромном первом кадре после возврата есть в статье о поиске просадок FPS), а часы шли. После возврата кристаллы, родившиеся до ухода, оказались «старше 2 секунд» и исчезли. Повтор на максимальной скорости прошёл те же шаги за доли секунды по часам, кристаллы дожили до героя — 8 очков вместо 5, расхождение на шаге 240. Со временем жизни «120 шагов» игра и повтор совпали.
Тот же возврат на вкладку ломает и ленту по времени: часы прошли 3 секунды, а накопитель с ограничением кадра 250 мс, как в финальном коде Фидлера, просимулировал только четверть секунды. Нажатие left, записанное как 6400 мс, в повторе пересчиталось в шаг 384, хотя в игре применилось на шаге 218, — сдвиг на 166 шагов, а сессия длилась всего 376.
Проверка: контрольные суммы и сверка снимков
Проверка повтора — это три действия: сыграть и записать ленту, проиграть её той же симуляцией, сравнить снимки мира в контрольных точках. Снимок — объект с тем, что составляет итог игры: позиция и скорость героя, здоровье, очки, флаг двери, координаты живых кристаллов и id оставшихся предметов. Чтобы не хранить снимок целиком, лента хранит его контрольную сумму — в нашем коде 32-битный FNV-1a от строки JSON.stringify.
Два правила делают сверку надёжной:
- Снимок не зависит от порядка хранения. Список
idпредметов в снимке отсортирован, иначе сверка «найдёт» расхождение там, где мир одинаков, а массив просто собран в другом порядке. - Числа сравниваются без округления. В снимок координаты попадают как есть, без
toFixed, поэтому сумма меняется даже от разницы в далёком знаке после запятой. Сравнение округлённыхx.toFixed(1)пропустило бы именно те расхождения, которые через минуту станут видны.
Контрольные точки нужны и потому, что итог может совпасть случайно. В нашем прогоне правка силы прыжка с 420 до 440 без смены версии правил разошлась на шаге 120, а финальный снимок — позиция, здоровье, очки, дверь — совпал полностью: оба героя к концу стояли на земле в одной точке. Сверка только итога сказала бы, что всё в порядке.
Проверка версии правил стоит до всего остального: если logic в ленте не совпадает с текущей, повтор не запускается вовсе. Лучше честное «лента записана для demo-65.1, а правила demo-65.2», чем тихо проигранная другая игра. Если в игре есть динамическая подстройка сложности, как в статье о кривой сложности, она тоже должна считаться внутри шага из состояния мира: подстройка по данным вне ленты разведёт повтор так же, как часы.
Код на JavaScript и проверка в Node.js
Модуль ниже ничего не рисует: в нём шаг мира, накопитель кадров, снимок и контрольная сумма, запись живой игры и повтор с проверкой. Переключатели cfg включают наивные варианты, чтобы прогон показал каждую ловушку на одном и том же коде; по умолчанию всё исправлено. Запуск — Node.js 24.22.1, модуль ES (.mjs); уровень, константы, шаг, зерно и все числа — наш пример.
/** replay.mjs — детерминированная симуляция, лента ввода, запись и проверка повтора */
export const LOGIC = "demo-65.1"; // версия правил: меняется при любой правке, влияющей на итог
export const STEP_MS = 1000 / 60; // фиксированный шаг симуляции
const RUN = 120, GRAVITY = 1200, TOUCH = 12;
export function mulberry32(seed) { // генератор с зерном (подробно — в статье о случайности)
return () => {
seed |= 0; seed = (seed + 0x6D2B79F5) | 0;
let t = Math.imul(seed ^ (seed >>> 15), 1 | seed);
t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
};
}
// cfg — переключатели наивных вариантов; по умолчанию всё исправлено.
// rand: своя функция вместо генератора с зерном; clock: часы вместо номера шага;
// order: "load" — порядок загрузки вместо сортировки по id; removal: "splice" — удаление в цикле.
export function createWorld(level, seed, cfg = {}) {
const items = level.items.map((it) => ({ ...it }));
if (cfg.order !== "load") items.sort((a, b) => a.id - b.id);
return {
step: 0, hero: { x: level.hero.x, y: level.hero.y, vy: 0, onGround: true },
hp: level.hp, score: 0, door: false, items, gems: [], nextId: 100,
jump: cfg.jump ?? 420, rand: cfg.rand ?? mulberry32(seed), cfg,
};
}
const touches = (h, o) => Math.abs(h.x - o.x) < TOUCH && Math.abs(h.y - o.y) < TOUCH;
function pickUp(w, it) {
if (it.kind === "heart") w.hp = Math.min(w.hp + 1, 3);
if (it.kind === "spike") w.hp -= 1;
if (it.kind === "star") w.score += 3;
}
// Один шаг мира. input — действия, а не клавиши; dt — секунды.
export function tick(w, input, dt) {
const h = w.hero;
const vx = ((input.right ? 1 : 0) - (input.left ? 1 : 0)) * RUN;
if (input.jump && h.onGround) { h.vy = w.jump; h.onGround = false; }
h.vy -= GRAVITY * dt;
h.x += vx * dt;
h.y += h.vy * dt;
if (h.y <= 0) { h.y = 0; h.vy = 0; h.onGround = true; }
w.topY = Math.max(w.topY ?? 0, h.y);
// Каждые 60 шагов — кристалл в случайном месте; живёт 120 шагов (или 2000 мс по часам).
const now = w.cfg.clock ? w.cfg.clock.t : w.step;
const life = w.cfg.clock ? 2000 : 120;
if (w.step % 60 === 0) w.gems.push({ id: w.nextId++, x: 20 + w.rand() * 280, y: 0, born: now });
w.gems = w.gems.filter((g) => now - g.born < life);
const left = w.gems.filter((g) => !touches(h, g));
w.score += w.gems.length - left.length;
w.gems = left;
// Предметы уровня: обход по порядку массива.
if (w.cfg.removal === "splice") {
w.items.forEach((it, i) => { if (touches(h, it)) { pickUp(w, it); w.items.splice(i, 1); } });
} else {
for (const it of w.items) if (touches(h, it)) { pickUp(w, it); it.dead = true; }
w.items = w.items.filter((it) => !it.dead); // отложенное удаление после обхода
}
if (!w.door && w.score >= 3 && h.x >= 280) w.door = true;
w.step++;
}
// Накопитель кадрового времени: кадры приходят как угодно, шаги — ровно по STEP_MS.
export function drive(frames, onFrame, onStep) {
let t = 0, acc = 0;
for (const f of frames) {
t += f;
acc += Math.min(f, 250); // после долгого простоя не догоняем
onFrame(t);
while (acc >= STEP_MS) { onStep(); acc -= STEP_MS; }
}
}
export function snapshot(w) {
const h = w.hero;
return { step: w.step, x: h.x, y: h.y, vy: h.vy, hp: w.hp, score: w.score, door: w.door,
gems: w.gems.map((g) => g.x), items: w.items.map((it) => it.id).sort((a, b) => a - b) };
}
export function checksum(w) { // FNV-1a по JSON снимка
let x = 0x811c9dc5;
for (const c of JSON.stringify(snapshot(w))) x = Math.imul(x ^ c.charCodeAt(0), 16777619);
return (x >>> 0).toString(16).padStart(8, "0");
}
export const short = (w) => "x=" + w.hero.x.toFixed(1) + " y=" + w.hero.y.toFixed(1) +
" hp=" + w.hp + " очки=" + w.score + " дверь=" + (w.door ? "да" : "нет");
// Живая игра: события клавиатуры с временем в мс → действия по карте клавиш → лента по номеру шага.
export function record(level, seed, events, frames, keymap, cfg = {}) {
const w = createWorld(level, seed, cfg);
const tape = { logic: LOGIC, seed, level, steps: 0, input: [], checks: {} };
const raw = [], stamps = [], held = {};
let e = 0;
drive(frames, (t) => {
if (cfg.clock) cfg.clock.t = t;
for (; e < events.length && events[e].t <= t; e++) {
const { code, down } = events[e], action = keymap[code];
raw.push([w.step, code, down]); // наивно: сырой код клавиши
if (!action || held[action] === down) continue;
held[action] = down;
tape.input.push([w.step, action, down]); // правильно: действие по номеру шага
stamps.push([events[e].t, action, down]); // наивно: время стенных часов
}
}, () => {
tick(w, held, STEP_MS / 1000);
if (w.step % 60 === 0) tape.checks[w.step] = checksum(w);
});
tape.steps = w.step;
return { world: w, tape, raw, stamps };
}
// Повтор: только лента, никаких часов и клавиатуры. Сверка с контрольными суммами по ходу.
export function replay(tape, cfg = {}, opts = {}) {
if (opts.checkVersion !== false && tape.logic !== (opts.logic ?? LOGIC))
return { error: "лента записана для " + tape.logic + ", а правила " + (opts.logic ?? LOGIC) };
const w = createWorld(tape.level, tape.seed, cfg);
const held = {};
let i = 0, firstBad = null;
const step = () => {
if (w.step >= tape.steps) return;
for (; i < tape.input.length && tape.input[i][0] === w.step; i++) {
const [, key, down] = tape.input[i];
const action = opts.keymap ? opts.keymap[key] : key;
if (action) held[action] = down;
}
if (cfg.clock) cfg.clock.t += 0.1; // повтор на максимальной скорости
const input = opts.live ? { ...held, ...opts.live(w.step) } : held;
tick(w, input, STEP_MS / 1000);
const want = tape.checks[w.step];
if (want && firstBad === null && want !== checksum(w)) firstBad = w.step;
if (opts.onStep) opts.onStep(w);
};
if (opts.frames) drive(opts.frames, () => {}, step); // с отрисовкой: кадры любой частоты
else while (w.step < tape.steps) step(); // без отрисовки: так быстро, как можно
return { world: w, firstBad };
}
Проверочный файл описывает уровень, сессию игрока — восемь событий клавиатуры и неровные кадры с 3 секундами в другой вкладке — и прогоняет одиннадцать сцен: исходную запись, честный повтор и девять способов его сломать.
import { STEP_MS, createWorld, tick, record, replay, checksum, snapshot, short } from "./replay.mjs";
// Наш пример: дорожка 300 px, сердце и шипы в одной точке, звезда в воздухе.
const level = {
hero: { x: 0, y: 0 }, hp: 3,
items: [{ id: 1, kind: "heart", x: 150, y: 0 }, { id: 2, kind: "spike", x: 150, y: 0 },
{ id: 3, kind: "star", x: 246, y: 80 }],
};
const SEED = 20261118;
const PLAYER_KEYS = { ArrowLeft: "left", ArrowRight: "right", KeyW: "jump" }; // игрок переназначил прыжок
const DEFAULT_KEYS = { ArrowLeft: "left", ArrowRight: "right", Space: "jump" }; // раскладка у зрителя повтора
const ev = (t, code, down) => ({ t, code, down });
const events = [
ev(200, "ArrowRight", 1), ev(1900, "KeyW", 1), ev(1990, "KeyW", 0), ev(2600, "ArrowRight", 0),
ev(6400, "ArrowLeft", 1), ev(7000, "KeyW", 1), ev(7060, "KeyW", 0), ev(8200, "ArrowLeft", 0),
];
// Кадры живой игры: неровные интервалы и 3 с в другой вкладке на 171-м кадре.
const frames = [];
for (let t = 0, i = 0; t < 9000; i++) {
const f = i === 170 ? 3000 : [17, 16, 17, 33, 16, 8, 17, 25][i % 8];
frames.push(f); t += f;
}
const even = (fps, ms) => Array.from({ length: Math.ceil(ms * fps / 1000) }, () => 1000 / fps);
const same = (a, b) => (checksum(a) === checksum(b) ? "совпало" : "НЕ совпало");
const verdict = (r) => (r.firstBad === null ? "контрольные точки совпали" : "расхождение на шаге " + r.firstBad);
console.log("1. Живая игра и лента");
const live = record(level, SEED, events, frames, PLAYER_KEYS);
const { tape } = live;
console.log(" итог: " + short(live.world) + ", шагов " + tape.steps + ", контрольных точек " +
Object.keys(tape.checks).length);
console.log(" лента: " + JSON.stringify(tape.input));
let perStep = 0;
replay(tape, {}, { onStep: (w) => { perStep += JSON.stringify(snapshot(w)).length; } });
console.log(" размер: лента " + JSON.stringify(tape).length + " байт, снимок мира каждый шаг " + perStep + " байт");
console.log("2. Повтор той же ленты");
const again = replay(tape);
console.log(" " + short(again.world) + " | " + verdict(again) + " | итог " + same(again.world, live.world));
for (const fps of [30, 60, 144]) {
const r = replay(tape, {}, { frames: even(fps, 7000) });
console.log(" с отрисовкой " + fps + " к/с: шагов " + r.world.step + ", " + checksum(r.world));
}
console.log("3. Переменный dt вместо шага: тот же ввод по времени");
for (const fps of [60, 30]) {
const w = createWorld(level, SEED), held = {}, dt = 1000 / fps;
let e = 0;
for (let t = dt; t <= 6000; t += dt) {
for (; e < events.length && events[e].t <= t; e++) held[PLAYER_KEYS[events[e].code]] = events[e].down;
tick(w, held, dt / 1000);
}
const star = w.items.some((it) => it.kind === "star") ? "не взята" : "взята";
console.log(" " + fps + " к/с: высота прыжка " + w.topY.toFixed(1) + " px, звезда " + star + ", " + short(w));
}
console.log("4. Math.random вместо генератора с зерном");
const rnd = record(level, SEED, events, frames, PLAYER_KEYS, { rand: Math.random });
const rndRun = replay(rnd.tape, { rand: Math.random });
console.log(" та же лента, второй прогон: " + (rndRun.firstBad === null ? "контрольные точки совпали" :
"контрольные точки разошлись") + ", итог " + same(rndRun.world, rnd.world));
console.log("5. Зерно не записано в ленту: повтор взял зерно 1");
const noSeed = replay({ ...tape, seed: 1 });
console.log(" " + short(noSeed.world) + " | " + verdict(noSeed));
console.log("6. Лента из кодов клавиш вместо действий");
const codes = { ...tape, input: live.raw };
console.log(" кодов в ленте " + live.raw.length + ": " + live.raw.map((x) => x[1]).join(", "));
for (const [name, keymap] of [["раскладка игрока", PLAYER_KEYS], ["раскладка зрителя", DEFAULT_KEYS]]) {
const r = replay(codes, {}, { keymap });
console.log(" " + name + ": " + short(r.world) + " | " + verdict(r));
}
console.log("7. Лента по стенным часам вместо номера шага");
const byClock = live.stamps.map(([t, a, d]) => [Math.floor(t / STEP_MS), a, d]);
console.log(" шаг в ленте: " + tape.input.map((x) => x[0]).join(" "));
console.log(" шаг по часам: " + byClock.map((x) => x[0]).join(" "));
const clockRun = replay({ ...tape, input: byClock });
console.log(" " + short(clockRun.world) + " | " + verdict(clockRun));
console.log("8. Часы внутри симуляции: кристалл живёт 2000 мс по Date.now");
const liveClock = record(level, SEED, events, frames, PLAYER_KEYS, { clock: { t: 0 } });
const replayClock = replay(liveClock.tape, { clock: { t: 0 } });
console.log(" игра: " + short(liveClock.world) + ", кристаллов на поле " + liveClock.world.gems.length);
console.log(" повтор: " + short(replayClock.world) + ", кристаллов на поле " + replayClock.world.gems.length +
" | " + verdict(replayClock));
console.log("9. Порядок объектов: загрузка асинхронная, удаление посреди цикла");
async function load(items, delays) { // кто загрузился раньше, тот раньше в массиве
const out = [];
await Promise.all(items.map((it) => new Promise((ok) =>
setTimeout(() => { out.push(it); ok(); }, delays[it.kind]))));
return { ...level, items: out };
}
const inGame = await load(level.items, { heart: 1, spike: 5, star: 3 });
const inReplay = await load(level.items, { heart: 5, spike: 1, star: 3 });
console.log(" порядок в игре: " + inGame.items.map((it) => it.kind).join(", ") +
"; в повторе: " + inReplay.items.map((it) => it.kind).join(", "));
const variants = [
["порядок загрузки, удаление в цикле", { order: "load", removal: "splice" }],
["порядок загрузки, удаление после обхода", { order: "load" }],
["по id, удаление в цикле", { removal: "splice" }],
["по id, удаление после обхода", {}],
];
for (const [name, cfg] of variants) {
const rec = record(inGame, SEED, events, frames, PLAYER_KEYS, cfg);
const rep = replay({ ...rec.tape, level: inReplay }, cfg);
console.log(" " + name + ": игра hp=" + rec.world.hp + ", повтор hp=" + rep.world.hp + " | " + verdict(rep));
}
console.log("10. Во время повтора читается живая клавиатура");
const stuck = replay(tape, {}, { live: (s) => (s < 30 ? { right: 1 } : {}) });
console.log(" стрелка вправо зажата первые 30 шагов: " + short(stuck.world) + " | " + verdict(stuck));
console.log("11. Правила изменились: прыжок 440 вместо 420");
const patched = replay(tape, { jump: 440 }, { checkVersion: false });
console.log(" без проверки версии: " + short(patched.world) + " | " + verdict(patched) +
" | итог " + same(patched.world, live.world));
console.log(" с проверкой: " + replay(tape, { jump: 440 }, { logic: "demo-65.2" }).error);
Вывод прогона (Node.js 24.22.1, node test.mjs):
1. Живая игра и лента
итог: x=70.0 y=0.0 hp=2 очки=5 дверь=да, шагов 376, контрольных точек 6
лента: [[11,"right",1],[113,"jump",1],[119,"jump",0],[154,"right",0],[218,"left",1],[253,"jump",1],[258,"jump",0],[326,"left",0]]
размер: лента 454 байт, снимок мира каждый шаг 41238 байт
2. Повтор той же ленты
x=70.0 y=0.0 hp=2 очки=5 дверь=да | контрольные точки совпали | итог совпало
с отрисовкой 30 к/с: шагов 376, cf9d8c32
с отрисовкой 60 к/с: шагов 376, cf9d8c32
с отрисовкой 144 к/с: шагов 376, cf9d8c32
3. Переменный dt вместо шага: тот же ввод по времени
60 к/с: высота прыжка 70.0 px, звезда взята, x=288.0 y=0.0 hp=2 очки=5 дверь=да
30 к/с: высота прыжка 66.7 px, звезда не взята, x=288.0 y=0.0 hp=2 очки=1 дверь=нет
4. Math.random вместо генератора с зерном
та же лента, второй прогон: контрольные точки разошлись, итог НЕ совпало
5. Зерно не записано в ленту: повтор взял зерно 1
x=70.0 y=0.0 hp=2 очки=6 дверь=да | расхождение на шаге 60
6. Лента из кодов клавиш вместо действий
кодов в ленте 8: ArrowRight, KeyW, KeyW, ArrowRight, ArrowLeft, KeyW, KeyW, ArrowLeft
раскладка игрока: x=70.0 y=0.0 hp=2 очки=5 дверь=да | контрольные точки совпали
раскладка зрителя: x=70.0 y=0.0 hp=2 очки=2 дверь=нет | расхождение на шаге 120
7. Лента по стенным часам вместо номера шага
шаг в ленте: 11 113 119 154 218 253 258 326
шаг по часам: 12 113 119 156 384 419 423 491
x=288.0 y=0.0 hp=2 очки=5 дверь=да | расхождение на шаге 60
8. Часы внутри симуляции: кристалл живёт 2000 мс по Date.now
игра: x=70.0 y=0.0 hp=2 очки=5 дверь=да, кристаллов на поле 2
повтор: x=70.0 y=0.0 hp=2 очки=8 дверь=да, кристаллов на поле 2 | расхождение на шаге 240
9. Порядок объектов: загрузка асинхронная, удаление посреди цикла
порядок в игре: heart, star, spike; в повторе: spike, star, heart
порядок загрузки, удаление в цикле: игра hp=2, повтор hp=3 | расхождение на шаге 120
порядок загрузки, удаление после обхода: игра hp=2, повтор hp=3 | расхождение на шаге 120
по id, удаление в цикле: игра hp=2, повтор hp=2 | контрольные точки совпали
по id, удаление после обхода: игра hp=2, повтор hp=2 | контрольные точки совпали
10. Во время повтора читается живая клавиатура
стрелка вправо зажата первые 30 шагов: x=92.0 y=0.0 hp=2 очки=2 дверь=нет | расхождение на шаге 60
11. Правила изменились: прыжок 440 вместо 420
без проверки версии: x=70.0 y=0.0 hp=2 очки=5 дверь=да | расхождение на шаге 120 | итог совпало
с проверкой: лента записана для demo-65.1, а правила demo-65.2
Что показал прогон: ловушки и исправления
Прогон показал, что исправленная симуляция повторяется до бита при любой частоте кадров, а каждая из девяти утечек ломает повтор в конкретной точке; по сценам:
- Запись. 376 шагов, 8 изменений ввода, 6 контрольных точек; лента — 454 байта, снимок мира на каждом шаге — 41 238 байт.
- Честный повтор. Все контрольные точки совпали, итог —
x=70.0, здоровье 2, 5 очков, дверь открыта; при отрисовке на 30, 60 и 144 кадрах в секунду одна и та же суммаcf9d8c32. - Переменный dt. Прыжок на 60 кадрах в секунду — 70,0 px, на 30 — 66,7 px, звезда на высоте 80 px не взята; кристаллы «раз в 60 шагов» стали появляться раз в 60 кадров, то есть вдвое реже. Итог — 1 очко против 5.
- Math.random. Второй прогон той же ленты разошёлся и на контрольных точках, и в итоге; номер первой несовпавшей точки зависит от выпавших чисел, поэтому в выводе его нет.
- Зерно не в ленте. Повтор с зерном 1 разошёлся на шаге 60, итог — 6 очков вместо 5.
- Коды клавиш. С раскладкой игрока лента из кодов совпала, с раскладкой зрителя — нет: прыжков 0, звезды нет, 2 очка, дверь закрыта, расхождение на шаге 120.
- Стенные часы в ленте. Два изменения сдвинулись на 1–2 шага из-за неровных кадров, четыре после вкладки — на 165–166 шагов, за конец записи. Герой остался справа,
x=288.0, расхождение на шаге 60. - Часы внутри шага. Кристаллы с временем жизни 2000 мс по часам исчезли в игре после 3 секунд в другой вкладке и дожили в быстром повторе: 8 очков вместо 5, расхождение на шаге 240.
- Порядок объектов. При порядке загрузки здоровье в игре 2, в повторе 3 при любом способе удаления; при сортировке по
idсовпали оба способа. - Живая клавиатура. Зажатая на 30 шагов стрелка вправо дала
x=92.0вместо 70, 2 очка и закрытую дверь. - Версия правил. Прыжок 440 вместо 420 без проверки версии разошёлся на шаге 120 при совпавшем итоге; с проверкой повтор не запустился, а вернул сообщение о несовпадении версий.
Все исправления сводятся к одному правилу: шаг читает только состояние мира, ленту и константы своей версии. Всё, что приходит снаружи — время кадра, часы, раскладка, порядок загрузки, клавиатура, — либо попадает в ленту, либо в шаг не попадает.
Практический сценарий: лента к отчёту об ошибке
Задача: тестировщик пишет, что «сердце на шипах иногда даёт 3 здоровья вместо 2», и у разработчика ошибка не воспроизводится. Нужно, чтобы любой такой отчёт приходил с лентой, которая у разработчика проигрывается в ту же самую игру, а исправление проверялось автоматически.
- Заголовок. При старте уровня записать версию правил, зерно и исходный уровень. Версию поднимать при любой правке шага, констант или данных уровня, влияющей на итог.
- Ввод. На каждом кадре переводить события клавиатуры, геймпада и касания в действия, применять изменения на ближайшем шаге и писать в ленту
[номер шага, действие, 1 или 0]. - Контрольные точки. Каждые 60 шагов класть в ленту контрольную сумму снимка мира.
- Чистый шаг. Убрать из шага
Math.random,Date.now,performance.now, чтение глобальной клавиатуры и порядок из загрузки; новые объекты получаютidиз счётчика мира. - Кнопка «Сохранить повтор». Лента сериализуется в JSON и прикладывается к отчёту; хранить её можно так же, как сохранение.
- Повтор у разработчика. Проверка версии, затем проигрывание без отрисовки до первой несовпавшей контрольной точки — это секунда, в которой искать причину.
- Тест. Лента из отчёта становится тестом: после исправления она проигрывается с новой версией правил и новыми ожидаемыми суммами, а старые ленты прогоняются на каждой сборке.
Проверяемый итог: на исходном уровне лента 454 байта проигрывается в те же x=70.0, здоровье 2, 5 очков и открытую дверь при отрисовке на 30, 60 и 144 кадрах в секунду и без отрисовки, а у тестировщика и разработчика здоровье после сердца на шипах одинаковое, потому что порядок задаёт id, а не загрузка. Отчёт со случайной ошибкой превращается в воспроизводимый за секунду тест. Как раньше мы проверяли детерминизм в статье об Asteroids на JavaScript — два прогона с одним зерном в одном процессе, — здесь проверка та же, но ввод приходит с чужой машины.
Когда вам это не подойдёт
Лента ввода подходит для одиночной игры, где автор контролирует каждую строку шага; вот где она лишняя или её мало:
- Короткая пошаговая сессия, где нужна только отмена. Если игроку нужно вернуть ход назад, хватит истории ходов, как в Sokoban; повтор идёт только вперёд от старта и отмену не заменяет.
- Нужно лишь показать ролик. Для трейлера или клипа в соцсети проще записать видео: оно проигрывается где угодно, а лента — только той же игрой той же версии правил.
- Физика стороннего движка, которую вы не контролируете. Если шаг считает чужая библиотека с внутренней случайностью или с функциями, чья точность зависит от реализации, гарантировать совпадение до бита нельзя. MDN прямо предупреждает, что многие функции
Mathв разных браузерах, а иногда и в одном движке на другой ОС или архитектуре, дают разный результат; Фидлер добавляет, что детерминизм на одной машине не гарантирует его на другом компиляторе, ОС или архитектуре. Мы проверяли прогон только в Node.js 24.22.1. Тогда надёжнее записывать снимки состояния с интерполяцией между ними. - Сетевая игра с чужим вводом. Когда ввод другого игрока приходит по сети с задержкой и потерями, нужен свой протокол синхронизации; лента из этой статьи — только основа для него, и сетевую часть мы здесь не разбираем.
- Долгий архив повторов через обновления. Лента проигрывается только той версией правил, для которой записана. Если повторы должны жить годами, придётся хранить старые версии логики или переходить на запись состояния.
- Перемотка на середину длинной сессии. Чтобы показать минуту 40, повтор пересчитывает 40 минут шагов. Для быстрой перемотки к ленте добавляют полные снимки мира раз в несколько секунд и считают от ближайшего.
Мы разрабатываем J2DRU — браузерный 2D игровой движок, где логика собирается из событий, условий и действий, а проект можно углублять на TypeScript. Движок в разработке и публично пока не открыт, заявку можно оставить на странице раннего доступа (подача заявки не гарантирует приглашение).
Источники (проверено: ноябрь 2026, 11.11.2026): Glenn Fiedler — Fix Your Timestep! (10.06.2004; поведение симуляции зависит от переданного dt; точная повторяемость при одинаковом вводе требует полностью фиксированного dt, полуфиксированный шаг не точно такой же из-за ограниченной точности чисел с плавающей точкой; ограничение времени кадра 0,25 с; интерполяция между предыдущим и текущим состоянием по остатку накопителя); Glenn Fiedler — Deterministic Lockstep (29.11.2014; определение детерминизма — тот же результат при том же начальном состоянии и вводе, до бита, с одинаковой контрольной суммой состояния; ODE перемешивал порядок ограничений генератором случайных чисел, исправление — зерно по номеру кадра; детерминизм на одной машине не гарантирует его на другом компиляторе, ОС или архитектуре; ввод снимается структурой в начале шага и помечается номером шага); MDN — Math.random() (начальное зерно выбирает реализация, пользователь не может задать или сбросить его); MDN — Math (точность многих функций Math зависит от реализации; разные браузеры, а также один движок на другой ОС или архитектуре могут дать разный результат). Схема ленты, функции tick, drive, record, replay, snapshot, checksum, уровень, константы, зерно, раскладки, события, кадры и все числа прогона — наш пример и наш расчёт в Node.js 24.22.1.
Читайте также:
- Игровой цикл (Game Loop) и физика столкновений (AABB, хитбоксы и триггеры) простыми словами и на уровне профи
- Действия ввода вместо клавиш: KeyboardEvent.code, Gamepad API, мёртвая зона
- Случайность без несправедливости: мешок без повторов, взвешенный выбор и гарантия редкого
- Спавн и удаление объектов в 2D-игре: время жизни, отложенное удаление и пулы
- Сохранения в браузерной игре: localStorage или IndexedDB, версии формата и защита от потери прогресса
- Sokoban на JavaScript: ящики, цели и отмена хода
- Ветвящиеся диалоги на JavaScript: дерево реплик в JSON, условия и флаги