unity消息机制

最新推荐文章于 2023-04-10 11:21:33 发布
转载 最新推荐文章于 2023-04-10 11:21:33 发布 · 475 阅读 · 0
文章标签：

#c# unity 

using UnityEngine;
using System.Collections;

/// <summary>
/// 消息监听接口
/// </summary>
public interface IEventListener   
{
    /// <summary>
    /// 处理消息
    /// </summary>
    /// <param name="id">消息Id</param>
    /// <param name="param1">参数1</param>
    /// <param name="param2">参数2</param>
    /// <returns>是否终止消息派发</returns>
    bool HandleEvent(int id, object param1, object param2);

    /// <summary>
    /// 消息优先级
    /// </summary>
    /// <returns></returns>
    int EventPriority();
}
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
using UnityEngine;
using System.Collections;
using System.Collections.Generic;

public class EventNode : MonoBehaviour
{
    /// <summary>
    /// 节点优先级
    /// </summary>
    public int EventNodePriority { set; get; }

    /// <summary>
    /// 所有消息集合
    /// </summary>
    private Dictionary<int, List<IEventListener>> mListeners = new Dictionary<int, List<IEventListener>>();

    /// <summary>
    /// 消息节点
    /// </summary>
    private List<EventNode> mNodeList = new List<EventNode>();

    /// <summary>
    /// 挂载一个消息节点到当前节点上
    /// </summary>
    /// <param name="node">消息节点</param>
    /// <returns>如果当前节点里面已经包含要添加的这个节点那么返回false</returns>
    public bool AttachEventNode(EventNode node)
    {
        if (node == null)
        {
            return false;
        }

        if (mNodeList.Contains(node))
        {
            return false;
        }
        int pos = 0;
        for (int i = 0; i < mNodeList.Count;i++ )
        {
            if (node.EventNodePriority > mNodeList[i].EventNodePriority)
            {
                break;
            }
            pos++;
        }

        mNodeList.Insert(pos,node);
        return true;
    }

    /// <summary>
    /// 卸载一个消息节点
    /// </summary>
    /// <param name="node">消息节点</param>
    /// <returns>如果节点不存在那么返回false</returns>
    public bool DetachEventNode(EventNode node)
    {
        if (!mNodeList.Contains(node))
        {
            return false;
        }
        mNodeList.Remove(node);
        return true;
    }

    /// <summary>
    /// 挂载一个消息监听器到当前的消息节点
    /// </summary>
    /// <param name="key">消息ID</param>
    /// <param name="listener">消息监听器</param>
    /// <returns>当前消息节点已经挂载了这个消息监听器那么返回false</returns>
    public bool AttachEventListener(int key,IEventListener listener)
    {
        if (listener == null)
        {
            return false;
        }
        if (!mListeners.ContainsKey(key))
        {
            mListeners.Add(key,new List<IEventListener>() { listener });
            return true;
        }
        if (mListeners[key].Contains(listener))
        {
            return false;
        }
        int pos = 0;
        for (int i = 0;i< mListeners[key].Count;i++ )
        {
            if (listener.EventPriority() > mListeners[key][i].EventPriority())
            {
                break;
            }
            pos++;
        }
        mListeners[key].Insert(pos,listener);
        return true;
    }

    /// <summary>
    /// 卸载一个消息节点
    /// </summary>
    /// <returns>如果当前消息节点不存在那么返回false</returns>
    public bool DetachEventListener(int key,IEventListener listener)
    {
       if (mListeners.ContainsKey(key) && mListeners[key].Contains(listener))
       {
           mListeners[key].Remove(listener);
           return true;
       }
       return false;
    }

    public void SendEvent(int key,object param1 = null,object param2 = null)
    {
        DispatchEvent(key, param1, param2);
    }

    /// <summary>
    /// 派发消息到子消息节点以及自己节点下的监听器上
    /// </summary>
    /// <param name="key">消息ID</param>
    /// <param name="param1"></param>
    /// <param name="param2"></param>
    /// <returns>如果中断消息返回true</returns>
    private bool DispatchEvent(int key,object param1,object param2)
    {
        for (int i = 0; i < mNodeList.Count;i++ )
        {
            if (mNodeList[i].DispatchEvent(key, param1, param2)) return true;
        }
        return TriggerEvent(key, param1, param2);
    }


