Memento

using UnityEngine;

namespace Patterns.Behavioral.Memento
{
    /// <summary>
    /// Client: saves and loads checkpoints. It shuttles mementos
    /// between the player and the history without inspecting them.
    /// </summary>
    public class CheckpointTester : MonoBehaviour
    {
        [SerializeField] private Player player;

        private readonly SaveHistory history = new(capacity: 5);

        private void Update()
        {
            if (Input.GetKeyDown(KeyCode.F5))
            {
                PlayerMemento snapshot = player.Save();
                history.Push(snapshot);
                Debug.Log($"Saved {snapshot}");
            }

            if (Input.GetKeyDown(KeyCode.F9) && history.Latest != null)
            {
                player.Restore(history.Latest);
                Debug.Log($"Restored {history.Latest}");
            }

            // Mess with the state so there is something to restore.
            if (Input.GetKeyDown(KeyCode.D)) player.TakeDamage(25);
            if (Input.GetKeyDown(KeyCode.L)) player.LevelUp();
            if (Input.GetKeyDown(KeyCode.M)) player.Move(Random.insideUnitSphere * 3f);
        }
    }
}

using UnityEngine;

namespace Patterns.Behavioral.Memento
{
    /// <summary>
    /// Immutable snapshot of the player's state. Once created it can
    /// never change, so stored history is always trustworthy.
    /// </summary>
    public sealed class PlayerMemento
    {
        public Vector3 Position { get; }
        public int Health { get; }
        public int Level { get; }
        public float Timestamp { get; }

        public PlayerMemento(Vector3 position, int health, int level)
        {
            Position = position;
            Health = health;
            Level = level;
            Timestamp = Time.time;
        }

        public override string ToString() =>
            $"[{Timestamp:0.0}s] pos {Position}, hp {Health}, lvl {Level}";
    }
}

using UnityEngine;

namespace Patterns.Behavioral.Memento
{
    /// <summary>
    /// Originator. Only the player knows how to turn its state into a
    /// memento and how to apply one back.
    /// </summary>
    public class Player : MonoBehaviour
    {
        [SerializeField] private int maxHealth = 100;

        private int health;
        private int level = 1;

        public int Health => health;
        public int Level => level;

        private void Awake() => health = maxHealth;

        public void TakeDamage(int amount) => health = Mathf.Max(0, health - amount);
        public void LevelUp() => level++;
        public void Move(Vector3 delta) => transform.position += delta;

        public PlayerMemento Save()
        {
            return new PlayerMemento(transform.position, health, level);
        }

        public void Restore(PlayerMemento memento)
        {
            transform.position = memento.Position;
            health = memento.Health;
            level = memento.Level;
        }
    }
}

using System.Collections.Generic;

namespace Patterns.Behavioral.Memento
{
    /// <summary>
    /// Caretaker. Stores snapshots and hands them back on request,
    /// but never reads or modifies their contents.
    /// </summary>
    public class SaveHistory
    {
        private readonly List<PlayerMemento> slots = new();
        private readonly int capacity;

        public SaveHistory(int capacity = 5) => this.capacity = capacity;

        public int Count => slots.Count;

        public void Push(PlayerMemento memento)
        {
            if (slots.Count == capacity)
                slots.RemoveAt(0); // forget the oldest save

            slots.Add(memento);
        }

        public PlayerMemento Get(int index) => slots[index];

        public PlayerMemento Latest => slots.Count > 0 ? slots[^1] : null;
    }
}