Game Programming - CSCI 3213

Spring 2026 - Lecture 10

Oklahoma City University

• Understand the Strategy design pattern
• Learn the difference between Strategy and State patterns
• Implement enemy drone behaviors using Strategy pattern
• Create runtime-swappable attack maneuvers
• Recognize when to use Strategy vs. other patterns
• Explore alternative solutions using Unity's animation system

Core Concept

Flying robotic enemies that attack the player with predictable, automated behaviors.

Characteristics:

• Weapon: Front-facing laser beam (45° angle)
• Intelligence: No AI - pure algorithmic movement
• Difficulty: Easy alone, challenging in formations
• Attack Patterns: Three distinct maneuvers

1. Bobbing Maneuver

• Rapid vertical movement (up and down)
• Continuous laser fire
• Hard to predict vertical position

2. Weaving Maneuver

• Rapid horizontal movement (side to side)
• Limited to track rail distance
• Forces player to time their pass

3. Fallback Maneuver

• Moves backward while shooting
• Can match player's bike speed
• Limited duration before stopping

Core Concept

Define a family of algorithms, encapsulate each one, and make them interchangeable at runtime.

Real-World Analogy

Think of a GPS navigation app:

• Context: Route planner
• Strategies: Fastest route, shortest distance, avoid highways
• Runtime selection: User chooses which strategy to use

Key Participants:

• Context: Uses strategy objects
  • In our case: Drone class
• Strategy Interface: Common interface for all strategies
  • In our case: IManeuverBehaviour
• Concrete Strategies: Specific implementations
  • BoppingManeuver
  • WeavingManeuver
  • FallbackManeuver

• Encapsulation:
  • Each algorithm in its own class
  • Avoid long conditional statements
  • Cleaner, more organized code
• Runtime Flexibility:
  • Swap algorithms dynamically
  • No need to restart or rebuild
  • Responsive to gameplay conditions
• Open/Closed Principle:
  • Open for extension (new strategies)
  • Closed for modification (existing code)
• Testing:
  • Test each strategy independently
  • Mock strategies for unit tests

• Client Awareness:
  • Client must know about all strategies
  • Must understand which to select
  • Increased coupling to strategy types
• Pattern Confusion:
  • Strategy and State look similar structurally
  • Team members may misunderstand intent
  • Requires clear documentation
• Class Proliferation:
  • More classes to manage
  • Can be overkill for simple cases

Use Strategy When:

• ✅ Multiple variants of same behavior needed
• ✅ Want to assign behavior at runtime
• ✅ Internal state doesn't dictate behavior changes
• ✅ Need to accomplish specific task based on runtime criteria

Use State/FSM Instead When:

• ❌ Behavior changes based on internal state
• ❌ Need state transitions and history
• ❌ Object is inherently stateful (e.g., player character)

Other Use Cases for Strategy:

• Encryption algorithms (platform-dependent)
• Pathfinding algorithms (A*, Dijkstra, etc.)
• Spell behaviors in fantasy games
• Difficulty level implementations

Imagine without Strategy Pattern:

public class Drone : MonoBehaviour
{
    public enum ManeuverType { Bopping, Weaving, Fallback }
    public ManeuverType currentManeuver;

    void Update()
    {
        if (currentManeuver == ManeuverType.Bopping)
        {
            // 50 lines of bopping code
        }
        else if (currentManeuver == ManeuverType.Weaving)
        {
            // 50 lines of weaving code
        }
        else if (currentManeuver == ManeuverType.Fallback)
        {
            // 50 lines of fallback code
        }
    }
}

Steps:

1. Create new Unity scene
2. Create empty GameObject
3. Attach ClientStrategy script
4. Add all strategy scripts to project
5. Press Play
6. Click "Spawn Drone" button
7. Observe cube executing random maneuver
8. Spawn multiple drones to see variety

Better Alternatives:

• DOTween: Powerful tween animation engine
  • Less code, better results
  • Built-in easing functions
  • Sequence chaining
  • http://dotween.demigiant.com
• Unity Animation System: For complex movements
  • Animator Controller
  • Animation Clips
  • State Machine transitions

Why we used coroutines here:

• No external dependencies
• Easy to understand and port
• Focus on pattern, not animation

Professional Approach:

Benefits:

• Better quality animations
• Smooth transitions between maneuvers
• Visual editing in Animator window
• Could switch to State pattern if needed

Use Strategy Pattern When:

• ✅ Behavior is algorithmic (pathfinding, damage calculation)
• ✅ Not purely visual/animated
• ✅ Need to combine multiple systems
• ✅ Behavior includes complex logic beyond animation

Use Unity Animator When:

• ✅ Primarily visual animation
• ✅ Need smooth transitions
• ✅ Animation created by artists
• ✅ State-based with transitions

Hybrid Approach:

// Strategy determines WHAT to do
public class SmartAttackStrategy : IManeuverBehaviour
{
    public void Maneuver(Drone drone)
    {
        // Calculate best attack based on player position
        // Then trigger appropriate animation
        drone.animator.SetTrigger("ExecuteCalculatedAttack");
    }
}

Real-World Game Applications:

• Save File Encryption:

  saveManager.SetEncryptionStrategy(
      platform == PC ? new AES256() : new SimpleXOR()
  );

• Difficulty Settings:

  enemy.SetBehaviorStrategy(
      difficulty == Hard ? new AggressiveAI() : new PassiveAI()
  );

• Pathfinding Algorithms:

  navigator.SetPathfindingStrategy(
      mapSize > 1000 ? new AStarStrategy() : new DijkstraStrategy()
  );

• Combat Systems:

  weapon.SetDamageStrategy(
      target.armor > 50 ? new ArmorPiercingDamage() : new StandardDamage()
  );

Making Simple Enemies Challenging:

Easy Extension:

// 1. Create new strategy class
public class CirclingManeuver :
    MonoBehaviour, IManeuverBehaviour
{
    public void Maneuver(Drone drone)
    {
        StartCoroutine(Circle(drone));
    }

    IEnumerator Circle(Drone drone)
    {
        float radius = 3f;
        float angle = 0f;
        Vector3 center = drone.transform.position;

        while (true)
        {
            angle += drone.speed * Time.deltaTime;
            float x = center.x + Mathf.Cos(angle) * radius;
            float z = center.z + Mathf.Sin(angle) * radius;
            drone.transform.position = new Vector3(x, center.y, z);
            yield return null;
        }
    }
}

That's it! No changes to Drone class needed.

Optimization Strategies:

• Object Pooling:
  • Don't Instantiate/Destroy drones constantly
  • Recycle drone GameObjects
  • Use Object Pool pattern (covered earlier)
• Strategy Caching:

  // Cache strategy components
  private Dictionary<Type, IManeuverBehaviour> _strategyCache;
  
  void Start()
  {
      _strategyCache = new Dictionary<Type, IManeuverBehaviour>()
      {
          { typeof(BoppingManeuver), GetComponent<BoppingManeuver>() },
          { typeof(WeavingManeuver), GetComponent<WeavingManeuver>() },
          { typeof(FallbackManeuver), GetComponent<FallbackManeuver>() }
      };
  }

• Update Optimization:
  • Use coroutines instead of Update() when possible
  • Reduces per-frame overhead

1. Forgetting to Stop Previous Coroutine:

   // BAD - old strategy still running!
   drone.ApplyStrategy(newStrategy);
   
   // GOOD - stop previous first
   StopAllCoroutines();
   drone.ApplyStrategy(newStrategy);

2. Not Handling Null Strategies:

   public void ApplyStrategy(IManeuverBehaviour strategy)
   {
       if (strategy == null)
       {
           Debug.LogError("Null strategy provided!");
           return;
       }
       strategy.Maneuver(this);
   }

3. Hardcoding Strategy References:
   • Use dependency injection or service locator
   • Don't tightly couple client to specific strategy types
4. Overusing Strategy for Simple Cases:
   • If you only have 1-2 behaviors, direct calls may be clearer

Add Logging:

public void Maneuver(Drone drone)
{
    Debug.Log($"[{GetType().Name}] Starting maneuver on {drone.name}");
    StartCoroutine(Bopple(drone));
}

public void ApplyStrategy(IManeuverBehaviour strategy)
{
    Debug.Log($"[Drone] Applying strategy: {strategy.GetType().Name}");
    strategy.Maneuver(this);
}

Visual Debugging:

• Use Gizmos to show movement paths
• Color-code drones by strategy type
• Display strategy name in UI overlay

void OnDrawGizmos()
{
    Gizmos.color = strategyType == BoppingManeuver ? Color.red : Color.blue;
    Gizmos.DrawWireSphere(transform.position, 0.5f);
}

Strategy Pattern in Production Games:

• Civilization Series:
  • AI strategies (aggressive, defensive, cultural)
  • Switched based on game state
• StarCraft II:
  • Build order strategies
  • Combat micro strategies
• Racing Games:
  • AI racing lines (aggressive vs safe)
  • Rubberbanding strategies
• RPGs:
  • Combat AI (melee, ranged, support)
  • Companion behaviors

What We Learned:

• ✅ Strategy pattern encapsulates algorithm families in separate classes
• ✅ Enables runtime behavior selection without state dependency
• ✅ Perfect for enemy drones with predictable, swappable maneuvers
• ✅ Similar to State pattern but with different intent
• ✅ Alternative: Unity Animator for pure animation cases

Key Takeaways:

• Context class uses strategies through interface
• Each strategy is independent and testable
• Easy to extend with new behaviors
• Consider Unity's native systems for animation
• Strategy pattern shines for algorithmic behaviors

Implement a Dynamic Drone Spawner

Further Reading:

• Design Patterns (GoF): Original Strategy pattern definition
• Game Programming Patterns: Game-specific strategy applications
• Unity Animator Documentation:
  • https://docs.unity3d.com/Manual/AnimationOverview.html
• DOTween: Professional animation solution
  • http://dotween.demigiant.com

Code Examples:

• Full implementation in course GitHub repo
• FPP project folder has working drone example
• Includes formation spawning and visual effects

Next Lecture:

Decorator Pattern: Implementing a weapon upgrade system

Thank you! 🎮