Unity3D游戏开发框架-消息机制

最新推荐文章于 2024-06-12 20:06:13 发布
最新推荐文章于 2024-06-12 20:06:13 发布
阅读量440 收藏
点赞数

这里写图片描述
这里写图片描述

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, "测试消息发送");
        }
    }
}
Record_o
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
unity进阶学习笔记：消息框架
Raine_Yang的博客
05-06 1966
1 使用消息框架的目的对于小型游戏，可能不需要任何框架，而是让各个游戏脚本直接相互通信。如要实现玩家受到攻击血量减少，通过玩家控制类向血条脚本发送消息减少血量。但是这样直接通信会导致各脚本通信关系记为复杂，并且每一个脚本都和多个脚本有联系，导致维护和更新十分困难我们利用上节课讲的管理类，可以将一类脚本由一个管理类控制，如将玩家的功能放在玩家管理类下，将血条，背包等UI组件放在UI管理类下。这样要减少玩家血量，可以让玩家控制类向UI管理类发消息，然后UI管理类来改变血条。该方案对大部分小型游戏适用，但对于大型
分享Unity3d的消息机制实现
dfgjava的专栏
10-26 1万+
在mvc模式中，消息机制被广泛使用，Unity3d自带的消息机制真心不好用，像SendMessage，需要知道响应事件的物件，还需要一个响应函数的函数名字符串作为参数，如果我们有多个物件都要响应某个事件怎么办呢，或者我们不知道有哪些物件要响应事件怎么办呢，在NEGUI的工具类NGUITools中有个函数NGUITools是这么实现的 static public void Broadcast
Unity进阶第二章-消息框架（实现角色吃金币功能）
weixin_43853077的博客
07-21 1431
消息框架
Unity框架集合（持续更新）
最新发布
06-12 2443
游戏开发 引擎 CE游戏引擎-CRYENGINE UE游戏引擎-UnrealEngine Vulkan图形API游戏引擎-BansheeEngine 跨平台游戏引擎-GODOT C#开源跨平台游戏引擎-xenko 跨平台渲染框架-The-Forge Google开源跨平台基于物理的渲染引擎-filament 从零开始手敲次世代游戏引擎-GameEngineFromScratch 框架 Unity 基础框架-MyUnityFrameWork Unity 游戏框架-GameFramework Unity
U3D游戏开发框架（八）——消息系统
L的博客
05-13 4168
一：目的 为什么要使用消息系统呢，假如我们的游戏中现在有一个敌人和一个玩家，当敌人击中玩家后玩家需要执行自身的扣血操作，那么就需要在敌人类中引用玩家脚本，这样就造成了代码的耦合，消息系统在开发中是一个非常重要的系统，他的作用就是解耦合 Unity提供的消息机制SendMessage可以非常方便我们的脚本开发，但它实现的是一种伪监听者模式，利用的是反射机制，比较低效，几乎不会有人在项目中使用Unity内置的SendMessage，一般都自己去实现一套消息系统 二：解决的问题及优点 ——解耦合 三：使用
[Unity] 单例化中泛型类继承问题笔记
weixin_64080879的博客
07-21 249
解决Unity C#单例化中泛型类继承的问题
Unity游戏开发消息框架代码
m0_56339943的博客
05-22 188
三层消息框架基类
unity3d游戏框架消息机制
11-13
Unity3d游戏框架的消息机制是其核心开发过程中不可或缺的一部分，它允许不同组件之间进行通信，实现功能的解耦合，从而提高代码的可维护性和扩展性。在Unity中，消息机制主要体现在各种事件（Event）和消息（Message...
让不懂编程的人爱上Unity3d游戏开发004-初识神兵-游戏引擎的诞生和发展1
08-03
游戏引擎的诞生和发展是计算机科技和游戏...Unity3D等现代游戏引擎的出现，不仅简化了游戏制作的过程，还拓宽了游戏创作的可能性，使得更多的人，无论是否懂编程，都能参与到游戏的创造中来，体验到游戏开发的乐趣。
Unity3D源码 Action-RPG Starter Kit 6.01 动作游戏模板
05-05
Unity3D是一款强大的跨平台游戏开发工具，特别适合制作3D和2D的动作角色扮演游戏（Action-RPG）。Action-RPG Starter Kit 6.01 是一个专为Unity开发者准备的游戏开发模板，它提供了完整的框架和资源，帮助新手快速...
使用Unity3D基于GameFramework框架开发的战棋类生存经营游戏.zip
06-01
GameFramework框架是专为Unity3D设计的一个轻量级的游戏开发框架，它简化了游戏逻辑的编写，提供了诸如消息系统、事件管理、资源管理、UI系统、网络模块等基础功能，帮助开发者高效地组织和管理游戏代码，降低项目的...
Unity 一套消息通信框架
11-15
不同模块之间的消息通信机制，简单易懂，主要包括消息体以及消息中心，注册和发送消息
Unity进阶-消息框架的理论知识与实际操作学习笔记
abaidaye的博客
07-20 239
这种框架其实就是分层管理了很多脚本，防止脚本调用产生的耦合性问题。它的基础部分分为三个部分 脚本基础类，管理层基础类 ，以及命令类。实际操作：使用消息框架制作吃金币功能。功能脚本–控制页面显示。DLC：泛型的单例类。绑定到canvas上。
Unity如何搭建游戏框架
2301_80135027的博客
10-11 620
Unity 提供profiler工具对游戏开发中的性能剖析是非常重要的,因为有些性能数据只有Unity引擎内部才有，Unity内部有很多重要的与性能相关的数据，都可以供开发者访问到,但是它提供的性能分析工具只展示了通用重要的数据，于是有一些性能分析工具根据不同的项目性能需求，显示出更细致的性能数据的插件，其实都是读取了Unity提供的性能数据。经过这些考虑，基本上一个游戏框架的雏形就出来了，一个组织游戏项目开发的流程与规范基本就定型了，这样项目也就基于这样的方式铺开来，进行快速的迭代开发。
Unity游戏基本框架
热门推荐
TongOuO的博客
02-01 1万+
Unity游戏基本框架性代码个人总结笔记，参考自B站各教程，希望对他人也有所帮助，对我自己也方便复习。
unity游戏架构设计
军大君的博客
06-21 589
unity游戏架构设计
Unity3D开发之基于委托的消息框架开发
Jay W的博客
08-20 739
我们在开发项目的时候会发现，我们经常要在不同模块不同类之间调用函数。比如：我们在点击场景一个物体后，就需要对UI界面做一定的变化。通常最简单的方式是我们直接在面板绑定持有对更改界面的函数的对象。可是如果项目比较大，类比较多的情况下，我们会发现项目变得异常混乱。更改一点需求可能会牵一发而动全身。其实这就是代码的耦合性太高。 一.静态委托事件 如果项目很小，只有几处跨模块调用代码，我们通常会在方法...
Unity与C++网络游戏开发实战：基于VR、AI与分布式架构 【1.0】
qq_43416206的博客
03-24 885
本书给大家介绍一个智能系统整体开发的知识体系和流程方法。本章是本书开始篇章，将为大家介绍掌握客户端必要的基础知识，以及基于客户端开发的框架和工具链——Unity。现在就让我们开始关于Unity引擎的学习吧。Unity是一个在当今图形开发领域占有重要地位的图形引擎。Unity引擎以其先进的构造理念和长久的发展，如今在游戏和图形开发领域中是开发者使用最多、工作效率最高，以及最适合入门的一门开发引擎。Unity引擎平台有哪些组成部分呢？下面将详细介绍。目前，Unity是在全球范围内应用最广泛的3D引擎。
[Unity 架构] 更好的 Unity 游戏架构
unity尧明的博客
10-30 2041
在使用 Unity 重新制作 Diamond Dash 工作了六个月后，我可以说我从 Wooga 的工程师那里学到了很多，除了自我反思。我经常学习软方式，也学习硬方式。无论如何，在经历了比失败更多的成功之后，我提出了我对伟大架构应该是什么样子的看法。
Unity3D网络游戏开发实战指南
"《开发必备--Unity3D网络游戏实战》是罗培羽撰写的一本深入讲解Unity3D网络游戏开发的书籍，旨在帮助读者理解和掌握网络游戏的开发原理和实践技巧。书中通过一个多人坦克对战游戏的案例，详细阐述了游戏的网络框架...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值