初学者，自用笔记

对象池池化工厂(以enemy为例)

数据驱动

// 数据接口定义：等级数据
public interface ILevelData
{
    int level { get; }
}

// 数据接口定义：配置ID
public interface IConfigId
{
    int Id { get; }
}

// 数据接口定义：敌人数据
public interface IEnemyData : ILevelData
{
    int hp { get; }
    float damage { get; }
}

// 等级配置基类（数据驱动核心）
public abstract class LevelConfigBase<TLevelData> : ScriptableObject, IConfigId
    where TLevelData : ILevelData
{
    [SerializeField] private int id;
    public int Id => id;

    [SerializeField] protected List<TLevelData> levelDatas = new List<TLevelData>();

    // 获取对应等级的数据（数据驱动核心方法）
    public virtual TLevelData GetLevelData(int level)
    {
        return levelDatas.Find(d => d.level == level);
    }
}

// 敌人配置类（具体数据配置）
[CreateAssetMenu(fileName = "EnemyConfig", menuName = "Config/EnemyConfig")]
public class EnemyConfig : LevelConfigBase<EnemyConfig.EnemyLevelData>
{
    // 敌人等级数据模型（数据驱动载体）
    [System.Serializable]
    public class EnemyLevelData : IEnemyData
    {
        [SerializeField] private int _level;
        [SerializeField] private int _hp;
        [SerializeField] private float _damage;

        public int level => _level;
        public int hp => _hp;
        public float damage => _damage;
    }
}

// 敌人基类（池化对象具体实现）
public class Enemy : PooledObjectBase
{
    public int curLevel;
    public int curHp;
    public float curDamage;

    // 带数据初始化（数据驱动初始化）
    public override void OnGet<T>(T _data)
    {
        if (_data is IEnemyData enemyData)
        {
            curLevel = enemyData.level;
            curHp = enemyData.hp;
            curDamage = enemyData.damage;
        }
    }

    // 释放重置（池化对象复用）
    public override void OnRelease()
    {
        curLevel = 0;
        curHp = 0;
        curDamage = 0;
        transform.localScale = Vector3.one;
    }

    // 无数据初始化
    public override void OnGet() { }
}

// 小兵（敌人子类）
public class Soldier : Enemy { }

// Boss（敌人子类）
public class Boss : Enemy { }

其他需配置数据模仿当前代码实现

泛型工厂基类(池化)

// 池化工厂接口：定义池化对象的创建契约，包含产品类型和数据类型约束
public interface IPoolFactory<TProduct, TData>
    where TProduct : PooledObjectBase // 约束产品类型必须是池化对象基类
{
    // 创建池化对象的方法：接收池标识、位置、旋转和数据参数
    TProduct Create(string _poolKey, Vector3 pos, Quaternion rot, TData _data = default);
}

// 所有工厂的基类：统一管理工厂标识
public abstract class FactoryBase
{
    public string factoryKey; // 工厂唯一标识

    // 构造函数：初始化工厂标识
    public FactoryBase(string _key)
    {
        factoryKey = _key;
    }
}

// 池化泛型工厂基类：实现池化工厂接口，封装通用池化对象创建逻辑
public abstract class PoolBasedFactory<TProduct, TData> : FactoryBase, IPoolFactory<TProduct, TData>
    where TProduct : PooledObjectBase // 约束产品类型为池化对象
    where TData : class
{
    public PoolManager poolManager; // 对象池管理器引用

    // 构造函数：初始化工厂标识并获取对象池管理器单例
    protected PoolBasedFactory(string _key) : base(_key)
    {
        poolManager = PoolManager.Instance;
    }

    public virtual TProduct Create(string _poolKey,Vector3 pos=default, Quaternion rot=default,TData _data=default)
    {
        TProduct obj = null;

        // 判断是否传入了数据（TData）
        bool hasData = !EqualityComparer<TData>.Default.Equals(_data, default(TData));

        // 判断是否传入了位置信息（使用默认值判断）
        bool hasPosition = pos != default || rot != default;

        if (hasData && hasPosition)
        {
            // 有数据且有位置：调用带位置+数据的GetObject
            obj = poolManager.GetObject<TProduct, TData>(_poolKey, pos, rot, _data);
        }
        else if (hasData && !hasPosition)
        {
            // 有数据但无位置：调用带数据的GetObject（默认位置）
            obj = poolManager.GetObject<TProduct, TData>(_poolKey, _data);
        }
        else if (!hasData && hasPosition)
        {
            // 无数据但有位置：调用带位置的GetObject
            obj = poolManager.GetObject<TProduct>(_poolKey, pos, rot);
        }
        else
        {
            // 无数据且无位置：调用默认位置的GetObject
            obj = poolManager.GetObject<TProduct>(_poolKey);
        }

        return obj;
    }
}

