This document discusses intelligent and autonomous agents for games. It covers steering behaviors like seek, arrive and obstacle avoidance that can be used to control game entities. It also discusses using pathfinding on a navigation graph built from the environment to find paths between points. Common search algorithms for pathfinding like Dijkstra's algorithm and A* are explained. The document suggests using steering behaviors to move entities along paths found through the graph to create autonomous behaviors.

1. INTRO TO INTELLIGENT AND
AUTONOMOUS AGENTS
Steering behaviors and pathfinding

2. Game AI
 What we’re covering today
 And what we’re not
 How AI can improve your games
 Autonomous agents

3. Steering Behaviors
 What they are
 When they’re used
 Quite often
 http://www.youtube.com/watch?v=e2YYtSJhmJg
 Movies
 Let’s try some out!

4. Seek
 Move entity from current position to target
position as quickly as possible

5. Our entity is the triangle. How do we get to the
target?

6. Desired velocity = target.position - myPosition

7. You can get a vector pointing from A to B by B - A

10. Don’t worry about
overshooting, it’ll be
corrected

11. Other steering behaviors
 Arrive
 Obstacle Avoidance
 Make sure we don’t have a force that’s too
big!

12. Using SBs in your Entities
 ChasePlayer State
 Obstacle avoidance, Pursue or Seek
 Idle State
 Wander, maybe flocking?
 Sheep
 Flocking, Wander, Obstacle Avoidance, Evade

13. Steering behaviors ftw :?

14. Wouldn’t this be lovely? Well then, let’s find a path

15. A graph of points! (navigation graph)

16. Building a Nav Graph
 Goal: A list of nodes and edges
 What is needed:
 Start point, cast distance, interval
 (optional)Max number of nodes

17. Data Structures
GraphNode GraphEdge
Vector3 position GraphNode fromNode
GraphEdge[4] edges GraphFrom toNode
(Float weight)

18. List<GraphNodes> Nodes
For ( i = 1; i <= xCastDistance; ++i)
For (j = 1; j <= zCastDistance; ++j)
{
cast a ray downward from above for each potential neighbor node
(i.e. (curX + invertal, curZ), (curX, curZ + interval), etc.)
if raycast hit the ground
{
new GraphNode(GraphNode(Raycast hit point))
if we haven’t already found this node
{
Add new graph node to Nodes
}
(calculate edge cost)
new GraphEdge(current node, new graph node, cost))
Add new graph edge to the current node’s Edge list
}

19. Start from initial position, start casting out!

21. What happens when node cast hits out of bounds?

23. New position

24. Nothing new, just adding another node/edge

25. :o A box!
Hit an object not tagged ground, skip it, keep moving

26. :OOOOO But we already processed that node!
Result depends on algorithm implementation. Easy route (the way the pseudo code was
setup) is to have each node responsible for itself. So in our case add the edge and ignore
the node.

27. Improvements Worth Mentioning
 Reducing node density
 Indexing GraphNodes and GraphEdges

28. Data Structures for Indexing
GraphNode GraphEdge
int index int fromNodeIndex
Vector3 position int toNodeIndex
GraphEdge[4] mEdges float weight
Instead of storing the GraphNodes that a GraphEdge is connected to, we
store the index of each GraphNode, so we’re not storing a GraphNode twice

29. Take a look at that graph

30. Search Algorithms
 Depth-first search
 Breadth-first search
 Dijkstra’s algorithm
 A* (aka Dijkstra++)
 ^ yahtzee

31. Dijkstra’s Algorithm
 Usable with weighted graphs. Graphs without
weight can be processed by assuming edges
of equal weight
 Guaranteed to find shortest path, if it exists.
 Implementation
 Examine nodes on our search frontier, find the
one with the smallest total weight, and add it to
our path and keep going

39. Picture from “Programming Game AI by Example” by Mat Buckland

40. Picture from “Programming Game AI by Example” by Mat Buckland

41. A*
 Dijkstra with an additional weight factor
(heuristic)
 Heuristic: Making a decision based on some knowledge
 There’s something troublesome in the Dijsktra
implementation that seems like it would be an
easy fix

42. We know where our target is, so let’s
approximate the cost from the nodes we are
looking at to the target and factor that
into what we choose
In this case, Euclidean distance

43. Manhattan Distance

44. Results
Picture from “Programming Game AI by Example” by Mat Buckland

45. Picture from “Programming Game AI by Example” by Mat Buckland

46. Review
 Steering behaviors
 Navigation graphs
 Search algorithms
 So how do they work together?
 You have a point on the graph you want to reach.
 You find a sequence of nodes to follow.
 Use steering behaviors to get from point to
point, and create interesting behavior on the way

47. Next time…
 Organizing these lower level decisions into
functional, autonomous agents (in a
smart, extendable, debug-friendly way )
 Questions?
(can someone let Jordan know he can wake up now? kthx)