Unity小白——事件的侦听

最新推荐文章于 2022-05-12 15:04:11 发布
最新推荐文章于 2022-05-12 15:04:11 发布
阅读量221 收藏 1
点赞数
分类专栏： unity 文章标签： unity
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44181315/article/details/105505456
版权

一、脚本

// Messenger.cs v1.0 by Magnus Wolffelt, magnus.wolffelt@gmail.com
// Version 1.4 by Julie Iaccarino, biscuitWizard @ github.com
//
// Inspired by and based on Rod Hyde's Messenger:
// http://www.unifycommunity.com/wiki/index.php?title=CSharpMessenger
//
// This is a C# messenger (notification center). It uses delegates
// and generics to provide type-checked messaging between event producers and
// event consumers, without the need for producers or consumers to be aware of
// each other. The major improvement from Hyde's implementation is that
// there is more extensive error detection, preventing silent bugs.
//
// Usage example:
// Messenger<float>.AddListener("myEvent", MyEventHandler);
// ...
// Messenger<float>.Broadcast("myEvent", 1.0f);
//
// Callback example:
// Messenger<float>.AddListener<string>("myEvent", MyEventHandler);
// private string MyEventHandler(float f1) { return "Test " + f1; }
// ...
// Messenger<float>.Broadcast<string>("myEvent", 1.0f, MyEventCallback);
// private void MyEventCallback(string s1) { Debug.Log(s1"); }
//
// If preferred, change DEFAULT_MODE to not require listeners.

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

public enum MessengerMode
{
    DONT_REQUIRE_LISTENER,
    REQUIRE_LISTENER,
}

static internal class MessengerInternal
{
    readonly public static Dictionary<string, Delegate> eventTable = new Dictionary<string, Delegate>();
    static public MessengerMode DEFAULT_MODE = MessengerMode.REQUIRE_LISTENER;

    static public void AddListener(string eventType, Delegate callback)
    {
        MessengerInternal.OnListenerAdding(eventType, callback);
        eventTable[eventType] = Delegate.Combine(eventTable[eventType], callback);
    }

    static public void RemoveListener(string eventType, Delegate handler)
    {
        MessengerInternal.OnListenerRemoving(eventType, handler);
        eventTable[eventType] = Delegate.Remove(eventTable[eventType], handler);
        MessengerInternal.OnListenerRemoved(eventType);
    }

    static public T[] GetInvocationList<T>(string eventType)
    {
        Delegate d;
        if (eventTable.TryGetValue(eventType, out d))
        {
            try
            {
                return d.GetInvocationList().Cast<T>().ToArray();
            }
            catch
            {
                throw MessengerInternal.CreateBroadcastSignatureException(eventType);
            }
        }
        return new T[0];
    }

    static public void OnListenerAdding(string eventType, Delegate listenerBeingAdded)
    {
        if (!eventTable.ContainsKey(eventType))
        {
            eventTable.Add(eventType, null);
        }

        var d = eventTable[eventType];
        if (d != null && d.GetType() != listenerBeingAdded.GetType())
        {
            throw new ListenerException(string.Format("Attempting to add listener with inconsistent signature for event type {0}. Current listeners have type {1} and listener being added has type {2}", eventType, d.GetType().Name, listenerBeingAdded.GetType().Name));
        }
    }

    static public void OnListenerRemoving(string eventType, Delegate listenerBeingRemoved)
    {
        if (eventTable.ContainsKey(eventType))
        {
            var d = eventTable[eventType];

            if (d == null)
            {
                throw new ListenerException(string.Format("Attempting to remove listener with for event type {0} but current listener is null.", eventType));
            }
            else if (d.GetType() != listenerBeingRemoved.GetType())
            {
                throw new ListenerException(string.Format("Attempting to remove listener with inconsistent signature for event type {0}. Current listeners have type {1} and listener being removed has type {2}", eventType, d.GetType().Name, listenerBeingRemoved.GetType().Name));
            }
        }
        else
        {
            throw new ListenerException(string.Format("Attempting to remove listener for type {0} but Messenger doesn't know about this event type.", eventType));
        }
    }

