---
title: "Деревья поведения для врагов: когда конечного автомата мало"
description: "Что такое дерево поведения в игровом ИИ и когда оно удобнее конечного автомата: тик и три статуса, последовательность, выбор и декоратор, прерывание долгого действия. Ядро на JavaScript из 5 типов узлов и враг со стражей, погоней, ударом с замахом 350 мс и отступлением к аптечке; прогон в Node.js 24 — до 9 узлов за тик, ошибка с дёрганьем на границе зоны удара и её исправление."
slug: derevya-povedeniya-dlya-vragov-kogda-konechnogo-avtomata-malo
date: 2026-11-13
updated: 2026-11-13
scheduled_at: "2026-11-13T09:00:00+03:00"
rubric: logika-i-arhitektura
tags: ["derevo-povedeniya", "ii-vragov", "arhitektura", "javascript", "profi"]
reading_time: 19
draft: false
summary: "Дерево поведения — способ описать ИИ врага не переходами между состояниями, а деревом задач: каждый кадр корень опрашивает ветки по приоритету, и каждая отвечает «успех», «провал» или «выполняется». Новое поведение, например отступление при малом здоровье, добавляется одной веткой и не требует правки остальных, а долгое действие вроде замаха прерывается само, как только сработала ветка важнее. Ядро умещается в 5 типов узлов на JavaScript; цена — повторная проверка условий на каждом тике и необходимость гасить дёрганье на границах условий."
---

## Коротко

Дерево поведения описывает ИИ врага как дерево задач: каждый кадр корень опрашивает ветки по приоритету, и каждая отвечает «успех», «провал» или «выполняется». Оно выгоднее конечного автомата, когда у врага больше трёх-четырёх поведений и новые добавляются часто: отступление при малом здоровье — одна новая ветка без правки остальных, а начатый замах прерывается сам, если сработала ветка важнее. Ядро на JavaScript — 5 типов узлов и около 60 строк; плата — повторные проверки условий на каждом тике и дёрганье на границах условий, которое гасят запасом в несколько пикселей.

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

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

## Когда конечного автомата становится мало

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

Возьмём стражника с четырьмя поведениями: патруль, погоня, удар, отступление к аптечке при малом здоровье. В автомате на это нужно 8 переходов (наш подсчёт):

| Откуда | Куда | Условие |
|---|---|---|
| Патруль | Погоня | игрок ближе 96 px |
| Погоня | Патруль | игрок дальше 96 px |
| Погоня | Удар | игрок ближе 20 px |
| Удар | Погоня | удар нанесён |
| Патруль | Отступление | здоровье ≤ 30 |
| Погоня | Отступление | здоровье ≤ 30 |
| Удар | Отступление | здоровье ≤ 30 |
| Отступление | Патруль | вылечился |

Последние четыре строки появились, когда добавили одно поведение «отступить», и три из них правят уже готовые состояния. Колледанчизе и Эгрен в книге «Behavior Trees in Robotics and AI» (arXiv, 2017) сравнивают такие переходы с оператором `goto`: это односторонняя передача управления, и чтобы система быстро реагировала, переходов нужно много. Если убрать состояние, придётся пересмотреть все переходы в него, а внутри полностью связанной группы из n состояний их n(n − 1): для 4 состояний — 12, для 5 — 20.

## Как устроено дерево поведения: тик и три статуса

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

- **успех** (success) — цель достигнута;
- **провал** (failure) — не получилось или условие ложно;
- **выполняется** (running) — действие ещё идёт, спросите в следующем кадре.

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

Подход пришёл из игр: статья Википедии о деревьях поведения ссылается на доклад Дэмиана Айлы «Handling Complexity in the Halo 2 AI» с GDC 2005 (сама Halo 2 вышла у Bungie в 2004 году) и называет среди игр с деревьями поведения Halo, Bioshock и Spore. Сейчас деревья поведения есть в Unity и Unreal Engine и применяются в робототехнике.

## Шесть типов узлов

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

