Pathfinding - Part 1: Α* heuristic search

INTERACTIVE OBJECTS IN
GAMING APPLICATIONS
Basic principles and practical scenarios in Unity
June 2013Stavros Vassos Sapienza University of Rome, DIAG, Italy vassos@dis.uniroma1.it

Interactive objects in games
2
 Pathfinding
 Part 1: A* heuristic search on a grid
 Part 2: Examples in Unity
 Part 3: Beyond the basics
 Action-based decision making
 AI Architectures

Interactive objects in games
4
 Pathfinding
 Part 1: A* heuristic search on a grid
 Part 2: Examples in Unity
 Part 3: Beyond the basics
 Action-based decision making
 AI Architectures

Pathfinding
5
 Find a path that connects two points in the game world

Pathfinding
6
 Fundamental requirement in most video games
 Traditionally considered as “AI for games”
 Typically dealt as separate component of the game
that is used “as a service” by other AI components,
e.g., the decision making component of characters

Pathfinding
7
 Fundamental requirement in most video games
 Traditionally considered as “AI for games”
 Typically dealt as separate component of the game
that is used “as a service” by other AI components,
e.g., the decision making component of characters
 More complicated than it looks!

Pathfinding
8
 Funny video with bugs by Paul Tozour (2008)
youtube link

Pathfinding: A* heuristic search
9
 Let’s start with a textbook approach
 Game-world as a grid, A* heuristic search

10
 Using tool from http://www.policyalmanac.org/

11
 Simple forward search
 Explore until the target is found
 Open list
 Possible nodes to visit next
 Closed list
 Visited nodes
 Choose next node using
 A cost function g(n) – cost so far
 A heuristic function h(n) – remaining

12
 Open list
 Closed list in blue
 Visited nodes

13
 Open list in green
 Closed list
 Visited nodes

14
 Open list in green
 Closed list in blue
 Visited nodes
 Here exactly one node is
expanded (i.e., the starting node)

15
 Use f(n) = g(n) + h(n) for each
node in the open list to pick the
next one to expand
 f(n) is computed when node n is
added to the open list, when
node n’ is expanded, e.g.:
 g(n) = g(n’) + 10 if straight
 g(n) = g(n’) + 14 if diagonal
 h(n) = manhattan distance to target

16
 Estimated remaining cost h(n) guides the search
 Cost so far g(n) balances wrt weak estimates
g(n) = 0+10
h(n) = 80
f(n) = 90

17
 Manhattan distance: x2-x1 + y2-y1
 Here it is an accurate estimate as the example is trivial
g(n) = 0+10
h(n) = 80
f(n) = 90

18
 Expanding the node with the minimal value of f(n)..

19

20

21
 Things become more interesting when there are
obstacles in the way

22
 What percentage of the search space will be
expanded (i.e., explored) in this case?

23
 We expect that the search would go directly
toward the destination expanding only nodes to the
right, until it hits the wall and then go toward up
and down in parallel
 Then, as the g(n) cost of each expanded node
increases though, it forces the search method to look
back and expand also in the other directions away
from the goal
 This way, following a dead-end for too long is
avoided, but also more nodes are explored

24

25

26

27
All four nodes are equally
promising

28
f(n1) = 54+50 = 104
f(n2) = 44+60 = 104

29
f(n1) = 54+50 = 104
f(n2) = 44+60 = 104
But why not
f(n1) = 60+50 ?
f(n2) = 50+60 ?

30
 Some important details
 What happens when a node is already visited
 The closed list keeps track about visited nodes
 Also keeps track of the best way so far to get there
 When a node n is expanded by node n’, and f(n) is
better than the value stored in the closed list, then we
update the f(n) value

31
This node is considered both when
the two other nodes are expanded

32
 Some important details
 What happens when a node is already visited
 The closed list keeps track about visited nodes
 Also keeps track of the best way so far to get there
 When a node n is expanded by node n’, and f(n) is
better than the value stored in the closed list, then we
update the f(n) value
 We also need to update the best path that leads there

33
 Keeping track of the best path that leads to a node
 In general we could store with each node also the path
