Хабрахабр

[Перевод] Имитация естественного движения: Steering Behaviors

image

Steering behaviors помогают автономным персонажам реалистично двигаться благодаря применению простых сил, сочетание которых создаёт естественно выглядящее и импровизированное движение по окружению. В этом туториале я расскажу об основах теории steering behaviors, а также об их реализации.

Благодаря этому они просты в понимании и реализации, но в то же время способны создавать очень сложные паттерны движения.
Примечание: хотя этот туториал писался на AS3 и Flash, те же самые техники и концепции можно использовать почти в любой среде разработки игр. Идеи, на которых построены такие поведения, предложены Крейгом Рейндольдсом; они не основаны на сложных стратегиях с использованием планирования пути или глобальных вычислений, а применяют локальную информацию, например, силы соседних объектов. Вам понадобится базовое понимание математических векторов.

Часть 1. Поведение Seek (поиск)

Позиция, скорость и движение

Реализация всех сил, участвующих в steering behaviors, возможна при использовании математических векторов. Так как эти силы влияют на скорость и позицию персонажа, то для их представления логично будет также использовать векторы.

Хотя у вектора есть направление, мы будем игнорировать его, когда дело будет касаться позиции (будем считать, что вектор позиции указывает на текущее местоположение персонажа).

На показанном выше изображении показан персонаж, находящийся в (x, y) и имеющий скорость (a, b). Движение вычисляется с помощью метода Эйлера:

position = position + velocity

Направление вектора скорости будет управлять направлением движения персонажа, а его длина (или величина) будет управлять величиной перемещения за каждый кадр. Чем больше длина, тем быстрее движется персонаж. Вектор скорости можно усекать, чтобы он не превышал определённого значения (обычно это максимальная скорость). Ниже показано изображение, демонстрирующее такой подход.

Паттерн движения иллюстрирует поведение seek, но пока без приложенных управляющих сил. Красный квадрат движется по направлению к цели. Зелёной линией обозначен вектор скорости, вычисляемый следующим образом:

velocity = normalize(target - position) * max_velocity

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

Вычисление сил

Если задействована только сила скорости, то персонаж будет двигаться только по прямой, задаваемой направлением этого вектора. Один из принципов steering behaviors заключается в воздействии на движение персонажа добавлением сил (называемых управляющими силами). Благодаря этим силам персонаж будет двигаться в том или ином направлении.

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

В поведении seek задействуются две силы: требуемая скорость и управляющая сила:

Требуемая скорость — это сила, направляющая персонажа к цели по кратчайшему возможному пути (по прямой линии между ними — ранее это была единственная сила, действовавшая на персонажа). Управляющая сила — это результат вычитания из требуемой скорости текущей скорости; она также направляет персонажа к цели.

Эти силы вычисляются следующим образом:

desired_velocity = normalize(target - position) * max_velocity
steering = desired_velocity - velocity

Приложение сил

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

Приложение этих сил и вычисление конечных скорости/позиции имеют следующий вид:

steering = truncate (steering, max_force)
steering = steering / mass velocity = truncate (velocity + steering , max_speed)
position = position + velocity

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

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

Часть 2. Поведения Flee and Arrival

Убегание

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

desired_velocity = normalize(target - position) * max_velocity
steering = desired_velocity - velocity

В этом случае desired_velocity является кратчайшим путём между персонажем и целью. Она получается вычитанием позиции цели из позиции персонажа. Результатом является вектор силы, проходящий от персонажа к цели.

В поведении flee используются те же две силы, но они настроены так, чтобы персонаж убегал от цели:

Поведение Flee

Этот новый вектор desired_velocity вычисляется вычитанием позиции персонажа из позиции цели, что даёт нам вектор, направленный от цели к персонажу.

Получающиеся силы вычисляются почти так же, как в поведении seek:

desired_velocity = normalize(position - target) * max_velocity
steering = desired_velocity - velocity

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

При сравнении вектора требуемой скорости в поведении flee с этим же вектором в поведении seek можно вывести следующее соотношение:

flee_desired_velocity = -seek_desired_velocity

Иными словами, один вектор является отрицательным по отношению к другому.

Приложение сил избегания

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

