Маски и слои столкновений: кто с кем сталкивается, на битовых масках

Коротко

Слои столкновений отвечают на вопрос «нужно ли вообще проверять эту пару»: у каждого объекта есть категория — один бит его слоя — и маска — биты слоёв, с которыми он готов сталкиваться. В Box2D и Matter.js пара проходит фильтр, только если каждый есть в маске другого, а общая ненулевая группа перекрывает маски. Маски надёжнее получать из таблицы пар «кто с кем», чем набирать вручную: в нашем шутере из 352 объектов фильтр оставил 8300 пар из 61 776, а один забытый бит сделал пули игрока призрачными.

Содержание

  1. Зачем фильтровать пары до проверки геометрии
  2. Категория и маска: два числа на объект
  3. Двустороннее правило: каждый должен видеть другого
  4. Таблица «кто с кем» вместо ручных масок
  5. Группы: когда свои не сталкиваются
  6. Ловушки 32 бит в JavaScript
  7. Код на JavaScript и проверка в Node.js
  8. Фильтр, сенсор и реакция: кто за что отвечает
  9. Практический сценарий: шутер на двоих с режимом «каждый сам за себя»
  10. Когда вам это не подойдёт

Зачем фильтровать пары до проверки геометрии

Фильтр по слоям нужен, чтобы игра не спрашивала у геометрии то, ответ на что заранее известен: пуля игрока никогда не должна задевать монету, а монета — врага. Проверка прямоугольников AABB, разобранная в статье об игровом цикле и столкновениях, дешёвая, но после неё идёт реакция: выталкивание, урон, звук. Если пара прошла геометрию, а логика потом решает «а, это монета и вражеская пуля, ничего не делаем», в коде появляется цепочка if (a.type === … && b.type === …), которая растёт с каждым новым типом объекта.

Битовая маска заменяет эту цепочку одной операцией & над двумя числами. Она отвечает только на один вопрос — «могут ли эти двое столкнуться вообще» — и делает это до любых координат.

Фильтр и пространственный хеш из статьи о столкновениях сотен объектов решают разные задачи и хорошо работают вместе. Хеш отбрасывает пары, которые далеко друг от друга. Маска отбрасывает пары, которым нечего делать друг с другом, даже если они стоят вплотную. Порядок обычно такой:

широкая фаза (хеш, сетка)   → пары, которые рядом
фильтр по маскам            → пары, которым есть дело друг до друга
узкая фаза (AABB, круги)    → пары, которые действительно пересеклись
реакция                     → выталкивание, урон, подбор

Фильтр можно поставить и перед хешем: тогда в хеш кладут только одну из групп, как в разделе «Хешируйте меньшую группу» той же статьи. Маски делают этот приём общим: группа — это просто набор битов.

Категория и маска: два числа на объект

Категория — это слой, в котором объект находится, а маска — слои, на которые он смотрит; оба поля — целые числа, где каждый бит означает один слой. Слой номер i — это число 1 << i: слой 0 — 1, слой 1 — 2, слой 2 — 4 и так далее.

Шесть слоёв шутера с видом сверху выглядят так:

СлойБитКатегория (двоичная)Десятичная
wall — стены00000011
player — игроки10000102
enemy — враги20001004
pbullet — пули игроков30010008
ebullet — пули врагов401000016
pickup — подбираемые предметы510000032

Маска собирается операцией «или» из категорий интересных слоёв. Пуля игрока должна останавливаться о стены и попадать во врагов, значит её маска — wall | enemy = 1 + 4 = 5, в двоичном виде 000101. Проверка «есть ли слой X в маске» — это (mask & X) !== 0.

Названия у движков разные, смысл один:

ДвижокКатегорияМаскаСлоёвПо умолчанию
Godot 4collision_layercollision_mask32слой 1, маска 1
Matter.js 0.20collisionFilter.categorycollisionFilter.mask32категория 0x0001
Box2D 3.xfilter.categoryBitsfilter.maskBits64—

У 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. В прогоне ниже это дало:

