Prototype

using UnityEngine;

namespace Patterns.Creational.Prototype
{
    /// <summary>
    /// Client. Uses Instantiate (Unity's built-in prototype) for the
    /// GameObject, and EnemyData.Clone() for its plain C# data.
    /// </summary>
    public class CloneSpawner : MonoBehaviour
    {
        [SerializeField] private GameObject prototypeObject; // a configured scene object or prefab
        [SerializeField] private EnemyData prototypeData = new();
        [SerializeField] private float spread = 3f;

        private void Update()
        {
            if (Input.GetKeyDown(KeyCode.C))
                SpawnClone();
        }

        private void SpawnClone()
        {
            Vector3 offset = Random.insideUnitSphere * spread;
            offset.y = 0f;

            // 1. Unity copies the whole hierarchy and serialized fields.
            GameObject go = Instantiate(prototypeObject, transform.position + offset, Quaternion.identity);
            go.transform.localScale = Vector3.one * prototypeData.size;

            // 2. Our own deep copy for runtime data.
            EnemyData data = prototypeData.Clone();
            data.abilities.Add("Split"); // safe: prototype's list is untouched

            if (go.TryGetComponent(out Renderer r))
                r.material.color = data.color;

            Debug.Log($"Clone: {data}");
            Debug.Log($"Prototype: {prototypeData}");
        }
    }
}

namespace Patterns.Creational.Prototype
{
    /// <summary>
    /// Strongly typed alternative to System.ICloneable.
    /// Implementations promise a deep, independent copy.
    /// </summary>
    public interface IPrototype<T>
    {
        T Clone();
    }
}

using System;
using System.Collections.Generic;
using UnityEngine;

namespace Patterns.Creational.Prototype
{
    /// <summary>
    /// Plain C# enemy configuration. Clone() is deep: the abilities list
    /// is copied, so clones never share it with the prototype.
    /// </summary>
    [Serializable]
    public class EnemyData : IPrototype<EnemyData>, ICloneable
    {
        public string name = "Slime";
        public Color color = Color.green;
        public float size = 1f;
        public int health = 30;
        public List<string> abilities = new() { "Bounce" };

        /// <summary>Deep copy: value fields via MemberwiseClone, then new collections.</summary>
        public EnemyData Clone()
        {
            var copy = (EnemyData)MemberwiseClone();
            copy.abilities = new List<string>(abilities);
            return copy;
        }

        /// <summary>
        /// Shallow copy, shown for contrast. The returned object shares
        /// the same abilities list instance as this one.
        /// </summary>
        public EnemyData ShallowClone() => (EnemyData)MemberwiseClone();

        object ICloneable.Clone() => Clone();

        public override string ToString() =>
            $"{name} hp:{health} size:{size:0.0} [{string.Join(", ", abilities)}]";
    }
}