I may not have gone where I intended to go, but I think I have ended up where I needed to be. Douglas Adams

Size: px

Start display at page:

Download "I may not have gone where I intended to go, but I think I have ended up where I needed to be. Douglas Adams"

Beverly Hunter
5 years ago
Views:

1 Disclaimer: I use these notes as a guide rather than a comprehensive coverage of the topic. They are neither a substitute for attending the lectures nor for reading the assigned material. I may not have gone where I intended to go, but I think I have ended up where I needed to be. Douglas Adams All you need is the plan, the road map, and the courage to press on to your destination. Earl Nightingale

2 PREVIOUSLY ON

3 Class N-3 1. How would you describe AI (generally), to not us? 2. Game AI is really about The I of I. Which is what? Supporting the P E which is all about making the game more enjoyable Doing all the things that a(nother) player or designer 3. What are ways Game AI differs from Academic AI? 4. (academic) AI in games vs. AI for games. What s that? 5. What is the complexity fallacy? 6. The essence of a game is a g_ a set of r_, and a? 7. What are three big components of game AI in-game? 8. What is a way game AI is used out-of-game?

4 Class N-2 1. What is attack kung fu style? 2. How do intentional mistakes help games? 3. What defines a graph? 4. What defines graph search? 5. Name 3 uniformed graph search algorithms. 6. What is a heuristic? 7. Admissible heuristics never estimate 8. Examples of using graphs for games

17 Is NavMesh good for all games? Not necessarily 2d Strategy game grid gives fast random access Among the best for robust pathfinding and terrain reasoning in 3d worlds Find the right solution for your problem

18 Class N-1 1. What are some benefits of path networks? 2. Cons of path networks? 3. What is the flood fill algorithm? 4. What is a simple approach to using path navigation nodes? 5. What is a navigation table? 6. How does the expanded geometry model work? Does it work with map gen features? 7. What are the major wins of a Nav Mesh? 8. Would you calculate an optimal nav-mesh?

findnearestwaypoint() Most engines provide a rapid nearest function for objects Spatial partitioning w/ special data structures: Quad-trees (2d), oct-trees

19 findnearestwaypoint() Most engines provide a rapid nearest function for objects Spatial partitioning w/ special data structures: Quad-trees (2d), oct-trees (3d), k-d trees Binary space partitioning (BSP tree) Multi-resolution maps (hierarchical grids) The gain over all-pairs techniques depends on number of agents/objects

20 Graphs, Search, & Path Planning Continued (and maybe kinematic motion; steering and flocking)

21 PATH NETWORK SEARCH

22 Precomputing Paths Why, When Faster than computation on the fly Especially with large maps or lots of agents How Use Dijkstra s algorithm to create lookup tables Lookup cost tables Registering search requests What is the main problem with precomputed paths?

23 Dijkstra s algorithm A single-source, multi-target shortest path algorithm for arbitrary directed graphs with non-negative weights Tells you path from any one node to all other nodes

24 Given: G=(V,E), source For each vertex v in G, set dist[v] to infinity Set dist[source] = 0 Let Q = all vertices in G While Q is not empty: Let u = get vertex in Q with smallest distance value Remove u from Q For each neighbor v of u: d = dist[u] + distance(u, v) if d < dist[v] then: dist[v] = d parent[v] = u Return dist[]

25 For each vertex v in G, set dist[v] to infinity Set dist[source] = 0 Let Q = all vertices in G While Q is not empty inf 6 2 inf 3 inf inf x dist[x] par[x] inf 3 inf 4 inf 5 inf 6 inf Q=[1,2,3,4,5,6] U= * Source = inf Let u = get vertex in Q with smallest distance value (node 1) dist[v]

26 Remove u (node 1) from Q For each neighbor v of u: d = dist[u] + distance(u, v) if d < dist[v] then: dist[v] = d parent[v] = u inf 6 2 inf 5 inf inf x dist[x] par[x] inf 4 inf 5 inf 6 inf Q=[1,2,3,4,5,6] U=1 V= * Source = parent[v] dist[v]

27 Remove u (node 1) from Q For each neighbor v of u: d = dist[u] + distance(u, v) if d < dist[v] then: dist[v] = d parent[v] = u inf inf inf x dist[x] dist[1]=0 par[x] 1 0 dist[2]=7 2 7 dist[3]= 1 dist[4]=inf 3 dist[5]=inf 1 4 inf dist[6]=inf 5 Q=[1,2,3,4,5,6] inf 6 inf Q=[1,2,3,4,5,6] U=1 V= * Source = parent[v] dist[v]