    static public void OnListenerRemoved(string eventType)
    {
        if (eventTable[eventType] == null)
        {
            eventTable.Remove(eventType);
        }
    }

    static public void OnBroadcasting(string eventType, MessengerMode mode)
    {
        if (mode == MessengerMode.REQUIRE_LISTENER && !eventTable.ContainsKey(eventType))
        {
            throw new MessengerInternal.BroadcastException(string.Format("Broadcasting message {0} but no listener found.", eventType));
        }
    }

    static public BroadcastException CreateBroadcastSignatureException(string eventType)
    {
        return new BroadcastException(string.Format("Broadcasting message {0} but listeners have a different signature than the broadcaster.", eventType));
    }

    public class BroadcastException : Exception
    {
        public BroadcastException(string msg)
            : base(msg)
        {
        }
    }

    public class ListenerException : Exception
    {
        public ListenerException(string msg)
            : base(msg)
        {
        }
    }
}

// No parameters
static public class Messenger
{
    static public void AddListener(string eventType, Action handler)
    {
        MessengerInternal.AddListener(eventType, handler);
    }

    static public void AddListener<TReturn>(string eventType, Func<TReturn> handler)
    {
        MessengerInternal.AddListener(eventType, handler);
    }

    static public void RemoveListener(string eventType, Action handler)
    {
        MessengerInternal.RemoveListener(eventType, handler);
    }

    static public void RemoveListener<TReturn>(string eventType, Func<TReturn> handler)
    {
        MessengerInternal.RemoveListener(eventType, handler);
    }

    static public void Broadcast(string eventType)
    {
        Broadcast(eventType, MessengerInternal.DEFAULT_MODE);
    }

    static public void Broadcast<TReturn>(string eventType, Action<TReturn> returnCall)
    {
        Broadcast(eventType, returnCall, MessengerInternal.DEFAULT_MODE);
    }

    static public void Broadcast(string eventType, MessengerMode mode)
    {
        MessengerInternal.OnBroadcasting(eventType, mode);
        var invocationList = MessengerInternal.GetInvocationList<Action>(eventType);

        foreach (var callback in invocationList)
            callback.Invoke();
    }

    static public void Broadcast<TReturn>(string eventType, Action<TReturn> returnCall, MessengerMode mode)
    {
        MessengerInternal.OnBroadcasting(eventType, mode);
        var invocationList = MessengerInternal.GetInvocationList<Func<TReturn>>(eventType);

        foreach (var result in invocationList.Select(del => del.Invoke()).Cast<TReturn>())
        {
            returnCall.Invoke(result);
        }
    }
}

// One parameter
static public class Messenger<T>
{
    static public void AddListener(string eventType, Action<T> handler)
    {
        MessengerInternal.AddListener(eventType, handler);
    }

    static public void AddListener<TReturn>(string eventType, Func<T, TReturn> handler)
    {
        MessengerInternal.AddListener(eventType, handler);
    }

    static public void RemoveListener(string eventType, Action<T> handler)
    {
        MessengerInternal.RemoveListener(eventType, handler);
    }

    static public void RemoveListener<TReturn>(string eventType, Func<T, TReturn> handler)
    {
        MessengerInternal.RemoveListener(eventType, handler);
    }

    static public void Broadcast(string eventType, T arg1)
    {
        Broadcast(eventType, arg1, MessengerInternal.DEFAULT_MODE);
    }

    static public void Broadcast<TReturn>(string eventType, T arg1, Action<TReturn> returnCall)
    {
        Broadcast(eventType, arg1, returnCall, MessengerInternal.DEFAULT_MODE);
    }

    static public void Broadcast(string eventType, T arg1, MessengerMode mode)
    {
        MessengerInternal.OnBroadcasting(eventType, mode);
        var invocationList = MessengerInternal.GetInvocationList<Action<T>>(eventType);

        foreach (var callback in invocationList)
            callback.Invoke(arg1);
    }

