Pathfinding - Part 1: Α* heuristic search

INTERACTIVE OBJECTS IN

GAMING APPLICATIONS

Basic principles and practical scenarios in Unity

June 2013 Stavros Vassos Sapienza University of Rome, DIAG, Italy [email protected]

Interactive objects in games 2

Pathfinding

Part 1: A* heuristic search on a grid

Part 2: Examples in Unity

Part 3: Beyond the basics

Action-based decision making

AI Architectures

Pathfinding 3

Preview

Interactive objects in games 4

Pathfinding

Part 1: A* heuristic search on a grid

Part 2: Examples in Unity

Part 3: Beyond the basics

Action-based decision making

AI Architectures

Pathfinding 5

Find a path that connects two points in the game world

Pathfinding 6


Fundamental requirement in most video games

Traditionally considered as “AI for games”

Typically dealt as separate component of the game

that is used “as a service” by other AI components,

e.g., the decision making component of characters

Pathfinding 7


Fundamental requirement in most video games

Traditionally considered as “AI for games”

Typically dealt as separate component of the game

that is used “as a service” by other AI components,

e.g., the decision making component of characters

More complicated than it looks!

Pathfinding 8

Funny video with bugs by Paul Tozour (2008)

youtube link

http://www.youtube.com/watch?v=lw9G-8gL5o0



Pathfinding: A* heuristic search 9

Let’s start with a textbook approach

Game-world as a grid, A* heuristic search



Using tool from http://www.policyalmanac.org/

http://www.policyalmanac.org/games/aStarTutorial.htm




Simple forward search

Explore until the target is found

Open list

Possible nodes to visit next

Closed list

Visited nodes

Choose next node using

A cost function g(n) – cost so far

A heuristic function h(n) – remaining




Open list


Closed list in blue

Visited nodes




Open list in green


Closed list

Visited nodes




Open list in green


Closed list in blue

Visited nodes

Here exactly one node is

expanded (i.e., the starting node)




Use f(n) = g(n) + h(n) for each

node in the open list to pick the

next one to expand

f(n) is computed when node n is

added to the open list, when

node n’ is expanded, e.g.:

g(n) = g(n’) + 10 if straight

g(n) = g(n’) + 14 if diagonal

h(n) = manhattan distance to target


Estimated remaining cost h(n) guides the search

Cost so far g(n) balances wrt weak estimates

g(n) = 0+10

h(n) = 80

f(n) = 90


Manhattan distance: x2-x1 + y2-y1

Here it is an accurate estimate as the example is trivial

g(n) = 0+10

h(n) = 80

f(n) = 90


Expanding the node with the minimal value of f(n)..






Things become more interesting when there are

obstacles in the way


What percentage of the search space will be

expanded (i.e., explored) in this case?


We expect that the search would go directly toward the destination expanding only nodes to the right, until it hits the wall and then go toward up and down in parallel

Then, as the g(n) cost of each expanded node increases though, it forces the search method to look back and expand also in the other directions away from the goal

This way, following a dead-end for too long is avoided, but also more nodes are explored





All four nodes are equally

promising


f(n1) = 54+50 = 104

f(n2) = 44+60 = 104


f(n1) = 54+50 = 104

f(n2) = 44+60 = 104

But why not

f(n1) = 60+50 ?

f(n2) = 50+60 ?


Some important details

What happens when a node is already visited

The closed list keeps track about visited nodes

Also keeps track of the best way so far to get there

When a node n is expanded by node n’, and f(n) is

better than the value stored in the closed list, then we

update the f(n) value


This node is considered both when

the two other nodes are expanded


Some important details

What happens when a node is already visited

The closed list keeps track about visited nodes

Also keeps track of the best way so far to get there

When a node n is expanded by node n’, and f(n) is

better than the value stored in the closed list, then we

update the f(n) value

We also need to update the best path that leads there


Keeping track of the best path that leads to a node

In general we could store with each node also the path

that takes us there (we will see this in heuristic search A*

planning later)

Here we just need to store the parent of the node n,

i.e., the node n’ that we expanded to get n with the

best f(n) value


Keeping track of the best path that leads to a node

In general we could store with each node also the path

that takes us there (we will see this in heuristic search A*

planning later)

Here we just need to store the parent of the node n,

i.e., the node n’ that we expanded to get n with the

best f(n) value

This is what these little arrows do in the images we saw




f(n1) = 58+60 = 118

In fact more costly than the other

f(n2) = 10+100 = 110


f(n1) = 58+60 = 118

In fact more costly than the other

f(n2) = 10+100 = 110

Put it differently: a

lot of cost g(n1) has

been invested, but

the estimated cost

h(n1) is not small

enough to make the

overall cost f(n1) the

best promising





f(n1) = 146