抽象工厂(池化)

// 敌人抽象工厂接口：定义创建小兵和Boss的契约（产品族接口）
public interface IEnemyFactory
{
    Soldier CreateSoldier(string poolKey, int enemyId, int level, Vector3 pos=default, Quaternion rot=default);
    Boss CreateBoss(string poolKey, int enemyId, int level, Vector3 pos=default, Quaternion rot=default);
}

// 小兵工厂接口：定义创建小兵的契约（单一产品接口）
public interface ISoldierFactory
{
    Soldier CreateSoldier(string poolKey, int enemyId, int level, Vector3 pos=default, Quaternion rot=default);
}

// Boss工厂接口：定义创建Boss的契约（单一产品接口）
public interface IBossFactory
{
    Boss CreateBoss(string poolKey, int enemyId, int level, Vector3 pos=default, Quaternion rot=default);
}

// 小兵工厂：实现小兵创建逻辑的具体工厂（池化+数据驱动）
public class SoldierFactory : PoolBasedFactory<Soldier, IEnemyData>, ISoldierFactory
{
    // 存储小兵配置表（ID映射配置）
    private readonly Dictionary<int, EnemyConfig> _configDic = new Dictionary<int, EnemyConfig>();
    // 配置加载路径（按游戏模式区分）
    public string loadstr= "Configs/Enemy/Soldier";
    
    // 构造函数：初始化工厂标识和游戏模式
    public SoldierFactory(string key,GameMode _mode) : base(key)
    {
        loadstr += _mode.ToString(); // 拼接模式路径（如Default/Event）
        LoadConfigs(); // 加载对应模式的小兵配置
    }

    // 加载配置表（数据驱动核心）
    private void LoadConfigs()
    {
        var configs = Resources.LoadAll<EnemyConfig>(loadstr);
        foreach (var config in configs)
        {
            if (config == null) continue;
            _configDic[config.Id] = config; // 缓存配置ID映射
        }
    }

    // 创建小兵：结合配置和对象池
    public Soldier CreateSoldier(string poolKey, int enemyId, int level, Vector3 pos=default, Quaternion rot=default)
    {
        // 查找对应ID的配置
        if (!_configDic.TryGetValue(enemyId, out var config)) return null;
        // 获取对应等级的属性数据
        var levelData = config.GetLevelData(level);
        if (levelData == null) return null;

        // 通过对象池创建小兵并传入属性数据
        return Create(poolKey, pos, rot, levelData);
    }
}

// Boss工厂：实现Boss创建逻辑的具体工厂（池化+数据驱动）
public class BossFactory : PoolBasedFactory<Boss, IEnemyData>, IBossFactory
{
    // 存储Bo***表（ID映射配置）
    private readonly Dictionary<int, EnemyConfig> _configDic = new Dictionary<int, EnemyConfig>();
    // 配置加载路径（按游戏模式区分）
    public string loadstr = "Configs/Enemy/Boss";

    // 构造函数：初始化工厂标识和游戏模式
    public BossFactory(string key,GameMode _mode) : base(key)
    {
        loadstr += _mode.ToString(); // 拼接模式路径
        LoadConfigs(); // 加载对应模式的Bo***
    }

    // 加载配置表（数据驱动核心）
    private void LoadConfigs()
    {
        var configs = Resources.LoadAll<EnemyConfig>(loadstr);
        foreach (var config in configs)
        {
            if (config == null) continue;
            _configDic[config.Id] = config; // 缓存配置ID映射
        }
    }

    // 创建Boss：结合配置和对象池
    public Boss CreateBoss(string poolKey, int enemyId, int level, Vector3 pos=default, Quaternion rot=default)
    {
        // 查找对应ID的配置
        if (!_configDic.TryGetValue(enemyId, out var config)) return null;
        // 获取对应等级的属性数据
        var levelData = config.GetLevelData(level);
        if (levelData == null) return null;

        // 通过对象池创建Boss并传入属性数据
        return Create(poolKey, pos, rot, levelData);
    }
}