| Узел | Что делает | Успех | Провал | Выполняется |
|---|---|---|---|---|
| Последовательность (→) | опрашивает детей слева направо | все дети — успех | первый провал | первый «выполняется» |
| Выбор, fallback (?) | опрашивает детей слева направо | первый успех | все дети — провал | первый «выполняется» |
| Параллельный (⇉) | тикает всех детей сразу | не меньше M успехов | больше N − M провалов | иначе |
| Декоратор (◇) | меняет статус или решает, тикать ли ребёнка | по своему правилу | по своему правилу | по своему правилу |
| Действие | делает что-то в мире | закончило | невозможно | ещё идёт |
| Условие | проверяет утверждение | истина | ложь | никогда |

Последовательность — это «И»: открой дверь, затем пройди. Выбор — это «ИЛИ» с приоритетом: если первый вариант не сработал, попробуй следующий. Декораторы — инвертор, «не больше N попыток», «не дольше T секунд», перезарядка. Параллельный узел нужен реже, в нашем примере его нет.

## Дерево врага-стражника

Дерево того же стражника — выбор из четырёх веток, расставленных по приоритету слева направо (сверху вниз в схеме):

```text
? враг
├─ → отступление
│   ├─ условие: здоровье ≤ 30
│   └─ действие: бежать к аптечке (x = 10) и вылечиться до 100
├─ → атака
│   ├─ условие: игрок в досягаемости (20 px, во время замаха 28 px)
│   └─ ◇ перезарядка 1 с
│       └─ действие: замах 350 мс, затем удар на 10 HP
├─ → погоня
│   ├─ условие: игрок ближе 96 px
│   └─ действие: бежать к игроку со скоростью 70 px/с
└─ действие: патруль между x = 40 и x = 200 со скоростью 40 px/с
```

Отступление добавлено одной верхней веткой из двух узлов, и ни одну из старых веток для этого не правили. Приоритет задаётся порядком: здоровье проверяется первым в каждом тике, поэтому никакое другое поведение не помешает врагу сбежать. Замах 350 мс — из диапазона 250–400 мс для честного предупреждения, который мы разбирали в статье о патрулировании врагов. Все числа в схеме — параметры нашего примера, а не правило.

## Ядро и враг на JavaScript, прогон в Node.js

Ядро — пять функций-конструкторов узлов (`condition`, `action`, `sequence`, `selector`, `cooldown`) и функция `tickTree`, которая делает один тик и прерывает брошенные действия. Код ниже — один файл без зависимостей: сохраните как `bt.mjs` и запустите `node bt.mjs`. Мы проверяли его в Node.js 24.22.1. Враг живёт на одной горизонтали, координаты — в пикселях, время — в секундах, шаг — 1/60 с. Сценарий на 10 секунд: игрок стоит справа, с 3-й секунды идёт навстречу до x = 150, а на 7-й секунде ранит врага на 75 HP.

