---
title: "Повтор прохождения (replay): запись ввода и детерминированная симуляция"
description: "Как сделать повтор прохождения браузерной 2D-игры без видео: заголовок ленты с версией правил, зерном и уровнем, действия ввода по номеру шага симуляции, контрольные суммы снимков мира. Почему повтор расходится от переменного dt, Math.random, кодов клавиш, стенных часов, порядка загрузки объектов и живой клавиатуры, и как это поймать проверкой. Код на JavaScript проверен в Node.js 24."
slug: povtor-prohozhdeniya-replay-zapis-vvoda-i-determinirovannaya-simulyaciya
date: 2026-11-18
updated: 2026-11-18
scheduled_at: "2026-11-18T09:00:00+03:00"
rubric: logika-i-arhitektura
tags: ["javascript", "vvod", "game-loop", "arhitektura-igry", "profi"]
reading_time: 24
draft: false
summary: "Повтор прохождения — это не видео и не сохранение, а лента: заголовок с версией правил, зерном генератора и исходным уровнем плюс список действий игрока с номером шага симуляции, на котором действие началось или закончилось. При воспроизведении та же симуляция с тем же шагом получает тот же ввод и обязана прийти к тому же снимку мира, а контрольные суммы через каждые 60 шагов показывают, где она разошлась. В нашем прогоне 8 действий заняли 454 байта против 41 238 байт снимков на каждом шаге; повтор разошёлся от Math.random, от зерна, которого нет в ленте, от кодов клавиш при другой раскладке, от времени нажатия в миллисекундах (после возврата на вкладку — сдвиг на 166 шагов), от Date.now внутри шага, от порядка асинхронной загрузки объектов и от живой клавиатуры во время просмотра."
---

## Коротко

Повтор прохождения — это лента, а не запись экрана: заголовок с версией правил, зерном генератора и исходным уровнем плюс список действий вида «шаг 113, `jump`, нажато», которые симуляция с фиксированным шагом проигрывает заново и обязана прийти к тому же снимку мира до последнего бита. Повтор ломается всем, что влияет на шаг, но не попало в ленту: временем кадра, `Math.random`, стенными часами, раскладкой клавиш, порядком загрузки объектов, живой клавиатурой. В нашем прогоне каждая такая утечка видна в выводе — по контрольным суммам через каждые 60 шагов или по итогу — и исправлена, а исправленный повтор совпал с игрой при отрисовке на 30, 60 и 144 кадрах в секунду.

## Содержание

1. Повтор — не видео и не сохранение
2. Что записывать: заголовок и лента действий
3. Фиксированный шаг: лента считает шаги, а не миллисекунды
4. Случайность: зерно в заголовке, Math.random вне симуляции
5. Действия, а не клавиши
6. Порядок обхода и удаление объектов
7. Часы внутри шага и возврат на вкладку
8. Проверка: контрольные суммы и сверка снимков
9. Код на JavaScript и проверка в Node.js
10. Что показал прогон: ловушки и исправления
11. Практический сценарий: лента к отчёту об ошибке
12. Когда вам это не подойдёт

## Повтор — не видео и не сохранение

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

| | Видео | Сохранение | Повтор (лента ввода) |
|---|---|---|---|
| Что хранит | кадры экрана | состояние мира в одной точке | заголовок и действия по номеру шага |
| Размер в нашем примере | — | один снимок мира | 454 байта на 376 шагов |
| Можно проиграть быстрее | только перемоткой картинки | нет, это одна точка | да, без отрисовки |
| Можно проверить кодом | нет | частично | да, сверкой снимков |
| Что нужно для просмотра | любой плеер | та же игра | та же игра той же версии правил |

Отсюда главное требование: симуляция должна быть детерминированной. Гленн Фидлер в статье «Deterministic Lockstep» (29.11.2014) формулирует его жёстко: при одинаковом начальном состоянии и одинаковом вводе результат должен совпадать не «примерно», а до бита — настолько, что контрольная сумма всего состояния после каждого шага одинакова. Его статья о сетевой игре, наша — нет, но определение то же: повтор, который совпал «почти», через минуту расходится полностью, потому что любая разница на одном шаге становится входом следующего.