// 普通关卡敌人工厂：组合小兵/Boss工厂的产品族工厂（抽象工厂具体实现）
public class DefaultEnemyFactory : FactoryBase, IEnemyFactory
{
    private readonly ISoldierFactory _soldierFactory; // 小兵工厂依赖
    private readonly IBossFactory _bossFactory;       // Boss工厂依赖

    // 构造函数：注入具体工厂依赖（依赖注入）
    public DefaultEnemyFactory(
        string key,
        ISoldierFactory soldierFactory,
        IBossFactory bossFactory
    ) : base(key)
    {
        _soldierFactory = soldierFactory;
        _bossFactory = bossFactory;
    }

    // 创建普通关卡小兵：委托给小兵工厂
    public Soldier CreateSoldier(string poolKey, int enemyId, int level, Vector3 pos=default, Quaternion rot=default)
        => _soldierFactory.CreateSoldier(poolKey, enemyId, level, pos, rot);

    // 创建普通关卡Boss：委托给Boss工厂
    public Boss CreateBoss(string poolKey, int enemyId, int level, Vector3 pos=default, Quaternion rot=default)
        => _bossFactory.CreateBoss(poolKey, enemyId, level, pos, rot);
}

// 活动关卡敌人工厂：组合小兵/Boss工厂的产品族工厂（抽象工厂具体实现）
public class EventEnemyFactory : FactoryBase, IEnemyFactory
{
    private readonly ISoldierFactory _soldierFactory; // 小兵工厂依赖
    private readonly IBossFactory _bossFactory;       // Boss工厂依赖

    // 构造函数：注入具体工厂依赖（依赖注入）
    public EventEnemyFactory(
        string key,
        ISoldierFactory soldierFactory,
        IBossFactory bossFactory
    ) : base(key)
    {
        _soldierFactory = soldierFactory;
        _bossFactory = bossFactory;
    }

    // 创建活动关卡小兵：委托给活动模式小兵工厂（可扩展特殊逻辑）
    public Soldier CreateSoldier(string poolKey, int enemyId, int level, Vector3 pos=default, Quaternion rot=default)
        => _soldierFactory.CreateSoldier(poolKey, enemyId, level, pos, rot);

    // 创建活动关卡Boss：委托给活动模式Boss工厂（可扩展特殊逻辑）
    public Boss CreateBoss(string poolKey, int enemyId, int level, Vector3 pos=default, Quaternion rot=default)
        => _bossFactory.CreateBoss(poolKey, enemyId, level, pos, rot);
}

具体工厂(池化)

// 基础池化工厂：针对PooledObjectBase基类的具体池化工厂实现
public class BasePoolFactory : PoolBasedFactory<PooledObjectBase, object>
{
    // 构造函数：传入工厂标识
    public BasePoolFactory(string _key) : base(_key)
    {
    }

    // 重写创建方法：调用基类逻辑，可扩展自定义行为
    public override PooledObjectBase Create(string _poolKey, Vector3 pos=default, Quaternion rot=default, object _data = null)
    {
        return base.Create(_poolKey, pos, rot, _data);
    }
}

工厂管理器

// 游戏模式枚举：区分不同游戏场景（普通模式/活动模式）
public enum GameMode
{
    Default,   // 普通模式
    Event,     // 活动模式
}

// 工厂管理器：统一管理所有工厂的注册、获取和模式切换（注册表模式+抽象工厂模式应用）
public class FactoryManager : MonoBehaviour
{
    public static FactoryManager Instance; // 单例实例

    // 工厂注册表：存储所有工厂实例（键=工厂标识，值=工厂实例）
    public Dictionary<string, FactoryBase> factoryDic = new Dictionary<string, FactoryBase>();

    [SerializeField] private GameObject NonPoolprefab; // 非池化预制体示例
    public GameMode gameMode = GameMode.Default;       // 当前游戏模式

    private void Awake()
    {
        // 单例模式初始化：确保全局唯一实例
        if (Instance == null)
        {
            Instance = this;
        }
        else
        {
            Destroy(gameObject); // 销毁重复实例
            return;
        }

        InitFactors(); // 初始化所有工厂
    }

