Transcript Artificial Intelligence in Game Design

Artificial Intelligence in
Game Design
Lecture 11:
Path Planning Algorithms
Path Planning Algorithms
• Dijkstra’s shortest path algorithm
– Guaranteed to find shortest path
– Not fast (O (n2) )
• A* path algorithm
– Requires estimation heuristic
– Much faster
– Not guaranteed to find shortest path depending on heuristic
Dijkstra Algorithm Example
• Example:
5
2
6
6
7
1
8
3
1
Dijkstra Algorithm Example
• Example as a graph:
E
5
2
6
B
6
D
7
A
1
G
1
8
3
C
Goal: find shortest path from A to G
Dijkstra Algorithm Components
• Tree
– Contains all explored nodes
– Initially start node
– Assumption: know shortest path from
start to all nodes in rest of tree
• Fringe
– All nodes adjacent to some tree node
– Assumption : know shortest path from
start to all fringe nodes using only
nodes in tree
• Unknown
– All nodes not in tree or fringe
Dijkstra Algorithm Components
• Data structure for each node stores:
–
–
–
–
State of that node (tree, fringe, or unknown)
Shortest path (so far) from start to node
Total cost of that path
Initially:
• Fringe nodes have just edge from start
• Unknown nodes have no path
State
A
B
C
D
E
G
Best Path
Path Cost
Dijkstra Algorithm
At each cycle:
• Add fringe node n with shortest path to tree
• Recheck all nodes f in fringe to see if now shorter path
using n
– If current best path to f > path to n + edge from n to f
new path to f = path to n + edge from n to f
• Add unknown nodes u adjacent to n to fringe
– u’s path = path to n + edge from n to u
• Done when goal node in tree
– At that point, have shortest path to goal from start
Dijkstra Algorithm Example
Initially:
• Start node A in tree
• Adjacent nodes B, C, and E in fringe
• Paths to nodes = edge from start
E
5
2
B
6
D
6
7
A
G
1
8
3
C
1
Dijkstra Algorithm Example
State
Best Path
Path Cost
A
Tree
A
B
Fringe
AB
6
C
Fringe
AC
8
D
Unknown
E
Fringe
AE
2
G
Unknown
Dijkstra Algorithm Example
Next step:
• Add E to tree (shortest path of B, C, and E)
• Check whether creates shorter path to B (no)
• Check whether adjacent to unknown nodes (no)
E
5
2
B
6
D
6
7
A
G
1
8
3
C
1
Dijkstra Algorithm Example
Check whether A  E  B shorter
Cost of A  E  B = 7, so no change
State
Best Path
Path Cost
A
Tree
A
B
Fringe
AB
6
C
Fringe
AC
8
D
Unknown
E
Tree
AE
2
G
Unknown
Dijkstra Algorithm Example
Next step:
• Add B to tree (shortest path of B and C)
• Check whether creates shorter path to B (yes)
• Check whether adjacent to unknown nodes (yes)
E
5
2
B
6
D
6
7
A
G
1
8
3
C
1
Dijkstra Algorithm Example
Check whether A  B  C shorter
Cost of A  B  C = 7, so use it as path
State
Best Path
A
Tree
A
B
Tree
AB
6
C
Fringe
ACABC
87
D
Fringe
ABD
12
E
Tree
AE
2
G
Fringe
ABG
13
Paths to new nodes =
path to B + edge from B
Path Cost
Dijkstra Algorithm Example
Next step:
• Add C to tree (shortest path of C, D, and G)
• Check whether creates shorter path to G (yes)
E
5
2
B
6
D
6
7
A
G
1
8
3
C
1
Dijkstra Algorithm Example
Check whether A  C  G shorter
Cost of A  B  C  G = 10, so use it as
path
State
Best Path
Path Cost
A
Tree
A
B
Tree
AB
6
C
Tree
ABC
7
D
Fringe
ABD
12
E
Tree
AE
2
G
Fringe
ABGABCG
13 10
Dijkstra Algorithm Example
Next step:
• Add goal node G to tree (shortest path of D and G)
• Algorithm finished
– No possibility of shorter path through D
E
5
2
B
6
D
6
7
A
G
1
8
3
C
1
Dijkstra Algorithm Example
Final path and path cost
State
Best Path
Path Cost
A
Tree
A
B
Tree
AB
6
C
Tree
ABC
7
D
Fringe
ABD
12
E
Tree
AE
2
G
Tree
ABCG
10
Dijkstra Algorithm Analysis
• Worst case: may need to example all n nodes
• For each step, must check all m nodes in fringe
– Worst case: all n nodes in fringe
– Unlikely, since most levels far less interconnected
• Number of comparisons: O (nm)
– O (n2) in worst case
The A* Algorithm
• Similar in structure to Dijkstra
– Tree, fringe, and unknown nodes
– Store “best path so far” fro each node explored
– Choose next fringe node to add to tree
• Idea:
Choose fringe node n believed to be part of “shortest path”
– Haven’t explored entire graph yet, so don’t know path length
– Requires estimate of total path length
• Estimate is a heuristic H(n)
The A* Algorithm
• Estimated path length for path including n =
length of path from start to n + estimated distance from n to goal
Known, since have explored
graph from start to n
Requires heuristic H(n) to
create an estimate
Start
Goal
A* Algorithm Example
90
CLE
YNG
60
70
AKR
CAN
30
70
PIT
80
75
50
WHE
COL
100
Goal: find shortest path from YNG to COL
A* Algorithm Example
State
Best Path
Path Cost Heuristic
from Start H (n)
YNG
CLE
100
AKR
90
CAN
75
PIT
150
WHE
90
COL
0
Heuristic H (n) = “as crow flies” distance to COL
Total Estimated
Path Cost
A* Algorithm Example
State
Best Path
Path Cost Heuristic
from Start H (n)
Total Estimated
Path Cost
YNG
Tree
YNG
CLE
Fringe
YNG  CLE
90
100
190
AKR
Fringe
YNG  AKR
70
90
160
CAN
Unknown
PIT
Fringe
YNG  PIT
70
150
220
WHE
Fringe
YNG  WHE
80
90
170
COL
Unknown
75
0
Best path so far
A* Algorithm Example
State
Best Path
Path Cost Heuristic
from Start H (n)
Total Estimated
Path Cost
YNG
Tree
YNG
CLE
Fringe
YNG  CLE
90
100
190
AKR
Tree
YNG  AKR
70
90
160
CAN
Fringe
YNG  AKR  CAN
100
75
175
PIT
Fringe
YNG  PIT
70
150
220
WHE
Fringe
YNG  WHE
80
90
170
COL
Unknown
0
Add CAN to fringe
A* Algorithm Example
State
Best Path
Path Cost Heuristic
from Start H (n)
Total Estimated
Path Cost
YNG
Tree
YNG
CLE
Fringe
YNG  CLE
90
100
190
AKR
Tree
YNG  AKR
70
90
160
CAN
Fringe
YNG  AKR  CAN
100
75
175
PIT
Fringe
YNG  PIT
70
150
220
WHE
Fringe
YNG  WHE
80
90
170
COL
Unknown
0
Best path so far
A* Algorithm Example
State
Best Path
Path Cost Heuristic
from Start H (n)
Total Estimated
Path Cost
YNG
Tree
YNG
CLE
Fringe
YNG  CLE
90
100
190
AKR
Tree
YNG  AKR
70
90
160
CAN
Fringe
YNG  AKR  CAN
100
75
175
PIT
Fringe
YNG  PIT
70
150
220
WHE
Tree
YNG  WHE
80
90
170
COL
Fringe
YNG  WHE  COL
180
0
180
Add COL to fringe
A* Algorithm Example
State
Best Path
Path Cost Heuristic
from Start H (n)
Total Estimated
Path Cost
YNG
Tree
YNG
CLE
Fringe
YNG  CLE
90
100
190
AKR
Tree
YNG  AKR
70
90
160
CAN
Fringe
YNG  AKR  CAN
100
75
175
PIT
Fringe
YNG  PIT
70
150
220
WHE
Tree
YNG  WHE
80
90
170
COL
Fringe
YNG  WHE  COL
180
0
180
Best path so far
A* Algorithm Example
State
Best Path
Path Cost Heuristic
from Start H (n)
Total Estimated
Path Cost
YNG
Tree
YNG
CLE
Fringe YNG  CLE
90
100
190
AKR
Tree
YNG  AKR
70
90
160
CAN
Tree
YNG  AKR  CAN
100
75
175
PIT
Fringe YNG  PIT
70
150
220
WHE
Tree
80
90
170
COL
Fringe YNG  AKR  CAN  COL 175
0
175
YNG  WHE
Like Dijkstra, reevaluate all other nodes in fringe to see
if new tree node gives shorter path
A* Algorithm Example
State
Best Path
Path Cost Heuristic
from Start H (n)
Total Estimated
Path Cost
YNG
Tree
YNG
CLE
Fringe YNG  CLE
90
100
190
AKR
Tree
YNG  AKR
70
90
160
CAN
Tree
YNG  AKR  CAN
100
75
175
PIT
Fringe YNG  PIT
70
150
220
WHE
Tree
YNG  WHE
80
90
170
COL
Tree
YNG  AKR  CAN  COL
175
0
175
Best path
When goal node added to tree,
algorithm done
A* Heuristics
• A* heuristic admissible if always underestimates
distance to goal
H (n) ≤ actual distance to goal
A* Heuristics
– True for example
– Usually true for “as crow flies” estimates
CLE
ARK CAN PIT
WHE
Estimated
100
90
75
150
90
Actual
115
105
75
150
100
A* Heuristics
• Heuristic may not be valid if “short cuts” in level
B
C
Start
“Transporter pad”
between C and goal
A
–
–
–
–
Goal
D
A
B
C
Estimated
4
3
6.5 4
Actual
4
11 0
Estimated path using C has length 12.5
Actual path has length 6 (using transporter pad)
Path using A has estimated length 7
Goal added to tree before C ever explored
• However, non-optimal behavior may be more plausible
– Character may not know about transporter pad!
D
4
A* Heuristics
• Algorithm can be inefficient if heuristic severely underestimates
distance
– PIT and other obviously implausible nodes (CHI, PHI, NY, TOR, etc.) not
explored
Estimated
CLE
ARK CAN WHE PIT
CHI
PHI
TOR NY
100
90
240
400
210
75
90
150
…
420
• If all estimated distances low (1 for example) then all will be
explored
– Adjacent nodes (YNG  PIT  PHIL) explored before paths with closer but
more nodes (YNG  AKR  CAN  COL)
A* Heuristics
• Heuristic underestimates can happen in levels with costly terrain
– Estimated distance = 4 squares
– Actual distance = 2 + 5 + 5 = 9 due
to desert, mountains
• No perfect solution
• Potential hierarchical solution:
– Create high-level map with terrain type of
large general areas
– Determine which areas direct path to goal
would cross
– Factor in terrain costs
Start
Goal
Estimated distance =
width of forest area * cost of forest +
width of mountain area * cost of mountain