游戏前端开发的必要设计--观察者模式的应用

我们都知道观察者模式吧，它非常有用，是游戏开发中的必备设计。 

游戏开发设计，尤其是在前端开发中观察者模式是一个非常有用的设计。在这里我所讲的观察者模式不同于教科书上。

这里我把观察者和发布者结合，两者并存于一体。这样的一个设计使得他可以完整的模拟现实中的对象和对象之间的所有交互。

下面是C#语言版本的实现。

 Actor.cs 这个类用于提供数据的发送和接收

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
/// <summary>
/// 信号接收者处理各自逻辑的回调
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="signal"></param>
public delegate void OnSignalHandler<T>(Signal<T> signal);
/// <summary>
/// 用于实现观察者和主题发布者
/// instance.Add()添加感兴趣的主题并对应处理
/// instance.Send()发送主题
/// 解耦发送者和接受者之间的强引用关系
/// 达到数据通信之间的弱关系
/// 达到高维护性的目的
/// </summary>
public class Actor
{
    /// <summary>
    /// 信号字典
    /// </summary>
    private Dictionary<Enum, Delegate> signalDict = new Dictionary<Enum, Delegate>(); 
    /// <summary>
    /// 管理器
    /// </summary>
    private ActorManager actorManager = ActorManager.GetInstance();
    /// <summary>
    /// 发送者
    /// </summary>
    private object target = null;
    /// <summary>
    /// 生命状态控制
    /// </summary>
    private byte lifeCondition = 1;//1:awake 0;sleep
    /// <summary>
    /// 缺省状态下 target==null
    /// </summary>
    public Actor()
    {

    }
    /// <summary>
    /// 可选 target 用于需要
    /// </summary>
    /// <param name="target"></param>
    public Actor(object target)
    {
        this.target = target;
    }
    /// <summary>
    /// 不可手动调用
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="type"></param>
    /// <param name="signal"></param>
    public void handler<T>(Enum type, Signal<T> signal)
    {
        if (lifeCondition == 0) return;
        if (signalDict.ContainsKey(type))
        {
            OnSignalHandler<T> caller = signalDict[type] as OnSignalHandler<T>;
            if (caller != null)
            {
                caller(signal);
            }
        }
    }
    /// <summary>
    /// 添加关注
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="type"></param>
    /// <param name="caller"></param>
    public void Add<T>(Enum type, OnSignalHandler<T> caller)
    {
        this.signalDict.Add(type, caller);
        this.actorManager.Add(type, this);
    }
    /// <summary>
    /// 移除关注
    /// </summary>
    /// <param name="type"></param>
    public void Remove(Enum type)
    {
        this.signalDict.Remove(type);
        this.actorManager.Remove(type, this);
    }

    /// <summary>
    /// 移除全部
    /// </summary>
    public void RemoveAll()
    {        
        Dictionary<Enum, Delegate>.KeyCollection keys = this.signalDict.Keys;
        Enum[] tempArr = new Enum[keys.Count];
        keys.CopyTo(tempArr, 0);
        foreach (Enum key in tempArr)
        {
            Remove(key);
        }            
    }
    /// <summary>
    /// 发送信号
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="type"></param>
    /// <param name="obj"></param>
    public void Send<T>(Enum type, T obj)
    {
        Signal<T> data = new Signal<T>(obj);     
        data.type = type;
        data.target = target == null ? this : target;
        actorManager.Send<T>(type, data);
    }
    /// <summary>
    /// 唤醒状态
    /// </summary>
    public void Awake()
    {
        lifeCondition = 1;
    }
    /// <summary>
    /// 休眠状态
    /// </summary>
    public void Sleep()
    {
        lifeCondition = 0;
    }
    public void Destory()
    {
        this.RemoveAll();
        this.actorManager = null;
        this.signalDict = null;
        this.target = null;
    }
}

 

 

 

 ActorManager.cs 这个类管理所有的Actor

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using System.Collections;


