• Unity3D C#事件管理:EventManager

    原文地址：http://bbs.9ria.com/thread-153258-1-1.html

    原project地址：https://github.com/djandrew/UnityEventManager

    多年的Flash开发。我很赞赏Flash的事件系统。

    Uinty对象通信所使用的方法SendMessage在多数情况下是工作正常，但假设在一个具有无数引用其它对象的GameObject的大型项目进行反射，那问题就来了。


    我用C＃在Uinty中所写的第一个东西，就是管理抽象类的事件管理系统。

    究其核心。EventManager使用也是SendMessage。并对游戏对象[gameObject]有直接引用，但若有事件发生。其便会对需求进行分解，不同的类间会有信息共享，这样事件对象就知道怎样互相通信。



    若有不论什么建议或修正。欢迎留言。



    EventManager.cs(十按。本链接为凝视译版，若认为某译不妥请对比英文版自行勘误)

    1. /*
    2.     Event Manager
    3.     Static manager for handling an event driven communication model in Unity.
    4.     This is similar to Adobe Flash's event listener model used in ActionScript.
    5.      
    6.     Copyright © 2012 Dustin Andrew
    7.     dustin.andrew@gmail.com
    8.     http://www.dustinandrew.me/
    9.      
    10.     This program is free software: you can redistribute it and/or modify
    11.     it under the terms of the GNU General Public License as published by
    12.     the Free Software Foundation, either version 3 of the License, or 
    13.     any later version.

    15.     This program is distributed in the hope that it will be useful,
    16.     but WITHOUT ANY WARRANTY; without even the implied warranty of
    17.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    18.     GNU General Public License for more details.

    20.     http://www.gnu.org/licenses/
    21. */

    23. /* 
    24. *  Setup:
    25. *  Create an empty GameObject and add the EventManager script to it.
    26. *  Create custom event classes that extend the CustomEvent.
    27. * 
    28. *  Restrictions & Tips:
    29. *  DO NOT add event listeners in the Awake() method! 
    30. *  This is used by the EventManager to initialize.
    31. *  Change this class' Execution Order to before default time if you need to work around this.
    32. *  Use the Start() method to setup your events.
    33. *  Make event listener callback functions public.
    34. *  Extend the CustomEvent class when creating your events.
    35. *  Use custom variables in your custom events over the arguments hashtable to maintain class abstraction
    36. *  Clean up and remove event listeners when objects are destroyed.
    37. *  Events are not received if the listener gameObject.active is false.
    38. * 
    39. *  Examples:
    40. * 
    41. *  // setup event listeners
    42. *  void Start() {
    43. *      EventManager.instance.addEventListener(CustomEventObj.EVENT_TO_LISTEN_TO, gameObject, "OnSomethingHappened");
    44. *  }
    45. *  
    46. *  // remove event listeners
    47. *  void OnDestroy() {
    48. *      if (gameObject) {
    49. *          // remove a single event
    50. *          EventManager.instance.removeEventListener(CustomEventObj.EVENT_TO_LISTEN_TO, gameObject);
    51. *          // remove all events
    52. *          EventManager.instance.removeAllEventListeners(gameObject);
    53. *      }
    54. *  }
    55. * 
    56. *  // get values passed by events
    57. *  public void OnSomethingHappened(CustomEventObj evt) {
    58. *      Debug.Log((datatype)evt.arguments["value"]);
    59. *      // or if using custom vars instead of arguments hashtable
    60. *      Debug.Log(evt.rockOn);      
    61. *  }
    62. * 
    63. *  // dispatch events
    64. *  void TriggerEvent() {
    65. *      CustomEventObj evt = new CustomEventObj(CustomEventObj.EVENT_TO_TRIGGER);
    66. *      evt.arguments.Add("value", 3);
    67. *      EventManager.instance.dispatchEvent(evt);
    68. *  }
    69. * 
    70. *  // create custom events
    71. *  using UnityEngine;
    72. *  using System.Collections;
    73. * 
    74. *  public class CustomEventObj : CustomEvent {
    75. * 
    76. *      // event types
    77. *      public static string MY_EVENT_1 = "my_event_1";
    78. *      public static string MY_EVENT_2 = "my_event_2";
    79. * 
    80. *      // optionally add custom variables instead of using the arguments hashtable
    81. *      public int myCustomEventVar1 = 0;
    82. *      public bool rockOn = true;
    83. * 
    84. *      public CustomEventObj(string eventType = "") {
    85. *         type = eventType;
    86. *      }
    87. *  }
    88. * 
    89. */

    91. using UnityEngine;
    92. using System.Collections;

    94. // internal event listener model
    95. internal class EventListener {
    96.     public string name;
    97.     public GameObject listener;
    98.     public string function; 
    99. }

    101. // Custom event class, extend when creating custom events
    102. public class CustomEvent {
    103.      
    104.     private string _type;
    105.     private Hashtable _arguments = new Hashtable();
    106.      
    107.     // constructor
    108.     public CustomEvent(string eventType = "") {
    109.         _type = eventType;
    110.     }
    111.      
    112.     // the type of event
    113.     public string type {
    114.         get { return _type; }
    115.         set { _type = value; }
    116.     }
    117.      
    118.     // the arguments to pass with the event
    119.     public Hashtable arguments {
    120.         get { return _arguments; }
    121.         set { _arguments = value; }
    122.     }
    123. }

    125. public class EventManager : MonoBehaviour {
    126.      
    127.     // singleton instance
    128.     public static EventManager instance;
    129.      
    130.     // settings
    131.     public bool allowSingleton = true; // EventManager class will transfer between scene changes.
    132.     public bool allowWarningOutputs = true;
    133.     public bool allowDebugOutputs = true;
    134.      
    135.     private static bool _created = false;   
    136.     private Hashtable _listeners = new Hashtable(); 
    137.      
    138.     // setup singleton if allowed
    139.     public void Awake() {
    140.         if (!_created && allowSingleton) {
    141.             DontDestroyOnLoad(this);
    142.             instance = this;
    143.             _created = true;
    144.             Setup();
    145.         } else {
    146.             if (allowSingleton) {
    147.                 if (EventManager.instance.allowWarningOutputs) {
    148.                     Debug.LogWarning("Only a single instance of " + this.name + " should exists!");
    149.                 }
    150.                 Destroy(gameObject);
    151.             } else {
    152.                 instance = this;
    153.                 Setup();
    154.             }
    155.         }
    156.     }
    157.      
    158.     // clear events on quit
    159.     public void OnApplicationQuit() {
    160.         _listeners.Clear();
    161.     }
    162.      
    163.     // PUBLIC *******************************
    164.      
    165.     // Add event listener
    166.     public bool addEventListener(string eventType, GameObject listener, string function) {
    167.         if (listener == null || eventType == null) {
    168.             if (allowWarningOutputs) {
    169.                 Debug.LogWarning("Event Manager: AddListener failed due to no listener or event name specified.");
    170.             }
    171.             return false;
    172.         }
    173.         recordEvent(eventType);
    174.         return recordListener(eventType, listener, function);
    175.     }
    176.      
    177.     // Remove event listener
    178.     public bool removeEventListener(string eventType, GameObject listener) {
    179.         if (!checkForEvent(eventType)) return false;
    180.          
    181.         ArrayList listenerList = _listeners[eventType] as ArrayList;
    182.         foreach (EventListener callback in listenerList) {
    183.             if (callback.name == listener.GetInstanceID().ToString()) {
    184.                 listenerList.Remove(callback);
    185.                 return true;
    186.             }
    187.         }
    188.         return false;
    189.     }
    190.      
    191.     // Remove all event listeners
    192.     public void removeAllEventListeners(GameObject listener) {
    193.         foreach (EventListener callback in _listeners) {
    194.             if (callback.listener.GetInstanceID().ToString() == listener.GetInstanceID().ToString()) {
    195.                 _listeners.Remove(callback);
    196.             }
    197.         }
    198.     }
    199.      
    200.     // Dispatch an event
    201.     public bool dispatchEvent(CustomEvent evt) {
    202.         string eventType = evt.type;
    203.         if (!checkForEvent(eventType)) {
    204.             if (allowWarningOutputs) {
    205.                 Debug.LogWarning("Event Manager: Event "" + eventType + "" triggered has no listeners!");
    206.             }
    207.             return false;
    208.         }
    209.          
    210.         ArrayList listenerList = _listeners[eventType] as ArrayList;
    211.         if (allowDebugOutputs) {
    212.             Debug.Log("Event Manager: Event " + eventType + " dispatched to " + listenerList.Count + ((listenerList.Count == 1) ? " listener." : " listeners."));
    213.         }
    214.         foreach (EventListener callback in listenerList) {
    215.             if (callback.listener && callback.listener.active) {
    216.                 callback.listener.SendMessage(callback.function, evt, SendMessageOptions.DontRequireReceiver);
    217.             }
    218.         }
    219.         return false;
    220.     }
    221.      
    222.     // PRIVATE *******************************
    223.      
    224.     private void Setup() {
    225.         // TO DO: Self create GameObject if not already created
    226.     }
    227.      
    228.     // see if event already exists
    229.     private bool checkForEvent(string eventType) {
    230.         if (_listeners.ContainsKey(eventType)) return true;
    231.         return false;
    232.     }
    233.      
    234.     // record event, if it doesn't already exists
    235.     private bool recordEvent(string eventType) {
    236.         if (!checkForEvent(eventType)) {
    237.             _listeners.Add(eventType, new ArrayList());
    238.         }
    239.         return true;
    240.     }
    241.      
    242.     // delete event, if not already removed
    243.     private bool deleteEvent(string eventType) {
    244.         if (!checkForEvent(eventType)) return false;
    245.         _listeners.Remove(eventType);
    246.         return true;
    247.     }
    248.      
    249.     // check if listener exists
    250.     private bool checkForListener(string eventType, GameObject listener) {
    251.         if (!checkForEvent(eventType)) {
    252.             recordEvent(eventType);
    253.         }
    254.          
    255.         ArrayList listenerList = _listeners[eventType] as ArrayList;
    256.         foreach (EventListener callback in listenerList) {
    257.             if (callback.name == listener.GetInstanceID().ToString()) return true;
    258.         }
    259.         return false;
    260.     }
    261.      
    262.     // record listener, if not already recorded
    263.     private bool recordListener(string eventType, GameObject listener, string function) {
    264.         if (!checkForListener(eventType, listener)) {
    265.             ArrayList listenerList = _listeners[eventType] as ArrayList;
    266.             EventListener callback = new EventListener();
    267.             callback.name = listener.GetInstanceID().ToString();
    268.             callback.listener = listener;
    269.             callback.function = function;
    270.             listenerList.Add(callback);
    271.             return true;
    272.         } else {
    273.             if (allowWarningOutputs) {
    274.                 Debug.LogWarning("Event Manager: Listener: " + listener.name + " is already in list for event: " + eventType);
    275.             }
    276.             return false;
    277.         }
    278.     }
    279. }
    复制代码



    原文链接：http://www.dustinandrew.me/blog/2012/10/9/unity3d-c-event-manager.html

    翻译词数：225
  • 相关阅读:
    3个检测浏览器UserAgent信息的网站
    linux系统下配置网桥(CentOS 5.5)
    squid封禁不带UserAgent的请求
    iptables透明网桥无法使用透明代理错误
    Squid修改用户浏览器的Useragent信息
    MySQL主从复制（MasterSlave）与读写分离（MySQLProxy）实践
    js中格式化时间
    js获取当前月的第一天和最后一天
    JS String.toDate
    Js获取当前日期时间及其它操作
  • 原文地址：https://www.cnblogs.com/jzssuanfa/p/7287220.html
Copyright © 2020-2023  润新知