h(n2) = 146


Important point about A*!

Does A* provide the shortest path?




It depends on the heuristic

One particular class of heuristics that ensure optimal

solutions are the admissible heuristics

These are optimistic heuristics that always

underestimate the remaining cost









Intuition1: Think of a heuristic that hugely overestimates

the optimal path and is zero for all other nodes.









Intuition2: When heuristic is zero for all nodes, the best

node is based on total cost so the optimal path is found.









(Understanding heuristics will become very important

when we talk about heuristic search A* planning later)


Basic options to consider for pathfinding problems

Forward/backward/bi-directional search

A*/best-first/weighted A*/…

Domain-dependent/independent heuristics

Manhattan, Chebyshev, Euclidian

Heuristics on Amit's A* pages

Diagonal movement: 4-connected vs 8-connected grid

A* playground to try out different combinations

http://qiao.github.io/PathFinding.js/visual/

http://theory.stanford.edu/~amitp/GameProgramming/Heuristics.html




http://qiao.github.io/PathFinding.js/visual/



h(n): Euclidean

Grid: 4-connected


h(n): Euclidean

Grid: 8-connected


h(n): Manhattan

Grid: 4-connected


h(n): Manhattan

Grid: 8-connected


In many cases this is all you need to handle

pathfinding in a game (modulo tuning your

implementation to be efficient)

In AAA modern games though, the game-world is

more complicated both in terms of features and in

terms of size, and tricks (or research) is needed!


More complicated game-worlds

Different types of terrain different cost

Road, path, water, terrain, mud, …

Different type of characters different cost/ability

Walking units, vehicles, air-units, scouters, …

More than one level

Stairs, elevators, hills, slopes, …

“Nicer” paths are needed!

Smoother curves, more “organic”, with variation, …

The game-world is huge!

Need for memory and CPU efficiency


More complicated game-worlds

Different types of terrain different cost

Different type of characters different cost/ability

More than one level

“Nicer” paths are needed!

The game-world is huge!

We can deal with some of these with simple tricks

There is a lot of applied and research work!

E.g., AI Programming Wisdom book series

Also in top AI/Robotics conferences, e.g., AAAI, ICAPS,

AIIDE, IROS


Commercial game grid-world benchmarks

http://www.movingai.com/benchmarks/




GPPC: Grid-Based Path Planning Competition

http://movingai.com/GPPC/cfp.html

Maps

Size at most 2048x2048

Static (unchanging)

8-connected

Diagonal actions in an optimal path cost sqrt(2)

http://movingai.com/GPPC/cfp.html


Many neat tricks for efficient/nice pathfinding

Alternative game-world representations

Better heuristics

Beyond A*

But first let’s see how this simple grid representation

and A* heuristic works in a game setting in Unity

Pathfinding Part 2: Examples in Unity 60

Pathfinding - Part 1: Α* heuristic search

Education

Transcript of Pathfinding - Part 1: Α* heuristic search

Monte Carlo Tree Search for Scheduling Activity Recognitionweb.engr.oregonstate.edu/~sinisa/talks/iccv13_AOG_presentation.pdf · Monte Carlo Tree Search for Scheduling Activity Recognition

Can Social Bookmarking Improve Web Search?

Lecture 17 Games and Adversarial Search

PArT NuMBEr SElECTION r 57. · 2013. 3. 19. · RAMSES Series To download technical data sheets, visit & enter the part number in the Search box. For more detailed technical information

Search for Minimal Supersymmetric Standard Model Higgs H ...uu.diva-portal.org/smash/get/diva2:1103987/FULLTEXT01.pdfZ the discovered particle is part of an extended scalar sector,benchmark

Search for Higgs decaying to exotic scalers

The Twenty-Five Year Lick Planet Search

3.2.2 LINE SEARCH METHODS: EXTRAS

Lecture 4 Part 1: Finish Geometrical Optics Part 2 ...

LUCIFER: Neutrinoless Double Beta Decay search with ...

The basics of semantic search, more than just adding synonyms to a search query!!!

Σεμινάριο SEO - Search Engine Optimization

Monte-Carlo Search Algorithms

Resolution Tunnels for Improved SAT Solver Performancegauss.ececs.uc.edu/China/china-06.pdf · Speed up search Reduce Search Space: • Reduce breadth of search space by initially

CS 4700: Foundations of Artificial Intelligence · CS 4700: Foundations of Artificial Intelligence Bart Selman selm[email protected] Module: Adversarial Search R&N: Chapter 5 Part

Αναζήτηση ( Search)

The Precautionary Principle as a Heuristic Patch

Kariera's Search Smart eBook

Current GRB Search Results & Future Prospects: Extending the Transient Point-Source Search

Heuristic methods used in sqlmap