# Search and Path Finding for NPC and Games Abdennour El Rhalibi - PowerPoint PPT Presentation

PPT – Search and Path Finding for NPC and Games Abdennour El Rhalibi PowerPoint presentation | free to view - id: 992b9-MTQxY

The Adobe Flash plugin is needed to view this content

Get the plugin now

View by Category
Title:

## Search and Path Finding for NPC and Games Abdennour El Rhalibi

Description:

### ... list of complete paths and choose one with least cost. 31 ... Result/Goal: 'Glide down gradient/path of least resistance' 42. Potential Fields. Advantages? ... – PowerPoint PPT presentation

Number of Views:64
Avg rating:3.0/5.0
Slides: 78
Provided by: abdennour8
Category:
Tags:
Transcript and Presenter's Notes

Title: Search and Path Finding for NPC and Games Abdennour El Rhalibi

1
Search and Path Findingfor NPC and
GamesAbdennour El Rhalibi
CMPSEM044 CMPCD3026
2
Path Planning and Search
Solution Path
Spatial Environment
discretisation
Grid of cells mapped on the environment
Search Tree
search
Path
3
Overview
• Alternative Search Space Representations
• Grids
• Graphs
• Meshes
• When we know what the world looks like, how can
we move through it?
• A
• Precomputed Pathfinding with Navigation Sets
• Potential Fields

4
Introduction
• In many video games, artificial characters have
to find their way through spatial layouts
• rooms (DOOM-like games)
• terrain models, maps, etc. (strategy games)

5
Search Path Planning
• A significant number of games involve moving in
buildings, battlefields, etc.
• Choosing the best path within a determined space
is a classic AI problem
• Algorithms have been developed that construct
the best path by exploring possible directions on
the basis of individual cells properties

6
Discretisation
grid cells
hexagonal cells
G
3D discretisation
S
7
Regular Grids
8
Regular Grids
• How do we generate?
• Random access lookup (O(1)) to determine what
tile lies at any coordinate
• Complete
• Negatives
• Usually requires large number of nodes to
accurately represent world
• Path Quality
• Agent can only walk in four cardinal directions?
Thats no fun.
• Let them walk diagonals! Still not much fun

9
Regular Grids
NWSE
Diagonals
String-Pulling
Catmull-Rom Spline
10
Grids as Graphs
• Everything else we look at will be a graph
• Grids are graphs too
• Each cell is a node and edges are adjoining cells
• Maybe we should just handle grid as a graph
• Undirected graph could tell us about topography,
etc, whereas array cant

11
Grids as Graphs
12
Corner Graphs
• Waypoints around obstacles

13
Corner Graphs
• How do we generate?
• Identify convex corners, can character walk in
straight line between? Add edge if possible
• Less memory
• Faster generation
• Negatives
• Character will walk on a rail hugging edges of
obstacles instead of walking through open space
• And what about different sized characters?
• Lookup is O(n2), have to check every node in
graph against every other. Imagine a world with

14
Corner Graphs
15
Corner Graphs
16
Waypoint Graphs
• Place nodes in middle of rooms instead of at
convex corners

17
Waypoint Graphs
• How do we generate?
• Place nodes wherever we want (suits 3-D worlds ?
But requires hand tuning to be effective ?)
• Reduce memory footprint from regular grids,
reduce wall hugging from corner graphs
• Work well in human architectures
• Negatives
• Still O(n2)
• Path Quality vs. Simplicity
• Works poorly in open areas

18
Waypoint Graphs
19
Circle-Based Waypoint Graphs
waypoint

20
Circle-Based Waypoint
• Only look at overlapping circles, alleviating
O(n2) problem from before
• Easier to obtain optimal paths
• Works well in open terrain
• Negatives
• Doesnt work as well in human architectures that
arent circle friendly

21
Space-Filling Volumes
• Use rectangles or 3-D Boxes instead of circles

22
Space-Filling Volumes
• How do we generate?
• Seed and Grow
• Make Grid and Merge
• Very similar to circle-based, but handles angles
better

23
• Lets try and cover walk able surfaces with
convex polygons
• Character can travel between adjoining polygons

24
25
• How do we generate?
• By hand (time consuming)
• Automated tools to analyze and optimize geometry
of world
• Too complex and not represented as a single
polygon mesh, instead may be overlapping, etc

26
• Quickly find optimal paths independent of
character shapes and capabilities
• Handle indoor and outdoor terrains well
• Negatives
• Can become complex and expensive memory wise
• Difficult to generate

27
Problem with N-Sided Meshes
28
Interacting with Pathfinding
• What about dynamic objects in world?
• All the representations discussed have been
static and obviously cant handle a dynamic world
directly
• These representations need to be able to provide
information to system determining path
• Waypoint Graphs and Corner Graphs dont
illustrate walk able surfaces
• Meshes and Grids do map every walk able surface
• Space-filling volumes and Circle Waypoints
provide some representation of walk able areas

