---
title: "Маски и слои столкновений: кто с кем сталкивается, на битовых масках"
description: "Как в 2D-игре решить, какие объекты вообще проверять на столкновение: категория и маска как два числа на объект, правило «каждый есть в маске другого» из Box2D и Matter.js, группы для своих, таблица «кто с кем» вместо ручных масок и ловушки 32-битных операций JavaScript. Код проверен в Node.js 24."
slug: maski-i-sloi-stolknovenij-kto-s-kem-stalkivaetsya-na-bitovyh-maskah
date: 2026-11-16
updated: 2026-11-16
scheduled_at: "2026-11-16T09:00:00+03:00"
rubric: ustrojstvo-2d-igr
tags: ["fizika", "stolknoveniya", "bitovye-maski", "javascript", "razrabotchikam"]
reading_time: 23
draft: false
summary: "Слой столкновений — это один бит в числе: у объекта есть категория (в каком он слое) и маска (с какими слоями готов сталкиваться). В Box2D и Matter.js пара проходит фильтр, только если каждый есть в маске другого, а одинаковая ненулевая группа перекрывает маски: положительная — всегда сталкиваются, отрицательная — никогда. Маски надёжнее строить из таблицы пар «кто с кем», а не набирать руками: в нашем примере шутера фильтр оставил 8300 пар из 61 776 (13,4%), а забытый бит в маске врага сделал пули игрока призрачными. В JavaScript побитовые операции 32-битные: 1 << 31 даёт отрицательное число, а 1 << 32 — снова 1."
---

## Коротко

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

## Содержание

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

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

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

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

Фильтр и пространственный хеш из статьи о [столкновениях сотен объектов](/blog/prostranstvennoe-heshirovanie-stolknoveniya-soten-obektov-bez-perebora) решают разные задачи и хорошо работают вместе. Хеш отбрасывает пары, которые далеко друг от друга. Маска отбрасывает пары, которым нечего делать друг с другом, даже если они стоят вплотную. Порядок обычно такой:

```text
широкая фаза (хеш, сетка)   → пары, которые рядом
фильтр по маскам            → пары, которым есть дело друг до друга
узкая фаза (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](/blog/sloi-otrisovki-i-poryadok-glubiny-z-order-i-sortirovka-po-y-v-2d), и смешивать эти два понятия в одном поле `layer` — верный способ получить врага, который перестал сталкиваться, потому что его перенесли «на передний план».

## Двустороннее правило: каждый должен видеть другого

В Box2D и Matter.js пара сталкивается, только если категория A есть в маске B и категория B есть в маске A одновременно. Документация Box2D записывает это так:

```text
(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`.

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

```text
          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` остаётся верной.

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

1. Проверять в маске только `!== 0`, никогда не `> 0`.
2. Хранить и выводить маски через `>>> 0`, чтобы в журнале было положительное число.
3. Падать с ошибкой, если слоёв больше 32, а не молча сдвигать дальше. Функция `defineLayers()` ниже так и делает.
4. Если слоёв действительно больше 32 — переходить на `BigInt` (`1n << 40n` работает) или хранить маску двумя числами. Чаще это повод пересмотреть слои: 32 типа объектов, которым нужны разные правила столкновений, — много для 2D-игры.

## Код на JavaScript и проверка в Node.js

Модуль ниже ничего не рисует и не двигает: он заводит слои, строит маски из списка пар, проверяет пару с учётом групп и объясняет, почему пара не сталкивается. Запуск — Node.js 24.22.1, вывод прогона приведён в конце раздела и совпадает с числами в тексте.

```js
/** 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 бит:

```js
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`):

```text
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()` для каждой пары из широкой фазы до проверки прямоугольников. Объекты, которые постоянно создаются и удаляются, вроде пуль, удобно брать из пула, как в статье о [спавне и пулах](/blog/spavn-i-udalenie-obektov-v-2d-igre-vremya-zhizni-i-puly): категорию, маску и группу тогда нужно сбрасывать при каждой выдаче объекта из пула, иначе пуля игрока 2 унаследует группу игрока 1.

## Фильтр, сенсор и реакция: кто за что отвечает

Маска решает только, встретятся ли двое; что произойдёт при встрече, решают сенсор и код реакции. Это три отдельных вопроса, и путать их — частая причина запутанных масок.

| Вопрос | Кто отвечает | Пример |
|---|---|---|
| Проверять ли пару вообще? | категория, маска, группа | пуля врага не проверяется с предметами |
| Выталкивать или только сообщить? | флаг сенсора (триггера) | предмет — сенсор: игрок проходит сквозь и подбирает его |
| Что сделать после касания? | код реакции по паре слоёв | `pbullet — enemy`: урон врагу, пулю вернуть в пул |

Предмет в нашем примере — сенсор: у него есть слой и маска, но выталкивать игрока он не должен. В Box2D это флаг `isSensor` на форме, в Matter.js — `isSensor` на теле, в Godot — отдельный тип узла `Area2D`. Разница между твёрдым коллайдером и триггером подробно описана в статье об [игровом цикле и столкновениях](/blog/igrovoj-cikl-i-fizika-stolknovenij-aabb).

Реакцию удобно выбирать по той же паре слоёв, которая прошла фильтр: таблица обработчиков с ключом «слой 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. **Вывести слой и маску в отладочный оверлей** рядом с хитбоксом. Как сделать такой оверлей, описано в статье про [отладочный оверлей](/blog/otladochnyj-overlej-na-javascript-hitboksy-fps-i-zhurnal-sobytij); для масок хватает подписи вида `pbullet 000101 g-1` над объектом.

Проверочный результат: в кооперативе ни одна пуля игрока не задевает игроков, в новом режиме пуля задевает только соперника, а число пар после фильтра в кооперативе осталось прежним, 8300 из 61 776. Честность попаданий в таком режиме зависит ещё и от того, насколько хорошо видны пули; об этом — в статье про [run-and-gun и читаемость пуль](/blog/run-and-gun-ot-contra-do-cuphead-strelba-v-8-napravlenij-i-chitaemost-pul).

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

Слои и маски хороши, когда типов объектов немного, а правил между ними — таблица; в остальных случаях они либо лишние, либо недостаточны:

- **Три-четыре типа объектов.** В «Змейке» или пинг-понге два-три вида объектов и одна-две пары; условие `if` по типу короче и понятнее, чем битовая таблица.
- **Правило зависит от состояния, а не от типа.** «Враг не сталкивается с игроком, пока тот в рывке», «пуля пролетает сквозь союзника, если у него щит». Это не слой, а условие в момент контакта: в Box2D для этого есть пользовательский фильтр и обратный вызов перед решением контакта, в своём коде — проверка флагов после маски.
- **Односторонние платформы.** Сквозь платформу можно прыгнуть снизу, но стоять на ней сверху. Маской это не выразить: слой один и тот же, разница — в направлении движения. Решается по нормали и скорости в момент контакта.
- **Больше 32 типов с разными правилами.** На обычных числах JavaScript маска закончится. `BigInt` или две маски решают задачу, но сначала стоит проверить, не дублируют ли слои друг друга: часто «огненный враг» и «ледяной враг» сталкиваются одинаково и должны быть одним слоем.
- **Вы используете готовый физический движок.** Тогда не пишите свой фильтр поверх: настраивайте его встроенные категории, маски и группы, а код из статьи берите как образец таблицы пар и проверки симметрии.

Мы разрабатываем **J2DRU** — браузерный 2D игровой движок, где логика собирается из событий, условий и действий, а проект можно углублять на TypeScript. Движок в разработке и публично пока не открыт, заявку можно оставить на [странице раннего доступа](/early-access?utm_source=blog&utm_medium=article&utm_campaign=maski-i-sloi-stolknovenij-kto-s-kem-stalkivaetsya-na-bitovyh-maskah) (подача заявки не гарантирует приглашение).

**Источники (проверено: ноябрь 2026, 11.11.2026):** [Box2D Documentation — Simulation, раздел Filtering](https://box2d.org/documentation/md_simulation.html) (64 категории, `categoryBits` и `maskBits` типа `uint64_t`, правило `(catA & maskB) != 0 && (catB & maskA) != 0`, `groupIndex`: положительная группа — всегда сталкиваются, отрицательная — никогда, группа важнее масок; пример с велосипедистом; совет описывать, что должно сталкиваться; смена фильтра дорогая, контакты уничтожаются; `isSensor`; пользовательский фильтр и pre-solve); [Matter.js 0.20.0 — Matter.Body](https://brm.io/matter-js/docs/classes/Body.html) (`collisionFilter.category`, `mask`, `group`: 32 категории, категория по умолчанию `0x0001`, правила групп и масок, `Body.nextGroup`, `isSensor`); [Godot Engine 4.7 — Physics introduction, Collision layers and masks](https://docs.godotengine.org/en/stable/tutorials/physics/physics_introduction.html) (`collision_layer` и `collision_mask`, 32 слоя, по умолчанию слой 1 и маска 1, нумерация слоёв с 1, пример маски `0b1101` = 13 для слоёв 1, 3 и 4, `set_collision_mask_value()`, `Area2D`); [MDN — Left shift](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Left_shift) (для чисел результат — 32-битное целое, сдвиг по модулю 32, для BigInt без усечения). Слои, список пар, сцена из 352 объектов, доля 13,4% и все числа прогона — наш пример и наш расчёт в Node.js 24.22.1.

**Читайте также:**
- [Игровой цикл (Game Loop) и физика столкновений (AABB, хитбоксы и триггеры) простыми словами и на уровне профи](/blog/igrovoj-cikl-i-fizika-stolknovenij-aabb)
- [Пространственное хеширование: столкновения сотен объектов без проверки «каждый с каждым»](/blog/prostranstvennoe-heshirovanie-stolknoveniya-soten-obektov-bez-perebora)
- [Слои отрисовки и порядок глубины: Z-order и сортировка по Y в 2D](/blog/sloi-otrisovki-i-poryadok-glubiny-z-order-i-sortirovka-po-y-v-2d)
- [Спавн и удаление объектов в 2D-игре: время жизни, отложенное удаление и пулы](/blog/spavn-i-udalenie-obektov-v-2d-igre-vremya-zhizni-i-puly)
- [Отладочный оверлей на JavaScript: хитбоксы, FPS и журнал событий](/blog/otladochnyj-overlej-na-javascript-hitboksy-fps-i-zhurnal-sobytij)
- [Run-and-gun: от Contra (1987) до Cuphead (2017) — стрельба в 8 направлениях и читаемость пуль](/blog/run-and-gun-ot-contra-do-cuphead-strelba-v-8-napravlenij-i-chitaemost-pul)
