unity 消息机制

已于 2023-04-11 15:55:55 修改
阅读量137 收藏
点赞数 1
文章标签： unity c# 游戏引擎
于 2023-04-10 11:21:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33721227/article/details/130055888
版权 
/**
 *      Description : 委托定义
 * 
 *       Author :    Ankh
 *      
 *      CreateTime : 2021-11-13
 * 
 */
namespace Kernal
{
    public delegate void CallBack();
    public delegate void CallBack<T>(T arg1);
    public delegate void CallBack<T, X>(T arg1, X arg2);
    public delegate void CallBack<T, X, Y>(T arg1, X arg2, Y arg3);
    public delegate void CallBack<T, X, Y, Z>(T arg1, X arg2, Y arg3, Z arg4);
    public delegate void CallBack<T, X, Y, Z, W>(T arg1, X arg2, Y arg3, Z arg4, W arg5);
}



/**
*      Description : 事件管理中心
* 
*       Author :    Ankh
*      
*      CreateTime : 2021-11-13
* 
*/

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

namespace Kernal
{
    public class EventCenter
    {
        // 存放事件列表
        private static Dictionary<EventType, Delegate> m_EventTable = new Dictionary<EventType, Delegate>();

        #region 判断方法
        //  添加 判断的方法  字典是否已经注册的了相同 事件码的 回调函数
        private static bool OnAddListenering(EventType eventType, Delegate callBack)
        {
            bool isOk = true;
            if (!m_EventTable.ContainsKey(eventType))
            {
                m_EventTable.Add(eventType, null);
            }
            Delegate d = m_EventTable[eventType];
            if (d != null)
            {
                foreach (Delegate del in d.GetInvocationList())
                {
                    if (object.Equals(del, callBack))
                    {
                        isOk = false;
                        Debug.LogError(string.Format("尝试为事件 {0} 重复添加同一个脚本函数,  要添加的函数名称：{1}()", eventType, callBack.Method.Name));
                        break;
                    }
                }
                if (d.GetType() != callBack.GetType())
                {
                    isOk = false;
                    Debug.LogError(string.Format("尝试为事件{0}添加不同类型的委托，当前事件对应的委托是{1},要添加的委托类型是{2}", eventType, d.GetType(), callBack.GetType()));
                }
            }
            return isOk;
        }

        //  添加 移除的方法  字典是否 存在
        private static bool OnRemoveListenering(EventType eventType, Delegate callBack)
        {
            bool isOK = true;
            if (m_EventTable.ContainsKey(eventType))
            {
                Delegate d = m_EventTable[eventType];
                if (d == null)
                {
                   Debug.LogError(string.Format("移除监听错误,事件{0}没有对应的委托", eventType));
                   isOK = false;
                }
                else if (d.GetType() != callBack.GetType())
                {
                   Debug.LogError(string.Format("移除监听错误,尝试为事件{0}移除不同类型的委托，当前事件对应的委托是{1},要添加的委托类型是{2}", eventType, d.GetType(), callBack.GetType()));
                   isOK = false;
                }
            }
            else
            {
               Debug.LogError(string.Format("移除监听错误,没有事件码{0}", eventType));
               isOK = false;
            }
            return isOK;
        }

        // 添加 移除的方法后需要把对应的事件码移除掉
        private static void OnRemovedListenering(EventType eventType)
        {
            if (m_EventTable[eventType] == null)
            {
                m_EventTable.Remove(eventType);
            }
        }

        // 判断是否有该类型的事件
        private static bool OnBroadcasting(EventType eventType)
        {
            if (!m_EventTable.ContainsKey(eventType))
            {
               Debug.Log(string.Format("<color=#FF000>广播事件错误, {0} 类型事件为空 </color>", eventType));
               return false;
            }
            else return true;
        }
        #endregion

        #region 无参数
        public static void AddListener(EventType eventType, CallBack callBack)
        {
            if (OnAddListenering(eventType, callBack) == false) return;
            m_EventTable[eventType] = (CallBack)m_EventTable[eventType] + callBack;
        }