Отмена хода, как в [Sokoban на JavaScript](/blog/sokoban-na-javascript-yashchiki-celi-i-otmena-hoda), идёт назад по истории, а повтор — всегда вперёд от старта. Хранить ленту можно так же, как сохранение, — строкой JSON, см. статью о [сохранениях в браузерной игре](/blog/sohraneniya-v-brauzernoj-igre-localstorage-indexeddb).

## Что записывать: заголовок и лента действий

Записывать нужно заголовок один раз и короткую ленту изменений ввода, а позиции объектов — только как редкие контрольные суммы для проверки. В нашей схеме лента — объект 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](/blog/igrovoj-cikl-i-fizika-stolknovenij-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-игры](/blog/dostupnost-2d-igry-cvet-tryaska-ekrana-subtitry-i-skorost-igry), и он работает через накопитель, лента его не замечает: замедление меняет число шагов в секунду, а не сами шаги.

## Случайность: зерно в заголовке, Math.random вне симуляции

Каждое случайное решение, которое влияет на мир, должно брать число из генератора с зерном, а зерно — лежать в заголовке ленты. `Math.random` для этого не годится: по MDN начальное зерно выбирает реализация, и пользователь не может ни задать, ни сбросить его. В нашем прогоне сессия с `Math.random` и повтор той же ленты разошлись уже на контрольных точках, хотя ввод совпадал до шага.

Сам генератор, мешок без повторов и взвешенный выбор разобраны в статье о [случайности без несправедливости](/blog/sluchajnost-bez-nespravedlivosti-meshok-bez-povtorov-vzveshennyj-vybor); в коде ниже мы берём оттуда функцию `mulberry32` без изменений. Для повтора к ней добавляются три правила:

- **Зерно — в ленту.** Повтор, который взял зерно по умолчанию (в нашем прогоне 1 вместо 20261118), разошёлся на первой же контрольной точке, шаге 60: кристаллы появились в других местах, и итог — 6 очков вместо 5.
- **Один генератор на симуляцию.** Если эффекты частиц или звук берут числа из того же генератора, что и мир, то включённые в настройках частицы меняют, где появится следующий кристалл. Картинке — свой генератор или `Math.random`, миру — свой.
- **Порядок вызовов — часть детерминизма.** Генератор выдаёт последовательность, поэтому лишний вызов `rand()` в одной ветке кода сдвигает все следующие числа. Фидлер приводит пример из физического движка ODE: решатель использовал генератор случайных чисел, чтобы перемешивать порядок обработки ограничений, и это ломало детерминизм; исправление — задавать внутреннее зерно номером кадра перед каждым шагом.

## Действия, а не клавиши

В ленту пишут действия игры — `left`, `right`, `jump`, — а не коды клавиш и не номера кнопок геймпада. Как отделить действия от клавиш, разобрано в статье о [вводе: KeyboardEvent.code, Gamepad API и мёртвой зоне](/blog/vvod-klaviatura-gejmpad-kasanie-v-2d-igre); здесь — что это даёт повтору.

Карта клавиш — настройка конкретного игрока, а не часть игры. В нашем прогоне игрок переназначил прыжок на `KeyW`. Лента из сырых кодов у него проигрывается правильно, а у зрителя с раскладкой по умолчанию, где прыжок — `Space`, все четыре события `KeyW` ничего не значат: герой ни разу не прыгнул, не взял звезду, набрал 2 очка вместо 5, дверь не открылась, и контрольная сумма разошлась на шаге 120. Лента из действий от раскладки не зависит. То же правило мы уже встречали в статье о [ветвящихся диалогах](/blog/vetvyashchiesya-dialogi-na-javascript-derevo-replik-v-json-usloviya-i-flagi): выборы игрока пишут по `id`, а не по номеру кнопки.

Второе следствие — повтор должен читать только ленту. Если код шага берёт ввод из глобального объекта нажатых клавиш, во время просмотра в симуляцию попадает живая клавиатура. В нашем прогоне стрелка вправо, зажатая первые 30 шагов просмотра, увела героя на 22 px правее и мимо звезды: 2 очка вместо 5 и закрытая дверь. Исправление — один источник ввода на шаг: либо клавиатура через карту действий, либо лента, но не их смесь.

## Порядок обхода и удаление объектов

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

