---
title: "Волны врагов на JavaScript: расписание, бюджет сложности и паузы"
description: "Как устроить волны врагов в браузерной 2D-игре: бюджет волны в очках стоимости, ритм «рост — пик — передышка», состав из доступных типов, расписание выпуска группами, пауза до следующей волны по зачистке или тайм-ауту и лимит живых врагов. Ориентиры Plants vs. Zombies и Left 4 Dead, модуль на JavaScript, проверенный в Node.js 24 шестью сценариями."
slug: volny-vragov-na-javascript-raspisanie-byudzhet-slozhnosti-i-pauzy
date: 2026-11-14
updated: 2026-11-14
scheduled_at: "2026-11-14T19:00:00+03:00"
rubric: praktika-i-uroki
tags: ["volny-vragov", "javascript", "gejmdizajn", "arkady", "razrabotchikam"]
reading_time: 25
draft: false
summary: "Волну врагов удобно описывать не списком врагов, а бюджетом: каждый тип стоит очки, волна n получает 6 + 3 × (n − 1) очков, каждая пятая волна — пик ×1,5, следующая за ней — передышка ×0,7. Состав набирают из доступных к этой волне типов, выпускают группами от дешёвых к дорогим, а следующую волну запускают через 3 секунды после зачистки, но не позже 20 секунд после последнего выпуска. Лимит живых врагов обязателен: в нашем прогоне без него игрок, который не успевает убивать, к 240-й секунде получил 101 врага на экране, с лимитом — 12."
---

## Коротко

Волну врагов удобнее задавать бюджетом: у каждого типа врага есть стоимость в очках, а волна номер n тратит 6 + 3 × (n − 1) очков, причём каждая пятая волна — пик ×1,5, а следующая — передышка ×0,7. Состав набирают из типов, открытых к этой волне, выпускают группами от дешёвых к дорогим, а следующую волну запускают через 3 секунды после зачистки, но не позже 20 секунд после последнего выпуска. Лимит живых врагов обязателен: в нашем прогоне без него игрок, который не убивает, к 240-й секунде получил 101 врага на экране, с лимитом — 12.

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

1. Из чего состоит волна
2. Бюджет волны: одна формула вместо списков
3. Ритм: рост, пик и передышка
4. Состав: какие враги и сколько
5. Расписание выпуска: группы и интервалы
6. Пауза между волнами: зачистка или тайм-аут
7. Точки появления и лимит живых
8. Код на JavaScript и проверка в Node.js
9. Обвязка для браузера
10. Практический сценарий: арена на 10 волн
11. Когда вам это не подойдёт

## Из чего состоит волна

Волна — это порция врагов с тремя решениями: кого выпустить, когда и откуда, и когда начинать следующую порцию. В Plants vs. Zombies (PopCap Games, 5 мая 2009 года) зомби идут волнами, с каждой отбитой волной их плотность растёт, а в конце уровня и часто в середине приходит особо крупная волна во главе с зомби с флагом. Эта схема — рост, пик, обязательная финальная волна — подходит почти любой аркаде с волнами: tower defense, арене, вертикальному шутеру.

Удобно разделить волну на пять независимых частей и настраивать их по отдельности:

| Часть | Вопрос | Параметры в нашем примере |
|---|---|---|
| Бюджет | насколько волна тяжелее предыдущей | база 6, шаг 3, пик каждые 5 волн |
| Состав | какие враги входят в бюджет | стоимость типов 1 / 2 / 5, дорогих — не больше половины бюджета |
| Расписание | в каком порядке и темпе выходят враги | интервал 0,6 с, между группами 2 с |
| Пауза | когда начинается следующая волна | 3 с после зачистки, не позже 20 с |
| Появление | где и сколько живых одновременно | не ближе 200 px к игроку, не больше 12 живых |

Все числа в таблице и дальше — наш пример для небольшой арены 640 × 360 px, а не стандарт жанра.

## Бюджет волны: одна формула вместо списков