        public static void RemoveListener(EventType eventType, CallBack callBack)
        {
            if (OnRemoveListenering(eventType, callBack) == false) return;
            m_EventTable[eventType] = (CallBack)m_EventTable[eventType] - callBack;
            OnRemovedListenering(eventType);
        }

        public static void Broadcast(EventType eventType)
        {
            if (OnBroadcasting(eventType) == false) return;
            CallBack callBack = m_EventTable[eventType] as CallBack;
            if (callBack != null)
                callBack();
            else
               Debug.LogError(string.Format("广播事件错误, 该类型为空", eventType));
        }
        #endregion

        #region 一个参数
        public static void AddListener<T>(EventType eventType, CallBack<T> callBack)
        {
            if (OnAddListenering(eventType, callBack) == false) return;
            m_EventTable[eventType] = (CallBack<T>)m_EventTable[eventType] + callBack;
        }

        public static void RemoveListener<T>(EventType eventType, CallBack<T> callBack)
        {
            if (OnRemoveListenering(eventType, callBack) == false) return;
            m_EventTable[eventType] = (CallBack<T>)m_EventTable[eventType] - callBack;
            OnRemovedListenering(eventType);
        }

        public static void Broadcast<T>(EventType eventType, T arg)
        {
            if (OnBroadcasting(eventType) == false) return;
            CallBack<T> callBack = m_EventTable[eventType] as CallBack<T>;
            if (callBack != null)
                callBack(arg);
            else
               Debug.LogError(string.Format("广播事件错误, 事件{0}为空", eventType));
        }
        #endregion

        #region 两个参数
        public static void AddListener<T, X>(EventType eventType, CallBack<T, X> callBack)
        {
            if (OnAddListenering(eventType, callBack) == false) return;
            m_EventTable[eventType] = (CallBack<T, X>)m_EventTable[eventType] + callBack;
        }

        public static void RemoveListener<T, X>(EventType eventType, CallBack<T, X> callBack)
        {
            if (OnRemoveListenering(eventType, callBack) == false) return;
            m_EventTable[eventType] = (CallBack<T, X>)m_EventTable[eventType] - callBack;
            OnRemovedListenering(eventType);
        }

        public static void Broadcast<T, X>(EventType eventType, T arg1, X arg2)
        {
            if (OnBroadcasting(eventType) == false) return;
            CallBack<T, X> callBack = m_EventTable[eventType] as CallBack<T, X>;
            if (callBack != null)
                callBack(arg1, arg2);
            else
               Debug.LogError(string.Format("广播事件错误, 事件{0}为空", eventType));
        }
        #endregion

        #region 三个参数
        public static void AddListener<T, X, Y>(EventType eventType, CallBack<T, X, Y> callBack)
        {
            if (OnAddListenering(eventType, callBack) == false) return;
            m_EventTable[eventType] = (CallBack<T, X, Y>)m_EventTable[eventType] + callBack;
        }

        public static void RemoveListener<T, X, Y>(EventType eventType, CallBack<T, X, Y> callBack)
        {
            if (OnRemoveListenering(eventType, callBack) == false) return;
            m_EventTable[eventType] = (CallBack<T, X, Y>)m_EventTable[eventType] - callBack;
            OnRemovedListenering(eventType);
        }

        public static void Broadcast<T, X, Y>(EventType eventType, T arg1, X arg2, Y arg3)
        {
            if (OnBroadcasting(eventType) == false) return;
            CallBack<T, X, Y> callBack = m_EventTable[eventType] as CallBack<T, X, Y>;
            if (callBack != null)
                callBack(arg1, arg2, arg3);
            else
               Debug.LogError(string.Format("广播事件错误, 事件{0}为空", eventType));
        }
        #endregion

        #region 四个参数
        public static void AddListener<T, X, Y, Z>(EventType eventType, CallBack<T, X, Y, Z> callBack)
        {
            if (OnAddListenering(eventType, callBack) == false) return;
            m_EventTable[eventType] = (CallBack<T, X, Y, Z>)m_EventTable[eventType] + callBack;
        }

        public static void RemoveListener<T, X, Y, Z>(EventType eventType, CallBack<T, X, Y, Z> callBack)
        {
            if (OnRemoveListenering(eventType, callBack) == false) return;
            m_EventTable[eventType] = (CallBack<T, X, Y, Z>)m_EventTable[eventType] - callBack;
            OnRemovedListenering(eventType);
        }

