游戏设计模式——中介者模式（Mediator）

中介者模式

定义：定义一个接口来封装一群对象的互动行为。中介者通过移除对象之间的引用，来减少它们之间的耦合度，并且能改变它们之间的互动性。
以运输业的运营方式来说中介者模式，可以解释为：
“设置一个物品集货中心，让所有收货点的物品都必须先集中到集货中心后，再分配出去，各集货地点之间不必知道其他集货点的位置，省去各自在货物运送上的浪费”。

中介者模式的优点

不会引入太多其他的系统：使每一个游戏系统、玩家界面对外的依赖度缩小到只有一个类
系统被依赖的程度降低：每一个游戏系统或者玩家界面，当只在一个主要的类中被调用时，后期更改只影响主要的那一个类，因此减少系统维护的难度
总结：降低系统的耦合度，提升系统的可维护性。高内聚低耦合。

中介者模式的缺点

跟状态模式的通病一样，中介者模式也面临着接口过大的风险，可使用观察者模式来解决此问题。

下面是栗子

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

namespace Leon_Mediator
{
    //用来管理Colleague物件的界面
    public abstract class Leon_Mediator
    {
        public abstract void SendMessage(Colleague theColleague, string Message);
    }

    //Meidator所控管的Colleague
    public abstract class Colleague
    {
        protected Leon_Mediator m_Mediator = null;
        public Colleague(Leon_Mediator theMediator)
        {
            m_Mediator = theMediator;
        }

        //Mediator通知请求
        public abstract void Request(string Message);
    }

    //实现Colleague的类别1
    public class ConcreteColleague1 : Colleague
    {
        public ConcreteColleague1(Leon_Mediator theMediator) : base(theMediator) { }

        //执行动作
        public void Action()
        {
            //执行后需要通知其他Colleague
            m_Mediator.SendMessage(this, "Colleague1发出通知");
        }

        //Mediator通知请求
        public override void Request(string Message)
        {
            Debug.Log("ConcreteColleague1.Request" + Message);
        }
    }

    //实现Colleague的类别2
    public class ConcreteColleague2 : Colleague
    {
        public ConcreteColleague2(Leon_Mediator theMediator) : base(theMediator) { }

        //执行动作
        public void Action()
        {
            //执行后需要通知其他Colleague
            m_Mediator.SendMessage(this, "Colleague2发出通知");
        }

        //Mediator通知请求
        public override void Request(string Message)
        {
            Debug.Log("ConcreteColleague2.Request" + Message);
        }
    }

    //实现Mediator界面，并集合管理Colleague物件
    public class ConcreteMediator : Leon_Mediator
    {
        ConcreteColleague1 m_Colleague1 = null;
        ConcreteColleague2 m_Colleague2 = null;


        public void SetColleague1(ConcreteColleague1 theColleague)
        {
            m_Colleague1 = theColleague;
        }

        public void SetColleague2(ConcreteColleague2 theColleague)
        {
            m_Colleague2 = theColleague;
        }

        //收到由Colleague通知请求
        public override void SendMessage(Colleague theColleague, string Message)
        {
            //收到Colleague1通知Colleague2
            if (m_Colleague1 == theColleague)
                m_Colleague2.Request(Message);

            //收到Colleague2通知Colleague1
            if (m_Colleague2 == theColleague)
                m_Colleague1.Request(Message);
        }
    }
}

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

public class Leon_MediatorTest : MonoBehaviour
{
    // Start is called before the first frame update
    void Start()
    {
        UnitTest();
    }

    void UnitTest()
    {
        //产生中介者
        ConcreteMediator pMediator = new ConcreteMediator();

        //产生两个Colleague
        ConcreteColleague1 pColleague1 = new ConcreteColleague1(pMediator);
        ConcreteColleague2 pColleague2 = new ConcreteColleague2(pMediator);

        //设定给中介者
        pMediator.SetColleague1(pColleague1);
        pMediator.SetColleague2(pColleague2);

        //执行
        pColleague1.Action();
        pColleague2.Action();
    }
}