Interfaces

using UnityEngine;

using System.Collections;

//-----------------------------------------------------------

//Enum defining all possible game events

//More events should be added to the list

public enum EVENT_TYPE {GAME_INIT,

                        GAME_END,

                        AMMO_CHANGE,

                        HEALTH_CHANGE,

                        DEAD};

//-----------------------------------------------------------

//Listener interface to be implemented on Listener classes

public interface IListener

    //Notification function to be invoked on Listeners when events happen

    void OnEvent(EVENT_TYPE Event_Type, Component Sender, object Param = null);

//-----------------------------------------------------------

using UnityEngine;

using System.Collections;

using System.Collections.Generic;

//-----------------------------------------------------------

//Singleton EventManager to send events to listeners

//Works with IListener implementations

public class EventManager : MonoBehaviour

    #region C# properties

    //-----------------------------------------------------------

    //Public access to instance

    public static EventManager Instance

        get{return instance;}

        set{}

    #endregion

    #region variables

    //Internal reference to Notifications Manager instance (singleton design pattern)

    private static EventManager instance = null;

    //Array of listener objects (all objects registered to listen for events)

    private Dictionary<EVENT_TYPE, List<IListener>> Listeners = new Dictionary<EVENT_TYPE, List<IListener>>();

    #endregion

    //-----------------------------------------------------------

    #region methods

    //Called at start-up to initialize

    void Awake()

        //If no instance exists, then assign this instance

        if(instance == null)

            instance = this;

            DontDestroyOnLoad(gameObject); //Prevent object from being destroyed on scene exit

        else //Instance already exists, so destroy this one. This should be a singleton object

            DestroyImmediate(this);

    //-----------------------------------------------------------

    /// <summary>

    /// Function to add specified listener-object to array of listeners

    /// </summary>

    /// <param name="Event_Type">Event to Listen for</param>

    /// <param name="Listener">Object to listen for event</param>

    public void AddListener(EVENT_TYPE Event_Type, IListener Listener)

        //List of listeners for this event

        List<IListener> ListenList = null;

        //New item to be added. Check for existing event type key. If one exists, add to list

        if(Listeners.TryGetValue(Event_Type, out ListenList))

            //List exists, so add new item

            ListenList.Add(Listener);

            return;

        //Otherwise create new list as dictionary key

        ListenList = new List<IListener>();

        ListenList.Add(Listener);

        Listeners.Add(Event_Type, ListenList); //Add to internal listeners list

    //-----------------------------------------------------------

    /// <summary>

    /// Function to post event to listeners

    /// </summary>

    /// <param name="Event_Type">Event to invoke</param>

    /// <param name="Sender">Object invoking event</param>

    /// <param name="Param">Optional argument</param>

    public void PostNotification(EVENT_TYPE Event_Type, Component Sender, object Param = null)

        //Notify all listeners of an event

        //List of listeners for this event only

        List<IListener> ListenList = null;

        //If no event entry exists, then exit because there are no listeners to notify

        if(!Listeners.TryGetValue(Event_Type, out ListenList))

            return;

        //Entry exists. Now notify appropriate listeners

        for(int i=0; i<ListenList.Count; i++)

            if(!ListenList[i].Equals(null)) //If object is not null, then send message via interfaces

                ListenList[i].OnEvent(Event_Type, Sender, Param);

    //-----------------------------------------------------------

    //Remove event type entry from dictionary, including all listeners

    public void RemoveEvent(EVENT_TYPE Event_Type)

        //Remove entry from dictionary

        Listeners.Remove(Event_Type);

    //-----------------------------------------------------------

    //Remove all redundant entries from the Dictionary

    public void RemoveRedundancies()

        //Create new dictionary

        Dictionary<EVENT_TYPE, List<IListener>> TmpListeners = new Dictionary<EVENT_TYPE, List<IListener>>();

        //Cycle through all dictionary entries

        foreach(KeyValuePair<EVENT_TYPE, List<IListener>> Item in Listeners)

            //Cycle through all listener objects in list, remove null objects

            for(int i = Item.Value.Count-1; i>=0; i--)

                //If null, then remove item

                if(Item.Value[i].Equals(null))

                    Item.Value.RemoveAt(i);

            //If items remain in list for this notification, then add this to tmp dictionary

            if(Item.Value.Count > 0)

                TmpListeners.Add (Item.Key, Item.Value);

        //Replace listeners object with new, optimized dictionary

        Listeners = TmpListeners;

    //-----------------------------------------------------------

    //Called on scene change. Clean up dictionary

    void OnLevelWasLoaded()

        RemoveRedundancies();

    //-----------------------------------------------------------

    #endregion

using UnityEngine;

using System.Collections;

public class EnemyObject : MonoBehaviour, IListener

    //-------------------------------------------------------

    //C# accessors for private variables

    public int Health

        get{return _health;}

set

            //Clamp health between 0-100

            _health = Mathf.Clamp(value, 0, 100);

            //Post notification - health has been changed

            EventManager.Instance.PostNotification(EVENT_TYPE.HEALTH_CHANGE, this, _health);

    //-------------------------------------------------------

    public int Ammo

        get{return _ammo;}

set

            //Clamp ammo between 0-50

            _ammo = Mathf.Clamp(value,0,50);

            //Post notification - ammo has been changed

            EventManager.Instance.PostNotification(EVENT_TYPE.AMMO_CHANGE, this, _health);

    //-------------------------------------------------------

    //Internal variables for health and ammo

    private int _health = 100;

    private int _ammo = 50;

    //-------------------------------------------------------

    //Called at start-up

    void Start()

        //Add myself as listener for health change events

        EventManager.Instance.AddListener(EVENT_TYPE.HEALTH_CHANGE, this);

    //-------------------------------------------------------

    // Update is called once per frame

    void Update ()

        //If you press space bar, the health is reduce

        if(Input.GetKeyDown(KeyCode.Space))

            //Take some damage of space bar  press

            Health -= 5;

    //-------------------------------------------------------

    //Called when events happen

    public void OnEvent(EVENT_TYPE Event_Type, Component Sender, object Param = null)

        //Detect event type

        switch(Event_Type)

            case EVENT_TYPE.HEALTH_CHANGE:

                OnHealthChange(Sender, (int)Param);

            break;

    //-------------------------------------------------------

    //Function called when health changes

    void OnHealthChange(Component Enemy, int NewHealth)

        //If health has changed of this object

        if(this.GetInstanceID() != Enemy.GetInstanceID()) return;

        Debug.Log ("Object: " + gameObject.name +  " Health is: " + NewHealth.ToString());

    //-------------------------------------------------------

Google Sites

Report abuse