Бюджет — это число очков, которое волна тратит на врагов, и рост сложности задаётся им, а не ручными списками «волна 7: 3 стрелка и 2 танка». Каждому типу назначают стоимость примерно по угрозе: сколько времени и внимания игрок тратит на этого врага.

```text
бюджет(n) = 6 + 3 × (n − 1)
если n делится на 5            → бюджет × 1,5  (пик)
если n − 1 делится на 5, n > 1 → бюджет × 0,7  (передышка)
результат округляется до целого
```

Стоимость типов в примере: бегун — 1, стрелок — 2, танк — 5. Стоимость — это отношение угроз, поэтому её проверяют плейтестом: если два стрелка ощущаются тяжелее танка, танк дешевле, чем записано. Когда стоимости честные, новый тип врага не ломает баланс: его просто добавляют в таблицу, и бюджет сам решает, сколько их войдёт.

## Ритм: рост, пик и передышка

Сложность волн должна расти не по прямой, а ступенями с пиками и короткими спадами после них. Майкл Бут из Valve в докладе об ИИ Left 4 Dead (AIIDE 2009) описывает такой цикл для режиссёра врагов: нарастание угрозы, удержание пика 3–5 секунд, спад до естественной паузы в бою и отдых 30–45 секунд с минимумом врагов. Там же он формулирует причину: постоянный бой утомляет, а долгое бездействие скучно. И отдельно подчёркивает, что алгоритм меняет темп, а не сложность.

В нашей формуле этот ритм заложен прямо в бюджет. Вот что она даёт для первых 10 волн (наш расчёт):

| Волна | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
|---|---|---|---|---|---|---|---|---|---|---|
| Бюджет | 6 | 9 | 12 | 15 | **27** | 15 | 24 | 27 | 30 | **50** |
| Роль | старт | рост | новый тип | рост | пик | передышка + новый тип | рост | рост | рост | финальный пик |

Два правила ритма:

- **Новый тип — в спокойную волну.** Стрелок открывается на 3-й волне, танк — на 6-й, сразу после пика. Игрок знакомится с танком, когда остальных врагов мало, а не в самой тяжёлой волне.
- **Пик — заметный.** Если пик всего на 10–20 % тяжелее соседей, игрок его не почувствует. У нас пик в 1,5 раза больше обычной волны, а финальная 10-я — в 1,67 раза тяжелее 9-й.

Подстраивать бюджет под конкретного игрока — отдельная задача; как это делать и почему опасно, разобрано в статье про кривую сложности и динамическую подстройку. Здесь кривая одна для всех.

## Состав: какие враги и сколько

Состав набирают из типов, открытых к номеру волны, пока остаются очки бюджета, и ограничивают долю дорогих врагов. Без ограничения бюджет 50 мог бы целиком уйти на 10 танков — это уже не волна, а стена.

Правила нашего рецепта:

1. **Доступность.** У типа есть номер волны, с которой он появляется (`from`).
2. **Доля дорогих.** На каждый тип дороже 1 очка тратится не больше 50 % бюджета.
3. **Остаток.** Бегун стоит 1, поэтому бюджет всегда тратится до нуля.
4. **Случайность с зерном.** Тип выбирается случайно, но генератором с зерном: при том же зерне волна та же, и найденную на плейтесте неудачную волну можно воспроизвести. Как сделать случайность честной — мешок без повторов, веса, зерно, — разобрано в статье про случайность без несправедливости.

## Расписание выпуска: группы и интервалы

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

Расписание волны из 6 бегунов, 3 стрелков и 1 танка при интервале 0,6 с и паузе между группами 2 с (наш прогон):

| Время от начала волны | Кто выходит |
|---|---|
| 0; 0,6; 1,2; 1,8; 2,4; 3,0 с | 6 бегунов |
| 5,0; 5,6; 6,2 с | 3 стрелка |
| 8,2 с | 1 танк |