28 Remove u (node 1) from Q For each neighbor v of u: d = dist[u] + distance(u, v) if d < dist[v] then: dist[v] = d parent[v] = u inf inf x dist[x] par[x] inf 5 inf Q=[1,2,3,4,5,6] U=1 V= * Source = parent[v] dist[v]

29 inf inf x dist[x] par[x] inf 5 inf Q=[2,3,4,5,6] U=2 V= * Source = Let u = get vertex in Q with smallest distance value (node 2)

30 Remove u (node 2) from Q For each neighbor v of u: d = dist[u] + distance(u, v) if d < dist[v] then: dist[v] = d parent[v] = u inf inf x dist[x] par[x] inf 5 inf Q=[2,3,4,5,6] U=2 V= * Source = parent[v] dist[v]

31 Remove u (node 2) from Q For each neighbor v of u: d = dist[u] + distance(u, v) if d < dist[v] then: dist[v] = d parent[v] = u inf x dist[x] par[x] inf Q=[2,3,4,5,6] U=2 V= * Source = parent[v] dist[v]

32 inf x dist[x] par[x] inf Q=[3,4,5,6] U=3 V= * Source = Let u = get vertex in Q with smallest distance value (node 3)

33 Remove u (node 3) from Q For each neighbor v of u: d = dist[u] + distance(u, v) if d < dist[v] then: dist[v] = d parent[v] = u inf x dist[x] par[x] inf Q=[3,4,5,6] U=3 V= * Source = parent[v] dist[v]

34 Remove u (node 3) from Q For each neighbor v of u: d = dist[u] + distance(u, v) if d < dist[v] then: dist[v] = d parent[v] = u inf x dist[x] par[x] inf Q=[3,4,5,6] U=3 V= * Source = parent[v] dist[v]

35 inf x dist[x] par[x] inf Q=[4,5,6] U=6 V= * Source = Let u = get vertex in Q with smallest distance value (node 6)

36 Remove u (node 6) from Q For each neighbor v of u: d = dist[u] + distance(u, v) if d < dist[v] then: dist[v] = d parent[v] = u x dist[x] par[x] Q=[4,5,6] U=6 V= * Source = parent[v] dist[v]

37 x dist[x] par[x] Q=[4,5] U=4 V= * Source = Let u = get vertex in Q with smallest distance value (node 4)

38 Remove u (node 4) from Q For each neighbor v of u: d = dist[u] + distance(u, v) if d < dist[v] then: dist[v] = d parent[v] = u x dist[x] par[x] Q=[4,5] U=4 V= * Source = parent[v] dist[v]

39 x dist[x] par[x] Q=[5] U=5 V= * Source = Let u = get vertex in Q with smallest distance value (node 5)

40 x dist[x] par[x] Q=[ ] U=5 V= * Source = * We now know the shortest distance and shortest path to all nodes from node 1.

41 Floyd-Warshall algorithm All-pairs shortest path algorithm Tells you path from all nodes to all other nodes in weighted graph Positive or negative edge weights, but no negative cycles (edges sum to negative) Incrementally improves estimate O( V 3 ) [Use Dijkstra from each starting vertex when the graph is sparse and has non-negative edges]

42 Given: G=(V,E), source For each edge (u, v) do: dist[u][v] = weight of edge (u, v) or infinity next[u][v] = v For k = 1 to V do: for i = 1 to V do: for j = 1 to V do: Intermediate node Start node End node if dist[i][k] + dist[k][j] < dist[i][j] then: dist[i][j] = dist[i][k] + dist[k][j] next[i][j] = next[i][k]

43 Distance INF INF INF 1 INF INF INF 2 INF INF INF 1 INF 3 4 INF INF 6 3 INF k = 0 i = 0 j = Next

44 0 Distance INF INF INF INF INF INF 2 INF INF INF 1 INF 3 4 INF INF 6 3 INF 4 3 Next M S k = 2 i = F j = < INF 4 2 3

45 Distance INF 10 INF 1 INF INF INF 2 INF INF INF 1 INF 3 4 INF INF 6 3 INF M S F 3 4 k = 2 i = 0 j = 3 0 -> 3: dist 10, goto 2 Next

46 0 Distance INF 10 INF INF INF INF 2 INF INF INF 1 INF 3 4 INF INF 6 3 INF 4 3 Next M S k = 2 i = F j = < INF 4 2 3

