Utility AI: враг выбирает действие по очкам полезности

Коротко

В utility AI враг каждый раз оценивает все свои действия числом от 0 до 1 и выполняет то, у которого больше очков, а не идёт по переходам автомата или веткам дерева. Очки действия — произведение нескольких соображений, каждое переведено из игрового значения кривой ответа, и ноль любого соображения запрещает действие целиком. Чтобы враг не метался между близкими вариантами, решают раз в 0,2 с и дают текущему действию бонус инерции: в нашем прогоне смен действия за 10 секунд стало 6 вместо 303.

Содержание

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

Что решает выбор по полезности

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

Дэвид Грэм (David "Rez" Graham) в главе «An Introduction to Utility Theory» книги Game AI Pro (CRC Press, 2013) описывает суть так: все возможные действия оцениваются разом, и выбирается одно из действий с наибольшей оценкой. Оценки должны быть в одной шкале по всей системе, и удобная шкала — от 0 до 1. На GDC 2010 в рамках AI Summit этой теме был посвящён доклад Дэйва Марка и Кевина Дилла «Improving AI Decision Modeling Through Utility Theory»: в его описании резкий переход «да/нет» в условиях if назван причиной такого же резкого поведения, а кривые ответа и взвешенная случайность — способом его смягчить.

Пример, на котором видна разница. Стрелок ранен до 30 из 100, аптечка в 300 px. В автомате нужен порог вида «здоровье ≤ 30 → к аптечке», и при 31 враг стоит под огнём до последнего. В выборе по полезности желание лечиться растёт плавно, а итог зависит ещё и от расстояния до аптечки: близкая аптечка перевешивает раньше, далёкая — позже. Ниже это видно в прогоне: при аптечке в 300 px враг уходит лечиться на 25 единицах здоровья, при аптечке в 600 px — только на 10.

Действие, соображение, кривая ответа

Система состоит из трёх частей: действие — то, что враг может сделать; соображение — один фактор «за» или «против» этого действия; кривая ответа — функция, которая переводит игровое значение в число от 0 до 1 для соображения. Грэм называет соображения decision factors, у Марка и Дилла и в большинстве докладов о технике — considerations.

Набор действий стрелка из нашего примера:

ДействиеКорзинаСоображенияВход и кривая
Стрелятьбойвидит, дальность, патроны, смелостьвидит — 0 или 1; дальность — 1 до 160 px, 0 к 320 px; патроны — 0,4 + 0,6 × доля магазина, 0 при пустом; смелость — √(здоровье)
Сблизитьсябойвидит, далеко, здоровьедалеко — логистическая ступенька около 200 px; здоровье — линейно
Перезарядитьбойпусто, безопаснопусто — (1 − доля магазина)²; безопасно — 0,3…1 по расстоянию 80–320 px
К аптечкебойранен, аптечкаранен — кусочно-линейная по точкам; аптечка — 1 − 0,6 × (расстояние / 600 px), 0 если аптечки нет
Патрульпокойвсегдаконстанта 0,5

Все пороги и коэффициенты — наш пример для арены 640 × 360 px, а не стандарт. Наше правило настройки: значение «нормально» должно давать 1, а не что-то посередине. Тогда соображение тянет итог вниз, только когда действительно говорит «плохо».

Четыре кривые и когда какую брать

Почти любое соображение покрывается четырьмя кривыми: линейной, степенной, логистической и кусочно-линейной. Грэм в Game AI Pro разбирает именно эти типы; формулы ниже — наша запись для кода.

линейная:          u = (x − lo) / (hi − lo), обрезано до 0…1
степенная:         u = линейная^k      k > 1 — медленный старт, k < 1 — быстрый
логистическая:     u = 1 / (1 + e^(−(x − mid) / w))   ступенька около mid, ширина w
кусочно-линейная:  точки [x, u], между ними — линейная интерполяция
КриваяКогда братьПример из стрелка
Линейнаяфактор важен равномерно во всём диапазоне«здоровье» у сближения
Степенная, k < 1важно не опуститься совсем низко, середина почти не влияет«смелость» = √(здоровье): при 50 из 100 — 0,71
Степенная, k > 1фактор включается ближе к краю«пусто» = (1 − доля)²: при половине магазина — 0,25
Логистическаянужен порог, но без резкого скачка«далеко»: 0,08 при 140 px, 0,5 при 200 px
Кусочно-линейнаядизайнеру нужна точная форма: «до 70 % не важно, потом резко»«ранен»: 0 при 70 % здоровья, 0,3 при 50 %, 0,9 при 25 %

