diff --git a/src/Base/IStateMachine.cs b/src/Base/IStateMachine.cs
index 3f9bd18..87e60a1 100644
--- a/src/Base/IStateMachine.cs
+++ b/src/Base/IStateMachine.cs
@@ -1,6 +1,13 @@
 
+using System.Collections.Generic;
+
 namespace FSM
 {
+	public interface IStateMachine : IState
+	{
+		IReadOnlyList<IState> States { get; }
+	}
+	
 	/// <summary>
 	/// A subset of features that every parent state machine has to provide.
 	/// It is useful, as it allows the parent state machine to be independent from the
@@ -9,7 +16,7 @@ namespace FSM
 	/// => An abstraction layer
 	/// </summary>
 	/// <typeparam name="TStateId">They type of the names / ids of the sub states</typeparam>
-	public interface IStateMachine<TStateId>
+	public interface IStateMachine<TStateId> : IStateMachine
 	{
 		/// <summary>
 		/// Tells the state machine that, if there is a state transition pending,
@@ -21,5 +28,6 @@ public interface IStateMachine<TStateId>
 
 		StateBase<TStateId> ActiveState { get; }
 		TStateId ActiveStateName { get; }
+		TStateId PrevStateName { get; }
 	}
 }
diff --git a/src/Base/StateBase.cs b/src/Base/StateBase.cs
index f4f4a58..d56def2 100644
--- a/src/Base/StateBase.cs
+++ b/src/Base/StateBase.cs
@@ -1,17 +1,26 @@
+using System;
+using System.Collections.Generic;
 using UnityEngine;
 
 namespace FSM
 {
+	public interface IState
+	{
+		
+	}
+	
 	/// <summary>
 	/// The base class of all states
 	/// </summary>
-	public class StateBase<TStateId>
+	public class StateBase<TStateId> : IState
 	{
 		public bool needsExitTime;
 		public TStateId name;
 
 		public IStateMachine<TStateId> fsm;
 
+		private Dictionary<Type, Delegate> commandHandlers;
+
 		/// <summary>
 		/// Initialises a new instance of the BaseState class
 		/// </summary>
@@ -46,6 +55,45 @@ public virtual void OnLogic() {
 
 		}
 
+		/// <summary>
+		/// Set command handler
+		/// </summary>
+		/// <param name="handler">Handler delegate</param>
+		/// <typeparam name="TCommand">Type of command</typeparam>
+		protected void SetCommandHandler<TCommand>(Action<TCommand> handler)
+		{
+			if (commandHandlers == null)
+			{
+				commandHandlers = new Dictionary<Type, Delegate>();
+			}
+
+			commandHandlers[typeof(TCommand)] = handler;
+		}
+
+		protected bool CanProcessCommand<TCommand>()
+		{
+			if (commandHandlers != null)
+			{
+				commandHandlers.TryGetValue(typeof(TCommand), out var commandHandler);
+				return commandHandler is Action<TCommand>;
+			}
+			return false;
+		}
+
+		/// <summary>
+		/// Called when state is active and fsm was call OnCommand
+		/// </summary>
+		/// <param name="command"></param>
+		/// <typeparam name="TCommand"></typeparam>
+		public virtual void OnCommand<TCommand>(TCommand command = default)
+		{
+			if (commandHandlers != null)
+			{
+				commandHandlers.TryGetValue(typeof(TCommand), out var commandHandler);
+				(commandHandler as Action<TCommand>)?.Invoke(command);
+			}
+		}
+
 		/// <summary>
 		/// Called when the state machine transitions from this state to another state (exits this state)
 		/// </summary>
diff --git a/src/HybridStateMachine.cs b/src/HybridStateMachine.cs
index d7b5525..ebf1aae 100644
--- a/src/HybridStateMachine.cs
+++ b/src/HybridStateMachine.cs
@@ -1,5 +1,6 @@
 using UnityEngine;
 using System;
+using System.Collections.Generic;
 
 namespace FSM
 {
@@ -33,11 +34,17 @@ public class HybridStateMachine<TOwnId, TStateId, TEvent> : StateMachine<TOwnId,
 		/// 	Determins whether the state machine as a state of a parent state machine is allowed to instantly
 		/// 	exit on a transition (false), or if it should wait until the active state is ready for a
 		/// 	state change (true).</param>
+		/// <param name="stateIdComparer">Comparer which will be used for lookup by state id.
+		///		Recommended for struct typed TStateId or custom lookup logic.</param>
+		/// <param name="eventComparer">Comparer which will be used for lookup by event.
+		///		Recommended for struct typed TEvent or custom lookup logic.</param>
 		public HybridStateMachine(
 				Action<HybridStateMachine<TOwnId, TStateId, TEvent>> onEnter = null,
 				Action<HybridStateMachine<TOwnId, TStateId, TEvent>> onLogic = null,
 				Action<HybridStateMachine<TOwnId, TStateId, TEvent>> onExit = null,
-				bool needsExitTime = false) : base(needsExitTime)
+				bool needsExitTime = false,
+				IEqualityComparer<TStateId> stateIdComparer = null, 
+				IEqualityComparer<TEvent> eventComparer = null) : base(needsExitTime, stateIdComparer, eventComparer)
 		{
 			this.onEnter = onEnter;
 			this.onLogic = onLogic;
@@ -76,7 +83,9 @@ public HybridStateMachine(
 			Action<HybridStateMachine<TStateId, TStateId, TEvent>> onEnter = null,
 			Action<HybridStateMachine<TStateId, TStateId, TEvent>> onLogic = null,
 			Action<HybridStateMachine<TStateId, TStateId, TEvent>> onExit = null,
-			bool needsExitTime = false) : base(onEnter, onLogic, onExit, needsExitTime)
+			bool needsExitTime = false,
+			IEqualityComparer<TStateId> stateIdComparer = null, 
+			IEqualityComparer<TEvent> eventComparer = null) : base(onEnter, onLogic, onExit, needsExitTime, stateIdComparer, eventComparer)
 		{
 		}
 	}
@@ -87,7 +96,8 @@ public HybridStateMachine(
 			Action<HybridStateMachine<TStateId, TStateId, string>> onEnter = null,
 			Action<HybridStateMachine<TStateId, TStateId, string>> onLogic = null,
 			Action<HybridStateMachine<TStateId, TStateId, string>> onExit = null,
-			bool needsExitTime = false) : base(onEnter, onLogic, onExit, needsExitTime)
+			bool needsExitTime = false,
+			IEqualityComparer<TStateId> stateIdComparer = null) : base(onEnter, onLogic, onExit, needsExitTime, stateIdComparer)
 		{
 		}
 	}
