Command

using UnityEngine;

namespace Patterns.Behavioral.Command
{
    /// <summary>
    /// Client: turns key presses into command objects and hands them
    /// to the invoker. It never moves the unit itself.
    /// </summary>
    public class InputHandler : MonoBehaviour
    {
        [SerializeField] private Transform unit;
        [SerializeField] private RectInt board = new(0, 0, 5, 5);

        private readonly CommandInvoker invoker = new();

        private void Update()
        {
            if (Input.GetKeyDown(KeyCode.W)) Move(Vector2Int.up);
            if (Input.GetKeyDown(KeyCode.S)) Move(Vector2Int.down);
            if (Input.GetKeyDown(KeyCode.A)) Move(Vector2Int.left);
            if (Input.GetKeyDown(KeyCode.D)) Move(Vector2Int.right);

            if (Input.GetKeyDown(KeyCode.Z)) invoker.Undo();
            if (Input.GetKeyDown(KeyCode.Y)) invoker.Redo();
        }

        private void Move(Vector2Int direction)
        {
            invoker.Execute(new MoveCommand(unit, direction, board));
        }
    }
}

namespace Patterns.Behavioral.Command
{
    /// <summary>
    /// A single, reversible action. The invoker only knows this interface,
    /// never the concrete work being done.
    /// </summary>
    public interface ICommand
    {
        /// <summary>Performs the action. Returns false if it could not run.</summary>
        bool Execute();

        /// <summary>Reverts exactly what Execute did.</summary>
        void Undo();
    }
}

using UnityEngine;

namespace Patterns.Behavioral.Command
{
    /// <summary>
    /// Moves a unit one tile on a grid. Remembers where the unit started
    /// so Undo can put it back precisely.
    /// </summary>
    public class MoveCommand : ICommand
    {
        private readonly Transform unit;
        private readonly Vector2Int direction;
        private readonly RectInt bounds;
        private Vector3 previousPosition;

        public MoveCommand(Transform unit, Vector2Int direction, RectInt bounds)
        {
            this.unit = unit;
            this.direction = direction;
            this.bounds = bounds;
        }

        public bool Execute()
        {
            Vector3 target = unit.position + new Vector3(direction.x, direction.y, 0f);
            var cell = Vector2Int.RoundToInt(target);
            if (!bounds.Contains(cell))
                return false; // walking off the board is not allowed

            previousPosition = unit.position;
            unit.position = target;
            return true;
        }

        public void Undo() => unit.position = previousPosition;

        public override string ToString() => $"Move {direction}";
    }
}

using System.Collections.Generic;
using UnityEngine;

namespace Patterns.Behavioral.Command
{
    /// <summary>
    /// Runs commands and keeps the history needed for undo and redo.
    /// It has no idea what any command actually does.
    /// </summary>
    public class CommandInvoker
    {
        private readonly Stack<ICommand> undoStack = new();
        private readonly Stack<ICommand> redoStack = new();

        public int UndoCount => undoStack.Count;
        public int RedoCount => redoStack.Count;

        public void Execute(ICommand command)
        {
            if (!command.Execute())
            {
                Debug.Log($"{command} blocked");
                return;
            }

            undoStack.Push(command);
            redoStack.Clear(); // a new action invalidates the old future
        }

        public void Undo()
        {
            if (undoStack.Count == 0) return;

            ICommand command = undoStack.Pop();
            command.Undo();
            redoStack.Push(command);
        }

        public void Redo()
        {
            if (redoStack.Count == 0) return;

            ICommand command = redoStack.Pop();
            command.Execute();
            undoStack.Push(command);
        }
    }
}