    static public void Broadcast<TReturn>(string eventType, T arg1, Action<TReturn> returnCall, MessengerMode mode)
    {
        MessengerInternal.OnBroadcasting(eventType, mode);
        var invocationList = MessengerInternal.GetInvocationList<Func<T, TReturn>>(eventType);

        foreach (var result in invocationList.Select(del => del.Invoke(arg1)).Cast<TReturn>())
        {
            returnCall.Invoke(result);
        }
    }
}


// Two parameters
static public class Messenger<T, U>
{
    static public void AddListener(string eventType, Action<T, U> handler)
    {
        MessengerInternal.AddListener(eventType, handler);
    }

    static public void AddListener<TReturn>(string eventType, Func<T, U, TReturn> handler)
    {
        MessengerInternal.AddListener(eventType, handler);
    }

    static public void RemoveListener(string eventType, Action<T, U> handler)
    {
        MessengerInternal.RemoveListener(eventType, handler);
    }

    static public void RemoveListener<TReturn>(string eventType, Func<T, U, TReturn> handler)
    {
        MessengerInternal.RemoveListener(eventType, handler);
    }

    static public void Broadcast(string eventType, T arg1, U arg2)
    {
        Broadcast(eventType, arg1, arg2, MessengerInternal.DEFAULT_MODE);
    }

    static public void Broadcast<TReturn>(string eventType, T arg1, U arg2, Action<TReturn> returnCall)
    {
        Broadcast(eventType, arg1, arg2, returnCall, MessengerInternal.DEFAULT_MODE);
    }

    static public void Broadcast(string eventType, T arg1, U arg2, MessengerMode mode)
    {
        MessengerInternal.OnBroadcasting(eventType, mode);
        var invocationList = MessengerInternal.GetInvocationList<Action<T, U>>(eventType);

        foreach (var callback in invocationList)
            callback.Invoke(arg1, arg2);
    }

    static public void Broadcast<TReturn>(string eventType, T arg1, U arg2, Action<TReturn> returnCall, MessengerMode mode)
    {
        MessengerInternal.OnBroadcasting(eventType, mode);
        var invocationList = MessengerInternal.GetInvocationList<Func<T, U, TReturn>>(eventType);

        foreach (var result in invocationList.Select(del => del.Invoke(arg1, arg2)).Cast<TReturn>())
        {
            returnCall.Invoke(result);
        }
    }
}


// Three parameters
static public class Messenger<T, U, V>
{
    static public void AddListener(string eventType, Action<T, U, V> handler)
    {
        MessengerInternal.AddListener(eventType, handler);
    }

    static public void AddListener<TReturn>(string eventType, Func<T, U, V, TReturn> handler)
    {
        MessengerInternal.AddListener(eventType, handler);
    }

    static public void RemoveListener(string eventType, Action<T, U, V> handler)
    {
        MessengerInternal.RemoveListener(eventType, handler);
    }

    static public void RemoveListener<TReturn>(string eventType, Func<T, U, V, TReturn> handler)
    {
        MessengerInternal.RemoveListener(eventType, handler);
    }

    static public void Broadcast(string eventType, T arg1, U arg2, V arg3)
    {
        Broadcast(eventType, arg1, arg2, arg3, MessengerInternal.DEFAULT_MODE);
    }

    static public void Broadcast<TReturn>(string eventType, T arg1, U arg2, V arg3, Action<TReturn> returnCall)
    {
        Broadcast(eventType, arg1, arg2, arg3, returnCall, MessengerInternal.DEFAULT_MODE);
    }

    static public void Broadcast(string eventType, T arg1, U arg2, V arg3, MessengerMode mode)
    {
        MessengerInternal.OnBroadcasting(eventType, mode);
        var invocationList = MessengerInternal.GetInvocationList<Action<T, U, V>>(eventType);

        foreach (var callback in invocationList)
            callback.Invoke(arg1, arg2, arg3);
    }