diff --git a/src/State.cs b/src/State.cs
index 6ce8c4b..1603169 100644
--- a/src/State.cs
+++ b/src/State.cs
@@ -28,21 +28,36 @@ public class State<TStateId> : StateBase<TStateId>
 		/// <param name="needsExitTime">Determins if the state is allowed to instantly
 		/// 	exit on a transition (false), or if the state machine should wait until the state is ready for a
 		/// 	state change (true)</param>
+		/// <param name="commands">Commands which will be registered for OnCommand calls</param>
 		public State(
 				Action<State<TStateId>> onEnter = null,
 				Action<State<TStateId>> onLogic = null,
 				Action<State<TStateId>> onExit = null,
 				Func<State<TStateId>, bool> canExit = null,
-				bool needsExitTime = false) : base(needsExitTime)
+				bool needsExitTime = false,
+				params CommandBase<TStateId>[] commands) : base(needsExitTime)
 		{
 			this.onEnter = onEnter;
 			this.onLogic = onLogic;
 			this.onExit = onExit;
 			this.canExit = canExit;
 
+			if (commands != null)
+			{
+				foreach (var command in commands)
+				{
+					command?.Register(this);
+				}
+			}
+
 			this.timer = new Timer();
 		}
 
+		internal void SetCommandHandlerInternal<TCommand>(Action<TCommand> handler)
+		{
+			SetCommandHandler(handler);
+		}
+
 		public override void OnEnter()
 		{
 			timer.Reset();
@@ -76,7 +91,8 @@ public State(
 			Action<State<string>> onLogic = null,
 			Action<State<string>> onExit = null,
 			Func<State<string>, bool> canExit = null,
-			bool needsExitTime = false) : base(onEnter, onLogic, onExit, canExit, needsExitTime)
+			bool needsExitTime = false,
+			params CommandBase<string>[] commands) : base(onEnter, onLogic, onExit, canExit, needsExitTime, commands)
 		{
 		}
 	}
diff --git a/src/StateMachine.cs b/src/StateMachine.cs
index 33455e8..c2fa6aa 100644
--- a/src/StateMachine.cs
+++ b/src/StateMachine.cs
@@ -32,6 +32,12 @@ private class StateBundle
 			public StateBase<TStateId> state;
 			public List<TransitionBase<TStateId>> transitions;
 			public Dictionary<TEvent, List<TransitionBase<TStateId>>> triggerToTransitions;
