7.2. AI ENGINE AND STEERING BEHAVIOUR IDesign of an AI Engine and introduction to steering in game AI

GAME AI ENGINEDesign of a game Artificial Intelligence Engine

A Game Artificial Intelligence Engine

In simple games, AI tends to be bespoke and individually written for each character (e.g. embedded within the layer/object update method).

In more complex games there is a need to have a set of general AI routines that can be controlled by level designers, etc. There is often a need to manage CPU/memory constraints. Aside: Unless you explicitly

wish to do so, you do not need to define a separate AI

engine in your relatively simple game.

Example structure of an AI EngineThe AI gets some time to perform / progress its routines.

Higher-level AI applies to groups, whilst lower-level AI operates on individual game objects.

The AI engine can query the world to obtain information.

The output of the AI engine is turned into actions that update the game state.

Execution Management

World Interface

AI receives processor time

AI output is turned into action

AI o

btai

ns w

orld

info

rmat

ion

Movement

(Character AI)

Decis ion

Making (Char

AI)

Strategy

(Group AI )

Animation Physics ...

Aside: Not all games need all types of AI, e.g. Board games may only need strategic AI,

whilst a scrolling shooter may only need simple movement AI.

AI Engine (movement)The movement component contains a range of algorithms that make decisions about motion.

There are a range of movement algorithms, from very simple, to very complex.

Execution Management

World Interface

Movement

S tr at eg yD e c i

s i o n M a ki n g

Animation

Physics ...

AI Engine (decision making)Each game character will typically have a range of different behaviours that can be performed. The decision making process determines which behaviour is best at a given point in time.

Selected behaviours are then translated into action (possibly making use of movement AI, or simply triggering an animation).

Execution Management

World Interface

Movement

S tr at eg yD e c i

s i o n M a ki n g

Animation

Physics ...

AI Engine (strategy)In order to coordinate the behaviour of multiple game objects some form of strategic AI is often needed.

In other words, strategic AI controls/ influences the behaviour of a group of characters, often devolving the execution of the group behaviour to individual decision making / movement algorithms.

Execution Management

World Interface

Movement

S tr at eg yD e c i

s i o n M a ki n g

Animation

Physics ...

INTRODUCTION TO MOVEMENTIntroduction to the different forms of movement AI

Execution Management

World

Interface

Movement

S t r a te g y

Animation Physics ...

Introduction to movement AIThe aim of movement AI is to sensibly move game objects around the level.

All movement algorithms take as input data about the state of the world and output geometric data about the desired form of movement.

Some algorithms only require the object’s position and a target position. Others algorithms require lots of interaction with objects (e.g. collision avoidance, etc.).

Some algorithms directly output a new velocity (termed kinematic movement), others output an acceleration/force used to update the object’s velocity (termed dynamic or steering behaviours)

Introduction to movement AI (kinematics)

All game objects can be defined as having a position and an orientation.

In some game types a movement algorithm can directly update the position/orientation (e.g. tile-based). However, this will look unrealistic in other types of game (e.g. driving).

In order to permit continuous (2D) movement it is necessary to store:Vector position

float orientation;Vector velocity;float rotation;

Steering algorithms output an acceleration (or force) applied to directional or rotational velocities. Using the Newton Euler equations, the variables can be updated as follows:

velocity += acceleration * time_deltarotation += angular_acc * time_delta

position += velocity * time_deltaorientation += rotation * time_delta

Aside: In most 3D games, characters are usually under the influence of gravity, with

movement effectively constrained to just two

dimensions

KINEMATIC MOVEMENT ALGORITHMSBasic forms of kinematic movement algorithm

Execution Management

World Interface

Movement

S t ra te gy

D e c is i o n M a k i

n g

Animation Physics

...

Based upon Artificial Intelligence for Games

Kinematic movement algorithmsKinematic movement algorithms operate using positions and orientations. The output is a target velocity (speed + orientation).

