---
title: "Хитбоксы и хёртбоксы в 2D-экшене: активные кадры атаки и неуязвимость"
description: "Как устроен удар в 2D-экшене: хитбокс бьёт, хёртбокс получает урон, коллайдер движения только толкает. Фазы startup, active и recovery в шагах фиксированного цикла, таблица атак данными, одно попадание на цель за атаку, зеркалирование хитбокса по взгляду, неуязвимость после удара и в уклонении, порядок обработки при взаимном ударе. Пять ловушек показаны прогоном в Node.js 24."
slug: hitboksy-i-hyortboksy-v-2d-ekshene-aktivnaya-faza-ataki-i-neuyazvimost
date: 2026-11-20
updated: 2026-11-20
scheduled_at: "2026-11-20T14:00:00+03:00"
rubric: gejmdizajn-i-mehaniki
tags: ["hitboksy", "gejmdizajn", "javascript", "razrabotchikam", "gejmdizajneram"]
reading_time: 22
draft: false
summary: "Удар в 2D-экшене держится на трёх разных прямоугольниках и счётчике шагов: хитбокс атаки существует только в активной фазе, бьёт по хёртбоксу цели и запоминает, кого уже задел, а неуязвимость отключает хёртбокс на заданное число шагов. В нашем прогоне на JavaScript урон в каждом кадре активной фазы снял 8 здоровья вместо 2, хитбокс без зеркала не доставал врага при взгляде влево, а обработка по очереди отдала взаимный удар тому, кто первым в списке."
---

## Коротко

Удар в 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](/blog/igrovoj-cikl-i-fizika-stolknovenij-aabb).

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

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

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

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

Разделение нужно, потому что у трёх зон разные правила жизни, даже если по размеру они близки. Хитбокс появляется и исчезает по таблице атаки, хёртбокс выключается неуязвимостью, а коллайдер движения работает всегда, даже у неуязвимого героя: иначе неуязвимый персонаж провалился бы сквозь врага. Каким должен быть размер хёртбокса относительно спрайта и почему опасность честнее делать меньше картинки, мы разбирали в статье про [патрулирование врагов и читаемые опасности](/blog/patrulirovanie-vragov-i-chitaemye-opasnosti) и во [Flappy-клоне](/blog/flappy-klon-na-javascript-generaciya-trub-i-chestnyj-hitboks); здесь размеры важны только тем, что зоны разные.

Отдельные зоны ещё и проще отлаживать: если рисовать их разным цветом, сразу видно, какая из трёх виновата. Как сделать такой оверлей, показано в статье про [отладочный оверлей](/blog/otladochnyj-overlej-na-javascript-hitboksy-fps-i-zhurnal-sobytij).

## Фазы атаки: 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 кадров. Как длина замаха врага связана со временем реакции игрока, мы разбирали в статье про [читаемые опасности](/blog/patrulirovanie-vragov-i-chitaemye-opasnosti); здесь замах — просто число в таблице.

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

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

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

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

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

Атака — это состояние бойца: пока она идёт, другие действия не начинаются. В нашем коде это одна проверка в `startAttack`; если у персонажа уже есть автомат состояний, атака становится ещё одним состоянием, как в статье про [конечный автомат персонажа](/blog/konechnyj-avtomat-personazha-platformera).

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

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

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

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

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

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

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

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

```text
взгляд вправо: 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): персонаж мигает, пока неуязвим. У определения стоит пометка «нужен источник», поэтому берём из него только сам термин; мигание — хороший способ показать игроку, что таймер идёт, но в логике оно ничего не решает. Если в игре уже есть маски столкновений, неуязвимость удобнее держать отдельным флагом или таймером, а не обнулять маску, — это мы разбирали в статье про [маски и слои столкновений](/blog/maski-i-sloi-stolknovenij-kto-s-kem-stalkivaetsya-na-bitovyh-maskah).

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

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

```text
неуязвимость уклонения, начатого на шаге 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 с. Как устроены фиксированный шаг и аккумулятор, разобрано в статье про [игровой цикл](/blog/igrovoj-cikl-i-fizika-stolknovenij-aabb), а зачем симуляции повторяемость — в статье про [повтор прохождения](/blog/povtor-prohozhdeniya-replay-zapis-vvoda-i-determinirovannaya-simulyaciya).

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

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

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

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

```text
шаг логики:
  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` вызывается из цикла с фиксированным шагом так же, как физика в статье про [игровой цикл](/blog/igrovoj-cikl-i-fizika-stolknovenij-aabb), а рамки зон рисует оверлей.

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

```js
// 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);
    }
  }
}
```

