Хитбоксы и хёртбоксы в 2D-экшене: активные кадры атаки и неуязвимость

Коротко

Удар в 2D-экшене описывают тремя разными прямоугольниками: хитбокс атаки наносит урон, хёртбокс тела его получает, а коллайдер движения только не даёт персонажам пройти друг сквозь друга. Атака — это таблица шагов: в фазе startup хитбокса нет, в active он есть и запоминает задетые цели, в recovery снова нет; при взгляде влево хитбокс зеркалится вокруг опорной точки. Неуязвимость отключает хёртбокс на число шагов после удара или на часть уклонения, а попадания шага сначала собирают и только потом применяют, чтобы взаимный удар не зависел от порядка в списке.

Содержание

  1. Три прямоугольника: хитбокс, хёртбокс и коллайдер движения
  2. Фазы атаки: startup, active, recovery
  3. Одно попадание на цель за атаку
  4. Зеркалирование по направлению взгляда
  5. Неуязвимость после удара и во время уклонения
  6. Порядок обработки в шаге и взаимный удар
  7. Код на JavaScript
  8. Проверка в Node.js
  9. Что показал прогон: пять ловушек
  10. Что не подтвердилось
  11. Практический сценарий: уклонение не спасает от когтей
  12. Когда вам это не подойдёт

Три прямоугольника: хитбокс, хёртбокс и коллайдер движения

У каждого бойца в 2D-экшене три разные зоны: хитбокс атаки (что бьёт), хёртбокс тела (куда бьют) и коллайдер движения (что толкает). Если смешать их в один прямоугольник, враг получает урон, задев героя спиной.

ЗонаКому принадлежитКогда существуетЧто делает
Хитбоксатакетолько в активной фазенаносит урон, если пересёк чужой хёртбокс
Хёртбокстелувсегда, кроме неуязвимостиполучает урон
Коллайдер движениятелувсегдане пускает в стены и в другого бойца

По глоссарию Infil, во время startup и recovery хитбоксов нет вообще: активная фаза и определяется тем, что хитбокс существует. Хёртбокс обычно повторяет фигуру персонажа, а коллайдер движения в файтингах называют pushbox: это не та часть, по которой бьют, а та, которой бойцы толкают друг друга. Wikipedia в статье о столкновениях добавляет, что хитбоксы рассчитаны на одностороннее событие «удар попал», а для упора в стену берут простые прямоугольники AABB; как работают выталкивание и триггеры, мы разбирали в статье про игровой цикл и AABB.

В нашем примере у бойца тело (коллайдер движения) 20×44, хёртбокс 16×42, а у удара slash хитбокс 30×16 со смещением 10 px вперёд от опорной точки. Все прямоугольники хранятся в локальных координатах для взгляда вправо; в мир их переводит одна функция.

Где источники расходятся в терминах

Названия «хитбокс» и «хёртбокс» не стандартизованы, и источники говорят об этом прямо. Wikipedia пишет, что некоторые игры меняют значения местами, а другие называют хитбоксом обе зоны; глоссарий Infil отмечает, что игроки часто говорят «хитбокс», имея в виду хёртбокс. В глоссарии видеоигровых терминов Wikipedia хитбокс — зона, которая наносит урон или другой эффект, а хёртбокс — зона, где игра регистрирует попадание. Мы держимся этого же деления: хитбокс у атаки, хёртбокс у тела. В коде называйте поля так, чтобы путаницы не было: hitbox у атаки, hurt у тела, body для движения.

Зачем разделять, если прямоугольники почти совпадают

Разделение нужно, потому что у трёх зон разные правила жизни, даже если по размеру они близки. Хитбокс появляется и исчезает по таблице атаки, хёртбокс выключается неуязвимостью, а коллайдер движения работает всегда, даже у неуязвимого героя: иначе неуязвимый персонаж провалился бы сквозь врага. Каким должен быть размер хёртбокса относительно спрайта и почему опасность честнее делать меньше картинки, мы разбирали в статье про патрулирование врагов и читаемые опасности и во Flappy-клоне; здесь размеры важны только тем, что зоны разные.

Отдельные зоны ещё и проще отлаживать: если рисовать их разным цветом, сразу видно, какая из трёх виновата. Как сделать такой оверлей, показано в статье про отладочный оверлей.

Фазы атаки: startup, active, recovery

Любая атака делится на три фазы, и считать их нужно в шагах фиксированного цикла: startup — замах без хитбокса, active — шаги, когда хитбокс существует, recovery — возврат, когда хитбокса уже нет, а действовать ещё нельзя. Глоссарий Infil называет эти три фазы основой frame data и измеряет их в кадрах; в большинстве файтингов кадр — 1/60 секунды.

В нашем примере две атаки:

АтакаstartupactiverecoveryВсегоУрон
slash (герой)641525 шагов = 416,7 мс2
claw (враг)931830 шагов = 500,0 мс1

