public class Test
{
    public Test()
    {
        Promise<int, int> promise = new Promise<int, int>((reslove, reject) =>
        {
            reslove(10);
        });
        promise.Then((res) =>
        {
            Debug.Log(res);
        });
    }
}

public class Promise<TRes, TError>
{
    public delegate void funReslove(TRes res);
    public delegate void funReject(TError err);
    public delegate void fun(funReslove reslove, funReject reject);
    public funReslove m_reslove;
    public funReject m_reject;
    public fun m_fun;

    public Promise(fun fun)
    {
        m_fun = fun;
        m_fun?.Invoke(m_reslove, m_reject);
    }
    public void Then(funReslove reslove)
    {
        m_reslove += reslove;
    }
    public void Catch(funReject reject)
    {
        m_reject += reject;
    }
}

public interface BaseCommand
{
    /// <summary>
    /// 执行命令
    /// </summary>
    /// <param name="command"></param>
    /// <param name="obj"></param>
    public void Execute(GameObject gameObject);
    /// <summary>
    /// 回退命令
    /// </summary>
    /// <param name="obj"></param>
    public void Revoke(GameObject gameObject);
}

public class MoveCommand : BaseCommand
{
    private GameObject m_gameObject;
    private Vector3 m_direction;

    public MoveCommand(Vector3 dir)
    {
        m_direction = dir;
    }

    public void Execute(GameObject obj)
    {
        m_gameObject = obj;
        m_gameObject.transform.Translate(m_direction);
    }

    public void Revoke(GameObject obj)
    {
        m_gameObject = obj;
        m_gameObject.transform.Translate(Quaternion.Euler(0f, 180f, 0f) * m_direction);
    }
}

public static class CommandManager
{
    private static Stack<BaseCommand> m_commands = new Stack<BaseCommand>();
    public static void Clear() { m_commands.Clear(); }
    /// <summary>
    /// 执行命令
    /// </summary>
    /// <param name="command"></param>
    /// <param name="obj"></param>
    public static void Excute(BaseCommand command, GameObject obj)
    {
        command.Execute(obj);
        m_commands.Push(command);
    }
    /// <summary>
    /// 回退命令
    /// </summary>
    /// <param name="obj"></param>
    public static void Revock(GameObject obj)
    {
        if (m_commands.TryPop(out BaseCommand commmand))
        {
            commmand.Revoke(obj);
        }
    }
}

public class TestCommandMode : MonoBehaviour
{
    private MoveCommand m_moveForwad;
    private MoveCommand m_moveBack;
    private MoveCommand m_moveLeft;
    private MoveCommand m_moveRight;

    private void Start()
    {
        m_moveForwad = new MoveCommand(Vector3.forward);
        m_moveBack = new MoveCommand(Vector3.back);
        m_moveLeft = new MoveCommand(Vector3.left);
        m_moveRight = new MoveCommand(Vector3.right);
    }

    private void Update()
    {
        if (Input.GetKeyDown(KeyCode.W))
        {
            CommandManager.Excute(m_moveForwad, gameObject);
        }
        if (Input.GetKeyDown(KeyCode.S))
        {
            CommandManager.Excute(m_moveBack, gameObject);
        }
        if (Input.GetKeyDown(KeyCode.A))
        {
            CommandManager.Excute(m_moveLeft, gameObject);
        }
        if (Input.GetKeyDown(KeyCode.D))
        {
            CommandManager.Excute(m_moveRight, gameObject);
        }
        if (Input.GetKeyDown(KeyCode.R))
        {
            CommandManager.Revock(gameObject);
        }
    }
}