Add Event builders

GamecraftModdingAPI/Events/EmitterBuilder.cs

@@ -0,0 +1,105 @@
+using System;
+
+using Svelto.ECS;
+
+namespace GamecraftModdingAPI.Events
+{
+    public class EmitterBuilder
+    {
+		private string name;
+
+		private int? type;
+
+        /// <summary>
+        /// Create a new event emitter builder.
+        /// </summary>
+        public EmitterBuilder()
+        {
+        }
+
+        /// <summary>
+        /// Create a new event emitter builder.
+		/// This is equivalent to new <code>EmitterBuilder().Name(name)</code>
+        /// </summary>
+        /// <param name="name">The emitter name.</param>
+		public EmitterBuilder(string name)
+		{
+			this.name = name;
+		}
+
+        /// <summary>
+		/// Create and return an event emitter builder.
+        /// </summary>
+        /// <returns>The builder.</returns>
+		public static EmitterBuilder Builder()
+		{
+			return new EmitterBuilder();
+		}
+
+        /// <summary>
+        /// Create and return an event emitter builder.
+		/// This is equivalent to <code>Builder().Name(name)</code>
+        /// </summary>
+        /// <returns>The builder.</returns>
+        /// <param name="name">The emitter name.</param>
+		public static EmitterBuilder Builder(string name)
+		{
+			return new EmitterBuilder(name);
+		}
+
+        /// <summary>
+        /// Name the event emitter.
+        /// </summary>
+        /// <returns>The builder.</returns>
+        /// <param name="name">The event emitter name.</param>
+		public EmitterBuilder Name(string name)
+		{
+			this.name = name;
+			return this;
+		}
+
+        /// <summary>
+        /// Set the type of event to handle.
+        /// </summary>
+        /// <returns>The builder.</returns>
+        /// <param name="eventType">The event type.</param>
+		public EmitterBuilder Handle(EventType eventType)
+		{
+			return Handle((int)eventType);
+		}
+
+		/// <summary>
+        /// Set the type of event to handle.
+        /// </summary>
+        /// <returns>The builder.</returns>
+        /// <param name="eventType">The event type.</param>
+		public EmitterBuilder Handle(int eventType)
+		{
+			this.type = eventType;
+			return this;
+		}
+
+        /// <summary>
+        /// Build the event emitter.
+        /// </summary>
+        /// <returns>The event emitter.</returns>
+        /// <param name="register">Automatically register the event emitter with EventManager.AddEventemitter().</param>
+		public IEventEmitterEngine Build(bool register = true)
+		{
+			if (string.IsNullOrWhiteSpace(name))
+            {
+                throw new EventParameterMissingException("Event emitter name must be defined before Build() is called");
+            }
+			if (!type.HasValue)
+			{
+				throw new EventParameterMissingException("Event emitter event type must be defined before Build() is called");
+			}
+			SimpleEventEmitterEngine result = new SimpleEventEmitterEngine(type.Value, name);
+			if (register)
+			{
+				EventManager.AddEventEmitter(result);
+			}
+			return result;
+		}
+    }
+}

GamecraftModdingAPI/Events/EventExceptions.cs

@@ -52,4 +52,15 @@ namespace GamecraftModdingAPI.Events
 		{
 		}
 	}
+
+	public class EventParameterMissingException : EventException
+	{
+		public EventParameterMissingException()
+		{
+		}
+
+		public EventParameterMissingException(string message) : base(message)
+		{
+		}
+	}
 }

GamecraftModdingAPI/Events/HandlerBuilder.cs