Сложение этих сил и вычисление конечных скорости/позиции выполняются тем же образом, что и раньше.

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

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

Arrival

Как мы видели, поведение seek заставляет персонаж двигаться к цели. Когда он достигает своей цели, управляющая сила продолжает на него воздействовать в соответствии с теми же правилами, заставляя персонаж «скакать» вперёд и назад вокруг цели.

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

Первый этап — когда персонаж находится далеко от цели; он работает точно так же, как поведение seek (персонаж на всей скорости движется к цели). Это поведение состоит из двух этапов.

Второй этап начинается, когда персонаж близок к цели, находится внутри её «области замедления» (круга, центрированного в местоположении цели):

Когда персонаж входит в круг, он замедляется, пока не остановится в цели.

Замедление

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

// Если (velocity + steering) равно нулю, то движение отсутствует
velocity = truncate(velocity + steering, max_speed)
position = position + velocity function truncate(vector:Vector3D, max:Number) :void { var i :Number; i = max / vector.length; i = i < 1.0 ? i : 1.0; vector.scaleBy(i);
}

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

// Вычисление требуемой скорости
desired_velocity = target - position
distance = length(desired_velocity) // Проверка расстояния для определения того, находится ли персонаж
// внутри области замедления
if (distance < slowingRadius) { // Внутри области замедления desired_velocity = normalize(desired_velocity) * max_velocity * (distance / slowingRadius)
} else { // Снаружи области замедления desired_velocity = normalize(desired_velocity) * max_velocity
} // На основании этого задаём управляющую силу
steering = desired_velocity - velocity

Если расстояние больше slowingRadius, то персонаж находится далеко от цели и его скорость должна оставаться равной max_velocity.

Если расстояние меньше slowingRadius, то персонаж вошёл в область замедления и его скорость должна снижаться.

Линейное изменение заставляет скорость плавно снижаться: Значение distance / slowingRadius изменяется в интервале от 1 (когда distance равно slowingRadius) до 0 (когда distance почти равно нулю).

Как сказано выше, движение персонажа выполняется следующим образом:

steering = desired_velocity - velocity
velocity = truncate (velocity + steering , max_speed)
position = position + velocity

Если требуемая скорость снизилась до нуля, то управляющая сила становится равной -velocity. Следовательно, когда эта управляющая сила прибавляется к скорости, то мы получаем ноль, что заставляет персонаж остановиться.

Исходный вектор скорости персонажа не меняется и продолжает работать, но обнуляется прибавлением управляющей силы. По сути, поведение arrival вычисляет силу, которая должна быть равна -velocity, не позволяя персонажу двигаться, пока приложена эта сила.

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

Заключение

Поведение flee заставляет персонаж отдаляться от цели, а поведение arrival заставляет его замедляться и останавливаться в позиции цели. Оба поведения можно использовать для создания плавных паттернов убегания или следования. Кроме того, их можно сочетать, создавая ещё более сложные движения.

Часть 3. Поведение Wander

Блуждание

В играх часто бывает необходимо, чтобы персонажи случайным образом блуждали по окружению. Обычно такие персонажи просто ждут какого-то события (например боя с игроком) или что-то ищут. Когда игрок способен увидеть такое поведение, то функция блуждания персонажа должна быть достаточно реалистичной и красиво выглядящей.

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

Управляющее поведение wander предназначено для создания реалистичного «естественного» движения, которое убедит игрока, что персонаж на самом деле живой и самостоятельно ходит.

Поиск и случайность

Существует несколько способов реализации паттерна блуждания с помощью steering behaviors. Самый простой — это описанное ранее поведение seek. Когда персонаж выполняет поиск, он движется к цели.

Если мы будем располагать цель в игровой области случайным образом, то персонаж будет перемещаться по всему окружению, преследуя цель. Если позиция этой цели изменяется каждые несколько секунд, то персонаж никогда не сможет её достичь (а если и сможет, то цель снова переместится).

Интерактивное демо на Flash находится здесь.

Реализовать это можно следующим кодом:

