Game Update :

Assets/Scripts/Enemy/OnePunchMan/OnePunchManStateMachine.cs

@@ -3,13 +3,10 @@
 
 namespace StatePattern.Enemy
 {
-    public class OnePunchManStateMachine : IStateMachine
+    public class OnePunchManStateMachine : GenericStateMachine<OnePunchManController>
     {
-        private OnePunchManController Owner;
-        private IState currentState;
-        protected Dictionary<States, IState> States = new Dictionary<States, IState>();
 
-        public OnePunchManStateMachine(OnePunchManController Owner)
+        public OnePunchManStateMachine(OnePunchManController Owner) : base(Owner)
         {
             this.Owner = Owner;
             CreateStates();
@@ -18,28 +15,9 @@ public OnePunchManStateMachine(OnePunchManController Owner)
 
         private void CreateStates()
         {
-            States.Add(StateMachine.States.IDLE, new IdleState(this));
-            States.Add(StateMachine.States.ROTATING, new RotatingState(this));
-            States.Add(StateMachine.States.SHOOTING, new ShootingState(this));
+            States.Add(StateMachine.States.IDLE, new IdleState<OnePunchManController>(this));
+            States.Add(StateMachine.States.ROTATING, new RotatingState<OnePunchManController>(this));
+            States.Add(StateMachine.States.SHOOTING, new ShootingState<OnePunchManController>(this));
         }
-
-        private void SetOwner()
-        {
-            foreach(IState state in States.Values)
-            {
-                state.Owner = Owner;
-            }
-        }
-
-        public void Update() => currentState?.Update();
-
-        protected void ChangeState(IState newState)
-        {
-            currentState?.OnStateExit();
-            currentState = newState;
-            currentState?.OnStateEnter();
-        }
-
-        public void ChangeState(States newState) => ChangeState(States[newState]);
     }
 }

Assets/Scripts/Enemy/PatrolMan/PatrolManStateMachine.cs

@@ -4,13 +4,9 @@
 
 namespace StatePattern.Enemy
 {
-    public class PatrolManStateMachine : IStateMachine
+    public class PatrolManStateMachine : GenericStateMachine<PatrolManController>
     {
-        private PatrolManController Owner;
-        private IState currentState;
-        protected Dictionary<States, IState> States = new Dictionary<States, IState>();
-
-        public PatrolManStateMachine(PatrolManController Owner)
+        public PatrolManStateMachine(PatrolManController Owner) : base(Owner)
         {
             this.Owner = Owner;
             CreateStates();
@@ -19,29 +15,10 @@ public PatrolManStateMachine(PatrolManController Owner)
 
         private void CreateStates()
         {
-            States.Add(StateMachine.States.IDLE, new IdleState(this));
-            States.Add(StateMachine.States.PATROLLING, new PatrollingState(this));
-            States.Add(StateMachine.States.CHASING, new ChasingState(this));
-            States.Add(StateMachine.States.SHOOTING, new ShootingState(this));
+            States.Add(StateMachine.States.IDLE, new IdleState<PatrolManController>(this));
+            States.Add(StateMachine.States.PATROLLING, new PatrollingState<PatrolManController>(this));
+            States.Add(StateMachine.States.CHASING, new ChasingState<PatrolManController>(this));
+            States.Add(StateMachine.States.SHOOTING, new ShootingState<PatrolManController>(this));
         }
-
-        private void SetOwner()
-        {
-            foreach (IState state in States.Values)
-            {
-                state.Owner = Owner;
-            }
-        }
-
-        public void Update() => currentState?.Update();
-
-        protected void ChangeState(IState newState)
-        {
-            currentState?.OnStateExit();
-            currentState = newState;
-            currentState?.OnStateEnter();
-        }
-
-        public void ChangeState(States newState) => ChangeState(States[newState]);
     }
 }

Assets/Scripts/Enemy/States/ChasingState.cs

@@ -6,13 +6,13 @@
 
 namespace StatePattern.Enemy
 {
-    public class ChasingState : IState
+    public class ChasingState<T> : IState where T : EnemyController
     {
         public EnemyController Owner { get; set; }
-        private IStateMachine stateMachine;
+        private GenericStateMachine<T> stateMachine;
         private PlayerController target;
 
-        public ChasingState(IStateMachine stateMachine) => this.stateMachine = stateMachine;
+        public ChasingState(GenericStateMachine<T> stateMachine) => this.stateMachine = stateMachine;
 
         public void OnStateEnter()
         {

Assets/Scripts/Enemy/States/IdleState.cs

@@ -3,13 +3,13 @@
 
 namespace StatePattern.Enemy
 {
-    public class IdleState : IState
+    public class IdleState<T> : IState where T : EnemyController
     {
         public EnemyController Owner { get; set; }
-        private IStateMachine stateMachine;
+        private GenericStateMachine<T> stateMachine;
         private float timer;
 
-        public IdleState(IStateMachine stateMachine) => this.stateMachine = stateMachine;
+        public IdleState(GenericStateMachine<T> stateMachine) => this.stateMachine = stateMachine;
 
         public void OnStateEnter() => ResetTimer();
 
@@ -18,7 +18,7 @@ public void Update()
             timer -= Time.deltaTime;
             if (timer <= 0)
             {
-                if (Owner.GetType() == typeof(OnePunchManController))
+                if (typeof(T) == typeof(OnePunchManController))
                     stateMachine.ChangeState(States.ROTATING);
                 else
                     stateMachine.ChangeState(States.PATROLLING);

Assets/Scripts/Enemy/States/PatrollingState.cs

@@ -4,14 +4,14 @@
 
 namespace StatePattern.Enemy
 {
-    public class PatrollingState : IState
+    public class PatrollingState <T>: IState where T : EnemyController 
     {
         public EnemyController Owner { get; set; }
-        private IStateMachine stateMachine;
+        private GenericStateMachine <T> stateMachine;
         private int currentPatrollingIndex = -1;
         private Vector3 destination;
 
-        public PatrollingState(IStateMachine stateMachine) => this.stateMachine = stateMachine;
+        public PatrollingState(GenericStateMachine <T> stateMachine) => this.stateMachine = stateMachine;
 
         public void OnStateEnter()
         {

Assets/Scripts/Enemy/States/RotatingState.cs

@@ -3,13 +3,13 @@
 
 namespace StatePattern.Enemy
 {
-    public class RotatingState : IState
+    public class RotatingState<T> : IState where T : EnemyController
     {
         public EnemyController Owner { get; set; }
-        private IStateMachine stateMachine;
+        private GenericStateMachine<T> stateMachine;
         private float targetRotation;
 
-        public RotatingState(IStateMachine stateMachine) => this.stateMachine = stateMachine;
+        public RotatingState(GenericStateMachine<T> stateMachine) => this.stateMachine = stateMachine;
 
         public void OnStateEnter() => targetRotation = (Owner.Rotation.eulerAngles.y + 180) % 360;
 

Assets/Scripts/Enemy/States/ShootingState.cs

@@ -5,14 +5,14 @@
 
 namespace StatePattern.Enemy
 {
-    public class ShootingState : IState
+    public class ShootingState <T> : IState where T :EnemyController
     {
         public EnemyController Owner { get; set; }
-        private IStateMachine stateMachine;
+        private GenericStateMachine<T> stateMachine;
         private PlayerController target;
         private float shootTimer;
 
-        public ShootingState(IStateMachine stateMachine) => this.stateMachine = stateMachine;
+        public ShootingState(GenericStateMachine<T> stateMachine) => this.stateMachine = stateMachine;
 
         public void OnStateEnter()
         {

Assets/Scripts/StateMachine/GenericStateMachine.cs

@@ -0,0 +1,33 @@
+using StatePattern.Enemy;
+using System.Collections.Generic;
+
+namespace StatePattern.StateMachine
+{
+    public class GenericStateMachine<T> where T : EnemyController
+    {
+        protected T Owner;
+        protected IState currentState;
+        protected Dictionary<States, IState> States = new Dictionary<States, IState>();
+
+        public GenericStateMachine(T Owner) => this.Owner = Owner;
+
+        public void Update() => currentState?.Update();
+
+        protected void ChangeState(IState newState)
+        {
+            currentState?.OnStateExit();
+            currentState = newState;
+            currentState?.OnStateEnter();
+        }
+
+        public void ChangeState(States newState) => ChangeState(States[newState]);
+
+        protected void SetOwner()
+        {
+            foreach (IState state in States.Values)
+            {
+                state.Owner = Owner;
+            }
+        }
+    }
+}

Assets/Scripts/StateMachine/States.cs

@@ -0,0 +1,12 @@
+namespace StatePattern.StateMachine
+{
+    public enum States
+    {
+        IDLE,
+        ROTATING,
+        SHOOTING,
+        PATROLLING,
+        CHASING
+    }
+
+}