СлойМаска (двоичная)ШестнадцатеричнаяКого видит
wall0111100x1eигроков, врагов, оба вида пуль
player1101010x35стены, врагов, пули врагов, предметы
enemy0010110xbстены, игроков, пули игроков
pbullet0001010x5стены, врагов
ebullet0000110x3стены, игроков
pickup0000100x2игроков

Набирать такие числа руками — значит рано или поздно ошибиться в одном бите. Генерация из списка пар убирает целый класс ошибок, и список пар заодно служит документацией.

Группы: когда свои не сталкиваются

Группа — это третье число, которое перекрывает маски: если у двух объектов одинаковая ненулевая группа, положительная разрешает столкновение всегда, отрицательная запрещает всегда. Так правило описано и в 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 << 301073741824обычное положительное число
1 << 31-2147483648старший бит — знак
(1 << 31) >>> 02147483648>>> 0 переводит в беззнаковое
1 << 321сдвиг по модулю 32: 33-й слой совпал с первым
~0-1«все слои», но со знаком
~0 >>> 04294967295 = 0xffffffff«все слои» без знака

Две из этих строк опасны молча. 1 << 32 не выдаёт ошибку: 33-й слой просто становится первым, и пули начинают сталкиваться со стенами, которых не должны видеть. А отрицательная категория 32-го слоя ломает сравнения вида mask > 0 и вывод в отладке, хотя сама проверка (a & b) !== 0 остаётся верной.

Правила, которые снимают обе проблемы:

  1. Проверять в маске только !== 0, никогда не > 0.
  2. Хранить и выводить маски через >>> 0, чтобы в журнале было положительное число.
  3. Падать с ошибкой, если слоёв больше 32, а не молча сдвигать дальше. Функция defineLayers() ниже так и делает.
  4. Если слоёв действительно больше 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 пуль врагов на экране, стены — тайловая сетка.

Порядок работы:

  1. Записать список пар словами до кода: кто с кем сталкивается в кооперативе и что меняется в новом режиме. Здесь меняется одна строка: появляется пара pbullet — player.
  2. Собрать маски из списка функцией buildMasks() для каждого режима отдельно. Два списка правил — два набора масок, без условий «если режим такой-то» в проверке столкновений.
  3. Раздать группы: игроку 1 и всем его пулям — -1, игроку 2 и его пулям — -2. В кооперативе группы не мешают: пары pbullet — player там нет вовсе.
  4. Прогнать проверку симметрии oneSided() на обоих наборах. Пустой список — можно идти дальше.
  5. Проверить контрольные пары через explain(): своя пуля → свой игрок — «группа, никогда»; своя пуля → соперник — «да»; игрок → игрок — «нет». Ровно эти три строки есть в выводе прогона.
  6. Сбросить группу при выдаче пули из пула, иначе пуля, выпущенная игроком 2, может прийти с группой игрока 1 от прошлого выстрела.
  7. Вывести слой и маску в отладочный оверлей рядом с хитбоксом. Как сделать такой оверлей, описано в статье про отладочный оверлей; для масок хватает подписи вида 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.

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

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

Чем категория отличается от маски?

Категория говорит, кто этот объект: в каком слое он находится, обычно ровно один бит. Маска говорит, кого объект готов замечать: в ней столько битов, сколько слоёв ему интересно. Пуля игрока — категория pbullet, маска «стены и враги».

Почему пуля проходит сквозь врага, хотя в маске пули враг есть?

В Box2D и Matter.js столкновение требует согласия обеих сторон: категория пули должна быть в маске врага, а категория врага — в маске пули. Если маску врага собрали руками и забыли пули, пара отбрасывается молча. Строите маски из списка пар — и такая ошибка невозможна.

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

Дать игроку и его пулям одну отрицательную группу, например -1, а второму игроку и его пулям — -2. Одинаковая отрицательная группа запрещает столкновение независимо от масок, а пары из разных групп проверяются по маскам как обычно.

Сколько слоёв можно завести?

Зависит от движка: в Godot 32 слоя, в Matter.js 32 категории, в текущей документации Box2D — 64. В своём коде на JavaScript удобный предел — 32, потому что побитовые операции над обычными числами работают с 32-битными целыми; для большего числа слоёв нужен BigInt или два числа.