Повтор прохождения (replay): запись ввода и детерминированная симуляция

Коротко

Повтор прохождения — это лента, а не запись экрана: заголовок с версией правил, зерном генератора и исходным уровнем плюс список действий вида «шаг 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, идёт назад по истории, а повтор — всегда вперёд от старта. Хранить ленту можно так же, как сохранение, — строкой 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

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

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

  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 — два прогона с одним зерном в одном процессе, — здесь проверка та же, но ввод приходит с чужой машины.

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

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

  • Короткая пошаговая сессия, где нужна только отмена. Если игроку нужно вернуть ход назад, хватит истории ходов, как в 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.

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

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

Чем повтор прохождения отличается от видео и от сохранения?

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

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

Потому что симуляция живёт шагами, а не миллисекундами: нажатие применяется на первом шаге после кадра, в котором оно пришло, и это зависит от неровных кадров. В нашем прогоне пересчёт времени в шаг сдвинул два нажатия на 1–2 шага, а после 3 секунд в другой вкладке — на 165–166 шагов. Пишите номер шага, на котором действие реально применилось.

Что делать с Math.random в игре, где есть повтор?

Убрать из симуляции. По MDN начальное зерно Math.random выбирает реализация, задать или сбросить его нельзя. Все случайные решения мира берут числа из генератора с зерном, а зерно лежит в заголовке ленты. Случайность только для картинки — искры, тряску — можно оставить на Math.random, если она не влияет ни на одно число в снимке мира.

Как проверить, что повтор не разошёлся?

Во время игры раз в 60 шагов считать контрольную сумму снимка мира и класть её в ленту, а при повторе считать заново и сравнивать. Первая несовпавшая точка показывает, в какой секунде искать причину. Сверки одного финала мало: в нашем прогоне правка силы прыжка разошлась на шаге 120, а итог — позиция, здоровье, очки и дверь — совпал.