7.2. AI E NGINE AND S TEERING B EHAVIOUR I Design of an AI Engine and introduction to steering in game AI

Design of 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.

The 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. AI receives processor time AI output is turned into action AI obtains world information 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.

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.

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).

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.

Introduction to the different forms of movement AI Execution Management World Interface Movem ent Strat egy Decision Making AnimationPhysics

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)

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_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

Basic forms of kinematic movement algorithm Execution Management World Interface Movem ent Strat egy Decision Making AnimationPhysics Based upon Artificial Intelligence for Games

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() To do: Consider if applicable

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. 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; else return 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

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 ) { 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 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.

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 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 * 0.75 vel= 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

Forms of dynamic (or steering) movement algorithm Execution Management World Interface Movem ent Strat egy Decision Making AnimationPhysics Based upon Artificial Intelligence for Games

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() To do: Consider if applicable Face() Separate() PathFollow() AvoidObstacle() Jump() Pursue() Evade() Interpose() Align()

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 pathSeek path

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

To do: Complete Question Clinic Iterate/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