Прогон печатает каждую атаку строкой по шагам: s — startup, a — active, r — recovery. У slash первый активный шаг — 7-й, у claw — 10-й. Активная фаза короткая: по Infil, у ударов в файтингах обычно около 1–4 активных кадров при полной длине приёма до 30 кадров. Как длина замаха врага связана со временем реакции игрока, мы разбирали в статье про читаемые опасности; здесь замах — просто число в таблице.

Как считать первый активный кадр

Первый активный кадр в разных источниках считают по-разному, и это нужно записать в документ по игре. По Infil, многие сообщества включают первый активный кадр в startup: удар с startup 8 в такой записи попадает на 8-м кадре, а не на 9-м. В нашей таблице startup 6 означает шесть шагов без хитбокса и попадание не раньше 7-го шага; в записи с двойным счётом тот же удар назывался бы семикадровым. Ошибиться здесь легко на один шаг, а один шаг решает, кто ударил первым.

Таблица атаки как данные

Атаку хранят как запись данных, а не как набор if в коде анимации: длительности фаз, урон и прямоугольник хитбокса лежат рядом. Тогда геймдизайнер меняет числа, не трогая логику, а проверка прогоном показывает, что изменилось. Схема записи:

атака = {
  startup:  шагов без хитбокса,
  active:   шагов с хитбоксом,
  recovery: шагов без хитбокса до возврата управления,
  damage:   урон за одно попадание,
  hitbox:   { x, y, w, h } от опорной точки при взгляде вправо
}
фаза(шаг) = startup,  если шаг ≤ startup
            active,   если шаг ≤ startup + active
            recovery, иначе

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

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

Одно попадание на цель за атаку

Атака должна попадать по каждой цели не больше одного раза, поэтому у неё есть список уже задетых. Проверка пересечения идёт в каждом шаге активной фазы; без списка цель, которая простояла под хитбоксом все 4 шага, получит урон 4 раза.

Правило простое:

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

В коде список — это Set с идентификаторами целей: по MDN, каждое значение в Set встречается только один раз. Список принадлежит атаке, а не цели: так один взмах задевает двух врагов по разу, а второй взмах снова может попасть по тому же врагу. Если нужен многоударный приём, например три удара за одну анимацию, его описывают тремя активными окнами с очисткой списка между ними, а не отключением списка.

Зеркалирование по направлению взгляда

Хитбокс при взгляде влево отражают относительно опорной точки, и при этом меняется не только знак смещения, но и сторона ширины:

взгляд вправо: left = x + r.x
взгляд влево:  left = x − r.x − r.w
верх и высота от взгляда не зависят: top = y + r.y

Если просто сменить знак у смещения (x − r.x) и оставить ширину отложенной вправо, прямоугольник уедет на всю свою ширину назад и окажется почти внутри героя. В нашем прогоне такая ошибка сократила дальность удара влево с 47 до 17 px, и враг на 35 px слева не получил урона. Если не зеркалить вовсе, хитбокс бьёт назад: враг слева в безопасности, а враг за спиной справа получает урон.

Хёртбоксы и коллайдер в нашем примере симметричны, поэтому зеркалить их можно той же функцией и не думать. Если же у персонажа выставлена вперёд рука или щит, несимметричны и они, и одна функция toWorld для всех прямоугольников избавляет от расхождений. Разворот картинки спрайта делается отдельно и по той же опорной точке.

Неуязвимость после удара и во время уклонения

Неуязвимость — это время, когда хёртбокс персонажа не принимает удары, и задают её в шагах. По глоссарию Infil, неуязвимые приёмы обычно просто убирают хёртбоксы; глоссарий Wikipedia называет три частых повода для кадров неуязвимости: действие игрока (уклонение, перекат), полученный удар и короткое время после возрождения. Коллайдер движения при этом остаётся: неуязвимый герой не проходит сквозь врага.

Неуязвимость после удара

Неуязвимость после удара не даёт одному врагу снять всё здоровье серией, пока игрок не успел отойти. В нашем примере враг бьёт claw без пауз, то есть раз в 30 шагов. За 300 шагов герой с неуязвимостью 45 шагов получил 5 ударов, без неуязвимости — 10 и потерял все 10 здоровья. Число 45 выбрано так, чтобы следующий удар того же врага приходился на неуязвимость, а удар через один — уже нет.

В глоссарии Wikipedia этот приём описан как мигающая неуязвимость (flashing invulnerability, mercy invincibility): персонаж мигает, пока неуязвим. У определения стоит пометка «нужен источник», поэтому берём из него только сам термин; мигание — хороший способ показать игроку, что таймер идёт, но в логике оно ничего не решает. Если в игре уже есть маски столкновений, неуязвимость удобнее держать отдельным флагом или таймером, а не обнулять маску, — это мы разбирали в статье про маски и слои столкновений.

Неуязвимость во время уклонения

