added tick update systems and some advanced examples

Author: cjddmut

Assets/UnityEvents/Examples/Advance.meta

@@ -0,0 +1,74 @@
+using UnityEngine;
+
+namespace UnityEvents.Example
+{
+	/// <summary>
+	/// Example of using an event system that isn't controlled by any of the update ticks. Events will only be processed
+	/// when told to be processed.
+	/// </summary>
+	public class ExampleControlledEventSystem
+	{
+		// This system will allow subscribers and events to be queued. Events have to be told when to process isntead
+		// of happening automatically in a tick. The example will only show regular events but this can handle both.
+		// See ExampleSimpleJob.cs for a job example. 
+		private UnityEventSystem _system = new UnityEventSystem();
+
+		// I have to be an unmanaged type! Need references? Use an id and have a lookup database system.
+		private struct EvExampleEvent
+		{
+			public int exampleValue;
+
+			public EvExampleEvent(int exampleValue)
+			{
+				this.exampleValue = exampleValue;
+			}
+		}
+
+		public void UseCustomSystem()
+		{
+			// Event systems are associated with an EventEntity, this is how an event system can know who to send
+			// and event to but keep all events together for performance.
+			//
+			// For example the global sim event system is its own EventEntity. As is the Global UI system and each
+			// GameObject is converted to an EventEntity.
+			//
+			// It is better to use a single UnityEventSystem with multiple entities than an UnityEventSystem for each
+			// entity. For example if there are multiple 'global' systems that all get processed at the same time then
+			// it is more performant to have a since UnityEventSystem and an EventEntity for each 'global system' that 
+			// talk to the same UnityEventSystem.
+			//
+			// GlobalEventSystem, GameObject systems, and TickEventSystem uses EventManager which uses one UnityEventSystem
+			// for each update tick.
+			EventEntity entity1 = EventEntity.CreateEntity();
+			EventEntity entity2 = EventEntity.CreateEntity();
+			
+			// Can subscribe a listener to both entities
+			_system.Subscribe<EvExampleEvent>(entity1, OnExampleEvent);
+			_system.Subscribe<EvExampleEvent>(entity2, OnExampleEventDoublePrint);
+			
+			// We queue up events, avoid the send verb here since we have to manually process the events.
+			_system.QueueEvent(entity1, new EvExampleEvent(1));
+			
+			// Now we process the queued events. We only sent an event to the entity1 system, the listener to entity2
+			// will NOT invoke.
+			_system.ProcessEvents();
+			
+			// Each listener needs to unsubscribe from the appropriate event entity
+			_system.Unsubscribe<EvExampleEvent>(entity1, OnExampleEvent);
+			_system.Unsubscribe<EvExampleEvent>(entity2, OnExampleEventDoublePrint);
+			
+			// To have a global system that you control just store an EventEntity and just use that.
+		}
+
+		private void OnExampleEvent(EvExampleEvent ev)
+		{
+			Debug.Log("Event received! Value: " + ev.exampleValue);
+		}
+		
+		private void OnExampleEventDoublePrint(EvExampleEvent ev)
+		{
+			Debug.Log("Event received! Value: " + ev.exampleValue);
+			Debug.Log("Event received! Value: " + ev.exampleValue);
+		}
+	}
+}

Assets/UnityEvents/Examples/Advance/ExampleControlledEventSystem.cs

@@ -0,0 +1,44 @@
+using UnityEngine;
+
+namespace UnityEvents.Example
+{
+	/// <summary>
+	/// Example of using a custom event system that send events on an update tick. This could be used to create custom
+	/// local event system and custom global event system. GlobalEventSystem is a static class that holds a tick
+	/// based event system for simulation and ui and passes subscriptions/events through it.
+	/// </summary>
+	public class ExampleCustomTickEventSystem
+	{
+		// This system will process events in the Update tick. The example will only show regular events but this can
+		// handle both. See ExampleSimpleJob.cs for a job example.
+		private TickEventSystem _system = new TickEventSystem(EventUpdateTick.Update);
+
+		// I have to be an unmanaged type! Need references? Use an id and have a lookup database system.
+		private struct EvExampleEvent
+		{
+			public int exampleValue;
+
+			public EvExampleEvent(int exampleValue)
+			{
+				this.exampleValue = exampleValue;
+			}
+		}
+		
+		public void UseCustomSystem()
+		{
+			// Subscribe to the custom event system
+			_system.Subscribe<EvExampleEvent>(OnExampleEvent);
+			
+			// Can send an event to it. This will be processed in the Update loop.
+			_system.SendEvent(new EvExampleEvent(10));
+			
+			// And unsubscribe from it
+			_system.Unsubscribe<EvExampleEvent>(OnExampleEvent);
+		}
+
+		private void OnExampleEvent(EvExampleEvent ev)
+		{
+			Debug.Log("Event received! Value: " + ev.exampleValue);
+		}
+	}
+}

