Download Kinematic Movement Algorithms

7.2.AI ENGINE
AND STEERING BEHAVIOUR I
Design of an AI Engine and introduction to steering in game AI
Design 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 Engine
AI receives processor time
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.
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 obtains world information
The AI gets some time to
perform / progress its routines.
AI output is turned into action
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.
World Interface
Execution Management
Stra
tegy
Move
ment
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).
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
Strat
egy
Movem
ent
Animation
Introduction to the different forms of movement AI
Physics
Introduction to movement AI
The 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
float
Vector
float
position
orientation;
velocity;
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_delta
rotation += angular_acc * time_delta
position += velocity * time_delta
orientation += rotation * time_delta
Aside: In most 3D games, characters
are usually under the influence of
gravity, with movement effectively
constrained to just two dimensions
Execution Management
World Interface
Strat
egy
Movem
ent
Animation
Physics
Basic forms of kinematic movement algorithm
Based upon
Artificial Intelligence for Games
Kinematic movement algorithms
Kinematic 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()
Seek
Seek 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.
Target velocity
The velocity can be used to define the
output orientation if needed.
Seek ( Vector source, Vector target,
float maxSpeed ) { normalise() will return
DetermineOrientation(
Vector velocity, float currentOrientation ) {
vector of unit length
and same direction
Vector velocity
= (target – source).normalise()
* maxSpeed;
return velocity;
}
Current velocity
if( velocity.length() == 0 )
return currentOrientation;
else
return Math.atan2( -velocity.x, velocity.y)
}
See common on next slide for atan
Flee
Flee 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 ) {
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)
Vector velocity
= (source – target).normalise()
* maxSpeed;
return velocity;
}
This is useful to find the direction
from one point to another.
Aside: As with seek, etc., the returned
velocity can be used to provide the
object’s orientation if desired.
Arrive
A 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
vel= max * 0.4
follows:
vel= max * 0.6
vel= max * 0.75
vel= max
vel = max
Arrive ( Vector source, Vector target,
float maxSpeed, float nearRadius ) {
float slowingFactor = 0.2;
slowingFactor =
slowing strength
Vector velocity = [0,0,...];
Vector separation = (target – source);
if( separation.length() < nearRadius )
return velocity; Return initial velocity = 0.0
velocity = separation / slowingFactor;
if( velocity.length() > maxSpeed )
velocity =
velocity.normalise() * maxSpeed;
Closeness
threshold
return velocity;
}
Determine velocity, and
cap at max speed if
needed
Execution Management
World Interface
Strat
egy
Movem
ent
Animation
Physics
Forms of dynamic (or steering) movement algorithm
Based upon
Artificial Intelligence for Games
Steering movement algorithms
Steering 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()
Pursue()
Evade()
Interpose()
Align()
Face()
Separate()
PathFollow()
AvoidObstacle()
Jump()
Matching a target property
Basic 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.
Summary
Today we
explored:
 The design of
an AI engine
 Kinematic
forms of
movement AI
 Introduction
to steering
forms of
movement AI