Интервал 0,6 с — около 36 кадров при 60 кадрах в секунду: достаточно, чтобы враги не накладывались спрайтами в точке появления. Если враги всё же слипаются, интервал увеличивают или чередуют точки появления.

## Пауза между волнами: зачистка или тайм-аут

Следующую волну лучше запускать по двум условиям сразу: через короткую паузу после того, как убит последний враг, но не позже тайм-аута после последнего выпуска. У каждого условия по отдельности есть слабость:

| Правило | Плюс | Минус |
|---|---|---|
| Только по таймеру | предсказуемый темп, удобно под музыку | быстрый игрок скучает, медленный тонет |
| Только по зачистке | игрок сам задаёт темп | один застрявший враг в углу останавливает игру |
| Зачистка + 3 с, но не позже 20 с | быстрый не ждёт, застрявший враг не держит игру | нужен лимит живых, иначе волны накладываются |

Три секунды после зачистки — время подобрать награду и увидеть надпись о новой волне. Двадцать секунд — наш потолок для арены 640 × 360 px, где бегун доходит от края до игрока в центре за 2–4 секунды, а танк — за 7–11 (скорости 90 и 30 px/с из обвязки ниже); в tower defense с длинным путём тайм-аут больше.

## Точки появления и лимит живых

Враги появляются в точках за краем экрана по очереди, пропуская точки ближе 200 px к игроку, а одновременно живых врагов не больше 12. Очередь точек не даёт всей волне выйти с одной стороны, а запрет близких точек убирает удар из ниоткуда — враг, появившийся вплотную к герою, наносит урон раньше, чем его можно увидеть.

Лимит живых работает как пробка: если на экране уже 12 врагов, расписание волны замирает и продолжается, когда кого-то убьют. Без лимита тайм-аут из прошлого раздела запускает новые волны поверх неразобранных, и экран заполняется — это показал прогон ниже. Как появляются и удаляются объекты без лишней нагрузки на сборщик мусора, разобрано в статье про спавн, время жизни и пулы.

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

Модуль ниже считает бюджет, набирает состав, строит расписание, выбирает точку появления и ведёт волны по состояниям «пауза → выпуск → бой». Он ничего не рисует, поэтому проверяется в Node.js без браузера.

