add strategy pattern in Patterns folder

Author: ozankasikci

Patterns/StrategyPattern/Character.cs

@@ -0,0 +1,35 @@
+using UnityEngine;
+using UnityCheatSheet.Patterns.StrategyPattern.Strategies;
+
+namespace UnityCheatSheet.Patterns.StrategyPattern
+{
+    public class Character : MonoBehaviour
+    {
+        private IAttackStrategy attackStrategy;
+        public Transform target;
+
+        private void Start()
+        {
+            // Default to melee attack
+            SetAttackStrategy(new MeleeAttackStrategy());
+        }
+
+        public void SetAttackStrategy(IAttackStrategy strategy)
+        {
+            attackStrategy = strategy;
+            Debug.Log($"Changed to {strategy.GetType().Name} - Range: {strategy.GetRange()}, Damage: {strategy.GetDamage()}");
+        }
+
+        public void PerformAttack()
+        {
+            if (attackStrategy != null && target != null)
+            {
+                attackStrategy.Attack(transform, target);
+            }
+            else
+            {
+                Debug.LogWarning("Cannot attack: Missing strategy or target");
+            }
+        }
+    }
+} 

Patterns/StrategyPattern/IAttackStrategy.cs

@@ -0,0 +1,11 @@
+using UnityEngine;
+
+namespace UnityCheatSheet.Patterns.StrategyPattern
+{
+    public interface IAttackStrategy
+    {
+        void Attack(Transform attacker, Transform target);
+        float GetDamage();
+        float GetRange();
+    }
+} 

Patterns/StrategyPattern/README.md

@@ -0,0 +1,38 @@
+# Strategy Pattern Example
+
+A Unity example demonstrating the Strategy Pattern with a combat system.
+
+## Overview
+
+The Strategy Pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable. In this example, we use it to implement different attack strategies that a character can switch between during gameplay.
+
+## Implementation
+
+- [`IAttackStrategy.cs`](IAttackStrategy.cs): Base interface for all attack strategies
+- [`Character.cs`](Character.cs): Context class that uses the strategies
+- Strategies:
+  - [`MeleeAttackStrategy.cs`](Strategies/MeleeAttackStrategy.cs): Close-range attack
+  - [`RangedAttackStrategy.cs`](Strategies/RangedAttackStrategy.cs): Long-range attack
+  - [`AreaAttackStrategy.cs`](Strategies/AreaAttackStrategy.cs): Area-of-effect attack
+
+## Usage
+
+```csharp
+// Add Character component to a GameObject
+Character character = gameObject.AddComponent<Character>();
+
+// Switch between different attack strategies
+character.SetAttackStrategy(new MeleeAttackStrategy());
+character.SetAttackStrategy(new RangedAttackStrategy());
+character.SetAttackStrategy(new AreaAttackStrategy());
+
+// Perform attack with current strategy
+character.PerformAttack();
+```
+
+## Benefits
+
+- Easy to add new attack strategies
+- Switch strategies at runtime
+- Clean separation of attack algorithms
+- Encapsulated attack behavior 

Patterns/StrategyPattern/Strategies/AreaAttackStrategy.cs

@@ -0,0 +1,19 @@
+using UnityEngine;
+
+namespace UnityCheatSheet.Patterns.StrategyPattern.Strategies
+{
+    public class AreaAttackStrategy : IAttackStrategy
+    {
+        private readonly float damage = 10f;
+        private readonly float range = 5f;
+
+        public void Attack(Transform attacker, Transform target)
+        {
+            Debug.Log($"Performing area attack at {attacker.position} with radius {range}!");
+            Debug.Log($"All enemies within range take {damage} damage!");
+        }
+
+        public float GetDamage() => damage;
+        public float GetRange() => range;
+    }
+} 

Patterns/StrategyPattern/Strategies/MeleeAttackStrategy.cs

@@ -0,0 +1,25 @@
+using UnityEngine;
+
+namespace UnityCheatSheet.Patterns.StrategyPattern.Strategies
+{
+    public class MeleeAttackStrategy : IAttackStrategy
+    {
+        private readonly float damage = 20f;
+        private readonly float range = 2f;
+
+        public void Attack(Transform attacker, Transform target)
+        {
+            if (Vector3.Distance(attacker.position, target.position) <= range)
+            {
+                Debug.Log($"Performing melee attack for {damage} damage!");
+            }
+            else
+            {
+                Debug.Log("Target is too far for melee attack");
+            }
+        }
+
+        public float GetDamage() => damage;
+        public float GetRange() => range;
+    }
+} 

