5 Designs to Replace Finite State Machine

Overview

The video argues that “vanilla” finite state machines (FSMs) break down as game mechanics become more complex—primarily due to state explosion (a combinatorial growth in required states and transitions). It then presents five alternative approaches/upgrade patterns to replace or improve FSMs, along with notes that future tutorials will include implementation guidance (potentially via live coding).

Why FSMs Fail (Core Analysis)

• State explosion problem: As mechanics like dash, stun, and “transitions that should work from multiple prior states” are added, the number of necessary states/transitions grows rapidly.
• FSMs become difficult to manage when behavior depends not just on going from A to B, but on combinations of conditions, such as:
  • Can dash while jumping?
  • Can run while stunned in mid-air?

Alternative / Upgrade Solutions (“The 5”)

1. Hierarchical State Machines (HSM)

   • Reduce diagram complexity by grouping related states under a parent state.
   • Example:
     • Instead of transitioning directly to run, use idle -> move, then handle move substates like run, walk, dash, slide, etc.
   • Intended benefit: organization + manageable state diagrams.

2. Pushdown Automata / Stack-based FSM (“history” states)

   • Vanilla FSMs usually don’t remember previous context needed to return after an action.
   • Stack approach:
     • Push the current state onto a stack during transitions.
     • For temporary/interruption states (jump, stun), pop the stack to return to what was underneath.
   • Useful for cases like:
     • Sitting → jump → return to sitting
     • Shooting while crouched/standing → return to prior stance afterward
     • Stun occurring “from any state” → return to the prior non-stunned state

3. Behavior Trees

   • Replace state-transition chains with a tree of behaviors (nodes).
   • Leaves are actions (e.g., run, shoot, unlock).
   • Two key control nodes:
     • Selector (fallback): try behaviors in order; if one fails, move to the next. Succeeds when one works.
     • Sequence: execute behaviors in order and stop/fail if one fails (not a fallback; it keeps progressing through the plan).
   • Example AI decision flow:
     • Recon: if chasing fails (no target/vision), fall back to searching; once found, chase.

4. Utility AI (priority/scoring-based decision making)

   • Instead of fixed priority/branching or “one transition wins,” actions compute priority values based on world/agent state.
   • Example issue with FSMs/decision trees:
     • Health low vs. ammo low can cause oscillation/twitching between reload and taking cover.
   • Utility approach:
     • Priorities change continuously—for instance, as health drops, take cover priority rises until it beats reload.
   • Implementation concept:
     • Gather candidate actions with computed priorities, then select via something like a priority queue.
   • Also briefly mentioned: can adapt to dialogue selection using conditional logic plus weighted randomness (conceptually similar).

5. GOAP (Goal-Oriented Action Planning)

   • Shifts from “what state should I switch to?” toward “what goal should I achieve?”
   • Example:
     • Low health → goal is to raise HP, leading to actions like find a medkit → use medkit.
   • Planning method:
     • Actions have preconditions (when the action is allowed) and postconditions (effects on the world/agent state).
     • Uses search (described as BFS or similar) over the action graph until a goal-satisfying state is found.
   • Potential extensions:
     • Narrative-like goals such as “take revenge” (target must be located, then eliminated), described as promising for procedural narratives.

Guidance / Tutorial Focus Mentioned

• The creator indicates they’ll release an additional video that implements the solutions, likely including live coding in a specific engine/tool.
• The next series will include manual implementation demonstrations with “minimal editing,” encouraging viewers to subscribe/follow.

Main Speakers or Sources

• Main speaker/source: The video’s creator/host (a game development YouTuber; no specific name provided in the subtitles).
• Referenced concepts/literature (no specific author named in subtitles):
  • Hierarchical FSM
  • Pushdown automata (stack history)
  • Behavior trees
  • Utility AI
  • GOAP