Кусочно-линейная кривая — самая удобная для настройки руками. По словам Грэма, именно такие кривые использует The Sims для потребности «голод»: сим не обращает внимания на голод до порога, потом слегка голоден, потом очень. Точки кривой можно вынести в данные уровня или в таблицу баланса, и геймдизайнер правит их без программиста.

Как сложить соображения: произведение и вето

Соображения одного действия удобнее перемножать: ноль любого соображения обнуляет действие, а единица итог не меняет. Так «видит игрока» и «есть патроны» работают как условия-вето без отдельной логики: нет патронов — стрельба получает 0 при любых других факторах. В демо к главе Грэма оценка лечения тоже получается произведением: желание лечиться × угроза.

У произведения есть плата — много факторов чуть меньше 1 вместе дают маленькое число (наш расчёт):

Соображений по 0,8ПроизведениеСреднее геометрическое
10,8000,800
20,6400,800
40,4100,800
80,1680,800

Действие с восемью «неплохими» соображениями проигрывает действию с одним, хотя по смыслу они равны. Первое, что приходит в голову, — заменить произведение на среднее геометрическое: оно не проседает от числа факторов и тоже даёт вето на нуле. Мы так и сделали в первой версии и получили другую ошибку — она разобрана в разделе с кодом. Рабочее правило вышло проще: 2–4 соображения на действие и кривые, у которых «нормально» = 1.

Кроме соображений у действия может быть вес — множитель всего итога. Грэм описывает веса, которые показывают, насколько ИИ важен фактор, как способ задать характер. Проще всего начать с веса всего действия: трусливый стрелок с весом лечения, например, 1,3 уходит к аптечке раньше храброго с весом 0,8 при одних и тех же кривых.

Как выбрать действие: лучшее, случайное из лучших, корзины

Есть три способа выбрать действие по очкам: взять максимум, взять случайное с вероятностью по очкам или взять случайное среди близких к лучшему. Грэм разбирает все три:

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

Для третьего способа Грэм предлагает брать либо несколько лучших действий, либо все, что не хуже лучшего, например, на 10 %. В нашем прогоне при оценках 0,50, 0,47 и 0,30 и полосе 10 % за 1000 решений первое выбрано 533 раза, второе — 467, третье — ни разу: 0,30 вне полосы. Случайность берут из генератора с зерном, чтобы странное решение врага можно было повторить.

Корзины решают другую проблему: некоторые действия не нужно даже сравнивать. Грэм приводит пример охранника в шутере: когда по нему стреляют, он не должен взвешивать «попить кофе» против «укрыться». Действия делят на корзины с приоритетом и сначала ищут подходящее действие в старшей корзине; к младшей переходят, только если в старшей все оценки ниже порога. Этот приём он называет bucketing или dual utility AI со ссылкой на работу Кевина Дилла (2011). У нашего стрелка две корзины: «бой» и «покой» с патрулём, порог — 0,05. Поэтому патруль с оценкой 0,5 никогда не перебивает стрельбу с оценкой 0,45, а начинается, только когда игрок пропал из виду.

Инерция: почему враг дёргается и как это лечится

Враг дёргается, когда два действия получают почти равные очки и мелкое изменение входа каждый кадр перекидывает победу. Грэм описывает ровно этот случай: солдат оценивает «атаковать» и «убежать» по 0,5, решает каждый кадр, стреляет, бежит, снова стреляет. Он предлагает три средства: бонус к текущему действию, время, в течение которого текущее действие держится, и откладывание нового решения — например, в The Sims Medieval сим выбирал действие, только когда его очередь взаимодействий пустела.

Мы проверили это на границе «стрелять / сблизиться». При здоровье 70 оценки сравниваются между 220 и 225 px: при 220 px стрельба — 0,52, сближение — 0,48, при 225 px — уже 0,50 против 0,51. Игрок в симуляции мечется на ±25 px вокруг 225 px, 10 секунд по 60 кадров (наш прогон):

Как решает врагСмен действия за 10 с
Каждый кадр, без инерции303
Раз в 0,2 с, без инерции20
Раз в 0,2 с, бонус +0,15 и минимум 0,5 с6

