建造者模式

在Unity中使用C#实现建造者模式，核心是解决「复杂对象的分步构建与表示分离」问题。结合游戏开发典型场景——自定义游戏角色（包含外观、属性、技能等多个组件），能直观体现建造者模式“分步组装、灵活定制”的核心特性（比如创建“肉盾战士”“爆发法师”等不同配置的角色，复用同一套构建流程）

一、核心思路（建造者模式）

二、完整代码实现

1. 产品类：GameCharacter（复杂对象——游戏角色）

using System.Collections.Generic;
using UnityEngine;

/// <summary>
/// 复杂产品：游戏角色（包含多个组件）
/// </summary>
public class GameCharacter
{
    // 角色基础信息
    public string Name { get; set; }
    public string RoleType { get; set; } // 战士/法师/刺客

    // 组件1：外观
    public string Appearance { get; set; } // 模型/皮肤
    // 组件2：属性
    public int Hp { get; set; }
    public int Attack { get; set; }
    public int Defense { get; set; }
    // 组件3：技能
    public List<string> Skills { get; set; } = new List<string>();
    // 组件4：装备
    public string Weapon { get; set; }
    public string Armor { get; set; }

    // 展示角色配置
    public void ShowInfo()
    {
        Debug.Log($"========== 角色配置完成 ==========\n" +
                  $"角色名称：{Name}\n" +
                  $"角色类型：{RoleType}\n" +
                  $"外观：{Appearance}\n" +
                  $"属性：HP={Hp} | 攻击={Attack} | 防御={Defense}\n" +
                  $"技能：{string.Join("、", Skills)}\n" +
                  $"装备：{Weapon} + {Armor}\n" +
                  "==================================");
    }
}

2. 抽象建造者：ICharacterBuilder（定义构建步骤）

/// <summary>
/// 抽象建造者：定义构建角色各个组件的方法
/// </summary>
public interface ICharacterBuilder
{
    // 初始化角色基础信息
    void InitBaseInfo(string name);
    // 构建外观
    void BuildAppearance();
    // 构建属性
    void BuildAttributes();
    // 构建技能
    void BuildSkills();
    // 构建装备
    void BuildEquipment();
    // 获取最终构建的角色
    GameCharacter GetResult();
}

3. 具体建造者：定制不同角色（战士/法师）

3.1 肉盾战士建造者：WarriorBuilder

/// <summary>
/// 具体建造者1：肉盾战士建造者（高血量、高防御、近战技能）
/// </summary>
public class WarriorBuilder : ICharacterBuilder
{
    private GameCharacter _character = new GameCharacter();

    public void InitBaseInfo(string name)
    {
        _character.Name = name;
        _character.RoleType = "肉盾战士";
        Debug.Log($"[战士建造者] 初始化角色：{name}");
    }

    public void BuildAppearance()
    {
        // Unity特有逻辑：可在此加载战士预制体/皮肤
        _character.Appearance = "重甲战士模型 + 红色皮肤";
        Debug.Log($"[战士建造者] 构建外观：{_character.Appearance}");
    }

    public void BuildAttributes()
    {
        _character.Hp = 2000; // 高血量
        _character.Attack = 300;
        _character.Defense = 800; // 高防御
        Debug.Log($"[战士建造者] 构建属性：HP={_character.Hp} 攻击={_character.Attack} 防御={_character.Defense}");
    }

    public void BuildSkills()
    {
        _character.Skills.AddRange(new[] { "盾击", "嘲讽", "生命回复", "范围劈砍" });
        Debug.Log($"[战士建造者] 构建技能：{string.Join("、", _character.Skills)}");
    }

    public void BuildEquipment()
    {
        _character.Weapon = "巨型战斧";
        _character.Armor = "熔岩重甲";
        Debug.Log($"[战士建造者] 构建装备：{_character.Weapon} + {_character.Armor}");
    }

    public GameCharacter GetResult()
    {
        return _character;
    }
}

3.2 爆发法师建造者：MageBuilder

/// <summary>
/// 具体建造者2：爆发法师建造者（低血量、高攻击、法术技能）
/// </summary>
public class MageBuilder : ICharacterBuilder
{
    private GameCharacter _character = new GameCharacter();

    public void InitBaseInfo(string name)
    {
        _character.Name = name;
        _character.RoleType = "爆发法师";
        Debug.Log($"[法师建造者] 初始化角色：{name}");
    }

    public void BuildAppearance()
    {
        _character.Appearance = "法袍模型 + 蓝色特效皮肤";
        Debug.Log($"[法师建造者] 构建外观：{_character.Appearance}");
    }