public class ActorManager
{
    private Dictionary<Enum, List<Actor>> signalDict;
    private static ActorManager ins;
    private ActorManager()
    {        
        signalDict = new Dictionary<Enum, List<Actor>>();
    }
    /// <summary>
    /// 添加actor的信号类型
    /// </summary>
    /// <param name="type"></param>
    /// <param name="observer"></param>
    public void Add(Enum type, Actor observer)
    {
        List<Actor> obsers;
        if (this.signalDict.ContainsKey(type))
        {
            obsers = this.signalDict[type] as List<Actor>;
            if (!obsers.Contains(observer))
                obsers.Add(observer);
        }
        else
        {
            obsers = new List<Actor>();
            this.signalDict.Add(type, obsers);
            obsers.Add(observer);
        }
    }
    /// <summary>
    /// 移除指定的actor的信号类型
    /// </summary>
    /// <param name="type"></param>
    /// <param name="observer"></param>
    public void Remove(Enum type, Actor observer)
    {
        List<Actor> obsers;
        if (this.signalDict.ContainsKey(type))
        {
            obsers = this.signalDict[type] as List<Actor>;
            if(obsers.Contains(observer))
                obsers.Remove(observer);
        }
    }
    /// <summary>
    /// 单例 获得
    /// </summary>
    /// <returns></returns>
    public static ActorManager GetInstance()
    {
        if (null == ins)
            ins = new ActorManager();
        return ins;
    }
    /// <summary>
    /// 发送信号数据
    /// </summary>
    /// <param name="type"></param>
    /// <param name="data"></param>
    public void Send<T>(Enum type, Signal<T> data)
    {
        if (this.signalDict.ContainsKey(type))
        {
            List<Actor> obsers = this.signalDict[type] as List<Actor>;
            int count = obsers.Count;
            for (int i = 0; i < count; ++i)
            {
                obsers[i].handler<T>(type, data);
            }           
        }
    }   
}

 

 

 

 Signal.cs 发送数据的封装类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

/// <summary>
/// 信号数据 
/// 发送者发出去的数据包装类
/// </summary>
  
public class Signal<T>
{
    /// <summary>
    /// 信号类型
    /// </summary>
    public Enum type;
    /// <summary>
    /// 数据
    /// </summary>
    public T data;
    /// <summary>
    /// 发送者
    /// </summary>
    public object target;

    public Signal(T obj)
    {
        this.data = obj;
    }
    
    /// <summary>
    /// 类型判断
    /// </summary>
    /// <param name="type"></param>
    /// <returns></returns>
    public bool IsEqualType(Enum type)
    {
        return this.type == type;
    }
    /// <summary>
    /// 发送者判断
    /// </summary>
    /// <param name="target"></param>
    /// <returns></returns>
    public bool IsEqualTarget(object target)
    {
        return this.target == target;
    }
}

 

 

·上面的代码介绍完了。那么我们能用它来实现什么样的功能需求呢？

试想一下这么一个情景：在一个教室里有这么几个人，一个会汉语和英语的中国人，一个只会日语的日本人，一个只会讲英语的英国人，还有一个人是会他们三种语言的

语言学教授。他们在一起交流的过程中有一部分人能听懂对方而有一部分人听不懂。中国人说英语的时候会只有日本人不会有所反应，而日本人说日语的时候中国人和

英国人是听不懂的。。。。如果每个人都你一句我一句的说话，那么最后该有哪些人作出哪些正确的响应呢？

 

要解决这个问题。我们需要首先构造一个人的基类 。实现一些简单的功能，比如Talk。就是通过字符串和语言类型讲出自己的话。下面是Human类的实现：

Human.cs 这个类

using System;
using System.Collections.Generic;

/// <summary>
/// 人
/// </summary>
public class Human
{
    /// <summary>
    /// 语言类型
    /// </summary>
    public enum Language
    {
        Chinese,
        English,
        Japanese,
    }
    /// <summary>
    /// 姓名
    /// </summary>
    protected string name;
    /// <summary>
    /// Actor 实例
    /// </summary>
    protected Actor actor = new Actor();
    /// <summary>
    /// 名字构造
    /// </summary>
    /// <param name="name"></param>
    public Human(string name)
    {
        this.name = name;
    }
    /// <summary>
    /// 讲话
    /// </summary>
    /// <param name="language"></param>
    /// <param name="value"></param>
    public virtual void Talk(Enum language, string value)
    {
        System.Console.WriteLine(name + "\t 说 \t" + value);
        actor.Send<string>(language, value);
    }  
}

 中国人 像大多数天朝人民一样这个中国人也会一点英语