Решение каждый кадр даёт 30 смен в секунду — враг буквально дрожит на месте. Решение раз в 0,2 с убирает основную часть, а бонус и минимальное время делают каждую смену осмысленной. Бонус подбирают по тому, насколько оценки меняются от шума входа: здесь 50 px разброса сдвигают обе оценки примерно на 0,25, и бонус 0,1 оставлял 9 смен, а 0,2 — 4. Одно исключение обязательно: если текущее действие стало невозможным (кончились патроны, и оценка стрельбы — 0), минимальное время не действует, и враг переключается сразу.

Код на JavaScript и проверка в Node.js

Модуль ниже содержит кривые, оценку действий, выбор с корзинами и полосой случайности и «мозг» врага с периодом решений и инерцией. Он ничего не рисует, поэтому проверяется в Node.js без браузера.

// utility.mjs — выбор действия врага по очкам полезности (utility AI)
// Кривые ответа: переводят игровое значение в число от 0 до 1
export const clamp01 = v => Math.max(0, Math.min(1, v));
export const linear = (x, lo, hi) => clamp01((x - lo) / (hi - lo));          // 0 при lo, 1 при hi
export const power = (x, lo, hi, k) => linear(x, lo, hi) ** k;              // k > 1 — медленный старт, k < 1 — быстрый
export const logistic = (x, mid, width) => 1 / (1 + Math.exp(-(x - mid) / width)); // плавная ступенька около mid
export function piecewise(points) {                                         // [[x, y], …] по возрастанию x
  return x => {
    if (x <= points[0][0]) return points[0][1];
    for (let i = 1; i < points.length; i++) {
      const [x0, y0] = points[i - 1], [x1, y1] = points[i];
      if (x <= x1) return y0 + (y1 - y0) * (x - x0) / (x1 - x0);
    }
    return points[points.length - 1][1];
  };
}

// Итог действия: произведение соображений. Ноль у любого — вето (действие невозможно),
// а соображение, равное 1, итог не меняет. Плата: много факторов чуть меньше 1 тянут итог вниз.
export const product = values => values.reduce((a, b) => a * b, 1);
// Для сравнения: среднее геометрическое — не проседает от числа факторов, но размывает сильный сигнал
export const geomean = values => values.some(v => v <= 0) ? 0 : product(values) ** (1 / values.length);

// Оценить все действия: [{ name, bucket, score, parts }]
export function scoreAll(actions, ctx, combine = product) {
  return actions.map(a => {
    const parts = Object.fromEntries(Object.entries(a.considerations).map(([k, f]) => [k, clamp01(f(ctx))]));
    return { name: a.name, bucket: a.bucket, score: combine(Object.values(parts)) * (a.weight ?? 1), parts };
  });
}

// Выбор: старшая корзина, где есть действие не ниже minScore; внутри — лучшее или
// взвешенная случайность среди тех, кто не хуже лучшего более чем на band (доля).
export function choose(scored, { minScore = 0.05, band = 0, rand = Math.random } = {}) {
  const buckets = [...new Set(scored.map(s => s.bucket))].sort((a, b) => b - a);
  for (const b of buckets) {
    const live = scored.filter(s => s.bucket === b && s.score >= minScore);
    if (!live.length) continue;
    const best = Math.max(...live.map(s => s.score));
    const top = live.filter(s => s.score >= best * (1 - band));
    if (top.length === 1) return top[0];
    const sum = top.reduce((s, x) => s + x.score, 0);
    let r = rand() * sum;
    for (const s of top) { r -= s.score; if (r <= 0) return s; }
    return top[top.length - 1];
  }
  return null;
}

// Мозг врага: решает не каждый кадр, а раз в period секунд; текущее действие получает
// бонус инерции и не сменится раньше minCommit секунд
export function createBrain(actions, { period = 0.2, inertia = 0.15, minCommit = 0.5, ...opt } = {}) {
  let current = null, since = Infinity, timer = 0;
  return {
    get current() { return current; },
    update(dt, ctx) {
      since += dt; timer -= dt;
      if (timer > 1e-9) return current;
      timer = period;
      const scored = scoreAll(actions, ctx);
      const cur = scored.find(s => s.name === current);
      if (cur && cur.score > 0) {
        if (since < minCommit - 1e-9) return current;     // ещё не отработали минимум
        cur.score = Math.min(1, cur.score + inertia);
      }
      const pick = choose(scored, opt);
      const next = pick ? pick.name : null;
      if (next !== current) { current = next; since = 0; }
      return current;
    },
  };
}

