Unity 组合模式（实例详解）

在Unity中，组合模式（Composite Pattern）是一种结构型设计模式，它允许你将对象组合成树形结构来表现“整体-部分”的层次结构，并且用户可以一致地处理单个对象和组合对象。下面我会提供三个简化的代码实例来说明组合模式在Unity中的应用：

示例1：Unity中的图形界面元素组合

// 抽象组件接口
public abstract class UIComponent
{
    public string Name { get; set; }
    
    public abstract void Render();
    public abstract void Add(UIComponent component);
    public abstract void Remove(UIComponent component);
}

// 叶子节点（具体组件）
public class UIButton : UIComponent
{
    private Texture2D buttonTexture;

    // 构造函数等...

    public override void Render()
    {
        GUI.DrawTexture(new Rect(0, 0, buttonSize.x, buttonSize.y), buttonTexture);
    }

    // 叶子节点不支持添加或删除子组件
    public override void Add(UIComponent component) {}
    public override void Remove(UIComponent component) {}
}

// 组合节点（容器组件）
public class UIMenu : UIComponent
{
    private List<UIComponent> components = new List<UIComponent>();

    public override void Render()
    {
        foreach (var component in components)
            component.Render();
    }

    public override void Add(UIComponent component)
    {
        components.Add(component);
    }

    public override void Remove(UIComponent component)
    {
        components.Remove(component);
    }
}

// 使用示例：
var menu = new UIMenu("MainMenu");
menu.Add(new UIButton("Button1"));
menu.Add(new UIButton("Button2"));

// 渲染整个菜单及其包含的所有按钮
menu.Render();

示例2：Unity中的游戏对象层级组合

// 抽象的游戏对象类
public abstract class GameObjectComposite
{
    public string Name { get; set; }
    protected List<GameObjectComposite> children = new List<GameObjectComposite>();

    public virtual void Update() 
    {
        foreach (var child in children)
            child.Update();
    }

    public void Add(GameObjectComposite obj)
    {
        children.Add(obj);
    }

    public void Remove(GameObjectComposite obj)
    {
        children.Remove(obj);
    }
}

// 具体的游戏对象叶子节点
public class GameObjectLeaf : GameObjectComposite
{
    public override void Update()
    {
        // 实现叶子节点的更新逻辑，如移动、动画播放等
    }
}

// 具体的游戏对象容器节点
public class GameObjectGroup : GameObjectComposite
{
    // 可能会有额外的方法和属性用于管理子对象
    // ...

    public override void Update()
    {
        base.Update();
        // 实现容器节点自身的更新逻辑
    }
}

// 使用示例：
var group = new GameObjectGroup("Enemies");
group.Add(new GameObjectLeaf("Enemy1"));
group.Add(new GameObjectLeaf("Enemy2"));

// 更新所有敌人
group.Update();

示例3：Unity中的场景图节点组合

// 抽象场景图节点接口
public abstract class SceneNode
{
    public string Name { get; set; }
    protected List<SceneNode>childNodes = new List<SceneNode>();

    public abstract void Draw();

    public void AddChild(SceneNode node)
    {
        childNodes.Add(node);
    }

    public void RemoveChild(SceneNode node)
    {
        childNodes.Remove(node);
    }
}

// 叶子节点：一个具体的3D模型
public class ModelNode : SceneNode
{
    public MeshRenderer Renderer { get; private set; }

    public ModelNode(MeshFilter meshFilter, MeshRenderer renderer)
    {
        Renderer = renderer;
        // 初始化其他必要组件...
    }

    public override void Draw()
    {
        Renderer.enabled = true;
        // 调用渲染方法或其他绘制逻辑
    }
}

// 容器节点：一个场景图分支
public class GroupNode : SceneNode
{
    public override void Draw()
    {
        foreach (var node in childNodes)
            node.Draw();
    }
}

// 使用示例：
var groupNode = new GroupNode("BuildingParts");
groupNode.AddChild(new ModelNode(meshFilter1, renderer1));
groupNode.AddChild(new ModelNode(meshFilter2, renderer2));

// 绘制整个建筑群
groupNode.Draw();

以上每个示例都展示了如何使用组合模式来表示一个树形结构，其中抽象基类定义了对组件进行添加、移除以及执行通用操作的方法，而叶子节点和组合节点分别实现这些方法以适应各自的具体功能。

python推荐学习汇总连接：
50个开发必备的Python经典脚本(1-10)

50个开发必备的Python经典脚本(11-20)

50个开发必备的Python经典脚本(21-30)

50个开发必备的Python经典脚本(31-40)

50个开发必备的Python经典脚本(41-50)
————————————————

​最后我们放松一下眼睛