1 Artificial Intelligence in Games Week 5 Steve Rabin [email protected] TA: Chi-Hao Kuo...

1

Artificial Intelligence in GamesWeek 5

Steve [email protected]

www.aiwisdom.com/digipen

TA: Chi-Hao Kuo ([email protected])TA: Allan Deutsch ([email protected])

2

Project 1B: Behavior Trees How did it go? Thoughts?

If you didn’t turn it in… You must email it! One day late 50% penalty (up to 33 hours late –

3AM)

3

Questions1. Group emergent behavior: The group behavior

emerges from what?2. Flocking: What are the individual agents called?3. Flocking: Name the 3 primary steering behaviors.4. Flocking: Name the other 3 helpful steering

behaviors.5. Flocking: How is the leader chosen?6. Name as many steering behaviors as you can.7. Formations: Describe the 2 levels of steering.

4

5

Swarm of Nano Quadroters!!!

http://www.youtube.com/watch?v=YQIMGV5vtd4



6

News Flash!!!

Dateline: Thu Oct 1, 6:06 AM

http://ca.news.yahoo.com/s/afp/091001/oddities/

japan_auto_technology_offbeat

7

"Cars may one day mimic fish to avoid collisions" TOKYO (AFP) - Engineers in

Japan say they are a step closer to developing technology they hope will cut the risk of car crashes -- by mimicking the behavior of fish.

The experts at Nissan Motor have been studying fish and the way they are able to swim in schools and avoid colliding with each other.

8

Nissan:Welcome back to 1987!!!

9

Cars may one day mimic fish to avoid collisions The result is a robot that can travel in a

group of up to seven, avoiding bumps by sharing information with its peers.

The firm hopes to use the technology in its vehicles in future.

The three-wheeled robot uses a laser range finder, which measures the distance to an obstacle, and radio communications to recreate the behavior of fish, which can change direction and travel side by side without colliding.

10

Cars may one day mimic fish to avoid collisions Last year Nissan unveiled a similar robot inspired

by the bumblebee, which is also highly adept at avoiding collisions but travels solo.

"We, in a motorized world, have a lot to learn from the behavior of a school of fish in terms of each fish's degree of freedom and safety," said Toshiyuki Andou, the principal engineer in the project.

By sharing information, the group can travel safely, changing its shape as needed, Andou said.

Nissan will demonstrate the technology at the CEATEC electronics trade fair in Japan next week.

11

Movement Two types

Reactive movement Planned movement

12

Planned Movement Define a search space

representation Apply a search algorithm to find a

path Optional: Post-process path Agent follows path

13

Search Space Representations Represent terrain with a data

structure What kind?

Search data structure to find a path from point A to point B

Let's brainstorm some types of graph data structures...

14

Search Space Representations:Important Questions to Ask How does search space scale?

Larger search space = slower search

How does search space get made? Level Designer or Algorithm?

Does search space represent safe paths or safe walkable areas or both?

15

Search Space Representations Regular grids Waypoint graphs Corner graphs Circle-based waypoint graphs Navigation meshes

16

Search Space Representations:Regular Grid

17

Search Space Representations:Regular Grid

Rectangular Grid vs Hex Grid Hex grids

How do you index them? Advantages? Disadvantages?

18

Search Space Representations: Waypoint Graphs Must be hand-placed Common in FPS games

19

Search Space Representations:Corner Graphs (Points of Visibility)

20

Search Space Representations: Circle-based Waypoint Graphs Waypoints that only connect to overlapping

circles Characters can move freely within a circle Good for open terrain Bad for angular environments

21

Search Space Representations: Navigation Meshes Types

Triangle mesh N-sided polygon mesh

Ideal for 3D games Can be extracted from level geometry

22

Which Search Space Representation? Consider

Amount of designer intervention Amount of technology that must be developed Scalability Terrain type Local pathfinding

Grid representation Essentially 2D games Successful in RTS genre with 100’s to 1000’s of agents

Waypoint representation 3D FPS type environments with few agents Hand placement and local pathfinding limit viability with ever