Набор действий стрелка — отдельный файл с данными: кривые и точки, которые правит геймдизайнер.

// enemy.mjs — набор действий стрелка: оценки зависят от здоровья, патронов и расстояния
import { linear, power, logistic, piecewise } from './utility.mjs';

const lowHp = piecewise([[0, 1], [0.25, 0.9], [0.5, 0.3], [0.7, 0]]);      // «как сильно хочется лечиться»
const inRange = piecewise([[0, 1], [160, 1], [320, 0]]);                      // дальность выстрела, px

export const ACTIONS = [
  { name: 'стрелять', bucket: 1, considerations: {
      видит: c => c.sees ? 1 : 0,
      дальность: c => inRange(c.dist),
      патроны: c => c.ammo > 0 ? 0.4 + 0.6 * c.ammo / c.maxAmmo : 0,
      смелость: c => power(c.hp, 0, c.maxHp, 0.5) } },
  { name: 'сблизиться', bucket: 1, considerations: {
      видит: c => c.sees ? 1 : 0,
      далеко: c => logistic(c.dist, 200, 25),
      здоровье: c => linear(c.hp, 0, c.maxHp) } },
  { name: 'перезарядить', bucket: 1, considerations: {
      пусто: c => power(1 - c.ammo / c.maxAmmo, 0, 1, 2),
      безопасно: c => 0.3 + 0.7 * linear(c.dist, 80, 320) } },
  { name: 'к аптечке', bucket: 1, considerations: {
      ранен: c => lowHp(c.hp / c.maxHp),
      аптечка: c => c.medkit === null ? 0 : 1 - 0.6 * linear(c.medkit, 0, 600) } },
  { name: 'патруль', bucket: 0, considerations: { всегда: () => 0.5 } },
];

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

import { scoreAll, choose, product, geomean, createBrain } from './utility.mjs';
import { ACTIONS } from './enemy.mjs';

// Генератор с зерном (mulberry32), чтобы прогон повторялся
function rng(seed) {
  return () => { seed = (seed + 0x6D2B79F5) | 0; let t = seed;
    t = Math.imul(t ^ (t >>> 15), t | 1); t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
    return ((t ^ (t >>> 14)) >>> 0) / 4294967296; };
}

const base = { hp: 100, maxHp: 100, ammo: 12, maxAmmo: 12, dist: 140, sees: true, medkit: 300 };
const fmt = s => s.map(x => `${x.name} ${x.score.toFixed(2)}`).join(' | ');

// 1. Одна ситуация: здоров, полный магазин, игрок в 140 px
console.log('1) здоров, 140 px:', fmt(scoreAll(ACTIONS, base)), '→', choose(scoreAll(ACTIONS, base)).name);

// 2. Здоровье падает — с какого момента враг идёт к аптечке
let prev = null;
for (let hp = 100; hp >= 0; hp -= 5) {
  const pick = choose(scoreAll(ACTIONS, { ...base, hp })).name;
  if (pick !== prev) { console.log(`2) hp ${String(hp).padStart(3)}: ${pick}`); prev = pick; }
}
// аптечка далеко (600 px) и аптечки нет
prev = null;
for (let hp = 100; hp >= 0; hp -= 5) {
  const pick = choose(scoreAll(ACTIONS, { ...base, hp, medkit: 600 })).name;
  if (pick !== prev) { console.log(`2) аптечка в 600 px, hp ${String(hp).padStart(3)}: ${pick}`); prev = pick; }
}
console.log('2) hp 20, аптечки нет:', choose(scoreAll(ACTIONS, { ...base, hp: 20, medkit: null })).name);

// 3. Патроны кончаются
for (const ammo of [12, 6, 3, 1, 0]) {
  const sc = scoreAll(ACTIONS, { ...base, ammo });
  console.log(`3) патронов ${String(ammo).padStart(2)}: стрелять ${sc[0].score.toFixed(2)}, перезарядить ${sc[2].score.toFixed(2)} → ${choose(sc).name}`);
}

// 4. Игрок пропал из виду — боевые действия ниже порога, работает младшая корзина
console.log('4) не видит, магазин полный:', choose(scoreAll(ACTIONS, { ...base, sees: false })).name);