    public void BuildAttributes()
    {
        _character.Hp = 800; // 低血量
        _character.Attack = 1200; // 高攻击
        _character.Defense = 200;
        Debug.Log($"[法师建造者] 构建属性：HP={_character.Hp} 攻击={_character.Attack} 防御={_character.Defense}");
    }

    public void BuildSkills()
    {
        _character.Skills.AddRange(new[] { "火球术", "冰锥术", "法术暴击", "瞬移" });
        Debug.Log($"[法师建造者] 构建技能：{string.Join("、", _character.Skills)}");
    }

    public void BuildEquipment()
    {
        _character.Weapon = "烈焰法杖";
        _character.Armor = "秘法披风";
        Debug.Log($"[法师建造者] 构建装备：{_character.Weapon} + {_character.Armor}");
    }

    public GameCharacter GetResult()
    {
        return _character;
    }
}

4. 指挥者：CharacterDirector（封装构建流程）

/// <summary>
/// 指挥者：固定角色构建的流程（外观→属性→技能→装备），解耦构建步骤与客户端
/// </summary>
public class CharacterDirector
{
    private readonly ICharacterBuilder _builder;

    // 传入具体建造者
    public CharacterDirector(ICharacterBuilder builder)
    {
        _builder = builder;
    }

    /// <summary>
    /// 构建完整角色（固定流程）
    /// </summary>
    /// <param name="name">角色名称</param>
    /// <returns>构建完成的角色</returns>
    public GameCharacter ConstructCharacter(string name)
    {
        Debug.Log("\n========== 开始构建角色 ==========");
        _builder.InitBaseInfo(name);
        _builder.BuildAppearance();
        _builder.BuildAttributes();
        _builder.BuildSkills();
        _builder.BuildEquipment();
        Debug.Log("========== 角色构建完成 ==========\n");
        return _builder.GetResult();
    }
}

5. 客户端调用：GameManager（Unity场景挂载）

using UnityEngine;

/// <summary>
/// 游戏管理器（客户端）：通过指挥者+建造者创建定制化角色
/// </summary>
public class GameManager : MonoBehaviour
{
    private void Start()
    {
        // ========== 1. 构建肉盾战士 ==========
        // 步骤1：创建具体建造者（战士）
        ICharacterBuilder warriorBuilder = new WarriorBuilder();
        // 步骤2：创建指挥者，传入建造者
        CharacterDirector warriorDirector = new CharacterDirector(warriorBuilder);
        // 步骤3：指挥者执行构建流程，获取角色
        GameCharacter warrior = warriorDirector.ConstructCharacter("钢铁守卫");
        // 展示角色信息
        warrior.ShowInfo();

        // ========== 2. 构建爆发法师 ==========
        Debug.Log("\n-----------------------------------\n");
        ICharacterBuilder mageBuilder = new MageBuilder();
        CharacterDirector mageDirector = new CharacterDirector(mageBuilder);
        GameCharacter mage = mageDirector.ConstructCharacter("寒冰法师");
        mage.ShowInfo();
    }
}

三、Unity运行效果

将GameManager挂载到场景任意物体（如MainCamera），运行后控制台输出：

========== 开始构建角色 ==========
[战士建造者] 初始化角色：钢铁守卫
[战士建造者] 构建外观：重甲战士模型 + 红色皮肤
[战士建造者] 构建属性：HP=2000 攻击=300 防御=800
[战士建造者] 构建技能：盾击、嘲讽、生命回复、范围劈砍
[战士建造者] 构建装备：巨型战斧 + 熔岩重甲
========== 角色构建完成 ==========

========== 角色配置完成 ==========
角色名称：钢铁守卫
角色类型：肉盾战士
外观：重甲战士模型 + 红色皮肤
属性：HP=2000 | 攻击=300 | 防御=800
技能：盾击、嘲讽、生命回复、范围劈砍
装备：巨型战斧 + 熔岩重甲
==================================

-----------------------------------

========== 开始构建角色 ==========
[法师建造者] 初始化角色：寒冰法师
[法师建造者] 构建外观：法袍模型 + 蓝色特效皮肤
[法师建造者] 构建属性：HP=800 攻击=1200 防御=200
[法师建造者] 构建技能：火球术、冰锥术、法术暴击、瞬移
[法师建造者] 构建装备：烈焰法杖 + 秘法披风
========== 角色构建完成 ==========

========== 角色配置完成 ==========
角色名称：寒冰法师
角色类型：爆发法师
外观：法袍模型 + 蓝色特效皮肤
属性：HP=800 | 攻击=1200 | 防御=200
技能：火球术、冰锥术、法术暴击、瞬移
装备：烈焰法杖 + 秘法披风
==================================

四、Unity场景扩展（贴合实际开发）

1. 新增角色类型（刺客）