```js
// waves.mjs — волны врагов: бюджет, состав, расписание, паузы и лимит живых
// Типы врагов: cost — сколько «стоит» враг в бюджете волны, from — с какой волны доступен
export const TYPES = {
  runner:  { cost: 1, from: 1 },   // бегун: слабый и быстрый
  shooter: { cost: 2, from: 3 },   // стрелок: держит дистанцию
  tank:    { cost: 5, from: 6 },   // танк: медленный и прочный
};

// Генератор с зерном: одна и та же волна при одном зерне
export function rng(seed) {
  return () => { seed = (seed + 0x6D2B79F5) | 0; let t = seed;
    t = Math.imul(t ^ (t >>> 15), t | 1); t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
    return ((t ^ (t >>> 14)) >>> 0) / 4294967296; };
}

// Бюджет волны n: база + шаг за волну, каждая peakEvery-я волна — пик (×peakMul),
// волна сразу после пика — передышка (×restMul)
export function budget(n, { base = 6, step = 3, peakEvery = 5, peakMul = 1.5, restMul = 0.7 } = {}) {
  const b = base + step * (n - 1);
  if (n % peakEvery === 0) return Math.round(b * peakMul);
  if (n > 1 && (n - 1) % peakEvery === 0) return Math.round(b * restMul);
  return b;
}

// Состав: тратим бюджет на доступные типы; дорогих — не больше maxShare бюджета
export function compose(n, money, rand, { maxShare = 0.5 } = {}) {
  const open = Object.entries(TYPES).filter(([, t]) => t.from <= n);
  const out = {}, spent = {};
  let left = money;
  while (true) {
    const can = open.filter(([k, t]) => t.cost <= left &&
      (t.cost === 1 || (spent[k] ?? 0) + t.cost <= money * maxShare));
    if (!can.length) break;
    const [k, t] = can[Math.floor(rand() * can.length)];
    out[k] = (out[k] ?? 0) + 1; spent[k] = (spent[k] ?? 0) + t.cost; left -= t.cost;
  }
  return { units: out, left };
}

// Расписание: группы по типам, дорогие — последними; внутри группы интервал gap,
// между группами пауза groupGap. Возвращает [{ t, type }] в секундах от начала волны
export function schedule(units, { gap = 0.6, groupGap = 2 } = {}) {
  const order = Object.keys(units).sort((a, b) => TYPES[a].cost - TYPES[b].cost);
  const list = []; let t = 0;
  for (const type of order) {
    for (let i = 0; i < units[type]; i++) { list.push({ t: +t.toFixed(2), type }); t += gap; }
    t += groupGap - gap;
  }
  return list;
}

// Точка появления: по кругу, но не ближе minDist к игроку
export function pickPoint(points, player, cursor, minDist = 200) {
  for (let i = 0; i < points.length; i++) {
    const p = points[(cursor + i) % points.length];
    if (Math.hypot(p.x - player.x, p.y - player.y) >= minDist) return { p, next: (cursor + i + 1) % points.length };
  }
  return null; // все точки рядом с игроком — подождать
}

// Режиссёр волн: пауза → выпуск по расписанию → ожидание зачистки → пауза…
// Следующая волна: через minPause после зачистки, но не позже maxPause после последнего выпуска
const EPS = 1e-6;  // шаг 0,1 с в двоичной дроби не точен: 3 − 30 × 0,1 даёт не ровно 0

export function createDirector({ seed = 1, maxAlive = 12, minPause = 3, maxPause = 20, firstPause = 2 } = {}) {
  const rand = rng(seed);
  let n = 0, state = 'pause', timer = firstPause, queue = [], waveT = 0, sinceLast = 0;
  return {
    get wave() { return n; }, get state() { return state; },
    // dt — шаг в секундах, alive — сколько врагов живо; возвращает типы, которые выпустить сейчас
    update(dt, alive) {
      const out = [];
      if (state === 'pause') {
        timer -= dt;
        if (timer <= EPS) {
          n++; waveT = 0; state = 'spawn';
          queue = schedule(compose(n, budget(n), rand).units);
        }
      }
      if (state === 'spawn') {
        waveT += dt;
        while (queue.length && queue[0].t <= waveT + EPS && alive + out.length < maxAlive) out.push(queue.shift().type);
        if (queue.length && queue[0].t <= waveT + EPS) waveT -= dt;  // упёрлись в лимит — расписание ждёт
        if (!queue.length) { state = 'fight'; sinceLast = 0; }
      } else if (state === 'fight') {
        sinceLast += dt;
        if (alive === 0) { state = 'pause'; timer = minPause; }
        else if (sinceLast >= maxPause - EPS) { state = 'pause'; timer = 0; }
      }
      return out;
    },
  };
}
```

Проверка прогоняет шесть сценариев: бюджет и состав 10 волн, повтор волны по зерну, расписание, выбор точки появления и три типа игроков в симуляции на 240 секунд с шагом 0,1 с. Игрок в симуляции убивает фиксированное число врагов в секунду.