// 5. Произведение против среднего геометрического: 1, 2, 4, 8 соображений по 0,8
for (const n of [1, 2, 4, 8]) {
  const v = Array(n).fill(0.8);
  console.log(`5) ${n} × 0,8: произведение ${product(v).toFixed(3)}, геометрическое ${geomean(v).toFixed(3)}`);
}
// то же правило выбора, но итог — среднее геометрическое: когда враг уходит лечиться
prev = null;
for (let hp = 100; hp >= 0; hp -= 5) {
  const pick = choose(scoreAll(ACTIONS, { ...base, hp }, geomean)).name;
  if (pick !== prev) { console.log(`5) геометрическое, hp ${String(hp).padStart(3)}: ${pick}`); prev = pick; }
}

// 6. Дрожание на границе «стрелять / сблизиться»: игрок мечется около 225 px, шаг 1/60 с, 10 с
function jitter(opts) {
  const r = rng(3), brain = createBrain(ACTIONS, opts);
  let switches = 0, last = null; const count = {};
  for (let f = 0; f < 600; f++) {
    const dist = 225 + (r() * 2 - 1) * 25;
    const a = brain.update(1 / 60, { ...base, hp: 70, dist });
    count[a] = (count[a] ?? 0) + 1;
    if (last && a !== last) switches++; last = a;
  }
  return `${switches} смен; кадров: ${Object.entries(count).map(([k, v]) => `${k} ${v}`).join(', ')}`;
}
console.log('6) каждый кадр, без инерции:       ', jitter({ period: 0, inertia: 0, minCommit: 0 }));
console.log('6) раз в 0,2 с, без инерции:       ', jitter({ period: 0.2, inertia: 0, minCommit: 0 }));
console.log('6) раз в 0,2 с, инерция 0,15 + 0,5 с:', jitter({ period: 0.2, inertia: 0.15, minCommit: 0.5 }));

// 7. Взвешенная случайность среди лучших в пределах 10 %: 1000 решений
const tie = [{ name: 'A', bucket: 1, score: 0.50 }, { name: 'B', bucket: 1, score: 0.47 }, { name: 'C', bucket: 1, score: 0.30 }];
const r7 = rng(11), cnt = { A: 0, B: 0, C: 0 };
for (let i = 0; i < 1000; i++) cnt[choose(tie, { band: 0.1, rand: r7 }).name]++;
console.log('7) 0,50 / 0,47 / 0,30, полоса 10 %, 1000 решений:', JSON.stringify(cnt));

Вывод прогона (проверено в Node.js 24.22.1, 11.11.2026):

1) здоров, 140 px: стрелять 1.00 | сблизиться 0.08 | перезарядить 0.00 | к аптечке 0.00 | патруль 0.50 → стрелять
2) hp 100: стрелять
2) hp  25: к аптечке
2) аптечка в 600 px, hp 100: стрелять
2) аптечка в 600 px, hp  10: к аптечке
2) hp 20, аптечки нет: стрелять
3) патронов 12: стрелять 1.00, перезарядить 0.00 → стрелять
3) патронов  6: стрелять 0.70, перезарядить 0.12 → стрелять
3) патронов  3: стрелять 0.55, перезарядить 0.27 → стрелять
3) патронов  1: стрелять 0.45, перезарядить 0.40 → стрелять
3) патронов  0: стрелять 0.00, перезарядить 0.47 → перезарядить
4) не видит, магазин полный: патруль
5) 1 × 0,8: произведение 0.800, геометрическое 0.800
5) 2 × 0,8: произведение 0.640, геометрическое 0.800
5) 4 × 0,8: произведение 0.410, геометрическое 0.800
5) 8 × 0,8: произведение 0.168, геометрическое 0.800
5) геометрическое, hp 100: стрелять
5) геометрическое, hp  15: к аптечке
6) каждый кадр, без инерции:        303 смен; кадров: сблизиться 319, стрелять 281
6) раз в 0,2 с, без инерции:        20 смен; кадров: сблизиться 396, стрелять 204
6) раз в 0,2 с, инерция 0,15 + 0,5 с: 6 смен; кадров: сблизиться 432, стрелять 168
7) 0,50 / 0,47 / 0,30, полоса 10 %, 1000 решений: {"A":533,"B":467,"C":0}

