Factory

using System.Collections.Generic;
using UnityEngine;

namespace Patterns.Creational.Factory
{
    /// <summary>
    /// Client. It knows enemy *types* and the factory, but never
    /// references Goblin, Orc or Dragon classes or prefabs.
    /// </summary>
    public class EnemySpawner : MonoBehaviour
    {
        [SerializeField] private EnemyFactory factory;
        [SerializeField] private Transform[] spawnPoints;

        private readonly List<IEnemy> alive = new();

        private void Update()
        {
            if (Input.GetKeyDown(KeyCode.Alpha1)) Spawn(EnemyType.Goblin);
            if (Input.GetKeyDown(KeyCode.Alpha2)) Spawn(EnemyType.Orc);
            if (Input.GetKeyDown(KeyCode.Alpha3)) Spawn(EnemyType.Dragon);

            if (Input.GetKeyDown(KeyCode.Space))
                foreach (IEnemy enemy in alive)
                    enemy.Attack();
        }

        private void Spawn(EnemyType type)
        {
            Transform point = spawnPoints[Random.Range(0, spawnPoints.Length)];
            IEnemy enemy = factory.Create(type, point.position, transform);

            if (enemy != null)
                alive.Add(enemy);
        }
    }
}

using UnityEngine;

namespace Patterns.Creational.Factory
{
    public enum EnemyType { Goblin, Orc, Dragon }

    /// <summary>
    /// What every client sees. Spawners, wave controllers and UI only
    /// ever talk to this interface, never to Goblin or Dragon directly.
    /// </summary>
    public interface IEnemy
    {
        EnemyType Type { get; }
        int Health { get; }
        void Spawn(Vector3 position);
        void Attack();
    }

    /// <summary>Shared MonoBehaviour base so prefabs can be referenced in a list.</summary>
    public abstract class Enemy : MonoBehaviour, IEnemy
    {
        [SerializeField] private int baseHealth = 10;

        public abstract EnemyType Type { get; }
        public int Health { get; protected set; }

        public virtual void Spawn(Vector3 position)
        {
            transform.position = position;
            Health = baseHealth;
            gameObject.SetActive(true);
        }

        public abstract void Attack();
    }
}

using UnityEngine;

namespace Patterns.Creational.Factory
{
    /// <summary>Fast, weak melee enemy.</summary>
    public class Goblin : Enemy
    {
        public override EnemyType Type => EnemyType.Goblin;
        public override void Attack() => Debug.Log("Goblin stabs for 3.");
    }

    /// <summary>Slow, tough melee enemy.</summary>
    public class Orc : Enemy
    {
        public override EnemyType Type => EnemyType.Orc;
        public override void Attack() => Debug.Log("Orc smashes for 8.");
    }

    /// <summary>Flying boss that breathes fire.</summary>
    public class Dragon : Enemy
    {
        [SerializeField] private ParticleSystem fireBreath;

        public override EnemyType Type => EnemyType.Dragon;

        public override void Spawn(Vector3 position)
        {
            base.Spawn(position + Vector3.up * 4f); // dragons arrive airborne
        }

        public override void Attack()
        {
            if (fireBreath != null) fireBreath.Play();
            Debug.Log("Dragon breathes fire for 25.");
        }
    }
}

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

namespace Patterns.Creational.Factory
{
    /// <summary>
    /// Data-driven factory stored as an asset. Designers map each
    /// EnemyType to a prefab; code only calls Create(type).
    /// </summary>
    [CreateAssetMenu(menuName = "Patterns/Enemy Factory")]
    public class EnemyFactory : ScriptableObject
    {
        [Serializable]
        private struct Entry
        {
            public EnemyType type;
            public Enemy prefab;
        }

        [SerializeField] private List<Entry> prefabs = new();

        private Dictionary<EnemyType, Enemy> lookup;

        private void OnEnable() => lookup = null; // rebuild after domain reload / edits

        public IEnemy Create(EnemyType type, Vector3 position, Transform parent = null)
        {
            lookup ??= BuildLookup();

            if (!lookup.TryGetValue(type, out Enemy prefab))
            {
                Debug.LogError($"EnemyFactory: no prefab registered for {type}.");
                return null;
            }

            Enemy instance = Instantiate(prefab, parent);
            instance.Spawn(position);
            return instance;
        }

        private Dictionary<EnemyType, Enemy> BuildLookup()
        {
            var map = new Dictionary<EnemyType, Enemy>();
            foreach (Entry e in prefabs)
                map[e.type] = e.prefab;
            return map;
        }
    }
}