29
Path finding
• Now that we have world represented, how do we
plan movement?
• A, Depth-First, Dijkstra
• Dynamic path finding is expensive
• Precompiled solutions can eliminate runtime cost,
but memory expensive
• Article suggests technique of Navigation Set
Hierarchy

30
Path finding
• Determine best paths leading from source node to
boundary of source set
• Determine best path from source set boundary to
goal set boundary
• Determine best path from goal set boundary to
goal node
• Compile list of complete paths and choose one
with least cost

31
Transition Table
• Main element in pre computed solutions is a
lookup table
• Each entry represents next step to take from one
node to some goal node

32
Transition Table
33
Transition Table
• Do not need full search of nodes at run time,
just series of lookups
• Fast, but becomes memory expensive as size of
world grows
• How expensive? n2
• solution to shrink transition tables?
• Hierarchy!

34
• Self-contained collection of nodes that requires
no links to external nodes to complete a path
• Nodes can be members of more than one set
• Goal Find someway to partition large Navigation
Sets into smaller ones

35
Complete Hierarchy
36
Interface Nodes and Sets
• Need to account for paths that cross navigation
sets
• Any node that connects to a node in another
navigation set is an interface node
• Have a second layer of nodes in addition to
• Interface set itself is a navigation set
• Therefore, can make transition table for it too

37
Complete Hierarchy
• 21 nodes
• 1 Navigation Set 441 Table Entries (2121)
• 4 Navigation Sets 183 Table Entries (77 77
77 66)

38
Constructing the Hierarchy
• Two goals to process
• How many tables to create?
• Amount of data needed is 1/n of original size
interface set
• As size of navigation sets increase, cost of
interface set becomes less a factor
• Where to place boundaries?
• Keep interface nodes as low as possible

39
Constructing the Hierarchy
40
Potential Fields
• Reactive approach to path finding
• Setup virtual potential or force field around
objects
• Must define field and agents reaction to field
• Interactions in general are explicitly stated and
movement emerges
• Paths are not planned explicitly

41
Potential Fields
• Think of world as matrix
• Each point tells has value to represent strength
of field under it
• Possibly assign potential based on distance from
goal
• Might get stuck behind obstacle
• Result/Goal Glide down gradient/path of least
resistance

42
Potential Fields
• Works in continuous space! No need to make grid,
place waypoints, etc
• Can be trapped in local minima
• Its emergent, not sure what it will do

43
Path planning on a grid (1/2)
• Going from A to B avoiding obstacles
• It is only possible to move from one cell to an
• How to find
• the shortest path?
• In the shortest time?
• At the lesser cost?

B
A
44
Path planning on a grid (2/2)
• From each node of the grid, it is possible to go
only to neighbouring nodes
• Path planning is the process by which a path is
assembled from A to B through authorised moves

45
Search Trees
• From a given node, it is possible to generate a
set of neighbours. For instance a given node on
the grid has for neighbours corresponding to the
N, S, E, W, NW, NE, SE, SW moves
• The process of generating all the neighbours of a
given node is called node expansion.

46
Grid Moves and Search Trees
B
path
A
47
Search Algorithms and Path Planning
• Because the path on the grid is formally
equivalent to a path on the tree, tree-searching
algorithms can be used for path planning
• The path found on the tree does correspond to a
path on the grid, hence in the game environment

48
Why Search?
• Search is a key technique for AI, in particular
real-time AI
• Applications in computer games include
• Path planning
• Moving Target Search
• Two-player games (othello, chess, etc.)
• Search-based planning for animation or
intelligent actor behaviour

49
Search
• Search consists of a set of technique that
explore graphs and extract solutions, i.e.
sub-graphs satisfying some desirable properties
• Solutions can be
• Nodes (e.g. n-queens)
• Paths (e.g. n-puzzle)

50
State-space Search
• In the state space representation of a problem,
the nodes correspond to partial problem solution
states and the arcs correspond to steps in the
problem solving process (or operators)
• This makes possible to apply the same
graph-search algorithms for finding a solution to
these problems (various optimisation problems,
games, etc.)

51
Search Problems
• Many problems can be described as search problems
(though this is not always the best description)
• Some traditional search problems are used to
teach search algorithms and assess the
performance of search methods

52
Search Algorithms
• These algorithms are based on graph traversal
through node expansion, i.e. the generation of
successors of a given node
• There are several formulations for search
algorithms (e.g., recursive vs. non-recursive
ones)

53
Search Algorithms (2)
• Traditionally, search algorithms are described
using two specific data structures, OPEN and
CLOSED
• OPEN is the list of candidate nodes
• CLOSED is the list of explored nodes

54
Uninformed Search
• Brute force search
• could take more than the age of universe on
some problems (e.g. Chess)
• One solutions is to use heuristics to prune the
search space this is called informed search or
heuristic search
• All the search algorithms we will describe are
heuristic search algorithms

55
OPEN
a
b c d e
c d e f g h
d e f g h i j

56
• Put S (the Start node) on OPEN
• While OPEN is not empty
• Select the first node from OPEN
• If n is a goal node, exit on success, else
• Expand node n
• Put children at the end of OPEN (eliminating
those already in OPEN or CLOSED)
• Note this is a FIFO strategy