    // 初始化所有工厂：注册非池化工厂、池化工厂和敌人工厂
    private void InitFactors()
    {
        factoryDic.Clear(); // 清空注册表

        // 1. 注册非池化工厂：传入创建逻辑（实例化预制体）
        NonPoolBaseFactory nonPoolFactory =
            new NonPoolBaseFactory("NonPoolBase",
           (pos, rot) => Instantiate(NonPoolprefab, pos, rot));
        AddFactors(nonPoolFactory);

        // 2. 注册基础池化工厂
        BasePoolFactory BasePoolFactory = new BasePoolFactory("Base");
        AddFactors(BasePoolFactory);

        // 3. 初始化敌人工厂（根据游戏模式）
        InitEnemyFactory();
    }

    // 初始化敌人工厂：根据当前游戏模式创建对应的敌人家族工厂（抽象工厂模式）
    private void InitEnemyFactory()
    {
        ISoldierFactory soldierFactory; // 小兵工厂接口
        IBossFactory bossFactory;       // Boss工厂接口

        // 根据游戏模式选择对应的具体工厂
        switch (gameMode)
        {
            case GameMode.Default:
                // 普通模式：创建普通敌人工厂
                soldierFactory = new SoldierFactory("Soldier_Default", gameMode);
                bossFactory = new BossFactory("Boss_Default", gameMode);
                AddFactors(new DefaultEnemyFactory("Enemy", soldierFactory, bossFactory));
                break;

            case GameMode.Event:
                // 活动模式：创建活动敌人工厂
                soldierFactory = new SoldierFactory("Soldier_Event", gameMode);
                bossFactory = new BossFactory("Boss_Event", gameMode);
                AddFactors(new EventEnemyFactory("Enemy", soldierFactory, bossFactory));
                break;
        }
    }

    // 切换游戏模式：动态替换敌人工厂（产品族切换）
    public void SwitchGameMode(GameMode newMode)
    {
        if (gameMode == newMode)
            return; // 模式未变化，直接返回

        gameMode = newMode;

        // 移除旧的敌人工厂（产品族）
        factoryDic.Remove("Enemy");

        // 根据新模式重新注册敌人工厂
        InitEnemyFactory();
    }

    // 注册工厂到注册表：添加工厂实例并验证有效性
    public void AddFactors(FactoryBase _base)
    {
        if (_base == null || string.IsNullOrEmpty(_base.factoryKey))
        { return; } // 无效工厂，跳过注册
        factoryDic[_base.factoryKey] = _base; // 存入注册表
    }

    // 获取工厂：从注册表中按标识和类型获取工厂（泛型方法）
    public T GetFactory<T>(string _key) where T : class
    {
        if (factoryDic.TryGetValue(_key, out var factory))
        {
            return factory as T; // 类型转换后返回
        }
        return null; // 未找到对应工厂
    }

    // 清空所有工厂：重置注册表
    public void ClearAllFactories()
    {
        factoryDic.Clear();
    }
}

泛型工厂(非池化)

//非池化工厂
public interface INonPoolFactory<TProduct, TData>
    where TProduct : class
{
    TProduct Create(Vector3 pos=default, Quaternion rot=default, TData data = default);
}

// 非池化泛型工厂基类：通过 Func<TData, TProduct> 委托来创建对象
public abstract class NonPoolFactory<TProduct, TData>
    : FactoryBase, INonPoolFactory<TProduct, TData>
    where TProduct : class
{
    // 创建函数：由子类或外部注入，决定如何创建对象
    protected System.Func<Vector3, Quaternion, TData, TProduct> _createFunc;
    protected NonPoolFactory(string key) : base(key)
    {

    }

    protected NonPoolFactory(string key, System.Func<Vector3, Quaternion, TData, TProduct> createFunc)
            : base(key)
    {
        _createFunc = createFunc;
    }

    public virtual TProduct Create(Vector3 pos=default, Quaternion rot=default, TData data = default)
    {
        if (_createFunc == null)
        {
            return null;
        }

        return _createFunc.Invoke(pos,rot,data);
    }

    // 允许运行时重设创建函数
    public void SetCreateFunc(System.Func<Vector3, Quaternion, TData, TProduct> createFunc)
    {
        _createFunc = createFunc;
    }
}

