Game Update :

Assets/Scenes/GameScene.unity

@@ -38,7 +38,7 @@ RenderSettings:
   m_ReflectionIntensity: 1
   m_CustomReflection: {fileID: 0}
   m_Sun: {fileID: 705507994}
-  m_IndirectSpecularColor: {r: 0.17276844, g: 0.21589246, b: 0.2978263, a: 1}
+  m_IndirectSpecularColor: {r: 0.172768, g: 0.21589167, b: 0.29782546, a: 1}
   m_UseRadianceAmbientProbe: 0
 --- !u!157 &3
 LightmapSettings:
@@ -798,6 +798,7 @@ MonoBehaviour:
   playerScriptableObject: {fileID: 11400000, guid: 4240caefbf2e2f64eb8046b7c92646e0, type: 2}
   levelScriptableObjects:
   - {fileID: 11400000, guid: bada358cc71564c49831629438d87724, type: 2}
+  - {fileID: 11400000, guid: 3ceefc333a7c35a4d8743f64f88754db, type: 2}
   sfxSource: {fileID: 629913882}
   bgMusicSource: {fileID: 973737936}
 --- !u!4 &2053379264

Assets/Scripts/Enemy/EnemyController.cs

@@ -13,7 +13,7 @@ public class EnemyController
 
         protected int currentHealth;
         protected EnemyState currentState;
-        protected NavMeshAgent Agent => enemyView.Agent;
+        public NavMeshAgent Agent => enemyView.Agent;
         public EnemyScriptableObject Data => enemyScriptableObject;
         public Quaternion Rotation => enemyView.transform.rotation;
         public Vector3 Position => enemyView.transform.position;

Assets/Scripts/Enemy/OnePunchMan/IState.cs