```js
// Дерево поведения врага: ядро и прогон сценария в Node.js
const SUCCESS = 'success', FAILURE = 'failure', RUNNING = 'running';

// Листья: условие отвечает «да/нет», действие может длиться несколько кадров
const condition = (name, test) => ({
  tick(ctx) { ctx.visits++; return test(ctx) ? SUCCESS : FAILURE; },
});
const action = (name, run, halt = () => {}) => ({
  name, halt,
  tick(ctx) {
    ctx.visits++;
    const status = run(ctx);
    ctx.branch = name;
    if (status === RUNNING) ctx.running.add(this);
    return status;
  },
});

// Последовательность: идёт слева направо, пока дети отвечают «успех»
const sequence = (...children) => ({
  tick(ctx) {
    ctx.visits++;
    for (const child of children) {
      const status = child.tick(ctx);
      if (status !== SUCCESS) return status;
    }
    return SUCCESS;
  },
});
// Выбор: первый ребёнок, который не провалился, решает за всех
const selector = (...children) => ({
  tick(ctx) {
    ctx.visits++;
    for (const child of children) {
      const status = child.tick(ctx);
      if (status !== FAILURE) return status;
    }
    return FAILURE;
  },
});
// Декоратор: после успешного удара ветка «закрыта» на seconds секунд
const cooldown = (seconds, child) => {
  let readyAt = 0;
  return {
    tick(ctx) {
      ctx.visits++;
      if (ctx.time < readyAt) return FAILURE;
      const status = child.tick(ctx);
      if (status === SUCCESS) readyAt = ctx.time + seconds;
      return status;
    },
  };
};

// Один тик дерева: всё, что выполнялось в прошлом кадре и не выполняется сейчас, прерываем
function tickTree(root, ctx) {
  ctx.visits = 0;
  ctx.running = new Set();
  const status = root.tick(ctx);
  for (const a of ctx.prevRunning) if (!ctx.running.has(a)) a.halt(ctx);
  ctx.prevRunning = ctx.running;
  return status;
}

// Враг на платформе: всё в пикселях и секундах
const enemy = { x: 40, hp: 100, dir: 1, windup: 0 };
const player = { x: 300, hp: 100 };
const PATROL_A = 40, PATROL_B = 200, MEDKIT_X = 10;
const SIGHT = 96, REACH = 20, LEASH = 8, WINDUP = 0.35, DT = 1 / 60;
const moveTo = (target, speed, dt) => {
  const step = Math.sign(target - enemy.x) * Math.min(speed * dt, Math.abs(target - enemy.x));
  enemy.x += step;
};

const root = selector(
  sequence(
    condition('здоровье ≤ 30', () => enemy.hp <= 30),
    action('отступить к аптечке', (ctx) => {
      moveTo(MEDKIT_X, 90, ctx.dt);
      if (enemy.x !== MEDKIT_X) return RUNNING;
      enemy.hp = 100;
      return SUCCESS;
    }),
  ),
  sequence(
    // Во время замаха зона удара шире на LEASH px, иначе враг дёргается на границе
    condition('игрок в досягаемости', () =>
      Math.abs(player.x - enemy.x) <= REACH + (enemy.windup > 0 ? LEASH : 0)),
    cooldown(1, action('замах и удар', (ctx) => {
      enemy.windup += ctx.dt;
      if (enemy.windup < WINDUP - 1e-9) return RUNNING;
      enemy.windup = 0;
      player.hp -= 10;
      ctx.log(`удар, у игрока ${player.hp} HP`);
      return SUCCESS;
    }, (ctx) => {
      if (enemy.windup > 0) ctx.log(`замах прерван на ${Math.round(enemy.windup * 1000)} мс`);
      enemy.windup = 0;
    })),
  ),
  sequence(
    condition('игрок ближе 96 px', () => Math.abs(player.x - enemy.x) <= SIGHT),
    action('преследовать', (ctx) => {
      moveTo(player.x - Math.sign(player.x - enemy.x) * 16, 70, ctx.dt);
      return RUNNING;
    }),
  ),
  action('патрулировать', (ctx) => {
    const target = enemy.dir > 0 ? PATROL_B : PATROL_A;
    moveTo(target, 40, ctx.dt);
    if (enemy.x === target) enemy.dir *= -1;
    return RUNNING;
  }),
);

// Сценарий на 10 секунд: игрок идёт навстречу, а на 7,0 с ранит врага на 75 HP
const ctx = { dt: DT, time: 0, prevRunning: new Set(), visits: 0, branch: '' };
ctx.log = (msg) => console.log(`${ctx.time.toFixed(2)} с  ${msg}`);
let lastBranch = '', maxVisits = 0, sumVisits = 0, frames = 0;
for (let frame = 0; frame < 10 * 60; frame++) {
  ctx.time = frame * DT;
  if (ctx.time >= 3) player.x = Math.max(150, 300 - 60 * (ctx.time - 3));
  if (frame === 7 * 60) { enemy.hp -= 75; ctx.log(`игрок ранил врага, у врага ${enemy.hp} HP`); }
  tickTree(root, ctx);
  if (ctx.branch !== lastBranch) {
    ctx.log(`ветка: ${ctx.branch} (враг x = ${enemy.x.toFixed(1)}, игрок x = ${player.x.toFixed(1)})`);
    lastBranch = ctx.branch;
  }
  maxVisits = Math.max(maxVisits, ctx.visits); sumVisits += ctx.visits; frames++;
}
console.log(`узлов за тик: в среднем ${(sumVisits / frames).toFixed(1)}, максимум ${maxVisits}`);
console.log(`200 врагов × 60 тиков/с = ${(200 * 60 * maxVisits).toLocaleString('ru-RU')} вызовов tick в секунду в худшем случае`);
```

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