Что показывают сценарии:

  • 1. Одна ситуация. Здоровый стрелок с полным магазином в 140 px от игрока получает 1,00 за стрельбу: все четыре соображения равны 1. Перезарядка и лечение — 0, сближение — 0,08: игрок близко.
  • 2. Здоровье. С аптечкой в 300 px враг уходит лечиться на 25 единицах здоровья: при 30 стрельба и лечение почти равны (0,55 и 0,55), при 25 лечение уже 0,63 против 0,50. С аптечкой в 600 px он держится до 10. Без аптечки на уровне соображение «аптечка» равно 0, и раненый на 20 стрелок продолжает стрелять — вето работает.
  • 3. Патроны. Оценка стрельбы падает с 1,00 до 0,45 при последнем патроне, перезарядка растёт до 0,40, но стрельба всё ещё выигрывает; при пустом магазине стрельба — 0, и враг перезаряжается.
  • 4. Корзины. Если игрок не виден, стрельба и сближение — 0, перезарядка и лечение тоже 0 (магазин полон, здоровье 100), и выбор уходит в младшую корзину — патруль.
  • 5. Произведение и геометрическое. 8 соображений по 0,8 дают 0,168 при произведении и 0,800 при среднем геометрическом. Но со средним геометрическим тот же враг уходит лечиться только на 15 единицах здоровья вместо 25.
  • 6. Дрожание. Совпадает с таблицей в разделе про инерцию: 303, 20 и 6 смен.
  • 7. Полоса 10 %. 533 и 467 решений из 1000 для действий с 0,50 и 0,47 — близко к отношению оценок; действие с 0,30 не выбрано ни разу.

Что нашли при проверке. Первая версия складывала соображения средним геометрическим, и враг уходил к аптечке только на 10 единицах здоровья. Причина — у стрельбы четыре соображения, и три из них («видит», «дальность», «патроны») равны 1: среднее геометрическое подтягивает итог к единице, и одна низкая «смелость» размывается. В нынешних кривых при 20 единицах здоровья стрельба по среднему геометрическому получает 0,82 против 0,80 у лечения, а по произведению — 0,45 против 0,64. Мы перешли на произведение, при котором соображения, равные 1, итог не меняют, а сравнение оставили в сценарии 5. Вторая ошибка — в кривой аптечки: при множителе 0,8 далёкая аптечка в 600 px получала 0,2, и враг не шёл к ней ни при каком здоровье выше нуля; множитель уменьшен до 0,6. Третья — бонус инерции 0,1 оставлял 9 смен за 10 секунд, увеличен до 0,15.

Обвязка для браузера и отладка оценок

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

// main.js — стрелок на utility AI в браузере: canvas 640×360, игрок — курсор мыши
import { createBrain, scoreAll } from './utility.mjs';
import { ACTIONS } from './enemy.mjs';

const ctx = document.querySelector('canvas').getContext('2d');
const enemy = { x: 80, y: 180, hp: 100, maxHp: 100, ammo: 12, maxAmmo: 12, cooldown: 0 };
const medkit = { x: 320, y: 320 };
const player = { x: 320, y: 180 };
const brain = createBrain(ACTIONS);
let last = performance.now();

addEventListener('pointermove', e => {
  const r = ctx.canvas.getBoundingClientRect();
  player.x = (e.clientX - r.left) * ctx.canvas.width / r.width;
  player.y = (e.clientY - r.top) * ctx.canvas.height / r.height;
});
addEventListener('pointerdown', () => { enemy.hp = Math.max(0, enemy.hp - 15); }); // клик — ранить врага

function moveTo(t, speed, dt) {
  const dx = t.x - enemy.x, dy = t.y - enemy.y, d = Math.hypot(dx, dy) || 1;
  enemy.x += dx / d * Math.min(speed * dt, d); enemy.y += dy / d * Math.min(speed * dt, d);
}