    /// <summary>
    /// 消息触发
    /// </summary>
    /// <param name="key">消息id</param>
    /// <param name="param1"></param>
    /// <param name="param2"></param>
    /// <returns>是否中断</returns>
    private bool TriggerEvent(int key,object param1,object param2)
    {
        if (!this.gameObject.activeSelf || !this.gameObject.activeInHierarchy || !this.enabled)
        {
            return false;
        }

        if (!mListeners.ContainsKey(key))
        {
            return false;
        }
        List<IEventListener> listeners = mListeners[key];
        for (int i = 0; i < listeners.Count; i++)
        {
            if (listeners[i].HandleEvent(key, param1, param2)) return true;
        }
        return false;
    }

   void OnApplicationQuit()
    {
        mListeners.Clear();
        mNodeList.Clear();
    }

}
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169

测试：

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

public class EventDef
{
    public const int EventTest1 = 1;
    public const int EventTest2 = EventTest1 + 1;


    public const int ResLoadFinish = 1000;

}

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
using UnityEngine;
using System.Collections;

public class EventListener : MonoBehaviour,IEventListener 
{
    // Awake is called when the script instance is being loaded.
    void Awake() 
    {
        if (EventNodeCore.Instance)
        {
            EventNodeCore.Instance.AttachEventListener(EventDef.EventTest1, this);
        }
    }

    void OnDestroy()
    {
        if (EventNodeCore.Instance)
        {
            EventNodeCore.Instance.DetachEventListener(EventDef.EventTest1, this);
        }
    }
    public bool HandleEvent(int id, object param1, object param2)
    {
        Debug.Log("EventListener.HandleEvent =>" + " id=" + id + "param1=" + param1);
        switch(id)
        {
            case EventDef.EventTest1:
                Debug.Log(this.name + "=>" + "HandleEvent EventTest1");
                return false;
        }
        return false;
    }

    public int EventPriority()
    {
        return 0;
    }
}

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
using UnityEngine;
using System.Collections;

public class EventListener1 : MonoBehaviour , IEventListener
{
    // Awake is called when the script instance is being loaded.
    void Awake() 
    {
        if (EventNode1.Instance)
        {
            EventNode1.Instance.AttachEventListener(EventDef.EventTest1, this);
            EventNode1.Instance.AttachEventListener(EventDef.EventTest2, this);
        }
    }
    void OnDestroy()
    {
        if (EventNode1.Instance)
        {
            EventNode1.Instance.DetachEventListener(EventDef.EventTest1, this);
            EventNode1.Instance.DetachEventListener(EventDef.EventTest2, this);
        }
    }
    // Start is called on the frame when a script is enabled just before any of the Update methods is called the first time.
    void Start()
    {
    }

    // Update is called every frame, if the MonoBehaviour is enabled.
    void Update() 
    {
    }

    public bool HandleEvent(int id, object param1, object param2)
    {
        Debug.Log("EventListener1." + "HandleEvent => id =" + id + " param1=" + param1);
        //return true 消息中断
        return false;
    }

    public int EventPriority()
    {
        return 1;
    }
}

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
using UnityEngine;
using System.Collections;

public class EventListener2 : MonoBehaviour,IEventListener 
{
    // Awake is called when the script instance is being loaded.
    void Awake() 
    {
        if (EventNode2.Instance)
        {
            EventNode2.Instance.AttachEventListener(EventDef.EventTest1, this);
        }
    }

    void OnDestroy()
    {
        if (EventNode2.Instance)
        {
            EventNode2.Instance.DetachEventListener(EventDef.EventTest1, this);
        }
    }

    public bool HandleEvent(int id, object param1, object param2)
    {
        Debug.Log("EventListener2.HandleEvent => id =" + id + " param1=" + param1);
        return false;
    }

    public int EventPriority()
    {
        return 2;
    }
}

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
using UnityEngine;
using System.Collections;

public class EventNode1 : EventNode
{
    private static EventNode1 mInstance;
    public static EventNode1 Instance
    {
        get
        {
            return mInstance;
        }
    }