```text
0.00 с  ветка: патрулировать (враг x = 40.7, игрок x = 300.0)
3.45 с  ветка: преследовать (враг x = 179.2, игрок x = 273.0)
4.03 с  ветка: замах и удар (враг x = 218.8, игрок x = 238.0)
4.37 с  удар, у игрока 90 HP
4.38 с  ветка: преследовать (враг x = 220.0, игрок x = 217.0)
5.37 с  ветка: замах и удар (враг x = 175.0, игрок x = 158.0)
5.70 с  удар, у игрока 80 HP
5.72 с  ветка: преследовать (враг x = 173.8, игрок x = 150.0)
6.70 с  ветка: замах и удар (враг x = 166.0, игрок x = 150.0)
7.00 с  игрок ранил врага, у врага 25 HP
7.00 с  замах прерван на 300 мс
7.00 с  ветка: отступить к аптечке (враг x = 164.5, игрок x = 150.0)
8.73 с  ветка: патрулировать (враг x = 10.7, игрок x = 150.0)
9.85 с  ветка: преследовать (враг x = 55.8, игрок x = 150.0)
узлов за тик: в среднем 7.4, максимум 9
200 врагов × 60 тиков/с = 108 000 вызовов tick в секунду в худшем случае
```

Журнал показывает, как дерево переключает ветки без единого явного перехода. В 3,45 с игрок вошёл в зону 96 px, и включилась погоня. В 4,03 с враг дотянулся до игрока; ровно через 21 кадр, на 4,37 с, прошёл удар, и перезарядка 1 с вернула врага в погоню. На 7,00 с здоровье упало до 25, и верхняя ветка перехватила управление посреди замаха. Отступление к x = 10 со скоростью 90 px/с заняло 1,73 с, после чего враг вылечился и сам вернулся к патрулю, а затем к погоне.

## Прерывание: зачем действию функция остановки

Функция остановки нужна, потому что дерево не сообщает действию, что его бросили: в следующем кадре до него просто не доходит тик. Если ничего не сделать, в объекте врага останется недокрученный замах — 300 мс из 350, — и когда враг вернётся к атаке, удар случится через 50 мс, без честного предупреждения.

Поэтому `tickTree` помнит, какие действия вернули «выполняется» в прошлом кадре. Всё, что было в этом списке и не попало в него сейчас, получает вызов `halt`. В нашем примере `halt` сбрасывает `enemy.windup`; в настоящей игре он ещё остановит анимацию замаха и звук. Строка «замах прерван на 300 мс» в выводе — это и есть такая остановка в момент, когда сработала ветка отступления.

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

## Ошибка прогона: дёрганье на границе зоны удара

В первом прогоне враг дёргался между погоней и ударом, потому что зона удара проверялась одним и тем же порогом 20 px в обе стороны. Игрок отходил на 1 px за кадр, расстояние колебалось около 20 px, и с `LEASH = 0` журнал между 5,37 с и 5,52 с выглядел так:

```text
5.37 с  ветка: замах и удар (враг x = 175.0, игрок x = 158.0)
5.42 с  замах прерван на 50 мс
5.42 с  ветка: преследовать (враг x = 173.8, игрок x = 155.0)
5.43 с  ветка: замах и удар (враг x = 173.8, игрок x = 154.0)
5.45 с  замах прерван на 17 мс
5.45 с  ветка: преследовать (враг x = 172.7, игрок x = 153.0)
5.52 с  ветка: замах и удар (враг x = 169.2, игрок x = 150.0)
```

За 0,15 с враг дважды начал и бросил замах — на экране это выглядит как дрожь анимации. Исправление — гистерезис: пока замах идёт, зона удара шире на `LEASH = 8` px, то есть 28 px вместо 20. С ним второй удар начался в 5,37 с и прошёл в 5,70 с без прерываний, как в основном выводе выше. Тот же эффект в книге о деревьях поведения показан на примере робота, который мечется между подзарядкой и работой около порога 20 % батареи; лечится он так же — разными порогами входа и выхода.

Правило для своих деревьев: у каждого условия, которое охраняет долгое действие, должен быть запас на выход. Это расстояние, время или значение здоровья, на которое условие «держится» после срабатывания.

## Сколько стоит обход дерева

В нашем примере один тик дерева стоит от 7 до 9 вызовов `tick`, в среднем 7,4 за 600 кадров. Максимум 9 получается, когда игрок в досягаемости, но перезарядка ещё не прошла: выбор проверяет отступление, атаку с декоратором и только потом погоню.