47 Distance INF INF INF INF 2 INF INF INF 1 INF 3 4 INF INF 6 3 INF M S F 3 4 k = 2 i = 0 j = 4 0 -> 3: dist 10, goto 2 Next

48 Distance INF INF INF INF 2 INF INF INF 1 INF 3 4 INF INF 6 3 INF M S F 3 4 k = 3 i = 0 j = < 15 Next

49 Distance INF INF INF INF 2 INF INF INF 1 INF 3 4 INF INF 6 3 INF M S F 3 4 k = 3 i = 0 j = 4 0 -> 4: dist 13, goto 2 Next

50 Distance INF INF INF INF 2 INF INF INF 1 INF 3 4 INF INF 6 3 INF M S F 3 4 k = 3 i = 2 j = < 6 Next

51 Distance INF INF INF INF 2 INF INF INF 1 INF 3 4 INF INF 6 3 INF M S F 3 4 k = 3 i = 2 j = 4 2 -> 4: dist 4, goto 3 Next

52 Distance INF INF INF INF 1 INF 3 4 INF INF 6 3 INF

53 Reconstructing the path Want to go from u to v if next[u][v] is empty then return null path path = (u) while u <> v do: u = next[u][v] path.append(u) return path

54 Dynamic environments Terrain can change Jumpable? Kickable? Too big to jump/kick? Typically: destructible environments Path network edges can be eliminated Path network edges can be created

55 Heuristic Search Find shortest path from a single source to a single destination Heuristic function: We have some knowledge about how far away any given state from the goal, in terms of operation cost For navigation: Euclidean distance, Manhattan distance

56 A 366 B 0 C 160 D 242 E 161 F 176 G 77 H 151 I 226 L 244 M 241 N 234 O 380 P 100 S 253 T 32 U 80 V 1 Z 374

A* Search Single source, single target graph search Generalization of Dijkstra Guaranteed to return the optimal path if the heuristic is admissible;

57 A* Search Single source, single target graph search Generalization of Dijkstra Guaranteed to return the optimal path if the heuristic is admissible; quick and accurate Evaluate each state: f(n) = g(n) + h(n) Open list: nodes that are known and waiting to be visited Closed list: nodes that have been visited

58 A* Given: init, goal(s), ops ops = { } closed = nil open = {init} current = init while (NOT isgoal(current) AND open <> nil) closed = closed + {current} open = open {current} + (successors(current, ops) closed) current = first(open) end while if isgoal(current) then reconstruct solution else fail * Insert according to evaluation function

59 Evaluation function f(n) = g(n) + h(n) A 366 B 0 C 160 D 242 E 161 F 176 G 77 H 151 I 226 L 244 M 241 N 234 O 380 P 100 S 253 T 32 U 80 V 1 Z 374 Open: A(366) Closed:

60 Evaluation function f(n) = g(n) + h(n) A 366 B 0 C 160 D 242 E 161 F 176 G 77 H 151 I 226 L 244 M 241 N 234 O 380 P 100 S 253 T 32 U 80 V 1 Z 374 Open: S( =33), T(32+118=447), Z(374+75=44) Closed: A(366)

61 Evaluation function f(n) = g(n) + h(n) A 366 B 0 C 160 D 242 E 161 F 176 G 77 H 151 I 226 L 244 M 241 N 234 O 380 P 100 S 253 T 32 U 80 V 1 Z 374 Open: R(220+13=413), F(23+176=415), T(32+118=447), Z(374+75=44), O(21+380=671) Closed: S(33), A(366)

62 Evaluation function f(n) = g(n) + h(n) A 366 B 0 C 160 D 242 E 161 F 176 G 77 H 151 I 226 L 244 M 241 N 234 O 380 P 100 S 253 T 32 U 80 V 1 Z 374 Open: F(23+176=415), P( =417), T(32+118=447), Z(374+75=44), C( =526), O Closed: R(413), S(33), A(366)

63 Evaluation function f(n) = g(n) + h(n) A 366 B 0 C 160 D 242 E 161 F 176 Backtrack! G 77 H 151 I 226 L 244 M 241 N 234 O 380 P 100 S 253 T 32 U 80 V 1 Z 374 Open: P( =417), T(32+118=447), Z(374+75=44), B(450+0=450), C( =526), O(2 Closed: F(415), R(413), S(33), A(366)

64 Evaluation function f(n) = g(n) + h(n) A 366 B 0 C 160 D 242 E 161 F 176 G 77 H 151 I 226 L 244 M 241 N 234 O 380 P 100 S 253 T 32 U 80 V 1 Z 374 Open: B(418+0=418), T(32+118=447), Z(374+75=44), C( =526), O(21+380=671) Closed: P(417), F(415), R(413), S(33), A(366)

65 Evaluation function f(n) = g(n) + h(n) A 366 B 0 C 160 D 242 E 161 F 176 G 77 H 151 I 226 L 244 M 241 N 234 O 380 P 100 S 253 T 32 U 80 V 1 Z 374 Solution: A-S-R-P-B Open: T(32+118=447), Z(374+75=44), C( =526), O(21+380=671) Closed: B(418), P(417), F(415), R(413), S(33), A(366)

66 A* Search A* is optimal but only if you use an admissible heuristic An admissible heuristic is mathematically guaranteed to underestimate the cost of reaching a goal What is an admissible heuristic for path finding on a path network?

67 Non-Admissible Heuristics What happens if you have a non-admissible heuristic? F G Goal A B C D

68 Non-admissible heuristics Discourage agent from being in particular states Encourage agent from being in particular states

69 Hierarchical Path Planning Used to reduce CPU overhead of graph search Plan with coarse-grained and fine-grained maps People think hierarchically (more efficient) We can prune a large number of states Example: Planning a trip to NYC based on states, then individual roads

70 Hierarchical A* star.pdf Within 1% of optimal path length, but up to 10 times faster

71 How high up do you go? As high as you can without start and end being in the same node.

72 1. Build clusters. Can be arbitrary 2. Find transitions, a (possibly empty) set of obstacle-free locations. 3. Inter-edges: Place a node on either side of transition, and link them (cost 1). 4. Intra-edges: Search between nodes inside cluster, record cost. * Can keep optimal intra-cluster paths, or discard for memory savings.

73 1. Start cluster: Search within cluster to the border 2. Search across clusters to the goal cluster 3. Goal cluster: Search from border to goal 4. Path smoothing * Really just adds start and goal to the hierarchy graph

74 Path Smoothing in Hierarchical A*

75 Sticky Situations Dynamic environments can ruin plans What do we do when an agent has been pushed back through a doorway that it has already visited? What do we do in fog of war situations? What if we have a moving target?

76 Real Time A* Online search: execute as you search Because you can t look at a state until you get there You can t backtrack No open list Modified cost function f() g(n) is actual distance from n to current state (instead of initial state) Use a hash-table to keep track of h() for nodes you have visited (because you might visit them again) Pick node with lowest f-value from immediate successors Execute move immediately After you move, update previous location h(prev) = second best f-value Second best f-value represents the estimated cost of returning to the previous state (and then add g)

77 RTA* with lookahead At every node you can see some distance DFS, then back up the value (think of it as minimin with alpha-pruning) Search out to known limit Pick best, then move Repeat, because something might change in the environment that change our assessment Things we discover as our horizon moves Things that change behind us

78 D* Lite Incremental search: replan often, but reuse search space if possible In unknown terrain, assume anything you don t know is clear (optimistic) Perform A*, execute plan until discrepancy, then replan D* Lite achieves 2x speedup over A* (when replanning)

79 Omniscient optimal : given complete information

80 Optimistic optimal : assume empty for parts you don t know.

81 Heuristic Search Recap A* Can t precompute Dynamic environments Memory issues Optimal when heuristic is admissible (and assuming no changes) Replanning can be slow on really big maps Hierarchical A* is the same, but faster

82 Heuristic Search Recap Real-time A* Stumbling in the dark, 1 step lookahead Replan every step, but fast! Realistic? For a blind agent that knows nothing Optimal when completely blind

83 Heuristic Search Recap Real-time A* with lookahead Good for fog-of-war Replan every step, with fast bounded lookahead to edge of known space Optimality depends on lookahead

84 Heuristic Search Recap D* Lite Assume everything is open/clear Replan when necessary Worst case: Runs like Real-Time A* Best case: Never replan Optimal including changes

85 See also AI Game Programming wisdom 2, CH 2 Buckland CH 8 Millington CH 4

86 Next time (KINEMATIC) MOVEMENT, STEERING, FLOCKING, FORMATIONS

Graph Search Howie Choset

Graph Search Howie Choset 16-11 Outline Overview of Search Techniques A* Search Graphs Collection of Edges and Nodes (Vertices) A tree Grids Stacks and Queues Stack: First in, Last out (FILO) Queue: First