    void Awake()
    {
        mInstance = this;

        //base.EventNodePriority = 30;

        if (EventNodeCore.Instance)
        {
            EventNodeCore.Instance.AttachEventNode(this);
        }
        Debug.Log("-------------1");
    }

    void OnDestroy()
    {
        if (EventNodeCore.Instance)
        {
            EventNodeCore.Instance.DetachEventNode(this);
        }
    }
}

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
using UnityEngine;
using System.Collections;

public class EventNode2 : EventNode 
{
    private static EventNode2 mInstance;
    public static EventNode2 Instance
    {
        get
        {
            return mInstance;
        }
    }

    // Awake is called when the script instance is being loaded.
    void Awake() 
    {
        mInstance = this;
        base.EventNodePriority = 20;
        if (EventNodeCore.Instance)
        {
            EventNodeCore.Instance.AttachEventNode(this);
        }
    }
    void OnDestroy()
    {
        if (EventNodeCore.Instance)
        {
            EventNodeCore.Instance.DetachEventNode(this);
        }
    }


}

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
using UnityEngine;
using System.Collections;

public class EventNodeCore : EventNode
{
    private static EventNodeCore mInstance;
    public static EventNodeCore Instance
    {
        get
        {
            return mInstance;
        }

    }
    void Awake()
    {
        mInstance = this;
        Debug.Log("-------------");
    }

    void OnDestroy()
    {

    }

    void OnGUI()
    {
        if (GUI.Button(new Rect (0,0,200,50),"EventNodecore.SenEvent"))
        {
            EventNodeCore.Instance.SendEvent(EventDef.EventTest1, "测试消息发送");
        }
        if (GUI.Button(new Rect(0, 60, 200, 50), "EventNode1.SenEvent"))
        {
            EventNode1.Instance.SendEvent(EventDef.EventTest1, "测试消息发送");
            EventNode1.Instance.SendEvent(EventDef.EventTest2, "测试消息发送");
        }
        if (GUI.Button(new Rect(0, 120, 200, 50), "EventNode2.SenEvent"))
        {
            EventNode2.Instance.SendEvent(EventDef.EventTest1, "测试消息发送");
        }
    }
}

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43

转载请注明原文链接：http://blog.youkuaiyun.com/u013108312/article/details/52351826