The speed may simply vary between full speed and stationary, i.e. kinematic algorithms do not use acceleration.

This section will explore the following basic forms of kinematic movement algorithm:Seek()

Flee()Arrive()

To do:Consider

if applicable

SeekSeek takes as input a current and target location. The algorithm calculates the direction from the current to the target location and defines a matching velocity.

The velocity can be used to define the output orientation if needed.

Seek ( Vector source, Vector target,float maxSpeed ) {

Vector velocity= (target –

source).normalise()* maxSpeed;

return velocity;}

DetermineOrientation(Vector velocity, float currentOrientation ) {

if( velocity.length() == 0 )return currentOrientation;

elsereturn Math.atan2( -velocity.x,

velocity.y)}

Current velocity

Target velocity

normalise() will return vector of unit length and same direction

See common on next slide for atan

FleeFlee is the opposite of Seek, i.e. the object moves away from their target. It can simply be defined as the opposite of the velocity returned by Seek, i.e:

Flee( Vector source, Vector target,float maxSpeed ) {

Vector velocity= (source – target).normalise()

* maxSpeed;return velocity;

}

Aside: Why atan2 on last slide? atan2 computes the arctangent of y/x in a range of (−π, π), i.e. it determines the counter clockwise angle (radians) between the x-axis and the vector <x,y> in 2D Euclidean space. The normal atan function returns a range of (−π/2, π/2)

This is useful to find the direction from one point to another.

ArriveA problem with Seek is that it can keep overshooting the target, never reaching it. One means to overcome this is to provide a buffer ‘close enough’ region around the target. Another is to reduce the speed as the target comes close. Both approaches can be combined as follows:

Arrive ( Vector source, Vector target,float maxSpeed, float nearRadius ) {

float slowingFactor = 0.2;

Vector velocity = [0,0,...];Vector separation = (target – source);

if( separation.length() < nearRadius )return velocity;

velocity = separation / slowingFactor;if( velocity.length() > maxSpeed )

velocity = velocity.normalise() *

maxSpeed;

return velocity;}

vel = max

vel= max

vel= max * 0.75vel= max * 0.6

vel= max * 0.4

Closeness threshold

Aside: As with seek, etc., the returned velocity can be used to provide the object’s orientation if

desired.

slowingFactor = slowing strength

Determine velocity, and cap at max speed if needed

Return initial velocity = 0.0

STEERING MOVEMENT ALGORITHMSForms of dynamic (or steering) movement algorithm

Execution Management

World Interface

Movement

S t ra te gy

D e c is i o n M a k i

n g

Animation Physics

...

Based upon Artificial Intelligence for Games

Steering movement algorithmsSteering behaviours extend the kinematic movement algorithms by determining acceleration (both forward movement and rotation)

In many game types (e.g. driving games) steering algorithms are often used. In other games, they may not be useful.

We will consider the following forms of steering behaviour:

Seek()Flee()Arrive()Wander()

To do:Consider

if applicable

Face()Separate()PathFollow()AvoidObstacle()Jump()

Pursue()Evade() Interpose()Align()

Matching a target propertyBasic steering algorithms operate by trying to match some kinematic property of the target to the source, e.g. this might be the target’s position, velocity, orientation, etc. Matching steering algorithms take source and target kinematic properties as input.

More advanced steering behaviours try to match a combination of properties, potentially with additional constraints.

Typically for each matching behaviour there is a readily defined opposite behaviour (e.g. Seek vs. Flee, etc.).

Flee path Seek path

Thinking about movement….The next lecture will consider the steering behaviours in detail.

As part of completing the Question Clinic for this week, please do think about the role of AI (including movement based AI) in your game and identify current areas of uncertainty.

To do:Think about

movement

Summary

To do:Complete Question

ClinicIterate/refine your game

design to define AI needs

Continue to plan what you hope to do for the Alpha handin

Today we explored:

The design of an AI engine

Kinematic forms of movement AI

Introduction to steering forms of movement AI