57
Depth-first Search
OPEN
a
b c d e
f g h c d e
n o g h c d e

p h c d e
58
Depth-first Search
• Put S on OPEN
• While OPEN is not empty do
• Select first node from OPEN
• If n is a goal node, exit with solution
• Else expand node n, put children of n at the
beginning of OPEN (eliminating those already on
OPEN or CLOSED)
• Note this is a LIFO strategy

59
Heuristic Search
• General idea to use some form of information to
reduce the number of nodes explored by the search
process
• This saves time and space (memory)
• introduction to heuristic search A

60
Heuristic Search
• Principle using information to guide the search
of the space state, reducing the number of nodes
actually explored
• This information characterises how a given node

61
Heuristic Search
• Depth-first search and breadth-first search
select the first node from the OPEN list as the
next node to be explored
• The first node might not be the best
• How to extract the best node from OPEN?
• An evaluation function, f(n), measures the
quality of each node
• A heuristic is an estimate of the cost to the
goal node
• It is not mathematically accurate, it is a guess

62
Best-first Search
• Put S on OPEN
• While OPEN is not empty
• Select the node n from OPEN for which f(n) is
minimal, put n in CLOSED Expand n, generating
all its successors ni
• For all ni do
• Compute f(ni)
• If ni is neither in OPEN or CLOSED, put it in
OPEN
• If ni is already in OPEN or CLOSED, compare the
new value of f(ni) to the old one. If the new one
is lower ( better), substitute the new value to
the old, redirecting its pointers to n

63
Best-first Search
• The problem with BF search is that is has no
memory
• It can wander in the graph without keeping track
of the cost of the path it generated so far

64
The A Algorithm
• A is a heuristic search algorithm whose
evaluation function, f, takes into account both
the value of a node for reaching the goal and the
cost f(n) g(n) h(n)
• If n is a successor of n
• g(n) c(n, n) g(n)

n
c(n, n)
n
65
The f function in A
f(n) h(n) g(n)
Best-first component
(breadth-first search if h(n) 0 for all n)
66
The A Algorithm (1/3)(adapted from J. Pearl)
• 1. Put initial node in OPEN
• 2. if OPEN is empty, exit on failure
• 3. Take out of OPEN the node n for which f is
minimum and put it in CLOSED
• 4. If n is a goal node, exit returning the path
obtained by tracing back pointers from n to s

67
A Algorithm (2/3)
• 5. Otherwise expand n, generating all successors
nodes n, and keep pointers from these to n. For
each n (successor of n)
• if n is neither in OPEN or CLOSED, compute h(n)
and f(n) h(n) g(n)
• if n is already either in OPEN or CLOSED,
re-direct its pointers along the path giving
minimal g(n)

68
A Algorithm (3/3)
• 6. If n has required changing pointers and was
previously on CLOSED, put it back in OPEN
• 7. Go to step 2

69
The A Algorithm (pseudo-code)
While OPEN is not empty pop node n from OPEN
for which f is minimal if n is a goal node
return successful path for each successor n
of n if n is already in OPEN or CLOSED with
a lower cost g(n), consider next
successor compute f(n) if n is
in CLOSED, remove it from CLOSED if n is
not yet in OPEN, push n on OPEN push n
onto CLOSED Return failure if no solution found
70
Distance as Heuristic Function
B
• Cell x is closer to B than cell z
• As the goal is to find the shortest path,
distance can be used to select the most promising
nodes

x
A
z
Euclidean distance
Manhattan distance
71
Example
h d (n, G)
c 1
S
G
5
3
2
4
1
3
2
4
g(n) g(n) c(n, n)
1
5
S
f g h
f g h (estimate)
72
Example (2)
S
G
3
3.1
3.2
3.3
5
2
4
1
3
2
4
1
5
S
3.1
3.2
3.3
73
Example (3)
S
1
1
2
2
3
4
1
2
4
1
1
2
3
2
2
2
2
2
2
3
4
4
3
3
4
1
5
3
4
5
4
5
6
4
4
5
5
5
6
5
5
6
6
6
6
6
6
6
2.2
2.3
2.1
74
Implementing Path Planning (1)
• Discretise your graphic environment to obtain a
grid of cells
• Determine the contents of each cell, this will
define the cost for each cell (whether it can be
traversed or not, and at which terrain cost)
• For a static environment, this can be done
off-line

75
Implementing Path Planning (2)
• Choose the data structures for OPEN and CLOSED
depending on estimated size of the problem
• get relevant source code for handling data
structures
• Implement the A algorithm itself
• Map the resulting path to the animation procedure

76
Dynamic Environments
• A assumes that the goal is fixed
• Hence it cannot be used in dynamic environments,
i.e. environments in which the goal is moving
• Solutions
• A to last known location local search
• Real-time A (Algorithm versions of real-time
search)

77
The A Family
• RTA Real-Time A. The algorithm commits to a
move every unit of time
• LRTA Learning RTA (variants can be used to
chase moving targets)