increasing worlds Navigation Mesh

3D games with many complex terrain features (like pits) Can be automated

23

Local Obstacles Characters, crates, etc not

represented in search space What can be done? What about pits?

24

Ledges and Jumps How should this work? How should the path planning

algorithm deal with this?

25

Doors and Elevators Elevator requires:

Hit button Wait for door to open Pass through door

26

Intermission

Origin of the word “Robot”

1920 Czech play:“Rossum’s Universal Robots”

27

28

29

30

31

32

33

34

FDA-approved SpineAssist spine-surgery robot Propelled by micro legs 1mm x 14mm

35

36

37

38

39

Real Flying Robot Bugs Robotic insects make first controlled

flight https://www.youtube.com/watch?v=cyjKOJhIiuU

40

https://www.youtube.com/watch?v=cyjKOJhIiuU

41

Pathfinding

Planning your Pathwith Intelligent Search

42

Pathfinding Goal is to find an optimal path if one exists

Optimal? Is that the shortest path? Search algorithms explore the search

space to find a path from the start to the goal

Many different search algorithms Random Bounce/Trace Breadth-First Best-First Dijkstra A*

43

Criteria to Judge Pathfinding Algorithms Quality of path

Shortest, cheapest Resource requirements

CPU, memory, time Completeness

Will find a path if one exists

44

Thinking about Algorithms:Sorting What’s the stupidest/worst

algorithm you could come up with for sorting?

45

Thinking about Algorithms:Sorting Luckysort

Already sorted, O(0)

Bozosort Randomly swap two elements and test if sorted,

repeat

Bogosortfunction bogosort(array)

while !is_sorted(array)

array = random_permutation(array)

46

Pathfinding Algorithms What’s the stupidest/worst

algorithm you could come up with for pathfinding?

47

Random Bounce Search directly toward the goal If obstacle

Randomly move in a direction Repeat until goal reached

48

Random Bounce Not a complete search algorithm Path found is likely not optimal Consumes very little memory

49

Random Trace Search directly toward the goal If obstacle

Randomly trace clockwise or counter-clockwise around it

Repeat until goal reached

50

Random Trace How will Random trace do on the

following maps?

51

Random Trace Simple version not a complete

search algorithm With enough tweeking, maybe it can

be Path found is likely not optimal Consumes very little memory

52

Working Toward A*:Terminology Search Space – connected graph to be explored Node – the individual locations of the search space Start Node – the place where the search will begin Goal Node – the goal location of the search

Heuristic – a function, h(n), that returns an estimate of the cheapest cost from a Node to the Goal Node

Admissible – if h(n) never overestimates the cost of getting to the Goal Node

53

Working Toward A*:Open and Closed Lists Concept of Open and Closed Lists

Open List: Promising nodes not yet explored

Closed List: Nodes already explored

54

Working Toward A*:General Structure of Algorithms

1. Push Start Node onto the Open List2. While (Open List not empty)

a. Pop a node from the Open List (parent node)b. If node is Goal Node, then path foundc. Find neighboring child nodes and add them to the Open Listd. Place parent node on the Closed List

55

Working Toward A*:What Does a Node Look Like? Like this?

class PlannerNode

{

public:

PlannerNode *m_pParent;

int m_cellX, m_cellY;

...

};

56

Breadth-First Explores the search space ply-by-

ply

57

Breadth-First Characteristics It is a complete algorithm Exhaustive and systematic

but not very clever High Memory Consumption Finds the path with fewest nodes

Not the shortest or cheapest path!

58

Best-First Uses problem specific knowledge Heads straight for the goal Computes estimated distance of node to

goal Heuristic, h(x), to order Open List

59

Best-First:Problem Case

60

Best-First Characteristics It is a complete algorithm Heuristic search Uses fewer resources than

Breadth-First Finds good paths

Doesn’t guarantee optimal path

61

Dijkstra Uses accumulated distance to

order nodes on Open List Accumulated cost from Start Node

to current node is called given cost, g(x)

