Game Programming - CSCI 3213

Spring 2026 - Lecture 15 (Final)

Oklahoma City University

• Understand the Service Locator design pattern
• Learn to manage global dependencies efficiently
• Implement service registration and retrieval
• Create service contracts using interfaces
• Recognize benefits and drawbacks of the pattern
• Understand when to use Service Locator vs Dependency Injection
• Integrate Unity services (Analytics, Ads, Logging)

Restaurant Waiter System

Think about dining at a restaurant:

Core Concept

Maintain a central registry of services and provide a mechanism to locate and access them globally.

The Problem It Solves

You need global access to services (logging, analytics, ads) but don't want tight coupling or complex initialization throughout your codebase.

Architecture:

┌─────────────────────────────────────┐
│          Client Code                │
│    (Requests services)              │
└──────────────┬──────────────────────┘
               │ GetService()
               ↓
┌──────────────────────────────────────┐
│      Service Locator                 │ ← Central Registry
│    (Dictionary of services)          │
└──────────────┬───────────────────────┘
               │ Returns instance
               ↓
┌──────────────────────────────────────┐
│      Service Providers               │
│  - Logger (ILoggerService)           │
│  - Analytics (IAnalyticsService)     │
│  - Ads (IAdvertisement)              │
└──────────────────────────────────────┘
                    

Flow:

1. Services register themselves on startup
2. Client requests service by interface type
3. Service Locator looks up and returns instance
4. Client uses service through interface

• Simplicity:
  • Easy to understand and implement
  • No steep learning curve
  • Quick to get started
• Decoupling:
  • Clients don't know about concrete implementations
  • Services can be swapped at runtime
  • Easy to mock for testing
• Runtime Optimization:
  • Select best implementation based on context
  • Debug vs Release builds
  • Platform-specific services
• Global Access:
  • Services accessible from anywhere
  • No need to pass dependencies through constructors

• Hidden Dependencies (Black Boxing):
  • Class dependencies not visible in constructor
  • Hard to see what a class needs
  • Runtime errors instead of compile-time errors
• Globally Dependent:
  • Can become a global dependency itself
  • Tight coupling to Service Locator
  • Hard to remove once widely used
• Testing Challenges:
  • Need to set up locator before tests
  • Test isolation harder
  • Mock registration complexity

Use Service Locator For:

• ✅ Truly global services (logging, analytics)
• ✅ Services needed everywhere in codebase
• ✅ Services that can be mocked/removed without breaking gameplay
• ✅ Cross-cutting concerns (debugging, profiling)

DON'T Use Service Locator For:

• ❌ Context-specific components (HUD, Player, Enemy)
• ❌ Services only used in certain scenes
• ❌ Dependencies that should be explicit
• ❌ Core gameplay logic

using UnityEngine;

    public class Logger : ILoggerService
    {
        public void Log(string message)
        {
            Debug.Log("Logged: " + message);
        }
}

Production Logger Could Include:

• File output to persistent data path
• Log levels (Info, Warning, Error)
• Timestamps and stack traces
• Remote logging to server
• Log rotation and size limits

// Enhanced logger example
public void Log(string message, LogLevel level = LogLevel.Info)
{
    string timestamp = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
    string logEntry = $"[{timestamp}] [{level}] {message}";

    Debug.Log(logEntry);
    WriteToFile(logEntry);

    if (level == LogLevel.Error)
        SendToAnalytics(logEntry);
}

using UnityEngine;

    public class Analytics : IAnalyticsService
    {
        public void SendEvent(string eventName)
        {
            Debug.Log("Sent: " + eventName);
        }
}

Real Analytics Integration:

public class UnityAnalytics : IAnalyticsService
{
    public void SendEvent(string eventName)
    {
        // Unity Analytics
        Unity.Analytics.Analytics.CustomEvent(eventName);
    }
}

public class GoogleAnalytics : IAnalyticsService
{
    public void SendEvent(string eventName)
    {
        // Google Analytics for Games
        FirebaseAnalytics.LogEvent(eventName);
    }
}

using UnityEngine;

    public class Advertisement : IAdvertisement
    {
        public void DisplayAd()
        {
            Debug.Log("Displaying video advertisement");
        }
}

Real Ad Integration:

using UnityEngine.Advertisements;

public class UnityAds : IAdvertisement
{
    private string gameId = "1234567";
    private string placementId = "rewardedVideo";