Patterns/StrategyPattern/Strategies/RangedAttackStrategy.cs

@@ -0,0 +1,26 @@
+using UnityEngine;
+
+namespace UnityCheatSheet.Patterns.StrategyPattern.Strategies
+{
+    public class RangedAttackStrategy : IAttackStrategy
+    {
+        private readonly float damage = 15f;
+        private readonly float range = 10f;
+
+        public void Attack(Transform attacker, Transform target)
+        {
+            if (Vector3.Distance(attacker.position, target.position) <= range)
+            {
+                Vector3 direction = (target.position - attacker.position).normalized;
+                Debug.Log($"Firing projectile in direction {direction} for {damage} damage!");
+            }
+            else
+            {
+                Debug.Log("Target is out of range for ranged attack");
+            }
+        }
+
+        public float GetDamage() => damage;
+        public float GetRange() => range;
+    }
+} 

README.md

@@ -869,77 +869,33 @@ public class StateMachine : MonoBehaviour {
 ```
 
 ### Strategy Pattern
-```csharp
-// Strategy interface
-public interface IAttackStrategy {
-    void Attack(Transform attacker, Transform target);
-}
+The Strategy Pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable. This pattern lets the algorithm vary independently from clients that use it.
 
-// Concrete strategy classes
-public class MeleeAttackStrategy : IAttackStrategy {
-    public void Attack(Transform attacker, Transform target) {
-        float meleeRange = 2f;
-        if (Vector3.Distance(attacker.position, target.position) <= meleeRange) {
-            Debug.Log("Performing melee attack!");
-            // Implement melee attack logic here
-        } else {
-            Debug.Log("Target is too far for melee attack");
-        }
-    }
-}
+> 📘 **See the detailed example: [Strategy Pattern - Combat System Example](Patterns/StrategyPattern/README.md)**  
+> A complete example showing how to implement a combat system using the Strategy Pattern.
 
-public class RangedAttackStrategy : IAttackStrategy {
-    public void Attack(Transform attacker, Transform target) {
-        Debug.Log("Performing ranged attack!");
-        // Implement ranged attack logic here, e.g., instantiate a projectile
-    }
+#### Basic Example
+```csharp
+// Strategy interface
+public interface IStrategy {
+    void Execute();
 }
 
-public class AreaOfEffectAttackStrategy : IAttackStrategy {
-    public void Attack(Transform attacker, Transform target) {
-        Debug.Log("Performing area of effect attack!");
-        // Implement AoE attack logic here, e.g., create an explosion effect
-    }
+// Example strategy implementation
+public class AttackStrategy : IStrategy {
+    public void Execute() => Debug.Log("Performing attack!");
 }
 
 // Context class that uses the strategy
 public class Character : MonoBehaviour {
-    private IAttackStrategy attackStrategy;
-    public Transform target;
+    private IStrategy strategy;
 
-    public void SetAttackStrategy(IAttackStrategy strategy) {
-        attackStrategy = strategy;
+    public void SetStrategy(IStrategy newStrategy) {
+        strategy = newStrategy;
     }
 
-    public void PerformAttack() {
-        if (attackStrategy != null && target != null) {
-            attackStrategy.Attack(transform, target);
-        }
-    }
-}
-
-// Usage example
-public class GameManager : MonoBehaviour {
-    public Character character;
-
-    private void Start() {
-        character.SetAttackStrategy(new MeleeAttackStrategy());
-    }
-
-    private void Update() {
-        if (Input.GetKeyDown(KeyCode.M)) {
-            character.SetAttackStrategy(new MeleeAttackStrategy());
-        }
-        else if (Input.GetKeyDown(KeyCode.R)) {
-            character.SetAttackStrategy(new RangedAttackStrategy());
-        }
-        else if (Input.GetKeyDown(KeyCode.A)) {
-            character.SetAttackStrategy(new AreaOfEffectAttackStrategy());
-        }
-
-        if (Input.GetKeyDown(KeyCode.Space)) {
-            character.PerformAttack();
-        }
+    public void ExecuteStrategy() {
+        strategy?.Execute();
     }
 }
 ```