灰色轨迹df
关注
Unity3D游戏开发框架-消息机制
Circle
08-29 1万+
转载请注明原文链接：http://blog.youkuaiyun.com/u013108312/article/details/52351826 using UnityEngine; using System.Collections;/// <summary> /// 消息监听接口 /// </summary> public interface IEventListener { /// <s
unity进阶学习笔记：消息框架
Raine_Yang的博客
05-06 2363
1 使用消息框架的目的对于小型游戏，可能不需要任何框架，而是让各个游戏脚本直接相互通信。如要实现玩家受到攻击血量减少，通过玩家控制类向血条脚本发送消息减少血量。但是这样直接通信会导致各脚本通信关系记为复杂，并且每一个脚本都和多个脚本有联系，导致维护和更新十分困难我们利用上节课讲的管理类，可以将一类脚本由一个管理类控制，如将玩家的功能放在玩家管理类下，将血条，背包等UI组件放在UI管理类下。这样要减少玩家血量，可以让玩家控制类向UI管理类发消息，然后UI管理类来改变血条。该方案对大部分小型游戏适用，但对于大型
Unity 消息发送机制 解析
weixin_34041003的博客
05-10 230
1.思考消息发送机制，也可以叫做观察者设计模式（应该是这样的）。通俗易懂点讲，就是 一个物体发出消息，另外一个，或者几个物体可以同时接收到这一消息并作出各自不同的行为（反馈，处理）。那么，首先，我们想到，需要什么？I: 我们需要的是消息（实例），发送者。 消息（实例）+发送者=我们需要的消息，就能够处理任何消息。II：怎么把这个消息发送出去（消息处理中心）。III：发送者发...
unity 简单消息机制
ztysmile的博客
06-22 654
Msg:定义消息体 public class Msg { private Dictionary<string, object> data = new Dictionary<string, object>(); /// <summary> /// 得到数据 /// </summary> /// <returns></returns> public object GetData(string key) { if (
Unity消息机制
a2217018103的博客
04-18 486
unity 消息机制 unity 消息发送机制 解析 该博客，只为解析，解析，解析，已经整理好，已经整理好，已经整理好。代码核心原理套用网上最流行的那一套，也是最常用游戏开发适用的消息机制。这里面加上自己的一些优化，极大的修正（哈哈），实测，没问题。万一要是出现问题，欢迎童鞋可以留言给我修正。 有童鞋可能会好奇，unity里面不是有自己的一套消息发送， 例如什么SendMessage，这…这个几乎...
unity3d游戏框架消息机制
11-13
Unity3d游戏框架的消息机制是其核心开发过程中不可或缺的一部分，它允许不同组件之间进行通信，实现功能的解耦合，从而提高代码的可维护性和扩展性。在Unity中，消息机制主要体现在各种事件（Event）和消息（Message...
unity 消息分发机制demo
01-23
Unity引擎中的消息分发机制是游戏开发中一个关键的概念，它允许不同的游戏对象之间进行通信，而无需直接引用对方。这种机制在很多设计模式中都有体现，如观察者模式。在Unity中，委托（Delegate）和事件（Event）是...
Unity消息订阅机制的插件
03-26
在Unity中，消息订阅机制是其组件系统的核心部分，它允许不同的游戏对象之间进行通信，而无需直接引用彼此，这种机制被称为事件或者消息系统。本插件就是针对Unity消息订阅机制的增强，旨在提供更加灵活和方便的解决...
Unity基于“消息机制”的UI框架（实体项目讲解）
qq_39038038的博客
06-27 4125
1.效果展示。2.代码结构这里定义了一个StartPanel(开始界面)，LoginPanel(登录界面)，RegisterPanel(注册界面)Framework文件夹:包含了框架所包含的工具类。UI文件夹：项目的界面操作文件。上代码：void Awake() { //注册绑定事件。 Bind(UIEvent.BEGIN_PANEL_ACTIVE); ...
unity简易消息机制
tangfei_csdn的博客
07-14 594
unity 简易消息机制
unity--消息机制
chenxl2441的博客
01-09 283
/// 1.同模块上下级之间进行访问，可用可不用，推荐不用。消息机制的一个特点是谁订阅，谁会收到消息 /// 没有订阅就不会，如果我们代码开发内容很多很复杂，那么我们后期维护不方便查找相关引用。 /// 2.跨模块访问调用管理者相关方法，可用可不用，推荐不用。因为GameManager里提供了必要的外部可访问 /// 接口方法，直接调用管理里边的方法就可以了。封装的很好，访问者不需要去认识除了G...
unity中的简易消息机制
01-26 460
MsgDispatcher.cs:  using System; using System.Collections.Generic; using UnityEngine; namespace LJFramework { public class MsgDispatcher : MonoBehaviour { static Dictionary&lt;strin...
unity消息系统机制----个人学习记录
Edision_li的博客
08-02 412
1.消息基类 using System.Collections; using System.Collections.Generic; using UnityEngine; public enum CEventType { GAME_OVER, GAME_WIN, PAUSE, GAME_DATA, } public class CBaseEvent { ...
Unity 游戏框架搭建 2017 (五) 简易消息机制
凉鞋的笔记
11-07 1228
什么是消息机制? 23333333，让我先笑一会。 为什么用消息机制? 三个字,解!!!!耦!!!!合!!!!。 我的框架中的消息机制用例: 1.接收者 Receiver.cs using UnityEngine; namespace QFramework.Example { /// <summary> ...
unity 消息机制
qq_33721227的博客
04-10 190
【代码】unity 消息机制
Unity 游戏框架搭建 (五) 简易消息机制
aasd1m的博客
12-08 874
什么是消息机制? 23333333，让我先笑一会。 为什么用消息机制?   三个字,解!!!!耦!!!!合!!!!。 我的框架中的消息机制用例: 1.接收者 [C#] 纯文本查看 复制代码 ?   01 02 03 04 05
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值