Assets/UnityEvents/Scripts/GlobalUIEventSystem.cs.meta Assets/UnityEvents/Examples/Advance/ExampleControlledEventSystem.cs.meta

@@ -0,0 +1,73 @@
+using UnityEngine;
+using UnityEventsInternal;
+
+namespace UnityEvents.Example
+{
+	/// <summary>
+	/// Example of using event handlers directly. Similar to UnityEventSystem but only works for a specific event.
+	/// Can be used to only allow a single event.
+	/// </summary>
+	public class ExampleHandlers
+	{
+		private EventHandlerStandard<EvExampleEvent> _standardHandler = new EventHandlerStandard<EvExampleEvent>();
+		private EventHandlerJob<ExampleJob, EvExampleEvent> _jobHandler = new EventHandlerJob<ExampleJob, EvExampleEvent>();
+		
+		// I have to be an unmanaged type! Need references? Use an id and have a lookup database system.
+		private struct EvExampleEvent
+		{
+			public int exampleValue;
+
+			public EvExampleEvent(int exampleValue)
+			{
+				this.exampleValue = exampleValue;
+			}
+		}
+		
+		private struct ExampleJob : IJobForEvent<EvExampleEvent>
+		{
+			// This result is stored across jobs, wipe it out at the beginning of each job if this isn't wanted!
+			public int result;
+			
+			public void ExecuteEvent(EvExampleEvent ev)
+			{
+				result += ev.exampleValue;
+			}
+		}
+
+		public void StandardHandlerExample()
+		{
+			// Handlers ultimately are what store the subscriptions and process events. Ideally they shouldn't need
+			// to be used directly and TickEventSystem and UnityEventSystem would be sufficient in most cases.
+			
+			// See ExampleControlledEventSystem.cs for a description on EventEntities.
+			EventEntity entity = EventEntity.CreateEntity();
+			
+			// Subscribe, Unsubscribe, and Events will seem familiar but can ONLY use EvExampleEvent. Doesn't work for
+			// all events.
+			_standardHandler.Subscribe(entity, OnExampleEvent);
+			
+			// Handlers have to be told to process events so we queue an event and process it later.
+			_standardHandler.QueueEvent(entity, new EvExampleEvent(7777));
+			_standardHandler.ProcessEvents();
+			
+			_standardHandler.Unsubscribe(entity, OnExampleEvent);
+			
+			// There's a job handler as well, they are separate and won't fire on the same events
+			_jobHandler.Subscribe(entity, new ExampleJob(), OnJobFinished);
+			_jobHandler.QueueEvent(entity, new EvExampleEvent(111));
+			_jobHandler.ProcessEvents();
+			_jobHandler.Unsubscribe(entity, OnJobFinished);
+			
+		}
+		
+		private void OnExampleEvent(EvExampleEvent ev)
+		{
+			Debug.Log("Event received! Value: " + ev.exampleValue);
+		}
+		
+		private void OnJobFinished(ExampleJob ev)
+		{
+			Debug.Log("Job finished! Value: " + ev.result);
+		}
+	}
+}

Assets/UnityEvents/Examples/Advance/ExampleCustomTickEventSystem.cs

@@ -8,6 +8,17 @@ namespace UnityEvents.Example
 	/// </summary>
 	public class ExampleSimple : MonoBehaviour
 	{
+		// I have to be an unmanaged type! Need references? Use an id and have a lookup database system.
+		private struct EvExampleEvent
+		{
+			public int exampleValue;
+
+			public EvExampleEvent(int exampleValue)
+			{
+				this.exampleValue = exampleValue;
+			}
+		}
+
 		private void OnEnable()
 		{
 			// Subscribes to the global event system, handles events in FixedUpdate
@@ -18,7 +29,7 @@ private void OnEnable()
 
 			// Is the game paused but still need events for UI? There's a global UI system. Handles events in
 			// LateUpdate
-			GlobalUIEventSystem.Subscribe<EvExampleEvent>(OnExampleEvent);
+			GlobalEventSystem.SubscribeUI<EvExampleEvent>(OnExampleEvent);
 
 			// There's also local event system for each GameObject that run in LateUpdate.
 			gameObject.SubscribeUI<EvExampleEvent>(OnExampleEvent);
@@ -32,7 +43,7 @@ private void OnDisable()
 			GlobalEventSystem.Unsubscribe<EvExampleEvent>(OnExampleEvent);
 			gameObject.Unsubscribe<EvExampleEvent>(OnExampleEvent);
 
-			GlobalUIEventSystem.Unsubscribe<EvExampleEvent>(OnExampleEvent);
+			GlobalEventSystem.UnsubscribeUI<EvExampleEvent>(OnExampleEvent);
 			gameObject.UnsubscribeUI<EvExampleEvent>(OnExampleEvent);
 		}
 
@@ -47,7 +58,7 @@ public void SendEvents()
 
 			// Can send events to the global UI event system. These will be processed in LateUpdate which allows the
 			// game to paused.
-			GlobalUIEventSystem.SendEvent(new EvExampleEvent(-1));
+			GlobalEventSystem.SendEventUI(new EvExampleEvent(-1));
 
 			// Similarly can send to a specific GameObject to be processed in LateUpdate
 			gameObject.SendEventUI(new EvExampleEvent(999999));
@@ -58,15 +69,4 @@ private void OnExampleEvent(EvExampleEvent ev)
 			Debug.Log("Event received! Value: " + ev.exampleValue);
 		}
 	}
