Коротко
Слои столкновений отвечают на вопрос «нужно ли вообще проверять эту пару»: у каждого объекта есть категория — один бит его слоя — и маска — биты слоёв, с которыми он готов сталкиваться. В Box2D и Matter.js пара проходит фильтр, только если каждый есть в маске другого, а общая ненулевая группа перекрывает маски. Маски надёжнее получать из таблицы пар «кто с кем», чем набирать вручную: в нашем шутере из 352 объектов фильтр оставил 8300 пар из 61 776, а один забытый бит сделал пули игрока призрачными.
Содержание
- Зачем фильтровать пары до проверки геометрии
- Категория и маска: два числа на объект
- Двустороннее правило: каждый должен видеть другого
- Таблица «кто с кем» вместо ручных масок
- Группы: когда свои не сталкиваются
- Ловушки 32 бит в JavaScript
- Код на JavaScript и проверка в Node.js
- Фильтр, сенсор и реакция: кто за что отвечает
- Практический сценарий: шутер на двоих с режимом «каждый сам за себя»
- Когда вам это не подойдёт
Зачем фильтровать пары до проверки геометрии
Фильтр по слоям нужен, чтобы игра не спрашивала у геометрии то, ответ на что заранее известен: пуля игрока никогда не должна задевать монету, а монета — врага. Проверка прямоугольников AABB, разобранная в статье об игровом цикле и столкновениях, дешёвая, но после неё идёт реакция: выталкивание, урон, звук. Если пара прошла геометрию, а логика потом решает «а, это монета и вражеская пуля, ничего не делаем», в коде появляется цепочка if (a.type === … && b.type === …), которая растёт с каждым новым типом объекта.
Битовая маска заменяет эту цепочку одной операцией & над двумя числами. Она отвечает только на один вопрос — «могут ли эти двое столкнуться вообще» — и делает это до любых координат.
Фильтр и пространственный хеш из статьи о столкновениях сотен объектов решают разные задачи и хорошо работают вместе. Хеш отбрасывает пары, которые далеко друг от друга. Маска отбрасывает пары, которым нечего делать друг с другом, даже если они стоят вплотную. Порядок обычно такой:
широкая фаза (хеш, сетка) → пары, которые рядом
фильтр по маскам → пары, которым есть дело друг до друга
узкая фаза (AABB, круги) → пары, которые действительно пересеклись
реакция → выталкивание, урон, подбор
Фильтр можно поставить и перед хешем: тогда в хеш кладут только одну из групп, как в разделе «Хешируйте меньшую группу» той же статьи. Маски делают этот приём общим: группа — это просто набор битов.
Категория и маска: два числа на объект
Категория — это слой, в котором объект находится, а маска — слои, на которые он смотрит; оба поля — целые числа, где каждый бит означает один слой. Слой номер i — это число 1 << i: слой 0 — 1, слой 1 — 2, слой 2 — 4 и так далее.
Шесть слоёв шутера с видом сверху выглядят так:
| Слой | Бит | Категория (двоичная) | Десятичная |
|---|---|---|---|
| wall — стены | 0 | 000001 | 1 |
| player — игроки | 1 | 000010 | 2 |
| enemy — враги | 2 | 000100 | 4 |
| pbullet — пули игроков | 3 | 001000 | 8 |
| ebullet — пули врагов | 4 | 010000 | 16 |
| pickup — подбираемые предметы | 5 | 100000 | 32 |
Маска собирается операцией «или» из категорий интересных слоёв. Пуля игрока должна останавливаться о стены и попадать во врагов, значит её маска — wall | enemy = 1 + 4 = 5, в двоичном виде 000101. Проверка «есть ли слой X в маске» — это (mask & X) !== 0.
Названия у движков разные, смысл один:
| Движок | Категория | Маска | Слоёв | По умолчанию |
|---|---|---|---|---|
| Godot 4 | collision_layer | collision_mask | 32 | слой 1, маска 1 |
| Matter.js 0.20 | collisionFilter.category | collisionFilter.mask | 32 | категория 0x0001 |
| Box2D 3.x | filter.categoryBits | filter.maskBits | 64 | — |
У Godot есть деталь нумерации: в редакторе и в функциях set_collision_mask_value() слои считаются с 1, а биты — с 0. Слой 3 в интерфейсе — это 1 << 2, то есть 4. Документация Godot приводит пример: маска для слоёв 1, 3 и 4 — 0b1101, или 13. Ошибка на единицу здесь самая частая: слой «враги» в редакторе стоит третьим, а в коде маска собрана из 1 << 3.
Слои столкновений не связаны со слоями отрисовки. Порядок, в котором спрайты рисуются друг поверх друга, разобран в статье о Z-order и сортировке по Y, и смешивать эти два понятия в одном поле layer — верный способ получить врага, который перестал сталкиваться, потому что его перенесли «на передний план».
Двустороннее правило: каждый должен видеть другого
В Box2D и Matter.js пара сталкивается, только если категория A есть в маске B и категория B есть в маске A одновременно. Документация Box2D записывает это так:
(catA & maskB) != 0 И (catB & maskA) != 0 → пара может столкнуться
Matter.js формулирует то же самое: тела A и B сталкиваются, если каждое включает категорию другого в свою маску.
У такого правила есть удобная сторона: любой объект может отказаться от столкновения в одиночку. Призрак, проходящий сквозь стены, — это просто стена не в его маске, маски стен трогать не нужно. И есть неудобная: если одна сторона согласна, а другая нет, пара отбрасывается молча. Ни ошибки, ни предупреждения — пуля пролетает сквозь врага, и вы полчаса ищете баг в проверке прямоугольников.
Отсюда практическое следствие: при двустороннем правиле таблица «кто с кем» должна быть симметричной. Если pbullet смотрит на enemy, то enemy обязан смотреть на pbullet. Несимметричная маска — почти всегда ошибка, и её можно найти автоматически, это делает функция oneSided() в коде ниже.
Не во всех движках правило именно такое. Прежде чем переносить маски из одного движка в другой, найдите в его документации, требуется ли согласие обеих сторон или достаточно одной; от этого зависит, какие биты нужно ставить.
Совет из документации Box2D, который стоит повторить: описывайте ситуации, где объекты должны сталкиваться, а не где не должны. Тогда маска — это список «да», и в ней не появляется двойных отрицаний вроде «не игнорировать не-врагов».
Таблица «кто с кем» вместо ручных масок
Маски надёжнее всего получать кодом из списка пар, которые должны сталкиваться: одна строка — одна пара, и обе маски обновляются сразу. Для нашего шутера список из 8 пар:
| Пара | Что происходит |
|---|---|
| player — wall | игрок упирается в стену |
| enemy — wall | враг упирается в стену |
| pbullet — wall | пуля игрока исчезает о стену |
| ebullet — wall | пуля врага исчезает о стену |
| player — enemy | касание врага ранит игрока |
| pbullet — enemy | пуля игрока ранит врага |
| ebullet — player | пуля врага ранит игрока |
| player — pickup | игрок подбирает предмет |
Чего в списке нет, тоже стоит записать словами: игроки не толкают друг друга, враги проходят друг сквозь друга, пули не сталкиваются между собой, предметы лежат и ни на что не реагируют. Если позже решите, что враги должны расталкиваться, добавляется одна строка enemy — enemy.
Та же таблица в виде матрицы — шаблон, который удобно держать рядом с кодом и показывать геймдизайнеру:
wall player enemy pbullet ebullet pickup
wall . x x x x .
player x . x . x x
enemy x x . x . .
pbullet x . x . . .
ebullet x x . . . .
pickup . x . . . .
Матрица симметрична относительно диагонали, и это не совпадение: при двустороннем правиле так и должно быть.
Из списка пар маски получаются так: для каждой пары [a, b] добавить бит b в маску a и бит a в маску b. В прогоне ниже это дало:
| Слой | Маска (двоичная) | Шестнадцатеричная | Кого видит |
|---|---|---|---|
| wall | 011110 | 0x1e | игроков, врагов, оба вида пуль |
| player | 110101 | 0x35 | стены, врагов, пули врагов, предметы |
| enemy | 001011 | 0xb | стены, игроков, пули игроков |
| pbullet | 000101 | 0x5 | стены, врагов |
| ebullet | 000011 | 0x3 | стены, игроков |
| pickup | 000010 | 0x2 | игроков |
Набирать такие числа руками — значит рано или поздно ошибиться в одном бите. Генерация из списка пар убирает целый класс ошибок, и список пар заодно служит документацией.
Группы: когда свои не сталкиваются
Группа — это третье число, которое перекрывает маски: если у двух объектов одинаковая ненулевая группа, положительная разрешает столкновение всегда, отрицательная запрещает всегда. Так правило описано и в Box2D (groupIndex), и в Matter.js (collisionFilter.group). Если группы разные или хотя бы у одного объекта группа 0, решают категории и маски.
Зачем это нужно, если есть маски? Маски работают со слоями — со всеми пулями сразу. Группы работают с конкретными «семьями» объектов внутри одного слоя. Типичные случаи:
- Стрелок и его пули. Пули игрока 1 не должны попадать в игрока 1, но должны попадать в игрока 2. Масками слоёв это неудобно выражать: оба игрока в одном слое, а заводить по слою на каждого игрока и каждый вид его пуль — быстро исчерпать биты. Игроку 1 и его пулям дают группу -1, игроку 2 и его пулям — -2.
- Части одного составного объекта. Сегменты босса-змеи стоят вплотную и перекрываются; если они в слое
enemyи враги расталкиваются, сегменты будут толкать друг друга. Общая отрицательная группа на все сегменты решает это, не трогая столкновения с другими врагами. - Положительная группа — исключение из масок. Например, два ящика из слоя, который сам с собой не сталкивается, должны стоять друг на друге: общая положительная группа разрешит именно эту пару.
Документация Box2D открывает раздел о фильтрации примером с велосипедистом: персонаж и велосипед перекрываются и не должны выталкивать друг друга, но оба сталкиваются с землёй. Группы там же предлагаются для связанных объектов вроде частей велосипеда.
Номера групп удобно выдавать счётчиком: у Matter.js для этого есть Body.nextGroup(true), который возвращает следующую группу «не сталкиваются». В своём коде достаточно let nextGroup = 0; const newGroup = () => --nextGroup;.
Ловушки 32 бит в JavaScript
Побитовые операции JavaScript над обычными числами работают с 32-битными целыми со знаком, поэтому слоёв в одном числе не больше 32, а старший бит делает число отрицательным. Это прямо описано в справочнике MDN по оператору <<: результат — 32-битное целое, а сдвиг берётся по модулю 32. Что это значит на практике, видно в прогоне ниже:
| Выражение | Результат | Почему |
|---|---|---|
1 << 30 | 1073741824 | обычное положительное число |
1 << 31 | -2147483648 | старший бит — знак |
(1 << 31) >>> 0 | 2147483648 | >>> 0 переводит в беззнаковое |
1 << 32 | 1 | сдвиг по модулю 32: 33-й слой совпал с первым |
~0 | -1 | «все слои», но со знаком |
~0 >>> 0 | 4294967295 = 0xffffffff | «все слои» без знака |
Две из этих строк опасны молча. 1 << 32 не выдаёт ошибку: 33-й слой просто становится первым, и пули начинают сталкиваться со стенами, которых не должны видеть. А отрицательная категория 32-го слоя ломает сравнения вида mask > 0 и вывод в отладке, хотя сама проверка (a & b) !== 0 остаётся верной.
Правила, которые снимают обе проблемы:
- Проверять в маске только
!== 0, никогда не> 0. - Хранить и выводить маски через
>>> 0, чтобы в журнале было положительное число. - Падать с ошибкой, если слоёв больше 32, а не молча сдвигать дальше. Функция
defineLayers()ниже так и делает. - Если слоёв действительно больше 32 — переходить на
BigInt(1n << 40nработает) или хранить маску двумя числами. Чаще это повод пересмотреть слои: 32 типа объектов, которым нужны разные правила столкновений, — много для 2D-игры.
Код на JavaScript и проверка в Node.js
Модуль ниже ничего не рисует и не двигает: он заводит слои, строит маски из списка пар, проверяет пару с учётом групп и объясняет, почему пара не сталкивается. Запуск — Node.js 24.22.1, вывод прогона приведён в конце раздела и совпадает с числами в тексте.
/** layers.mjs — слои и маски столкновений на битах */
export function defineLayers(names) {
if (names.length > 32)
throw new RangeError("слоёв " + names.length + ", а побитовые операции JS работают с 32 битами");
const L = {};
names.forEach((name, i) => { L[name] = (1 << i) >>> 0; });
return L;
}
// rules — список пар «эти слои сталкиваются»; маски строятся сразу с обеих сторон
export function buildMasks(L, rules) {
const mask = {};
for (const name in L) mask[name] = 0;
for (const [a, b] of rules) {
mask[a] = (mask[a] | L[b]) >>> 0;
mask[b] = (mask[b] | L[a]) >>> 0;
}
return mask;
}
export function makeBody(L, mask, layer, group = 0) {
return { layer, category: L[layer], mask: mask[layer], group };
}
// Правило как в Box2D и Matter.js: сначала группа, потом категория и маска с обеих сторон
export function canCollide(a, b) {
if (a.group !== 0 && a.group === b.group) return a.group > 0;
return (a.category & b.mask) !== 0 && (b.category & a.mask) !== 0;
}
// Почему пара сталкивается или нет — для отладки
export function explain(a, b) {
if (a.group !== 0 && a.group === b.group)
return "группа " + a.group + (a.group > 0 ? ": всегда сталкиваются" : ": никогда не сталкиваются");
const ab = (a.category & b.mask) !== 0, ba = (b.category & a.mask) !== 0;
if (ab && ba) return "да: каждый есть в маске другого";
if (!ab && !ba) return "нет: ни один не смотрит на другого";
return "нет: " + (ab ? a.layer + " не видит " + b.layer : b.layer + " не видит " + a.layer) + " (односторонняя маска)";
}
// Ищем односторонние связи: A смотрит на B, а B на A — нет
export function oneSided(L, mask) {
const out = [];
for (const a in L) for (const b in L)
if (a < b && ((mask[a] & L[b]) !== 0) !== ((mask[b] & L[a]) !== 0))
out.push((mask[a] & L[b]) ? a + " → " + b : b + " → " + a);
return out;
}
export const bin = (x, width) => (x >>> 0).toString(2).padStart(width, "0");
Проверочный файл строит слои шутера, считает, сколько пар отсекает фильтр, воспроизводит забытый бит, включает режим «каждый сам за себя» и проверяет ловушки 32 бит:
import { defineLayers, buildMasks, makeBody, canCollide, explain, oneSided, bin } from "./layers.mjs";
// 1. Слои и правила для шутера с видом сверху
const L = defineLayers(["wall", "player", "enemy", "pbullet", "ebullet", "pickup"]);
const rules = [
["player", "wall"], ["enemy", "wall"], ["pbullet", "wall"], ["ebullet", "wall"],
["player", "enemy"], ["pbullet", "enemy"], ["ebullet", "player"], ["player", "pickup"],
];
const mask = buildMasks(L, rules);
for (const n in L)
console.log(n.padEnd(8), "категория", bin(L[n], 6), "маска", bin(mask[n], 6), "= 0x" + mask[n].toString(16));
// 2. Сколько пар отсекает фильтр в сцене (стены проверяются по тайловой сетке, в список не входят)
const counts = { player: 2, enemy: 40, pbullet: 200, ebullet: 80, pickup: 30 };
const bodies = [];
for (const n in counts) for (let i = 0; i < counts[n]; i++) bodies.push(makeBody(L, mask, n));
let all = 0, passed = 0;
for (let i = 0; i < bodies.length; i++)
for (let j = i + 1; j < bodies.length; j++) { all++; if (canCollide(bodies[i], bodies[j])) passed++; }
console.log("объектов", bodies.length, "| пар всего", all, "| проходят фильтр", passed,
"| доля " + (100 * passed / all).toFixed(1) + "%");
// 3. Ошибка: маску врага собрали руками и забыли пули игрока
const badMask = { ...mask, enemy: (L.wall | L.player) >>> 0 };
const e = makeBody(L, badMask, "enemy"), b = makeBody(L, badMask, "pbullet");
console.log("пуля → враг:", canCollide(b, e), "|", explain(b, e));
console.log("односторонние связи:", oneSided(L, badMask));
console.log("в правильных масках:", oneSided(L, mask));
// 4. Режим «каждый сам за себя»: пули бьют игроков, но не своего стрелка
const pvp = buildMasks(L, [...rules, ["pbullet", "player"]]);
const p1 = makeBody(L, pvp, "player", -1), p1shot = makeBody(L, pvp, "pbullet", -1);
const p2 = makeBody(L, pvp, "player", -2);
console.log("пуля p1 → p1:", canCollide(p1shot, p1), "|", explain(p1shot, p1));
console.log("пуля p1 → p2:", canCollide(p1shot, p2), "|", explain(p1shot, p2));
console.log("p1 → p2:", canCollide(p1, p2), "|", explain(p1, p2));
// 5. Ловушки 32 бит
console.log("1 << 30 =", 1 << 30, "| 1 << 31 =", 1 << 31, "| (1 << 31) >>> 0 =", (1 << 31) >>> 0, "| 1 << 32 =", 1 << 32);
console.log("~0 =", ~0, "| ~0 >>> 0 =", ~0 >>> 0, "= 0x" + (~0 >>> 0).toString(16));
try { defineLayers(Array.from({ length: 33 }, (_, i) => "l" + i)); }
catch (err) { console.log(err.constructor.name + ":", err.message); }
Вывод прогона (Node.js 24.22.1, node test.mjs):
wall категория 000001 маска 011110 = 0x1e
player категория 000010 маска 110101 = 0x35
enemy категория 000100 маска 001011 = 0xb
pbullet категория 001000 маска 000101 = 0x5
ebullet категория 010000 маска 000011 = 0x3
pickup категория 100000 маска 000010 = 0x2
объектов 352 | пар всего 61776 | проходят фильтр 8300 | доля 13.4%
пуля → враг: false | нет: enemy не видит pbullet (односторонняя маска)
односторонние связи: [ 'pbullet → enemy' ]
в правильных масках: []
пуля p1 → p1: false | группа -1: никогда не сталкиваются
пуля p1 → p2: true | да: каждый есть в маске другого
p1 → p2: false | нет: ни один не смотрит на другого
1 << 30 = 1073741824 | 1 << 31 = -2147483648 | (1 << 31) >>> 0 = 2147483648 | 1 << 32 = 1
~0 = -1 | ~0 >>> 0 = 4294967295 = 0xffffffff
RangeError: слоёв 33, а побитовые операции JS работают с 32 битами
Что видно из прогона:
- Маски совпали с таблицей «кто с кем». Каждая строка вывода — строка матрицы, прочитанная справа налево: младший бит —
wall. - Фильтр оставил 13,4% пар. Из 61 776 возможных пар между 352 подвижными объектами геометрию стоит проверять только у 8300: 8000 пар «пуля игрока — враг», 160 «пуля врага — игрок», 80 «игрок — враг» и 60 «игрок — предмет». Самый многочисленный слой, 200 пуль игроков, сталкивается только с 40 врагами, а 80 пуль врагов — только с 2 игроками. Это наш расчёт на нашей сцене: в игре без пуль доля будет другой.
- Забытый бит не даёт ошибки. Пуля по-прежнему «смотрит» на врага, но враг на неё — нет, и пара отбрасывается.
explain()называет виноватую сторону, аoneSided()находит такую связь во всей таблице сразу; в масках из списка пар односторонних связей нет. - Группа перекрыла маски. После добавления пары
pbullet — playerпуля игрока 1 могла бы попасть в него самого, но общая группа -1 это запрещает. В игрока 2 из группы -2 она попадает, а сами игроки по-прежнему проходят друг сквозь друга: парыplayer — playerв списке нет. - 33-й слой не завёлся. Без проверки в
defineLayers()он получил бы бит1 << 32, то есть 1, и совпал бы со стенами.
Чтобы подключить модуль к игре, достаточно вызывать canCollide() для каждой пары из широкой фазы до проверки прямоугольников. Объекты, которые постоянно создаются и удаляются, вроде пуль, удобно брать из пула, как в статье о спавне и пулах: категорию, маску и группу тогда нужно сбрасывать при каждой выдаче объекта из пула, иначе пуля игрока 2 унаследует группу игрока 1.
Фильтр, сенсор и реакция: кто за что отвечает
Маска решает только, встретятся ли двое; что произойдёт при встрече, решают сенсор и код реакции. Это три отдельных вопроса, и путать их — частая причина запутанных масок.
| Вопрос | Кто отвечает | Пример |
|---|---|---|
| Проверять ли пару вообще? | категория, маска, группа | пуля врага не проверяется с предметами |
| Выталкивать или только сообщить? | флаг сенсора (триггера) | предмет — сенсор: игрок проходит сквозь и подбирает его |
| Что сделать после касания? | код реакции по паре слоёв | pbullet — enemy: урон врагу, пулю вернуть в пул |
Предмет в нашем примере — сенсор: у него есть слой и маска, но выталкивать игрока он не должен. В Box2D это флаг isSensor на форме, в Matter.js — isSensor на теле, в Godot — отдельный тип узла Area2D. Разница между твёрдым коллайдером и триггером подробно описана в статье об игровом цикле и столкновениях.
Реакцию удобно выбирать по той же паре слоёв, которая прошла фильтр: таблица обработчиков с ключом «слой A + слой B». Тогда новая механика — это строка в списке пар и функция в таблице, а не правка десятка условий.
Ещё одно следствие разделения: временно отключить столкновения, например на время неуязвимости после удара, лучше флагом, а не обнулением маски. Маску потом нужно восстановить точно, а флаг просто снимается. Документация Box2D отдельно предупреждает, что смена фильтра у уже созданной формы дорогая: движок уничтожает её контакты.
Практический сценарий: шутер на двоих с режимом «каждый сам за себя»
Задача: в готовом кооперативном шутере с видом сверху добавить режим, где игроки стреляют друг в друга, не сломав кооператив. Входные условия — шесть слоёв и восемь пар из таблицы выше, два игрока, 40 врагов, до 200 пуль игроков и 80 пуль врагов на экране, стены — тайловая сетка.
Порядок работы:
- Записать список пар словами до кода: кто с кем сталкивается в кооперативе и что меняется в новом режиме. Здесь меняется одна строка: появляется пара
pbullet — player. - Собрать маски из списка функцией
buildMasks()для каждого режима отдельно. Два списка правил — два набора масок, без условий «если режим такой-то» в проверке столкновений. - Раздать группы: игроку 1 и всем его пулям — -1, игроку 2 и его пулям — -2. В кооперативе группы не мешают: пары
pbullet — playerтам нет вовсе. - Прогнать проверку симметрии
oneSided()на обоих наборах. Пустой список — можно идти дальше. - Проверить контрольные пары через
explain(): своя пуля → свой игрок — «группа, никогда»; своя пуля → соперник — «да»; игрок → игрок — «нет». Ровно эти три строки есть в выводе прогона. - Сбросить группу при выдаче пули из пула, иначе пуля, выпущенная игроком 2, может прийти с группой игрока 1 от прошлого выстрела.
- Вывести слой и маску в отладочный оверлей рядом с хитбоксом. Как сделать такой оверлей, описано в статье про отладочный оверлей; для масок хватает подписи вида
pbullet 000101 g-1над объектом.
Проверочный результат: в кооперативе ни одна пуля игрока не задевает игроков, в новом режиме пуля задевает только соперника, а число пар после фильтра в кооперативе осталось прежним, 8300 из 61 776. Честность попаданий в таком режиме зависит ещё и от того, насколько хорошо видны пули; об этом — в статье про run-and-gun и читаемость пуль.
Когда вам это не подойдёт
Слои и маски хороши, когда типов объектов немного, а правил между ними — таблица; в остальных случаях они либо лишние, либо недостаточны:
- Три-четыре типа объектов. В «Змейке» или пинг-понге два-три вида объектов и одна-две пары; условие
ifпо типу короче и понятнее, чем битовая таблица. - Правило зависит от состояния, а не от типа. «Враг не сталкивается с игроком, пока тот в рывке», «пуля пролетает сквозь союзника, если у него щит». Это не слой, а условие в момент контакта: в Box2D для этого есть пользовательский фильтр и обратный вызов перед решением контакта, в своём коде — проверка флагов после маски.
- Односторонние платформы. Сквозь платформу можно прыгнуть снизу, но стоять на ней сверху. Маской это не выразить: слой один и тот же, разница — в направлении движения. Решается по нормали и скорости в момент контакта.
- Больше 32 типов с разными правилами. На обычных числах JavaScript маска закончится.
BigIntили две маски решают задачу, но сначала стоит проверить, не дублируют ли слои друг друга: часто «огненный враг» и «ледяной враг» сталкиваются одинаково и должны быть одним слоем. - Вы используете готовый физический движок. Тогда не пишите свой фильтр поверх: настраивайте его встроенные категории, маски и группы, а код из статьи берите как образец таблицы пар и проверки симметрии.
Мы разрабатываем J2DRU — браузерный 2D игровой движок, где логика собирается из событий, условий и действий, а проект можно углублять на TypeScript. Движок в разработке и публично пока не открыт, заявку можно оставить на странице раннего доступа (подача заявки не гарантирует приглашение).
Источники (проверено: ноябрь 2026, 11.11.2026): Box2D Documentation — Simulation, раздел Filtering (64 категории, categoryBits и maskBits типа uint64_t, правило (catA & maskB) != 0 && (catB & maskA) != 0, groupIndex: положительная группа — всегда сталкиваются, отрицательная — никогда, группа важнее масок; пример с велосипедистом; совет описывать, что должно сталкиваться; смена фильтра дорогая, контакты уничтожаются; isSensor; пользовательский фильтр и pre-solve); Matter.js 0.20.0 — Matter.Body (collisionFilter.category, mask, group: 32 категории, категория по умолчанию 0x0001, правила групп и масок, Body.nextGroup, isSensor); Godot Engine 4.7 — Physics introduction, Collision layers and masks (collision_layer и collision_mask, 32 слоя, по умолчанию слой 1 и маска 1, нумерация слоёв с 1, пример маски 0b1101 = 13 для слоёв 1, 3 и 4, set_collision_mask_value(), Area2D); MDN — Left shift (для чисел результат — 32-битное целое, сдвиг по модулю 32, для BigInt без усечения). Слои, список пар, сцена из 352 объектов, доля 13,4% и все числа прогона — наш пример и наш расчёт в Node.js 24.22.1.
Читайте также:
- Игровой цикл (Game Loop) и физика столкновений (AABB, хитбоксы и триггеры) простыми словами и на уровне профи
- Пространственное хеширование: столкновения сотен объектов без проверки «каждый с каждым»
- Слои отрисовки и порядок глубины: Z-order и сортировка по Y в 2D
- Спавн и удаление объектов в 2D-игре: время жизни, отложенное удаление и пулы
- Отладочный оверлей на JavaScript: хитбоксы, FPS и журнал событий
- Run-and-gun: от Contra (1987) до Cuphead (2017) — стрельба в 8 направлениях и читаемость пуль