Коротко
Дерево поведения описывает ИИ врага как дерево задач: каждый кадр корень опрашивает ветки по приоритету, и каждая отвечает «успех», «провал» или «выполняется». Оно выгоднее конечного автомата, когда у врага больше трёх-четырёх поведений и новые добавляются часто: отступление при малом здоровье — одна новая ветка без правки остальных, а начатый замах прерывается сам, если сработала ветка важнее. Ядро на JavaScript — 5 типов узлов и около 60 строк; плата — повторные проверки условий на каждом тике и дёрганье на границах условий, которое гасят запасом в несколько пикселей.
Содержание
- Когда конечного автомата становится мало
- Как устроено дерево поведения: тик и три статуса
- Шесть типов узлов
- Дерево врага-стражника
- Ядро и враг на JavaScript, прогон в Node.js
- Прерывание: зачем действию функция остановки
- Ошибка прогона: дёрганье на границе зоны удара
- Сколько стоит обход дерева
- Узлы с памятью: когда реакция не нужна
- Когда вам это не подойдёт
Когда конечного автомата становится мало
Конечного автомата становится мало, когда переходов между состояниями больше, чем самих состояний, и каждое новое поведение требует правки старых. Для героя платформера из статьи о конечном автомате хватает пяти состояний, и это нормальный выбор. У врага всё иначе: он должен в любой момент бросить текущее дело, если случилось что-то важнее.
Возьмём стражника с четырьмя поведениями: патруль, погоня, удар, отступление к аптечке при малом здоровье. В автомате на это нужно 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 секунд», перезарядка. Параллельный узел нужен реже, в нашем примере его нет.
Дерево врага-стражника
Дерево того же стражника — выбор из четырёх веток, расставленных по приоритету слева направо (сверху вниз в схеме):
? враг
├─ → отступление
│ ├─ условие: здоровье ≤ 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.
// Дерево поведения врага: ядро и прогон сценария в 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 в секунду в худшем случае`);
Вывод прогона:
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 с выглядел так:
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 получается, когда игрок в досягаемости, но перезарядка ещё не прошла: выбор проверяет отступление, атаку с декоратором и только потом погоню.
200 врагов × 60 тиков/с × 9 вызовов = 108 000 вызовов tick в секунду
Это наш расчёт для этого маленького дерева. Сами вызовы дешёвые, дорого то, что внутри условий: поиск пути, проверка видимости лучом, перебор соседей. Если условие дорогое, его считают реже, например раз в 5–10 кадров, и кладут результат в объект врага, а дерево читает уже готовое значение. Для отладки полезно выводить имя активной ветки над врагом — как в нашем журнале, только на экране; это легко добавить в отладочный оверлей.
Узлы с памятью: когда реакция не нужна
Узел с памятью — это последовательность или выбор, которые не перепроверяют уже завершённых детей, пока вся последовательность не закончится. Обычная последовательность каждый тик начинает с первого ребёнка; последовательность с памятью продолжает с того, на котором остановилась.
Это нужно для цепочек, которые нельзя отыгрывать заново: «подойти к рычагу → дёрнуть → отбежать». Если после рывка условие «рядом с рычагом» перестало выполняться, обычная последовательность вернётся к первому шагу и враг снова побежит к рычагу. В книге Колледанчизе и Эгрена такие узлы советуют только там, где ничто внешнее не может отменить сделанное, иначе дерево теряет реакцию на события. В коде это одно поле с индексом текущего ребёнка, которое сбрасывается при успехе или провале всей последовательности.
Когда вам это не подойдёт
Дерево поведения — не замена всему, и в нескольких случаях оно хуже простых решений:
- Враг с одним-двумя поведениями. Патрульному из статьи о читаемых опасностях хватает автомата из трёх фаз или даже
switch; дерево добавит код, но не ясность. - Герой под управлением игрока. Состояния героя меняет ввод, а не приоритеты ИИ; здесь удобнее конечный автомат с иерархией и стеком.
- Поведение «что выгоднее», а не «что важнее». Порядок веток в дереве жёсткий. Если враг должен взвешивать десяток факторов — расстояние, патроны, здоровье, укрытия, — удобнее подход с очками полезности или вычисление приоритета внутри узла.
- Сценарный босс с фиксированными фазами. Если поведение — заранее известная последовательность атак по таймеру, проще описать её списком фаз, чем деревом.
- Дорогие условия у сотен врагов. Обход дерева каждый кадр перепроверяет все условия слева от активной ветки. Если они дорогие, придётся кешировать результаты или тикать дерево реже, и выигрыш в простоте частично теряется.
Мы разрабатываем J2DRU — браузерный 2D игровой движок, где игровая логика собирается из событий, условий и действий, а то, что неудобно выразить событиями, можно вынести в скрипты на TypeScript. Движок в разработке и публично пока не открыт, заявку можно оставить на странице раннего доступа (подача заявки не гарантирует приглашение).
Источники (проверено: ноябрь 2026, 11.11.2026): Michele Colledanchise, Petter Ögren — «Behavior Trees in Robotics and AI: An Introduction», arXiv:1709.00084 (тик и статусы, последовательность, fallback, параллельный узел, декораторы, условия без статуса «выполняется», реактивность, узлы с памятью, сравнение переходов автомата с goto, n(n − 1) переходов в полностью связанной группе, пример с подзарядкой около 20 %); Wikipedia — 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 (Bungie, 2004); Robert Nystrom — Game Programming Patterns, глава State (ограничения конечных автоматов и отсылка к деревьям поведения). Параметры врага, подсчёт переходов автомата, число вызовов tick и расчёт для 200 врагов — наш пример и наш прогон в Node.js 24.22.1.
Читайте также: