Transcript CSE 114 – Computer Science I Lecture 1: Introduction

CSE 380 – Computer Game Programming
Pathfinding AI
Dig Dug, by Namco
Pathfinding
• Computation and execution of a path from
point p1 to p2
• Perhaps most common AI problem in games
• Can be very frustrating to implement well
– Algorithms must be tailored to fit games
• For an object at point p1, suggest an algorithm
to get to point p2
Simple 2D Vectoring Solution
• Determine vector v to head towards p2
v.x = p2.x – p1.x
v.y = p2.y – p1.y
• Now, scale v according to speed (use simple
geometry)
• What’s the problem?
– we are assuming there are no obstacles
Simple Trial and Error
•
•
For simple obstacles that aren’t large
Algorithm:
1. Go towards target destination
2. When you hit an obstacle:
•
•
•
Back it up
Randomly turn it right or left 45-90 degrees
Move it forward again for some random amount in a range
3. Go back to step 1
•
•
Easy & fast
Not good for fixed obstacles of any size
Contour Tracing
• Algorithm:
1. Go towards target destination
2. If you hit an obstacle:
– trace the contour of the obstacle blocking the path
– move such that you are a uniform distance from edge
– periodically test if a line to your destination intersects the
obstacle anymore
– if yes, stop tracing and head towards destination
– if no, go back to tracing
Real Time Pathfinding
• Modern strategy games use lots of units
simultaneously
• Dynamically computing paths can be expensive
• Solution: precompute
Waypoint Pathfinding
• Setup a network of paths
– connect all points of interest in the game via a
connected network of nodes
– each node represents a waypoint
– edges in the network represent:
• vector direction
• vector length
Key for precomputed paths
• Paths should avoid obstacles
What are precomputed paths?
• Nodes:
– locations on map (x, y)
• Edges
– direct paths to other nodes (x, y)
– distance
• Vectors
– computed from node to node along path
• Options:
– pre-compute and store entire paths (only viable for small data
sets)
– dynamically calculate paths from pre-computed graph data
How do we improve finding a path
• Game objects don’t necessarily start at nodes
– they shouldn’t have to go to nodes to pick up a path
either
• Made easier by path coverage
– making sure that everywhere on the board can reach a
path quickly
Dynamic Pathfinding Algorithms using Graphs
•
•
•
•
Breadth-first search
Depth-first search
Dijkstra’s algorithm
A*
• Premise:
– you have a graph of nodes
– you are at one node & you want to get to another
– What combination of edges will get you there?
Breadth-first search
• Fan out in all directions at the same time
–
–
–
–
visit each node one unit away
then two units away
then three
etc.
• Like a growing circle
• What’s bi-directional breadth-first search?
Depth-first search
• Searches one way all the way until:
– it finds the goal
OR
– it runs out of space
Dijkstra’s Algorithm
• Similar to minimum spanning tree algorithm
• O(V2), where V is the # of vertices
• Premise:
– find the shortest path from starting node to other nodes
along the way
– use those shortest path to determine your ultimate
shortest path
• A nice Dijkstra’s Applet:
– http://carbon.cudenver.edu/~hgreenbe/sessions/dijkstra/DijkstraApplet.html
A* Algorithm
• Solves shortest path problem for a directed graph
• All nodes have a G & H value
– G: min distance from origin node (A) to the given node
– H: estimated distance to goal
• Key to determining which nodes to use:
– Minimize G + H
How does it work
• Place origin node A in open list
• Look at all adjacent nodes for A
–
–
–
–
Add them to open list with A as parent
Remove A from open list & add to closed list
Which node (B) is the minimum distance (G + H)?
Remove minimum from open list and add to closed list
• Look at all adjacent nodes for B not on the closed list
– Add them to open list with B as parent
– Which node (C) is the minimum distance (G + H)?
– Is that node (C) already on the open list?
• If yes, just ignore B in path
• Continue in this manner until destination is reached
A* and Grids
• Strategy games are typically played on grids
• A grid can be easily divided into large nodes
– store the center of the node
– nodes must not include impassible terrain (e.g. water)
• The smaller the nodes, the more processing
• Example assumptions:
– horizontal/vertical movements cost 10
– diagonal movements cost 14
– no diagonal movements through obstacles
A* Grid Example
A* Grid Example
A* Grid Example
A* Grid Example
A* Grid Example
A* Grid Example
References
• A* Pathfinding for beginners
– http://www.policyalmanac.org/games/aStarTutorial.htm