---
title: "Tower defense на JavaScript: путь врагов, башни и выбор цели"
description: "Как собрать tower defense на чистом JavaScript с фиксированным шагом: путь врагов как ломаная и движение по пройденному расстоянию, волны таблицей, клетки для башен, поиск цели в радиусе через квадрат расстояния, стратегии first, last, close и strong, перезарядка, снаряды и мгновенное попадание, золото за убийство и жизни базы. Три ловушки показаны прогоном в Node.js 24."
slug: tower-defense-na-javascript-put-vragov-bashni-i-vybor-celi
date: 2026-11-20
updated: 2026-11-20
scheduled_at: "2026-11-20T19:00:00+03:00"
rubric: praktika-i-uroki
tags: ["tower-defense", "javascript", "algoritmy", "razrabotchikam", "shkolnikam"]
reading_time: 23
draft: false
summary: "В tower defense враг хранит одно число — сколько пикселей пути он прошёл, а позицию на ломаной из точек получают из этого числа, поэтому остаток шага сам переходит на следующий отрезок. Башня ищет цель в радиусе по квадрату расстояния и выбирает «первого» по пройденному пути, а не по месту в массиве. В нашем прогоне «первый по индексу» пропустил 3 врагов там, где выбор по пути не пропустил ни одного, награда за каждый удар по мёртвому врагу удвоила золото волны, а радиус без квадрата оставил башни без единого выстрела."
---

## Коротко

Игру tower defense на JavaScript собирают из пяти таблиц данных — путь, враги, волны, башни, клетки карты — и одного шага фиксированного цикла, в котором враги идут, башни стреляют, а мёртвые удаляются в конце. Враг хранит пройденное по ломаной расстояние, и из него вычисляется позиция; башня ищет цель через квадрат расстояния и выбирает по стратегии: first — кто прошёл больше, last — кто меньше, close — кто ближе к башне, strong — у кого больше здоровья. Награда начисляется только при переходе врага из живых в мёртвые, а жизни базы снимает враг, дошедший до конца пути.

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

1. Из чего состоит игра в коде
2. Путь врагов как ломаная из точек
3. Волны как таблица
4. Где можно ставить башню
5. Поиск цели в радиусе
6. Стратегии выбора цели
7. Перезарядка, снаряд и мгновенное попадание
8. Смерть, награда и жизни базы
9. Код на JavaScript
10. Проверка в Node.js
11. Что показал прогон: три ловушки
12. Что не подтвердилось
13. Практический сценарий: вторая волна прорывается
14. Когда вам это не подойдёт

## Из чего состоит игра в коде

Игра в нашем примере — это несколько таблиц данных и функция `step`, которая продвигает мир на 1/60 секунды. Откуда взялся жанр и чем заданный путь отличается от лабиринта из башен, мы рассказывали в [истории tower defense](/blog/istoriya-tower-defense-v-2d-ot-rampart-i-modov-k-otdelnomu-zhanru); здесь берём самую простую схему — путь задан автором карты и не меняется.

| Часть | Где лежит | Что хранит |
|---|---|---|
| Путь | `PATH` | точки ломаной в px |
| Карта | `ROWS` | 10×8 клеток по 40 px: свободно или камень |
| Враги | `ENEMIES` | здоровье, скорость в px/с, золото за убийство, сколько жизней снимает |
| Волны | `WAVES` | группы: тип, сколько, интервал и сдвиг в шагах |
| Башни | `TOWERS` | цена, радиус, перезарядка в шагах, урон, вид выстрела |
| Партия | `makeGame` | золото, жизни, списки врагов, башен и снарядов |

Порядок внутри шага записан явно: появление врагов по расписанию, движение и проверка конца пути, выстрелы башен, полёт снарядов, удаление мёртвых и дошедших. Как устроен цикл с фиксированным шагом и почему логика не должна зависеть от частоты экрана, разобрано в статье про [игровой цикл и AABB](/blog/igrovoj-cikl-i-fizika-stolknovenij-aabb).

## Путь врагов как ломаная из точек

Путь врагов задают ломаной: списком точек, которые соединены отрезками. Так его определяет и Wikipedia: ломаная — кривая, заданная последовательностью точек-вершин и состоящая из отрезков между соседними вершинами. Наш путь проходит по центрам клеток: (0,60) → (300,60) → (300,180) → (100,180) → (100,260) → (400,260), пять отрезков длиной 300, 120, 200, 80 и 300 px, всего 1000 px.

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

```text
отрезок 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* на тайловой сетке, разобрано в [отдельной статье](/blog/algoritm-a-star-poiska-puti-na-tajlovoj-setke); для заданного пути он не нужен, а для лабиринта из башен его запускают заново после каждой постройки.

Пройденное расстояние полезно не только для движения. Оно же — прогресс врага: у кого оно больше, тот ближе к базе. Тот же приём — сравнивать участников по доле пройденного пути, а не по порядку в списке — мы применяли для места в заезде в [гонке с видом сверху](/blog/gonka-s-vidom-sverhu-na-javascript-chekpojnty-krugi-i-mesto-v-zaezde).

## Волны как таблица

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

| Волна | Начало, шаг | Группа | Сколько | Интервал, шагов | Сдвиг, шагов |
|---|---|---|---|---|---|
| 1 | 0 | runner | 5 | 36 | 0 |
| 2 | 600 | tank | 2 | 90 | 0 |
| 2 | 600 | runner | 6 | 24 | 60 |

Во второй волне бегуны выходят через 60 шагов после первого танка, а скорость у них вдвое выше: 84 px/с против 42. Значит, на пути они обгоняют танков, хотя в списке врагов стоят после них. Эта деталь и ловит ошибку «первый по индексу», о которой ниже. Как считать бюджет волны, ритм и паузы между волнами, мы разбирали в статье про [волны врагов](/blog/volny-vragov-na-javascript-raspisanie-byudzhet-slozhnosti-i-pauzy); здесь таблица — просто расписание.

## Где можно ставить башню

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

```text
можно_ли(клетка, тип):
  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 в статье о евклидовом расстоянии отмечает, что при сравнении расстояний корень удобно опускать, потому что он не меняет порядок.

```text
dx = x_врага − x_башни,  dy = y_врага − y_башни
в радиусе: dx² + dy² ≤ r²
ближе: dx₁² + dy₁² < dx₂² + dy₂²   (корень не нужен)
```

Если нужно само расстояние, например чтобы показать его в отладке, есть `Math.hypot`: по MDN он возвращает корень из суммы квадратов аргументов и не переполняется на очень больших числах, порядка 10¹⁵⁴ и выше. Для пикселей карты переполнение не грозит, так что выбор между двумя записями — вопрос удобства; важно не перепутать, что с чем сравнивается.

### Радиус по клеткам

Радиус «в клетках» — это не круг, а квадрат. Если сравнивать номера клеток врага и башни через наибольшую разность по столбцу и строке, получится расстояние Чебышёва: по Wikipedia, это наибольшая из разностей по координатам, а на шахматной доске — число ходов короля. Зона такой башни — квадрат 7×7 клеток при радиусе 3, и по диагонали она достаёт дальше нарисованного круга.

Башня в нашем коде перебирает всех врагов в списке; когда их сотни, кандидатов в радиусе ищут через [пространственное хеширование](/blog/prostranstvennoe-heshirovanie-stolknoveniya-soten-obektov-bez-perebora).

## Стратегии выбора цели

Из врагов в радиусе башня выбирает одного по правилу, и у каждого правила свой счёт: first — больше пройденный путь, last — меньше пройденный путь, close — меньше квадрат расстояния до башни, strong — больше здоровья. По фан-вики Bloons Wiki, в серии Bloons TD такой выбор появился в Bloons Tower Defense 3; First там — цель, ближайшая к выходу по оставшейся длине трассы, и это вариант по умолчанию для новой башни, а при ничьей у Strong берётся First.

```text
счёт(враг):  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`: урон по мёртвому не наносится, награда начисляется только при переходе из живых в мёртвые, а убирают мёртвых из списка в конце шага, чтобы не сдвигать массив посреди перебора. Почему удалять объекты лучше отложенно, мы разбирали в статье про [спавн и удаление объектов](/blog/spavn-i-udalenie-obektov-v-2d-igre-vremya-zhizni-i-puly).

```text
урон(враг, 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` — два других способа обойтись с мёртвой целью.

```js
// 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;
}
```

```js
// 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 раз подряд, вывод совпадал байт в байт.

**Вывод прогона:**

```text
# 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 золотых на старте.