that takes us there (we will see this in heuristic search A*
planning later)
 Here we just need to store the parent of the node n,
i.e., the node n’ that we expanded to get n with the
best f(n) value

34
 Keeping track of the best path that leads to a node
 In general we could store with each node also the path
that takes us there (we will see this in heuristic search A*
planning later)
 Here we just need to store the parent of the node n,
i.e., the node n’ that we expanded to get n with the
best f(n) value
 This is what these little arrows do in the images we saw

35

36

37
f(n1) = 58+60 = 118
In fact more costly than the other
f(n2) = 10+100 = 110

38
f(n1) = 58+60 = 118
In fact more costly than the other
f(n2) = 10+100 = 110
Put it differently: a
lot of cost g(n1) has
been invested, but
the estimated cost
h(n1) is not small
enough to make the
overall cost f(n1) the
best promising

39

40

41

42
f(n1) = 146
h(n2) = 146

43
 Important point about A*!
 Does A* provide the shortest path?

44
 It depends on the heuristic
 One particular class of heuristics that ensure optimal
solutions are the admissible heuristics
 These are optimistic heuristics that always
underestimate the remaining cost

45
 Intuition1: Think of a heuristic that hugely overestimates
the optimal path and is zero for all other nodes.

46
 Intuition2: When heuristic is zero for all nodes, the best
node is based on total cost so the optimal path is found.

47
 (Understanding heuristics will become very important
when we talk about heuristic search A* planning later)

48
 Basic options to consider for pathfinding problems
 Forward/backward/bi-directional search
 A*/best-first/weighted A*/…
 Domain-dependent/independent heuristics
 Manhattan, Chebyshev, Euclidian
 Heuristics on Amit's A* pages
 Diagonal movement: 4-connected vs 8-connected grid
 A* playground to try out different combinations
 http://qiao.github.io/PathFinding.js/visual/

49

50
h(n): Euclidean
Grid: 4-connected

51
h(n): Euclidean
Grid: 8-connected

52
h(n): Manhattan
Grid: 4-connected

53
h(n): Manhattan
Grid: 8-connected

54
 In many cases this is all you need to handle
pathfinding in a game (modulo tuning your
implementation to be efficient)
 In AAA modern games though, the game-world is
more complicated both in terms of features and in
terms of size, and tricks (or research) is needed!

55
 More complicated game-worlds
 Different types of terrain  different cost
 Road, path, water, terrain, mud, …
 Different type of characters  different cost/ability
 Walking units, vehicles, air-units, scouters, …
 More than one level
 Stairs, elevators, hills, slopes, …
 “Nicer” paths are needed!
 Smoother curves, more “organic”, with variation, …
 The game-world is huge!
 Need for memory and CPU efficiency

56
 More complicated game-worlds
 Different types of terrain  different cost
 Different type of characters  different cost/ability
 More than one level
 “Nicer” paths are needed!
 The game-world is huge!
 We can deal with some of these with simple tricks
 There is a lot of applied and research work!
 E.g., AI Programming Wisdom book series
 Also in top AI/Robotics conferences, e.g., AAAI, ICAPS,
AIIDE, IROS

57
 Commercial game grid-world benchmarks
 http://www.movingai.com/benchmarks/

58
 GPPC: Grid-Based Path Planning Competition
 http://movingai.com/GPPC/cfp.html
 Maps
 Size at most 2048x2048
 Static (unchanging)
 8-connected
 Diagonal actions in an optimal path cost sqrt(2)

59
 Many neat tricks for efficient/nice pathfinding
 Alternative game-world representations
 Better heuristics
 Beyond A*
 But first let’s see how this simple grid representation
and A* heuristic works in a game setting in Unity

Pathfinding Part 2: Examples in Unity
60

Pathfinding - Part 1: Α* heuristic search

Recommended

Recommended

More Related Content

What's hot

What's hot (19)

Similar to Pathfinding - Part 1: Α* heuristic search

Similar to Pathfinding - Part 1: Α* heuristic search (20)

More from Stavros Vassos

More from Stavros Vassos (11)

Recently uploaded

Recently uploaded (20)

Pathfinding - Part 1: Α* heuristic search