+			private IEqualityComparer<TEvent> eventComparer;
+
+			public StateBundle(IEqualityComparer<TEvent> eventComparer)
+			{
+				this.eventComparer = eventComparer;
+			}
 
 			public void AddTransition(TransitionBase<TStateId> t)
 			{
@@ -40,8 +46,12 @@ public void AddTransition(TransitionBase<TStateId> t)
 			}
 
 			public void AddTriggerTransition(TEvent trigger, TransitionBase<TStateId> transition) {
-				triggerToTransitions = triggerToTransitions
-					?? new Dictionary<TEvent, List<TransitionBase<TStateId>>>();
+				if (triggerToTransitions == null)
+				{
+					triggerToTransitions = eventComparer == null
+						? new Dictionary<TEvent, List<TransitionBase<TStateId>>>()
+						: new Dictionary<TEvent, List<TransitionBase<TStateId>>>(eventComparer);
+				}
 
 				List<TransitionBase<TStateId>> transitionsOfTrigger;
 
@@ -55,6 +65,9 @@ public void AddTriggerTransition(TEvent trigger, TransitionBase<TStateId> transi
 			}
 		}
 
+		private IEqualityComparer<TEvent> eventComparer;
+		private IEqualityComparer<TStateId> stateIdComparer;
+		
 		// A cached empty list of transitions (For improved readability, less GC)
 		private static readonly List<TransitionBase<TStateId>> noTransitions
 			= new List<TransitionBase<TStateId>>(0);
@@ -65,8 +78,7 @@ private static readonly Dictionary<TEvent, List<TransitionBase<TStateId>>> noTri
 		private (TStateId state, bool isPending) pendingState = (default, false);
 
 		// Central storage of states
-		private Dictionary<TStateId, StateBundle> nameToStateBundle
-			= new Dictionary<TStateId, StateBundle>();
+		private Dictionary<TStateId, StateBundle> nameToStateBundle; 
 
 		private StateBase<TStateId> activeState = null;
 		private List<TransitionBase<TStateId>> activeTransitions = noTransitions;
@@ -77,6 +89,10 @@ private List<TransitionBase<TStateId>> transitionsFromAny
 		private Dictionary<TEvent, List<TransitionBase<TStateId>>> triggerTransitionsFromAny
 			= new Dictionary<TEvent, List<TransitionBase<TStateId>>>();
 
+		private readonly List<IState> states;
+
+		public IReadOnlyList<IState> States { get; }
+
 		public StateBase<TStateId> ActiveState
 		{
 			get
@@ -92,6 +108,7 @@ public StateBase<TStateId> ActiveState
 			}
 		}
 		public TStateId ActiveStateName => ActiveState.name;
+		public TStateId PrevStateName { get; private set; }
 
 		private bool IsRootFsm => fsm == null;
 
@@ -102,9 +119,19 @@ public StateBase<TStateId> ActiveState
 		/// 	Determins whether the state machine as a state of a parent state machine is allowed to instantly
 		/// 	exit on a transition (false), or if it should wait until the active state is ready for a
 		/// 	state change (true).</param>
-		public StateMachine(bool needsExitTime = true) : base(needsExitTime)
+		/// <param name="stateIdComparer">Comparer which will be used for lookup by state id.
+		///		Recommended for struct typed TStateId or custom lookup logic.</param>
+		/// <param name="eventComparer">Comparer which will be used for lookup by event.
+		///		Recommended for struct typed TEvent or custom lookup logic.</param>
+		public StateMachine(bool needsExitTime = true, IEqualityComparer<TStateId> stateIdComparer = null, IEqualityComparer<TEvent> eventComparer = null) : base(needsExitTime)
 		{
-
+			this.eventComparer = eventComparer;
+			this.stateIdComparer = stateIdComparer;
+			nameToStateBundle = stateIdComparer == null
+				? new Dictionary<TStateId, StateBundle>()
+				: new Dictionary<TStateId, StateBundle>(stateIdComparer);
+			states = new List<IState>();
+			States = states.AsReadOnly();
 		}
 
 		/// <summary>
@@ -151,6 +178,7 @@ private void ChangeState(TStateId name)
 			activeTransitions = bundle.transitions ?? noTransitions;
 			activeTriggerTransitions = bundle.triggerToTransitions ?? noTriggerTransitions;
 
+			PrevStateName = activeState != null ? activeState.name : default;
 			activeState = bundle.state;
 			activeState.OnEnter();
 
@@ -269,8 +297,17 @@ public override void OnLogic()
 				TransitionBase<TStateId> transition = transitionsFromAny[i];
 
 				// Don't transition to the "to" state, if that state is already the active state
-				if (transition.to.Equals(activeState.name))
-					continue;
+				if (stateIdComparer != null)
+				{
+					if (stateIdComparer.Equals(transition.to, activeState.name))
+						continue;
+				}
+				else
+				{
+					if (transition.to.Equals(activeState.name))
+						continue;	
+				}
+				
 
 				if (TryTransition(transition))
 					break;
@@ -288,6 +325,28 @@ public override void OnLogic()
 			activeState.OnLogic();
 		}
 
