Коротко
Игру tower defense на JavaScript собирают из пяти таблиц данных — путь, враги, волны, башни, клетки карты — и одного шага фиксированного цикла, в котором враги идут, башни стреляют, а мёртвые удаляются в конце. Враг хранит пройденное по ломаной расстояние, и из него вычисляется позиция; башня ищет цель через квадрат расстояния и выбирает по стратегии: first — кто прошёл больше, last — кто меньше, close — кто ближе к башне, strong — у кого больше здоровья. Награда начисляется только при переходе врага из живых в мёртвые, а жизни базы снимает враг, дошедший до конца пути.
Содержание
- Из чего состоит игра в коде
- Путь врагов как ломаная из точек
- Волны как таблица
- Где можно ставить башню
- Поиск цели в радиусе
- Стратегии выбора цели
- Перезарядка, снаряд и мгновенное попадание
- Смерть, награда и жизни базы
- Код на JavaScript
- Проверка в Node.js
- Что показал прогон: три ловушки
- Что не подтвердилось
- Практический сценарий: вторая волна прорывается
- Когда вам это не подойдёт
Из чего состоит игра в коде
Игра в нашем примере — это несколько таблиц данных и функция step, которая продвигает мир на 1/60 секунды. Откуда взялся жанр и чем заданный путь отличается от лабиринта из башен, мы рассказывали в истории tower defense; здесь берём самую простую схему — путь задан автором карты и не меняется.
| Часть | Где лежит | Что хранит |
|---|---|---|
| Путь | PATH | точки ломаной в px |
| Карта | ROWS | 10×8 клеток по 40 px: свободно или камень |
| Враги | ENEMIES | здоровье, скорость в px/с, золото за убийство, сколько жизней снимает |
| Волны | WAVES | группы: тип, сколько, интервал и сдвиг в шагах |
| Башни | TOWERS | цена, радиус, перезарядка в шагах, урон, вид выстрела |
| Партия | makeGame | золото, жизни, списки врагов, башен и снарядов |
Порядок внутри шага записан явно: появление врагов по расписанию, движение и проверка конца пути, выстрелы башен, полёт снарядов, удаление мёртвых и дошедших. Как устроен цикл с фиксированным шагом и почему логика не должна зависеть от частоты экрана, разобрано в статье про игровой цикл и AABB.
Путь врагов как ломаная из точек
Путь врагов задают ломаной: списком точек, которые соединены отрезками. Так его определяет и Wikipedia: ломаная — кривая, заданная последовательностью точек-вершин и состоящая из отрезков между соседними вершинами. Наш путь проходит по центрам клеток: (0,60) → (300,60) → (300,180) → (100,180) → (100,260) → (400,260), пять отрезков длиной 300, 120, 200, 80 и 300 px, всего 1000 px.
Враг хранит не номер точки, к которой идёт, а одно число — сколько пикселей пути он уже прошёл. Каждый шаг к этому числу прибавляется скорость, умноженная на 1/60 с, а позиция на экране вычисляется из него:
отрезок i: от Pᵢ до Pᵢ₊₁, длина Lᵢ, начало на пути Sᵢ = L₀ + … + Lᵢ₋₁
позиция(d): найти i, где Sᵢ ≤ d ≤ Sᵢ + Lᵢ
k = (d − Sᵢ) / Lᵢ
x = xᵢ + (xᵢ₊₁ − xᵢ) · k
y = yᵢ + (yᵢ₊₁ − yᵢ) · k
шаг врага: d = d + скорость · 1/60
дошёл до базы: d ≥ L₀ + L₁ + … (длина всего пути)
Перенос остатка на следующий отрезок
Когда позиция вычисляется из пройденного расстояния, остаток шага переходит на следующий отрезок сам, без отдельного кода. В прогоне враг стоял в (295,60), в 5 px от первого угла, и сделал шаг 14 px: с переносом он оказался в (300,69) — 5 px до угла и 9 px вниз по второму отрезку. Два простых варианта кода «иди к следующей точке» ведут себя иначе: с «прилипанием» к точке (snap) враг остановился в углу (300,60) и потерял 9 px шага, а без прилипания (overshoot) проскочил угол и оказался в (309,60) — за краем пути.
Откуда берётся ломаная
Ломаную либо рисует автор карты, либо её находит поиск пути по сетке; во втором случае точки — это центры клеток найденного пути. Как работает поиск A* на тайловой сетке, разобрано в отдельной статье; для заданного пути он не нужен, а для лабиринта из башен его запускают заново после каждой постройки.
Пройденное расстояние полезно не только для движения. Оно же — прогресс врага: у кого оно больше, тот ближе к базе. Тот же приём — сравнивать участников по доле пройденного пути, а не по порядку в списке — мы применяли для места в заезде в гонке с видом сверху.
Волны как таблица
Волны хранят таблицей групп: тип врага, сколько их, интервал между ними в шагах и сдвиг от начала волны. Код превращает таблицу в одну очередь появлений, отсортированную по шагу, и каждый шаг выпускает тех, чей срок наступил.
| Волна | Начало, шаг | Группа | Сколько | Интервал, шагов | Сдвиг, шагов |
|---|---|---|---|---|---|
| 1 | 0 | runner | 5 | 36 | 0 |
| 2 | 600 | tank | 2 | 90 | 0 |
| 2 | 600 | runner | 6 | 24 | 60 |
Во второй волне бегуны выходят через 60 шагов после первого танка, а скорость у них вдвое выше: 84 px/с против 42. Значит, на пути они обгоняют танков, хотя в списке врагов стоят после них. Эта деталь и ловит ошибку «первый по индексу», о которой ниже. Как считать бюджет волны, ритм и паузы между волнами, мы разбирали в статье про волны врагов; здесь таблица — просто расписание.
Где можно ставить башню
Башню можно ставить на свободную клетку карты, которой нет на пути, если она не занята и золота хватает. Проверки идут по порядку, и функция возвращает причину отказа, чтобы интерфейс мог её показать:
можно_ли(клетка, тип):
1. клетка вне карты → «вне карты»
2. на клетке камень → «камень»
3. клетка лежит на пути → «путь»
4. на клетке уже башня → «занято»
5. золото < цена башни → «мало золота»
иначе → «ok», золото −= цена
Клетки пути вычисляются из той же ломаной: код проходит по каждому отрезку с шагом 1 px и отмечает клетки, через которые он прошёл; у нашего пути их 25. Хранить их отдельным слоем в данных карты не нужно — путь и запрет строительства не разойдутся. В прогоне с 25 золотыми: (4,2) — камень, (3,1) — путь, (12,0) — вне карты, (5,2) — башня arrow за 10, повтор на (5,2) — занято, (3,5) — zap за 15, после чего на (6,3) — мало золота.
Башня стоит в центре клетки: клетка (5,2) — это точка (220,100). Координаты клетки — номер столбца и строки, Math.floor от пикселей, делённых на 40.
Поиск цели в радиусе
Враг в радиусе башни, если квадрат расстояния до него не больше квадрата радиуса: dx·dx + dy·dy ≤ r·r. Корень здесь не нужен: Wikipedia в статье о евклидовом расстоянии отмечает, что при сравнении расстояний корень удобно опускать, потому что он не меняет порядок.
dx = x_врага − x_башни, dy = y_врага − y_башни
в радиусе: dx² + dy² ≤ r²
ближе: dx₁² + dy₁² < dx₂² + dy₂² (корень не нужен)
Если нужно само расстояние, например чтобы показать его в отладке, есть Math.hypot: по MDN он возвращает корень из суммы квадратов аргументов и не переполняется на очень больших числах, порядка 10¹⁵⁴ и выше. Для пикселей карты переполнение не грозит, так что выбор между двумя записями — вопрос удобства; важно не перепутать, что с чем сравнивается.
Радиус по клеткам
Радиус «в клетках» — это не круг, а квадрат. Если сравнивать номера клеток врага и башни через наибольшую разность по столбцу и строке, получится расстояние Чебышёва: по Wikipedia, это наибольшая из разностей по координатам, а на шахматной доске — число ходов короля. Зона такой башни — квадрат 7×7 клеток при радиусе 3, и по диагонали она достаёт дальше нарисованного круга.
Башня в нашем коде перебирает всех врагов в списке; когда их сотни, кандидатов в радиусе ищут через пространственное хеширование.
Стратегии выбора цели
Из врагов в радиусе башня выбирает одного по правилу, и у каждого правила свой счёт: first — больше пройденный путь, last — меньше пройденный путь, close — меньше квадрат расстояния до башни, strong — больше здоровья. По фан-вики Bloons Wiki, в серии Bloons TD такой выбор появился в Bloons Tower Defense 3; First там — цель, ближайшая к выходу по оставшейся длине трассы, и это вариант по умолчанию для новой башни, а при ничьей у Strong берётся First.
счёт(враг): first → пройдено
last → −пройдено
close → −(dx² + dy²)
strong → здоровье
цель = враг с наибольшим счётом; при равенстве — кто прошёл больше
Правило ничьей нужно записать явно: у двух бегунов одинаковое здоровье, и без него strong выберет того, кто раньше в массиве, то есть снова решит порядок создания объектов.
Снимок: кого выберет каждая стратегия
Из одних и тех же четырёх врагов в радиусе башни arrow в клетке (5,2) каждая стратегия выбрала своего:
| Враг | Пройдено, px | Здоровье | До башни, px |
|---|---|---|---|
| #1 tank | 340 | 14 | 80,0 |
| #2 runner | 300 | 4 | 89,4 |
| #3 tank | 395 | 9 | 97,1 |
| #4 runner | 190 | 4 | 50,0 |
Итог по разделу 4 вывода: first выбрал #3 — он прошёл больше всех; close и last — #4, он ближе всех к башне и меньше всех прошёл; strong — #1 с 14 здоровья. «Первый» по индексу массива выбрал #1: он создан раньше, хотя #3 прошёл 395 px против его 340.
Перезарядка, снаряд и мгновенное попадание
Перезарядка — счётчик шагов: после выстрела башня ждёт reload шагов и только потом ищет новую цель. В нашем коде счётчик ставится в reload − 1, потому что шаг выстрела тоже идёт в счёт, и башня arrow стреляет не чаще чем раз в 30 шагов. Если цели нет, башня не тратит перезарядку и проверяет снова на следующем шаге.
Выстрел бывает двух видов. Мгновенный (zap) наносит урон в том же шаге. Снаряд (arrow) летит со скоростью 360 px/с и каждый шаг поворачивает к текущей позиции цели, то есть догоняет её; урон он наносит, когда до цели остаётся не больше одного шага полёта.
Цель умерла, пока снаряд летит
Если цель умерла или дошла до базы, пока снаряд летел, урон ей наносить нельзя, а со снарядом решают одно из трёх:
- Пропасть. Снаряд долетает до последней точки цели и исчезает. Просто и честно, но выстрел потрачен.
- Перенаправить. Снаряд ищет ближайшего живого врага рядом и летит к нему; в нашем коде — один раз и не дальше радиуса башни от снаряда.
- Попадать мгновенно. Тогда вопроса нет, но и нет полёта, который видит игрок.
По Bloons Wiki, в Bloons TD выбор цели вообще не гарантирует попадания именно в неё: башня стреляет в сторону цели, а снаряд может задеть других по пути. В нашем примере снаряд бьёт только свою цель — это проще проверить прогоном.
Смерть, награда и жизни базы
Враг умирает один раз, и награду за него платят один раз — в тот момент, когда здоровье впервые опустилось до нуля. Для этого у врага есть флаг dead: урон по мёртвому не наносится, награда начисляется только при переходе из живых в мёртвые, а убирают мёртвых из списка в конце шага, чтобы не сдвигать массив посреди перебора. Почему удалять объекты лучше отложенно, мы разбирали в статье про спавн и удаление объектов.
урон(враг, n):
если враг.мёртв — ничего
враг.здоровье −= n
если здоровье ≤ 0: враг.мёртв = да, убито += 1, золото += награда
дошёл до базы: жизни −= сколько снимает враг; награды нет
жизни ≤ 0: база пала, партия окончена
Экономика в примере такая: стартовые 20 золотых уходят на две башни arrow по 10, бегун приносит 2, танк — 6. Если убить всех врагов двух волн, золото вырастает до 34. Бегун у базы снимает 1 жизнь, танк — 3, а жизней у базы 10.
Код на JavaScript
Пример — два файла: td.mjs с логикой и test.mjs, который прогоняет восемь сцен и печатает итог. Нужен Node.js 24 и папка с этими файлами; запуск — node test.mjs. Время только в шагах 1/60 с, случайности нет, поэтому вывод повторяется байт в байт. Браузерную обвязку мы не приводим: step вызывается из цикла с фиксированным шагом, а отрисовка читает позиции врагов, башен и снарядов.
Опции step включают ошибки для ловушек: move: "snap" и move: "overshoot" — движение «к следующей точке» без переноса остатка, rangeNoSquare — радиус без квадрата, rangeCells — радиус в клетках, doubleReward — награда за каждый удар по мёртвому; стратегия index — «первый» по месту в массиве. retarget и instant — два других способа обойтись с мёртвой целью.
// td.mjs — tower defense на фиксированном шаге 1/60 с; случайности нет
export const STEP = 1 / 60;
export const CELL = 40;
// Карта 10×8 клеток: «.» — можно строить, «#» — камень; клетки пути отмечает ломаная
export const ROWS = [
"..........",
"..........",
"....#.....",
"..........",
"..........",
"........#.",
"..........",
"..........",
];
// Путь — ломаная по центрам клеток, в px; вход слева, база справа
export const PATH = [[0, 60], [300, 60], [300, 180], [100, 180], [100, 260], [400, 260]];
// Враги и башни — таблицы данных; скорость в px/с, перезарядка в шагах
export const ENEMIES = {
runner: { hp: 4, speed: 84, gold: 2, harm: 1 },
tank: { hp: 14, speed: 42, gold: 6, harm: 3 },
};
export const TOWERS = {
arrow: { cost: 10, range: 100, reload: 30, damage: 1, shot: "projectile", speed: 360 },
zap: { cost: 15, range: 80, reload: 48, damage: 4, shot: "instant" },
};
// Волны: группа = тип, сколько, интервал в шагах, сдвиг от начала волны
export const WAVES = [
{ start: 0, groups: [{ type: "runner", count: 5, every: 36, from: 0 }] },
{ start: 600, groups: [{ type: "tank", count: 2, every: 90, from: 0 },
{ type: "runner", count: 6, every: 24, from: 60 }] },
];
export function makePath(points) {
const segs = [];
let total = 0;
for (let i = 1; i < points.length; i++) {
const [x0, y0] = points[i - 1];
const [x1, y1] = points[i];
const len = Math.hypot(x1 - x0, y1 - y0);
segs.push({ x0, y0, x1, y1, len, start: total });
total += len;
}
return { points, segs, total };
}
// Точка на ломаной по пройденному расстоянию: остаток шага сам переходит на следующий отрезок
export function pointAt(path, d) {
for (const s of path.segs) {
if (d <= s.start + s.len) {
const k = Math.max(0, d - s.start) / s.len;
return { x: s.x0 + (s.x1 - s.x0) * k, y: s.y0 + (s.y1 - s.y0) * k };
}
}
const last = path.segs[path.segs.length - 1];
return { x: last.x1, y: last.y1 };
}
// Ошибки для ловушки: движение «к следующей точке» без переноса остатка шага
export function moveToPoint(path, e, dist, mode) {
const [tx, ty] = path.points[Math.min(e.wp, path.points.length - 1)];
const dx = tx - e.x;
const dy = ty - e.y;
const left = Math.hypot(dx, dy);
if (left <= dist) {
e.wp += 1;
if (mode === "snap") { e.x = tx; e.y = ty; e.dist += left; return; } // остаток теряется
}
e.x += dx / left * dist; e.y += dy / left * dist; e.dist += dist; // overshoot: проскок за точку
}
export const cellOf = (v) => Math.floor(v / CELL);
export function pathCells(path) {
const set = new Set();
for (const s of path.segs) {
for (let k = 0; k <= s.len; k++) {
const x = s.x0 + (s.x1 - s.x0) * k / s.len;
const y = s.y0 + (s.y1 - s.y0) * k / s.len;
set.add(cellOf(Math.min(x, 399)) + "," + cellOf(Math.min(y, 319)));
}
}
return set;
}
export function makeGame(gold, lives, waves = WAVES) {
const path = makePath(PATH);
const queue = [];
for (const w of waves) {
for (const g of w.groups) {
for (let i = 0; i < g.count; i++) queue.push({ t: w.start + g.from + i * g.every, type: g.type });
}
}
queue.sort((a, b) => a.t - b.t);
return { t: 0, path, blocked: pathCells(path), gold, lives, towers: [], enemies: [], shots: [],
queue, nextId: 1, kills: 0, leaks: 0, wasted: 0, rewards: 0, fired: 0, maxShot: 0 };
}
// Можно ли поставить башню на клетку; возвращает причину отказа
export function canBuild(g, cx, cy, type) {
if (cx < 0 || cy < 0 || cy >= ROWS.length || cx >= ROWS[0].length) return "вне карты";
if (ROWS[cy][cx] === "#") return "камень";
if (g.blocked.has(cx + "," + cy)) return "путь";
if (g.towers.some((t) => t.cx === cx && t.cy === cy)) return "занято";
if (g.gold < TOWERS[type].cost) return "мало золота";
return "ok";
}
export function build(g, cx, cy, type, strategy) {
const why = canBuild(g, cx, cy, type);
if (why !== "ok") return why;
g.gold -= TOWERS[type].cost;
g.towers.push({ cx, cy, x: cx * CELL + CELL / 2, y: cy * CELL + CELL / 2,
spec: TOWERS[type], strategy, cool: 0 });
return "ok";
}
export function spawn(g, type) {
const p = pointAt(g.path, 0);
const e = { id: g.nextId, kind: ENEMIES[type], type, hp: ENEMIES[type].hp,
dist: 0, x: p.x, y: p.y, wp: 1, dead: false, leaked: false };
g.nextId += 1;
g.enemies.push(e);
return e;
}
export function inRange(t, e, opts) {
const dx = e.x - t.x;
const dy = e.y - t.y;
if (opts.rangeNoSquare) return dx * dx + dy * dy <= t.spec.range; // ошибка: r без квадрата
if (opts.rangeCells) { // ошибка: радиус в клетках, получается квадрат
const r = Math.round(t.spec.range / CELL);
return Math.max(Math.abs(cellOf(e.x) - t.cx), Math.abs(cellOf(e.y) - t.cy)) <= r;
}
return dx * dx + dy * dy <= t.spec.range * t.spec.range;
}
// Очки цели по стратегии: больше — лучше
export function score(t, e, strategy) {
if (strategy === "first") return e.dist;
if (strategy === "last") return -e.dist;
if (strategy === "close") return -((e.x - t.x) ** 2 + (e.y - t.y) ** 2);
if (strategy === "strong") return e.hp;
return 0;
}
export function pickTarget(g, t, opts) {
let best = null;
for (const e of g.enemies) {
if ((!opts.doubleReward && e.dead) || e.leaked || !inRange(t, e, opts)) continue;
if (t.strategy === "index") return e; // ошибка: «первый» по индексу массива
if (!best) { best = e; continue; }
const a = score(t, e, t.strategy);
const b = score(t, best, t.strategy);
if (a > b || (a === b && e.dist > best.dist)) best = e; // ничья — кто дальше прошёл
}
return best;
}
// Урон и награда: награда — только при переходе из живых в мёртвые
export function damage(g, e, amount, opts) {
if (e.dead && !opts.doubleReward) return; // мёртвых не бьём
e.hp -= amount;
if (e.hp > 0) return;
const wasAlive = !e.dead;
e.dead = true;
if (wasAlive) g.kills += 1;
// doubleReward — ошибка для ловушки: награда за каждый удар по hp ≤ 0
if (wasAlive || opts.doubleReward) { g.gold += e.kind.gold; g.rewards += 1; }
}
// Один шаг: появление, движение и утечки, башни, снаряды, удаление
export function step(g, opts = {}) {
g.t += 1;
while (g.queue.length > 0 && g.queue[0].t < g.t) spawn(g, g.queue.shift().type);
const v = opts.speedScale || 1;
for (const e of g.enemies) {
if (e.dead) continue;
const dist = e.kind.speed * v * STEP;
if (opts.move) moveToPoint(g.path, e, dist, opts.move);
else {
e.dist += dist;
const p = pointAt(g.path, e.dist);
e.x = p.x; e.y = p.y;
}
if (opts.move ? e.wp >= g.path.points.length : e.dist >= g.path.total - 1e-9) {
e.leaked = true; g.lives -= e.kind.harm; g.leaks += 1;
}
}
for (const t of g.towers) {
if (t.cool > 0) { t.cool -= 1; continue; }
const e = pickTarget(g, t, opts);
if (!e) continue;
t.cool = t.spec.reload - 1;
g.fired += 1;
g.maxShot = Math.max(g.maxShot, Math.hypot(e.x - t.x, e.y - t.y));
if (t.spec.shot === "instant" || opts.instant) damage(g, e, t.spec.damage, opts);
else g.shots.push({ x: t.x, y: t.y, target: e, tx: e.x, ty: e.y,
speed: t.spec.speed, damage: t.spec.damage, range: t.spec.range });
}
for (const s of g.shots) {
const e = s.target;
if (!e.dead && !e.leaked) { s.tx = e.x; s.ty = e.y; } // догоняем живую цель
else if (opts.retarget && !s.retargeted) {
const near = nearestAlive(g, s);
if (near) { s.target = near; s.tx = near.x; s.ty = near.y; s.retargeted = true; }
}
const dx = s.tx - s.x;
const dy = s.ty - s.y;
const left = Math.hypot(dx, dy);
const d = s.speed * STEP;
if (left <= d) {
s.done = true;
if (!s.target.dead && !s.target.leaked) damage(g, s.target, s.damage, opts);
else g.wasted += 1; // цель умерла или ушла, пока снаряд летел
} else {
s.x += dx / left * d; s.y += dy / left * d;
}
}
g.shots = g.shots.filter((s) => !s.done);
g.enemies = g.enemies.filter((e) => !e.dead && !e.leaked); // удаление в конце шага
}
// Новая цель для снаряда: ближайший живой враг не дальше радиуса башни от снаряда
function nearestAlive(g, s) {
let best = null;
let bd = Infinity;
for (const e of g.enemies) {
if (e.dead || e.leaked) continue;
const d = (e.x - s.x) ** 2 + (e.y - s.y) ** 2;
if (d <= s.range * s.range && d < bd) { best = e; bd = d; }
}
return best;
}
export function runAll(g, opts = {}, limit = 3000) {
const busy = () => g.queue.length > 0 || g.enemies.length > 0 || g.shots.length > 0;
while (g.t < limit && g.lives > 0 && busy()) step(g, opts);
return g;
}
// test.mjs — node test.mjs; вывод детерминирован
import { CELL, PATH, ENEMIES, TOWERS, WAVES, makeGame, makePath, pointAt, moveToPoint,
canBuild, build, spawn, pickTarget, step, runAll } from "./td.mjs";
const out = [];
const say = (s) => out.push(s);
const num = (x, d) => x.toFixed(d).replace(".", ",");
say("# 0. Модель");
say("шаг 1/60 с; клетка " + CELL + " px; карта 10×8 клеток; путь " +
PATH.map((p) => "(" + p[0] + "," + p[1] + ")").join("→"));
for (const [k, e] of Object.entries(ENEMIES)) {
say("враг " + k + ": hp " + e.hp + ", " + e.speed + " px/с, золото " + e.gold + ", снимает жизней " + e.harm);
}
for (const [k, t] of Object.entries(TOWERS)) {
say("башня " + k + ": цена " + t.cost + ", радиус " + t.range + " px, перезарядка " + t.reload +
" шагов, урон " + t.damage + ", " + (t.shot === "instant" ? "мгновенно" : "снаряд " + t.speed + " px/с"));
}
say("волны: " + WAVES.map((w, i) => (i + 1) + " — с шага " + w.start + ": " +
w.groups.map((g) => g.count + "×" + g.type + " через " + g.every + " (сдвиг " + g.from + ")").join(" + ")).join("; "));
say("");
say("# 1. Путь и перенос остатка");
const path = makePath(PATH);
say("длина " + path.total + " px; отрезки " + path.segs.map((s) => s.len).join(", ") +
"; клеток пути " + makeGame(0, 10).blocked.size);
for (const mode of ["перенос", "snap", "overshoot"]) {
const e = { x: 295, y: 60, dist: 295, wp: 1 };
if (mode === "перенос") { e.dist += 14; Object.assign(e, pointAt(path, e.dist)); }
else moveToPoint(path, e, 14, mode);
say(mode + ": из (295,60) шагом 14 px → (" + num(e.x, 0) + "," + num(e.y, 0) + "), пройдено " + num(e.dist, 0));
}
say("");
say("# 2. Угол пути на большой скорости: шагов до базы и отклонение от ломаной");
function offPath(x, y) {
let best = Infinity;
for (const s of path.segs) {
const k = Math.max(0, Math.min(1, ((x - s.x0) * (s.x1 - s.x0) + (y - s.y0) * (s.y1 - s.y0)) / (s.len * s.len)));
best = Math.min(best, Math.hypot(x - s.x0 - (s.x1 - s.x0) * k, y - s.y0 - (s.y1 - s.y0) * k));
}
return best;
}
for (const speed of [84, 420, 900]) {
const parts = [];
for (const [label, move] of [["перенос", undefined], ["snap", "snap"], ["overshoot", "overshoot"]]) {
const g = makeGame(0, 10, []);
const e = spawn(g, "runner");
let n = 0;
let dev = 0;
while (!e.leaked) {
step(g, { move, speedScale: speed / ENEMIES.runner.speed });
n += 1;
dev = Math.max(dev, offPath(e.x, e.y));
}
parts.push(label + " — " + n + ", отклонение " + num(dev, 1) + " px");
}
say(speed + " px/с (" + num(speed / 60, 1) + " px за шаг; без потерь " + num(1000 / (speed / 60), 1) + " шага): " + parts.join("; "));
}
say("");
say("# 3. Где можно ставить башню (золото 25)");
{
const g = makeGame(25, 10);
for (const [cx, cy, type] of [[4, 2, "arrow"], [3, 1, "arrow"], [12, 0, "arrow"], [5, 2, "arrow"],
[5, 2, "arrow"], [3, 5, "zap"], [3, 5, "arrow"], [6, 3, "zap"]]) {
say("клетка (" + cx + "," + cy + ") " + type + ": " + build(g, cx, cy, type, "first") + "; золото " + g.gold);
}
}
say("");
say("# 4. Выбор цели: снимок, башня arrow в клетке (5,2), центр (220,100)");
{
const g = makeGame(10, 10, []);
build(g, 5, 2, "arrow", "first");
const t = g.towers[0];
const set = [["tank", 340, 14], ["runner", 300, 4], ["tank", 395, 9], ["runner", 190, 4]];
for (const [type, d, hp] of set) {
const e = spawn(g, type);
e.dist = d; e.hp = hp;
Object.assign(e, pointAt(g.path, d));
}
for (const e of g.enemies) {
say("#" + e.id + " " + e.type + ": пройдено " + e.dist + " px, hp " + e.hp + ", (" + num(e.x, 0) + "," + num(e.y, 0) +
"), до башни " + num(Math.hypot(e.x - t.x, e.y - t.y), 1) + " px");
}
for (const s of ["first", "index", "close", "strong", "last"]) {
t.strategy = s;
const e = pickTarget(g, t, {});
say(s + " → #" + e.id);
}
}
say("");
say("# 5. Две волны, две башни arrow в (5,2) и (3,5), золото 20, жизней 10");
function scenario(strategy, opts = {}) {
const g = makeGame(20, 10);
build(g, 5, 2, "arrow", strategy);
build(g, 3, 5, "arrow", strategy);
return runAll(g, opts);
}
for (const s of ["first", "index", "close", "strong", "last"]) {
const g = scenario(s);
say(s + ": убито " + g.kills + ", прорвалось " + g.leaks + ", жизней " + g.lives + ", золото " + g.gold +
", выстрелов " + g.fired + ", снарядов впустую " + g.wasted);
}
say("");
say("# 6. Радиус: квадрат расстояния, r без квадрата, клетки (стратегия first)");
for (const [label, opts] of [["dx²+dy² ≤ r²", {}], ["dx²+dy² ≤ r", { rangeNoSquare: true }],
["клетки ≤ 3", { rangeCells: true }]]) {
const g = scenario("first", opts);
say(label + ": выстрелов " + g.fired + ", самый дальний " + num(g.maxShot, 1) + " px, убито " + g.kills +
", прорвалось " + g.leaks + ", жизней " + g.lives + (g.lives <= 0 ? ", база пала на шаге " + g.t : ""));
}
say("");
say("# 7. Снаряд и мёртвая цель (стратегия first)");
for (const [label, opts] of [["снаряд, цель умерла — пропасть", {}], ["снаряд, перенаправить", { retarget: true }],
["мгновенное попадание", { instant: true }]]) {
const g = scenario("first", opts);
say(label + ": выстрелов " + g.fired + ", впустую " + g.wasted + ", убито " + g.kills + ", прорвалось " + g.leaks +
", золото " + g.gold);
}
say("");
say("# 8. Награда за смерть: две башни zap в (2,2) и (2,0), волна 1");
for (const [label, opts] of [["награда при переходе в мёртвые", {}], ["награда за каждый удар по hp ≤ 0", { doubleReward: true }]]) {
const g = makeGame(30, 10, [WAVES[0]]);
build(g, 2, 2, "zap", "first");
build(g, 2, 0, "zap", "first");
runAll(g, opts);
say(label + ": убито " + g.kills + ", наград " + g.rewards + ", золото " + g.gold + ", выстрелов " + g.fired +
", прорвалось " + g.leaks);
}
process.stdout.write(out.join("\n") + "\n");
Проверка в Node.js
Ниже — полный вывод node test.mjs на Node.js 24.22.1; мы запускали его 25 раз подряд, вывод совпадал байт в байт.
Вывод прогона:
# 0. Модель
шаг 1/60 с; клетка 40 px; карта 10×8 клеток; путь (0,60)→(300,60)→(300,180)→(100,180)→(100,260)→(400,260)
враг runner: hp 4, 84 px/с, золото 2, снимает жизней 1
враг tank: hp 14, 42 px/с, золото 6, снимает жизней 3
башня arrow: цена 10, радиус 100 px, перезарядка 30 шагов, урон 1, снаряд 360 px/с
башня zap: цена 15, радиус 80 px, перезарядка 48 шагов, урон 4, мгновенно
волны: 1 — с шага 0: 5×runner через 36 (сдвиг 0); 2 — с шага 600: 2×tank через 90 (сдвиг 0) + 6×runner через 24 (сдвиг 60)
# 1. Путь и перенос остатка
длина 1000 px; отрезки 300, 120, 200, 80, 300; клеток пути 25
перенос: из (295,60) шагом 14 px → (300,69), пройдено 309
snap: из (295,60) шагом 14 px → (300,60), пройдено 300
overshoot: из (295,60) шагом 14 px → (309,60), пройдено 309
# 2. Угол пути на большой скорости: шагов до базы и отклонение от ломаной
84 px/с (1,4 px за шаг; без потерь 714,3 шага): перенос — 715, отклонение 0,0 px; snap — 717, отклонение 0,0 px; overshoot — 717, отклонение 1,2 px
420 px/с (7,0 px за шаг; без потерь 142,9 шага): перенос — 143, отклонение 0,0 px; snap — 145, отклонение 0,0 px; overshoot — 145, отклонение 6,0 px
900 px/с (15,0 px за шаг; без потерь 66,7 шага): перенос — 67, отклонение 0,0 px; snap — 71, отклонение 0,0 px; overshoot — 70, отклонение 15,0 px
# 3. Где можно ставить башню (золото 25)
клетка (4,2) arrow: камень; золото 25
клетка (3,1) arrow: путь; золото 25
клетка (12,0) arrow: вне карты; золото 25
клетка (5,2) arrow: ok; золото 15
клетка (5,2) arrow: занято; золото 15
клетка (3,5) zap: ok; золото 0
клетка (3,5) arrow: занято; золото 0
клетка (6,3) zap: мало золота; золото 0
# 4. Выбор цели: снимок, башня arrow в клетке (5,2), центр (220,100)
#1 tank: пройдено 340 px, hp 14, (300,100), до башни 80,0 px
#2 runner: пройдено 300 px, hp 4, (300,60), до башни 89,4 px
#3 tank: пройдено 395 px, hp 9, (300,155), до башни 97,1 px
#4 runner: пройдено 190 px, hp 4, (190,60), до башни 50,0 px
first → #3
index → #1
close → #4
strong → #1
last → #4
# 5. Две волны, две башни arrow в (5,2) и (3,5), золото 20, жизней 10
first: убито 13, прорвалось 0, жизней 10, золото 34, выстрелов 74, снарядов впустую 2
index: убито 10, прорвалось 3, жизней 7, золото 28, выстрелов 64, снарядов впустую 1
close: убито 11, прорвалось 2, жизней 8, золото 30, выстрелов 68, снарядов впустую 1
strong: убито 7, прорвалось 6, жизней 4, золото 22, выстрелов 60, снарядов впустую 0
last: убито 8, прорвалось 5, жизней 5, золото 24, выстрелов 63, снарядов впустую 0
# 6. Радиус: квадрат расстояния, r без квадрата, клетки (стратегия first)
dx²+dy² ≤ r²: выстрелов 74, самый дальний 99,8 px, убито 13, прорвалось 0, жизней 10
dx²+dy² ≤ r: выстрелов 0, самый дальний 0,0 px, убито 0, прорвалось 10, жизней 0, база пала на шаге 1471
клетки ≤ 3: выстрелов 75, самый дальний 175,8 px, убито 13, прорвалось 0, жизней 10
# 7. Снаряд и мёртвая цель (стратегия first)
снаряд, цель умерла — пропасть: выстрелов 74, впустую 2, убито 13, прорвалось 0, золото 34
снаряд, перенаправить: выстрелов 73, впустую 1, убито 13, прорвалось 0, золото 34
мгновенное попадание: выстрелов 72, впустую 0, убито 13, прорвалось 0, золото 34
# 8. Награда за смерть: две башни zap в (2,2) и (2,0), волна 1
награда при переходе в мёртвые: убито 5, наград 5, золото 10, выстрелов 5, прорвалось 0
награда за каждый удар по hp ≤ 0: убито 5, наград 10, золото 20, выстрелов 10, прорвалось 0
Что показал прогон: три ловушки
Три ловушки воспроизвелись и изменили исход партии: ловушка 1 — разделы 4 и 5 вывода, ловушка 2 — раздел 8, ловушка 3 — раздел 6. Ещё три ожидания прогон не подтвердил или подтвердил слабо — о них в следующем разделе.
Ловушка 1: «первый» по индексу массива
Если «первым» считать того, кто раньше в массиве, башня бьёт того, кто раньше появился, а не того, кто ближе к базе. В снимке «по индексу» выбран танк #1, хотя танк #3 прошёл больше. На двух волнах это стоило 3 жизней: по индексу убито 10 врагов, прорвались 3, у базы осталось 7 жизней и 28 золотых; выбор по пройденному пути убил всех 13, ни один не прорвался, жизней 10, золота 34. Прорвались бегуны второй волны: они вышли позже танков, обогнали их на пути, но в массиве остались позади.
Ловушка 2: награда за каждый удар по мёртвому
Если награду платить при каждой проверке «здоровье ≤ 0», а мёртвых убирать только в конце шага, второй выстрел в том же шаге снова платит за того же врага. Две башни zap стоят рядом и видят бегуна в одном и том же шаге: при правильной награде убито 5, наград 5, золото 10, выстрелов 5; с ошибкой — убито те же 5, но наград 10, золото 20 и выстрелов 10. Ошибка вредна вдвойне: игрок получает лишнее золото, а вторая башня тратит выстрел и перезарядку на мёртвого.
Ловушка 3: радиус без квадрата
Если сравнить квадрат расстояния с радиусом, а не с его квадратом, зона башни сжимается до круга радиусом √r. При dx²+dy² ≤ r обе башни не сделали ни одного выстрела, прорвались 10 врагов, и база пала на шаге 1471. С правильной формулой — 74 выстрела, самый дальний на 99,8 px, все 13 врагов убиты. Ошибка заметна сразу, но только если в игре есть хоть одна волна, которую башни должны остановить; в пустом тесте «башня стоит» её не видно.
Что не подтвердилось
Три ожидания прогон не подтвердил или подтвердил слабее, чем мы думали:
- «Без переноса остатка враг срезает углы». Слабо. На 84 px/с потери почти не видно: snap дошёл до базы за 717 шагов против 715 с переносом, overshoot отклонился от пути на 1,2 px. Эффект растёт со скоростью: на 900 px/с snap потерял 4 шага (71 против 67), а overshoot ушёл с пути на 15,0 px — ровно на длину шага. Значит, это ошибка для быстрых врагов и для ускорения игры большим шагом, а не для обычной скорости.
- «Радиус по клеткам ломает баланс». На этой карте — нет: башни с квадратной зоной сделали 75 выстрелов против 74 и так же убили всех 13. Но самый дальний выстрел ушёл на 175,8 px при нарисованном радиусе 100 px: игрок видит круг, а башня бьёт по квадрату. Ошибка честности, а не исхода.
- «Перенаправление снарядов спасает волну». Нет: без него пропало 2 снаряда из 74, с ним — 1 из 73, при мгновенном попадании — 0 из 72, а убито во всех трёх вариантах 13, прорывов 0 и золота 34. Выбор между ними — вопрос того, что игрок видит, а не баланса этой карты.
Практический сценарий: вторая волна прорывается
Задача: на карте две башни arrow в клетках (5,2) и (3,5), у обеих стратегия strong, и вторая волна пробивает оборону. Нужно остановить её, не покупая новых башен. Входные данные — таблицы ENEMIES, TOWERS, WAVES и 20 золотых на старте.
- Прогнать как есть. Раздел 5 вывода, строка strong: убито 7, прорвались 6, у базы 4 жизни.
- Посмотреть, кого выбирает башня. Снимок в разделе 4: strong выбирает танка #1 с 14 здоровья, а бегуны в это время идут мимо. По таблице волн бегуны второй волны вдвое быстрее танков и выходят позже.
- Сменить стратегию на first по пройденному пути. Ни таблицы, ни места башен не трогаем.
- Прогнать снова. Строка first: убито 13, прорвалось 0, жизней 10, золото 34.
- Проверить, что «первый» считается по пути. Строка index в том же разделе: прорвались 3. Если ваш результат совпал с ней, а не с first, у вас выбор по индексу массива.
Проверяемый итог: строка first в разделе 5 показывает 0 прорывов и 34 золотых. На эти деньги можно поставить ещё башни к третьей волне, и тогда проверку из раздела 3 — путь, камень, занято, мало золота — стоит прогнать для каждой новой клетки.
Когда вам это не подойдёт
Заданный путь, выбор цели по пройденному расстоянию и одиночные выстрелы подходят для классической карты с одной дорогой; вот где этого мало:
- Лабиринт из башен. Если игрок строит башни на пути и меняет его, ломаную нужно искать заново после каждой постройки, а «пройдено» у врага теряет смысл; сравнивают оставшийся путь до базы. Поиск пути — в статье про A* на тайловой сетке.
- Несколько дорог. Пройденные расстояния на разных путях нельзя сравнивать напрямую; для first берут оставшееся до базы расстояние по своему пути.
- Урон по площади и цепи. Взрыв или молния бьют по нескольким врагам сразу; нужен отдельный поиск всех целей в зоне попадания, а награда по-прежнему — один раз за смерть.
- Враг быстрее снаряда. Снаряд, который догоняет цель, не догонит врага, который движется быстрее него; тогда нужен выстрел с упреждением или мгновенное попадание.
- Сотни врагов. Каждая башня в нашем коде перебирает весь список врагов каждый шаг; на больших волнах кандидатов ищут через пространственную сетку.
Мы разрабатываем J2DRU — браузерный 2D игровой движок, где логика собирается из событий, условий и действий, а проект можно углублять на TypeScript. Движок в разработке и публично пока не открыт, заявку можно оставить на странице раннего доступа (подача заявки не гарантирует приглашение).
Источники (проверено: 12.11.2026, все страницы открываются с HTTP 200): Wikipedia — Polygonal chain (ломаная — кривая из последовательности вершин и отрезков между соседними); Wikipedia — Euclidean distance, раздел Squared Euclidean distance (при сравнении расстояний корень можно опустить, порядок не меняется); Wikipedia — Chebyshev distance (наибольшая из разностей по координатам; ходы короля на шахматной доске); MDN — Math.hypot() (корень из суммы квадратов; без переполнения при числах больше примерно 10¹⁵⁴); Bloons Wiki — Targeting priority (фан-вики: выбор цели с Bloons Tower Defense 3; First — ближайший к выходу по оставшейся длине трассы, вариант по умолчанию; ничья у Strong — First; выбор цели не гарантирует попадание именно в неё). Карта, путь, враги, башни, волны и все числа прогона — наш пример и наш прогон в Node.js 24.22.1.
Читайте также:
- Поиск пути A* на тайловой сетке: от поиска в ширину до рабочего кода на JavaScript
- История Tower Defense в 2D: от Rampart (1990) и модов к отдельному жанру
- Волны врагов на JavaScript: расписание, бюджет сложности и паузы
- Пространственное хеширование: столкновения сотен объектов без проверки «каждый с каждым»
- Гонка с видом сверху на JavaScript: чекпойнты, круги и место в заезде