Source Metadata
- Type: Anthology of practitioner articles (27 chapters)
- Editor: Steve Rabin
- Publisher: CRC Press / Taylor & Francis, 2020
- ISBN: 978-0-367-15104-1 (paperback)
- Series: Compiled from Game AI Pro volumes 1–3; architecture-focused curated selection
Key Takeaways
- Decision-making is a toolbox problem. FSMs, HFSMs, behaviour trees, utility systems, GOAP, and HTN each occupy a different spot on the authored-control ↔ emergent-planning spectrum; no single architecture is universally best (Dawe et al., Ch. 1).
- Structural architecture patterns cut across all algorithms. Hierarchy, option stacks, blackboards, intelligent-objects/terrain, and modularity apply regardless of whether you use a BT or a planner (Dill, Ch. 2).
- Blackboards in games = shared memory, not the academic pattern. The game industry uses the term to mean a shared key-value store for caching expensive queries (line-of-sight, paths) and coordinating multiple characters or reasoners — a simpler but highly practical definition (Dill, Ch. 2; Isla, referenced in Ch. 2).
- Option stacks solve the suspend-and-resume problem. Pushing a high-priority option onto a stack lets the AI temporarily react (e.g., hit reaction, grenade dodge) then resume previous behaviour without losing state — architecture-agnostic and straightforward to implement (Dill, Ch. 2).
- Intelligent objects and intelligent terrain move knowledge out of the NPC. The Sims’ advertisement system and Red Dead Redemption’s hotspot system push AI logic into world objects, dramatically reducing per-NPC complexity and enabling content-only expansion packs (Dill, Ch. 2).
- Modularity via considerations allows reuse across projects and architectures. Factoring AI decisions into small reusable modules — considerations, weight functions, target selectors — both eliminates duplicate code and raises the level of abstraction during configuration (Dill, Ch. 2; Dill and Dragert, Ch. 21).
- Second-generation behaviour trees separate node structure from per-instance state. Splitting Node (static shared data) from Task (transient runtime data) reduces memory footprint in scenes with many NPCs and enables pool-based allocation for cache-friendly traversal (Champandard and Dunstan, Ch. 3).
- Event-driven BTs avoid re-traversal from root every frame. A scheduler maintains a list of active behaviours and processes them via callbacks; composites schedule their next child rather than executing it synchronously — a significant performance gain on large trees (Champandard and Dunstan, Ch. 3).
- Scripted BT behaviours (e.g. Lua) accelerate iteration. Kingdoms of Amalur: Reckoning showed that separating BT algorithm (C++) from behaviour definitions (Lua script) lets designers write behaviours without recompiling, at the cost of careful performance management (Dawe, Ch. 4).
- BT/planner hybrids take the best of both. The behaviour tree constrains what the AI can do (designer-authored structure); a forward-simulation heuristic decides which branch to pick (Hilburn, Ch. 5). The Kinect Star Wars Jedi AI used this to handle emergent skill-level and mistake injection without tree changes.
- Utility theory is not the same as utility systems. Utility (continuous preferability score) can be used as a supplement within a BT (utility selector node) or as the entire decision engine (Sims-style full utility AI). Normalised scores, response curves, and bucketing solve the selection problem in both modes (Graham, Ch. 6; Merrill, Ch. 7).
- Reactivity and deliberation are architecturally distinct and should be separated. Reactivity = interruptions; deliberation = sustained goal-driven planning. Mixing them in one model creates transition overload and undesirable oscillation. An Action Selector module sequences them cleanly (Côté, Ch. 8).
- HTN planners express behaviour hierarchically and plan forward. A domain is a tree of compound tasks and primitive tasks; the planner decomposes from a root task using the current world state. HTN supports recursion, expected effects, method traversal records for priority, simultaneous behaviours via dual domains or background operators, and partial planning for performance (Humphreys, Ch. 9).
- LOD for AI (AI Level-of-Detail) trades fidelity for performance: distant NPCs run cheaper decision loops, and a LOD Trader system dynamically assigns computational budget based on player proximity and visibility (Sunshine-Hill, Ch. 11).
- Runtime compiled C++ (RTCC) enables hot-reload of AI code without engine restarts, matching scripting-language iteration speeds while keeping full C++ performance (Binks, Jack and Wilson, Ch. 12).
- Production systems (if-then rule sets) can complement BTs for data-driven emergent behaviours in specific domains (Zubek, Ch. 15; Schiel, Ch. 16).
- FINAL FANTASY XV combined BTs and state machines in a hybrid architecture with the “Meta-AI” layer coordinating companion behaviours; the combination handled the demands of a large open-world JRPG with multiple controllable party members (Miyake et al., Ch. 24).
Notable Claims
“We can use a blackboard to share information and ideas between AI components or between characters. We can move the intelligence into the objects, the terrain, the abilities, or the events in order to more logically divide the code and data.” — Dill, Ch. 2
“Option stacks allow us to push a new, high priority option on top of the stack, suspending the currently executing option but retaining its internal state. When the high priority option completes execution, it will pop itself back off of the stack, and the previously executing option will resume as if nothing had ever happened.” — Dill, Ch. 2
“Reactivity and deliberation can be merged together as long as the deliberation implementation allows for taking decisions and engaging actions in a very short time. However, this conclusion only considers the responsiveness aspect of the decision model itself; it doesn’t consider what triggered the need for a decision and the dynamics of the engaged actions itself.” — Côté, Ch. 8
“The behavior tree structure lends itself well to extensibility. After all, it’s nothing more than a tree traversal where the nodes themselves are responsible for and are able to customize the expansion of the tree.” — Merrill, Ch. 7
Relevance
| Chapter | Authors | Topic | Wiki pages informed |
|---|---|---|---|
| 1 | Dawe et al. | FSM, HFSM, BT, Utility, GOAP, HTN overview | game-ai-agent-design, ai-state-machine-pattern, behaviour-trees, goal-oriented-action-planning |
| 2 | Dill | Structural architecture: hierarchy, option stacks, blackboards, intelligent objects, modularity | blackboard-architecture (new), ai-architecture-patterns (new), game-ai-agent-design |
| 3 | Champandard, Dunstan | BT Starter Kit: composites, memory, event-driven scheduling | behaviour-trees |
| 4 | Dawe | Scripted BTs in Lua: iteration workflow, Kingdoms of Amalur | behaviour-trees |
| 5 | Hilburn | BT/Planner hybrid: Kinect Star Wars Jedi AI | behaviour-trees, goal-oriented-action-planning |
| 6 | Graham | Utility theory: expected utility, response curves, bucketing, inertia | utility-ai |
| 7 | Merrill | Utility selector node in existing BTs; utility propagation | utility-ai, behaviour-trees |
| 8 | Côté | Reactivity vs deliberation architecture | ai-architecture-patterns (new), game-ai-agent-design |
| 9 | Humphreys | HTN deep-dive: Trunk Thumper worked example | squad-ai-patterns, goal-oriented-action-planning |
| 11 | Sunshine-Hill | AI LOD Trader | npc-performance-at-scale |
| 12 | Binks et al. | Runtime compiled C++ for AI | ai-architecture-patterns (new) |
| 15–16 | Zubek, Schiel | Production rules in games | ai-architecture-patterns (new) |
| 21 | Dill, Dragert | Modular AI | ai-architecture-patterns (new) |
| 24 | Miyake et al. | FFXV BT + FSM hybrid, Meta-AI | behaviour-trees, buddy-ai |
| 25 | Graham | Lightweight reusable FSM | ai-state-machine-pattern |
Open Questions Raised
- When exactly should a team switch from a flat BT to a utility selector hybrid rather than migrating to a full utility-based engine?
- How does the option-stack pattern interact with animation-system interruption constraints in modern games where animation drives locomotion?
- The LOD Trader chapter implies a budget-assignment system — what does that look like in Unity’s job-system context?
- FFXV combined BTs, FSMs, and a Meta-AI — is this documented anywhere accessible, or only in this anthology?
Links
Pages directly informed by this source:
- blackboard-architecture — full concept page (new, from Ch. 2)
- ai-architecture-patterns — structural patterns overview (new, from Chs. 2, 8, 12, 15–16, 21)
- game-ai-agent-design — FSM/HFSM overview from Ch. 1; hierarchy/option-stack pointer
- behaviour-trees — BT Starter Kit (Ch. 3), scripted BTs (Ch. 4), BT/Planner hybrid (Ch. 5), utility selector (Ch. 7), FFXV (Ch. 24)
- utility-ai — utility theory (Ch. 6), utility selector node (Ch. 7)
- goal-oriented-action-planning — GOAP overview (Ch. 1), BT/planner hybrid (Ch. 5)
- squad-ai-patterns — HTN deep-dive (Ch. 9)
- npc-performance-at-scale — AI LOD Trader (Ch. 11)
- ai-state-machine-pattern — reusable FSM (Ch. 25)
- buddy-ai — FFXV party AI / Meta-AI (Ch. 24)