```js
import { budget, compose, schedule, rng, pickPoint, createDirector, TYPES } from './waves.mjs';

// 1. Бюджет и состав волн 1–10 (зерно 7)
const r = rng(7);
for (let n = 1; n <= 10; n++) {
  const b = budget(n), { units, left } = compose(n, b, r);
  const cost = Object.entries(units).reduce((s, [k, c]) => s + c * TYPES[k].cost, 0);
  console.log(`1) волна ${String(n).padStart(2)}: бюджет ${String(b).padStart(2)} | ` +
    Object.keys(TYPES).filter(k => units[k]).map(k => `${k}×${units[k]}`).join(' ') + ` | потрачено ${cost}, остаток ${left}`);
}

// 2. То же зерно — тот же состав
const a1 = JSON.stringify(compose(8, budget(8), rng(42)).units), a2 = JSON.stringify(compose(8, budget(8), rng(42)).units);
console.log('2) волна 8, зерно 42, два прогона:', a1, a1 === a2 ? '— совпали' : '— РАЗНЫЕ');

// 3. Расписание волны: 6 бегунов, 3 стрелка, 1 танк
const s = schedule({ tank: 1, runner: 6, shooter: 3 });
console.log('3) расписание:', s.map(e => `${e.t}с ${e.type}`).join(', '));

// 4. Точки появления: игрок стоит у левой точки
const points = [{ x: 0, y: 180 }, { x: 640, y: 180 }, { x: 320, y: 0 }];
let cur = 0; const got = [];
for (let i = 0; i < 4; i++) { const res = pickPoint(points, { x: 40, y: 180 }, cur); got.push(`(${res.p.x},${res.p.y})`); cur = res.next; }
console.log('4) игрок у (40,180), 4 выпуска:', got.join(' '));

// 5. Режиссёр: игрок убивает kill врагов в секунду; шаг 0,1 с, 240 с игры
function play(num, kill, label, opts = {}) {
  const d = createDirector({ seed: 7, ...opts });
  let alive = 0, maxSeen = 0, acc = 0, lastWave = 0; const starts = [];
  for (let step = 1; step <= 2400; step++) {
    const t = step / 10;                                   // время после этого шага
    alive += d.update(0.1, alive).length; maxSeen = Math.max(maxSeen, alive);
    if (d.wave !== lastWave) { starts.push(t); lastWave = d.wave; }
    acc = alive ? acc + kill * 0.1 : 0;   // пока врагов нет, «запас убийств» не копится
     const k = Math.min(alive, Math.floor(acc)); alive -= k; acc -= k;
  }
  const gaps = starts.slice(1).map((x, i) => +(x - starts[i]).toFixed(1));
  console.log(`${num}) ${label}: волн за 240 с — ${d.wave}, начала первых 6: ${starts.slice(0, 6).join(', ')} с; ` +
    `максимум живых ${maxSeen}; живых в конце ${alive}`);
  return gaps;
}
play(5, 2, 'быстрый игрок (2 врага/с)');
play(5, 0.5, 'медленный игрок (0,5 врага/с)');
play(5, 0, 'никого не убивает');

// 6. Никого не убивает, лимита живых нет — работает только тайм-аут паузы
play(6, 0, 'никого не убивает, без лимита живых', { maxAlive: Infinity });
```

Вывод прогона (проверено в Node.js 24.22.1, 11.11.2026):

```text
1) волна  1: бюджет  6 | runner×6 | потрачено 6, остаток 0
1) волна  2: бюджет  9 | runner×9 | потрачено 9, остаток 0
1) волна  3: бюджет 12 | runner×6 shooter×3 | потрачено 12, остаток 0
1) волна  4: бюджет 15 | runner×9 shooter×3 | потрачено 15, остаток 0
1) волна  5: бюджет 27 | runner×15 shooter×6 | потрачено 27, остаток 0
1) волна  6: бюджет 15 | runner×4 shooter×3 tank×1 | потрачено 15, остаток 0
1) волна  7: бюджет 24 | runner×2 shooter×6 tank×2 | потрачено 24, остаток 0
1) волна  8: бюджет 27 | runner×5 shooter×6 tank×2 | потрачено 27, остаток 0
1) волна  9: бюджет 30 | runner×5 shooter×5 tank×3 | потрачено 30, остаток 0
1) волна 10: бюджет 50 | runner×5 shooter×10 tank×5 | потрачено 50, остаток 0
2) волна 8, зерно 42, два прогона: {"shooter":6,"tank":2,"runner":5} — совпали
3) расписание: 0с runner, 0.6с runner, 1.2с runner, 1.8с runner, 2.4с runner, 3с runner, 5с shooter, 5.6с shooter, 6.2с shooter, 8.2с tank
4) игрок у (40,180), 4 выпуска: (640,180) (320,0) (640,180) (320,0)
5) быстрый игрок (2 врага/с): волн за 240 с — 17, начала первых 6: 2, 8.4, 16.6, 26.2, 37.6, 54.4 с; максимум живых 1; живых в конце 1
5) медленный игрок (0,5 врага/с): волн за 240 с — 10, начала первых 6: 2, 17, 38, 59, 86, 124.1 с; максимум живых 12; живых в конце 10
5) никого не убивает: волн за 240 с — 2, начала первых 6: 2, 25 с; максимум живых 12; живых в конце 12
6) никого не убивает, без лимита живых: волн за 240 с — 9, начала первых 6: 2, 25, 49.8, 76, 104, 137.4 с; максимум живых 101; живых в конце 101
```