@@ -2,7 +2,7 @@ namespace StatePattern.Enemy
 {
     public interface IState
     {
-        public OnePunchManController Owner { get; set; }
+        public EnemyController Owner { get; set; }
         public void OnStateEnter();
         public void Update();
         public void OnStateExit();

Assets/Scripts/Enemy/OnePunchMan/IStateMachine.cs

@@ -0,0 +1,19 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace StatePattern.StateMachine
+{
+    public interface IStateMachine
+    {
+        public void ChangeState(States newState);
+    }
+    public enum States
+    {
+        IDLE,
+        ROTATING,
+        SHOOTING,
+        PATROLLING,
+        CHASING
+    }
+}

Assets/Scripts/Enemy/OnePunchMan/OnePunchManStateMachine.cs

@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using StatePattern.StateMachine;
 
 namespace StatePattern.Enemy
 {
@@ -46,6 +47,8 @@ public enum OnePunchManStates
     {
         IDLE,
         ROTATING,
-        SHOOTING
+        SHOOTING,
+        PATROLLING,
+        CHASING
     }
 }

Assets/Scripts/Enemy/PatrolManStateMachine/PatrolManController.cs

@@ -0,0 +1,39 @@
+using StatePattern.Player;
+using StatePattern.StateMachine;
+using StatePattern.Main;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace StatePattern.Enemy
+{
+    public class PatrolManController : EnemyController
+    {
+        private PatrolManStateMachine stateMachine;
+
+        public PatrolManController(EnemyScriptableObject enemyScriptableObject) : base(enemyScriptableObject)
+        {
+            enemyView.SetController(this);
+            CreateStateMachine();
+            stateMachine.ChangeState(States.IDLE);
+        }
+
+        private void CreateStateMachine() => stateMachine = new PatrolManStateMachine(this);
+
+        public override void UpdateEnemy()
+        {
+            if (currentState == EnemyState.DEACTIVE)
+                return;
+
+            stateMachine.Update();
+        }
+
+        public override void PlayerEnteredRange(PlayerController targetToSet)
+        {
+            base.PlayerEnteredRange(targetToSet);
+            stateMachine.ChangeState(States.CHASING);
+        }
+
+        public override void PlayerExitedRange() => stateMachine.ChangeState(States.IDLE);
+    }
+}

Assets/Scripts/Enemy/PatrolManStateMachine/PatrolManStateMachine.cs

@@ -0,0 +1,47 @@
+using StatePattern.StateMachine;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace StatePattern.Enemy
+{
+    public class PatrolManStateMachine : IStateMachine
+    {
+        private PatrolManController Owner;
+        private IState currentState;
+        protected Dictionary<States, IState> States = new Dictionary<States, IState>();
+
+        public PatrolManStateMachine(PatrolManController Owner)
+        {
+            this.Owner = Owner;
+            CreateStates();
+            SetOwner();
+        }
+
+        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));
+        }
+
+        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

@@ -0,0 +1,50 @@
+using StatePattern.Main;
+using StatePattern.Player;
+using StatePattern.StateMachine;
+using System.Collections;
+using UnityEngine;
+
+namespace StatePattern.Enemy
+{
+    public class ChasingState : IState
+    {
+        public EnemyController Owner { get; set; }
+        private IStateMachine stateMachine;
+        private PlayerController target;
+
+        public ChasingState(IStateMachine stateMachine) => this.stateMachine = stateMachine;
+
+        public void OnStateEnter()
+        {
+            SetTarget();
+            SetStoppingDistance();
+        }
+
+        public void Update()
+        {
+            MoveTowardsTarget();
+            if (ReachedTarget())
+            {
+                ResetPath();
+                stateMachine.ChangeState(States.SHOOTING);
+            }
+        }
+
+        public void OnStateExit() => target = null;
+
+
+        private void SetTarget() => target = GameService.Instance.PlayerService.GetPlayer();
+
+        private void SetStoppingDistance() => Owner.Agent.stoppingDistance = Owner.Data.PlayerStoppingDistance;
+
+        private bool MoveTowardsTarget() => Owner.Agent.SetDestination(target.Position);
+
+        private bool ReachedTarget() => Owner.Agent.remainingDistance <= Owner.Agent.stoppingDistance;
+
+        private void ResetPath()
+        {
+            Owner.Agent.isStopped = true;
+            Owner.Agent.ResetPath();
+        }
+    }
+}

Assets/Scripts/Enemy/OnePunchMan/States/IdleState.cs → Assets/Scripts/Enemy/States/IdleState.cs

@@ -1,3 +1,4 @@
+using StatePattern.StateMachine;
 using System.Collections;
 using System.Collections.Generic;
 using UnityEngine;
@@ -6,19 +7,19 @@ namespace StatePattern.Enemy
 {
     public class IdleState : IState
     {
-        public OnePunchManController Owner { get; set; }
-        private OnePunchManStateMachine stateMachine;
+        public EnemyController Owner { get; set; }
+        private IStateMachine stateMachine;
         private float timer;
 
-        public IdleState(OnePunchManStateMachine stateMachine) => this.stateMachine = stateMachine;
+        public IdleState(IStateMachine stateMachine) => this.stateMachine = stateMachine;
 
         public void OnStateEnter() => ResetTimer();
 
         public void Update()
         {
             timer -= Time.deltaTime;
             if (timer <= 0)
-                stateMachine.ChangeState(OnePunchManStates.ROTATING);
+                stateMachine.ChangeState(States.ROTATING);
         }
 
         public void OnStateExit() => timer = 0;

Assets/Scripts/Enemy/States/PatrollingState.cs

@@ -0,0 +1,55 @@
+using StatePattern.StateMachine;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace StatePattern.Enemy
+{
+    public class PatrollingState : IState
+    {
+        public EnemyController Owner { get; set; }
+        private IStateMachine stateMachine;
+        private int currentPatrollingIndex = -1;
+        private Vector3 destination;
+
+        public PatrollingState(IStateMachine stateMachine) => this.stateMachine = stateMachine;
+
+        public void OnStateEnter()
+        {
+            SetNextWayPointIndex();
+            destination = GetDestination();
+            MoveTowardsDestination();
+        }
+
+        public void Update() 
+        {
+            if (ReachedDestination())
+                stateMachine.ChangeState(States.IDLE);
+        }
+
+        public void OnStateExit() { }
+
+        private void SetNextWayPointIndex()
+        {
+            if (currentPatrollingIndex == Owner.Data.PatrollingPoints.Count - 1)
+            {
+                currentPatrollingIndex = 0;
+            }
+            else
+            {
+                currentPatrollingIndex++;
+            }
+        }
+        private Vector3 GetDestination() => Owner.Data.PatrollingPoints[currentPatrollingIndex];
+
+        private void MoveTowardsDestination()
+        {
+            Owner.Agent.isStopped = false;
+
+            Owner.Agent.SetDestination(destination);
+        }
+
+        private bool ReachedDestination() => Owner.Agent.remainingDistance <= Owner.Agent.stoppingDistance;
+    }
+}

Assets/Scripts/Enemy/OnePunchMan/States/RotatingState.cs → Assets/Scripts/Enemy/States/RotatingState.cs

@@ -1,3 +1,4 @@
+using StatePattern.StateMachine;
 using System.Collections;
 using System.Collections.Generic;
 using UnityEngine;
@@ -6,19 +7,19 @@ namespace StatePattern.Enemy
 {
     public class RotatingState : IState
     {
-        public OnePunchManController Owner { get; set; }
-        private OnePunchManStateMachine stateMachine;
+        public EnemyController Owner { get; set; }
+        private IStateMachine stateMachine;
         private float targetRotation;
 
-        public RotatingState(OnePunchManStateMachine stateMachine) => this.stateMachine = stateMachine;
+        public RotatingState(IStateMachine stateMachine) => this.stateMachine = stateMachine;
 
         public void OnStateEnter() => targetRotation = (Owner.Rotation.eulerAngles.y + 180) % 360;
 
         public void Update()
         {
             Owner.SetRotation(CalculateRotation());
             if (IsRotationComplete())
-                stateMachine.ChangeState(OnePunchManStates.IDLE);
+                stateMachine.ChangeState(States.IDLE);
         }
 
         public void OnStateExit() => targetRotation = 0;