具体工厂(非池化)

public class NonPoolBaseFactory
    : NonPoolFactory<GameObject, object>
{
    public NonPoolBaseFactory(string key, System.Func<Vector3, Quaternion, GameObject> createFunc)
            : base(key)
    {
        _createFunc = (pos, rot, data) => createFunc(pos, rot);
    }

    // 无参创建方法
    public GameObject Create(Vector3 pos=default, Quaternion rot=default)
    {
        return base.Create(pos,rot,null);
    }
}

调用实例

    public int EnemyId;

    public void Awake()
    {
        // 直接按接口获取
        var enemyFactory = FactoryManager.Instance.GetFactory<IEnemyFactory>("EnemyFactory");
        if (enemyFactory == null)
        {
            Debug.LogError("敌人工厂获取失败！");
            return;
        }

        enemyFactory.CreateSoldier("Soldier", EnemyId, 1, transform.position, transform.rotation);
    }

技能工厂

SkillFactory

public interface ISkillFactory
{
    SkillType SupportType { get; }

    SkillBase CreateSkill(ISkillOwner owner, SkillData data);
}

public class SwapPositionSkillFactory : ISkillFactory
{
    public SkillType SupportType => SkillType.SwapPosition;

    public SkillBase CreateSkill(ISkillOwner owner, SkillData data)
    {
        var skill = new SwapPositionSkill(owner, data);
        var aimData = data as AimSkillData;

        // 创建并注入瞄准器
    if (aimData.aimData != null)
    {
        var aimFactory = AimFactoryRegistry.GetFactory(aimData.aimData.aimType);
        if (aimFactory != null)
        {
                skill.myAim = aimFactory.CreateAim(
                    owner,
                    owner.myTransform,
                    Camera.main,
                    aimData.aimData,
                    SupportType
                );
                
        }
    }
        return skill;
    }
}

SkillFactory泛型工厂重构

// 泛型Skill工厂基类（抽离通用逻辑）
public abstract class GenericSkillFactory<TSkill> : ISkillFactory 
    where TSkill : AimSkillBase
{
    // 子类只需实现这个属性，指定支持的技能类型
    public abstract SkillType SupportType { get; }

    // 子类实现：创建具体Skill实例（直接new）
    protected abstract TSkill CreateSkillInstance(ISkillOwner owner, SkillData data);
  
    // 通用的创建逻辑（所有Skill工厂都复用这部分）
    public SkillBase CreateSkill(ISkillOwner owner, SkillData data)
    {
        TSkill skill = CreateSkillInstance(owner, data);
        
        // 通用的瞄准器创建逻辑（所有工厂都一样）
        var aimData = data as AimSkillData;
        if (aimData?.aimData != null)
        {
            var aimFactory = AimFactoryRegistry.GetFactory(aimData.aimData.aimType);
            if (aimFactory != null)
            {
                skill.myAim = aimFactory.CreateAim(
                    owner,
                    owner.myTransform,
                    Camera.main,
                    aimData.aimData,
                    SupportType
                );
            }
        }

        return skill;
    }
}

// 重构后的具体工厂
public class SwapPositionSkillFactory : GenericSkillFactory<SwapPositionSkill>
{
    public override SkillType SupportType => SkillType.SwapPosition;
  
  protected override SwapPositionSkill CreateSkillInstance(ISkillOwner owner, SkillData data)
    {
        return new SwapPositionSkill(owner, data);
    }
}

SKillFactory注册表

public static class SkillFactoryRegistry
{
    private static readonly Dictionary<SkillType, ISkillFactory> factories = new();

    static SkillFactoryRegistry()
    {
        RegisterFactory(new SwapPositionSkillFactory());
        RegisterFactory(new SwapScaleSkillFactory());
        RegisterFactory(new SwapColliderSkillFactory());
        RegisterFactory(new SwapTargetSkillFactory());
        RegisterFactory(new SwapPlayerSkillFactory());
    }

    public static void RegisterFactory(ISkillFactory factory)
    {
        if (factory == null) return;
        factories[factory.SupportType] = factory;
    }

    public static ISkillFactory GetFactory(SkillType type)
    {
        factories.TryGetValue(type, out var f);
        return f;
    }

}

待优化-注册表优化，魔术字符串问题，原型模式代替new()