Что показывают сценарии:

- **1. Бюджет и состав.** Бюджет тратится до нуля, стрелки появляются с 3-й волны, танк — с 6-й, в волне-передышке, и ровно один: при бюджете 15 на танки можно потратить не больше 7,5 очка. В финальной 10-й волне 5 танков — ровно половина бюджета 50.
- **2. Зерно.** Волна 8 с зерном 42 в двух прогонах одинакова: 6 стрелков, 2 танка, 5 бегунов.
- **3. Расписание.** Группы идут от дешёвых к дорогим, танк — на 8,2-й секунде, совпадает с таблицей выше.
- **4. Точки.** Игрок стоит у левой точки (40 px от неё), поэтому она пропускается, и враги выходят по очереди справа и сверху.
- **5. Три игрока.** Быстрый (2 врага в секунду) прошёл 17 волн за 240 секунд: каждая следующая начиналась через 3 секунды после зачистки, а живых на экране больше одного не было. Медленный (0,5 в секунду) прошёл 10 волн: волны 2–5 начались по зачистке (17, 38, 59 и 86 с — каждый раз через 3 секунды после последнего убитого), а на пиковой 5-й волне он упёрся в лимит 12, расписание ждало, и 6-я волна началась по тайм-ауту на 124,1-й секунде, когда на экране ещё оставались 2 врага. Игрок, который не убивает никого, получил 2 волны: 1-я вышла целиком, 2-я началась по тайм-ауту на 25-й секунде (5 с последнего выпуска + 20 с) и остановилась на лимите 12.
- **6. Без лимита живых.** Тот же бездействующий игрок без лимита получил 9 волн и 101 врага на экране к 240-й секунде: тайм-аут продолжает запускать волны поверх неразобранных. Это главный довод за лимит: тайм-аут и лимит работают только в паре.

**Что нашли при проверке.** В первом прогоне волны начинались на 1,9-й секунде вместо 2-й, а паузы после зачистки выходили то 3,0, то 3,1 секунды. Причина — шаг 0,1 с не представим точно в двоичной дроби: 3 − 30 × 0,1 даёт не ровно ноль, и таймер срабатывал на шаг позже или раньше. В модуль добавлен допуск `EPS = 1e-6` для всех сравнений времени, а в проверке время теперь считается как номер шага, делённый на 10. Вторая ошибка была в самой проверке: «запас убийств» копился во время пауз, и медленный игрок после паузы убивал сразу нескольких врагов. Теперь запас сбрасывается, пока врагов нет.

## Обвязка для браузера

В браузере тот же модуль подключается к циклу `requestAnimationFrame`: режиссёр каждый кадр получает шаг времени и число живых врагов и возвращает, кого выпустить, а точку появления выбирает `pickPoint`.

```js
// main.js — режиссёр волн в браузерной игре: canvas 640×360, враги идут к игроку
import { createDirector, pickPoint } from './waves.mjs';

const ctx = document.querySelector('canvas').getContext('2d');
const SPEED = { runner: 90, shooter: 50, tank: 30 };          // px/с
const points = [{ x: -20, y: 180 }, { x: 660, y: 180 }, { x: 320, y: -20 }, { x: 320, y: 380 }];
const player = { x: 320, y: 180 };
const enemies = [];
const director = createDirector({ seed: Date.now() | 0, maxAlive: 12 });
let cursor = 0, last = performance.now();

addEventListener('pointerdown', e => {                       // клик убивает ближайшего врага в 24 px
  const r = ctx.canvas.getBoundingClientRect();
  const x = (e.clientX - r.left) * ctx.canvas.width / r.width, y = (e.clientY - r.top) * ctx.canvas.height / r.height;
  const i = enemies.findIndex(en => Math.hypot(en.x - x, en.y - y) < 24);
  if (i >= 0) enemies.splice(i, 1);
});

function frame(now) {
  const dt = Math.min((now - last) / 1000, 0.1);              // после смены вкладки — не больше 0,1 с
  last = now;
  for (const type of director.update(dt, enemies.length)) {
    const pick = pickPoint(points, player, cursor);
    if (!pick) continue;                                      // все точки у игрока — враг пропущен
    cursor = pick.next;
    enemies.push({ type, x: pick.p.x, y: pick.p.y });
  }
  for (const en of enemies) {
    const d = Math.hypot(player.x - en.x, player.y - en.y) || 1;
    en.x += (player.x - en.x) / d * SPEED[en.type] * dt;
    en.y += (player.y - en.y) / d * SPEED[en.type] * dt;
  }
  ctx.clearRect(0, 0, 640, 360);
  ctx.fillStyle = '#4af'; ctx.fillRect(player.x - 8, player.y - 8, 16, 16);
  for (const en of enemies) { ctx.fillStyle = en.type === 'tank' ? '#c33' : en.type === 'shooter' ? '#fa3' : '#9c4';
    ctx.fillRect(en.x - 6, en.y - 6, 12, 12); }
  ctx.fillStyle = '#fff';
  ctx.fillText(`Волна ${director.wave} · ${director.state === 'pause' ? 'пауза' : 'бой'} · врагов ${enemies.length}`, 8, 16);
  requestAnimationFrame(frame);
}
requestAnimationFrame(frame);
```

Нужна страница с `canvas` размером 640 × 360 и подключением `main.js` как модуля; откройте её через локальный сервер. Синтаксис обвязки проверен командой `node --check`. Три детали:

- **Шаг не больше 0,1 с.** Если вкладка была в фоне, `requestAnimationFrame` не вызывался, и первый шаг после возврата может быть в несколько секунд. Без ограничения режиссёр выпустил бы за один кадр всё расписание.
- **Зерно от времени.** В игре `Date.now()` даёт новую волну в каждой партии, а для отладки зерно фиксируют, чтобы повторить неудачную волну.
- **Подпись состояния.** Строка «Волна 3 · пауза · врагов 0» сверху — простейший отладочный вывод; в готовой игре на паузе показывают номер следующей волны.

## Практический сценарий: арена на 10 волн

Задача: браузерная арена 640 × 360 px, где партия длится около 4 минут и заканчивается финальной 10-й волной, а новичок проходит хотя бы 5 волн. Входные условия — три типа врагов (бегун, стрелок, танк), враги идут к игроку, управление мышью или касанием. Шаги:

1. **Стоимость.** Записать бегуна в 1 очко, стрелка в 2, танка в 5 и проверить на плейтесте: два стрелка должны ощущаться примерно как 4 бегуна.
2. **Кривая.** Взять формулу 6 + 3 × (n − 1), пик на 5-й и 10-й волне, передышку на 6-й; танк открыть на 6-й.
3. **Паузы.** 3 с после зачистки, тайм-аут 20 с, лимит 12 живых.
4. **Прогон.** Запустить проверку из статьи с вашими скоростями убийства: у нас медленный игрок с 0,5 врага в секунду прошёл 10 волн за 240 секунд, быстрый — 17, поэтому для партии ровно в 10 волн после 10-й нужен экран победы, а не 11-я волна.
5. **Плейтест.** Дать сыграть 5 людям, записать номер волны, на которой каждый погиб, и время каждой волны.

