如何使用泛型使这个 FSM 更加灵活？

Question

我试图通过拥有一个其他控制器（PlayerController、AiController 等）可以从中派生的 StateController 基类来制作一个更灵活的 FSM。 到目前为止，传递的参数具有严重的依赖性，不允许这种灵活性，因此，泛型。 唯一的问题是我无法理解这种方法。

这是 FSM 的代码，没有我希望实现的灵活性。

状态控制器.cs

using UnityEngine;

public class StateController : MonoBehaviour
{
    public State currentState;
    public State previousState;
    public State remainInState;

    private void Start()
    {
        if (!currentState)
            return;

        currentState.OnEnter(this);
    }

    private void FixedUpdate()
    {
        if (!currentState)
            return;

        currentState.OnFixedUpdate(this);
    }

    private void Update()
    {
        if (!currentState)
            return;

        currentState.OnUpdate(this);
    }

    private void LateUpdate()
    {
        if (!currentState)
            return;

        currentState.OnLateUpdate(this);
    }

    public void ChangeState(State nextState)
    {
        if (nextState != remainInState)
        {
            currentState.OnExit(this);
            previousState = currentState;
            currentState = nextState;
            currentState.OnEnter(this);
        }
    }
}

状态文件

using UnityEngine;

[CreateAssetMenu(menuName = ("State Controller/State"))]
public class State : ScriptableObject
{
    public StateAction[] onEnter;
    public StateAction[] onFixed;
    public StateAction[] onUpdate;
    public StateAction[] onLate;
    public StateAction[] onExit;

    public StateTransition[] transitions;

    public void OnEnter(StateController controller)
    {
        ExecuteActions(controller, onEnter);
    }

    public void OnFixedUpdate(StateController controller)
    {
        ExecuteActions(controller, onFixed);
    }

    public void OnUpdate(StateController controller)
    {
        ExecuteActions(controller, onUpdate);
        CheckTransitions(controller);
    }

    public void OnLateUpdate(StateController controller)
    {
        ExecuteActions(controller, onLate);
    }

    public void OnExit(StateController controller)
    {
        ExecuteActions(controller, onExit);
    }

    private void ExecuteActions(StateController controller, StateAction[] actions)
    {
        for (int i = 0; i < actions.Length; i++)
        {
            actions[i].Execute(controller);
        }
    }

    private void CheckTransitions(StateController controller)
    {
        for (int i = 0; i < transitions.Length; i++)
        {
            bool result = transitions[i].condition.CheckCondition(controller);

            if (result == true)
            {
                controller.ChangeState(transitions[i].trueState);
            }
            else
                controller.ChangeState(transitions[i].falseState);
        }
    }
}

状态动作.cs

using UnityEngine;

public abstract class StateAction : ScriptableObject
{
    public abstract void Execute(StateController controller);
}

状态条件.cs

using UnityEngine;

public abstract class StateCondition : ScriptableObject
{
   public abstract bool CheckCondition(StateController controller);
}

状态转换文件

[System.Serializable]
public class StateTransition
{
    public StateCondition condition;
    public State trueState;
    public State falseState;
}

但我希望灵活地使用 StateController.cs 作为基类，并能够从中派生另一个类（显然使其抽象并使用受保护的虚拟无效作为函数），例如 PlayerController 脚本......

using UnityEngine;

public class PlayerController : StateController
{
    //Other Variables Specific to this class

    protected override void Start()
    {
        base.Start();
    }

    //Other Functions Specific to this class
}

我认为使用泛型可以帮助解决这个问题，因为我有另一个脚本，它只能将 StateController 作为参数......

[CreateAssetMenu(menuName = ("State Controller/Action Test"))]
public class ActionTest : StateAction
{
    public override void Execute(StateController controller /*place PlayerController Here instead */)
    {
        Debug.Log(controller.currentState);
    }
}

泛型可能有所帮助，但它的实现对我来说令人生畏。 这是上述脚本的示例，其中泛型用于允许传入 PlayerController 但不会修复系统，因为 State.cs 需要 T 作为参数。

public abstract class StateAction<T> : ScriptableObject where T : StateController
{
    public abstract void Execute(T controller);
}

using UnityEngine;

[CreateAssetMenu(menuName = ("State Controller/Action Test"))]
public class ActionTest : StateAction<PlayerController>
{
    public override void Execute(PlayerController controller)
    {
        Debug.Log(controller.currentState);
    }
}

我知道 FSM 需要重组，但有没有其他人设法用这种方法重新设计类似的 FSM？

Answer 1

根据评论更新

尝试：

public abstract class StateAction : ScriptableObject
{ 
    public abstract void Execute(StateController controller);
}

public abstract class StateAction<T> : StateAction
    where T : StateController
{
    public abstract void Execute(T controller);

    public sealed override Execute(StateController controller)
    {
        if (controller is T)
        {
            Execute((T)controller);
        }
    }
}

然后你可以有这样的变量：

StateAction[] onEnter;