Коротко
Удар в 2D-экшене описывают тремя разными прямоугольниками: хитбокс атаки наносит урон, хёртбокс тела его получает, а коллайдер движения только не даёт персонажам пройти друг сквозь друга. Атака — это таблица шагов: в фазе startup хитбокса нет, в active он есть и запоминает задетые цели, в recovery снова нет; при взгляде влево хитбокс зеркалится вокруг опорной точки. Неуязвимость отключает хёртбокс на число шагов после удара или на часть уклонения, а попадания шага сначала собирают и только потом применяют, чтобы взаимный удар не зависел от порядка в списке.
Содержание
- Три прямоугольника: хитбокс, хёртбокс и коллайдер движения
- Фазы атаки: startup, active, recovery
- Одно попадание на цель за атаку
- Зеркалирование по направлению взгляда
- Неуязвимость после удара и во время уклонения
- Порядок обработки в шаге и взаимный удар
- Код на JavaScript
- Проверка в Node.js
- Что показал прогон: пять ловушек
- Что не подтвердилось
- Практический сценарий: уклонение не спасает от когтей
- Когда вам это не подойдёт
Три прямоугольника: хитбокс, хёртбокс и коллайдер движения
У каждого бойца в 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 секунды.
В нашем примере две атаки:
| Атака | startup | active | recovery | Всего | Урон |
|---|---|---|---|---|---|
| slash (герой) | 6 | 4 | 15 | 25 шагов = 416,7 мс | 2 |
| claw (враг) | 9 | 3 | 18 | 30 шагов = 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.
- Выписать активные шаги удара. У claw первый активный шаг — 10-й, последний — 12-й (строка
clawв разделе 1 вывода). - Прогнать окно. Раздел 6: при неуязвимости 2–10 спасает старт на шагах 3–9 — окно 7 шагов, 116,7 мс.
- Поменять только неуязвимость уклонения. Сдвинуть начало на 1-й шаг и продлить до 12-го, длину уклонения оставить 18 шагов.
- Прогнать снова. Окно — 10 шагов, 166,7 мс; спасает любой старт с 1-го по 10-й шаг.
- Проверить, что не сломалось остальное. Разделы 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.
Читайте также:
- Ближний и дальний бой в 2D: дистанция, риск и баланс урона
- Патрулирование врагов и читаемые опасности: как настроить честные столкновения и окно предупреждения
- Конечный автомат персонажа в платформере: от флагов isJumping к состояниям, иерархии и стеку
- Маски и слои столкновений: кто с кем сталкивается, на битовых масках
- Отладочный оверлей на JavaScript: хитбоксы, FPS и журнал событий