Коротко
Волну врагов удобнее задавать бюджетом: у каждого типа врага есть стоимость в очках, а волна номер n тратит 6 + 3 × (n − 1) очков, причём каждая пятая волна — пик ×1,5, а следующая — передышка ×0,7. Состав набирают из типов, открытых к этой волне, выпускают группами от дешёвых к дорогим, а следующую волну запускают через 3 секунды после зачистки, но не позже 20 секунд после последнего выпуска. Лимит живых врагов обязателен: в нашем прогоне без него игрок, который не убивает, к 240-й секунде получил 101 врага на экране, с лимитом — 12.
Содержание
- Из чего состоит волна
- Бюджет волны: одна формула вместо списков
- Ритм: рост, пик и передышка
- Состав: какие враги и сколько
- Расписание выпуска: группы и интервалы
- Пауза между волнами: зачистка или тайм-аут
- Точки появления и лимит живых
- Код на JavaScript и проверка в Node.js
- Обвязка для браузера
- Практический сценарий: арена на 10 волн
- Когда вам это не подойдёт
Из чего состоит волна
Волна — это порция врагов с тремя решениями: кого выпустить, когда и откуда, и когда начинать следующую порцию. В 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 волн (наш расчёт):
| Волна | 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 танков — это уже не волна, а стена.
Правила нашего рецепта:
- Доступность. У типа есть номер волны, с которой он появляется (
from). - Доля дорогих. На каждый тип дороже 1 очка тратится не больше 50 % бюджета.
- Остаток. Бегун стоит 1, поэтому бюджет всегда тратится до нуля.
- Случайность с зерном. Тип выбирается случайно, но генератором с зерном: при том же зерне волна та же, и найденную на плейтесте неудачную волну можно воспроизвести. Как сделать случайность честной — мешок без повторов, веса, зерно, — разобрано в статье про случайность без несправедливости.
Расписание выпуска: группы и интервалы
Врагов волны выпускают не разом, а группами одного типа с коротким интервалом внутри группы и паузой между группами, от дешёвых к дорогим. Так игрок сначала разбирается с толпой бегунов, затем со стрелками, а танк приходит последним и заметным.
Расписание волны из 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 очко, стрелка в 2, танка в 5 и проверить на плейтесте: два стрелка должны ощущаться примерно как 4 бегуна.
- Кривая. Взять формулу 6 + 3 × (n − 1), пик на 5-й и 10-й волне, передышку на 6-й; танк открыть на 6-й.
- Паузы. 3 с после зачистки, тайм-аут 20 с, лимит 12 живых.
- Прогон. Запустить проверку из статьи с вашими скоростями убийства: у нас медленный игрок с 0,5 врага в секунду прошёл 10 волн за 240 секунд, быстрый — 17, поэтому для партии ровно в 10 волн после 10-й нужен экран победы, а не 11-я волна.
- Плейтест. Дать сыграть 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.
Читайте также:
- Кривая сложности и динамическая подстройка: как не потерять ни новичка, ни опытного
- Случайность без несправедливости: мешок без повторов, взвешенный выбор и гарантия редкого
- Спавн и удаление объектов в 2D-игре: время жизни, отложенное удаление и пулы
- История Tower Defense в 2D: от Rampart (1990) и модов к отдельному жанру
- Пространственное хеширование: столкновения сотен объектов без проверки «каждый с каждым»