// Вычисление силы блуждания
private function wander() :Vector3D // возврат управляющей силы, подталкивающей игрока // к цели (поведение seek) return seek(target);
} // В игровом цикле обрабатываем силы и движение
// точно так же, как и раньше:
public function update() :void { steering = wander() steering = truncate (steering, max_force) steering = steering / mass velocity = truncate (velocity + steering , max_speed) position = position + velocity
}

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

Блуждание

Ещё одна реализация поведения wander была предложена Крейгом Рейнольдсом, когда он изобрёл эти поведения. Основная идея заключается в создании небольших случайных смещений и приложение их в каждом игровом кадре к вектору текущего направления персонажа (в нашем случае к скорости). Так как вектор скорости определяет направление движения персонажа и скорость его перемещения, любое воздействие на этот вектор приведёт к изменению текущего маршрута.

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

Один из них — поместить перед персонажем круг и использовать его для вычислений всех воздействующих сил: Такой подход тоже можно реализовать разными способами.

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

Она используется для вычисления силы блуждания. Эта сила смещения будет использоваться для воздействия на маршрут персонажа.

Вычисление позиции круга

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

// Константа CIRCLE_DISTANCE -
// это число, заданное где-то в другом месте кода.
// Код вычисления центра круга:
var circleCenter :Vector3D;
circleCenter = velocity.clone();
circleCenter.normalize();
circleCenter.scaleBy(CIRCLE_DISTANCE);

Вектор circleCenter — это клон (копия) вектора скорости, то есть он указывает в том же направлении. Он нормализован и умножен на скалярное значение (в нашем случае на CIRCLE_DISTANCE), что даст нам следующий вектор:

Сила смещения

Следующий компонент — это сила смещения, ответственная за повороты влево-вправо. Так как эта сила используется для создания отклонений, она может быть направлена куда угодно. Давайте используем вектор, выровненный относительно оси Y:

var displacement :Vector3D;
displacement = new Vector3D(0, -1);
displacement.scaleBy(CIRCLE_RADIUS);
//
// Случайное изменение направления вектора
// изменением его текущего угла
setAngle(displacement, wanderAngle);
//
// Немного изменяем wanderAngle, чтобы
// он не имел то же значения
// в следующем кадре игры.
wanderAngle += (Math.random() * ANGLE_CHANGE) - (ANGLE_CHANGE * .5);

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

Так как она отмасштабирована на значение радиуса круга, то будет выглядеть примерно так: Чтобы понять это, давайте представим, что вычисленная выше сила смещения расположена в центре круга.

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

Сила блуждания

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

var wanderForce :Vector3D;
wanderForce = circleCenter.add(displacement);

Визуально мы можем представить эти силы так:

Силу блуждания можно представить как вектор, исходящий из персонажа в точку на окружности круга. В зависимости от расположения этой точки сила блуждания будет толкать персонажа влево или вправо, сильно или слабо:

Чем больше сила блуждания сонаправлена с вектором скорости, тем меньше персонаж будет менять текущий маршрут. Сила блуждания будет действовать в точности как силы seek и flee: она будет подталкивать персонажа в нужном направлении.

Окончательный код силы блуждания выглядит так: Аналогично тому, как направление силы в поведениях seek и flee вычисляется на основании цели, направление блуждания вычисляется на основании случайной точки на окружности круга.

private function wander() :Vector3D { // Вычисление центра круга var circleCenter :Vector3D; circleCenter = velocity.clone(); circleCenter.normalize(); circleCenter.scaleBy(CIRCLE_DISTANCE); // // Вычисление силы смещения var displacement :Vector3D; displacement = new Vector3D(0, -1); displacement.scaleBy(CIRCLE_RADIUS); // // Случайное изменение направления вектора // изменением его текущего угла setAngle(displacement, wanderAngle); // // Немного изменяем wanderAngle, чтобы // он не имел то же значения // в следующем кадре игры. wanderAngle += Math.random() * ANGLE_CHANGE - ANGLE_CHANGE * .5; // // Вычисление и возврат силы блуждания var wanderForce :Vector3D; wanderForce = circleCenter.add(displacement); return wanderForce;
} public function setAngle(vector :Vector3D, value:Number):void { var len :Number = vector.length; vector.x = Math.cos(value) * len; vector.y = Math.sin(value) * len;
}

