Unity游戏开发之设计模式之事件分发系统

最新推荐文章于 2024-03-10 12:04:53 发布
最新推荐文章于 2024-03-10 12:04:53 发布
阅读量1.4k 收藏 11
点赞数 2
分类专栏： unity游戏开发 设计模式 文章标签： unity游戏开发 设计模式 csdn
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42422809/article/details/84886730
版权

Unity游戏开发 — 事件系统

记得刚刚毕业时候，上班的第一天，主程就给我讲了游戏开发中最常见的几种设计模式，当时听得一头雾水。只知道事件分发，事件监听，事件注册。那么到底是怎么实现的呢？下面我们慢慢的揭开它。

  1. 先了解一下什么是委托。这是C#基础，这里就不在陈述了。

  2. 了解什么观察者模式。简单的说：就是完美的将观察者和被观察的对象分离开，观察者设计模式定义了对象间的一种一对多的组合关系，以便一个对象的状态发生变化时，所有依赖于它的对象都得到通知并自动刷新。

游戏事件系统

unity的事件系统就是根据上面的组合现实的。

  1. 添加事件注册`
 private void AddDelegate(int evt, Delegate listener)
  {
      Delegate value;
      if (!listeners.TryGetValue(evt, out value))
      {
          listeners.Add(evt, listener);
      }
      else
      {
          value = (value != null) ? Delegate.Combine(value, listener) : listener;
          listeners[evt] = value;
      }
  }
  1. 移除事件
private void RemoveDelegate(int evt, Delegate listener)
   {
       Delegate func;
       if (listeners.TryGetValue(evt, out func))
       {
           if (func != null)
           {
               func = Delegate.Remove(func, listener);
               listeners[evt] = func;
           }
       }
   }
  1. 事件触发
 public void DispatchEvent(int evt)
    {
        Delegate func;

        try
        {
            if (listeners.TryGetValue(evt, out func) && func != null)
            {
            	//事件触发，执行委托委托（也就是执行注册事件事的方法）
                var act = (Act)func;
                act();
            }
        }
        catch (Exception e)
        {
            UnityEngine.Debug.LogError(e.Message);
            UnityEngine.Debug.LogError(e.StackTrace);
        }
    }

基本就是上面的这三个步骤；

这是源代码

using System;
using System.Collections.Generic;

public delegate void Act();
public delegate void Act<in T>(T t1);
public delegate void Act<in T1, in T2>(T1 t1, T2 t2);
public delegate void Act<in T1, in T2, in T3>(T1 t1, T2 t2, T3 t3);
public delegate void Act<in T1, in T2, in T3, in T4>(T1 t1, T2 t2, T3 t3, T4 t4);

public delegate T Fn<out T>();
public delegate T Fn<out T, in T1>(T1 t1);
public delegate T Fn<out T, in T1, in T2>(T1 t1, T2 t2);
public delegate T Fn<out T, in T1, in T2, in T3>(T1 t1, T2 t2, T3 t3);
public delegate T Fn<out T, in T1, in T2, in T3, in T4>(T1 t1, T2 t2, T3 t3, T4 t4);

public class EventDispatcher
{
    private Dictionary<int, Delegate> listeners = new Dictionary<int, Delegate>();

    public EventDispatcher()
    {
    }

    public void ClearEventListener()
    {
        listeners.Clear();
    }

    private void AddDelegate(int evt, Delegate listener)
    {
        Delegate value;
        if (!listeners.TryGetValue(evt, out value))
        {
            listeners.Add(evt, listener);
        }
        else
        {
            value = (value != null) ? Delegate.Combine(value, listener) : listener;
            listeners[evt] = value;
        }
    }

    private void RemoveDelegate(int evt, Delegate listener)
    {
        Delegate func;
        if (listeners.TryGetValue(evt, out func))
        {
            if (func != null)
            {
                func = Delegate.Remove(func, listener);
                listeners[evt] = func;
            }
        }
    }

    public void Regist(int evt, Act listener)
    {
        if (listener == null)
        {
            return;
        }

        AddDelegate(evt, listener);
    }

    public void UnRegist(int evt, Act listener)
    {
        if (listener == null)
        {
            return;
        }

        RemoveDelegate(evt, listener);
    }

    public void DispatchEvent(int evt)
    {
        Delegate func;

        try
        {
            if (listeners.TryGetValue(evt, out func) && func != null)
            {
                var act = (Act)func;
                act();
            }
        }
        catch (Exception e)
        {
            UnityEngine.Debug.LogError(e.Message);
            UnityEngine.Debug.LogError(e.StackTrace);
        }
    }

    public void Regist<T>(int evt, Act<T> listener)
    {
        if (listener == null)
        {
            return;
        }

        AddDelegate(evt, listener);
    }

    public void UnRegist<T>(int evt, Act<T> listener)
    {
        if (listener == null)
        {
            return;
        }

        RemoveDelegate(evt, listener);
    }

    public void DispatchEvent<T1>(int evt, T1 args)
    {
        Delegate func;

        if (listeners.TryGetValue(evt, out func) && func != null)
        {
            var act = (Act<T1>)func;
            act(args);
        }
    }

    public void Regist<T1, T2>(int evt, Act<T1, T2> listener)
    {
        if (listener == null)
        {
            return;
        }

        AddDelegate(evt, listener);
    }

    public void UnRegist<T1, T2>(int evt, Act<T1, T2> listener)
    {
        if (listener == null)
        {
            return;
        }

        RemoveDelegate(evt, listener);
    }

    public void DispatchEvent<T1, T2>(int evt, T1 arg1, T2 arg2)
    {
        Delegate func;
        try
        {
            if (listeners.TryGetValue(evt, out func) && func != null)
            {
                var tmp = (Act<T1, T2>)func;
                tmp(arg1, arg2);
            }
        }
        catch (Exception e)
        {
            UnityEngine.Debug.LogError(e.Message);
            UnityEngine.Debug.LogError(e.StackTrace);
        }
    }

    public void Regist<T1, T2, T3>(int evt, Act<T1, T2, T3> listener)
    {
        if (listener == null)
        {
            return;
        }

        AddDelegate(evt, listener);
    }

    public void UnRegist<T1, T2, T3>(int evt, Act<T1, T2, T3> listener)
    {
        if (listener == null)
        {
            return;
        }

        RemoveDelegate(evt, listener);
    }

    public void DispatchEvent<T1, T2, T3>(int evt, T1 arg1, T2 arg2, T3 arg3)
    {
        Delegate func;

        try
        {
            if (listeners.TryGetValue(evt, out func) && func != null)
            {
                var tmp = (Act<T1, T2, T3>)func;
                tmp(arg1, arg2, arg3);
            }
        }
        catch (Exception e)
        {
            UnityEngine.Debug.LogError(e.Message);
            UnityEngine.Debug.LogError(e.StackTrace);
        }
    }

    public void Regist<T1, T2, T3, T4>(int evt, Act<T1, T2, T3, T4> listener)
    {
        if (listener == null)
        {
            return;
        }

        AddDelegate(evt, listener);
    }

    public void UnRegist<T1, T2, T3, T4>(int evt, Act<T1, T2, T3, T4> listener)
    {
        if (listener == null)
        {
            return;
        }

        RemoveDelegate(evt, listener);
    }

    public void DispatchEvent<T1, T2, T3, T4>(int evt, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
    {
        Delegate func;

        try
        {
            if (listeners.TryGetValue(evt, out func) && func != null)
            {
                var tmp = (Act<T1, T2, T3, T4>)func;
                tmp(arg1, arg2, arg3, arg4);
            }
        }
        catch (Exception e)
        {
            UnityEngine.Debug.LogError(e.Message);
            UnityEngine.Debug.LogError(e.StackTrace);
        }
    }

    public void RegistFn<T>(int evt, Fn<T> listener)
    {
        if (listener == null)
        {
            return;
        }

        AddDelegate(evt, listener);
    }

    public void UnRegistFn<T>(int evt, Fn<T> listener)
    {
        if (listener == null)
        {
            return;
        }

        RemoveDelegate(evt, listener);
    }

    public T DispatchEventFn<T>(int evt)
    {
        Delegate func;
        try
        {
            if (listeners.TryGetValue(evt, out func) && func != null)
            {
                var fn = (Fn<T>)func;
                return fn();
            }
        }
        catch (Exception e)
        {
            UnityEngine.Debug.LogError(e.Message);
            UnityEngine.Debug.LogError(e.StackTrace);
        }

        return default(T);
    }

    public void RegistFn<T, T1>(int evt, Fn<T, T1> listener)
    {
        if (listener == null)
        {
            return;
        }

        AddDelegate(evt, listener);
    }

    public void UnRegistFn<T, T1>(int evt, Fn<T, T1> listener)
    {
        if (listener == null)
        {
            return;
        }

        RemoveDelegate(evt, listener);
    }

    public T DispatchEventFn<T, T1>(int evt, T1 args)
    {
        Delegate func;

        try
        {
            if (listeners.TryGetValue(evt, out func) && func != null)
            {
                var tmp = (Fn<T, T1>)func;
                return tmp(args);
            }
        }
        catch (Exception e)
        {
            UnityEngine.Debug.LogError(e.Message);
            UnityEngine.Debug.LogError(e.StackTrace);
        }

        return default(T);
    }

    public void RegistFn<T, T1, T2>(int evt, Fn<T, T1, T2> listener)
    {
        if (listener == null)
        {
            return;
        }

        AddDelegate(evt, listener);
    }

    public void UnRegistFn<T, T1, T2>(int evt, Fn<T, T1, T2> listener)
    {
        if (listener == null)
        {
            return;
        }

        RemoveDelegate(evt, listener);
    }

    public T DispatchEventFn<T, T1, T2>(int evt, T1 arg1, T2 arg2)
    {
        Delegate func;

        try
        {
            if (listeners.TryGetValue(evt, out func) && func != null)
            {
                var fn = (Fn<T, T1, T2>)func;
                return fn(arg1, arg2);
            }
        }
        catch (Exception e)
        {
            UnityEngine.Debug.LogError(e.Message);
            UnityEngine.Debug.LogError(e.StackTrace);
        }

        return default(T);
    }

    public void RegistFn<T, T1, T2, T3>(int evt, Fn<T, T1, T2, T3> listener)
    {
        if (listener == null)
        {
            return;
        }

        AddDelegate(evt, listener);
    }

    public void UnRegistFn<T, T1, T2, T3>(int evt, Fn<T, T1, T2, T3> listener)
    {
        if (listener == null)
        {
            return;
        }

        RemoveDelegate(evt, listener);
    }

    public T DispatchEventFn<T, T1, T2, T3>(int evt, T1 arg1, T2 arg2, T3 arg3)
    {
        Delegate func;

        try
        {
            if (listeners.TryGetValue(evt, out func) && func != null)
            {
                var fn = (Fn<T, T1, T2, T3>)func;
                return fn(arg1, arg2, arg3);
            }
        }
        catch (Exception e)
        {
            UnityEngine.Debug.LogError(e.Message);
            UnityEngine.Debug.LogError(e.StackTrace);
        }

        return default(T);
    }

    public void RegistFn<T, T1, T2, T3, T4>(int evt, Fn<T, T1, T2, T3, T4> listener)
    {
        if (listener == null)
        {
            return;
        }

        AddDelegate(evt, listener);
    }

    public void UnRegistFn<T, T1, T2, T3, T4>(int evt, Fn<T, T1, T2, T3, T4> listener)
    {
        if (listener == null)
        {
            return;
        }
        RemoveDelegate(evt, listener);
    }

    public T DispatchEventFn<T, T1, T2, T3, T4>(int evt, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
    {
        Delegate func;
        try
        {
            if (listeners.TryGetValue(evt, out func) && func != null)
            {
                var fn = (Fn<T, T1, T2, T3, T4>)func;
                return fn(arg1, arg2, arg3, arg4);
            }
        }
        catch (Exception e)
        {
            UnityEngine.Debug.LogError(e.Message);
            UnityEngine.Debug.LogError(e.StackTrace);

        }

        return default(T);
    }

    static EventDispatcher GameWorldEventDispatcher = new EventDispatcher();

    public static EventDispatcher GameEvent
    {
        get
        {
            return GameWorldEventDispatcher;
        }
    }
}

在游戏需要调用的地方在这里插入图片描述
最后说一下在游戏退出后执行一下

 public void ClearEventListener()
    {
        listeners.Clear();
    }
XXX004
关注
  • 2
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Event-SendMessage:Unity事件分发机制，实现事件分发中心
05-21
Event-SendMessage Unity事件分发机制，实现事件分发中心 Unity5.0.1f1
Unity事件分发器
abc1090275833的博客
03-18 1011
事件分发机制也被称之为事件监听派发系统，在每个游戏框架中都是不可或缺的一个模块。起作用主要是用来解耦，监听网络消息，或者做一些异步的操作等，下面是使用C#在Unity游戏开发中的事件分发处理机制的简单实现，希望能帮到大家。 using UnityEngine; using System.Collections; using System.Collections.Generic; ...
【案例设计】事件分发器 — 实现跨类的事件响应思路分享与实现
Mr.River的博客
07-20 630
类与类之间的通讯是程序开发中经常遭遇的事。其目的是传递属性、字段等内容，以提供给另一类中的方法以执行。于是为了强化这过程，降低耦合度。出现了事件分发器（EventDispatcher）的设计。...
Unity学前C#:事件详解
最新发布
Meiko_ahri的博客
03-10 675
事件(Event):通俗的解释就是"能够发生的什么事情"，并且事件都是隶属于某一个主体的,比如公司上市,那个上市这个事件就是隶属于公司由上面的定义就可以知道,将事件抽象到代码当中就是,事件要隶属于一个类,也就是一个类的成员在前面就已经讲过:属性：让对象有了访问数据的功能方法: 让对象有了对数据加工的功能事件: 让对象有了通知能力,使对象有了能通风报信的成员。
Unity虚拟摇杆（事件分发器实现）
m0_52021450的博客
03-12 3847
目录 搭建UI 编写代码 搭建UI ①创建一个image 命名为ControlArea 作为按钮识别的检测范围 并将透明度设置为1（透明度为0不触发事件检测） ②如下图的父子关系添加 image 并命名 找到合适的素材拖给相应的image 设置合适的大小（根据自己的喜好和素材的大小自行设置） ③注意选中joystick 的 锚点（花）放到左下角 防止因为分辨率改变使得按钮位置改变 中心点（pivot）的位置设置为（0.5，0.5）如下图 实现脚本 ...
unity客户端开源框架
weixin_44192860的博客
04-04 1636
unity客户端开源框架整理.
GameFramework篇：StarForce加载UI讲解（下）
设计师养成记
01-05 1995
我们从这里开始看，可以看到这里已经给事件参数赋好值了 追踪OpenUIFormSuccessEventArgs 回到上篇博文的结尾，发现最终还是用到了我们刚开始时依据哈希值订阅的事件OpenUIFormSuccessEvent，二GameFramework.UI.OpenUIFormSuccessEventArgs是我们这篇文章开头说的打开界面成功事件，大家注意区分， 然后我们发现这...
Unity 中不同方式的事件分发和监听
weixin_42565127的博客
01-05 692
Unity 中的事件分发和监听
unity 消息分发
luyuncsd123的专栏
06-22 4581
有2种方法，第一种，封装U3D中的发消息函数，自己写一个事件机制出来。第2种，用C#内置的事件机制。 第一种方法，下面这个类是Digital-tutors出的Unity Mobile Game Development这一套教程里06.Communication with Notification Center里的事件机制类，他是用JS写的，我把这个脚本翻译成了C#的。并加了详细的中文注释。本
Unity中事件的3种实现方法
夏湾的博客
07-24 3858
Unity中事件的3种实现方法
Unity 事件派发
极客七
01-25 516
方法 功能 备注 Watcher.on 注册监听 注册一个事件监听j Watcher.off 移除监听 移除一个事件监听 Watcher.Dispatch 派发事件 广播事件 前言: 由事件类和监听接口组成 自定义一个事件前，必须提供一个事件的监听方法以及一个事件标签。 好处: 各个模块专心的做自己的事情，不需要过问其他模块的事情 解耦 代码部分~ using System; using System.Col...
Unity—事件
m0_63330263的博客
01-13 1349
事件是委托类型字段的包装器、限制器，限制外界对委托类型字段的访问，委托类型字段通过事件包装、限制后，外界只能去访问它的+=、-=操作符（添加/移除事件处理器），提供了与之匹配的事件的事件处理器，能够记录、引用方法的这个任务，只有。事件不能在外部直接调用，只有事件的拥有者通过某些内部逻辑才能触发。并且会去使用委托类型的实例去储存方法的引用，去储存 事件处理器。//声明委托类型的字段，将会去存储，引用副委员的事件处理器。/为什么事件是基于委托的?+=事件响应者的事件处理器（来订阅OnOrder事件）
事件分发机制--unity碰撞器的使用
12-28
对于事件分发机制的使用，当碰到物体时，会集中调用事件
unity 消息分发机制demo
01-23
使用委托与事件机制实现 Unity消息分发机制，此文件是一个unitypackage类型，可直接运行，unity版本号是5.6.1
unity游戏开发之高仿原神主界面操作
10-30
资源详细情况：https://blog.csdn.net/lj820348789/article/details/121049215 在Unity 2018.4.36f1 (64-bit)上开发，建议在2018及以上版本的unity上运行
设计模式与游戏完美开发
07-06
设计模式与游戏完美开发 设计模式与游戏完美开发 设计模式与游戏完美开发 设计模式与游戏完美开发 设计模式与游戏完美开发 设计模式与游戏完美开发 设计模式与游戏完美开发 设计模式与游戏完美开发 设计模式与游戏...
Unity3D游戏开发之定义统一的对象搜索接口.pdf
11-30
Unity3D游戏开发之定义统一的对象搜索接口.pdf
iOS游戏开发之Unity3D引擎系列
07-23
资源名称：iOS游戏开发之Unity3D引擎系列资源目录：【】Unity3D 游戏引擎之IOS自定义游戏摇杆与飞机平滑的移动【】Unity3D 游戏引擎之IOS触摸屏手势控制镜头旋转与缩放【】Unity3D 游戏引擎之IOS高级界面发送消息...
unity3d游戏开发
01-20
unity3d游戏开发 unity3d游戏开发 unity3d游戏开发 unity3d游戏开发 unity3d游戏开发 unity3d游戏开发 unity3d游戏开发 unity3d游戏开发 unity3d游戏开发 unity3d游戏开发 unity3d游戏开发 unity3d游戏开发 ...
unity游戏开发之高仿原神
05-13
Unity是一款跨平台的游戏引擎，为游戏开发者提供了强大的开发工具和灵活的开发环境，使得游戏开发变得更加快捷和高效。而高仿原神是一款目前非常受欢迎的游戏，它提供了独特的画面、丰富的游戏性和深入的剧情，让...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值