function frame(now) {
  const dt = Math.min((now - last) / 1000, 0.1); last = now;
  const c = { ...enemy, dist: Math.hypot(player.x - enemy.x, player.y - enemy.y), sees: true,
              medkit: Math.hypot(medkit.x - enemy.x, medkit.y - enemy.y) };
  const action = brain.update(dt, c);
  enemy.cooldown -= dt;
  if (action === 'стрелять' && enemy.cooldown <= 0) { enemy.ammo--; enemy.cooldown = 0.4; }
  if (action === 'сблизиться') moveTo(player, 70, dt);
  if (action === 'перезарядить' && enemy.cooldown <= 0) { enemy.ammo = enemy.maxAmmo; enemy.cooldown = 1.5; }
  if (action === 'к аптечке') { moveTo(medkit, 90, dt); if (c.medkit < 8) enemy.hp = enemy.maxHp; }

  ctx.clearRect(0, 0, 640, 360);
  ctx.fillStyle = '#4c4'; ctx.fillRect(medkit.x - 6, medkit.y - 6, 12, 12);
  ctx.fillStyle = '#c33'; ctx.fillRect(enemy.x - 8, enemy.y - 8, 16, 16);
  ctx.fillStyle = '#fff';
  ctx.fillText(`${action} · hp ${enemy.hp} · патроны ${enemy.ammo}`, 8, 16);
  scoreAll(ACTIONS, c).sort((a, b) => b.score - a.score).slice(0, 3)       // отладка: почему выбрано
    .forEach((s, i) => ctx.fillText(`${s.name} ${s.score.toFixed(2)} ← ` +
      Object.entries(s.parts).map(([k, v]) => `${k} ${v.toFixed(2)}`).join(' × '), 8, 34 + i * 14));
  requestAnimationFrame(frame);
}
requestAnimationFrame(frame);

Нужна страница с canvas размером 640 × 360 и подключением main.js как модуля; откройте её через локальный сервер. Синтаксис обвязки проверен командой node --check. Три детали:

  • Отладочная строка обязательна. Строка вида «к аптечке 0.63 ← ранен 0.90 × аптечка 0.70» отвечает на главный вопрос плейтеста — почему враг это сделал. Без неё кривые настраивают вслепую.
  • Шаг не больше 0,1 с. После возврата на вкладку первый шаг может быть в несколько секунд, и минимальное время действия «истекло бы» мгновенно.
  • Клик ранит врага на 15. Так проверяется кривая «ранен»: после 5 кликов (здоровье 25) враг идёт к аптечке, если она ближе примерно 300 px; аптечка в обвязке стоит внизу по центру, около 280 px от точки старта врага.

Сколько это стоит на сотне врагов

Выбор по полезности стоит столько вызовов кривых, сколько соображений у всех действий врага, умноженных на число врагов и частоту решений. У нашего стрелка 12 соображений на 5 действий, значит у 200 врагов — 2400 вызовов за одно решение каждого (наш расчёт):

Как часто решаютВызовов кривых в секунду для 200 врагов
Каждый кадр при 60 кадрах в секунду144 000
Раз в 0,2 с12 000

На нашем боксе в Node.js 24.22.1 один полный круг оценки и выбора для 200 врагов занял около 0,6 мс — это 3–4 % кадра в 16,7 мс, если решать каждый кадр. Цифра зависит от машины и браузера; в горячем цикле можно не собирать объекты parts, они нужны только для отладочного вывода. Второй приём — разнести решения врагов по кадрам: при периоде 0,2 с и 60 кадрах в секунду в каждом кадре решают примерно 17 врагов из 200, а не все сразу. Если сотни врагов ищут друг друга по расстоянию, «кто рядом» лучше брать из пространственной сетки, а не перебором.

Практический сценарий: стрелок на арене

Задача: на арене 640 × 360 px один стрелок должен вести себя «разумно» в пяти ситуациях без единого порога if в коде решения. Входные условия — магазин на 12 патронов, здоровье 100, одна аптечка, игрок двигается мышью. Шаги:

  1. Действия и корзины. Записать 5 действий из таблицы в начале статьи, патруль — в младшую корзину.
  2. Кривые. Начать с наших точек и коэффициентов, «нормально» = 1 у каждого соображения.
  3. Прогон. Запустить проверку из статьи и сверить пороги: лечение на 25 при аптечке в 300 px, перезарядка только при пустом магазине, патруль, когда игрок не виден.
  4. Характер. Сделать второго стрелка с весом действия «к аптечке» 1,3 и сравнить, на каком здоровье он уходит.
  5. Плейтест. Дать сыграть 3 людям по 2 минуты и записать каждую смену действия с оценками из отладочной строки.