建造者模式扩展新角色极便捷，仅需新增具体建造者，无需修改指挥者和原有代码：

/// <summary>
/// 新增具体建造者：刺客建造者（高攻速、隐身技能）
/// </summary>
public class AssassinBuilder : ICharacterBuilder
{
    private GameCharacter _character = new GameCharacter();

    public void InitBaseInfo(string name)
    {
        _character.Name = name;
        _character.RoleType = "敏捷刺客";
    }

    public void BuildAppearance() => _character.Appearance = "潜行模型 + 黑色皮肤";
    public void BuildAttributes()
    {
        _character.Hp = 1000;
        _character.Attack = 700;
        _character.Defense = 300;
    }
    public void BuildSkills() => _character.Skills.AddRange(new[] { "隐身", "背刺", "暴击连击", "致盲" });
    public void BuildEquipment()
    {
        _character.Weapon = "淬毒匕首";
        _character.Armor = "暗影皮甲";
    }
    public GameCharacter GetResult() => _character;
}

// 客户端调用新增刺客
private void Start()
{
    // ... 原有战士/法师代码
    Debug.Log("\n-----------------------------------\n");
    ICharacterBuilder assassinBuilder = new AssassinBuilder();
    CharacterDirector assassinDirector = new CharacterDirector(assassinBuilder);
    GameCharacter assassin = assassinDirector.ConstructCharacter("影刃");
    assassin.ShowInfo();
}

2. 结合Unity预制体与资源加载

实际项目中，可在BuildAppearance方法中加载角色预制体、设置材质/特效：

public void BuildAppearance()
{
    // 加载Resources下的战士预制体
    GameObject warriorPrefab = Resources.Load<GameObject>("Prefabs/Warrior");
    if (warriorPrefab != null)
    {
        GameObject warriorObj = Instantiate(warriorPrefab, Vector3.zero, Quaternion.identity);
        // 设置皮肤材质
        Renderer renderer = warriorObj.GetComponentInChildren<Renderer>();
        renderer.material = Resources.Load<Material>("Materials/RedWarriorSkin");
        _character.Appearance = "重甲战士模型 + 红色皮肤（已加载预制体）";
    }
}

3. 动态调整构建流程（可选步骤）

指挥者可提供“精简构建”方法（比如只构建基础属性，不加载技能/装备）：

public class CharacterDirector
{
    // ... 原有代码

    /// <summary>
    /// 精简构建：仅初始化+外观+属性（用于新手角色）
    /// </summary>
    public GameCharacter ConstructSimpleCharacter(string name)
    {
        Debug.Log("\n========== 开始精简构建角色 ==========");
        _builder.InitBaseInfo(name);
        _builder.BuildAppearance();
        _builder.BuildAttributes();
        Debug.Log("========== 精简构建完成 ==========\n");
        return _builder.GetResult();
    }
}

// 客户端调用精简构建
GameCharacter noviceWarrior = warriorDirector.ConstructSimpleCharacter("新手战士");
noviceWarrior.ShowInfo(); // 技能/装备为空，仅基础信息

4. 链式调用优化（简化客户端代码）

可将建造者改为链式调用，省去指挥者（适合灵活定制步骤的场景）：

public class WarriorBuilder : ICharacterBuilder
{
    // ... 原有字段/方法

    // 链式调用扩展
    public WarriorBuilder WithName(string name)
    {
        InitBaseInfo(name);
        return this;
    }

    public WarriorBuilder WithAppearance()
    {
        BuildAppearance();
        return this;
    }

    public WarriorBuilder WithAttributes()
    {
        BuildAttributes();
        return this;
    }

    // 最终构建
    public GameCharacter Build()
    {
        return _character;
    }
}

// 客户端链式调用
GameCharacter customWarrior = new WarriorBuilder()
    .WithName("自定义战士")
    .WithAppearance()
    .WithAttributes()
    .Build();

五、建造者模式核心优势（Unity场景）

1. 分步构建，灵活定制：复杂角色的组件（外观/属性/技能）可分步构建，支持“完整构建”“精简构建”等不同流程；
2. 解耦构建与表示：客户端无需知道角色的具体构建细节，只需通过指挥者/建造者获取最终对象；
3. 复用构建流程：新增角色（刺客/射手）时，仅需新增具体建造者，指挥者的构建流程可完全复用；
4. 避免多参数构造器：相比GameCharacter的多参数构造器（如new GameCharacter("钢铁守卫", 2000, 300, 800, ...)），建造者模式更清晰、易维护。

六、建造者模式 vs 工厂模式（Unity场景对比）

建造者模式是Unity中开发“高定制化复杂对象”的首选模式，比如角色创建、关卡生成、复杂UI面板组装（包含按钮、文本、图标等多个组件）都非常适用。