Máquina de estado/State Machine no Unity

Código:

using System;
using System.Collections.Generic;
using System.Linq;

/// Author: TGM, 2020
public class StateMachine
{
    public string currentState { get; private set; }
    public string previousState { get; private set; }
    private Dictionary<string, StateActions> states;
    private List<StateChanges> changesAnyState;
    public const string PreviousState = "_previous";

    public StateMachine(string state) {
        currentState = state;
        states = new Dictionary<string, StateActions>();
        changesAnyState = new List<StateChanges>();
    }
    
    public bool IsCurrent(string[] states) => states != null && (states).Contains(currentState);

    public void AddState(string name, Action create = null, Action update = null, Action end = null)
    {
        StateActions state = new StateActions(create, update, end);
        states.Add(name, state);
    }

    public void AddChange(string from, string to, Func<bool> when, string[] exceptFrom = null)
    {
        StateActions stateFrom = states[from];
        
        if (stateFrom == null) throw new Exception($"Invalid state(s): from: {from}, to: {to}");

        stateFrom.changes.Add(new StateChanges(to, when, exceptFrom));
    }

    public void AddChangeAnyState(string to, Func<bool> when, string[] exceptFrom = null)
    {
        StateActions stateTo = states[to];
        if (stateTo == null) throw new Exception($"Invalid to state: {to}");

        changesAnyState.Add(new StateChanges(to, when, exceptFrom));
    }

    public void Update()
    {
        StateActions state = states[currentState];

        state.update?.Invoke();
        foreach (StateChanges change in state.changes)
        {
            bool changed = Change(change);
            if (changed) break;
        };

        foreach (StateChanges anyChange in changesAnyState)
        {
            Change(anyChange);
        }
    }

    private bool Change(StateChanges change)
    {
        if (change.when() && !(IsCurrent(change.exceptFrom)))
        {
            if (change.to != PreviousState)
            {
                previousState = currentState;
                currentState = change.to;
            } else
            {
                string oldState = currentState;
                currentState = previousState;
                previousState = oldState;
            }
            states[previousState].end?.Invoke();
            states[currentState].create?.Invoke();
            return true;
        };
        return false;
    }
}


internal class StateActions
{    
    public Action create;
    public Action update;
    public Action end;
    public List<StateChanges> changes;

    public StateActions(Action create, Action update, Action end)
    {
        this.create = create;
        this.update = update;
        this.end = end;
        changes = new List<StateChanges>();
    }
}

internal class StateChanges
{
    internal string to;
    internal Func<bool> when;
    internal string[] exceptFrom;

    public StateChanges(string to, Func<bool> when, string[] exceptFrom)
    {
        this.to = to;
        this.when = when;
        this.exceptFrom = exceptFrom;
    }
}

A questão é que nós (pessoas) ativamos os inputs através de coisas que vemos visualmente, mas uma IA não vai agir pelo visual (poderia até fazer assim, mas não sei se acabaria o jogo até 2022 hue), então ela tem que ter uma forma melhor de 'enxergar' aonde estão as coisas, e qual o estado dela. 

Código:


state = 1; // estado inicial da maquina


Código:

estado = "parado"

Código:

switch estado {
case "movimento": hspeed=dirHorizontal; vspeed=dirVertical; break;
case "ataque": atacar(); break;
}

Código:

switch estado {
case "movimento": if (atk) estado = "ataque";break;
case "ataque": if (!atk) estado = "movimento"; break;
}