Сложение сил

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

steering = wander()
steering = truncate (steering, max_force)
steering = steering / mass
velocity = truncate (velocity + steering , max_speed)
position = position + velocity

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

Интерактивное демо на Flash находится здесь.

Заключение

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

Часть 4. Pursuit и Evade

Что такое Pursuit?

Pursuit (преследование) — процесс следования за целью со стремлением поймать её. Важно заметить, что всё различие здесь заключается в слове «поймать». Если объект просто следует за целью, то ему достаточно повторять движения цели, следовательно, он будет идти по её следам.

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

Прогнозирование будущего

Как сказано в первой части туториала, движение вычисляется при помощи метода Эйлера:

position = position + velocity

Из этого непосредственно следует, что если известны текущие позиция и скорость персонажа, то мы можем предсказать, где он будет находиться через T обновлений игры. Допустим, персонаж движется по прямой и позиция, которую мы хотим спрогнозировать, находится находится спустя три обновления (T=3). Тогда будущая позиция персонажа будет такой:

position = position + velocity * T

Для правильного прогнозирования необходимо выбрать верное значение T. Если значение слишком большое, то преследователь будет гнаться за призраком. Если T слишком близко к нулю, то преследователь на самом деле не преследует, а просто следует за целью (прогнозирования нет).

При каждом обновлении генерируется новая «будущая позиция», основанная на векторе текущей скорости персонажа (который также управляет направлением движения). Если прогноз вычисляется для каждого кадра игры, то это сработает, даже если цель постоянно меняет своё направление.

Pursuing (преследование)

Поведение Pursuit работает примерно так же, как и Seek; единственное различие заключается в том, что преследователь стремится не к самой цели, а к её позиции в ближайшем будущем.

Тогда в следующем псевдокоде реализована основная идея поведения pursuit: Допустим, все персонажи в игре представлены классом Boid.

public function pursuit(t :Boid) :Vector3D { T :int = 3; futurePosition :Vector3D = t.position + t.velocity * T; return seek(futurePosition);
}

После вычисления силы преследования её необходимо прибавить к вектору скорости, как и во всех предыдущих управляющих силах:

public function update() :void { steering = pursuit(target) steering = truncate (steering, max_force) steering = steering / mass velocity = truncate (velocity + steering , max_speed) position = position + velocity
}

На рисунке ниже показан этот процесс:

Преследователь (персонаж внизу) стремится к будущей позиции цели, следуя по траектории, описанной оранжевой кривой. Готовый результат показан ниже. Здесь в поведении pursuit используется T=30.

Интерактивно демо на Flash находится здесь.

Улучшение точности преследования

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

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

Идея очень проста: вместо постоянного значения T необходимо использовать динамическое: Существует простой трюк, с помощью которого можно избежать этой проблемы и значительно повысить точность преследования.

T = distanceBetweenTargetAndPursuer / MAX_VELOCITY

Новое значение T вычисляется на основании расстояния между двумя персонажами и максимальной скорости, которой может достичь цель. Проще говоря, новое T означает «сколько обновлений нужно цели, чтобы переместиться из текущей позиции в позицию преследователя».

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

public function pursuit(t :Boid) :Vector3D { var distance :Vector3D = t.position - position; var T :int = distance.length / MAX_VELOCITY; futurePosition :Vector3D = t.position + t.velocity * T; return seek(futurePosition);
}

Поведение Pursuit использует динамическое T.

Интерактивное демо на Flash находится здесь.

Evading (избегание)

Поведение Evade противоположно поведению Pursuit. Вместо стремления к будущей позиции цели при поведении Evade будет убегать от этой позиции:

Код избегания практически аналогичен, меняется только последняя строка:

public function evade(t :Boid) :Vector3D { var distance :Vector3D = t.position - position; var updatesAhead :int = distance.length / MAX_VELOCITY; futurePosition :Vector3D = t.position + t.velocity * updatesAhead; return flee(futurePosition);
}

Интерактивное демо на Flash находится здесь.

Заключение

В этой части мы рассмотрели поведения Pursuit и Evade, которые отлично подходят для имитации множества различных паттернов, например, стада животных, пытающихся сбежать от охотника.