+		public override void OnCommand<TCommand>(TCommand command = default)
+		{
+			if (CanProcessCommand<TCommand>())
+			{
+				base.OnCommand(command);
+				return;
+			}
+			
+			SendCommandToStates(command);
+		}
+
+		protected void SendCommandToStates<TCommand>(TCommand command = default)
+		{
+			if (activeState == null)
+			{
+				throw new FSM.Exceptions.StateMachineNotInitializedException(
+					"Running OnCommand"
+				);
+			}
+			activeState.OnCommand(command);
+		}
+
 		public override void OnExit()
 		{
 			if (activeState != null)
@@ -310,7 +369,7 @@ private StateBundle GetOrCreateStateBundle(TStateId name) {
 			StateBundle bundle;
 
 			if (! nameToStateBundle.TryGetValue(name, out bundle)) {
-				bundle = new StateBundle();
+				bundle = new StateBundle(eventComparer);
 				nameToStateBundle.Add(name, bundle);
 			}
 
@@ -329,7 +388,12 @@ public void AddState(TStateId name, StateBase<TStateId> state)
 			state.Init();
 
 			StateBundle bundle = GetOrCreateStateBundle(name);
+			if (bundle.state != null)
+			{
+				states.Remove(bundle.state);
+			}
 			bundle.state = state;
+			states.Add(state);
 
 			if (nameToStateBundle.Count == 1 && !startState.hasState)
 			{
@@ -429,8 +493,16 @@ private bool TryTrigger(TEvent trigger)
 				{
 					TransitionBase<TStateId> transition = triggerTransitions[i];
 
-					if (transition.to.Equals(activeState.name))
-						continue;
+					if (stateIdComparer != null)
+					{
+						if (stateIdComparer.Equals(transition.to, activeState.name))
+							continue;
+					}
+					else
+					{
+						if (transition.to.Equals(activeState.name))
+							continue;	
+					}
 
 					if (TryTransition(transition))
 						return true;
@@ -581,7 +653,7 @@ public void AddTransitionFromAny(
 			Func<Transition<TStateId>, bool> condition = null,
 			bool forceInstantly = false)
 		{
-			AddTransition(CreateOptimizedTransition(default, to, condition, forceInstantly));
+			AddTransitionFromAny(CreateOptimizedTransition(default, to, condition, forceInstantly));
 		}
 
 		/// <summary>
@@ -618,14 +690,15 @@ public void AddTriggerTransitionFromAny(
 
 	public class StateMachine<TStateId, TEvent> : StateMachine<TStateId, TStateId, TEvent>
 	{
-		public StateMachine(bool needsExitTime = true) : base(needsExitTime)
+		public StateMachine(bool needsExitTime = true, IEqualityComparer<TStateId> stateIdComparer = null, IEqualityComparer<TEvent> eventComparer = null) 
+			: base(needsExitTime, stateIdComparer, eventComparer)
 		{
 		}
 	}
 
 	public class StateMachine<TStateId> : StateMachine<TStateId, TStateId, string>
 	{
-		public StateMachine(bool needsExitTime = true) : base(needsExitTime)
+		public StateMachine(bool needsExitTime = true, IEqualityComparer<TStateId> stateIdComparer = null) : base(needsExitTime, stateIdComparer)
 		{
 		}
 	}
diff --git a/src/Util/CommandBase.cs b/src/Util/CommandBase.cs
new file mode 100644
index 0000000..14b916d
--- /dev/null
+++ b/src/Util/CommandBase.cs
@@ -0,0 +1,38 @@
+using System;
+
+namespace FSM
+{
+    public abstract class CommandBase<TStateId>
+    {
+        internal abstract void Register(State<TStateId> state);
+    }
+		
+    public class Command<TStateId, TCommand>: CommandBase<TStateId>
+    {
+        private readonly Action<State<TStateId>, TCommand> handler;
+
+        public Command(Action<State<TStateId>, TCommand> handler)
+        {
+            this.handler = handler;
+        }
+
+        internal override void Register(State<TStateId> state)
+        {
+            if (handler == null)
+            {
+                return;
+            }
+            state.SetCommandHandlerInternal<TCommand>(command =>
+            {
+                handler?.Invoke(state, command);
+            });
+        }
+    }
+
+    public class Command<TCommand> : Command<string, TCommand>
+    {
+        public Command(Action<State<string>, TCommand> handler) : base(handler)
+        {
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Util/CommandBase.cs.meta b/src/Util/CommandBase.cs.meta
new file mode 100644
index 0000000..4a7604d
--- /dev/null
+++ b/src/Util/CommandBase.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 72a64ad22f2c4f31a749008082781de3
+timeCreated: 1630781377
\ No newline at end of file