    static public void Broadcast<TReturn>(string eventType, T arg1, U arg2, V arg3, Action<TReturn> returnCall, MessengerMode mode)
    {
        MessengerInternal.OnBroadcasting(eventType, mode);
        var invocationList = MessengerInternal.GetInvocationList<Func<T, U, V, TReturn>>(eventType);

        foreach (var result in invocationList.Select(del => del.Invoke(arg1, arg2, arg3)).Cast<TReturn>())
        {
            returnCall.Invoke(result);
        }
    }
}

// MessengerUnitTest.cs v1.0 by Magnus Wolffelt, magnus.wolffelt@gmail.com
// 
// Some functionality testing of the classes in Messenger.cs.
// A lot of attention is paid to proper exception throwing from the Messenger.

二、事件定义脚本

public static class GameEvent
{
    public const string ENEMY_HIT = "ENEMY_HIT";
    public const string SPEED_CHANGED = "SPEED_CHANGED";
}

三、消息传递给UI
1、UIController这个脚本中
1）private int _score;
2）//增加对时间的侦听
private void Awake()
{
Messenger.AddListener(GameEvent.ENEMY_HIT, OnEnemyHit);
}
3）//销毁
private void OnDestroy()
{
Messenger.RemoveListener(GameEvent.ENEMY_HIT, OnEnemyHit);
}
4）//把分数加一，并显示在左上角的数值里面
private void OnEnemyHit()
{
_score += 1;
scoreLabel.text = _score.ToString();
}