Note: not a heuristic search No estimation involved

62

Dijkstra It is a complete algorithm

It is an exhaustive search Always finds the most optimal path About as resource intensive as

Breadth-First

63

Intermission:Great Moments in Game Art History

64


65


66


67


68


69



70

71

A* Combines Best-First and Dijkstra

Given cost and Heuristic cost

Open List sorted by: Final cost = Given cost + (Heuristic cost *

weight) f(x) = g(x) + (h(x) * weight) Consider what different weights do

like 0, 1, and 2

72

A* Doesn’t fall into Best-First trap

73

A* Characteristics It is a complete algorithm Heuristic search On average uses fewer resources than

Breadth-First and Dijkstra If admissible heuristic used, guarantees

optimal path Admissible – if h(n) never overestimates the

cost of getting to the Goal Node How do you not overestimate the cost? What happens if you do overestimate it?

74

A* Algorithm:Walkthrough

Push Start Node onto the Open ListWhile (Open List is not empty) {

Pop cheapest node off Open List (parent node)If node is the Goal Node, then path found (RETURN “found”)For (all neighboring child nodes) {

Compute its cost, f(x) = g(x) + h(x)If child node isn’t on Open or Closed list, put it on Open List.If child node is on Open or Closed List, AND this new one is cheaper,

then take the old expensive one off both lists and put this new cheaper one on the Open List.

}Place parent node on the Closed List (we’re done with it)If taken too much time this frame (or in single step mode), abort

search for now and resume next frame (RETURN “working”)}Open List empty, thus no path possible (RETURN

“fail”)

75

A* Algorithm:Initial: Start/Goal Nodes, Lists empty







“fail”)

76

A* Algorithm:3 ways to exit







“fail”)

77

A* Algorithm:Prime the algorithm with the 1st node







“fail”)

78

A* Algorithm:While nodes still on Open List







“fail”)

79

A* Algorithm:No path found







“fail”)

80

A* Algorithm:Get next parent node to work with







“fail”)

81

A* Algorithm:Goal found?







“fail”)

82

A* Algorithm:Loop through child nodes







“fail”)

83

A* Algorithm:Compute child cost, f(x)







“fail”)

84

A* Algorithm:Put child node on Open List? (easy)







“fail”)

85

A* Algorithm:Put child node on Open List? (careful!)







“fail”)

86

A* Algorithm:Done with parent node







“fail”)

87

A* Algorithm:Aborting this frame (for single step)







“fail”)

88

A* Algorithm:3 ways to return







“fail”)

89

A* Algorithm:Walkthrough







“fail”)

90

A* Worksheet

91

A* DetailsNode data (for a given square)

parentRow; //Parent node (-1 is start node)parentCol; //Parent node (-1 is start node)

float cost; //Cost to get to this node, g(x)

float total; //Total cost, g(x) + h(x)

bool onOpen; //On Open Listbool onClosed; //On Closed List

92

Project 2: A* Pathfinding(due week 8) Absolute requirement:

Draw the open list of quads as one color, the closed list of quads as another color, draw the final path, and have Tiny follow the path

Grading (20%) Draw one step of A* each frame (use toggle) (15%) A path is always found if it exists (completeness) (15%) The path is optimal with a heuristic weight of 1.0 (15%) The path is optimal with a heuristic weight of 0.0, and

the search grows in a circular pattern (5%) The path uses diagonals and doesn't run into corners (5%) Calculate heuristic using Euclidean, Octile, Chebyshev,

and Manhattan methods (use toggle) (5%) Straightline optimization when possible (use toggle) (10%) Rubberband final path where possible (use toggle) (10%) Smooth using a Catmull-Rom spline (use toggle) (-10%) If it crashes at any time

93

Project 2:A* Pathfinding

Extra Credit (bells and whistles)

1 bell = 10% added to project grade

=

94

Project 2:A* Pathfinding Extra Credit

Implement Roy-Floyd-Warshall algorithm (in addition to A*). Must offer on-screen button to toggle on/off.

