enum States { Normal, Blocking }
enum Events { Attacked }

int lives = 3;

[SerializeField]
float blockTime = 2;

StateMachine<States, Events> stateMachine;

private void Awake()
{
    stateMachine = new StateMachine<States, Events>
    {
        AnyState =
        {
            OnEnter = fsm => Debug.Log($"Entering state {fsm.CurrentState}"),
            
            OnExit = fsm => Debug.Log($"Exiting state {fsm.CurrentState} to {fsm.NextState}")
        },

        [States.Normal] =
        {
            OnUpdate = fsm => Debug.Log($"Time idling: {fsm.TimeInState}"),

            [Events.Attacked] = _ => lives--,

            Transitions = {
                // in this state, check in update for space press. enter blocking state if true
                {_ => Input.GetKeyDown(KeyCode.Space), States.Blocking}
            }
        },

        [States.Blocking] =
        {
            [Events.Attacked] = _ => Debug.Log("Attack blocked"),

            Transitions = {
                {fsm => fsm.TimeInState >= blockTime, States.Normal}
            }
        }
    };

    /// Initialize can be called at any time when you're ready -- not just in Awake().
    /// By supplying this gameObject into the second parameter,
    /// the state machine will autmatically Close() when the gameObject is destroyed.
    /// Otherwise, you may want to call Close() in OnDestroy(), OnDisable() etc.
    /// Note: Initialization calls Enter() and Closing calls Exit().
    stateMachine.Initialize(States.Normal, this.gameObject);
}

void OnCollisionEnter(Collision collision)
{
    stateMachine.TriggerEvent(Events.Attacked);
}

using KDMagical.SUSMachine;

var fsm = new StateMachine<States>
{
    AnyState =
    {
        //...
    },

    [States.State1] =
    {
        // ...
    },

    [States.State2] =
    {
        // ...
    },

    [States.State3] =
    {
        // ...
    },
}

// without events
var fsm = new StateMachine<States> { };

// with events
var fsm = new StateMachine<States, Events>
{
    [States.State1] =
    {
        [Events.Event1] = _ => Debug.Log("Event1 Triggered!")
    }
};

var fsm =
{
    [States.State1] = new Stateful<States, (string name, int count)>
    {
        // names are optional here -- ("Hello", 0) does the same thing.
        InitialData = (name: "Hello", count: 0),

        OnEnter = (_, data, modify) =>
        {
            // deconstruct syntax
            var (name, count) = data;

            Debug.Log($"Name: {name}, Count: {count}");

            data.count++;

            modify(data);
        }

        Transitions =
        {
            { // transitions to State2 on the first frame where count reaches 2
                (_, data) => data.count >= 2,
                States.State2
            }
        }
    }
};

var fsm = new Stateful<States, int>
{
    [States.State1] = new Stateful<States, Events, int>
    {
        // as data is a struct, omitting InitialData will mean it is set to its default value.
        OnEnter = (_, data, __) => Debug.Log("data = " + data) // data = 0
    }
};

var stateMachine = new StateMachine<States>
{
    [States.Idle] =
    {
        Transitions =
        {
            {
                // if this returns true, enter the state specified.
                _ => Input.GetKeyDown(KeyCode.Space),
                // the state to enter if the predicate returned true.
                States.Jumping,
                // the update loop to run on. Can be omitted as Update is the default.
                TransitionType.Update
            }
        }
    }
}

Transitions =
{
    {
        _ => {
            switch (someNum)
            {
                case 1:
                    return States.State1;
                case 2:
                    return States.State2;
                case 3:
                    return States.State3;
                default:
                    return null;
            }
        }
    },
    // this last parameter is not necessary as it will default to TransitionType.Update if omitted
    TransitionType.Update
}

[States.Idle] =
{
    Transitions =
    {
        {
            _ => someNum < 0
                ? States.State1
                : (States?)null
        }
    }
}

Transitions =
{
    { Events.Event1, States.State1 }
}

Transitions =
{
    // when the event is triggered, the condition is called. Enters State1 if the condition is true.
    { Events.Event1, _ => someNum > 0, States.State1 }
}

Transitions =
{
    Events.Event1,
    _ => someNum switch
    {
        1 => States.State1,
        2 => States.State2,
        var x when x >= 3 => States.State3,
        _ => null
    }
}

var stateMachine = new StateMachine<States>
{
    [States.Jumping] =
    {
        Transitions =
        {
            {
                _ => {
                    Debug.Log("first check");
                    return GetJumpHeight() > limit;
                },
                States.State1
            },
            {
                fsm => {
                    Debug.Log("second check");
                    return fsm.TimeInState > jumpTime;
                },
                States.State2
            }
        }
    }
}

void StateCheck()
{
    if (someCondition)
    {
        stateMachine.SetState(States.State1);
    }
}

var fsm = new StateMachine<States>
{
    AnyState =
    {
        OnEnter = fsm => fsm.SetState(States.State2)
    }
}

fsm.Initialize(States.State1); // stack overflow! AnyState.OnEnter called infinitely!

// in state machine init...
[States.SomeState] = {
    OnEnter = SomeFunc
}

void SomeFunc(IStateMachine<States> stateMachine) { }

// in state machine init...
[States.SomeState] = Stateful<States, MyStruct>
{
    OnEnter = SomeFunc
}

void SomeFunc(IStateMachine<States> stateMachine, MyStruct data) { }

Initialize(T initialState, GameObject closeOnDestroy)

fsm.Initialize(States.State1);

// elsewhere, e.g. in OnDestroy
fsm.Close();