7 . 2. AI Engine and Steering Behaviour I
description
Transcript of 7 . 2. AI Engine and Steering Behaviour I
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