Волны врагов на JavaScript: расписание, бюджет сложности и паузы

Коротко

Волну врагов удобнее задавать бюджетом: у каждого типа врага есть стоимость в очках, а волна номер 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 танка». Каждому типу назначают стоимость примерно по угрозе: сколько времени и внимания игрок тратит на этого врага.

бюджет(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 волн (наш расчёт):

Волна12345678910
Бюджет691215271524273050
Рольстартростновый типростпикпередышка + новый типростростростфинальный пик

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

  • Новый тип — в спокойную волну. Стрелок открывается на 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 без браузера.

// 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 с. Игрок в симуляции убивает фиксированное число врагов в секунду.

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

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.

// 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. Движок в разработке и публично пока не открыт, заявку можно оставить на странице раннего доступа (подача заявки не гарантирует приглашение).

Источники (проверено: ноябрь 2026, 11.11.2026): Wikipedia — Plants vs. Zombies (video game) (PopCap Games, выход 5 мая 2009 года; зомби идут волнами, плотность растёт с каждой волной; в конце уровня и часто в середине — крупная волна во главе с зомби с флагом); Michael Booth (Valve) — The AI Systems of Left 4 Dead, AIIDE 2009 (цикл Build Up — Sustain Peak 3–5 с — Peak Fade — Relax 30–45 с; постоянный бой утомляет, долгое бездействие скучно; алгоритм меняет темп, а не сложность). Формула бюджета, стоимости типов, интервалы, паузы, лимит 12, скорости врагов и все числа прогонов — наш пример и наш расчёт в Node.js 24.22.1.

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

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

Что такое бюджет волны?

Число очков, которое волна тратит на врагов. Каждому типу задают стоимость (в нашем примере бегун — 1, стрелок — 2, танк — 5), и волна набирает врагов, пока хватает очков. Так рост сложности задаётся одной формулой, а не переписыванием списков: в нашем примере бюджет волны n равен 6 + 3 × (n − 1).

Когда запускать следующую волну — по таймеру или после зачистки?

Удобнее совместить: через короткую паузу после зачистки (у нас 3 с), но не позже тайм-аута после последнего выпуска (у нас 20 с). Быстрый игрок не скучает, медленного не ждут бесконечно. Тайм-аут без лимита живых врагов опасен: волны начинают накладываться.

Зачем нужна волна-передышка после пика?

Чтобы после самого тяжёлого боя игрок успел выдохнуть. Майкл Бут из Valve в докладе об ИИ Left 4 Dead (AIIDE 2009) описывает цикл «нарастание — удержание пика 3–5 секунд — спад — отдых 30–45 секунд» и называет постоянный бой утомительным, а долгое затишье — скучным. В нашем примере волна после пика получает 0,7 обычного бюджета; в ней же впервые появляется новый тип врага.

Сколько врагов держать на экране одновременно?

Столько, сколько игрок может прочитать, и столько, сколько выдерживает устройство; у нас лимит — 12 для экрана 640 × 360. Если лимит достигнут, расписание волны ждёт, а не выбрасывает лишних врагов разом. Число подбирают на плейтесте и по профилю кадра на слабом телефоне.