В нашем уровне сердце (+1 к здоровью, максимум 3) и шипы (−1) лежат в одной точке, и герой с полным здоровьем задевает их на одном шаге. Если сначала сердце, оно упирается в максимум, а шипы снимают единицу — здоровье 2. Если сначала шипы — 2, а потом сердце возвращает 3. Ограничение сверху делает эти два действия некоммутативными, и порядок в массиве решает исход. В нашем прогоне массив собирался в порядке завершения асинхронной загрузки: в игре сердце загрузилось первым, при просмотре — шипы. Итог: в игре 2, в повторе 3, расхождение на шаге 120.

Удаление посреди цикла — соседняя ошибка, и прогон показал важную деталь: само по себе оно повтор не ломает. `splice` внутри `forEach` пропускает следующий объект, но пропускает одинаково при каждом прогоне, поэтому при порядке по `id` игра и повтор совпали — оба с одной и той же ошибкой. Повтор ловит недетерминированность, а не любую ошибку логики. Расходится он, когда пропуск зависит от порядка, который пришёл извне. Почему удалять лучше после обхода и как устроено отложенное удаление, разобрано в статье о [спавне и удалении объектов](/blog/spavn-i-udalenie-obektov-v-2d-igre-vremya-zhizni-i-puly); для повтора добавим одно: новые объекты получают `id` из счётчика внутри мира (`nextId`), а не из глобального счётчика, который успел накрутить экран меню.

## Часы внутри шага и возврат на вкладку

Внутри шага симуляции не должно быть `Date.now()`, `performance.now()` и любых других часов: время мира — это номер шага, умноженный на длину шага. Часы отличаются в игре и в повторе по определению, потому что повтор идёт быстрее или медленнее реального времени.

Ловушка выглядит безобидно: «кристалл живёт 2 секунды» как `Date.now() - born < 2000`. В нашем прогоне игрок на 3 секунды ушёл в другую вкладку. Браузер в это время кадров не присылал (в фоновой вкладке большинство браузеров приостанавливает `requestAnimationFrame` — об этом и об огромном первом кадре после возврата есть в статье о [поиске просадок FPS](/blog/prosadki-fps-v-brauzernoj-igre-chrome-devtools-performance)), а часы шли. После возврата кристаллы, родившиеся до ухода, оказались «старше 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», чем тихо проигранная другая игра. Если в игре есть динамическая подстройка сложности, как в статье о [кривой сложности](/blog/krivaya-slozhnosti-i-dinamicheskaya-podstrojka-novichok-i-opytnyj), она тоже должна считаться внутри шага из состояния мира: подстройка по данным вне ленты разведёт повтор так же, как часы.

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

Модуль ниже ничего не рисует: в нём шаг мира, накопитель кадров, снимок и контрольная сумма, запись живой игры и повтор с проверкой. Переключатели `cfg` включают наивные варианты, чтобы прогон показал каждую ловушку на одном и том же коде; по умолчанию всё исправлено. Запуск — Node.js 24.22.1, модуль ES (`.mjs`); уровень, константы, шаг, зерно и все числа — наш пример.

