Loading...

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

Search and Path Findingfor NPC and

GamesAbdennour El Rhalibi

CMPSEM044 CMPCD3026

Path Planning and Search

Solution Path

Spatial Environment

discretisation

Grid of cells mapped on the environment

Search Tree

search

Path

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

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)

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

Discretisation

grid cells

hexagonal cells

G

3D discretisation

S

Regular Grids

Regular Grids

- How do we generate?
- Advantages
- 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

Regular Grids

NWSE

Diagonals

String-Pulling

Catmull-Rom Spline

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

Grids as Graphs

Corner Graphs

- Waypoints around obstacles

Corner Graphs

- How do we generate?
- Identify convex corners, can character walk in

straight line between? Add edge if possible - Advantages
- 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

a boat load or corners!

Corner Graphs

Corner Graphs

Waypoint Graphs

- Place nodes in middle of rooms instead of at

convex corners

Waypoint Graphs

- How do we generate?
- Place nodes wherever we want (suits 3-D worlds ?

But requires hand tuning to be effective ?) - Advantages
- 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

Waypoint Graphs

Circle-Based Waypoint Graphs

- Add radius parameter to indicate open space near

waypoint

Circle-Based Waypoint

- Advantages
- 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

Space-Filling Volumes

- Use rectangles or 3-D Boxes instead of circles

Space-Filling Volumes

- How do we generate?
- Seed and Grow
- Make Grid and Merge
- Very similar to circle-based, but handles angles

better

Navigation Meshes

- Lets try and cover walk able surfaces with

convex polygons - Character can travel between adjoining polygons

Navigation Meshes

Navigation Meshes

- 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

Navigation Meshes

- Advantages
- 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

Problem with N-Sided Meshes

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

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

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

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

Transition Table

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!

Navigation Set

- 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

Complete Hierarchy

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

navigation sets, called interface set - Interface set itself is a navigation set
- Therefore, can make transition table for it too

Complete Hierarchy

- 21 nodes
- 1 Navigation Set 441 Table Entries (2121)
- 4 Navigation Sets 183 Table Entries (77 77

77 66)

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

Constructing the Hierarchy

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

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

Potential Fields

- Advantages?
- Works in continuous space! No need to make grid,

place waypoints, etc - Disadvantages?
- Can be trapped in local minima
- Its emergent, not sure what it will do

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

adjacent cell - How to find
- the shortest path?
- In the shortest time?
- At the lesser cost?

B

A

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

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.

Grid Moves and Search Trees

B

path

A

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

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

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)

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.)

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

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)

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

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

Breadth-first Search

OPEN

a

b c d e

c d e f g h

d e f g h i j

Breadth-first Search

- 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

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

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

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

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

might lead to a solution

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

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

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

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

The f function in A

f(n) h(n) g(n)

Best-first component

Breadth-first component

(breadth-first search if h(n) 0 for all n)

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

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)

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

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

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

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)

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

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

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

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

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)

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) - Ae e-admissible A
- IDA Iterative-Deepening A (f threshold)
- D Dynamic A, allows replanning
- Rd A variant which uses information on how

good the heuristic function is