        public static void Broadcast<T, X, Y, Z>(EventType eventType, T arg1, X arg2, Y arg3, Z arg4)
        {
            if (OnBroadcasting(eventType) == false) return;
            CallBack<T, X, Y, Z> callBack = m_EventTable[eventType] as CallBack<T, X, Y, Z>;
            if (callBack != null)
                callBack(arg1, arg2, arg3, arg4);
            else
               Debug.LogError(string.Format("广播事件错误, 事件{0}为空", eventType));
        }
        #endregion

        #region 五个参数
        public static void AddListener<T, X, Y, Z, W>(EventType eventType, CallBack<T, X, Y, Z, W> callBack)
        {
            if (OnAddListenering(eventType, callBack) == false) return;
            m_EventTable[eventType] = (CallBack<T, X, Y, Z, W>)m_EventTable[eventType] + callBack;
        }

        public static void RemoveListener<T, X, Y, Z, W>(EventType eventType, CallBack<T, X, Y, Z, W> callBack)
        {
            if (OnRemoveListenering(eventType, callBack) == false) return;
            m_EventTable[eventType] = (CallBack<T, X, Y, Z, W>)m_EventTable[eventType] - callBack;
            OnRemovedListenering(eventType);
        }

        public static void Broadcast<T, X, Y, Z, W>(EventType eventType, T arg1, X arg2, Y arg3, Z arg4, W arg5)
        {
            if (OnBroadcasting(eventType) == false) return;
            CallBack<T, X, Y, Z, W> callBack = m_EventTable[eventType] as CallBack<T, X, Y, Z, W>;
            if (callBack != null)
                callBack(arg1, arg2, arg3, arg4, arg5);
            else
               Debug.LogError(string.Format("广播事件错误, 事件{0}为空", eventType));
        }
        #endregion

    }
}
/**
 *      Description : 事件码
 * 
 *       Author :    Ankh
 *      
 *      CreateTime : 2021-11-13
 * 
 */

namespace Kernal
{
    public enum EventType
    {
        
    }
}

