Коротко
Дискретная проверка AABB смотрит только на положения в конце шага, поэтому быстрый объект перепрыгивает стену; подшаги закрывают это ценой n проверок на шаг, а swept AABB считает время удара t от 0 до 1 одной проверкой на пару при любой скорости. В нашем прогоне пуля 8 px на 6000 px/с проходила стену 16 px в 92 стартах из 120 при дискретной проверке, в 8 из 120 при 4 подшагах и ни разу со swept AABB. Сама проверка — полдела: ответ на удар без TOI, «первая найденная» стена вместо самой ранней, неподвижная цель вместо относительной скорости и округление позиции после удара снова пропускают объект, и каждая из этих ловушек ниже ломается в выводе прогона, а потом исправляется.
Содержание
- Туннелирование коротко: что уже известно
- Три способа проверки: дискретно, подшагами, swept
- Подшаги: сколько нужно и сколько они стоят
- Swept AABB: время входа и выхода по двум осям
- Несколько препятствий: берём самый ранний контакт
- Ответ на удар: до точки TOI, затем скольжение
- Два движущихся объекта: относительная скорость
- Ядро на JavaScript и проверка в Node.js
- Что показал прогон: проскоки и исправления
- Как это делают Box2D и Godot
- Практический сценарий: снайперская пуля и тонкий забор
- Когда вам это не подойдёт
Туннелирование коротко: что уже известно
Туннелирование — это проскок объекта сквозь стену, когда за один шаг он сдвигается дальше, чем толщина стены плюс его собственный размер. Подробно, с игровым циклом и фиксированным шагом, это разобрано в статье об игровом цикле и столкновениях AABB; здесь нужен только итог:
безопасно, если v · dt < w_стены + w_объекта
пуля 8 px, стена 16 px, шаг 1/60 с: v < (16 + 8) · 60 = 1440 px/с
Там же в одной фразе названы два выхода — подшаги и проверка отрезка движения против прямоугольника стены (swept AABB). Эта статья — о том, как сделать оба, чем они отличаются и где ломаются. Третий выход, потолок скорости, хорош там, где скорость можно ограничить без ущерба для игры: в пинг-понге на JavaScript мяч разгоняется не выше 900 px/с, и этого хватает. Пуле снайперской винтовки или рывку героя потолок обычно не подходит.
Туннелирование — не единственная причина, по которой «пуля прошла сквозь врага». Если пара объектов отброшена фильтром слоёв, геометрия до неё вообще не доходит; это другой случай, он разобран в статье про маски и слои столкновений. Перед тем как чинить шаг, стоит убедиться, что пара вообще проверяется.
Три способа проверки: дискретно, подшагами, swept
Три способа отличаются тем, что они проверяют: дискретный — только конечное положение, подшаги — n промежуточных положений, swept — весь путь за шаг целиком.
| Способ | Что проверяет | Цена на пару за шаг | Пропускает |
|---|---|---|---|
| Дискретный AABB | положение в конце шага | 1 проверка, 4 сравнения | всё, что быстрее (w_стены + w_объекта) / dt |
| Подшаги, n штук | n положений внутри шага | n проверок | всё, что быстрее в n раз |
| Swept AABB | весь отрезок движения | 1 проверка, 4 деления и сравнения | ничего для неподвижной стены; повороты и кривые траектории не учитывает |
Цифры «пропускает» — не оценка на глаз. Ниже прогон стреляет пулей 8 px в стену 16 px из 120 стартовых положений с разной фазой относительно стены и считает, сколько раз пуля оказалась за стеной ни разу не столкнувшись. Это наш пример и наш расчёт; в реальной игре фаза зависит от того, откуда и когда выстрелили, и проскок выглядит случайным — в этом его главная неприятность.
Подшаги: сколько нужно и сколько они стоят
Подшаги спасают, если каждый из них короче суммы размеров стены и объекта; нужное число считается заранее по максимальной скорости:
шаг за кадр s = v · dt
нужно подшагов n = ⌊ s / (w_стены + w_объекта) ⌋ + 1
пуля 8 px, стена 16 px, 60 шагов/с:
1800 px/с → s = 30 px → n = ⌊30 / 24⌋ + 1 = 2
3000 px/с → s = 50 px → n = 3
6000 px/с → s = 100 px → n = 5
забор 2 px, пуля 4 px, 1800 px/с → n = ⌊30 / 6⌋ + 1 = 6
Плюс единица и округление вниз нужны из-за строгого неравенства: при подшаге, ровно равном сумме размеров, пуля может встать вплотную к стене до неё и вплотную после неё, а касание гранью в проверке AABB не считается пересечением. В прогоне это видно на 1440 px/с: шаг ровно 24 px, и 1 старт из 120 проходит сквозь стену. Граница из статьи про AABB строгая — v_max < 1440, а не ≤.
Подшаги недороги, пока быстрых объектов мало, а стены толстые. Цена растёт с двух сторон: быстрее объект — больше n, тоньше стена или меньше объект — тоже больше n. В нашем прогоне пуле 4 px на 1800 px/с против забора толщиной 2 px нужно 6 подшагов, и на сцене из 200 стен это 1200 проверок AABB за шаг против 200 проверок swept. Пространственная сетка из статьи о столкновениях сотен объектов сокращает число стен-кандидатов, но множитель n остаётся.
Недостаточное деление ломается тихо. При 6000 px/с и 4 подшагах пуля проходит стену в 8 стартах из 120 — около 7 %: на тестовой стрельбе в упор это легко не заметить, а в игре это «иногда пули проходят насквозь». Число подшагов надо считать от максимальной скорости, а не подбирать, пока не перестанет проскакивать.
Swept AABB: время входа и выхода по двум осям
Swept AABB отвечает на вопрос «в какой доле шага t от 0 до 1 движущаяся коробка впервые коснётся неподвижной», решая его по каждой оси отдельно и пересекая интервалы. По оси X коробка A перекрывает стену B, пока её проекция заходит на проекцию B; для движения со скоростью dx за шаг это интервал времени от входа до выхода:
Коробка A (x, y, w, h) за шаг сдвигается на (dx, dy). Стена B неподвижна.
ось X, dx ≠ 0:
t1 = (B.x − (A.x + A.w)) / dx передняя грань A у ближней грани B
t2 = (B.x + B.w − A.x) / dx задняя грань A ушла за дальнюю грань B
вход_x = min(t1, t2), выход_x = max(t1, t2)
ось X, dx = 0:
проекции по X не перекрываются → удара нет; иначе ось X ничего не ограничивает
ось Y — так же.
t_вход = max(вход_x, вход_y)
t_выход = min(выход_x, выход_y)
удар, если t_вход ≤ t_выход и 0 ≤ t_вход ≤ 1
нормаль — ось, которая дала t_вход: при dx > 0 это (−1, 0), левая грань стены
Смысл: по каждой оси коробки перекрываются в своём интервале времени, а пересекаются по-настоящему, только когда перекрыты обе оси сразу. Позднее из двух «входов» — момент, когда перекрытие наступило по обеим осям; раннее из двух «выходов» — когда оно закончилось хотя бы по одной. Если вход позже выхода, коробка прошла мимо: например, по X дошла до стены, когда по Y уже миновала её угол.
То же самое можно увидеть геометрически: расширить стену B на размеры A (сумма Минковского двух прямоугольников — снова прямоугольник) и пустить луч из угла A вдоль (dx, dy). Время входа луча в расширенный прямоугольник и есть TOI. Время входа и выхода по осям, нормаль удара и три варианта ответа — остановка, скольжение и отскок — разобраны в статье BrendanL.K на GameDev.net (30.04.2013); наш код отличается проверкой оси без движения и выбором самого раннего удара среди нескольких стен.
Две детали, о которые спотыкаются:
- dx = 0 нельзя пропускать через деление: получится бесконечность, а при касании гранью —
0 / 0 = NaN, и все сравнения с NaN ложны. Ось без движения проверяется перекрытием проекций. - t_вход < 0 означает, что по самой поздней оси перекрытие началось ещё до этого шага: объект уже внутри стены или касается её не с той стороны. Простая проверка такой случай отбрасывает — и это корень последней ловушки в прогоне.
Несколько препятствий: берём самый ранний контакт
При нескольких стенах на пути верный удар — тот, у которого t меньше всех, а не первый найденный в массиве. Порядок стен в массиве — это порядок загрузки уровня или вставки в сетку, к расстоянию он отношения не имеет. Если остановиться на первой стене с ударом, а она дальняя, объект встанет перед дальней стеной — то есть за ближней.
В прогоне у пули на пути две стены, ближняя x = 60 и дальняя x = 140, а в массиве дальняя стоит первой. «Первая найденная» даёт t = 0,66 и ставит пулю на x = 132 — за ближней стеной, которую она прошла насквозь. «Самая ранняя» даёт t = 0,26 и x = 52, перед ближней стеной. Та же ошибка встречается в лучах и проверке линии взгляда: «есть ли хоть одно пересечение» и «какое ближайшее» — разные функции.
Ответ на удар: до точки TOI, затем скольжение
После удара объект двигают ровно до момента удара — на dx · t и dy · t, а остаток шага 1 − t тратят на движение вдоль грани. Скорость в стену гасится, вдоль — сохраняется:
1. h = самый ранний удар на (dx, dy); нет удара → двигаемся на весь шаг, конец
2. x += dx · t, y += dy · t
3. ставим грань объекта точно на грань стены по нормали
4. нормаль по X → dx = 0, dy = dy · (1 − t)
нормаль по Y → dy = 0, dx = dx · (1 − t)
5. повторить с остатком (у нас — не больше 3 раз за шаг)
Повтор нужен, потому что скользящий объект может за тот же шаг упереться во вторую стену — например, в угол комнаты. Три итерации — наш выбор для прямоугольных уровней: каждый удар гасит одну компоненту, после двух ударов гасить больше нечего, и третья итерация только завершает шаг.
Главная ошибка здесь — обнаружить удар правильно, а ответить по-старому: сдвинуть объект на весь шаг и вытолкнуть его по наименьшему перекрытию от центра стены, как для медленных объектов. Если пуля успела зайти за середину стены, выталкивание «от центра» выносит её на дальнюю сторону. Для такого ответа условие строже, чем для обнаружения:
обнаружить пересечение: v · dt < w_стены + w_объекта → 1440 px/с
вытолкнуть в правильную сторону: v · dt < (w_стены + w_объекта) / 2 → 720 px/с
В прогоне при 1800 px/с без подшагов пуля пролетает стену в 25 стартах из 120 и ещё в 48 замечает пересечение, но выталкивается за стену: за стеной оказывается 73 пули из 120, около 61 %. Два подшага убирают пролёт, но 26 пуль всё ещё выталкиваются за стену; только при трёх подшагах (10 px, меньше 12) ошибок нет. Swept с TOI даёт 0 и 0 при одной проверке за шаг: объект ни в какой момент не оказывается внутри стены, выталкивать нечего.
Шаг 3 — установка грани точно на грань стены — выглядит лишним: x + dx · t и так должен попасть на грань. На деле он попадает с точностью до округления, и об этом последний результат прогона.
Два движущихся объекта: относительная скорость
Если движутся оба объекта, swept AABB считают в системе отсчёта одного из них: второй стоит, первый движется с разностью скоростей. Для пули со смещением (30, 0) за шаг и врага со смещением (−20, 0) проверка делается как для неподвижного врага и пули со смещением (50, 0); полученное t относится к обоим, и оба объекта двигают на свою долю шага.
Наивный вариант — проверить пулю против врага, «замороженного» в начале шага, и только потом сдвинуть врага — пропускает встречи, где они меняются местами за один шаг. В прогоне пуля 1800 px/с летит навстречу врагу 16 px на 1200 px/с: дискретная проверка пропустила 62 встречи из 120, swept против неподвижного врага — 48 из 120, swept с относительной скоростью — 0.
У этого приёма есть граница: он точен, пока обе скорости постоянны в течение шага и объекты не вращаются. Ускорение внутри шага, поворот и столкновение трёх быстрых объектов одновременно требуют решателя, который упорядочивает удары по времени, — это уже работа физического движка.
Ядро на JavaScript и проверка в Node.js
Модуль ниже ничего не рисует: в нём дискретная проверка, выталкивание без TOI, подшаги, swept AABB, поиск самого раннего удара и движение со скольжением. Запуск — Node.js 24.22.1; все сцены, скорости и размеры — наш пример.
/** sweep.mjs — дискретная проверка, подшаги и swept AABB для быстрых объектов */
// Прямоугольник: левый верхний угол (x, y), ширина w, высота h; ось Y вниз.
export function overlaps(a, b) {
return a.x < b.x + b.w && a.x + a.w > b.x && a.y < b.y + b.h && a.y + a.h > b.y;
}
// Ответ без TOI, как в статье про AABB: px = (hx_A + hx_B) − |cx_A − cx_B|,
// выталкиваем по X на px в сторону от центра стены.
export function pushOutX(a, b) {
const ca = a.x + a.w / 2, cb = b.x + b.w / 2;
const px = (a.w + b.w) / 2 - Math.abs(ca - cb);
a.x += ca < cb ? -px : px;
}
// Дискретный шаг: сдвинуть на (dx, dy), затем проверить пересечения.
// n > 1 — тот же шаг, разбитый на n подшагов. Возвращает число проверок AABB.
export function stepDiscrete(a, dx, dy, walls, n = 1, respond = null) {
let tests = 0;
for (let i = 0; i < n; i++) {
a.x += dx / n; a.y += dy / n;
for (const w of walls) {
tests++;
if (overlaps(a, w)) { a.hit = w; if (respond) respond(a, w); return tests; }
}
}
return tests;
}
// Swept AABB: когда (t от 0 до 1) коробка a, сдвигаясь на (dx, dy), впервые коснётся b.
// Возвращает { t, nx, ny } — время удара и нормаль грани b — или null.
export function sweep(a, dx, dy, b) {
let tEnter = -Infinity, tExit = Infinity, nx = 0, ny = 0;
if (dx === 0) {
if (a.x + a.w <= b.x || a.x >= b.x + b.w) return null;
} else {
const t1 = (b.x - (a.x + a.w)) / dx, t2 = (b.x + b.w - a.x) / dx;
const near = Math.min(t1, t2), far = Math.max(t1, t2);
if (near > tEnter) { tEnter = near; nx = dx > 0 ? -1 : 1; ny = 0; }
tExit = Math.min(tExit, far);
}
if (dy === 0) {
if (a.y + a.h <= b.y || a.y >= b.y + b.h) return null;
} else {
const t1 = (b.y - (a.y + a.h)) / dy, t2 = (b.y + b.h - a.y) / dy;
const near = Math.min(t1, t2), far = Math.max(t1, t2);
if (near > tEnter) { tEnter = near; nx = 0; ny = dy > 0 ? -1 : 1; }
tExit = Math.min(tExit, far);
}
if (tEnter > tExit || tEnter < 0 || tEnter > 1) return null;
return { t: tEnter, nx, ny };
}
// Самый ранний контакт среди всех стен (first = true — наивно: первый найденный).
export function firstHit(a, dx, dy, walls, first = false) {
let best = null;
for (const w of walls) {
const h = sweep(a, dx, dy, w);
if (h && (best === null || h.t < best.t)) { best = { ...h, wall: w }; if (first) break; }
}
return best;
}
// Движение со swept AABB: до удара, затем скольжение вдоль грани остатком шага.
// snap = true — ставить грань коробки точно на грань стены, а не в x + dx · t.
export function moveSwept(a, dx, dy, walls, snap = true) {
for (let i = 0; i < 3; i++) {
const h = firstHit(a, dx, dy, walls);
if (h === null) { a.x += dx; a.y += dy; return; }
a.x += dx * h.t; a.y += dy * h.t;
const w = h.wall;
if (snap && h.nx !== 0) a.x = h.nx < 0 ? w.x - a.w : w.x + w.w;
if (snap && h.ny !== 0) a.y = h.ny < 0 ? w.y - a.h : w.y + w.h;
a.hit = w;
const rest = 1 - h.t;
dx = h.nx !== 0 ? 0 : dx * rest; // гасим движение в стену, вдоль — оставляем
dy = h.ny !== 0 ? 0 : dy * rest;
}
}
Проверочный файл прогоняет пять сцен: пулю против стены на пяти скоростях тремя способами, выталкивание без TOI, две стены на пути, 1000 ящиков, падающих на пол, и встречу пули с врагом.
import { overlaps, pushOutX, stepDiscrete, sweep, firstHit, moveSwept } from "./sweep.mjs";
const STARTS = 120; // стартовых фаз на каждую скорость
// Пуля летит вправо в стену шириной wallW; результат по 120 стартам с разной фазой.
function shoot(v, mode, n, wallW, size) {
const step = v / 60, wall = { x: 100, y: 0, w: wallW, h: 64 };
let miss = 0, behind = 0;
for (let k = 0; k < STARTS; k++) {
const b = { x: 100 - size - step * (3 + (k + 1) / STARTS), y: 28, w: size, h: size };
for (let f = 0; f < 10 && !b.hit; f++) {
if (mode === "swept") moveSwept(b, step, 0, [wall]);
else stepDiscrete(b, step, 0, [wall], n, mode === "push" ? pushOutX : null);
}
if (!b.hit) miss++;
else if (b.x >= wall.x + wall.w) behind++;
}
return { miss, behind };
}
// Сколько подшагов нужно, чтобы ни одна из 120 пуль не прошла сквозь стену.
function minSubsteps(v, mode, wallW, size) {
for (let n = 1; n <= 64; n++) {
const r = shoot(v, mode, n, wallW, size);
if (r.miss === 0 && r.behind === 0) return n;
}
return -1;
}
const col = (s, w) => String(s).padStart(w);
console.log("1. Пуля 8 px, стена 16 px, 60 шагов/с: пролетела сквозь (из 120)");
console.log(" v, px/с шаг, px дискр. 2 подш. 4 подш. swept нужно подшагов");
for (const v of [900, 1440, 1800, 3000, 6000]) {
console.log(" " + col(v, 7) + col(v / 60, 8) + col(shoot(v, "d", 1, 16, 8).miss, 8) +
col(shoot(v, "d", 2, 16, 8).miss, 9) + col(shoot(v, "d", 4, 16, 8).miss, 9) +
col(shoot(v, "swept", 1, 16, 8).miss, 7) + col(minSubsteps(v, "d", 16, 8), 16));
}
const thin = minSubsteps(1800, "d", 2, 4);
console.log(" забор 2 px, пуля 4 px, 1800 px/с: подшагов " + thin +
", проверок AABB на 200 стен за шаг " + thin * 200 + " против 200 swept");
console.log("2. Заметили пересечение, вытолкнули от центра стены (1800 px/с)");
for (const n of [1, 2, 3]) {
const r = shoot(1800, "push", n, 16, 8);
console.log(" подшагов " + n + ": мимо " + r.miss + ", вытолкнуло за стену " + r.behind);
}
const rs = shoot(1800, "swept", 1, 16, 8);
console.log(" swept с TOI: мимо " + rs.miss + ", за стеной " + rs.behind);
console.log(" без проскока выталкиванием нужно подшагов: " + minSubsteps(1800, "push", 16, 8));
console.log("3. Две стены на пути, шаг 200 px");
const near = { x: 60, y: 0, w: 16, h: 64 }, far = { x: 140, y: 0, w: 16, h: 64 };
for (const first of [true, false]) {
const b = { x: 0, y: 28, w: 8, h: 8 };
const h = firstHit(b, 200, 0, [far, near], first);
console.log(" " + (first ? "первая найденная" : "самая ранняя ") + ": t = " + h.t.toFixed(2) +
", стена x = " + h.wall.x + ", пуля встанет на x = " + (b.x + 200 * h.t));
}
console.log("4. 1000 ящиков падают на пол, 120 шагов, скольжение по полу");
for (const [floorY, snap] of [[300, false], [300.3, false], [300.3, true]]) {
const floor = { x: -10000, y: floorY, w: 20000, h: 16 };
let fell = 0, example = null;
for (let i = 0; i < 1000; i++) {
const c = { x: i * 0.37, y: 20 + (i % 97) * 0.731, w: 8, h: 8 };
const dx = 0.1 + (i % 13) * 0.37, dy = 7 + (i % 29) * 1.913;
let landed = null;
for (let f = 0; f < 120; f++) {
moveSwept(c, dx, dy, [floor], snap);
if (c.hit && landed === null) landed = c.y + c.h;
}
if (c.y > floor.y) { fell++; if (example === null) example = landed; }
}
console.log(" пол y = " + floorY + ", " + (snap ? "грань на грань стены" : "позиция y + dy·t") +
": провалились " + fell + (example === null ? "" : ", низ ящика после удара " + example));
}
console.log("5. Пуля 1800 px/с навстречу врагу 1200 px/с, 120 стартов");
let missStatic = 0, missRel = 0, missDiscrete = 0;
for (let k = 0; k < STARTS; k++) {
const off = 50 * k / STARTS, bv = 30, ev = -20;
const scene = () => ({ b: { x: -off, y: 28, w: 8, h: 8 }, e: { x: 200, y: 24, w: 16, h: 16 } });
for (const mode of ["static", "relative", "discrete"]) {
const s = scene();
let hit = false;
for (let f = 0; f < 10 && !hit; f++) {
if (mode === "static") hit = sweep(s.b, bv, 0, s.e) !== null;
if (mode === "relative") hit = sweep(s.b, bv - ev, 0, s.e) !== null;
s.b.x += bv; s.e.x += ev;
if (mode === "discrete") hit = overlaps(s.b, s.e);
}
if (hit) continue;
if (mode === "static") missStatic++;
if (mode === "relative") missRel++;
if (mode === "discrete") missDiscrete++;
}
}
console.log(" дискретно мимо " + missDiscrete + ", swept против неподвижного врага мимо " + missStatic +
", swept по относительной скорости мимо " + missRel);
Вывод прогона (Node.js 24.22.1, node test.mjs):
1. Пуля 8 px, стена 16 px, 60 шагов/с: пролетела сквозь (из 120)
v, px/с шаг, px дискр. 2 подш. 4 подш. swept нужно подшагов
900 15 0 0 0 0 1
1440 24 1 0 0 0 2
1800 30 25 0 0 0 2
3000 50 63 6 0 0 3
6000 100 92 64 8 0 5
забор 2 px, пуля 4 px, 1800 px/с: подшагов 6, проверок AABB на 200 стен за шаг 1200 против 200 swept
2. Заметили пересечение, вытолкнули от центра стены (1800 px/с)
подшагов 1: мимо 25, вытолкнуло за стену 48
подшагов 2: мимо 0, вытолкнуло за стену 26
подшагов 3: мимо 0, вытолкнуло за стену 0
swept с TOI: мимо 0, за стеной 0
без проскока выталкиванием нужно подшагов: 3
3. Две стены на пути, шаг 200 px
первая найденная: t = 0.66, стена x = 140, пуля встанет на x = 132
самая ранняя : t = 0.26, стена x = 60, пуля встанет на x = 52
4. 1000 ящиков падают на пол, 120 шагов, скольжение по полу
пол y = 300, позиция y + dy·t: провалились 0
пол y = 300.3, позиция y + dy·t: провалились 7, низ ящика после удара 300.30000000000007
пол y = 300.3, грань на грань стены: провалились 0
5. Пуля 1800 px/с навстречу врагу 1200 px/с, 120 стартов
дискретно мимо 62, swept против неподвижного врага мимо 48, swept по относительной скорости мимо 0
Что показал прогон: проскоки и исправления
Прогон показывает, что дискретная проверка и подшаги пропускают объект в зависимости от скорости, а swept AABB — нет, но только если правильно выбран удар, ответ и система отсчёта. По сценам:
- Дискретная проверка. До 1440 px/с всё ловится, ровно на 1440 — 1 пролёт из 120 (граница строгая), дальше 25, 63 и 92 из 120 на 1800, 3000 и 6000 px/с. Swept — 0 на всех скоростях за одну проверку на шаг.
- Подшаги. Нужное число в последнем столбце совпадает с формулой
⌊s / 24⌋ + 1: 1, 2, 2, 3, 5. При 6000 px/с два подшага пропускают 64 пули, четыре — 8. Забор 2 px против пули 4 px требует 6 подшагов — 1200 проверок на 200 стен. - Ответ без TOI. Выталкивание от центра стены выносит пулю на дальнюю сторону: 48 из 120 без подшагов и 26 из 120 при двух, хотя два подшага пролёт уже устранили. Нужно три — вдвое строже условия обнаружения.
- Две стены. «Первая найденная» — t = 0,66, пуля за ближней стеной на x = 132. «Самая ранняя» — t = 0,26, x = 52.
- Встреча с врагом. Swept против врага, замершего в начале шага, — 48 пропусков из 120; с относительной скоростью — 0.
Отдельно — сцена с ящиками, единственная, где ошибка не в логике, а в арифметике. Ящики падают на пол по диагонали и скользят по нему. С полом на целом y = 300 в нашем прогоне провалов нет. С полом на y = 300.3 и позицией y + dy · t после удара у 7 ящиков из 1000 нижняя грань оказывается на 300.30000000000007 — внутри пола на 7·10⁻¹⁴ px. На следующем шаге время входа по Y становится крошечным отрицательным числом, проверка t_вход < 0 отбрасывает удар, ящик сдвигается на весь шаг внутрь пола и дальше проходит его насквозь. Число 300.3 в двоичной записи не представимо точно, а дробные координаты стен — обычное дело после масштабирования уровня или у движущихся платформ, так что целый пол в тесте эту ошибку просто прячет. Исправление — шаг 3 из раздела об ответе: после удара поставить грань ящика ровно на грань пола, y = floor.y − c.h. С ним провалов 0.
Проверку t_вход < 0 отбрасывать нельзя без замены: без неё объект, который уже внутри стены, получит «удар» в прошлом. Если по какой-то причине объект всё-таки оказался внутри — его поставили туда скриптом, стена появилась поверх него — нужен отдельный ответ: дискретное выталкивание до swept-проверки. В нашем коде этой ветки нет, потому что после установки грани на грань объект в стену не попадает.
Как это делают Box2D и Godot
Физические движки решают ту же задачу и называют её непрерывной проверкой столкновений (CCD); по документации Box2D 3.2 и Godot 4.7 (проверено: ноябрь 2026, 11.11.2026) она устроена так:
| Движок | Что включено по умолчанию | Быстрые объекты | Что важно знать |
|---|---|---|---|
| Box2D 3.2 | CCD динамических тел против статических: форма протягивается от старого положения к новому, считается время удара (TOI), тело ставится в первый TOI в конце шага | флаг isBullet: CCD со всеми типами тел, но не с другими пулями | между динамическими телами CCD по умолчанию нет ради скорости; автор советует пули «экономно»; safetyFactor включает или фактически выключает CCD для тела; события столкновения от CCD приходят на следующем шаге |
Godot 4.7, RigidBody2D | continuous_cd = 0, CCD выключен | CCD_MODE_CAST_RAY — луч, быстрее и менее точно; CCD_MODE_CAST_SHAPE — протягивание формы, медленнее и точнее | без CCD быстрые маленькие объекты могут пропустить столкновение |
Две вещи из таблицы совпадают с нашим прогоном. Box2D по умолчанию не делает CCD между двумя динамическими телами — та же встреча пули и врага, где нужна относительная скорость. А «пули экономно» — то же соображение, что и с подшагами: непрерывная проверка дороже дискретной, поэтому её включают только тем, кому она нужна. Подшаги решателя в Box2D (subStepCount, рекомендовано 4) — другое: они уточняют контакты и сочленения и не заменяют CCD.
Практический сценарий: снайперская пуля и тонкий забор
Задача: в шутере с видом сверху есть пистолет (900 px/с, пуля 8 px) и снайперская винтовка (6000 px/с, пуля 4 px), уровень из стен 16 px и заборов 2 px, 60 шагов физики в секунду. Нужно, чтобы ни одна пуля не проходила ни стену, ни забор, и проверить это до игры.
- Посчитать худший случай. Для винтовки против забора
s = 100 px,w_стены + w_объекта = 6 px, подшагов по формуле нужно⌊100 / 6⌋ + 1 = 17. Это повод для swept, а не для 17 подшагов. - Посчитать пистолет. Его шаг — 15 px. Против стены 16 px дискретной проверки хватает: 15 < 16 + 8 = 24. Против забора 2 px — нет: 15 больше 2 + 8 = 10, по формуле нужно
⌊15 / 10⌋ + 1 = 2подшага. Проще дать swept и пистолету: это одна проверка на пару вместо двух. - Пули — swept, остальные — дискретно. Герой и враги медленные, их оставить на обычном AABB с выталкиванием из статьи про AABB. Swept включать только пулям — как флаг
isBulletв Box2D. - Искать самый ранний удар. По всем стенам из ячеек сетки, которые пересекает расширенная коробка пули (коробка от старого до нового положения), брать минимальное t.
- Ответ на удар для пули — исчезнуть в точке TOI. Искру и звук ставить в
x + dx · t, а не в конечную позицию шага: иначе эффект появится за стеной. - Пуля против врага — по относительной скорости. Если враги быстрые (рывок, таран), считать swept по разности смещений.
- Прогон до игры. Пострелять по стене и забору из 120 фаз на максимальной скорости, как в
test.mjs: ожидание — 0 пролётов и 0 «за стеной». Для пуль, которые берутся из пула, сбрасывать признак удара при каждой выдаче, иначе новая пуля унаследуетhitот старой (пулы — в статье про спавн и удаление объектов).
Проверяемый итог: таблица прогона для ваших скоростей и толщин, где в столбце swept везде 0, а точка искры совпадает с гранью стены до тысячной доли пикселя.
Тот же принцип «проверять весь путь за шаг, а не конечную точку» уже встречался в гонке с видом сверху: там ворота засчитывают по пересечению отрезка движения с отрезком ворот. Для твёрдых стен этого мало — нужен размер объекта, поэтому здесь протягивается коробка, а не точка.
Когда вам это не подойдёт
Swept AABB из этой статьи — для прямоугольников без поворота и прямолинейного движения внутри шага; за этими границами нужен другой инструмент:
- Вращающиеся формы, круги и многоугольники. AABB повёрнутого тела больше самого тела, и swept по нему даст удар в воздухе. Нужен шейпкаст по настоящей форме — то, что в Godot называется
CCD_MODE_CAST_SHAPE, а в Box2D делается внутри CCD. - Объекты медленнее порога. Если
v · dtзаведомо меньше половины суммы размеров (для пули 8 px и стены 16 px — до 720 px/с), дискретная проверка с выталкиванием проще и дешевле. Swept для героя, который ходит на 200 px/с, — лишняя работа. - Нужна физика, а не попадание. Стопки ящиков, трение, импульсы, много быстрых тел одновременно — это решатель с упорядочиванием ударов по времени. Возьмите физический движок и включите CCD только быстрым телам.
- Траектория кривая внутри шага. Сильная гравитация или самонаведение за один шаг меняют направление; отрезок движения тогда приближение. Подшаги со swept на каждом подшаге — разумный компромисс.
- Удар в угол ровно по диагонали. При равных временах входа по обеим осям наш код выбирает нормаль по X — так написано сравнение
near > tEnter. Если для вашей игры важно, по какой грани скользить, решайте это правило явно.
Мы разрабатываем J2DRU — браузерный 2D игровой движок, где логика собирается из событий, условий и действий, а проект можно углублять на TypeScript. Движок в разработке и публично пока не открыт, заявку можно оставить на странице раннего доступа (подача заявки не гарантирует приглашение).
Источники (проверено: ноябрь 2026, 11.11.2026): Box2D 3.2.0 Documentation — Simulation (туннелирование; CCD по умолчанию для динамических тел против статических, протягивание форм и время удара, тело ставится в первый TOI в конце шага; CCD между динамическими телами по умолчанию нет; isBullet — CCD со всеми типами тел, кроме других пуль, «использовать экономно»; safetyFactor; события CCD — на следующем шаге; subStepCount, рекомендовано 4); Godot Engine 4.7 — RigidBody2D (continuous_cd, по умолчанию 0; CCD_MODE_DISABLED, CCD_MODE_CAST_RAY, CCD_MODE_CAST_SHAPE); GameDev.net — BrendanL.K, Swept AABB Collision Detection and Response, 30.04.2013 (время входа и выхода по осям, нормаль удара, ответы: остановка, скольжение, отскок). Сцены, скорости, размеры, формулы числа подшагов и порога выталкивания, 120 стартов, 1000 ящиков и все числа прогона — наш пример и наш расчёт в Node.js 24.22.1.
Читайте также:
- Игровой цикл (Game Loop) и физика столкновений (AABB, хитбоксы и триггеры) простыми словами и на уровне профи
- Пространственное хеширование: столкновения сотен объектов без проверки «каждый с каждым»
- Маски и слои столкновений: кто с кем сталкивается, на битовых масках
- Пинг-понг для двоих на JavaScript: ИИ соперника с задержкой реакции и честная подача
- Гонка с видом сверху на JavaScript: чекпойнты, круги и место в заезде
- Спавн и удаление объектов в 2D-игре: время жизни, отложенное удаление и пулы