```js
// 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 раз подряд, вывод совпадал байт в байт.

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

```text
# 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. Как выбор между риском и наградой сказывается на дуэли в целом, разбирается в статье про [ближний и дальний бой](/blog/blizhnij-i-dalnij-boj-v-2d-distanciya-risk-i-balans-urona).

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

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

- **Игры без ударов.** В платформере, где опасность только в касании шипов, хватает хёртбокса героя и прямоугольника опасности, без фаз и списков.
- **Очень быстрые хитбоксы.** Если хитбокс или цель за один шаг сдвигается больше своей ширины, проверка в конце шага пропустит касание; это решается проверкой по пути движения, как в статье про [туннелирование](/blog/tunnelirovanie-bystryh-obektov-swept-aabb-i-nepreryvnaya-proverka-stolknovenij).
- **Сложная форма удара.** Дуга меча или хлыст плохо ложатся в один прямоугольник: нужны несколько прямоугольников на шаг или своя форма на каждый активный шаг.
- **Сетевая игра.** Два прохода решают порядок внутри одного шага на одной машине, но не спор двух клиентов о том, кто ударил первым; там нужен один авторитетный источник состояния.
- **Логика с переменным шагом.** Если весь код игры живёт на времени кадра и переписать его на фиксированный шаг нельзя, таблица в шагах теряет точность; тогда хотя бы считайте все таймеры боя в одном месте и одним временем.

Мы разрабатываем **J2DRU** — браузерный 2D игровой движок, где логика собирается из событий, условий и действий, а проект можно углублять на TypeScript. Движок в разработке и публично пока не открыт, заявку можно оставить на [странице раннего доступа](/early-access?utm_source=blog&utm_medium=article&utm_campaign=hitboksy-i-hyortboksy-v-2d-ekshene-aktivnaya-faza-ataki-i-neuyazvimost) (подача заявки не гарантирует приглашение).

**Источники (проверено: 12.11.2026, все страницы открываются с HTTP 200):** [Wikipedia — Collision detection, раздел Hitbox](https://en.wikipedia.org/wiki/Collision_detection#Hitbox) (хитбокс как невидимая форма; хёртбокс принимает урон; взаимные хитбоксы — размен или отмена ударов; хёртбоксы друг с другом не взаимодействуют; термин не стандартизован, в некоторых играх значения меняют местами; для упора в стену — AABB); [Wikipedia — Glossary of video game terms](https://en.wikipedia.org/wiki/Glossary_of_video_game_terms) (hitbox, hurtbox, invincibility frames: уклонение, удар, возрождение; flashing invulnerability с пометкой «нужен источник»); [Infil's Fighting Game Glossary — Startup](https://glossary.infil.net/?t=Startup) (три фазы; двойной счёт первого активного кадра); [Active](https://glossary.infil.net/?t=Active) (обычно 1–4 активных кадра при длине приёма до 30); [Recovery](https://glossary.infil.net/?t=Recovery); [Frame](https://glossary.infil.net/?t=Frame) (большинство файтингов — 60 кадров в секунду); [Hitbox](https://glossary.infil.net/?t=Hitbox) (в startup и recovery хитбоксов нет); [Hurtbox](https://glossary.infil.net/?t=Hurtbox); [Pushbox](https://glossary.infil.net/?t=Pushbox); [Invincible](https://glossary.infil.net/?t=Invincible) (неуязвимость убирает хёртбоксы); [Trade](https://glossary.infil.net/?t=Trade); [Priority System](https://glossary.infil.net/?t=Priority%20System) (Street Fighter V — приоритет по силе удара; Street Fighter IV и Street Fighter 6 — без него); [Hitstop](https://glossary.infil.net/?t=Hitstop) (вне счёта фаз); [MDN — Set](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set) (каждое значение встречается один раз). Бойцы, атаки, уклонение, шипы, режимы экрана и все числа прогона — наш пример и наш прогон в Node.js 24.22.1.

**Читайте также:**
- [Ближний и дальний бой в 2D: дистанция, риск и баланс урона](/blog/blizhnij-i-dalnij-boj-v-2d-distanciya-risk-i-balans-urona)
- [Патрулирование врагов и читаемые опасности: как настроить честные столкновения и окно предупреждения](/blog/patrulirovanie-vragov-i-chitaemye-opasnosti)
- [Конечный автомат персонажа в платформере: от флагов isJumping к состояниям, иерархии и стеку](/blog/konechnyj-avtomat-personazha-platformera)
- [Маски и слои столкновений: кто с кем сталкивается, на битовых масках](/blog/maski-i-sloi-stolknovenij-kto-s-kem-stalkivaetsya-na-bitovyh-maskah)
- [Отладочный оверлей на JavaScript: хитбоксы, FPS и журнал событий](/blog/otladochnyj-overlej-na-javascript-hitboksy-fps-i-zhurnal-sobytij)