Проверяемый итог: за 2 минуты нет ни одного отрезка, где враг меняет действие чаще раза в 0,5 с, и каждый уход к аптечке можно объяснить строкой «ранен 0,90 × аптечка 0,70». Если игроки называют врага трусом, уменьшите вес лечения или сдвиньте точку 0,9 кривой «ранен» ниже 25 %.

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

Выбор по полезности хорош там, где решение зависит от сочетания факторов, но в ряде случаев он хуже простых решений:

  • Враг с одним-двумя поведениями. Патрульному хватает автомата или switch; кривые и веса добавят настройку, но не поведение.
  • Строгие сценарные цепочки. Если враг должен сделать «подойти — замахнуться — ударить — отступить» строго по порядку, это последовательность в дереве поведения или фазы в автомате; выбор по полезности будет пытаться прервать её посередине.
  • Нужна предсказуемость для игрока. В играх на заучивание паттернов (босс, головоломка) плавные оценки мешают: игрок должен знать, что при условии X враг всегда делает Y.
  • Некому настраивать кривые. Грэм прямо называет подбор функций полезности скорее искусством, чем наукой, и основной частью работы. Без отладочного вывода оценок и плейтестов система ведёт себя «странно», и причину не найти.
  • Нужен план на несколько шагов. Utility AI выбирает одно действие сейчас. Если врагу нужно «взять ключ, открыть дверь, зайти с фланга», нужен планировщик или поиск, а оценка полезности — только для выбора цели.

Мы разрабатываем J2DRU — браузерный 2D игровой движок, где игровая логика собирается из событий, условий, действий и выражений, а то, что неудобно выразить событиями, например оценку десятка соображений, можно вынести в скрипты на TypeScript. Движок в разработке и публично пока не открыт, заявку можно оставить на странице раннего доступа (подача заявки не гарантирует приглашение).

Источники (проверено: ноябрь 2026, 11.11.2026): David "Rez" Graham — «An Introduction to Utility Theory», Game AI Pro (CRC Press, 2013), глава 9 (оценка всех действий разом и выбор лучшего; нормализованные оценки 0–1; decision factors и веса как характер; линейные, степенные, логистические и кусочно-линейные кривые, кусочно-линейная кривая голода в The Sims; максимум, взвешенная случайность и выбор среди лучших в пределах, например, 10 %; корзины — bucketing, dual utility AI со ссылкой на K. Dill, 2011; инерция, кулдауны и решение по пустой очереди в The Sims Medieval; демо, где лечение = желание лечиться × угроза; подбор кривых — «скорее искусство, чем наука»); GDC Vault — Kevin Dill, Dave Mark, «Improving AI Decision Modeling Through Utility Theory», AI Summit, GDC 2010 (резкий переход «да/нет» в if даёт резкое поведение; кривые ответа, распределения и взвешенная случайность); Bill Merrill — «Building Utility Decisions into Your Existing Behavior Tree», Game AI Pro (CRC Press, 2013), глава 10 (встраивание оценки полезности в существующее дерево поведения). Набор действий, кривые, коэффициенты, пороги, параметры инерции, подсчёт вызовов, замер 0,6 мс и все числа прогонов — наш пример и наш расчёт в Node.js 24.22.1.

Читайте также:

Частые вопросы

Чем utility AI отличается от дерева поведения?

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

Что такое кривая ответа?

Функция, которая переводит игровое значение (здоровье, расстояние в пикселях, число патронов) в число от 0 до 1 для одного соображения. Бывают линейные, степенные, логистические (плавная ступенька) и кусочно-линейные, заданные точками. Дэвид Грэм в Game AI Pro пишет, что кусочно-линейные кривые используются в The Sims для потребности «голод».

Почему оценки соображений перемножают, а не складывают?

Произведение даёт вето: если патронов нет, соображение «патроны» равно 0, и стрельба получает 0 при любых других факторах. Соображение, равное 1, итог не меняет. Минус — много факторов чуть меньше 1 тянут итог вниз: 8 соображений по 0,8 дают 0,168, поэтому у одного действия лучше держать 2–4 соображения.

Как сделать, чтобы враг не переключался между действиями каждый кадр?

Решать реже (у нас раз в 0,2 с), давать текущему действию бонус инерции (у нас +0,15) и запрещать смену раньше минимального времени (у нас 0,5 с), кроме случая, когда текущее действие стало невозможным. В нашем прогоне с игроком, который мечется около границы, это дало 6 смен за 10 секунд вместо 303 при решении каждый кадр.