Проверяемый итог: все пятеро дошли до 5-й волны, хотя бы один погиб на пиковой 5-й или 10-й волне, а не на обычной. Если гибнут на 6-й, танк вводится слишком резко — уменьшите его долю в передышке или сдвиньте на 7-ю волну.

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

Волны с бюджетом и паузами подходят аркадам с повторяющимися боями, но не всем играм:

- **Авторские уровни с постановкой.** Если каждый враг стоит в задуманном месте, как в платформере или шутере с ручной расстановкой, формула бюджета мешает: волну пишут списком вручную.
- **Бесконечный поток без волн.** В играх, где враги идут непрерывно и ускоряются со временем, пауз нет; там вместо бюджета волны — частота появления от времени партии.
- **Сюжетные бои.** Если волна — часть сцены с репликами, её запускают событием сюжета, а не таймером.
- **Подстройка под игрока.** Эта схема — одна кривая для всех. Если новички массово застревают на одной волне, сначала правят стоимости и ритм; подстройка сложности под конкретного игрока — отдельная тема со своими рисками.
- **Сотни врагов.** Лимит 12 рассчитан на арену 640 × 360 и чтение глазами. Для «пулевого ада» с сотнями объектов нужны пулы и пространственная сетка для столкновений, а лимит подбирают по профилю кадра на слабом устройстве.

Мы разрабатываем **J2DRU** — браузерный 2D игровой движок, где логика собирается из событий, условий и действий, а проект можно углублять на TypeScript. Движок в разработке и публично пока не открыт, заявку можно оставить на [странице раннего доступа](/early-access?utm_source=blog&utm_medium=article&utm_campaign=volny-vragov-na-javascript-raspisanie-byudzhet-slozhnosti-i-pauzy) (подача заявки не гарантирует приглашение).

**Источники (проверено: ноябрь 2026, 11.11.2026):** [Wikipedia — Plants vs. Zombies (video game)](https://en.wikipedia.org/wiki/Plants_vs._Zombies_(video_game)) (PopCap Games, выход 5 мая 2009 года; зомби идут волнами, плотность растёт с каждой волной; в конце уровня и часто в середине — крупная волна во главе с зомби с флагом); [Michael Booth (Valve) — The AI Systems of Left 4 Dead, AIIDE 2009](https://cdn.fastly.steamstatic.com/apps/valve/2009/ai_systems_of_l4d_mike_booth.pdf) (цикл Build Up — Sustain Peak 3–5 с — Peak Fade — Relax 30–45 с; постоянный бой утомляет, долгое бездействие скучно; алгоритм меняет темп, а не сложность). Формула бюджета, стоимости типов, интервалы, паузы, лимит 12, скорости врагов и все числа прогонов — наш пример и наш расчёт в Node.js 24.22.1.

**Читайте также:**
- [Кривая сложности и динамическая подстройка: как не потерять ни новичка, ни опытного](/blog/krivaya-slozhnosti-i-dinamicheskaya-podstrojka-novichok-i-opytnyj)
- [Случайность без несправедливости: мешок без повторов, взвешенный выбор и гарантия редкого](/blog/sluchajnost-bez-nespravedlivosti-meshok-bez-povtorov-vzveshennyj-vybor)
- [Спавн и удаление объектов в 2D-игре: время жизни, отложенное удаление и пулы](/blog/spavn-i-udalenie-obektov-v-2d-igre-vremya-zhizni-i-puly)
- [История Tower Defense в 2D: от Rampart (1990) и модов к отдельному жанру](/blog/istoriya-tower-defense-v-2d-ot-rampart-i-modov-k-otdelnomu-zhanru)
- [Пространственное хеширование: столкновения сотен объектов без проверки «каждый с каждым»](/blog/prostranstvennoe-heshirovanie-stolknoveniya-soten-obektov-bez-perebora)
