StateMachines

Description

The StateMachines module implements a universal state management mechanism used across different parts of the project.

This module:

• defines base interfaces and abstractions for states

• manages transitions between states

• provides a unified state lifecycle (Enter / Exit / Update)

StateMachines serve as a foundation for game-level, system-level, and entity-level states, ensuring a consistent and extensible approach to logic control.

Implementation path: KrolStudio/SwipeGunner/Scripts/Runtime/Infrastructure/StateMachines/Common

⚠️ Recommendation: It is not recommended to modify the source files located in the Common folder. This code represents core infrastructure and is intended to be reused without direct modification. Functional extensions should be implemented through inheritance or by creating new implementations.

---

Built-in StateMachine Implementations

Implementation path: KrolStudio/SwipeGunner/Scripts/Runtime/Infrastructure/StateMachines/...

Each state machine is responsible for a specific level of logic and has a clearly defined scope.

The template includes the following state machine implementations:

1. GameStateMachine

GameStateMachine manages the global states of the application.

It is responsible for:

• handling the application entry point

• initializing and loading application data

• transitioning between the main application modes

void BindGameStateMachine()
{
    Container.Bind<GameStateMachine>().AsSingle();
    
    Container.Bind<BootstrapState>().AsSingle();
    Container.Bind<LoadProgressState>().AsSingle();
}

2. GameplayStateMachine

GameplayStateMachine manages states related to the core gameplay flow.

It is used to organize the gameplay lifecycle and control transitions between gameplay phases.

private void BindGameplayStateMachine()
{
    Container.Bind<GameplayStateMachine>().AsSingle();

    Container.Bind<GameplayBootstrapState>().AsSingle();
    Container.Bind<InitGameplayState>().AsSingle();
    Container.Bind<LaunchState>().AsSingle();
    Container.Bind<TutorialState>().AsSingle();
    Container.Bind<GameLoopState>().AsSingle();
    Container.Bind<WinGameState>().AsSingle();
    Container.Bind<LoseGameState>().AsSingle();
}

3. PlayerStateMachine

PlayerStateMachine is responsible for managing player states based on the current gameplay context.

private void BindPlayerStateMachine()
{
    Container.Bind<PlayerStateMachine>().AsSingle();

    Container.Bind<PlayerIdleState>().AsSingle();
    Container.Bind<PlayerRunState>().AsSingle();
    Container.Bind<PlayerFinishState>().AsSingle();
    Container.Bind<PlayerDeadState>().AsSingle();
}

4. TentacleStateMachine

TentacleStateMachine manages the states of the Tentacle entity.

Each Tentacle entity uses its own instance of a state machine.

void BindTentacleStateMachine()
{
    Container.Bind<TentacleStateMachine>().AsSingle();

    Container.Bind<TentacleIdleState>().AsSingle();
    Container.Bind<TentacleAttackState>().AsSingle();
    Container.Bind<TentacleDeadState>().AsSingle();
}

5. EnemyStateMachine

EnemyStateMachine manages the states of the Enemy entity.

Each Enemy entity uses its own instance of a state machine.

void BindEnemyStateMachine()
{
    Container.Bind<EnemyStateMachine>().AsSingle();

    Container.Bind<EnemyIdleState>().AsSingle();
    Container.Bind<EnemyInactiveState>().AsSingle();
    Container.Bind<EnemyHitState>().AsSingle();
    Container.Bind<EnemyChaseState>().AsSingle();
    Container.Bind<EnemyAttackState>().AsSingle();
    Container.Bind<EnemyWanderState>().AsSingle();
    Container.Bind<EnemyDeadState>().AsSingle();
}

How to Add a New StateMachine

To create a new state machine:

1. Define a new class

2. Inherit it from the base StateMachine class

namespace KrolStudio
{ 
    public class YourStateMachine : StateMachine
    {
    }  
}

In most cases, this class does not require additional implementation. Overriding base methods or extending functionality is only necessary when custom behavior is required.

1. Register your state machine in the Zenject container using an appropriate installer. For details on how to create an installer and register a state machine, see: [link]

2. Create and register the required states for the state machine. For details on how to create a state and register it within a state machine, see: [link]

3. In the required class, request a reference to your state machine and define a method that performs a transition to the specified state.

public class SomeStateA : IState, IUpdatableState
{
    readonly YourStateMachine stateMachine;
  
    [Inject]
    public SomeStateA (YourStateMachine stateMachine)
    {
        this.stateMachine = stateMachine;  
    }

    public UniTask Enter()
    {
        return default;
    }

    public UniTask Exit()
    {
        return default;
    }

    public void Update()
    {      
        if (SomeTrigger())
        {
            stateMachine.Enter<SomeStateB>().Forget();
        }
    }