@@ -0,0 +1,165 @@
+using System;
+
+using Svelto.ECS;
+
+namespace GamecraftModdingAPI.Events
+{
+    public class HandlerBuilder
+    {
+		private string name;
+
+		private int? type;
+
+		private Action<EntitiesDB> activated;
+
+		private Action<EntitiesDB> destroyed;
+
+        /// <summary>
+        /// Create a new event handler builder.
+        /// </summary>
+        public HandlerBuilder()
+        {
+        }
+
+        /// <summary>
+        /// Create a new event handler builder.
+		/// This is equivalent to new <code>HandlerBuilder().Name(name)</code>
+        /// </summary>
+        /// <param name="name">The handler name.</param>
+		public HandlerBuilder(string name)
+		{
+			this.name = name;
+		}
+
+        /// <summary>
+		/// Create and return an event handler builder.
+        /// </summary>
+        /// <returns>The builder.</returns>
+		public static HandlerBuilder Builder()
+		{
+			return new HandlerBuilder();
+		}
+
+        /// <summary>
+        /// Create and return an event handler builder.
+		/// This is equivalent to <code>Builder().Name(name)</code>
+        /// </summary>
+        /// <returns>The builder.</returns>
+        /// <param name="name">The handler name.</param>
+		public static HandlerBuilder Builder(string name)
+		{
+			return new HandlerBuilder(name);
+		}
+
+        /// <summary>
+        /// Name the event handler.
+        /// </summary>
+        /// <returns>The builder.</returns>
+        /// <param name="name">The event handler name.</param>
+		public HandlerBuilder Name(string name)
+		{
+			this.name = name;
+			return this;
+		}
+
+        /// <summary>
+        /// Set the action to perform on when the activated event occurs.
+        /// </summary>
+        /// <returns>The builder.</returns>
+        /// <param name="action">The activated event action.</param>
+		public HandlerBuilder OnActivation(Action action)
+		{
+			return OnActivation((_) => { action(); });
+		}
+
+		/// <summary>
+        /// Set the action to perform on when the activated event occurs.
+        /// </summary>
+        /// <returns>The builder.</returns>
+        /// <param name="action">The activated event action.</param>
+		public HandlerBuilder OnActivation(Action<EntitiesDB> action)
+		{
+			this.activated = action;
+			return this;
+		}
+
+		/// <summary>
+        /// Set the action to perform when the destroyed event occurs.
+        /// </summary>
+        /// <returns>The builder.</returns>
+        /// <param name="action">The destroyed event action.</param>
+		public HandlerBuilder OnDestruction(Action action)
+        {
+            return OnDestruction((_) => { action(); });
+        }
+
+		/// <summary>
+        /// Set the action to perform when the destroyed event occurs.
+        /// </summary>
+        /// <returns>The builder.</returns>
+        /// <param name="action">The destroyed event action.</param>
+        public HandlerBuilder OnDestruction(Action<EntitiesDB> action)
+        {
+			this.destroyed = action;
+            return this;
+        }
+
+        /// <summary>
+        /// Set the type of event to handle.
+        /// </summary>
+        /// <returns>The builder.</returns>
+        /// <param name="eventType">The event type.</param>
+		public HandlerBuilder Handle(EventType eventType)
+		{
+			return Handle((int)eventType);
+		}
+
+		/// <summary>
+        /// Set the type of event to handle.
+        /// </summary>
+        /// <returns>The builder.</returns>
+        /// <param name="eventType">The event type.</param>
+		public HandlerBuilder Handle(int eventType)
+		{
+			this.type = eventType;
+			return this;
+		}
+
+        /// <summary>
+        /// Build the event handler.
+        /// </summary>
+        /// <returns>The event handler.</returns>
+        /// <param name="register">Automatically register the event handler with EventManager.AddEventHandler().</param>
+		public IEventHandlerEngine Build(bool register = true)
+		{
+			if (string.IsNullOrWhiteSpace(name))
+            {
+                throw new EventParameterMissingException("Event handler name must be defined before Build() is called");
+            }
+			if (activated == null && destroyed == null)
+			{
+				throw new EventParameterMissingException("Event handler destruction or activated event action must be defined before Build() is called");
+			}
+			if (!type.HasValue)
+			{
+				throw new EventParameterMissingException("Event handler event type must be defined before Build() is called");
+			}
+			Action<EntitiesDB> validActivated = activated;
+            if (validActivated == null)
+			{
+				validActivated = (_) => { };
+			}
+			Action<EntitiesDB> validDestroyed = destroyed;
+            if (validDestroyed == null)
+            {
+                validDestroyed = (_) => { };
+            }
+			SimpleEventHandlerEngine result = new SimpleEventHandlerEngine(validActivated, validDestroyed, type.Value, name);
+			if (register)
+			{
+				EventManager.AddEventHandler(result);
+			}
+			return result;
+		}
+    }
+}

GamecraftModdingAPI/Tests/GamecraftModdingAPIPluginTest.cs

@@ -61,28 +61,54 @@ namespace GamecraftModdingAPI.Tests
 
 			Utility.VersionTracking.Enable();
 
