Издатель и подписчик в игре: порядок доставки событий, отписка и утечки памяти

Коротко

Шина событий отделяет того, кто сообщает о попадании, от звука, счёта и здоровья, которые на него реагируют, но порядок их вызова нужно задавать явно — приоритетом, а не порядком подписки. Рассылка идёт по снимку списка обработчиков, поэтому отписка во время события ничего не ломает, а события, порождённые другими событиями, лучше класть в очередь и разбирать в конце кадра с лимитом. Каждый объект, который подписался, обязан отписаться при удалении: в нашем прогоне 20 волн по 30 врагов без отписки оставили 600 обработчиков.

Содержание

  1. Зачем игре издатель и подписчик
  2. Порядок доставки: приоритет вместо случайности
  3. Отписка во время рассылки
  4. Событие внутри события: сразу или в очередь
  5. Утечки: подписчик, который пережил объект
  6. Код на JavaScript
  7. Практический сценарий: смерть врага
  8. Когда вам это не подойдёт

Зачем игре издатель и подписчик

Издатель и подписчик нужны, чтобы код, где враг получает удар, не вызывал напрямую звук, счёт, тряску камеры и достижения. Враг сообщает emit('hit', данные), а каждый модуль сам подписывается через on('hit', обработчик). Новый модуль добавляется без правки врага, а удалённый модуль не ломает остальные.

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

ВопросПравило в нашей шине
Кто вызывается первымбольший priority, при равном — порядок подписки
Что если подписчик отписался во время рассылкитекущая рассылка идёт по снимку, со следующей его нет
Что если обработчик породил новое событиеemit — сразу, post — в очередь до конца кадра
Кто отписываеттот, кто подписался, через функцию, которую вернул on

Порядок доставки: приоритет вместо случайности

Порядок доставки задают приоритетом, потому что порядок подписки зависит от порядка загрузки модулей и меняется при любой перестановке импортов. Типичная ошибка: интерфейс показывает здоровье до того, как модуль здоровья его уменьшил, и полоса отстаёт на одно попадание.

Правило из нашего примера: модуль здоровья подписан с приоритетом 10, звук и счёт — с 0. Вывод прогона — здоровье → звук → счёт, хотя здоровье подписалось последним. Приоритетов должно быть мало, 2–3 уровня; если их десяток, это признак того, что модулям нужны отдельные события, например hit и hitResolved.

Отписка во время рассылки

Отписка во время рассылки безопасна, если рассылка перебирает снимок списка, а отписка создаёт новый массив вместо удаления из текущего. Если удалять элемент из массива, по которому идёт цикл, следующий обработчик сдвигается на место удалённого и пропускается.

Отсюда честное правило, которое стоит записать в комментарий: подписчик, отписанный во время рассылки, ещё получит текущее событие, если он в снимке, и не получит следующее. В прогоне обработчик A при первом tick отписывает себя и B; B всё равно получает первый tick, а второй tick не получает никто. На этом же устроен once — подписка, которая снимает себя при первом вызове: два события coin дали 1 бонус и 0 оставшихся обработчиков.

Событие внутри события: сразу или в очередь

Вложенное событие, отправленное через emit, обрабатывается немедленно — раньше, чем остальные подписчики исходного события. Когда враг умирает, обработчик смерти начисляет очки, и если сделать это через emit, счёт обновится до того, как второй подписчик смерти выбросит награду. Через post событие встаёт в очередь, и порядок получается died 7 | drop | score +100.

Очередь разбирается в конце кадра методом flush с лимитом. Лимит нужен против цепочек, где обработчик сам себе отправляет событие: без него кадр не закончится. В прогоне цепочка ping → ping остановилась на 100 событиях, одно осталось в очереди на следующий кадр. Если лимит срабатывает, это ошибка в логике, и в отладочной сборке её стоит выводить в консоль.

Утечки: подписчик, который пережил объект

Утечка подписок возникает, когда объект удалён из игры, а его обработчик остался в шине и держит ссылку на объект. Сборщик мусора такой объект не освободит, а обработчик продолжит вызываться: в прогоне 20 волн по 30 врагов без отписки дали 600 обработчиков на playerMoved и 600 вызовов на одно движение игрока. С отпиской в конце волны — 0.

Рецепт: on возвращает функцию отписки, объект складывает такие функции в свой список и вызывает их при удалении. Отложенное удаление объектов разобрано в статье про спавн и пулы, а уборка подписок при смене сцены — в статье про сцены, ссылки в конце.

Код на JavaScript

Код содержит шину с приоритетами, снимком при рассылке, once, очередью с лимитом и проверку утечек. Он запускается в Node.js 24, вывод совпадает с комментариями.

function makeBus() {
  const handlers = new Map(); // имя -> массив { fn, priority }
  const queue = [];
  let dispatching = false;
  const bus = {
    on(name, fn, priority = 0) {
      const list = handlers.get(name) ?? [];
      list.push({ fn, priority });
      list.sort((a, b) => b.priority - a.priority); // сортировка стабильная: при равном приоритете — порядок подписки
      handlers.set(name, list);
      return () => {
        const cur = handlers.get(name) ?? [];
        handlers.set(name, cur.filter((h) => h.fn !== fn)); // новый массив, текущая рассылка не ломается
      };
    },
    once(name, fn, priority = 0) {
      const off = bus.on(name, (data) => { off(); fn(data); }, priority);
      return off;
    },
    emit(name, data) { // сразу
      for (const h of handlers.get(name) ?? []) h.fn(data); // перебираем снимок массива
    },
    post(name, data) { // в очередь, разбор в конце кадра
      queue.push({ name, data });
    },
    flush(limit = 100) {
      if (dispatching) return 0;
      dispatching = true;
      let n = 0;
      while (queue.length && n < limit) { const e = queue.shift(); bus.emit(e.name, e.data); n++; }
      dispatching = false;
      return n;
    },
    count(name) { return handlers.get(name)?.length ?? 0; },
    pending() { return queue.length; },
  };
  return bus;
}