```text
200 врагов × 60 тиков/с × 9 вызовов = 108 000 вызовов tick в секунду
```

Это наш расчёт для этого маленького дерева. Сами вызовы дешёвые, дорого то, что внутри условий: поиск пути, проверка видимости лучом, перебор соседей. Если условие дорогое, его считают реже, например раз в 5–10 кадров, и кладут результат в объект врага, а дерево читает уже готовое значение. Для отладки полезно выводить имя активной ветки над врагом — как в нашем журнале, только на экране; это легко добавить в [отладочный оверлей](/blog/otladochnyj-overlej-na-javascript-hitboksy-fps-i-zhurnal-sobytij).

## Узлы с памятью: когда реакция не нужна

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

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

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

Дерево поведения — не замена всему, и в нескольких случаях оно хуже простых решений:

- **Враг с одним-двумя поведениями.** Патрульному из статьи о читаемых опасностях хватает автомата из трёх фаз или даже `switch`; дерево добавит код, но не ясность.
- **Герой под управлением игрока.** Состояния героя меняет ввод, а не приоритеты ИИ; здесь удобнее конечный автомат с иерархией и стеком.
- **Поведение «что выгоднее», а не «что важнее».** Порядок веток в дереве жёсткий. Если враг должен взвешивать десяток факторов — расстояние, патроны, здоровье, укрытия, — удобнее подход с очками полезности или вычисление приоритета внутри узла.
- **Сценарный босс с фиксированными фазами.** Если поведение — заранее известная последовательность атак по таймеру, проще описать её списком фаз, чем деревом.
- **Дорогие условия у сотен врагов.** Обход дерева каждый кадр перепроверяет все условия слева от активной ветки. Если они дорогие, придётся кешировать результаты или тикать дерево реже, и выигрыш в простоте частично теряется.

Мы разрабатываем **J2DRU** — браузерный 2D игровой движок, где игровая логика собирается из событий, условий и действий, а то, что неудобно выразить событиями, можно вынести в скрипты на TypeScript. Движок в разработке и публично пока не открыт, заявку можно оставить на [странице раннего доступа](/early-access?utm_source=blog&utm_medium=article&utm_campaign=derevya-povedeniya-dlya-vragov-kogda-konechnogo-avtomata-malo) (подача заявки не гарантирует приглашение).

**Источники (проверено: ноябрь 2026, 11.11.2026):** [Michele Colledanchise, Petter Ögren — «Behavior Trees in Robotics and AI: An Introduction», arXiv:1709.00084](https://arxiv.org/abs/1709.00084) (тик и статусы, последовательность, fallback, параллельный узел, декораторы, условия без статуса «выполняется», реактивность, узлы с памятью, сравнение переходов автомата с `goto`, n(n − 1) переходов в полностью связанной группе, пример с подзарядкой около 20 %); [Wikipedia — Behavior tree (artificial intelligence, robotics and control)](https://en.wikipedia.org/wiki/Behavior_tree_(artificial_intelligence,_robotics_and_control)) (определение, ссылка на доклад D. Isla «Handling complexity in the Halo 2 AI», GDC 2005, применение в Halo, Bioshock, Spore, наличие в Unity и Unreal Engine); [Wikipedia — Halo 2](https://en.wikipedia.org/wiki/Halo_2) (Bungie, 2004); [Robert Nystrom — Game Programming Patterns, глава State](https://gameprogrammingpatterns.com/state.html) (ограничения конечных автоматов и отсылка к деревьям поведения). Параметры врага, подсчёт переходов автомата, число вызовов `tick` и расчёт для 200 врагов — наш пример и наш прогон в Node.js 24.22.1.

**Читайте также:**
- [Конечный автомат персонажа в платформере: от флагов isJumping к состояниям, иерархии и стеку](/blog/konechnyj-avtomat-personazha-platformera)
- [Патрулирование врагов и читаемые опасности: как настроить честные столкновения и окно предупреждения](/blog/patrulirovanie-vragov-i-chitaemye-opasnosti)
- [Издатель и подписчик в игре: порядок доставки событий, отписка и утечки памяти](/blog/izdatel-i-podpischik-v-igre-poryadok-sobytij-otpiska-i-utechki)