Уклонение защищает не всё время, а только на части своих шагов, и от этой части зависит, насколько уклонение трудное. В нашем примере уклонение длится 18 шагов, а неуязвим герой на шагах 2–10: первый шаг уязвим, последние 8 шагов — тоже. Против claw с активными шагами 10–12 спасает только старт на шагах 3–9: окно 7 шагов, или 116,7 мс. Нажал слишком поздно — первый шаг уклонения ещё уязвим; слишком рано — неуязвимость кончилась раньше последнего активного шага удара.

неуязвимость уклонения, начатого на шаге s: шаги s + invulFrom − 1 … s + invulTo − 1
уклонение спасает, если она накрывает все активные шаги удара:
  s ≥ последний активный − invulTo + 1
  s ≤ первый активный − invulFrom + 1
claw (10–12), неуязвимость 2–10:  s от 12 − 10 + 1 = 3 до 10 − 2 + 1 = 9

Формула сходится с прогоном: шаги 3–9. При неуязвимости 1–12 окно в прогоне выросло до 10 шагов (166,7 мс), и спасал любой старт с 1-го по 10-й шаг. Формула годится, пока герой стоит на месте; если уклонение уводит хёртбокс из-под хитбокса, окно получают только прогоном.

Почему в шагах, а не в миллисекундах

Неуязвимость считают в шагах фиксированного цикла, потому что тогда её длина не зависит от частоты экрана. Ошибка, которую легко допустить, — таймер в миллисекундах, который уменьшается на время кадра отрисовки, хотя удары проверяются в шагах логики. Таймер списывает время кадра целиком, а удар мог прийти на любом шаге внутри кадра, и граница неуязвимости сдвигается. В прогоне с шипами, которые бьют при каждом касании, шаги дали одинаковые 46 шагов между ударами на всех пяти режимах экрана, а таймер в мс — 45 шагов на 144 Гц и 48 при рывках, то есть 13 ударов вместо 14 за 10 с. Как устроены фиксированный шаг и аккумулятор, разобрано в статье про игровой цикл, а зачем симуляции повторяемость — в статье про повтор прохождения.

Короткую остановку игры при попадании (hitstop) мы здесь не разбираем: по Infil, её кадры стоят вне счёта startup, active и recovery, и это вопрос управления временем, а не столкновений.

Порядок обработки в шаге и взаимный удар

Попадания шага сначала собирают все, а применяют потом, иначе при взаимном ударе выигрывает тот, кто первым в списке бойцов. Глоссарий Infil называет одновременное попадание двух атак в одном кадре разменом (trade): обычно оба получают удар. Wikipedia описывает размен иначе — как столкновение двух хитбоксов, которое может дать размен или взаимную отмену ударов; в нашем примере хитбоксы друг с другом не проверяются, размен — это два попадания хитбокса в хёртбокс в одном шаге.

Проблема появляется, когда удар сбивает атаку цели. Если обрабатывать бойцов по очереди и сразу применять урон, первый в списке попадает, сбивает атаку второго, и у второго в этом же шаге хитбокса уже нет. В нашем прогоне при одновременном активном шаге герой первым в списке остался с 10 здоровья, а враг потерял 2; поменяли порядок — герой потерял 1, враг не получил ничего. Порядок в массиве — это порядок создания объектов, а не правило игры, поэтому исход дуэли решает массив, а не игрок.

шаг логики:
  1. продвинуть счётчик шагов, кадры атак и уклонений
  2. собрать все пары (атака, цель), где хитбокс ∩ хёртбокс
     — ничего не меняя
  3. применить все пары: урон, список задетых, сбить атаку цели,
     неуязвимость

С двумя проходами оба варианта порядка дали одинаковый размен: 9 здоровья у героя и 8 у врага. Если игре нужен победитель, его выбирают явным правилом, а не порядком массива. По Infil, в Street Fighter V действует система приоритета: тяжёлые удары бьют средние, средние — лёгкие, а в Street Fighter IV и Street Fighter 6 такой системы нет и удары любой силы размениваются. В коде такое правило — ещё одна проверка в шаге 3, когда оба бойца попали друг в друга.

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

Код на JavaScript

Пример — два файла: combat.mjs с логикой и test.mjs, который прогоняет восемь сцен и печатает итог. Нужен Node.js 24 и папка с этими файлами; запуск — node test.mjs. Время только в шагах: функция step — один шаг 1/60 с, случайности нет, поэтому вывод повторяется байт в байт. Браузерную обвязку мы не приводим: step вызывается из цикла с фиксированным шагом так же, как физика в статье про игровой цикл, а рамки зон рисует оверлей.

Опции в step включают ошибки для ловушек: wholeBody — один прямоугольник на всё, everyFrame — без списка задетых, noMirror и badMirror — два вида ошибки зеркала, msTimer — неуязвимость в миллисекундах; twoPass включает правильный порядок с двумя проходами.

// combat.mjs — хитбоксы, хёртбоксы и неуязвимость; время только в шагах 1/60 с
export const STEP = 1 / 60;