Часть 5. Менеджер движений

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

Комбинирование Steering Forces

Как говорилось ранее, каждое steering behavior создаёт результирующую силу (называемую «управляющей силой»), которая прибавляется к вектору скорости. Направление и величина этой силы направляют персонажа, заставляя его двигаться согласно паттерну (seek, flee, wander и так далее). В общем виде вычисления выглядят так:

steering = seek(); // здесь может быть любое поведение
steering = truncate (steering, max_force)
steering = steering / mass velocity = truncate (velocity + steering , max_speed)
position = position + velocity

Так как управляющая сила является вектором, её можно прибавить к любому другому вектору (так же, как и к скорости). Однако настоящая «магия» заключается в том, что мы можем складывать разные управляющие силы. Достаточно сделать так:

steering = nothing(); // нулевой вектор, означающий "нулевую величину силы"
steering = steering + seek();
steering = steering + flee();
(...)
steering = truncate (steering, max_force)
steering = steering / mass velocity = truncate (velocity + steering , max_speed)
position = position + velocity

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

Ниже показаны примеры скомбинированных управляющих сил, создающих единую управляющую силу:

Простое создание сложных паттернов

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

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

Подразумевается, что они должны вычисляться при каждом обновлении игры, поэтому они естественным образом реагируют на изменения окружения. В steering behaviors все силы являются динамическими.

Менеджер движений

Чтобы использовать несколько steering behaviors одновременно, полезно будет создать менеджер движений. Идея заключается в написании «чёрного ящика», который можно подключить к любой имеющейся сущности, что позволит ей выполнять эти поведения.

Менеджер передаёт хосту набор методов, таких как seek() и flee(). Менеджер имеет ссылку на сущность, к которой он подключается (на «хост»). При каждом вызове таких методов менеджер обновляет свои внутренние свойства для создания вектора управляющей силы.

Это изменяет величину и направление вектора скорости хоста в соответствии с активными поведениями. После обработки всех вызовов менеджер прибавляет результирующую управляющую силу к вектору скорости хоста.

На рисунке ниже показана архитектура:

Обобщаем элементы

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

Точку в пространстве можно выразить как экземпляр Point или Vector2D. Например, поведению Seek требуется точка в пространстве, используемая для вычисления управляющей силы, направленной к этому месту; для Pursuit требуется несколько фрагментов информации от цели, такие как текущая позиция и скорость. Оба они являются достаточно стандартными классами в любом фреймворке.

Чтобы сделать менеджер движений достаточно обобщённым, он должен получать цель, которая, вне зависимости от своего типа, может ответить на несколько «вопросов», например "Какова твоя текущая скорость?". Однако целью в поведении Pursuit может быть всё, что угодно. Благодаря некоторым принципам объектно-ориентированного программирования этого можно достичь с помощью интерфейсов.

Тогда этот интерфейс имеет следующую структуру: Допустим, интерфейс IBoid описывает сущность, которой может управлять менеджер движений, и любой класс в игре может использовать steering behaviors, если он реализует IBoid.

public interface IBoid
{ function getVelocity() :Vector3D; function getMaxVelocity() :Number; function getPosition() :Vector3D; function getMass() :Number;
}

Структура менеджера движений

Теперь, когда менеджер может взаимодействовать со всеми сущностями игры в обобщённом виде, можно создать его базовую структуру. Менеджер состоит их двух свойств (результирующая управляющая сила и ссылка на хост), а также из набора публичных методов, по одному на каждое поведение:

public class SteeringManager
{ public var steering :Vector3D; public var host :IBoid; // Конструктор public function SteeringManager(host :IBoid) { this.host = host; this.steering = new Vector3D(0, 0); } // Публичный API (по одному методу на каждое поведение) public function seek(target :Vector3D, slowingRadius :Number = 20) :void {} public function flee(target :Vector3D) :void {} public function wander() :void {} public function evade(target :IBoid) :void {} public function pursuit(target :IBoid) :void {} // Метод обновления. // Должен вызываться после вызова всех поведений public function update() :void {} // Сброс внутренней управляющей силы. public function reset() :void {} // Внутренний API private function doSeek(target :Vector3D, slowingRadius :Number = 0) :Vector3D {} private function doFlee(target :Vector3D) :Vector3D {} private function doWander() :Vector3D {} private function doEvade(target :IBoid) :Vector3D {} private function doPursuit(target :IBoid) :Vector3D {}
}