Implement Goal Bounding. Must offer an on-screen toggle to switch between A* and Goal Bounding. Hook it up to the timing.

95

Project 2:A* Pathfinding Extra Credit

Be in top 3 fastest class times on an A* search.

Beat 10 percent exe (Rabin)OR

Beat 15 percent exe (Fernando)OR

Beat 20 percent exe (Trent Reed)

96

Project 2:A* Pathfinding Watching the search

Escape after each time through search loop

Use quads to mark search Open list Closed list

Draw final path with line segments Waypoint to waypoint

97

Tiny Pathfinding Demo

98

Roy-Floyd-WarshallAll-Pairs Shortest Path Pre-compute ALL paths Just look up answer in a table!

1959 Bernard Roy 1962 Robert Floyd 1962 Stephen Warshall

99

Roy-Floyd-Warshall All-Pairs Shortest Path Table

A

4

A B C D E

A

B

C

D

E

B

CD

E

2

10

3

45

100

Roy-Floyd-Warshall All-Pairs Shortest Path O(n3)

int path[][]; //initialize to starting costs

void FloydWarshall() { for (k = 1 to n) { for each (i,j) in (1..n) { path[i][j] = min ( path[i][j], path[i][k] + path[k][j] ); } }}

101


A

4

A B C D E

A 0

B 0

C 0

D 0

E 0

B

CD

E

2

10

3

45

102


A

4

A B C D E

A 2 4

B 3

C 4 10

D 3 10 4

E 5

B

CD

E

2

10

3

45

103


A

4

A B C D E

A 0 2 4

B 0 3

C 4 0 10

D 3 10 0 4

E 5 0

B

CD

E

2

10

3

45

104


A

4

A B C D E

A 0 2 4 ∞ ∞

B ∞ 0 ∞ 3 ∞

C 4 ∞ 0 10 ∞

D ∞ 3 10 0 4

E ∞ ∞ 5 ∞ 0

B

CD

E

2

10

3

45

105


A

4

A B C D E

A 0 2 4 ∞ ∞

B ∞ 0 ∞ 3 ∞

B

CD

E

2

10

3

45

for (k = 1 to n) { for each (i,j) in (1..n) { path[i][j] = min (path[i][j], path[i][k] + path[k][j]); }}

106


A

4

A B C D E

A 0 2 4 ∞ ∞

B ∞ 0 ∞ 3 ∞

B

CD

E

2

10

3

45

for (k = 1 to n) { for each (i,j) in (1..n) { //example i=A, j=D, k=B path[i][j] = min (path[i][j], path[i][k] + path[k][j]); }}

107


A

4

A B C D E

A 0 2 4 5 ∞

B ∞ 0 ∞ 3 ∞

B

CD

E

2

10

3

45

for (k = 1 to n) { for each (i,j) in (1..n) { //example i=A, j=D, k=B path[i][j] = min (path[i][j], path[i][k] + path[k][j]); }}

108


A

4

A B C D E

A 0 2 4 5 9

B 16 0 12 3 7

C 4 6 0 9 13

D 13 3 9 0 4

E 9 11 5 14 0

B

CD

E

2

10

3

45

109

Roy-Floyd-Warshall (Represents ideal heuristic)

A

4

A B C D E

A 0 2 4 5 9

B 16 0 12 3 7

C 4 6 0 9 13

D 13 3 9 0 4

E 9 11 5 14 0

B

CD

E

2

10

3

45

110

Roy-Floyd-Warshall Inspired Next Node Look-up Table

A

4

A B C D E

A A B C B B

B D B D D D

C A A C A A

D E B E D E

E C C C C E

B

CD

E

2

10

3

45

111

Roy-Floyd-Warshall Inspired Next Node Look-up Table Speed of search? Cost to compute? What's the downside during

runtime? Which search space

representations does it work on?

Date post:	13-Jan-2016
Category:	Documents
Upload:	todd-collins
View:	215 times
Download:	0 times

1 Artificial Intelligence in Games Week 5 Steve Rabin [email protected] TA: Chi-Hao Kuo...

Documents