A_Ankh
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
Unity3D游戏开发框架-消息机制
Circle
08-29 1万+
转载请注明原文链接：http://blog.csdn.net/u013108312/article/details/52351826 using UnityEngine; using System.Collections;/// <summary> /// 消息监听接口 /// </summary> public interface IEventListener { /// <s
unity3d游戏框架消息机制
11-13
Unity3d游戏框架的消息机制是其核心开发过程中不可或缺的一部分，它允许不同组件之间进行通信，实现功能的解耦合，从而提高代码的可维护性和扩展性。在Unity中，消息机制主要体现在各种事件（Event）和消息（Message...
unity学习（8）——handler 游戏内部消息机制（调试与使用）
qq_27863281的博客
02-10 224
1.把（7）中的功能复现在注册界面的确定按钮上，到此为止还没有实现网络功能，不要急。第二步：给注册界面的两个input的text增加对应的tag。第一步：在RegPanelScript脚本中增加如下函数。第三步：给注册按钮的OnClick函数关联第一步中的函数。最后，测试所有程序功能都能正常运行。
Unity API学习之消息机制理论与应用
最新发布
qq_75073393的博客
06-10 777
Unity API学习之消息机制理论与应用void SendMessage(string methodName, object value = null, SendMessageOptions options = SendMessageOptions.RequireReceiver);
Unity中的消息机制
锅盖的铲屎官
06-11 3782
在游戏开发中，我们经常需要传递消息。传递消息一般有三种方法： 1. 保存对象的引用。 2. Unity 提供的 Message机制。 3. C#中的委托和事件。保存对象的引用例如手榴弹爆炸的时候， 需要获取手榴弹， 地面， 附近物体等游戏元素的对象， 然后播放爆炸特效。 这种方法是简单粗暴， 但是当项目的规模变大时， 增删改查将会变的很麻烦。 其实这是一种耦合度较高的方案。Unity
消息机制讲解
Nine_N的博客
11-25 646
Unity简易框架，使用消息机制控制脚本之间通信
Unity3D C# 基于观察者模式的全局消息机制(事件系统)
yueh0607
02-09 1548
本文将实现基于观察者模式的全局消息机制，如果喜欢请给我的博客或者点个免费的star吧项目内包含本文全部完整源码(可运行)
unity的消息收发机制(观察者模式)
地球OL重生之我是程序员
03-17 2489
using SpatialMap_SparseSpatialMap; using System; using System.Collections; using System.Collections.Generic; using System.Linq; using UnityEngine; using UnityEngine.UI; public static class EventMsgMgr { public delegate void EventFunc(params object[].
unity 消息分发机制demo
01-23
Unity引擎中的消息分发机制是游戏开发中一个关键的概念，它允许不同的游戏对象之间进行通信，而无需直接引用对方。这种机制在很多设计模式中都有体现，如观察者模式。在Unity中，委托（Delegate）和事件（Event）是...
基于MVC的消息机制
11-27
基于unity3D轻量级MVC的消息机制，可用于轻量级的开发。 也适合初中级程序猿来学习理解MVC框架。
Unity 一套消息通信框架
11-15
这种消息通信机制在游戏开发中有广泛的应用。例如，在玩家交互、场景切换、游戏状态更新等场景下，通过发送消息，各组件可以无须了解彼此的实现细节，只需关注自己关心的消息类型即可。此外，它还能支持动态插拔，...
unity事件机制
01-22
一个类在调用其他类里方法的时候，往往要用其实例，但在繁复的项目中就回变得很麻烦，这个demo或许能帮上你
unity简易消息机制
tangfei_csdn的博客
07-14 509
unity 简易消息机制
Unity ET学习笔记-一种消息机制的简单实现
qq_55042292的博客
07-06 295
一直很疑惑在ET中为什么加上特性并实现继承重写方法就可以将这条消息的实现了，记录一下简单版的实现过程。特性的意义：扫描该程序集中所有拥有特性的类调用父类中获取泛型类的函数，获得的结果暂时称其为组件类型将组件类型与该类绑定，加入字典通过组件类型找到对应类，调用对应类的接口函数，在该类中接口函数实现我们的重写方法代码：...
[Unity] C#使用委托和事件实现Unity消息中心（观察者模式）
m0_51776409的博客
08-03 2893
最近在学习ue的gameplay框架设计和设计模式，再回过头看一下自己过去一年写的unity项目框架（屎山）代码，感慨良多。体会到了做游戏写脚本，语言语法只是表层功夫，学会它可以让游戏跑起来。走多远的关键，还是在数据结构/算法/设计模式的内功。过去一年，自己也看了很多unity教程，国内unity开发社区还是挺活跃的，新手阶段能在网上找到各种各样的教程。但学会教程≠会做项目，实践才是检验真理的第一出路。......
UnityC# 实现简易消息机制与对耦合的思考
yueh0607
09-20 2304
藕这种东西大家都听说过吧？耦合就是像耦一样的东西…短路3s…我们在编写代码时应该，但是我们不期待完全解耦，这是不现实的，过于严重的解耦会导致代码割裂而散乱，我们追求”。耦合性：也称块间联系。指软件系统结构中各模度块间相互联系紧密程度的一种度量。模块之问间联系越紧密，其耦合性就越答强，模块的独立性则越差。来自 https://blog.csdn.net/qq_39736982/article/details/81478176。
Unity 消息发送机制 解析
weixin_34041003的博客
05-10 178
1.思考消息发送机制，也可以叫做观察者设计模式（应该是这样的）。通俗易懂点讲，就是 一个物体发出消息，另外一个，或者几个物体可以同时接收到这一消息并作出各自不同的行为（反馈，处理）。那么，首先，我们想到，需要什么？I: 我们需要的是消息（实例），发送者。 消息（实例）+发送者=我们需要的消息，就能够处理任何消息。II：怎么把这个消息发送出去（消息处理中心）。III：发送者发...
unity中的简易消息机制
01-26 408
MsgDispatcher.cs:  using System; using System.Collections.Generic; using UnityEngine; namespace LJFramework { public class MsgDispatcher : MonoBehaviour { static Dictionary&lt;strin...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

A_Ankh

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值