// Таблица атак: длительности в шагах, прямоугольники — для взгляда вправо
export const MOVES = {
  slash: { startup: 6, active: 4, recovery: 15, damage: 2,
    hitbox: { x: 10, y: -34, w: 30, h: 16 } },
  claw: { startup: 9, active: 3, recovery: 18, damage: 1,
    hitbox: { x: 8, y: -30, w: 24, h: 14 } },
};

// Уклонение: 18 шагов, неуязвим на шагах 2–10
export const DODGE = { total: 18, invulFrom: 2, invulTo: 10 };

export function makeFighter(id, x, facing, hp, hurtIframes) {
  return {
    id, x, y: 200, facing, hp, hurtIframes,
    body: { x: -10, y: -44, w: 20, h: 44 },  // коллайдер движения
    hurt: { x: -8, y: -42, w: 16, h: 42 },   // хёртбокс
    attack: null,     // { move, frame, hitSet }
    dodge: null,      // { frame, spec } во время уклонения
    invulUntil: -1,   // последний шаг неуязвимости после удара
    invulMs: 0,       // для ловушки: таймер в миллисекундах
    hits: 0,
  };
}

export function makeWorld(fighters) {
  return { t: 0, fighters };
}

export function startAttack(f, moveName) {
  if (f.attack || f.dodge) return false;
  f.attack = { move: MOVES[moveName], frame: 0, hitSet: new Set() };
  return true;
}

export function startDodge(f, spec = DODGE) {
  if (f.attack || f.dodge) return false;
  f.dodge = { frame: 0, spec };
  return true;
}

export function phaseOf(move, frame) {
  if (frame <= move.startup) return "startup";
  if (frame <= move.startup + move.active) return "active";
  return "recovery";
}

// Прямоугольник из локальных координат в мировые с учётом взгляда
export function toWorld(f, r) {
  const left = f.facing === 1 ? f.x + r.x : f.x - r.x - r.w;
  return { x: left, y: f.y + r.y, w: r.w, h: r.h };
}

export function overlap(a, b) {
  return a.x < b.x + b.w && b.x < a.x + a.w &&
         a.y < b.y + b.h && b.y < a.y + a.h;
}

export function isInvulnerable(w, f, opts) {
  if (opts.msTimer ? f.invulMs > 0 : w.t <= f.invulUntil) return true;
  if (!f.dodge) return false;
  const d = f.dodge;
  return d.frame >= d.spec.invulFrom && d.frame <= d.spec.invulTo;
}

export function hitboxWorld(a, opts) {
  const r = a.attack.move.hitbox;
  if (opts.wholeBody) return toWorld(a, a.body);
  if (opts.noMirror) return { x: a.x + r.x, y: a.y + r.y, w: r.w, h: r.h };
  if (opts.badMirror && a.facing === -1) {
    // ошибка: сменили знак смещения, ширину не учли
    return { x: a.x - r.x, y: a.y + r.y, w: r.w, h: r.h };
  }
  return toWorld(a, r);
}

// Собрать попадания атакующего a, ничего не меняя
export function hitsOf(w, a, opts) {
  const list = [];
  if (!a.attack || phaseOf(a.attack.move, a.attack.frame) !== "active") return list;
  const box = hitboxWorld(a, opts);
  for (const t of w.fighters) {
    if (t === a || isInvulnerable(w, t, opts)) continue;
    if (!opts.everyFrame && a.attack.hitSet.has(t.id)) continue;
    const target = toWorld(t, opts.wholeBody ? t.body : t.hurt);
    if (overlap(box, target)) list.push({ attack: a.attack, t });
  }
  return list;
}

// attack запомнен при сборе: первый проход мог уже сбить атаку
export function applyHit(w, attack, t, opts) {
  attack.hitSet.add(t.id);
  hurt(w, t, attack.move.damage, opts);
}

// Урон цели и включение неуязвимости после удара
export function hurt(w, t, damage, opts) {
  t.hp -= damage;
  t.hits += 1;
  t.attack = null;  // удар сбивает атаку цели
  if (t.hurtIframes > 0) {
    if (opts.msTimer) t.invulMs = t.hurtIframes * 1000 / 60;
    else t.invulUntil = w.t + t.hurtIframes;
  }
}

// Один шаг: таймеры, затем попадания
export function step(w, opts) {
  w.t += 1;
  for (const f of w.fighters) {
    if (f.attack) {
      f.attack.frame += 1;
      const m = f.attack.move;
      if (f.attack.frame > m.startup + m.active + m.recovery) f.attack = null;
    }
    if (f.dodge) {
      f.dodge.frame += 1;
      if (f.dodge.frame > f.dodge.spec.total) f.dodge = null;
    }
  }
  if (opts.twoPass) {
    const all = [];
    for (const a of w.fighters) all.push(...hitsOf(w, a, opts));
    for (const h of all) applyHit(w, h.attack, h.t, opts);
  } else {
    for (const a of w.fighters) {
      for (const h of hitsOf(w, a, opts)) applyHit(w, h.attack, h.t, opts);
    }
  }
}
// test.mjs — node test.mjs; вывод детерминирован
import { MOVES, DODGE, makeFighter, makeWorld, startAttack, startDodge,
  phaseOf, toWorld, overlap, isInvulnerable, hurt, step } from "./combat.mjs";