using System;
using System.Collections.Generic;

/// <summary>
/// 中国人
/// </summary>
public class Chinese:Human
{
    public Chinese(string name)
        : base(name)
    {
        //会中文
        actor.Add<string>(Language.Chinese, hearChineseHandler);
        //会英语
        actor.Add<string>(Language.English, heareEnglishHandler);
    }

    private void hearChineseHandler(Signal<string> signal)
    {
        System.Console.WriteLine(name + "\t 听到了\t " + signal.data);
    }

    private void heareEnglishHandler(Signal<string> signal)
    {
        System.Console.WriteLine(name + "\t 听到了\t " + signal.data);
    }
}

日本人

using System.Collections;
/// <summary>
/// 日本人
/// </summary>
public class Japanese : Human
{
    public Japanese(string name)
        : base(name)
    {
        //只会日语
        actor.Add<string>(Language.Japanese, hearJapaneseHandler);
    }

    private void hearJapaneseHandler(Signal<string> signal)
    {
        System.Console.WriteLine(name + "\t 听到了\t " + signal.data);
    }
}

英国人

using System.Collections;
/// <summary>
/// 英国人
/// </summary>
public class English : Human
{
    public English(string name)
        : base(name)
    {
        //只会英语
        actor.Add<string>(Language.English,hearEnglistHandler);
    }

    private void hearEnglistHandler(Signal<string> signal)
    {
        System.Console.WriteLine(name + "\t 听到了\t " + signal.data);
    }
}

 

语言学教授对于他来说会汉语日语英语简直太平常了

using System.Collections;
/// <summary>
/// 语言学家
/// </summary>
public class Philologer : Human
{
    public Philologer(string name)
        : base(name)
    {
        //会中文
        actor.Add<string>(Language.Chinese, hearChineseHandler);
        //会英语
        actor.Add<string>(Language.English, heareEnglishHandler);
        //会日语
        actor.Add<string>(Language.Japanese, hearJapaneseHandler);
    }


    private void hearJapaneseHandler(Signal<string> signal)
    {
        System.Console.WriteLine(name + "\t 听到了\t " + signal.data);
    }

    private void hearChineseHandler(Signal<string> signal)
    {
        System.Console.WriteLine(name + "\t 听到了\t " + signal.data);
    }

    private void heareEnglishHandler(Signal<string> signal)
    {
        System.Console.WriteLine(name + "\t 听到了\t " + signal.data);
    }
}

 

 主程序

class Program
    {        
        static void Main(string[] args)
        {
           
            Chinese chi = new Chinese("小张");
            English eng = new English("查理");
            Japanese jap = new Japanese("坂本龙马");
            Philologer phi = new Philologer("语言学叫兽");

            //test
            chi.Talk(Human.Language.Chinese, "你好");//小张 和 叫兽 能听到
            System.Console.WriteLine("--------------------------------");
            jap.Talk(Human.Language.Japanese, "斯国一");//坂本龙马 和 叫兽 能听到
            System.Console.WriteLine("--------------------------------");
            eng.Talk(Human.Language.English, "hello");//小张 查理 和 叫兽 能听到
            System.Console.WriteLine("--------------------------------");
            phi.Talk(Human.Language.English, "i am a professor");//小张 查理 和 叫兽 能听到
            System.Console.ReadKey();
        }
    }

 

 以下控制台输出了正确的结果：

 对于说话者来说他们说话的内容作为主题被发送出来，而此时的听众是观察者的角色，每一个听得懂这种主题语言的（类似于关注了这个主题的）角色都能收到对应的信息。

 同时说话者和听众的身份是并存的。每个人都可以说也都可以听。 

 我们看到语言学叫兽每次都能听到别人说话，就是因为他关注了所有语言。