```js
/** 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 секундами в другой вкладке — и прогоняет одиннадцать сцен: исходную запись, честный повтор и девять способов его сломать.

```js
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`):

```text
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
```

## Что показал прогон: ловушки и исправления

Прогон показал, что исправленная симуляция повторяется до бита при любой частоте кадров, а каждая из девяти утечек ломает повтор в конкретной точке; по сценам:

1. **Запись.** 376 шагов, 8 изменений ввода, 6 контрольных точек; лента — 454 байта, снимок мира на каждом шаге — 41 238 байт.
2. **Честный повтор.** Все контрольные точки совпали, итог — `x=70.0`, здоровье 2, 5 очков, дверь открыта; при отрисовке на 30, 60 и 144 кадрах в секунду одна и та же сумма `cf9d8c32`.
3. **Переменный dt.** Прыжок на 60 кадрах в секунду — 70,0 px, на 30 — 66,7 px, звезда на высоте 80 px не взята; кристаллы «раз в 60 шагов» стали появляться раз в 60 кадров, то есть вдвое реже. Итог — 1 очко против 5.
4. **Math.random.** Второй прогон той же ленты разошёлся и на контрольных точках, и в итоге; номер первой несовпавшей точки зависит от выпавших чисел, поэтому в выводе его нет.
5. **Зерно не в ленте.** Повтор с зерном 1 разошёлся на шаге 60, итог — 6 очков вместо 5.
6. **Коды клавиш.** С раскладкой игрока лента из кодов совпала, с раскладкой зрителя — нет: прыжков 0, звезды нет, 2 очка, дверь закрыта, расхождение на шаге 120.
7. **Стенные часы в ленте.** Два изменения сдвинулись на 1–2 шага из-за неровных кадров, четыре после вкладки — на 165–166 шагов, за конец записи. Герой остался справа, `x=288.0`, расхождение на шаге 60.
8. **Часы внутри шага.** Кристаллы с временем жизни 2000 мс по часам исчезли в игре после 3 секунд в другой вкладке и дожили в быстром повторе: 8 очков вместо 5, расхождение на шаге 240.
9. **Порядок объектов.** При порядке загрузки здоровье в игре 2, в повторе 3 при любом способе удаления; при сортировке по `id` совпали оба способа.
10. **Живая клавиатура.** Зажатая на 30 шагов стрелка вправо дала `x=92.0` вместо 70, 2 очка и закрытую дверь.
11. **Версия правил.** Прыжок 440 вместо 420 без проверки версии разошёлся на шаге 120 при совпавшем итоге; с проверкой повтор не запустился, а вернул сообщение о несовпадении версий.

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

## Практический сценарий: лента к отчёту об ошибке

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

1. **Заголовок.** При старте уровня записать версию правил, зерно и исходный уровень. Версию поднимать при любой правке шага, констант или данных уровня, влияющей на итог.
2. **Ввод.** На каждом кадре переводить события клавиатуры, геймпада и касания в действия, применять изменения на ближайшем шаге и писать в ленту `[номер шага, действие, 1 или 0]`.
3. **Контрольные точки.** Каждые 60 шагов класть в ленту контрольную сумму снимка мира.
4. **Чистый шаг.** Убрать из шага `Math.random`, `Date.now`, `performance.now`, чтение глобальной клавиатуры и порядок из загрузки; новые объекты получают `id` из счётчика мира.
5. **Кнопка «Сохранить повтор».** Лента сериализуется в JSON и прикладывается к отчёту; хранить её можно так же, как сохранение.
6. **Повтор у разработчика.** Проверка версии, затем проигрывание без отрисовки до первой несовпавшей контрольной точки — это секунда, в которой искать причину.
7. **Тест.** Лента из отчёта становится тестом: после исправления она проигрывается с новой версией правил и новыми ожидаемыми суммами, а старые ленты прогоняются на каждой сборке.

Проверяемый итог: на исходном уровне лента 454 байта проигрывается в те же `x=70.0`, здоровье 2, 5 очков и открытую дверь при отрисовке на 30, 60 и 144 кадрах в секунду и без отрисовки, а у тестировщика и разработчика здоровье после сердца на шипах одинаковое, потому что порядок задаёт `id`, а не загрузка. Отчёт со случайной ошибкой превращается в воспроизводимый за секунду тест. Как раньше мы проверяли детерминизм в статье об [Asteroids на JavaScript](/blog/asteroids-na-javascript-inerciya-povorot-korablya-i-droblenie-asteroidov) — два прогона с одним зерном в одном процессе, — здесь проверка та же, но ввод приходит с чужой машины.

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

Лента ввода подходит для одиночной игры, где автор контролирует каждую строку шага; вот где она лишняя или её мало:

- **Короткая пошаговая сессия, где нужна только отмена.** Если игроку нужно вернуть ход назад, хватит истории ходов, как в Sokoban; повтор идёт только вперёд от старта и отмену не заменяет.
- **Нужно лишь показать ролик.** Для трейлера или клипа в соцсети проще записать видео: оно проигрывается где угодно, а лента — только той же игрой той же версии правил.
- **Физика стороннего движка, которую вы не контролируете.** Если шаг считает чужая библиотека с внутренней случайностью или с функциями, чья точность зависит от реализации, гарантировать совпадение до бита нельзя. MDN прямо предупреждает, что многие функции `Math` в разных браузерах, а иногда и в одном движке на другой ОС или архитектуре, дают разный результат; Фидлер добавляет, что детерминизм на одной машине не гарантирует его на другом компиляторе, ОС или архитектуре. Мы проверяли прогон только в Node.js 24.22.1. Тогда надёжнее записывать снимки состояния с интерполяцией между ними.
- **Сетевая игра с чужим вводом.** Когда ввод другого игрока приходит по сети с задержкой и потерями, нужен свой протокол синхронизации; лента из этой статьи — только основа для него, и сетевую часть мы здесь не разбираем.
- **Долгий архив повторов через обновления.** Лента проигрывается только той версией правил, для которой записана. Если повторы должны жить годами, придётся хранить старые версии логики или переходить на запись состояния.
- **Перемотка на середину длинной сессии.** Чтобы показать минуту 40, повтор пересчитывает 40 минут шагов. Для быстрой перемотки к ленте добавляют полные снимки мира раз в несколько секунд и считают от ближайшего.

Мы разрабатываем **J2DRU** — браузерный 2D игровой движок, где логика собирается из событий, условий и действий, а проект можно углублять на TypeScript. Движок в разработке и публично пока не открыт, заявку можно оставить на [странице раннего доступа](/early-access?utm_source=blog&utm_medium=article&utm_campaign=povtor-prohozhdeniya-replay-zapis-vvoda-i-determinirovannaya-simulyaciya) (подача заявки не гарантирует приглашение).

**Источники (проверено: ноябрь 2026, 11.11.2026):** [Glenn Fiedler — Fix Your Timestep!](https://gafferongames.com/post/fix_your_timestep/) (10.06.2004; поведение симуляции зависит от переданного dt; точная повторяемость при одинаковом вводе требует полностью фиксированного dt, полуфиксированный шаг не точно такой же из-за ограниченной точности чисел с плавающей точкой; ограничение времени кадра 0,25 с; интерполяция между предыдущим и текущим состоянием по остатку накопителя); [Glenn Fiedler — Deterministic Lockstep](https://gafferongames.com/post/deterministic_lockstep/) (29.11.2014; определение детерминизма — тот же результат при том же начальном состоянии и вводе, до бита, с одинаковой контрольной суммой состояния; ODE перемешивал порядок ограничений генератором случайных чисел, исправление — зерно по номеру кадра; детерминизм на одной машине не гарантирует его на другом компиляторе, ОС или архитектуре; ввод снимается структурой в начале шага и помечается номером шага); [MDN — Math.random()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/random) (начальное зерно выбирает реализация, пользователь не может задать или сбросить его); [MDN — Math](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math) (точность многих функций `Math` зависит от реализации; разные браузеры, а также один движок на другой ОС или архитектуре могут дать разный результат). Схема ленты, функции `tick`, `drive`, `record`, `replay`, `snapshot`, `checksum`, уровень, константы, зерно, раскладки, события, кадры и все числа прогона — наш пример и наш расчёт в Node.js 24.22.1.

**Читайте также:**
- [Игровой цикл (Game Loop) и физика столкновений (AABB, хитбоксы и триггеры) простыми словами и на уровне профи](/blog/igrovoj-cikl-i-fizika-stolknovenij-aabb)
- [Действия ввода вместо клавиш: KeyboardEvent.code, Gamepad API, мёртвая зона](/blog/vvod-klaviatura-gejmpad-kasanie-v-2d-igre)
- [Случайность без несправедливости: мешок без повторов, взвешенный выбор и гарантия редкого](/blog/sluchajnost-bez-nespravedlivosti-meshok-bez-povtorov-vzveshennyj-vybor)
- [Спавн и удаление объектов в 2D-игре: время жизни, отложенное удаление и пулы](/blog/spavn-i-udalenie-obektov-v-2d-igre-vremya-zhizni-i-puly)
- [Сохранения в браузерной игре: localStorage или IndexedDB, версии формата и защита от потери прогресса](/blog/sohraneniya-v-brauzernoj-igre-localstorage-indexeddb)
- [Sokoban на JavaScript: ящики, цели и отмена хода](/blog/sokoban-na-javascript-yashchiki-celi-i-otmena-hoda)
- [Ветвящиеся диалоги на JavaScript: дерево реплик в JSON, условия и флаги](/blog/vetvyashchiesya-dialogi-na-javascript-derevo-replik-v-json-usloviya-i-flagi)