const out = [];
const say = (s) => out.push(s);
const num = (x, d) => x.toFixed(d).replace(".", ",");
const yesNo = (b) => (b ? "да" : "нет");

function run(w, opts, steps, script) {
  for (let i = 0; i < steps; i++) {
    if (script) script(w.t + 1);
    step(w, opts);
  }
}

// Ударил ли герой (слева, x=100) цель на дистанции d
function slashHits(d, facing, opts) {
  const hero = makeFighter("hero", 100, facing, 10, 45);
  const foe = makeFighter("foe", 100 + d, -facing, 10, 0);
  const w = makeWorld([hero, foe]);
  startAttack(hero, "slash");
  run(w, opts, 25);
  return foe.hits > 0;
}

function reach(facing, opts) {
  let best = -1;
  for (let d = 0; d <= 80; d++) if (slashHits(d * facing, facing, opts)) best = d;
  return best;
}

say("# 0. Модель");
say("шаг 1/60 с; slash 6/4/15 шагов, урон 2; claw 9/3/18, урон 1; " +
  "уклонение " + DODGE.total + " шагов, неуязвим на " + DODGE.invulFrom + "–" + DODGE.invulTo +
  "; неуязвимость героя после удара 45 шагов");
say("тело 20×44, хёртбокс 16×42, хитбокс slash 30×16 со смещением 10 px; " +
  "герой в x=100, цель на расстоянии d, d > 0 — справа");

say("");
say("# 1. Фазы атаки по шагам");
for (const name of ["slash", "claw"]) {
  const m = MOVES[name];
  const total = m.startup + m.active + m.recovery;
  let line = "";
  for (let f = 1; f <= total; f++) line += phaseOf(m, f)[0];
  say(name + ": " + line + " — всего " + total + " шагов = " + num(total * 1000 / 60, 1) +
    " мс; активных " + m.active + "; первый активный — шаг " + (m.startup + 1));
}

say("");
say("# 2. Один прямоугольник на всё");
const right = {};
const whole = { wholeBody: true };
say("враг вплотную за спиной (d=-18): хитбокс+хёртбокс — " + yesNo(slashHits(-18, 1, right)) +
  ", тело на всё — " + yesNo(slashHits(-18, 1, whole)));
say("враг впереди (d=35): хитбокс+хёртбокс — " + yesNo(slashHits(35, 1, right)) +
  ", тело на всё — " + yesNo(slashHits(35, 1, whole)));
say("дальность удара вперёд: хитбокс+хёртбокс — " + reach(1, right) +
  " px, тело на всё — " + reach(1, whole) + " px");

say("");
say("# 3. Урон за атаку: список задетых против каждого кадра");
for (const opts of [{}, { everyFrame: true }]) {
  const hero = makeFighter("hero", 100, 1, 10, 45);
  const a = makeFighter("a", 125, -1, 10, 0);
  const b = makeFighter("b", 135, -1, 10, 0);
  const w = makeWorld([hero, a, b]);
  startAttack(hero, "slash");
  run(w, opts, 25);
  say((opts.everyFrame ? "каждый кадр: " : "список задетых: ") +
    "a — попаданий " + a.hits + ", hp " + a.hp + "; b — попаданий " + b.hits + ", hp " + b.hp);
}
{
  const hero = makeFighter("hero", 100, 1, 10, 45);
  const a = makeFighter("a", 125, -1, 10, 0);
  const w = makeWorld([hero, a]);
  startAttack(hero, "slash");
  run(w, {}, 30);
  startAttack(hero, "slash");
  run(w, {}, 30);
  say("две атаки подряд, список задетых: a — попаданий " + a.hits + ", hp " + a.hp);
}

say("");
say("# 4. Взгляд влево");
const variants = [["зеркало", {}], ["без зеркала", { noMirror: true }],
  ["x → −x", { badMirror: true }]];
for (const [label, opts] of variants) {
  say(label + ": враг слева d=35 — " + yesNo(slashHits(-35, -1, opts)) +
    ", враг сзади справа d=35 — " + yesNo(slashHits(35, -1, opts)) +
    "; дальность влево " + (reach(-1, opts) < 0 ? "не достаёт" : reach(-1, opts) + " px"));
}

