设计模式-状态模式与中介者模式应用一例

状态模式-中介者模式应用一例

设计模式目录

相关模式：

• 状态模式
• 中介者模式

说明

使用中介者模式来连接状态的改变和对3D物体的操作；
对状态模式代码进行了一些改动：

• 在基础状态接口内增加了下列三个方法

 	public abstract void StateBegin();//状态开始时
    public abstract void StateEnd();//状态结束时
    public abstract void StateUpdate();//处于此状态时需持续更新内容

• 将改变状态方法进行下列相应改动

 //改变状态
public void ChangeState(State_Plus settingState)
{
     if (settingState == m_currentState)//若状态未改变直接跳转出函数体
                return;
     if (m_currentState != null)
         m_currentState.StateEnd();
     m_currentState = settingState;
     m_currentState.StateBegin();
}

• 增加一个下列方法，该函数在此例中于unity的mono中的Update()中调用

//持续更新，此函数需要在持续运行函数中调用
public void Update()
{
    m_currentState.StateUpdate();
}

在unity中运行方法

• 在场景中创建一个3D对象

• 在Project面版中创建一个材质球

• 将材质球及下面的脚本添加到创建的3D物体上

运行过程及结果

运行之后将得到一个初始的红色3D物体；
按下对应的按钮会切换对应的状态及改变3D物体的颜色：
三个按钮分别为R，G，B对应三种状态及三种颜色；
Console控制台也会打印对应的状态信息；

代码

在unity环境下编写运行

using System;
using System.Collections.Generic;
using UnityEngine;
namespace ZhhDesignPattern
{
    #region 单元测试代码
    public class State_Plus_UnitTest : MonoBehaviour
    {
        public Mediator_Plus_State m_mediator;//中介者
        public GameObjHandle m_gobj_handle;//对游戏对象的处理
        public StateContext m_context;//状态拥有者()

        void Awake()
        {
            m_mediator = new Mediator_Plus_State();
            m_gobj_handle = new GameObjHandle(gameObject, m_mediator);
            m_context = new StateContext(m_mediator);
            m_mediator.InitialColleague(m_context, m_gobj_handle);
        }

        void Start()
        {

        }

        void Update()
        {
            m_context.Update();
        }
    }
    #endregion

    #region 中介者模式相关代码
    //中介者接口类
    public abstract class Mediator_Plus
    {
        public abstract void SendMsg(State_Handle_Color type, Color color);
    }

    //中介者实现类
    public class Mediator_Plus_State : Mediator_Plus
    {
        public IColleague_Plus m_state_color = null;
        public IColleague_Plus m_gobj_handle = null;

        public Mediator_Plus_State()
        {
        }

        public void InitialColleague(StateContext state_color, GameObjHandle gobj_handle)
        {
            m_state_color = state_color;
            m_gobj_handle = gobj_handle;
        }

        public override void SendMsg(State_Handle_Color type, Color color)
        {
            switch (type)
            {
                case State_Handle_Color.Change_Color:
                    m_gobj_handle.Request(color);
                    break;
                default:
                    break;
            }
        }
    }

    //处理方式枚举
    public enum State_Handle_Color
    {
        Change_Color,
    }

    //中介者模式中同事接口
    public interface IColleague_Plus
    {
        Mediator_Plus Mediator { get; set; }

        void Request(Color color);
    }
    #endregion

    #region unity处理代码段
    //对游戏物体的处理
    public class GameObjHandle : IColleague_Plus
    {
        public GameObjHandle(GameObject obj, Mediator_Plus mediator)
        {
            m_obj_sphere = obj;
            m_meshRender = obj.GetComponent<MeshRenderer>();
            Mediator = mediator;
        }

        public GameObject m_obj_sphere;//要进行改变的游戏物体
        private MeshRenderer m_meshRender;//游戏物体的渲染组件

        private Mediator_Plus mediator;
        public Mediator_Plus Mediator//中介者对象
        {
            get
            {
                return mediator;
            }
            set
            {
                mediator = value;
            }
        }
        //改变物体的颜色
        private void SetMaterialColor(Color settingColor)
        {
            m_meshRender.material.color = settingColor;
        }

        public void Request(Color color)
        {
            SetMaterialColor(color);
        }
    }
    #endregion


    #region 状态模式主要代码
    //状态拥有者
    public class StateContext : IColleague_Plus
    {
        public State_Plus m_currentState;//当前状态
        public Dictionary<State_Color_Name, State_Plus> m_allState;//拥有的所有状态

