Game Programming - CSCI 3213

Spring 2026 - Lecture 9

Oklahoma City University

• Understand the Visitor design pattern
• Learn when and why to use the Visitor pattern
• Implement a power-up system using Visitor pattern
• Combine Visitor pattern with Unity ScriptableObjects
• Create designer-friendly power-up configuration

Classic Examples

• Pac-Man (1980): Power Pellets - temporary invincibility
• Super Mario Bros: Mushrooms - size and durability boost
• Sonic: Shield, Speed Shoes, Invincibility
• Modern Games: Complex multi-attribute boosts

Power-Up Specifications

• Granularity: Boost multiple properties simultaneously
  • Example: "Protector" - Shield durability + Weapon strength
• Permanence: Effects stack until maximum values reached
  • No temporal expiration
  • Benefits accumulate across pickups
• Designer-Friendly: No code required to create new power-ups
• Scalable: Easy to add new boost types

Core Concept

A Visitable object permits a Visitor to operate on specific elements of its structure.

Real-World Analogy

Imagine a power-up flowing through a bike like an electric current:

• Power-up enters the bike's structure
• Visits each component (engine, shield, weapon)
• Enhances visited components
• Original bike code remains unchanged

Key Participants

// 1. Visitor Interface
public interface IVisitor
{
    void Visit(BikeShield shield);
    void Visit(BikeEngine engine);
    void Visit(BikeWeapon weapon);
}

// 2. Visitable Interface
public interface IBikeElement
{
    void Accept(IVisitor visitor);
}

• Open/Closed Principle:
  • Open for extension (new visitors)
  • Closed for modification (existing elements)
• Single Responsibility:
  • Visitable objects hold data
  • Visitor objects define behaviors
• Centralized Logic:
  • All power-up logic in one place
  • Easy to maintain and modify

• Accessibility Issues:
  • Visitors may need access to private fields
  • Requires exposing more public properties
• Structural Complexity:
  • More complex than simpler patterns (Singleton, State)
  • Requires understanding of Double Dispatch concept
• Learning Curve:
  • Considered one of the harder patterns to grasp
  • Team members need pattern familiarity

What is Double Dispatch?

A mechanism that delegates method calls to different concrete methods based on the runtime types of two objects.

Quick Test Steps:

1. Create a new Unity scene
2. Add an empty GameObject
3. Attach the ClientVisitor test script (next slide)
4. Create 3 PowerUp assets via Assets/Create/PowerUp
5. Configure each PowerUp in Inspector:
   • Shield PowerUp: healShield = true
   • Engine PowerUp: turboBoost = 25
   • Weapon PowerUp: weaponRange = 5, weaponStrength = 10
6. Drag PowerUp assets to ClientVisitor component
7. Press Play and test buttons

Creating New Power-Ups (No Code!)

1. Right-click in Project window
2. Create → PowerUp
3. Name it (e.g., "SuperBoost")
4. Select the asset in Inspector
5. Configure properties:
   • Power-Up Name: "Super Boost"
   • Description: "Massive speed and weapon upgrade"
   • Turbo Boost: 50
   • Weapon Range: 10
   • Weapon Strength: 25
6. Assign to Pickup prefab
7. Done! No programming required

Adding New Visitable Components

// 1. Create new component
public class BikeArmor : MonoBehaviour, IBikeElement
{
    public float armorRating = 0f;
    public float maxArmor = 100f;

    public void Accept(IVisitor visitor)
    {
        visitor.Visit(this);
    }
}

// 2. Add Visit method to IVisitor interface
void Visit(BikeArmor bikeArmor);

// 3. Implement in PowerUp class
public void Visit(BikeArmor bikeArmor)
{
    bikeArmor.armorRating += armorBoost;
    if (bikeArmor.armorRating > bikeArmor.maxArmor)
        bikeArmor.armorRating = bikeArmor.maxArmor;
}

Adding Duration to Power-Ups

public class PowerUp : ScriptableObject, IVisitor
{
    public float duration = 0f; // 0 = permanent

    // Store original values
    private Dictionary<IBikeElement, object> _originalValues;

    public void Visit(BikeEngine bikeEngine)
    {
        if (duration > 0)
        {
            // Store original
            _originalValues[bikeEngine] = bikeEngine.turboBoost;

            // Apply boost
            bikeEngine.turboBoost += turboBoost;

            // Schedule revert
            StartCoroutine(RevertAfterDuration(bikeEngine));
        }
    }