say("");
say("# 5. Взаимный удар в одном шаге");
for (const [label, order, opts] of [
  ["герой первым в списке", "he", {}],
  ["враг первым в списке", "eh", {}],
  ["два прохода", "he", { twoPass: true }],
  ["два прохода, враг первым", "eh", { twoPass: true }]]) {
  const hero = makeFighter("hero", 100, 1, 10, 45);
  const foe = makeFighter("foe", 135, -1, 10, 0);
  const w = makeWorld(order === "he" ? [hero, foe] : [foe, hero]);
  run(w, opts, 40, (t) => {
    if (t === 1) startAttack(foe, "claw");
    if (t === 4) startAttack(hero, "slash");
  });
  say(label + ": hp героя " + hero.hp + ", hp врага " + foe.hp);
}

say("");
say("# 6. Окно уклонения против claw (активные шаги 10–12)");
for (const spec of [DODGE, { total: 18, invulFrom: 1, invulTo: 12 }]) {
  const saved = [];
  for (let s = 1; s <= 14; s++) {
    const hero = makeFighter("hero", 100, 1, 10, 45);
    const foe = makeFighter("foe", 125, -1, 10, 0);
    const w = makeWorld([hero, foe]);
    run(w, {}, 40, (t) => {
      if (t === 1) startAttack(foe, "claw");
      if (t === s) startDodge(hero, spec);
    });
    if (hero.hits === 0) saved.push(s);
  }
  say("неуязвим на " + spec.invulFrom + "–" + spec.invulTo + ": старт на шагах 1..14, удар не прошёл при " +
    saved.join(", ") + " — окно " + saved.length + " шагов = " + num(saved.length * 1000 / 60, 1) + " мс");
}

say("");
say("# 7. Неуязвимость после удара: враг бьёт claw без пауз, 300 шагов");
for (const ifr of [45, 0]) {
  const hero = makeFighter("hero", 100, 1, 10, ifr);
  const foe = makeFighter("foe", 125, -1, 99, 0);
  const w = makeWorld([hero, foe]);
  run(w, {}, 300, () => { if (!foe.attack) startAttack(foe, "claw"); });
  say("неуязвимость " + ifr + " шагов: попаданий " + hero.hits + ", hp " + hero.hp);
}

say("");
say("# 8. Шипы 10 с: неуязвимость в шагах против таймера в мс от dt кадра");
const spikes = { x: 80, y: 190, w: 40, h: 10 };
const rates = [["60 Гц", [1000 / 60]], ["144 Гц", [1000 / 144]], ["75 Гц", [1000 / 75]],
  ["30 Гц", [1000 / 30]], ["рывки 16,7/16,7/16,7/50 мс", [50 / 3, 50 / 3, 50 / 3, 50]]];
for (const msTimer of [false, true]) {
  for (const [label, dts] of rates) {
    const hero = makeFighter("hero", 100, 1, 100, 45);
    const w = makeWorld([hero]);
    const opts = { msTimer };
    const hitSteps = [];
    let acc = 0;
    let i = 0;
    while (w.t < 600) {
      const dt = dts[i % dts.length];
      i += 1;
      acc += dt;
      while (acc >= 1000 / 60 - 1e-9 && w.t < 600) {
        acc -= 1000 / 60;
        step(w, opts);
        if (!isInvulnerable(w, hero, opts) && overlap(toWorld(hero, hero.hurt), spikes)) {
          hurt(w, hero, 1, opts);
          hitSteps.push(w.t);
        }
      }
      if (hero.invulMs > 0) hero.invulMs -= dt;  // таймер в update(dt) кадра
    }
    const gaps = [];
    for (let k = 1; k < hitSteps.length; k++) gaps.push(hitSteps[k] - hitSteps[k - 1]);
    const lo = Math.min(...gaps);
    const hi = Math.max(...gaps);
    say((msTimer ? "мс от dt, " : "шаги, ") + label + ": попаданий " + hitSteps.length +
      ", между попаданиями " + (lo === hi ? lo : lo + "–" + hi) + " шагов");
  }
}

process.stdout.write(out.join("\n") + "\n");

Проверка в Node.js

Ниже — полный вывод node test.mjs на Node.js 24.22.1; мы запускали его 25 раз подряд, вывод совпадал байт в байт.

Вывод прогона:

# 0. Модель
шаг 1/60 с; slash 6/4/15 шагов, урон 2; claw 9/3/18, урон 1; уклонение 18 шагов, неуязвим на 2–10; неуязвимость героя после удара 45 шагов
тело 20×44, хёртбокс 16×42, хитбокс slash 30×16 со смещением 10 px; герой в x=100, цель на расстоянии d, d > 0 — справа

# 1. Фазы атаки по шагам
slash: ssssssaaaarrrrrrrrrrrrrrr — всего 25 шагов = 416,7 мс; активных 4; первый активный — шаг 7
claw: sssssssssaaarrrrrrrrrrrrrrrrrr — всего 30 шагов = 500,0 мс; активных 3; первый активный — шаг 10

# 2. Один прямоугольник на всё
враг вплотную за спиной (d=-18): хитбокс+хёртбокс — нет, тело на всё — да
враг впереди (d=35): хитбокс+хёртбокс — да, тело на всё — нет
дальность удара вперёд: хитбокс+хёртбокс — 47 px, тело на всё — 19 px