-            // debug/test handlers
-            EventManager.AddEventHandler(new SimpleEventHandlerEngine(() => { Logging.Log("App Inited event!"); }, () => { },
-                EventType.ApplicationInitialized, "appinit API debug"));
-            EventManager.AddEventHandler(new SimpleEventHandlerEngine(() => { Logging.Log("Menu Activated event!"); },
-                () => { Logging.Log("Menu Destroyed event!"); },
-                EventType.Menu, "menuact API debug"));
-            EventManager.AddEventHandler(new SimpleEventHandlerEngine(() => { Logging.Log("Menu Switched To event!"); }, () => { },
-                EventType.MenuSwitchedTo, "menuswitch API debug"));
-            EventManager.AddEventHandler(new SimpleEventHandlerEngine(() => { Logging.Log("Game Activated event!"); },
-                () => { Logging.Log("Game Destroyed event!"); },
-                EventType.Game, "gameact API debug"));
-            EventManager.AddEventHandler(new SimpleEventHandlerEngine(() => { Logging.Log("Game Reloaded event!"); }, () => { },
-                EventType.GameReloaded, "gamerel API debug"));
-            EventManager.AddEventHandler(new SimpleEventHandlerEngine(() => { Logging.Log("Game Switched To event!"); }, () => { },
-                EventType.GameSwitchedTo, "gameswitch API debug"));
-			EventManager.AddEventHandler(new SimpleEventHandlerEngine(() => { Logging.Log("Game Mode Simulation Switched To event!"); }, () => { },
-			    EventType.SimulationSwitchedTo, "simulationswitch API debug"));
-			EventManager.AddEventHandler(new SimpleEventHandlerEngine(() => { Logging.Log("Game Mode Build Switched To event!"); }, () => { },
-                EventType.BuildSwitchedTo, "buildswitch API debug"));
-
-			EventManager.AddEventHandler(new SimpleEventHandlerEngine(() => { throw new Exception(""); }, () => {},
-			    EventType.Menu, "menu activated API error thrower test"));
+			// debug/test handlers
+			HandlerBuilder.Builder()
+						  .Name("appinit API debug")
+						  .Handle(EventType.ApplicationInitialized)
+						  .OnActivation(() => { Logging.Log("App Inited event!"); })
+						  .Build();
+
+			HandlerBuilder.Builder("menuact API debug")
+						  .Handle(EventType.Menu)
+			              .OnActivation(() => { Logging.Log("Menu Activated event!"); })
+						  .OnDestruction(() => { Logging.Log("Menu Destroyed event!"); })
+						  .Build();
+
+			HandlerBuilder.Builder("menuswitch API debug")
+			              .Handle(EventType.MenuSwitchedTo)
+			              .OnActivation(() => { Logging.Log("Menu Switched To event!"); })
+                          .Build();
+
+			HandlerBuilder.Builder("gameact API debug")
+                          .Handle(EventType.Menu)
+			              .OnActivation(() => { Logging.Log("Game Activated event!"); })
+			              .OnDestruction(() => { Logging.Log("Game Destroyed event!"); })
+                          .Build();
+
+			HandlerBuilder.Builder("gamerel API debug")
+			              .Handle(EventType.GameReloaded)
+			              .OnActivation(() => { Logging.Log("Game Reloaded event!"); })
+                          .Build();
+
+			HandlerBuilder.Builder("gameswitch API debug")
+			              .Handle(EventType.GameSwitchedTo)
+			              .OnActivation(() => { Logging.Log("Game Switched To event!"); })
+                          .Build();
+
+			HandlerBuilder.Builder("simulationswitch API debug")
+			              .Handle(EventType.SimulationSwitchedTo)
+			              .OnActivation(() => { Logging.Log("Game Mode Simulation Switched To event!"); })
+                          .Build();
+
+			HandlerBuilder.Builder("buildswitch API debug")
+			              .Handle(EventType.BuildSwitchedTo)
+			              .OnActivation(() => { Logging.Log("Game Mode Build Switched To event!"); })
+                          .Build();
+
+			HandlerBuilder.Builder("menu activated API error thrower test")
+						  .Handle(EventType.Menu)
+						  .OnActivation(() => { throw new Exception("Event Handler always throws an exception!"); })
+						  .Build();
 
             // debug/test commands
 			if (Dependency.Hell("ExtraCommands"))