7 . 2. AI Engine and Steering Behaviour I

1. 7.2.AI Engine and Steering Behaviour I Design of an AI Engine and introduction to steering in game AI

2. Game AI Engine Design of a game Artificial Intelligence Engine

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

4. Example structure of an AI Engine AI receives processor time 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 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. AI output is turned into action

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

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

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

8. Introduction to Movement Introduction to the different forms of movement AI

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

10. 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: 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 Vector position float orientation; Vector velocity; float rotation; Aside: In most 3D games, characters are usually under the influence of gravity, with movement effectively constrained to just two dimensions

11. Kinematic Movement Algorithms Basic forms of kinematic movement algorithm Based upon Artificial Intelligence for Games

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

13. Seek Current velocity 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. Target velocity 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) } normalise() will return vector of unit length and same direction See common on next slide for atan

14. Flee 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. 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; }

15. Aside: As with seek, etc., the returned velocity can be used to provide the object’s orientation if desired. Arrive 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 * 0.4 vel= max * 0.6 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: vel= max * 0.75 Closeness threshold slowingFactor = slowing strength vel= max vel = max Return initial velocity = 0.0 Determine velocity, and cap at max speed if needed

16. Steering Movement Algorithms Forms of dynamic (or steering) movement algorithm Based upon Artificial Intelligence for Games

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

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

19. To do: Think about movement 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.

20. Summary Today we explored: • The design of an AI engine • Kinematic forms of movement AI • Introduction to steering forms of movement AI 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