# 3. Урон за атаку: список задетых против каждого кадра
список задетых: a — попаданий 1, hp 8; b — попаданий 1, hp 8
каждый кадр: a — попаданий 4, hp 2; b — попаданий 4, hp 2
две атаки подряд, список задетых: a — попаданий 2, hp 6

# 4. Взгляд влево
зеркало: враг слева d=35 — да, враг сзади справа d=35 — нет; дальность влево 47 px
без зеркала: враг слева d=35 — нет, враг сзади справа d=35 — да; дальность влево не достаёт
x → −x: враг слева d=35 — нет, враг сзади справа d=35 — нет; дальность влево 17 px

# 5. Взаимный удар в одном шаге
герой первым в списке: hp героя 10, hp врага 8
враг первым в списке: hp героя 9, hp врага 10
два прохода: hp героя 9, hp врага 8
два прохода, враг первым: hp героя 9, hp врага 8

# 6. Окно уклонения против claw (активные шаги 10–12)
неуязвим на 2–10: старт на шагах 1..14, удар не прошёл при 3, 4, 5, 6, 7, 8, 9 — окно 7 шагов = 116,7 мс
неуязвим на 1–12: старт на шагах 1..14, удар не прошёл при 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 — окно 10 шагов = 166,7 мс

# 7. Неуязвимость после удара: враг бьёт claw без пауз, 300 шагов
неуязвимость 45 шагов: попаданий 5, hp 5
неуязвимость 0 шагов: попаданий 10, hp 0

# 8. Шипы 10 с: неуязвимость в шагах против таймера в мс от dt кадра
шаги, 60 Гц: попаданий 14, между попаданиями 46 шагов
шаги, 144 Гц: попаданий 14, между попаданиями 46 шагов
шаги, 75 Гц: попаданий 14, между попаданиями 46 шагов
шаги, 30 Гц: попаданий 14, между попаданиями 46 шагов
шаги, рывки 16,7/16,7/16,7/50 мс: попаданий 14, между попаданиями 46 шагов
мс от dt, 60 Гц: попаданий 14, между попаданиями 46 шагов
мс от dt, 144 Гц: попаданий 14, между попаданиями 45 шагов
мс от dt, 75 Гц: попаданий 14, между попаданиями 46 шагов
мс от dt, 30 Гц: попаданий 14, между попаданиями 46 шагов
мс от dt, рывки 16,7/16,7/16,7/50 мс: попаданий 13, между попаданиями 48 шагов

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

Все пять ловушек воспроизвелись: ловушки 1–3 — разделы 2–4 вывода, ловушка 4 — раздел 8, ловушка 5 — раздел 5. Позиции: герой стоит в x = 100, враг — на расстоянии d от него, положительное d — справа.

Ловушка 1: один прямоугольник на всё тело

Если удар проверяет тело атакующего против тела цели, он бьёт назад и не достаёт вперёд. Враг вплотную за спиной (d = −18) получил урон, хотя герой бил вперёд, а враг впереди на 35 px — нет. Дальность удара вперёд упала с 47 px (хитбокс против хёртбокса) до 19 px (тело против тела).

Ловушка 2: урон в каждом кадре активной фазы

Без списка задетых один взмах slash попал по каждой из двух целей 4 раза и снял по 8 здоровья из 10 вместо 2. Со списком — по одному попаданию на цель, а две атаки подряд по стоящему врагу дали 2 попадания и 6 здоровья: список принадлежит атаке и очищается вместе с ней. Вторую атаку тест запускает после конца первой: пока идёт recovery, startAttack возвращает false.

Ловушка 3: хитбокс не зеркалится

Без зеркала при взгляде влево хитбокс остался справа: враг слева на 35 px не получил урона, враг за спиной справа на 35 px — получил, а дальность влево — ноль. Ошибка «сменили знак смещения, ширину не учли» не ударила ни того, ни другого и сократила дальность влево до 17 px.

Ловушка 4: неуязвимость в миллисекундах от времени кадра

Таймер в мс, уменьшаемый на время кадра отрисовки, сдвинул границу неуязвимости: 45 шагов между ударами шипов на 144 Гц и 48 при рывках вместо 46. На 60, 75 и 30 Гц разницы не было. Счёт в шагах дал 46 на всех пяти режимах.

Ловушка 5: порядок в списке решает взаимный удар

При обработке по очереди победил тот, кто первым в списке: герой первым — у врага 8 здоровья, у героя 10; враг первым — у героя 9, у врага 10. Два прохода дали размен 9 и 8 при обоих порядках.