При создании экземпляра менеджера он должен получать ссылку на хост, к которому он подключается. Она позволит менеджеру изменять вектор скорости хоста в соответствии с активными поведениями.

Возьмём для примера поведение Seek: Каждое поведение представляется двумя методами — публичным и приватным.

public function seek(target :Vector3D, slowingRadius :Number = 20) :void {}
private function doSeek(target :Vector3D, slowingRadius :Number = 0) :Vector3D {}

Публичный seek() будет вызываться, чтобы приказать менеджеру применить это конкретное поведение. У этого метода нет возвращаемого значения, а его параметры связаны с самим поведением, например, точка в пространстве. Внутри будет вызываться приватный метод doSeek(), а его возвращаемое значение, т.е. вычисленная управляющая сила этого конкретного поведения, будет прибавляться к свойству steering менеджера.

В следующем коде показана реализация seek:

// Публичный метод. // Получает цель и slowingRadius (используется для выполнения Arrival).
public function seek(target :Vector3D, slowingRadius :Number = 20) :void { steering.incrementBy(doSeek(target, slowingRadius));
} // Сама реализация Seek (с добавленным кодом Arrival)
private function doSeek(target :Vector3D, slowingRadius :Number = 0) :Vector3D { var force :Vector3D; var distance :Number; desired = target.subtract(host.getPosition()); distance = desired.length; desired.normalize(); if (distance <= slowingRadius) { desired.scaleBy(host.getMaxVelocity() * distance/slowingRadius); } else { desired.scaleBy(host.getMaxVelocity()); } force = desired.subtract(host.getVelocity()); return force;
}

Все другие методы поведения реализуются очень похожим образом. Например, метод pursuit() будет выглядеть так:

public function pursuit(target :IBoid) :void { steering.incrementBy(doPursuit(target));
} private function doPursuit(target :IBoid) :Vector3D { distance = target.getPosition().subtract(host.getPosition()); var updatesNeeded :Number = distance.length / host.getMaxVelocity(); var tv :Vector3D = target.getVelocity().clone(); tv.scaleBy(updatesNeeded); targetFuturePosition = target.getPosition().clone().add(tv); return doSeek(targetFuturePosition);
}

Мы можем использовать код из предыдущих частей туториала. Единственное, что нужно сделать — адаптировать его в виде behavior() и doBehavior(), чтобы его можно было прибавлять к менеджеру движения.

Приложение и обновление управляющих сил

При каждом вызове метода поведения вычисляемая им результирующая сила прибавляется к свойству steering менеджера. Следовательно, в этом свойстве аккумулируются все управляющие силы.

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

public function update():void { var velocity :Vector3D = host.getVelocity(); var position :Vector3D = host.getPosition(); truncate(steering, MAX_FORCE); steering.scaleBy(1 / host.getMass()); velocity.incrementBy(steering); truncate(velocity, host.getMaxVelocity()); position.incrementBy(velocity);
}

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

Применение

Допустим, у нас есть класс Prey, который должен двигаться с использованием steering behavior, но пока у него нет ни кода управления, ни менеджера движений. Его структура будет выглядеть так:

public class Prey
{ public var position :Vector3D; public var velocity :Vector3D; public var mass :Number; public function Prey(posX :Number, posY :Number, totalMass :Number) { position = new Vector3D(posX, posY); velocity = new Vector3D(-1, -2); mass = totalMass; x = position.x; y = position.y; } public function update():void { velocity.normalize(); velocity.scaleBy(MAX_VELOCITY); velocity.scaleBy(1 / mass); truncate(velocity, MAX_VELOCITY); position = position.add(velocity); x = position.x; y = position.y; }
}

При такой структуре экземпляры класса могут двигаться с помощью метода Эйлера. Чтобы мы могли использовать менеджер, классу нужно свойство, ссылающееся на менеджер движений, а также он должен применять интерфейс IBoid:

public class Prey implements IBoid
{ public var position :Vector3D; public var velocity :Vector3D; public var mass :Number; public var steering :SteeringManager; public function Prey(posX :Number, posY :Number, totalMass :Number) { position = new Vector3D(posX, posY); velocity = new Vector3D(-1, -2); mass = totalMass; steering = new SteeringManager(this); x = position.x; y = position.y; } public function update():void { velocity.normalize(); velocity.scaleBy(MAX_VELOCITY); velocity.scaleBy(1 / mass); truncate(velocity, MAX_VELOCITY); position = position.add(velocity); x = position.x; y = position.y; } // Ниже идут методы, требуемые интерфейсу IBoid. public function getVelocity() :Vector3D { return velocity; } public function getMaxVelocity() :Number { return 3; } public function getPosition() :Vector3D { return position; } public function getMass() :Number { return mass; }
}

Метод update() нужно изменить соответствующим образом, чтобы менеджер тоже мог обновляться:

public function update():void { // Делаем так, чтобы prey блуждала по окружению... steering.wander(); // Обновляем менеджер, чтобы он мог изменять вектор скорости prey. // Также менеджер будет выполнять интегрирование Эйлера, изменяя // вектор "позиции". steering.update(); // После обновления менеджером своих внутренних структур, нам достаточно // обновить нашу позицию в соответствии с вектором "позиции". x = position.x; y = position.y;
}

Все поведения можно использовать одновременно, поскольку вызовы всех методов выполняются до вызова update() менеджера, который прилагает всю аккумулированную управляющую силу к вектору скорости хоста.

В коде ниже показана другая версия метода update() Prey, но на этот раз она будет стремиться (seek) к точке на карте и избегать (evade) другого персонажа (и всё это одновременно):

public function update():void { var destination :Vector3D = getDestination(); // место, к которому стремимся var hunter :IBoid = getHunter(); // получаем сущность, которая на нас охотится // Стремимся к цели и избегаем охотника (одновременно!) steering.seek(destination); steering.evade(hunter); // Обновляем менеджер, чтобы он изменил вектор скорости prey. // Менеджер также выполняет интегрирование Эйлера, меняя // вектор "позиции". steering.update(); // После обновления менеджером своих внутренних структур, нам нужно только // обновить нашу позицию согласно вектору "позиции". x = position.x; y = position.y;
}

Пример

В показанном ниже примере представлено сложный паттерн движения, в котором сочетается несколько поведений. В сцене есть два типа персонажей: Hunter (охотник) и Prey (жертва).

Он преследует её, пока у него остаётся энергия (stamina). Охотник будет преследовать жертву, если подберётся достаточно близко. Когда энергия заканчивается, преследование прекращается и охотник начинает блуждать, пока не восстановит уровень энергии.

Вот метод update() класса Hunter:

public function update():void { if (resting && stamina++ >= MAX_STAMINA) { resting = false; } if (prey != null && !resting) { steering.pursuit(prey); stamina -= 2; if (stamina <= 0) { prey = null; resting = true; } } else { steering.wander(); prey = getClosestPrey(position); } steering.update(); x = position.x; y = position.y;
}

Жертва будет неограниченно блуждать. Если охотник подберётся слишком близко, то она будет избегать его. Если курсор мыши близко и рядом нет охотника, жертва будет стремиться к курсору.

Вот как выглядит метод update() Prey:

public function update():void { var distance :Number = Vector3D.distance(position, Game.mouse); hunter = getHunterWithinRange(position); if (hunter != null) { steering.evade(hunter); } if (distance <= 300 && hunter == null) { steering.seek(Game.mouse, 30); } else if(hunter == null){ steering.wander(); } steering.update(); x = position.x; y = position.y;
}

Заключение

Менеджер движений очень полезен для одновременного управления несколькими steering behaviors. Сочетание таких поведений может создавать очень сложные паттерны движения, позволяющие игровой сущности стремиться к одному объекту и одновременно избегать другого.

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

Теги
Показать больше

Похожие статьи

Добавить комментарий

Ваш e-mail не будет опубликован. Обязательные поля помечены *

Кнопка «Наверх»
Закрыть