小鱼大大
关注
专栏目录
Unity插件——Best HTTP
03-27
Unity插件——Best HTTP 封装好的网络插件，节省自己写http的时间
Unity插件——Fungus
03-27
unity插件，制作文字冒险类游戏用插件 tip：仅支持unity2018以下版本
Unity 之事件系统
weixin_30483697的博客
06-11 140
游戏开发过程中事件是非常多的，可以通过Messenger事件系统来解藕，用法如下： 1 使用方法 2 3 例子：在按下拍照按钮后通知刷新好友面板 4 步骤1、添加事件字段，该字段具有唯一性 5 在MessangerEventDef脚本（可以每个功能都有一个事件字段脚本，类似于消息）中添加字段"Demo_EventType". 6 7 步骤2、...
监听通知事件
Yang的博客
11-29 304
1.Messager 通知类，使用Messenger.AddListener()来进行事件的注册。Messenger.Broadcast(）进行事件的通知Messenger.RemoveListener(）来移除事件。 using System; using System.Collections; using System.Collections.Generic; using System....
Zjh游戏（八）客户端登陆注册的前期准备广播事件的制作，避免耦合性
赵某人
12-03 241
回调类型 public delegate void CallBack(); public delegate void CallBack<T>(T arg); public delegate void CallBack<T, X>(T arg1, X arg2); public delegate void CallBack<T, X, Y>(T arg1, X a...
Unity原生的事件监听与广播系统——UnityEvent
FutureDr的博客
05-12 2237
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 Unity原生的事件监听与广播系统——UnityEvent前言一、示例代码二、代码挂载及效果 前言 我们在开发Unity程序的过程中会用到事件系统，除了自己开发一套监听与广播系统，也可以使用Unity中原生的监听与广播系统——UnityEvent Unity官方文档地址：https://docs.unity3d.com/cn/2019.4/ScriptReference/Events.UnityEvent.html 一、示例代码 首先.
unity3d使用事件监听器举例
FireGhost57的专栏
04-07 3418
事件监听器举例,可以根据需求自己改
Unity3D研究院之通过C#使用Advanced CSharp Messenger（五十）
yuliying的专栏
01-05 542
Advanced CSharp Messenger 属于C#事件的一种。 维基百科中由详细的说明http://wiki.unity3d.com/index.php?title=Advanced_CSharp_Messenger 上周的一天刚巧有朋友问到我这一块的知识，那么我研究出来将它贴在博客中，帮助了他也帮助我自己！哇咔咔。 Advanced CSharp Messenger的特点可以将游
unity实战——穿越火线-附件资源
03-05
unity实战——穿越火线-附件资源
unity素材——可以直接用的
12-07
在这个“unity素材——可以直接用”的资源包中，包含了一个名为"Chapter4_AngryBotsAssets"的文件，这通常代表了一次Unity教程或项目中的一个章节，可能是针对愤怒机器人（Angry Bots）的示例场景。这个资源包可能...
Unity开发——读取Excel表格数据-附件资源
03-02
Unity开发——读取Excel表格数据-附件资源
内部消息机制
星宇的专栏
12-07 231
理解： 在事件处理类Messenger中定义一个事件表，以键值对（事件，代理（事件的响应函数））的形式存放事件与代理； 提供往事件表中添加事件监听，即添加键值对（事件，代理（事件的响应函数））；从事件表中移除事件监听；广播事件（即调用事件的响应函数）。 对于一个普通类来说，通过向事件表中添加事件监听，可以方便其它类通过广播来调用该类的函数。 一、定义事件枚举 public enu
unity 3种message消息管理使用
TheClimb的池塘
01-11 1646
BroadcastMessage 广播消息 function BroadcastMessage (methodName : string, parameter : object = null, options : SendMessageOptions = SendMessageOptions.RequireReceiver) : void 描述  在游戏物体每一个MonoBehaviour和它...
第一人称射击游戏实战——标签的封装和场景的淡入淡出效果
weixin_43156577的博客
06-11 491
标签的封装和场景的淡入淡出效果 知识点一：标签 标签用来识别游戏物体的，必须在使用之前在标签管理器中定义。 创建文件夹Screen->C#script（命名Tags） 相关代码 using System.Collections; using System.Collections.Generic; using UnityEngine; public class Tags { public const string plaer="Player"; public const string gameCo
观察者模式（基于CSharpMessenger扩展）
流彩飞霞的专栏
12-04 333
在使用c#中的事件时，经同事推荐看到了这个框架，它是c#消息传递的高级版本，代码不多，拜读之后对代码结构进行了重构，感觉更清晰点 /* * Advanced C# messenger by Ilya Suzdalnitski. V1.0 * * Based on Rod Hyde's "CSharpMessenger" and Magnus Wolffelt's "CSharpMess...
高级C#消息机制(Advanced CSharp Messenger)
07-11 5495
转载自 :http://wiki.unity3d.com/index.php?title=Advanced_CSharp_Messenger
多进程间通信Messenger使用
豌豆的专栏
04-05 365
Messenger 信使 也是进程间通信的一种方式，但是它的好处在于不用像aidl 一样必须要定义aidl 接口，然后通过接口来通信，本质上messenger 的实现底层也是通过aidl 实现的。 实现原理是客户端通过绑定服务端service ，通过返回的IBundle，生成获取到服务端的Messenger对像，然后通过服务端的Messenger 对象将客户端的Messenger 发送到服务端，...
java 信使服务_Android 绑定类型服务---使用信使（Messenger）
weixin_30979229的博客
02-13 178
如果需要服务跟远程进程通信，那么就可以使用Messenger对象来给服务提供接口。这种技术允许你在不使用AIDL的情况下执行进程间通信(IPC)。以下是信使(Messenger)对象的使用概要：1.服务端实现的一个处理器(Handler接口)，这个处理器针对每次来自客户端的调用接收一次回调；2.这个处理器被用于创建一个信使对象(Messager)(这个信使对象要引用这个处理器)；3.信...
unity简单设计模式---Advanced CSharp Messenger
游戏路上的小学生
03-12 3131
Contents [hide] 1 Description2 Foreword 2.1 Cause behind the MissingReferenceException and solution3 The Messenger 3.1 Usage 3.1.1 Event listener3.1.2 Registering an event listener3.1.3 Unregisterin
unity动画事件侦听
最新发布
07-11
在Unity中，可以通过以下步骤来侦听动画事件： 1. 首先，确保你的动画包含了需要侦听的事件。在Unity的动画编辑器中，选中你的动画片段，在Inspector面板中，展开"Events"部分。 2. 在"Events"部分，你可以添加和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值