// 1. Порядок доставки
const bus = makeBus();
const order = [];
bus.on('hit', () => order.push('звук'));
bus.on('hit', () => order.push('счёт'));
bus.on('hit', () => order.push('здоровье'), 10);
bus.emit('hit');
console.log(order.join(' → ')); // здоровье → звук → счёт

// 2. Отписка во время рассылки
const got = [];
const offA = bus.on('tick', () => { got.push('A'); offA(); offB(); });
const offB = bus.on('tick', () => got.push('B'));
bus.emit('tick'); bus.emit('tick');
console.log(got.join(' ')); // A B — B получил первое событие из снимка, второе не получил никто

// 3. once
let bonus = 0;
bus.once('coin', () => bonus++);
bus.emit('coin'); bus.emit('coin');
console.log(bonus, bus.count('coin')); // 1 0

// 4. Цепочка: событие внутри события
const chain = [];
bus.on('enemyDied', (e) => { chain.push('died ' + e.id); bus.post('scoreChanged', 100); });
bus.on('scoreChanged', (s) => chain.push('score +' + s));
bus.on('enemyDied', () => chain.push('drop'));
bus.emit('enemyDied', { id: 7 });
bus.flush();
console.log(chain.join(' | ')); // died 7 | drop | score +100

// 5. Бесконечная цепочка ограничена лимитом
const loop = makeBus();
loop.on('ping', () => loop.post('ping'));
loop.post('ping');
console.log(loop.flush(100), loop.pending()); // 100 1

// 6. Утечка: враги подписываются и удаляются без отписки
const leak = makeBus();
let calls = 0;
for (let wave = 0; wave < 20; wave++) {
  for (let i = 0; i < 30; i++) leak.on('playerMoved', () => { calls++; });
}
leak.emit('playerMoved');
console.log(leak.count('playerMoved'), calls); // 600 600

const clean = makeBus();
for (let wave = 0; wave < 20; wave++) {
  const offs = [];
  for (let i = 0; i < 30; i++) offs.push(clean.on('playerMoved', () => {}));
  offs.forEach((off) => off()); // волна закончилась — отписали всех
}
console.log(clean.count('playerMoved')); // 0

Сортировка при каждой подписке стоит O(n log n); для десятков подписчиков на событие это незаметно, а если их тысячи, держите отдельные массивы по приоритетам.

Практический сценарий: смерть врага

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

  1. Событие. Враг при смерти вызывает emit('enemyDied', { id, x, y, reward }) и больше ничего не знает.
  2. Приоритеты. Счётчик живых врагов — приоритет 10, награда и очки — 0.
  3. Очередь. Очки начисляются через post('scoreChanged', reward), проверка конца волны подписана на scoreChanged и тоже уходит в очередь через post('waveCheck').
  4. Разбор. В конце кадра flush(100): сначала очки, потом проверка волны — экран победы видит уже итоговый счёт.
  5. Отписка. Каждый враг, который подписывался, например на playerMoved, хранит функции отписки и вызывает их при удалении.
  6. Проверка. После 20 волн число обработчиков playerMoved равно числу живых врагов, а не числу всех когда-либо созданных.

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

Шина событий полезна для связей «один ко многим», но не для всех случаев:

  • Строгая последовательность из 2–3 шагов. Если после удара всегда нужно уменьшить здоровье и обновить полосу, прямой вызов функции понятнее и проще в отладке, чем событие с приоритетами.
  • Горячий цикл. Сотни снарядов, которые каждый кадр сообщают о позиции, дешевле обработать одним циклом по массиву, чем тысячами emit.
  • Нужен ответ. Шина рассылает сообщения, но не возвращает результат. Вопрос «можно ли открыть дверь» — это вызов функции, а не событие.
  • Маленькая игра в одном файле. Для мини-игры на 300 строк шина добавит слой, который сложнее читать, чем сам код.

Мы разрабатываем J2DRU — браузерный 2D игровой движок, где логика собирается из событий, условий и действий, а проект можно углублять на TypeScript. Движок в разработке и публично пока не открыт, заявку можно оставить на странице раннего доступа (подача заявки не гарантирует приглашение).

Источники: внешних фактов в статье нет. Приоритеты, лимит очереди 100, число волн и врагов и все выводы — наш пример и наш прогон в Node.js 24.

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

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

Что такое шина событий в игре?

Это объект с методами on, emit и функцией отписки: одна часть игры сообщает о событии, например «игрок получил урон», а звук, счёт и интерфейс подписаны на него и реагируют, не зная друг о друге.

В каком порядке вызываются подписчики?

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

Почему нельзя вызывать emit внутри обработчика?

Можно, но тогда второе событие обработается раньше, чем остальные подписчики первого. Если важен порядок, кладите вложенное событие в очередь через post и разбирайте её в конце кадра.

Как найти утечку подписок?

Выведите число обработчиков каждого события после нескольких волн или перезапусков уровня. Если оно растёт вместе с числом созданных объектов, кто-то подписывается и не отписывается.