Chapter 5.

4
Artificial Intelligence: Pathfinding
Outline
 Introduction to pathfinding
 5 pathfinding algorithms
 Summary

2
Introduction
 Almost every game requires pathfinding
 Agents must be able to find their way
around the game world
 Pathfinding is not a trivial problem
 The fastest and most efficient
pathfinding techniques tend to consume
a great deal of resources

3
Pathfinding algorithms
 A* algorithm
 Random-Trace
 Breadth-First
 Best-First
 Dijkstra

4
Representing
the Search Space
 Agents need to know where they can move
 Search space should represent either
 Clear routes that can be traversed
 Or the entire walkable surface
 Search space typically doesn’t represent:
 Small obstacles or moving objects
 Most common search space representations:
 Grids
 Waypoint graphs
 Navigation meshes

5
Grids
 2D grids – intuitive world representation
 Works well for many games including some
3D games such as Warcraft III
 Each cell is flagged as either Passable
or impassable
 Each object in the world can occupy
one or more cells

6
Characteristics of Grids
 Fast look-up
 Easy access to neighboring cells
 Complete representation of the level

7
Waypoint Graph
 A waypoint graph specifies lines/routes that
are “safe” for traversing
 Each line (or link) connects exactly two
waypoints
 An agent can choose to
walk along any of these
lines without having to
worry about running
into major obstacles
8
Characteristics
of Waypoint Graphs
 Waypoint node can be connected to any
number of other waypoint nodes
 Waypoint graph can easily represent
arbitrary 3D levels
 Can incorporate auxiliary information
 Such as ladders and jump pads
 Incomplete representation of the level

9
Navigation Meshes
 Combination of grids and waypoint graphs
 Every node of a navigation mesh represents a
convex polygon (or area)
 As opposed to a single position in a waypoint node
 Advantage of convex polygon
 Any two points inside can be connected without
crossing an edge of the polygon
 Navigation mesh can be thought of as a
walkable surface

10
Navigation Meshes (continued)

11
Characteristics of
Navigation Meshes
 Complete representation of the level
 Ties pathfinding and collision detection
together
 Can easily be used for 2D and 3D games

12
Searching for a Path
 A path is a list of cells, points, or nodes that
an agent must traverse
 A pathfinding algorithm finds a path
 From a start position to a goal position
 The following pathfinding algorithms can be
used on
 Grids
 Waypoint graphs
 Navigation meshes

13
Criteria for Evaluating
Pathfinding Algorithms
 Quality of final path
 Resource consumption during search
 CPU and memory
 Whether it is a complete algorithm
 A complete algorithm guarantees to find a
path if one exists

14
Random Trace
 Simple algorithm
 Agent moves towards goal
 If goal reached, then done
 If obstacle
 Trace around the obstacle clockwise or counter-
clockwise (pick randomly) until free path
towards goal
 Repeat procedure until goal reached

15
Random Trace Characteristics
 Not a complete algorithm
 Found paths are unlikely to be optimal
 Incapable of considering a wide variety
of paths
 Consumes very little memory

16
Random Trace (continued)
 How will Random Trace do on the
following maps?

17
Understanding A*
 To understand A*
 First understand Breadth-First, Best-First,
and Dijkstra algorithms
 A* is a combination of Best-First and
Dijkstra
 These algorithms use nodes to
represent candidate paths
 They keep track of numerous paths
simultaneously
18
Understanding A*
class PlannerNode
{
public:
PlannerNode *m_pParent;
int m_cellX, m_cellY;
...
};

 The m_pParent member is used to chain nodes

19
Understanding A*
 All of the following algorithms use two lists
 The open list

 The closed list

 Open list keeps track of promising nodes

reached the goal

 Then placed on the closed list

 The closed nodes are those that do not correspond to the goal
cell and have been processed already
20
Overall Structure of the
Algorithms
1. Create start point node – push onto open list
2. While open list is not empty
A. Pop node from open list (call it currentNode)
B. If currentNode corresponds to goal, break from
step 2
C. Create new nodes (successors nodes) for cells
around currentNode and push them onto open list
D. Put currentNode onto closed list

21
Main different between 5
pathfinding algorithms
 Breadth-First always processes the node
that has been waiting the longest
 Best-First always processes the one that
is closest to the goal
 Dijkstra processes the one that is the
cheapest to reach from the start cell
 A* chooses the node that is cheap and
close to the goal

22
Breadth-First
 Finds a path from the start to the goal by
examining the search space step by step
 It checks all the cells that are one step from
the start, and then checks cells that are two
plies from the start, and so on.
 This is because the algorithm always
processes the node that has been waiting the
longest.

23
Bread-First cont’
 It uses a queue as the open list
 Once a node is created, it is pushed to
the back of the queue
 So that the node at the front of the
queue is always the one that has been
waiting the longest

24
Breadth-First Characteristics
 Exhaustive search
 Systematic, but not clever
 Consumes substantial amount of CPU and
memory
 Guarantees to find paths that have fewest
number of nodes in them
 Not necessarily the shortest distance!
 Search as hard in the direction away from the
goal as it does toward the goal
 Complete algorithm

25
Bread-First example

26
Best-First
 Uses problem specific knowledge to
speed up the search process
 Head straight for the goal
 Computes the distance of every node to
the goal
 Uses the distance (or heuristic cost) as a
priority value to determine the next node
that should be brought out of the open list
27
Best-First (continued)

28
Best-First (continued)
 Situation where Best-First finds a suboptimal path

29
Best-First Characteristics
 Heuristic search
 Uses fewer resources than Breadth-First
 Tends to find good paths
 No guarantee to find most optimal path
 Complete algorithm

30
Dijkstra
 Disregards distance to goal
 Keeps track of the cost of every path
 No guessing
 Computes accumulated cost paid to
reach a node from the start
 Uses the cost (called the given cost) as a
priority value to determine the next node
that should be brought out of the open list
31
Dijkstra Characteristics
 Exhaustive search
 At least as resource intensive as
Breadth-First
 Always finds the most optimal path
 Complete algorithm

32
A*
 It uses an admissible heuristic function that
never overestimates the true cost
 Uses both heuristic cost (the estimated cost
to reach the goal) and given cost (the actual
cost paid to reach a node from the start) to
order the open list
 Final Cost = Given Cost + (Heuristic Cost * Heuristic Weight)

33
A* cont’
 Final Cost = Given Cost + (Heuristic Cost *
Heuristic Weight)
 Heuristic weight can be used to control the amount
of emphasis on the heuristic cost versus the given
cost.
 It can control whether A* should behave more like
Best-First or Dijkstra.
 If hw=0, final cost will be the given cost ->Dijkstra
 If hw >>1, it will behave just like Best-First

34
A* (continued)
 Avoids Best-First trap!

35
A* Characteristics
 Heuristic search
 On average, uses fewer resources than
Dijkstra and Breadth-First
 Admissible heuristic guarantees it will find the
most optimal path
 Complete algorithm

36
Summary
 Two key aspects of pathfinding:
 Representing the search space
 Searching for a path

37