1. **Прогнать как есть.** Раздел 5 вывода, строка strong: убито 7, прорвались 6, у базы 4 жизни.
2. **Посмотреть, кого выбирает башня.** Снимок в разделе 4: strong выбирает танка #1 с 14 здоровья, а бегуны в это время идут мимо. По таблице волн бегуны второй волны вдвое быстрее танков и выходят позже.
3. **Сменить стратегию на first по пройденному пути.** Ни таблицы, ни места башен не трогаем.
4. **Прогнать снова.** Строка first: убито 13, прорвалось 0, жизней 10, золото 34.
5. **Проверить, что «первый» считается по пути.** Строка index в том же разделе: прорвались 3. Если ваш результат совпал с ней, а не с first, у вас выбор по индексу массива.

Проверяемый итог: строка first в разделе 5 показывает 0 прорывов и 34 золотых. На эти деньги можно поставить ещё башни к третьей волне, и тогда проверку из раздела 3 — путь, камень, занято, мало золота — стоит прогнать для каждой новой клетки.

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

Заданный путь, выбор цели по пройденному расстоянию и одиночные выстрелы подходят для классической карты с одной дорогой; вот где этого мало:

- **Лабиринт из башен.** Если игрок строит башни на пути и меняет его, ломаную нужно искать заново после каждой постройки, а «пройдено» у врага теряет смысл; сравнивают оставшийся путь до базы. Поиск пути — в статье про [A* на тайловой сетке](/blog/algoritm-a-star-poiska-puti-na-tajlovoj-setke).
- **Несколько дорог.** Пройденные расстояния на разных путях нельзя сравнивать напрямую; для first берут оставшееся до базы расстояние по своему пути.
- **Урон по площади и цепи.** Взрыв или молния бьют по нескольким врагам сразу; нужен отдельный поиск всех целей в зоне попадания, а награда по-прежнему — один раз за смерть.
- **Враг быстрее снаряда.** Снаряд, который догоняет цель, не догонит врага, который движется быстрее него; тогда нужен выстрел с упреждением или мгновенное попадание.
- **Сотни врагов.** Каждая башня в нашем коде перебирает весь список врагов каждый шаг; на больших волнах кандидатов ищут через пространственную сетку.

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

**Источники (проверено: 12.11.2026, все страницы открываются с HTTP 200):** [Wikipedia — Polygonal chain](https://en.wikipedia.org/wiki/Polygonal_chain) (ломаная — кривая из последовательности вершин и отрезков между соседними); [Wikipedia — Euclidean distance, раздел Squared Euclidean distance](https://en.wikipedia.org/wiki/Euclidean_distance) (при сравнении расстояний корень можно опустить, порядок не меняется); [Wikipedia — Chebyshev distance](https://en.wikipedia.org/wiki/Chebyshev_distance) (наибольшая из разностей по координатам; ходы короля на шахматной доске); [MDN — Math.hypot()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/hypot) (корень из суммы квадратов; без переполнения при числах больше примерно 10¹⁵⁴); [Bloons Wiki — Targeting priority](https://www.bloonswiki.com/Targeting_priority) (фан-вики: выбор цели с Bloons Tower Defense 3; First — ближайший к выходу по оставшейся длине трассы, вариант по умолчанию; ничья у Strong — First; выбор цели не гарантирует попадание именно в неё). Карта, путь, враги, башни, волны и все числа прогона — наш пример и наш прогон в Node.js 24.22.1.

**Читайте также:**
- [Поиск пути A* на тайловой сетке: от поиска в ширину до рабочего кода на JavaScript](/blog/algoritm-a-star-poiska-puti-na-tajlovoj-setke)
- [История Tower Defense в 2D: от Rampart (1990) и модов к отдельному жанру](/blog/istoriya-tower-defense-v-2d-ot-rampart-i-modov-k-otdelnomu-zhanru)
- [Волны врагов на JavaScript: расписание, бюджет сложности и паузы](/blog/volny-vragov-na-javascript-raspisanie-byudzhet-slozhnosti-i-pauzy)
- [Пространственное хеширование: столкновения сотен объектов без проверки «каждый с каждым»](/blog/prostranstvennoe-heshirovanie-stolknoveniya-soten-obektov-bez-perebora)
- [Гонка с видом сверху на JavaScript: чекпойнты, круги и место в заезде](/blog/gonka-s-vidom-sverhu-na-javascript-chekpojnty-krugi-i-mesto-v-zaezde)