Что не подтвердилось

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

  • «Таймер в миллисекундах ломает неуязвимость». Слабее: граница сдвинулась на 1–2 шага, и за 10 с у шипов разница — 13 ударов против 14, только в двух режимах из пяти. На 60, 75 и 30 Гц таймер совпал с шагами. Главный вред не в длине, а в том, что исход зависит от экрана и рывков: один и тот же ввод на разных машинах даёт разный результат.
  • «Чем раньше начать уклонение, тем надёжнее». Нет: при неуязвимости на шагах 2–10 старт на 1-м и 2-м шагах не спас, потому что неуязвимость кончилась до последнего активного шага claw.
  • «Без зеркала удар просто бьёт назад, а с ошибкой знака — почти правильно». Нет: ошибка знака хуже — она не ударила ни врага спереди, ни врага сзади.

Практический сценарий: уклонение не спасает от когтей

Задача: игроки жалуются, что уклонение от когтей врага «не работает», и нужно сделать окно заметно шире, не меняя сам удар. Входные данные — таблица claw (9/3/18) и уклонение 18 шагов с неуязвимостью на 2–10.

  1. Выписать активные шаги удара. У claw первый активный шаг — 10-й, последний — 12-й (строка claw в разделе 1 вывода).
  2. Прогнать окно. Раздел 6: при неуязвимости 2–10 спасает старт на шагах 3–9 — окно 7 шагов, 116,7 мс.
  3. Поменять только неуязвимость уклонения. Сдвинуть начало на 1-й шаг и продлить до 12-го, длину уклонения оставить 18 шагов.
  4. Прогнать снова. Окно — 10 шагов, 166,7 мс; спасает любой старт с 1-го по 10-й шаг.
  5. Проверить, что не сломалось остальное. Разделы 1–5 и 7 от уклонения не зависят, и их строки в выводе те же: таблица атак, дальность и размен.

Проверяемый итог: строка «неуязвим на 1–12» в выводе показывает окно 10 шагов. Если окно стало слишком щедрым, уклонение теряет цену; тогда добавляют recovery уклонения или ограничение частоты, и снова прогоняют раздел 6. Как выбор между риском и наградой сказывается на дуэли в целом, разбирается в статье про ближний и дальний бой.

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

Таблица шагов, три зоны и два прохода хороши для экшена с ближним боем на фиксированном шаге; вот где их мало или они лишние:

  • Игры без ударов. В платформере, где опасность только в касании шипов, хватает хёртбокса героя и прямоугольника опасности, без фаз и списков.
  • Очень быстрые хитбоксы. Если хитбокс или цель за один шаг сдвигается больше своей ширины, проверка в конце шага пропустит касание; это решается проверкой по пути движения, как в статье про туннелирование.
  • Сложная форма удара. Дуга меча или хлыст плохо ложатся в один прямоугольник: нужны несколько прямоугольников на шаг или своя форма на каждый активный шаг.
  • Сетевая игра. Два прохода решают порядок внутри одного шага на одной машине, но не спор двух клиентов о том, кто ударил первым; там нужен один авторитетный источник состояния.
  • Логика с переменным шагом. Если весь код игры живёт на времени кадра и переписать его на фиксированный шаг нельзя, таблица в шагах теряет точность; тогда хотя бы считайте все таймеры боя в одном месте и одним временем.

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

Источники (проверено: 12.11.2026, все страницы открываются с HTTP 200): Wikipedia — Collision detection, раздел Hitbox (хитбокс как невидимая форма; хёртбокс принимает урон; взаимные хитбоксы — размен или отмена ударов; хёртбоксы друг с другом не взаимодействуют; термин не стандартизован, в некоторых играх значения меняют местами; для упора в стену — AABB); Wikipedia — Glossary of video game terms (hitbox, hurtbox, invincibility frames: уклонение, удар, возрождение; flashing invulnerability с пометкой «нужен источник»); Infil's Fighting Game Glossary — Startup (три фазы; двойной счёт первого активного кадра); Active (обычно 1–4 активных кадра при длине приёма до 30); Recovery; Frame (большинство файтингов — 60 кадров в секунду); Hitbox (в startup и recovery хитбоксов нет); Hurtbox; Pushbox; Invincible (неуязвимость убирает хёртбоксы); Trade; Priority System (Street Fighter V — приоритет по силе удара; Street Fighter IV и Street Fighter 6 — без него); Hitstop (вне счёта фаз); MDN — Set (каждое значение встречается один раз). Бойцы, атаки, уклонение, шипы, режимы экрана и все числа прогона — наш пример и наш прогон в Node.js 24.22.1.

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

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

Чем хитбокс отличается от хёртбокса?

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

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

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

Сколько кадров неуязвимости дать герою после удара?

Столько, сколько нужно, чтобы следующий удар того же врага не прошёл сразу. В нашем примере враг бьёт раз в 30 шагов; при неуязвимости 45 шагов за 300 шагов герой получил 5 ударов, без неуязвимости — 10. Считайте неуязвимость в шагах фиксированного цикла, а не в миллисекундах от времени кадра.

Кто побеждает, если два персонажа бьют друг друга в одном кадре?

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