Skip to content

State Machine

Jump to bottom
Wagner GFX edited this page Dec 7, 2024 · 1 revision

This is a simplified explanation of the State Machine, focused on the class structure and its usage.

More in-depth information can be read in the original State Machine Wiki for the Unity Open Project #1: Chop Chop project.

The changes in this project were done to keep it updated to the latest Unity versions and to decoupled it from the rest of the original project code and folder architecture.

Overview

The state machine is designed through Scriptable Objects. During the runtime, that definition is used as a blueprint to instantiate the state machine inner components.

When creating your agent, the recommended workflow is to use:

  • Passive Monobehaviour Components with public properties, functions and events to gather information or run specific behaviors.
  • StateActionSO assets to set the Inspector properties that will be used by StateAction.
  • StateAction inherited classes to run the behaviors from those Components and Assets.
  • StateConditionSO assets to set the Inspector properties that will be used by StateCondition.
  • StateCondition inherited classes to make decisions on state changes based on information from those Components and Assets.
  • StateSO assets to define a state and it's actions.
  • A TransitionTableSO asset to glue all states with transitions and conditions.
  • A StateMachine Component to instantiate and control the states during runtime.

Plugin Core Classes

State

  • It holds a collection of Actions and Transitions that are automatically filled during runtime.
  • It doesn't need to be implemented, as there is no customization needed.

StateAction

  • Classes inherited from it will continuously execute the actual runtime code for your agent while the State is active.
  • Actions are called during the state machine Awake, Update, OnStateEnter and OnStateExit.
  • This is where you can move the character, update the animation, etc.

Condition / StateCondition

  • Classes inherited from it must override the Condition.Statement() function.
  • This is where you can evaluate the current situation of the agent on thing like ground checks, movement direction, colliding with things, etc.
  • Statement results are cached during a single frame, allowing the transition logic to check them multiple times without impacting performance.
  • StateCondition is a wrapper that will convert the statement output to the result expected by the transitions.

StateTransition

  • It's responsible for analyzing when a state should transition to another. It holds a target State and groups of Conditions.
  • Conditions are grouped based on their boolean relationship using AND (grouped) and OR (ungrouped).
  • It doesn't need to be implemented, as there is no customization needed.

StateMachine

  • This is the Component to be placed in a GameObject agent.
  • It only requires a TransitionTableSO asset to define how the state machine will be set up during runtime.
  • In Editor Mode, it also accepts a reference to the StateMachineDebugger to help diagnose faulty state transitions.
  • Actions and Conditions should access the GameObject Components through the state machine functions as they are cached, for improved performance.

Plugin Scriptable Object Classes

StateSO

  • It represents a State and contains a collection of StateActionSO that must be supplied by the user.
  • It doesn't need to be implemented, as there is no customization needed.

StateActionSO

  • It represents StateActions and must be implemented for every type of action.
  • This is also where the action parameters are set. Use the asset to expose properties to the Inspector.
  • There is a non-generic version, but the generic class is preferred.

StateConditionSO

  • It represents StateConditions and must be implemented for every type of condition.
  • This is also where the condition parameters are set. Use the asset to expose properties to the Inspector.
  • There is a non-generic version, but the generic class is preferred.

TransitionTableSO

  • This is the heart of the State Machine, it defines all transitions for a State Machine.
  • Although it is possible to edit the asset directly, the State Machine Editor Window offers a much easier experience.

State Machine Editor Window

This window, accessible through the menu Tools > State Machine Editor, is the main tool to compose a state machine.

With it, you can change the state machine logical design:

  • Adding actions to a state.
  • Adding state transitions.
  • Adding a target state and conditions to a transition.
  • Setting the condition order, logic operation and boolean transformation.
  • It is not possible to group conditions manually (like using parentheses), but conditions can be repeated to create a similar logic.
  • Boolean transformation can convert a false output to true. This separates the condition result to the transition expected value.

State Machine Debugger

This class can debug the state transitions. It's extremely useful when the state machine goes haywire and start to transition in unexpected situations.

The debugger can be enabled and disabled during play mode.

The debugging details contain the agent, the current state, the target state and the condition results.

Clone this wiki locally