    public void DisplayAd()
    {
        if (Advertisement.IsReady(placementId))
        {
            Advertisement.Show(placementId);
        }
        else
        {
            Debug.LogWarning("Ad not ready");
        }
}

Steps:

1. Create new Unity scene
2. Create empty GameObject named "ServiceLocatorTest"
3. Attach ClientServiceLocator script
4. Press Play
5. Click buttons to test each service
6. Observe console output

Debug vs Release Builds:

private void RegisterServices()
{
    #if UNITY_EDITOR || DEBUG
        // Debug builds: verbose logging
        ILoggerService logger = new VerboseLogger();
    #else
        // Release builds: minimal logging
        ILoggerService logger = new MinimalLogger();
    #endif

    ServiceLocator.RegisterService(logger);

    #if UNITY_EDITOR
        // Don't send analytics during development
        IAnalyticsService analytics = new MockAnalytics();
    #else
        // Production: real analytics
        IAnalyticsService analytics = new UnityAnalytics();
    #endif

    ServiceLocator.RegisterService(analytics);
}

Add Unregister Functionality:

public static void UnregisterService<T>()
{
    if (Services.ContainsKey(typeof(T)))
    {
        Services.Remove(typeof(T));
    }
}

public static void UnregisterAllServices()
{
    Services.Clear();
}

Add Safe GetService (No Exception):

public static T TryGetService<T>() where T : class
{
    if (Services.TryGetValue(typeof(T), out object service))
    {
        return service as T;
    }
    return null;
}

// Usage
var logger = ServiceLocator.TryGetService<ILoggerService>();
if (logger != null)
{
    logger.Log("Service found!");
}

Player Actions Tracked with Services:

public class PlayerController : MonoBehaviour
{
    private ILoggerService _logger;
    private IAnalyticsService _analytics;

    void Start()
    {
        _logger = ServiceLocator.GetService<ILoggerService>();
        _analytics = ServiceLocator.GetService<IAnalyticsService>();

        _logger.Log("Player controller initialized");
        _analytics.SendEvent("player_session_start");
    }

    public void CollectCoin()
    {
        _logger.Log("Coin collected");
        _analytics.SendEvent("coin_collected");
        // ... game logic
    }

    public void Die()
    {
        _logger.Log("Player died");
        _analytics.SendEvent("player_death");

        // Show rewarded ad?
        var ads = ServiceLocator.TryGetService<IAdvertisement>();
        ads?.DisplayAd();
    }
}

What is Dependency Injection?

A technique where objects receive their dependencies from external sources rather than creating them.

// Dependencies are explicit!
public class PlayerController
{
    private readonly ILoggerService _logger;
    private readonly IAnalyticsService _analytics;

    // Constructor injection - dependencies visible
    public PlayerController(
        ILoggerService logger,
        IAnalyticsService analytics)
    {
        _logger = logger;
        _analytics = analytics;
    }

    public void Die()
    {
        _logger.Log("Player died");
        _analytics.SendEvent("player_death");
    }
}

Popular DI Frameworks:

• Extenject (Zenject):
  • Most popular Unity DI framework
  • Free on Unity Asset Store
  • Scene-based injection
  • https://github.com/modesttree/Extenject
• VContainer:
  • Fast, lightweight DI framework
  • Designed for Unity performance
  • Better than Zenject for large projects
• Microsoft.Extensions.DependencyInjection:
  • .NET standard DI container
  • Can be used in Unity
  • Good for cross-platform code

Unity Services (No Manual Implementation Needed):

• Unity Analytics:
  • Free player behavior tracking
  • Dashboard with charts and funnels
  • https://docs.unity3d.com/Manual/UnityAnalytics.html
• Unity Ads:
  • Video and banner ads
  • Rewarded ad support
  • Cross-promotion network
• Unity Cloud Save:
  • Cross-device player data
  • Cloud backup
• Unity IAP (In-App Purchases):
  • Cross-platform purchase handling
  • Receipt validation
• Unity Multiplayer Services:
  • Matchmaking, lobbies, relay

1. Using Service Locator for Everything:
   • ❌ Enemy, Player, HUD in Service Locator
   • ✅ Only truly global services
2. Not Handling Missing Services:

   // BAD - crashes if not registered
   var logger = ServiceLocator.GetService<ILoggerService>();
   
   // GOOD - handles gracefully
   var logger = ServiceLocator.TryGetService<ILoggerService>();
   logger?.Log("Message");

3. Registering Too Late:
   • Services should be registered in Awake() of first scene
   • Use DontDestroyOnLoad() for service manager
4. No Interface - Using Concrete Classes:

   // BAD - tight coupling
   ServiceLocator.RegisterService(new Logger());
   var logger = ServiceLocator.GetService<Logger>();
   
   // GOOD - loose coupling
   ServiceLocator.RegisterService<ILoggerService>(new Logger());
   var logger = ServiceLocator.GetService<ILoggerService>();

Optimization Strategies:

• Cache Service References:

  // BAD - lookup every frame
  void Update()
  {
      var logger = ServiceLocator.GetService<ILoggerService>();
      logger.Log("Frame update");
  }
  
  // GOOD - cache in Start()
  private ILoggerService _logger;
  
  void Start()
  {
      _logger = ServiceLocator.GetService<ILoggerService>();
  }
  
  void Update()
  {
      _logger.Log("Frame update");
  }

• Use Lazy Initialization for Heavy Services:

  private IAnalyticsService _analytics;
  public IAnalyticsService Analytics
  {
      get
      {
          if (_analytics == null)
              _analytics = ServiceLocator.GetService<IAnalyticsService>();
          return _analytics;
      }
  }

Add Debug Logging:

public static void RegisterService<T>(T service)
{
    string typeName = typeof(T).Name;

    if (!Services.ContainsKey(typeof(T)))
    {
        Services[typeof(T)] = service;
        Debug.Log($"[ServiceLocator] Registered: {typeName}");
    }
    else
    {
        Debug.LogError($"[ServiceLocator] Already registered: {typeName}");
        throw new ApplicationException("Service already registered");
    }
}

public static T GetService<T>()
{
    string typeName = typeof(T).Name;

    if (Services.TryGetValue(typeof(T), out object service))
    {
        Debug.Log($"[ServiceLocator] Retrieved: {typeName}");
        return (T)service;
    }

    Debug.LogError($"[ServiceLocator] Service not found: {typeName}");
    throw new ApplicationException("Requested service not found.");
}

List All Registered Services:

public static void LogAllServices()
{
    Debug.Log("=== Registered Services ===");
    foreach (var kvp in Services)
    {
        Debug.Log($"{kvp.Key.Name}: {kvp.Value.GetType().Name}");
    }
}

Creational Patterns:

• Singleton: Single global instance (GameManager)
• Object Pool: Reusable objects (bullets, enemies)

Structural Patterns:

• Adapter: Interface compatibility (inventory systems)
• Facade: Simplified interface (bike engine)
• Decorator: Dynamic behavior addition (weapon upgrades)

Behavioral Patterns:

• Observer: Event notification
• Strategy: Interchangeable algorithms (drone maneuvers)
• Visitor: Operations on object structures (power-ups)
• Command: Encapsulated requests

Architectural Patterns:

• Service Locator: Dependency management ← Today!
• Spatial Partition: Collision optimization

Patterns Work Together!

Service Locator Dos:

• ✅ Use for truly global, cross-cutting services
• ✅ Register services as early as possible
• ✅ Use interfaces for service contracts
• ✅ Cache service references in Start()
• ✅ Provide mock implementations for testing
• ✅ Handle missing services gracefully

Service Locator Don'ts:

• ❌ Don't use for scene-specific components
• ❌ Don't use for core gameplay dependencies
• ❌ Don't hide critical dependencies
• ❌ Don't register concrete classes directly
• ❌ Don't look up services every frame

General Pattern Advice:

• Understand the problem before applying a pattern
• Don't over-engineer simple solutions
• Refactor to patterns when complexity emerges
• Patterns are guidelines, not rules

Books to Read:

• Game Programming Patterns by Robert Nystrom
  • Free online: http://gameprogrammingpatterns.com
• Design Patterns by Gang of Four (GoF)
  • The original patterns bible
• Head First Design Patterns
  • Beginner-friendly with great examples
• Clean Code by Robert C. Martin
  • Writing maintainable code

Online Resources:

• https://refactoring.guru - Interactive pattern guide
• Unity Learn - Official Unity tutorials
• Catlike Coding - Advanced Unity tutorials
• GitHub - Study open-source game projects

Practice Projects:

• Implement classic games (Pac-Man, Tetris, Space Invaders)
• Contribute to open-source Unity projects
• Game jams (Ludum Dare, Global Game Jam)

Apply What You've Learned:

• Racing Game:
  • Facade: Vehicle engine system
  • Object Pool: Particle effects, tire marks
  • Service Locator: Analytics, ads
  • Strategy: AI difficulty levels
• Tower Defense:
  • Object Pool: Projectiles, enemies
  • Strategy: Different enemy behaviors
  • Decorator: Tower upgrades
  • Observer: Wave completion events
  • Spatial Partition: Enemy targeting
• RPG:
  • Adapter: Save system (cloud + local)
  • Visitor: Item effects on player
  • Command: Skill system
  • Service Locator: Quest tracking, inventory
• Puzzle Game:
  • Command: Undo/redo moves
  • Observer: Combo notifications
  • Service Locator: Leaderboards, achievements

What We Learned Today:

• ✅ Service Locator provides central registry for global services
• ✅ Simple to implement and understand
• ✅ Use for truly global services (logging, analytics, ads)
• ✅ Don't use for scene-specific or gameplay components
• ✅ Controversial pattern - some consider it anti-pattern
• ✅ Dependency Injection is more robust alternative
• ✅ Unity provides many built-in services

Course Completion:

• 🎓 15 lectures completed!
• 🎯 10+ design patterns mastered
• 🚀 Ready to build professional games
• 💪 Strong foundation in game architecture

Congratulations! 🎉

You've completed Game Programming CSCI 3213!

Thank you for an amazing semester!

Questions? Office Hours: Monday/Wednesday 2:00-4:00 PM
SSM 204A - bobby.reed@okcu.edu

🎮 Good luck with your game development journey! 🚀