    IEnumerator RevertAfterDuration(BikeEngine engine)
    {
        yield return new WaitForSeconds(duration);
        engine.turboBoost = (float)_originalValues[engine];
    }
}

Note on Implementation

Good Use Cases:

• Operating on complex object structures
• Need to add operations without modifying classes
• Operations are related but conceptually separate
• Object structure rarely changes, but operations do

Avoid When:

• Object structure changes frequently (adding new types)
• Simple operations on simple structures
• Team unfamiliar with pattern complexity
• Simpler patterns (Strategy, Command) would suffice

Beyond Power-Ups:

• Damage Systems:
  • Different damage types visit different armor components
  • Fire damage, ice damage, physical damage
• Status Effects:
  • Poison, slow, stun effects visit character stats
  • Each effect has unique impact on different attributes
• Buff/Debuff Systems:
  • Temporary or permanent stat modifications
  • Stackable or unique effects
• Rendering Pipelines:
  • Shader visitors operate on mesh components
  • Post-processing effects visit render targets

Optimization Tips:

• Cache Component References:
  • Store _bikeElements list once in Start()
  • Avoid repeated GetComponent() calls
• Object Pooling for Pickups:
  • Don't Destroy() - recycle instead
  • Reduces garbage collection overhead
• Conditional Visiting:
  • Skip components if powerup doesn't affect them
  • Check flags before calling Visit()

// Example: Conditional visiting
if (powerup.turboBoost > 0)
    element.Accept(powerup); // Only visit if needed

1. Forgetting to Implement All Visit Methods:
   • IVisitor requires one method per visitable type
   • Compiler will catch this, but plan ahead
2. Not Checking Maximum Values:
   • Always clamp boosted values to maximums
   • Prevents game-breaking stat inflation
3. Tight Coupling in Visit Methods:
   • Don't access deep nested properties
   • Use public interface of visited objects
4. Overusing the Pattern:
   • Not every system needs Visitor
   • Simple direct calls may be clearer

Unit Test Scenarios:

[Test]
public void PowerUp_BoostsWeaponRange()
{
    // Arrange
    var weapon = new BikeWeapon { range = 5, maxRange = 25 };
    var powerup = CreatePowerUp(weaponRange: 10);

    // Act
    powerup.Visit(weapon);

    // Assert
    Assert.AreEqual(15, weapon.range);
}

[Test]
public void PowerUp_RespectsMaximumValues()
{
    // Arrange
    var engine = new BikeEngine { turboBoost = 180, maxTurboBoost = 200 };
    var powerup = CreatePowerUp(turboBoost: 50);

    // Act
    powerup.Visit(engine);

    // Assert - Should cap at max, not exceed
    Assert.AreEqual(200, engine.turboBoost);
}

Add Logging to Track Visits:

public void Visit(BikeWeapon bikeWeapon)
{
    Debug.Log($"[PowerUp] Visiting weapon: " +
              $"Range {bikeWeapon.range} → {bikeWeapon.range + weaponRange}");

    // Apply boost...
}

public void Accept(IVisitor visitor)
{
    Debug.Log($"[{GetType().Name}] Accepting visitor: {visitor}");
    visitor.Visit(this);
}

Visual Debugging in Unity:

• Use OnGUI() to display current stat values
• Add particle effects when power-up applied
• Color-code UI elements based on boost level

What We Learned:

• ✅ Visitor pattern allows operations on object structures without modifying them
• ✅ Perfect for power-up systems with multiple component types
• ✅ Combines well with ScriptableObjects for designer-friendly workflows
• ✅ Separates data (visitable components) from behavior (visitors)
• ✅ Follows Open/Closed and Single Responsibility principles

Key Takeaways:

• One Visit() method per visitable type
• Accept() method is the entry point
• BikeController coordinates the visiting process
• ScriptableObjects enable no-code power-up creation

Implement a "Debuff" System

Using the Visitor pattern, create a debuff system that weakens the bike:

Further Reading:

• Design Patterns (Gang of Four): Original Visitor pattern description
• Unity ScriptableObjects Documentation: Deep dive into asset-based design
• Game Programming Patterns: Game-specific pattern applications

Code Examples:

• Full implementation in course GitHub repo
• FPP project folder has complete racing game example
• Includes working pickups and visual effects

Next Lecture:

Strategy Pattern: Implementing AI behaviors for enemy drones

Thank you! 🎮