        private Mediator_Plus medator;
        public Mediator_Plus Mediator
        {
            get
            {
                return medator;
            }
            set
            {
                medator = value;
            }
        }

        public StateContext(Mediator_Plus medator)
        {
            Mediator = medator;
            m_allState = new Dictionary<State_Color_Name, State_Plus>();
            m_allState.Add(State_Color_Name.State_Red, new ConcreteStateP_R(this));
            m_allState.Add(State_Color_Name.State_Green, new ConcreteStateP_G(this));
            m_allState.Add(State_Color_Name.State_Blue, new ConcreteStateP_B(this));
            //ChangeState(m_allState[State_Color_Name.State_Red]);//设定一个初始状态.
            m_currentState = m_allState[State_Color_Name.State_Red];
        }

        //改变状态
        public void ChangeState(State_Plus settingState)
        {
            if (settingState == m_currentState)//若状态未改变直接跳转出函数体
                return;
            if (m_currentState != null)
                m_currentState.StateEnd();
            m_currentState = settingState;
            m_currentState.StateBegin();
        }

        //持续更新，此函数需要在持续运行函数中调用
        public void Update()
        {
            m_currentState.StateUpdate();
        }

        public void Request(Color color)
        {
            throw new NotImplementedException();
        }
    }

    //状态接口类
    public abstract class State_Plus
    {

        public State_Plus(StateContext context)
        {
            m_context = context;
        }

        public StateContext m_context;//状态拥有者
        public abstract void StateBegin();//状态开始时
        public abstract void StateEnd();//状态结束时
        public abstract void StateUpdate();//处于此状态时需持续更新内容
    }

    //具体状态A
    public class ConcreteStateP_R : State_Plus
    {
        public ConcreteStateP_R(StateContext context) : base(context)
        {
        }

        public override void StateBegin()
        {
            Debug.Log("进入状态R");
            m_context.Mediator.SendMsg(State_Handle_Color.Change_Color, new Color(1, 0, 0));
        }

        public override void StateEnd()
        {
            Debug.Log("退出状态R");
        }

        public override void StateUpdate()
        {

            if (Input.GetKeyDown(KeyCode.R))
            {
                Debug.Log("当前处于R状态");
            }
            if (Input.GetKeyDown(KeyCode.G))
            {
                m_context.ChangeState(m_context.m_allState[State_Color_Name.State_Green]);
            }
            if (Input.GetKeyDown(KeyCode.B))
            {
                m_context.ChangeState(m_context.m_allState[State_Color_Name.State_Blue]);
            }
        }
    }

    //具体状态B
    public class ConcreteStateP_B : State_Plus
    {
        public ConcreteStateP_B(StateContext context) : base(context)
        {
        }

        public override void StateBegin()
        {
            Debug.Log("进入状态B");
            m_context.Mediator.SendMsg(State_Handle_Color.Change_Color, new Color(0, 0, 1));
        }

        public override void StateEnd()
        {
            Debug.Log("退出状态B");
        }

        public override void StateUpdate()
        {
            if (Input.GetKeyDown(KeyCode.R))
            {
                m_context.ChangeState(m_context.m_allState[State_Color_Name.State_Red]);
            }
            if (Input.GetKeyDown(KeyCode.G))
            {
                m_context.ChangeState(m_context.m_allState[State_Color_Name.State_Green]);
            }
            if (Input.GetKeyDown(KeyCode.B))
            {
                Debug.Log("当前处于B状态");
            }
        }
    }

    //具体状态C
    public class ConcreteStateP_G : State_Plus
    {
        public ConcreteStateP_G(StateContext context) : base(context)
        {
        }

        public override void StateBegin()
        {
            //TODO
            Debug.Log("进入状态G");
            m_context.Mediator.SendMsg(State_Handle_Color.Change_Color, new Color(0, 1, 0));
        }

        public override void StateEnd()
        {
            Debug.Log("退出状态G");
        }

        public override void StateUpdate()
        {
            if (Input.GetKeyDown(KeyCode.R))
            {
                m_context.ChangeState(m_context.m_allState[State_Color_Name.State_Red]);
            }
            if (Input.GetKeyDown(KeyCode.G))
            {
                Debug.Log("当前处于G状态");
            }
            if (Input.GetKeyDown(KeyCode.B))
            {
                m_context.ChangeState(m_context.m_allState[State_Color_Name.State_Blue]);
            }
        }
    }

    public enum State_Color_Name//状态名枚举
    {
        State_Red,
        State_Blue,
        State_Green,
    }
    #endregion
}