-
-	// I have to be an unmanaged type! Need references? Use an id and have a lookup database system.
-	public struct EvExampleEvent
-	{
-		public int exampleValue;
-
-		public EvExampleEvent(int exampleValue)
-		{
-			this.exampleValue = exampleValue;
-		}
-	}
 }

Assets/UnityEvents/Examples/Advance/ExampleCustomTickEventSystem.cs.meta

@@ -8,6 +8,17 @@ namespace UnityEvents.Example
 	/// </summary>
 	public class ExampleSimpleJob : MonoBehaviour
 	{
+		// I have to be an unmanaged type! Need references? Use an id and have a lookup database system.
+		private struct EvExampleEvent
+		{
+			public int exampleValue;
+
+			public EvExampleEvent(int exampleValue)
+			{
+				this.exampleValue = exampleValue;
+			}
+		}
+
 		private struct ExampleJob : IJobForEvent<EvExampleEvent>
 		{
 			// This result is stored across jobs, wipe it out at the beginning of each job if this isn't wanted!

Assets/UnityEvents/Examples/Advance/ExampleHandlers.cs

@@ -14,7 +14,7 @@ namespace UnityEvents
 	/// </summary>
 	/// <typeparam name="T_Job">The job the system is responsible for.</typeparam>
 	/// <typeparam name="T_Event">The event the system is responsible for.</typeparam>
-	public class UnityEventJobSystem<T_Job, T_Event> :
+	public class EventHandlerJob<T_Job, T_Event> :
 		IJobEventSystem<T_Event>,
 		IDisposable
 		where T_Job : struct, IJobForEvent<T_Event>
@@ -59,7 +59,7 @@ public Subscription(EventEntity entity, T_Job job)
 			}
 		}
 
-		public UnityEventJobSystem() : this(
+		public EventHandlerJob() : this(
 			DEFAULT_SUBSCRIBER_CAPACITY,
 			DEFAULT_EVENTS_TO_PROCESS_CAPACITY,
 			DEFAULT_PARALLEL_BATCH_COUNT)
@@ -72,7 +72,7 @@ public UnityEventJobSystem() : this(
 		/// <param name="subscriberStartingCapacity">The starting capacity of subscriber containers.</param>
 		/// <param name="queuedEventsStartingCapacity">The starting capacity of queued events containers.</param>
 		/// <param name="parallelBatchCount">The batch count allowed per thread for parallel processing.</param>
-		public UnityEventJobSystem(
+		public EventHandlerJob(
 			int subscriberStartingCapacity,
 			int queuedEventsStartingCapacity,
 			int parallelBatchCount)

Assets/UnityEvents/Examples/Advance/ExampleHandlers.cs.meta

@@ -12,7 +12,7 @@ namespace UnityEvents
 	/// Event system that processes regular events.
 	/// </summary>
 	/// <typeparam name="T_Event">The event the system is responsible for.</typeparam>
-	public class UnityEventStandardSystem<T_Event> : IEventSystem, IDisposable where T_Event : unmanaged
+	public class EventHandlerStandard<T_Event> : IEventSystem, IDisposable where T_Event : unmanaged
 	{
 		private NativeList<QueuedEvent<T_Event>> _queuedEvents;
 		private NativeList<EventEntity> _subscribers;
@@ -28,7 +28,7 @@ public class UnityEventStandardSystem<T_Event> : IEventSystem, IDisposable where
 		private const int DEFAULT_SUBSCRIBER_CAPACITY = 100;
 		private const int DEFAULT_PARALLEL_BATCH_COUNT = 32;
 
-		public UnityEventStandardSystem() : this(
+		public EventHandlerStandard() : this(
 			DEFAULT_SUBSCRIBER_CAPACITY,
 			DEFAULT_EVENTS_TO_PROCESS_CAPACITY,
 			DEFAULT_PARALLEL_BATCH_COUNT)
@@ -41,7 +41,7 @@ public UnityEventStandardSystem() : this(
 		/// <param name="subscriberStartingCapacity">The starting capacity of subscriber containers.</param>
 		/// <param name="queuedEventsStartingCapacity">The starting capacity of queued events containers.</param>
 		/// <param name="parallelBatchCount">The batch count allowed per thread for parallel processing.</param>
-		public UnityEventStandardSystem(
+		public EventHandlerStandard(
 			int subscriberStartingCapacity,
 			int queuedEventsStartingCapacity,
 			int parallelBatchCount)